DeepSeek V4.1 Flash
ff3319b842
一、纵向绘制异常/抽搐的根因 上一轮给图层加了「上下各半个网格高」的纵向预渲染余量，但"偏移超出余量"时仍走**排队整块重画** （一帧只补一个网格）：重画生效前 BlitWideBuffer 只能贴出有像素的那一部分，其余行留在底色上 = 网格内出现空白条带（"绘制错误"）；且重画后的锚点与"贴图偏移"不同源 = 波形"没按预期移动"。 鼠标按在最上方网格一路拖到窗口最下方（离开网格很远）时，每帧的幅值位移都远超余量 → 每帧触发整块 重画 = 抽搐；左右拖动时若鼠标同时有纵向位移，同样触发。 二、修法：与横向完全同构的纵向滚动 - RenderLaneLayerRegion 增加 stripY/stripH（纵向条带），可只补画"新暴露的一整条"。 - RollWideBuffer 新增纵向滚动：BitBlt 整块上/下移 roll 行 → 补画暴露的那一条 → layer.anchorYMax -= roll / pxPerValue（与横向 wideMin 同一套记账）。 必须在横向补条之前（横向补条会用当前 yMax 重置图层锚点，顺序反了细条会带上错的纵向偏移）。 - 滚动量量化（kLayerRollQuantum = 16 像素）：不足量子的偏移不滚，交给贴图的 srcY 偏移处理， 使画布映射在拖动中保持稳定、折线缓存（键含幅值映射）得以命中。 未量化时"每帧滚 1~30 行"会让折线每帧重算（实测滚动 3~4ms + 整帧 10~14ms）。 三、「弱峰调整」（原「弱峰增强」） - 术语统一：ComputeWeakPeakAdjust、WeakPeakItem.amountPercent（-200–200，默认 150）、面板标题 「弱峰调整」、标签「调整幅度 %」、光标胶囊尾缀、构建信号名「<原信号> (弱峰调整 X% M次迭代)」。 - 滑块量程 -200% – +200%，0 在正中间（ratio = (amount/200 + 1) / 2）；数值列加宽以容纳 "-200%"。 - 目标值（识别规则与旧实现完全相同；amount = 幅度/100）： * 0 ≤ a ≤ 1：当前值 → 同类极值中较温和的一侧； * 1 < a ≤ 2：该侧 → 另一侧（与旧实现逐位一致）； * -1 ≤ a < 0：当前值 → 相邻异类极值中较近的一个（波峰看较高的波谷、波谷看较低的波峰）； * -2 ≤ a < -1：较近的异类极值 → 较远的那个（弱峰被压平甚至抹除，左右平滑过渡）。 - 负幅度不得反向增强：目标夹在"不越过当前值"的一侧。平滑偏移的逐点过渡逻辑未改动。 四、验证（全部离屏，不占用鼠标/键盘/屏幕） - uitest 443/443：[X] 正幅度 0/50/100/150/200% → 峰 550/555/560/580/600（旧值逐位保持）、 谷 450/445/440/420/400；新增负幅度 -50/-100/-200% → 峰 500/450/400、谷 500/550/560； 超范围夹取、"未反向增强"（极值点）、健康峰不动；滑块中间 = 0%、拖出两端 = ±200%； 构建信号名含「弱峰调整」；[AH] 纯竖直拖拽 16 帧仅 2 次图层重画。 - panperf：拖出网格 900px + 对角平移 31 帧，被拖网格的空白行数与整幅重绘逐帧一致（64 vs 64 → 无空白条带），帧时 10~13ms，末帧差异与水平基线同量级（已知的 ≤0.5px 整数像素残差）。 - layercheck：clobbers=0/24、pan frames wrong=0/4、居中图层 vs 整幅重绘逐像素 0 差异； cursorcheck 30/30；make clean && make all 零警告。
2241 lines
66 KiB
C++
2241 lines
66 KiB
C++
#include "DataModel.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <cmath>
|
||
#include <cstdio>
|
||
#include <cstdlib>
|
||
#include <cwctype>
|
||
#include <deque>
|
||
#include <limits>
|
||
|
||
#include "Theme.hpp"
|
||
#include "Utf8Util.hpp"
|
||
|
||
namespace jdi
|
||
{
|
||
|
||
namespace
|
||
{
|
||
const double kMissing = std::numeric_limits<double>::quiet_NaN(); /**< 缺失值占位。 */
|
||
const double kDefaultLineWidth = 1.6; /**< 默认线宽。 */
|
||
|
||
/**
|
||
* @brief 判断列名是否为时间轴候选列。
|
||
* @param [IN] header 原始列名。
|
||
* @return 可能为时间轴返回 true。
|
||
*/
|
||
bool LooksLikeTimeHeader(const std::wstring& header)
|
||
{
|
||
const std::wstring text = ToLowerAscii(Trim(header));
|
||
if (text.empty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (text == L"t" || text == L"time" || text == L"timestamp" || text == L"simulation time" ||
|
||
text == L"时间" || text == L"时间轴")
|
||
{
|
||
return true;
|
||
}
|
||
return ContainsInsensitive(text, L"time") || ContainsInsensitive(text, L"时间");
|
||
}
|
||
|
||
/**
|
||
* @brief 从名称末尾的括号中提取单位（仅接受形如 mA / V / deg/s 的短标记）。
|
||
* @param [IN] text 列名（已去除首尾空白）。
|
||
* @return 单位文本，无法识别时返回空字符串。
|
||
*/
|
||
std::wstring ExtractUnit(const std::wstring& text)
|
||
{
|
||
if (text.size() < 3 || text.back() != L')')
|
||
{
|
||
return std::wstring();
|
||
}
|
||
|
||
const std::size_t open = text.rfind(L'(');
|
||
if (open == std::wstring::npos || open + 2 >= text.size())
|
||
{
|
||
return std::wstring();
|
||
}
|
||
|
||
const std::wstring inner = Trim(text.substr(open + 1, text.size() - open - 2));
|
||
if (inner.empty() || inner.size() > 10)
|
||
{
|
||
return std::wstring();
|
||
}
|
||
|
||
for (const wchar_t c : inner)
|
||
{
|
||
const bool allowed = iswalpha(c) || iswdigit(c) || c == L'%' || c == L'/' || c == L'^' ||
|
||
c == L'-' || c == L'.' || c == L'\u00B0' || c == L'\u00B5' ||
|
||
c == L'\u03A9' || c == L'\u00B2' || c == L'\u00B3' || c == L'\u00B7';
|
||
if (!allowed)
|
||
{
|
||
return std::wstring();
|
||
}
|
||
}
|
||
return inner;
|
||
}
|
||
|
||
/**
|
||
* @brief 为网格范围补充留白，避免波形紧贴边界。
|
||
* @param [IN, OUT] yMin 范围下限。
|
||
* @param [IN, OUT] yMax 范围上限。
|
||
*/
|
||
void PadRange(double& yMin, double& yMax)
|
||
{
|
||
if (!std::isfinite(yMin) || !std::isfinite(yMax))
|
||
{
|
||
yMin = 0.0;
|
||
yMax = 1.0;
|
||
return;
|
||
}
|
||
|
||
const double span = yMax - yMin;
|
||
if (span <= 0.0)
|
||
{
|
||
const double magnitude = std::max(1.0, std::fabs(yMin) * 0.1);
|
||
yMin -= magnitude;
|
||
yMax += magnitude;
|
||
return;
|
||
}
|
||
|
||
const double pad = span * 0.06;
|
||
yMin -= pad;
|
||
yMax += pad;
|
||
}
|
||
|
||
/**
|
||
* @brief 依据全部可见信号重新生成网格划分。
|
||
* @param [IN] visible 各信号的可见性（按 [文件][信号] 索引）。
|
||
* @param [IN] lanes 网格集合（原地更新）。
|
||
* @param [IN] mode 网格划分策略。
|
||
*/
|
||
void RebuildLanes(const std::vector<std::vector<bool>>& visible, std::vector<Lane>& lanes,
|
||
LaneMode mode)
|
||
{
|
||
// 随网格携带的“网格自身状态”（按信号继承）：重建网格时不能丢。
|
||
struct LaneCarry
|
||
{
|
||
bool fitYToSelection = false;
|
||
bool edgeCount = false;
|
||
double edgeValue = 0.0;
|
||
bool edgeValueValid = false;
|
||
bool edgePanelOpen = true;
|
||
double edgePanelX = -1.0;
|
||
double edgePanelY = -1.0;
|
||
bool edgeCenter = false;
|
||
std::vector<Lane::EdgeCenterItem> edgeCenterItems;
|
||
bool edgeCenterPanelOpen = true;
|
||
double edgeCenterPanelX = -1.0;
|
||
double edgeCenterPanelY = -1.0;
|
||
bool meanFilter = false;
|
||
std::vector<Lane::MeanFilterItem> meanFilterItems;
|
||
bool meanFilterPanelOpen = true;
|
||
double meanFilterPanelX = -1.0;
|
||
double meanFilterPanelY = -1.0;
|
||
bool weakPeak = false;
|
||
std::vector<Lane::WeakPeakItem> weakPeakItems;
|
||
bool weakPeakPanelOpen = true;
|
||
double weakPeakPanelX = -1.0;
|
||
double weakPeakPanelY = -1.0;
|
||
};
|
||
|
||
// 先记下每个信号原来所在网格的网格自身状态：
|
||
// 勾选可见性会重建网格，若不携带，用户刚打开的开关会被悄悄清掉。
|
||
std::vector<std::pair<SignalRef, LaneCarry>> previousCarry;
|
||
for (const Lane& lane : lanes)
|
||
{
|
||
LaneCarry carry;
|
||
carry.fitYToSelection = lane.fitYToSelection;
|
||
carry.edgeCount = lane.edgeCount;
|
||
carry.edgeValue = lane.edgeValue;
|
||
carry.edgeValueValid = lane.edgeValueValid;
|
||
carry.edgePanelOpen = lane.edgePanelOpen;
|
||
carry.edgePanelX = lane.edgePanelX;
|
||
carry.edgePanelY = lane.edgePanelY;
|
||
carry.edgeCenter = lane.edgeCenter;
|
||
carry.edgeCenterItems = lane.edgeCenterItems;
|
||
carry.edgeCenterPanelOpen = lane.edgeCenterPanelOpen;
|
||
carry.edgeCenterPanelX = lane.edgeCenterPanelX;
|
||
carry.edgeCenterPanelY = lane.edgeCenterPanelY;
|
||
carry.meanFilter = lane.meanFilter;
|
||
carry.meanFilterItems = lane.meanFilterItems;
|
||
carry.meanFilterPanelOpen = lane.meanFilterPanelOpen;
|
||
carry.meanFilterPanelX = lane.meanFilterPanelX;
|
||
carry.meanFilterPanelY = lane.meanFilterPanelY;
|
||
carry.weakPeak = lane.weakPeak;
|
||
carry.weakPeakItems = lane.weakPeakItems;
|
||
carry.weakPeakPanelOpen = lane.weakPeakPanelOpen;
|
||
carry.weakPeakPanelX = lane.weakPeakPanelX;
|
||
carry.weakPeakPanelY = lane.weakPeakPanelY;
|
||
for (const SignalRef& ref : lane.signals)
|
||
{
|
||
previousCarry.emplace_back(ref, carry);
|
||
}
|
||
}
|
||
const auto inheritedCarry = [&previousCarry](const SignalRef& ref)
|
||
{
|
||
for (const std::pair<SignalRef, LaneCarry>& entry : previousCarry)
|
||
{
|
||
if (entry.first == ref)
|
||
{
|
||
return entry.second;
|
||
}
|
||
}
|
||
return LaneCarry();
|
||
};
|
||
const auto applyCarry = [&inheritedCarry](Lane& lane, const SignalRef& ref)
|
||
{
|
||
const LaneCarry carry = inheritedCarry(ref);
|
||
lane.fitYToSelection = carry.fitYToSelection;
|
||
lane.edgeCount = carry.edgeCount;
|
||
lane.edgeValue = carry.edgeValue;
|
||
lane.edgeValueValid = carry.edgeValueValid;
|
||
lane.edgePanelOpen = carry.edgePanelOpen;
|
||
lane.edgePanelX = carry.edgePanelX;
|
||
lane.edgePanelY = carry.edgePanelY;
|
||
lane.edgeCenter = carry.edgeCenter;
|
||
lane.edgeCenterItems = carry.edgeCenterItems;
|
||
lane.edgeCenterPanelOpen = carry.edgeCenterPanelOpen;
|
||
lane.edgeCenterPanelX = carry.edgeCenterPanelX;
|
||
lane.edgeCenterPanelY = carry.edgeCenterPanelY;
|
||
lane.meanFilter = carry.meanFilter;
|
||
lane.meanFilterItems = carry.meanFilterItems;
|
||
lane.meanFilterPanelOpen = carry.meanFilterPanelOpen;
|
||
lane.meanFilterPanelX = carry.meanFilterPanelX;
|
||
lane.meanFilterPanelY = carry.meanFilterPanelY;
|
||
lane.weakPeak = carry.weakPeak;
|
||
lane.weakPeakItems = carry.weakPeakItems;
|
||
lane.weakPeakPanelOpen = carry.weakPeakPanelOpen;
|
||
lane.weakPeakPanelX = carry.weakPeakPanelX;
|
||
lane.weakPeakPanelY = carry.weakPeakPanelY;
|
||
};
|
||
|
||
// 收集全部可见信号引用。
|
||
std::vector<SignalRef> visibleRefs;
|
||
for (std::size_t fileIndex = 0; fileIndex < visible.size(); ++fileIndex)
|
||
{
|
||
for (std::size_t signalIndex = 0; signalIndex < visible[fileIndex].size(); ++signalIndex)
|
||
{
|
||
if (visible[fileIndex][signalIndex])
|
||
{
|
||
SignalRef ref;
|
||
ref.fileIndex = static_cast<int>(fileIndex);
|
||
ref.signalIndex = static_cast<int>(signalIndex);
|
||
visibleRefs.push_back(ref);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 判断某引用对应的信号是否可见（越界视为不可见）。
|
||
const auto isVisibleRef = [&visible](const SignalRef& ref)
|
||
{
|
||
if (ref.fileIndex < 0 || static_cast<std::size_t>(ref.fileIndex) >= visible.size())
|
||
{
|
||
return false;
|
||
}
|
||
const std::vector<bool>& fileVisible = visible[static_cast<std::size_t>(ref.fileIndex)];
|
||
if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
|
||
{
|
||
return false;
|
||
}
|
||
return fileVisible[static_cast<std::size_t>(ref.signalIndex)];
|
||
};
|
||
|
||
// 某信号当前所属的网格下标（-1 表示尚未分配网格）。
|
||
const auto laneIndexOf = [&lanes](const SignalRef& ref)
|
||
{
|
||
for (std::size_t index = 0; index < lanes.size(); ++index)
|
||
{
|
||
const std::vector<SignalRef>& refs = lanes[index].signals;
|
||
if (std::find(refs.begin(), refs.end(), ref) != refs.end())
|
||
{
|
||
return static_cast<int>(index);
|
||
}
|
||
}
|
||
return -1;
|
||
};
|
||
|
||
if (mode == LaneMode::PER_SIGNAL)
|
||
{
|
||
// 每条可见信号独占一个网格：网格数量严格跟随可见信号数量。
|
||
// **顺序按"原有网格位置"优先**：已经分配过网格的信号保持其相对次序，
|
||
// 新勾选（此前没有网格）的信号统一追加到最下方。
|
||
// 若直接按 visibleRefs（文件/列序）重建，新勾选的信号会按其列序
|
||
// 插到中间，位置看起来"不确定"。
|
||
std::vector<SignalRef> ordered;
|
||
ordered.reserve(visibleRefs.size());
|
||
for (const SignalRef& ref : visibleRefs)
|
||
{
|
||
if (laneIndexOf(ref) >= 0)
|
||
{
|
||
ordered.push_back(ref);
|
||
}
|
||
}
|
||
std::stable_sort(ordered.begin(), ordered.end(),
|
||
[&laneIndexOf](const SignalRef& a, const SignalRef& b)
|
||
{ return laneIndexOf(a) < laneIndexOf(b); });
|
||
for (const SignalRef& ref : visibleRefs)
|
||
{
|
||
if (laneIndexOf(ref) < 0)
|
||
{
|
||
ordered.push_back(ref);
|
||
}
|
||
}
|
||
|
||
lanes.clear();
|
||
lanes.reserve(ordered.size());
|
||
for (const SignalRef& ref : ordered)
|
||
{
|
||
Lane lane;
|
||
lane.autoRange = true;
|
||
applyCarry(lane, ref);
|
||
lane.signals.push_back(ref);
|
||
lanes.push_back(std::move(lane));
|
||
}
|
||
}
|
||
else if (mode == LaneMode::MERGED)
|
||
{
|
||
// 全部可见信号合并到同一网格；无可见信号时不保留空网格。
|
||
bool previousAutoRange = true;
|
||
double previousYMin = -1.0;
|
||
double previousYMax = 1.0;
|
||
if (lanes.size() == 1)
|
||
{
|
||
previousAutoRange = lanes[0].autoRange;
|
||
previousYMin = lanes[0].yMin;
|
||
previousYMax = lanes[0].yMax;
|
||
}
|
||
|
||
lanes.clear();
|
||
if (!visibleRefs.empty())
|
||
{
|
||
Lane lane;
|
||
lane.autoRange = previousAutoRange;
|
||
lane.yMin = previousYMin;
|
||
lane.yMax = previousYMax;
|
||
applyCarry(lane, visibleRefs.front());
|
||
lane.signals = visibleRefs;
|
||
lanes.push_back(std::move(lane));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 自定义划分：仅移除不可见信号与由此产生的空网格，保持用户排布。
|
||
for (Lane& lane : lanes)
|
||
{
|
||
std::vector<SignalRef>& refs = lane.signals;
|
||
refs.erase(std::remove_if(refs.begin(), refs.end(),
|
||
[&isVisibleRef](const SignalRef& ref)
|
||
{ return !isVisibleRef(ref); }),
|
||
refs.end());
|
||
}
|
||
|
||
lanes.erase(std::remove_if(lanes.begin(), lanes.end(),
|
||
[](const Lane& lane) { return lane.signals.empty(); }),
|
||
lanes.end());
|
||
|
||
// 未分配网格的可见信号各自独占一个新网格。
|
||
// 注意：不能把它们塞进已有的第一个网格——那会导致“拖拽合并后新勾选的信号
|
||
// 被悄悄并入合并网格”，用户看不到新增的独立泳道。
|
||
for (const SignalRef& ref : visibleRefs)
|
||
{
|
||
bool placed = false;
|
||
for (const Lane& lane : lanes)
|
||
{
|
||
if (std::find(lane.signals.begin(), lane.signals.end(), ref) != lane.signals.end())
|
||
{
|
||
placed = true;
|
||
break;
|
||
}
|
||
}
|
||
if (placed)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
Lane lane;
|
||
lane.autoRange = true;
|
||
applyCarry(lane, ref);
|
||
lane.signals.push_back(ref);
|
||
lanes.push_back(std::move(lane));
|
||
}
|
||
}
|
||
|
||
// 统一重命名，保证编号连续。
|
||
for (std::size_t index = 0; index < lanes.size(); ++index)
|
||
{
|
||
lanes[index].name = L"网格 " + std::to_wstring(index + 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
const wchar_t* DrawModeName(DrawMode mode)
|
||
{
|
||
switch (mode)
|
||
{
|
||
case DrawMode::LINE:
|
||
return L"线段";
|
||
case DrawMode::SCATTER:
|
||
return L"散点";
|
||
case DrawMode::LINE_SCATTER:
|
||
return L"点线";
|
||
default:
|
||
return L"线段";
|
||
}
|
||
}
|
||
|
||
// ============================ DataFile 构建 ============================
|
||
|
||
/**
|
||
* @brief 粗粒度包络层每个分组覆盖的采样数。
|
||
*
|
||
* 16KB 的双精度分组可覆盖 1024 个采样（内存开销 = 采样数的 1.6%），
|
||
* 但会让"每列采样数略多于分组跨度"的场景退化为逐点扫描。
|
||
* 取 256 时：额外内存约为采样数的 0.8%，最坏情况的扫描量也能压低到
|
||
* 每列 ≤256 个采样（2400 列 ≈ 0.6M 次读取，约 1ms）。
|
||
*/
|
||
const std::size_t kCoarseStride = 256;
|
||
|
||
/**
|
||
* @brief 单条信号的取值范围统计结果。
|
||
*/
|
||
struct SignalStats
|
||
{
|
||
double minValue = 0.0; /**< 有限采样值最小值。 */
|
||
double maxValue = 0.0; /**< 有限采样值最大值。 */
|
||
std::size_t finiteCount = 0; /**< 有限采样点数量。 */
|
||
};
|
||
|
||
/**
|
||
* @brief 统计一列采样的最小/最大值与有效点数量，并顺带构建粗粒度包络层。
|
||
*
|
||
* 两者在同一个循环内完成，避免为粗粒度层多扫一遍数据（大文件下那是一整趟内存遍历）。
|
||
*
|
||
* @param [IN] values 采样列。
|
||
* @param [OUT] coarseMin 粗粒度分组最小值输出。
|
||
* @param [OUT] coarseMax 粗粒度分组最大值输出。
|
||
* @return 统计结果。
|
||
*/
|
||
SignalStats ComputeStats(const std::vector<double>& values, std::vector<double>& coarseMin,
|
||
std::vector<double>& coarseMax)
|
||
{
|
||
SignalStats stats;
|
||
double low = std::numeric_limits<double>::infinity();
|
||
double high = -std::numeric_limits<double>::infinity();
|
||
|
||
const std::size_t count = values.size();
|
||
const std::size_t buckets = (count + kCoarseStride - 1) / kCoarseStride;
|
||
coarseMin.assign(buckets, std::numeric_limits<double>::infinity());
|
||
coarseMax.assign(buckets, -std::numeric_limits<double>::infinity());
|
||
|
||
std::size_t bucket = 0;
|
||
std::size_t bucketEnd = kCoarseStride;
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
if (index >= bucketEnd)
|
||
{
|
||
++bucket;
|
||
bucketEnd += kCoarseStride;
|
||
}
|
||
const double value = values[index];
|
||
if (std::isfinite(value))
|
||
{
|
||
++stats.finiteCount;
|
||
low = std::min(low, value);
|
||
high = std::max(high, value);
|
||
if (value < coarseMin[bucket])
|
||
{
|
||
coarseMin[bucket] = value;
|
||
}
|
||
if (value > coarseMax[bucket])
|
||
{
|
||
coarseMax[bucket] = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (stats.finiteCount == 0)
|
||
{
|
||
stats.minValue = 0.0;
|
||
stats.maxValue = 0.0;
|
||
}
|
||
else
|
||
{
|
||
stats.minValue = low;
|
||
stats.maxValue = high;
|
||
}
|
||
return stats;
|
||
}
|
||
|
||
bool BuildDataFile(CsvTable&& table, const std::wstring& filePath, std::size_t paletteBase, DataFile& file,
|
||
std::wstring& error, const CsvProgress& progress)
|
||
{
|
||
error.clear();
|
||
file = DataFile();
|
||
|
||
if (!table.HasData())
|
||
{
|
||
error = L"数据表为空。";
|
||
return false;
|
||
}
|
||
|
||
const std::size_t columnCount = table.headers.size();
|
||
if (table.columns.size() < columnCount)
|
||
{
|
||
error = L"数据表列结构不完整。";
|
||
return false;
|
||
}
|
||
|
||
// 1. 识别时间轴列：优先取列名匹配的列，否则回退到第一列。
|
||
int timeColumn = -1;
|
||
for (std::size_t column = 0; column < columnCount; ++column)
|
||
{
|
||
if (LooksLikeTimeHeader(table.headers[column]))
|
||
{
|
||
timeColumn = static_cast<int>(column);
|
||
break;
|
||
}
|
||
}
|
||
if (timeColumn < 0)
|
||
{
|
||
timeColumn = 0;
|
||
}
|
||
|
||
// 时间列整列移动，不做逐元素拷贝。
|
||
file.time = std::move(table.columns[static_cast<std::size_t>(timeColumn)]);
|
||
|
||
std::size_t finiteTimeCount = 0;
|
||
bool monotonic = true;
|
||
double previousTime = 0.0;
|
||
bool hasPrevious = false;
|
||
for (const double value : file.time)
|
||
{
|
||
if (std::isfinite(value))
|
||
{
|
||
++finiteTimeCount;
|
||
if (hasPrevious && value < previousTime)
|
||
{
|
||
monotonic = false;
|
||
}
|
||
previousTime = value;
|
||
hasPrevious = true;
|
||
}
|
||
}
|
||
|
||
if (finiteTimeCount < 2)
|
||
{
|
||
error = L"时间轴列（" + table.headers[static_cast<std::size_t>(timeColumn)] + L"）有效数值不足。";
|
||
return false;
|
||
}
|
||
|
||
file.timeColumnName = table.headers[static_cast<std::size_t>(timeColumn)];
|
||
file.timeMonotonic = monotonic;
|
||
file.filePath = filePath;
|
||
|
||
const std::size_t slashPos = filePath.find_last_of(L"\\/");
|
||
file.fileName = (slashPos == std::wstring::npos) ? filePath : filePath.substr(slashPos + 1);
|
||
|
||
// 2. 构建信号列：每列整块移动，随后就地统计取值范围。
|
||
int paletteCount = 0;
|
||
const std::uint32_t* palette = SignalPalette(paletteCount);
|
||
file.signals.reserve(columnCount);
|
||
for (std::size_t column = 0; column < columnCount; ++column)
|
||
{
|
||
if (static_cast<int>(column) == timeColumn)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
SignalData signal;
|
||
signal.rawHeader = table.headers[column];
|
||
{
|
||
// 名称完整保留文件内的列名（含 "[n]" 序号与括号描述），仅用于展示不做改写。
|
||
signal.name = Trim(signal.rawHeader);
|
||
signal.unit = ExtractUnit(signal.name);
|
||
}
|
||
|
||
signal.values = std::move(table.columns[column]);
|
||
const SignalStats stats = ComputeStats(signal.values, signal.coarseMin, signal.coarseMax);
|
||
signal.coarseStride = kCoarseStride;
|
||
signal.minValue = stats.minValue;
|
||
signal.maxValue = stats.maxValue;
|
||
signal.finiteCount = stats.finiteCount;
|
||
|
||
// 显示外观随信号一起初始化：调色板按「全局信号序号」取色，
|
||
// 使同一信号在任意标签页中都保持同一默认颜色。
|
||
{
|
||
const std::size_t globalIndex = paletteBase + file.signals.size();
|
||
if (palette != nullptr && paletteCount > 0)
|
||
{
|
||
const std::size_t count = static_cast<std::size_t>(paletteCount);
|
||
const std::size_t slot = globalIndex % count;
|
||
signal.style.color = palette[slot];
|
||
// 自定义色初值取调色板中「向后递进」的下一个颜色。
|
||
// 若初值等于本信号自身的预设色，样式区里点击该预设色块会被判定成
|
||
// “当前用的是自定义色”，高亮会直接跳到自定义色块上（此前的缺陷）。
|
||
signal.style.customColor = palette[(slot + 1) % count];
|
||
}
|
||
else
|
||
{
|
||
signal.style.color = 0xFF268BD2u;
|
||
signal.style.customColor = 0xFF859900u;
|
||
}
|
||
signal.style.opacity = 1.0f;
|
||
signal.style.lineWidth = 1.0f;
|
||
signal.style.mode = DrawMode::LINE;
|
||
}
|
||
|
||
file.signals.push_back(std::move(signal));
|
||
|
||
if (progress)
|
||
{
|
||
CsvProgressInfo info;
|
||
info.ratio = 0.75 + 0.25 * static_cast<double>(column + 1) / static_cast<double>(columnCount);
|
||
if (!progress(info))
|
||
{
|
||
error = L"已取消加载。";
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (file.signals.empty())
|
||
{
|
||
error = L"除时间轴外未发现任何数据列。";
|
||
return false;
|
||
}
|
||
|
||
// 3. 统计时间范围（时间列为空或全部无效时回退到行数上界）。
|
||
double tMin = std::numeric_limits<double>::infinity();
|
||
double tMax = -std::numeric_limits<double>::infinity();
|
||
for (const double value : file.time)
|
||
{
|
||
if (std::isfinite(value))
|
||
{
|
||
tMin = std::min(tMin, value);
|
||
tMax = std::max(tMax, value);
|
||
}
|
||
}
|
||
file.minTime = tMin;
|
||
file.maxTime = tMax;
|
||
return true;
|
||
}
|
||
|
||
// ============================ DataSet ============================
|
||
|
||
bool DataSet::AddDataFile(DataFile&& file, int& fileIndex)
|
||
{
|
||
fileIndex = -1;
|
||
if (file.signals.empty())
|
||
{
|
||
return false;
|
||
}
|
||
m_files.push_back(std::move(file));
|
||
fileIndex = static_cast<int>(m_files.size()) - 1;
|
||
return true;
|
||
}
|
||
|
||
bool DataSet::InsertDerivedSignal(int fileIndex, int afterSignalIndex, SignalData&& signal,
|
||
int& newSignalIndex)
|
||
{
|
||
newSignalIndex = -1;
|
||
if (fileIndex < 0 || fileIndex >= static_cast<int>(m_files.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
DataFile& file = m_files[static_cast<std::size_t>(fileIndex)];
|
||
if (afterSignalIndex < -1 || afterSignalIndex >= static_cast<int>(file.signals.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 1. 采样值统计与粗粒度包络层：与正常加载路径使用同一套统计逻辑，
|
||
// 否则派生信号在大文件下会退化成逐点扫描（包络构建变慢）。
|
||
const SignalStats stats = ComputeStats(signal.values, signal.coarseMin, signal.coarseMax);
|
||
signal.coarseStride = kCoarseStride;
|
||
signal.minValue = stats.minValue;
|
||
signal.maxValue = stats.maxValue;
|
||
signal.finiteCount = stats.finiteCount;
|
||
|
||
// 2. 显示外观按「全局信号序号」取调色板颜色（与普通新信号完全一致的规则）。
|
||
const int insertPos = afterSignalIndex + 1;
|
||
{
|
||
// 新信号的全局序号 = 本文件之前的信号总数 + 它在文件内的下标。
|
||
std::size_t globalIndex = static_cast<std::size_t>(insertPos);
|
||
for (int index = 0; index < fileIndex; ++index)
|
||
{
|
||
globalIndex += m_files[static_cast<std::size_t>(index)].signals.size();
|
||
}
|
||
|
||
int paletteCount = 0;
|
||
const std::uint32_t* palette = SignalPalette(paletteCount);
|
||
if (palette != nullptr && paletteCount > 0)
|
||
{
|
||
const std::size_t count = static_cast<std::size_t>(paletteCount);
|
||
const std::size_t slot = globalIndex % count;
|
||
signal.style.color = palette[slot];
|
||
signal.style.customColor = palette[(slot + 1) % count];
|
||
}
|
||
}
|
||
|
||
file.signals.insert(file.signals.begin() + insertPos, std::move(signal));
|
||
|
||
// 3. 全局选中引用：同一文件内位于插入点之后的信号下标整体后移。
|
||
if (m_selected.fileIndex == fileIndex && m_selected.signalIndex >= insertPos)
|
||
{
|
||
++m_selected.signalIndex;
|
||
}
|
||
|
||
newSignalIndex = insertPos;
|
||
return true;
|
||
}
|
||
|
||
bool DataSet::RemoveFile(int fileIndex)
|
||
{
|
||
if (fileIndex < 0 || fileIndex >= static_cast<int>(m_files.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 用移动到末位后弹出的方式移除，使被移除文件的时间轴与全部信号缓冲区在本调用内
|
||
// 立即析构归还操作系统，不再等待后续插入覆盖；最后收缩容量，避免残留空闲块。
|
||
const std::size_t position = static_cast<std::size_t>(fileIndex);
|
||
for (std::size_t index = position; index + 1 < m_files.size(); ++index)
|
||
{
|
||
m_files[index] = std::move(m_files[index + 1]);
|
||
}
|
||
m_files.pop_back();
|
||
m_files.shrink_to_fit();
|
||
return true;
|
||
}
|
||
|
||
bool DataSet::RemoveSignal(int fileIndex, int signalIndex)
|
||
{
|
||
if (fileIndex < 0 || fileIndex >= static_cast<int>(m_files.size()))
|
||
{
|
||
return false;
|
||
}
|
||
DataFile& file = m_files[static_cast<std::size_t>(fileIndex)];
|
||
if (signalIndex < 0 || signalIndex >= static_cast<int>(file.signals.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 与 RemoveFile 同一思路：先把待移除项移到末位（move 赋值时其原有缓冲当场析构），
|
||
// 再 pop_back + shrink_to_fit，使该信号的全部采样内存在本调用内立即归还给系统，
|
||
// 而不是留在容量里等后续插入覆盖。
|
||
std::vector<SignalData>& signals = file.signals;
|
||
const std::size_t position = static_cast<std::size_t>(signalIndex);
|
||
for (std::size_t index = position; index + 1 < signals.size(); ++index)
|
||
{
|
||
signals[index] = std::move(signals[index + 1]);
|
||
}
|
||
signals.pop_back();
|
||
signals.shrink_to_fit();
|
||
return true;
|
||
}
|
||
|
||
void DataSet::RemapSelectionAfterSignalRemoval(int fileIndex, int signalIndex)
|
||
{
|
||
if (fileIndex < 0 || signalIndex < 0 || m_selected.fileIndex != fileIndex)
|
||
{
|
||
return;
|
||
}
|
||
if (m_selected.signalIndex == signalIndex)
|
||
{
|
||
// 选中的信号本身被移除：取消选中。
|
||
m_selected = SignalRef();
|
||
}
|
||
else if (m_selected.signalIndex > signalIndex)
|
||
{
|
||
// 其后信号整体前移一位。
|
||
--m_selected.signalIndex;
|
||
}
|
||
}
|
||
|
||
std::size_t DataSet::SignalCount() const
|
||
{
|
||
std::size_t count = 0;
|
||
for (const DataFile& file : m_files)
|
||
{
|
||
count += file.signals.size();
|
||
}
|
||
return count;
|
||
}
|
||
|
||
const DataFile* DataSet::FileAt(int fileIndex) const
|
||
{
|
||
if (fileIndex < 0 || fileIndex >= static_cast<int>(m_files.size()))
|
||
{
|
||
return nullptr;
|
||
}
|
||
return &m_files[static_cast<std::size_t>(fileIndex)];
|
||
}
|
||
|
||
bool DataSet::SetSignalDisplayName(int fileIndex, int signalIndex, const std::wstring& name)
|
||
{
|
||
if (fileIndex < 0 || fileIndex >= static_cast<int>(m_files.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
DataFile& file = m_files[static_cast<std::size_t>(fileIndex)];
|
||
if (signalIndex < 0 || signalIndex >= static_cast<int>(file.signals.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 统一去除首尾空白；结果为空则视为恢复原始列名。
|
||
std::wstring trimmed = Trim(name);
|
||
SignalData& signal = file.signals[static_cast<std::size_t>(signalIndex)];
|
||
if (trimmed == signal.displayName)
|
||
{
|
||
return false;
|
||
}
|
||
signal.displayName = std::move(trimmed);
|
||
return true;
|
||
}
|
||
|
||
bool DataSet::SetFileDisplayName(int fileIndex, const std::wstring& name)
|
||
{
|
||
if (fileIndex < 0 || fileIndex >= static_cast<int>(m_files.size()))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
std::wstring trimmed = Trim(name);
|
||
DataFile& file = m_files[static_cast<std::size_t>(fileIndex)];
|
||
if (trimmed == file.displayName)
|
||
{
|
||
return false;
|
||
}
|
||
file.displayName = std::move(trimmed);
|
||
return true;
|
||
}
|
||
|
||
const SignalData* DataSet::Resolve(const SignalRef& ref) const
|
||
{
|
||
const DataFile* file = FileAt(ref.fileIndex);
|
||
if (file == nullptr)
|
||
{
|
||
return nullptr;
|
||
}
|
||
if (ref.signalIndex < 0 || ref.signalIndex >= static_cast<int>(file->signals.size()))
|
||
{
|
||
return nullptr;
|
||
}
|
||
return &file->signals[static_cast<std::size_t>(ref.signalIndex)];
|
||
}
|
||
|
||
const SignalStyle* DataSet::Style(const SignalRef& ref) const
|
||
{
|
||
const SignalData* signal = Resolve(ref);
|
||
return (signal != nullptr) ? &signal->style : nullptr;
|
||
}
|
||
|
||
SignalStyle* DataSet::Style(const SignalRef& ref)
|
||
{
|
||
const DataFile* file = FileAt(ref.fileIndex);
|
||
if (file == nullptr)
|
||
{
|
||
return nullptr;
|
||
}
|
||
if (ref.signalIndex < 0 || ref.signalIndex >= static_cast<int>(file->signals.size()))
|
||
{
|
||
return nullptr;
|
||
}
|
||
|
||
// 这里需要写入，因此借助非 const 路径重新定位信号。
|
||
DataFile& mutableFile = m_files[static_cast<std::size_t>(ref.fileIndex)];
|
||
return &mutableFile.signals[static_cast<std::size_t>(ref.signalIndex)].style;
|
||
}
|
||
|
||
double DataSet::MinTime() const
|
||
{
|
||
double value = std::numeric_limits<double>::infinity();
|
||
for (const DataFile& file : m_files)
|
||
{
|
||
if (std::isfinite(file.minTime))
|
||
{
|
||
value = std::min(value, file.minTime);
|
||
}
|
||
}
|
||
return std::isfinite(value) ? value : 0.0;
|
||
}
|
||
|
||
double DataSet::MaxTime() const
|
||
{
|
||
double value = -std::numeric_limits<double>::infinity();
|
||
for (const DataFile& file : m_files)
|
||
{
|
||
if (std::isfinite(file.maxTime))
|
||
{
|
||
value = std::max(value, file.maxTime);
|
||
}
|
||
}
|
||
return std::isfinite(value) ? value : 1.0;
|
||
}
|
||
|
||
void DataSet::RemapSelectionAfterFileRemoval(int fileIndex)
|
||
{
|
||
if (fileIndex < 0)
|
||
{
|
||
return;
|
||
}
|
||
if (m_selected.fileIndex == fileIndex)
|
||
{
|
||
m_selected = SignalRef();
|
||
}
|
||
else if (m_selected.fileIndex > fileIndex)
|
||
{
|
||
--m_selected.fileIndex;
|
||
}
|
||
}
|
||
|
||
bool DataSet::ValidateSelection()
|
||
{
|
||
if (!m_selected.IsValid())
|
||
{
|
||
return false;
|
||
}
|
||
if (Resolve(m_selected) != nullptr)
|
||
{
|
||
return false;
|
||
}
|
||
m_selected = SignalRef();
|
||
return true;
|
||
}
|
||
|
||
// ============================ 采样辅助 ============================
|
||
|
||
namespace
|
||
{
|
||
/**
|
||
* @brief 滑动平均的共用实现（输入只要可转成 double）。
|
||
*
|
||
* 窗口 = [max(0,i-N), min(count-1,i+N)]，每前进一步只增减边界处的两个采样点，
|
||
* 整体 O(n)，不额外占用前缀和内存。
|
||
*/
|
||
template <typename T>
|
||
void MovingAverageImpl(const std::vector<T>& values, int radius, std::vector<float>& out);
|
||
} // namespace
|
||
|
||
void ComputeMovingAverage(const std::vector<double>& values, int radius, std::vector<float>& out)
|
||
{
|
||
MovingAverageImpl(values, radius, out);
|
||
}
|
||
|
||
namespace
|
||
{
|
||
template <typename T>
|
||
void MovingAverageImpl(const std::vector<T>& values, int radius, std::vector<float>& out)
|
||
{
|
||
const int window = std::max(0, radius);
|
||
const std::size_t count = values.size();
|
||
out.assign(count, std::numeric_limits<float>::quiet_NaN());
|
||
if (count == 0 || window == 0)
|
||
{
|
||
// 半径 0 表示不平滑：原样复制（中心点无效处仍为 NaN）。
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
const double value = static_cast<double>(values[index]);
|
||
if (std::isfinite(value))
|
||
{
|
||
out[index] = static_cast<float>(value);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 滑动窗口求和：每前进一步只增减边界处的两个采样点，整体 O(n)。
|
||
double sum = 0.0;
|
||
std::size_t finiteCount = 0;
|
||
std::size_t windowLow = 0;
|
||
std::size_t windowHigh = 0; // 闭区间右端。
|
||
|
||
const auto addValue = [&sum, &finiteCount](double value)
|
||
{
|
||
if (std::isfinite(value))
|
||
{
|
||
sum += value;
|
||
++finiteCount;
|
||
}
|
||
};
|
||
const auto removeValue = [&sum, &finiteCount](double value)
|
||
{
|
||
if (std::isfinite(value))
|
||
{
|
||
sum -= value;
|
||
--finiteCount;
|
||
}
|
||
};
|
||
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
const std::size_t low = (index > static_cast<std::size_t>(window))
|
||
? (index - static_cast<std::size_t>(window))
|
||
: 0;
|
||
const std::size_t high =
|
||
std::min(count - 1, index + static_cast<std::size_t>(window));
|
||
|
||
if (index == 0)
|
||
{
|
||
windowLow = low;
|
||
windowHigh = high;
|
||
for (std::size_t i = windowLow; i <= windowHigh; ++i)
|
||
{
|
||
addValue(static_cast<double>(values[i]));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
while (windowLow < low)
|
||
{
|
||
removeValue(static_cast<double>(values[windowLow]));
|
||
++windowLow;
|
||
}
|
||
while (windowHigh < high)
|
||
{
|
||
++windowHigh;
|
||
addValue(static_cast<double>(values[windowHigh]));
|
||
}
|
||
}
|
||
|
||
// 中心点本身无效（NaN）时该处不产生有效结果。
|
||
const double center = static_cast<double>(values[index]);
|
||
if (finiteCount > 0 && std::isfinite(center))
|
||
{
|
||
out[index] = static_cast<float>(sum / static_cast<double>(finiteCount));
|
||
}
|
||
}
|
||
}
|
||
} // namespace
|
||
|
||
void ComputeMovingAverageIterated(const std::vector<double>& values, int radius, int iterations,
|
||
std::vector<float>& out)
|
||
{
|
||
const int stages = std::max(1, iterations);
|
||
// 第 1 阶：从原始采样值出发。
|
||
ComputeMovingAverage(values, radius, out);
|
||
if (stages == 1)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 后续各阶以上一阶的结果为输入（double 中转，避免 float→double 的精度损失累积）。
|
||
// 中转缓冲复用容量（线程本地），避免每阶重新分配上千万元素的向量。
|
||
thread_local std::vector<double> bufferBuffer;
|
||
std::vector<double>& buffer = bufferBuffer;
|
||
buffer.assign(values.size(), std::numeric_limits<double>::quiet_NaN());
|
||
std::vector<float> stage;
|
||
for (int iteration = 1; iteration < stages; ++iteration)
|
||
{
|
||
for (std::size_t index = 0; index < out.size(); ++index)
|
||
{
|
||
buffer[index] = std::isfinite(out[index]) ? static_cast<double>(out[index])
|
||
: std::numeric_limits<double>::quiet_NaN();
|
||
}
|
||
ComputeMovingAverage(buffer, radius, stage);
|
||
out.swap(stage);
|
||
}
|
||
}
|
||
|
||
namespace
|
||
{
|
||
/**
|
||
* @brief 「弱峰调整」内部使用的极值点（波峰 / 波谷）。
|
||
*/
|
||
struct PeakExtremum
|
||
{
|
||
std::size_t index = 0; /**< 采样下标。 */
|
||
double value = 0.0; /**< 采样值。 */
|
||
int type = 0; /**< +1 = 波峰，-1 = 波谷。 */
|
||
};
|
||
|
||
/**
|
||
* @brief 「弱峰调整」的单阶处理：把偏弱的波峰上拉 / 偏弱的波谷下拉，
|
||
* 或（负幅度）把弱峰本身削弱、压平。
|
||
*
|
||
* **不做任何前置滤波**（需要平滑时用户可以先用「均值滤波」构建一条滤波后的信号）：
|
||
* 极值点直接在输入采样上通过单调段的方向翻转识别。
|
||
*
|
||
* @param [IN] input 本阶的输入采样值。
|
||
* @param [IN] amount 调整幅度（-2 – +2，已夹取；0 = 完全不动）。
|
||
* @param [OUT] output 本阶的输出（长度与 input 相同；原值为 NaN 处保持 NaN）。
|
||
* @return 确实有采样点被改动返回 true；完全无弱峰时返回 false。
|
||
*/
|
||
bool ApplyWeakPeakStage(const std::vector<float>& input, double amount,
|
||
std::vector<float>& output, std::vector<PeakExtremum>& extremes)
|
||
{
|
||
const std::size_t count = input.size();
|
||
output.assign(count, std::numeric_limits<float>::quiet_NaN());
|
||
if (count == 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 先把有效采样原样拷入输出，之后按“极值点之间的平滑偏移”逐点叠加。
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
const float value = input[index];
|
||
if (std::isfinite(value))
|
||
{
|
||
output[index] = value;
|
||
}
|
||
}
|
||
|
||
// 1) 识别波峰 / 波谷：扫描单调段，方向翻转处的上一个采样点即为极值点。
|
||
// 波峰（先升后降）与波谷（先降后升）必然交替出现，
|
||
// 因此同类极值就是极值序列里下标 ±2 的两个。
|
||
extremes.clear();
|
||
{
|
||
int direction = 0; // 当前单调段方向（+1 上升、-1 下降）。
|
||
bool hasPrevious = false;
|
||
std::size_t previousIndex = 0;
|
||
double previousValue = 0.0;
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
const double value = static_cast<double>(input[index]);
|
||
if (!std::isfinite(value))
|
||
{
|
||
// 无效采样作为断点：不跨越它判定极值。
|
||
hasPrevious = false;
|
||
continue;
|
||
}
|
||
if (!hasPrevious)
|
||
{
|
||
hasPrevious = true;
|
||
previousIndex = index;
|
||
previousValue = value;
|
||
continue;
|
||
}
|
||
const int step = (value > previousValue) ? 1 : ((value < previousValue) ? -1 : 0);
|
||
if (step != 0)
|
||
{
|
||
if (direction == 0)
|
||
{
|
||
direction = step;
|
||
}
|
||
else if (step != direction)
|
||
{
|
||
// 方向在此翻转：上一个采样点就是极值（原方向向上则为波峰）。
|
||
PeakExtremum extreme;
|
||
extreme.index = previousIndex;
|
||
extreme.value = previousValue;
|
||
extreme.type = direction;
|
||
extremes.push_back(extreme);
|
||
direction = step;
|
||
}
|
||
}
|
||
previousIndex = index;
|
||
previousValue = value;
|
||
}
|
||
}
|
||
|
||
// 识别不到足够多的极值（常量 / 单调 / 采样点太少）：本阶无需任何改动。
|
||
if (extremes.size() < 5)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 2) 逐个极值点判定“是否偏弱”，并算出它自己的目标偏移量。
|
||
const std::size_t extremeCount = extremes.size();
|
||
thread_local std::vector<double> shiftBuffer;
|
||
std::vector<double>& shift = shiftBuffer;
|
||
shift.assign(extremeCount, 0.0);
|
||
for (std::size_t k = 2; k + 2 < extremeCount; ++k)
|
||
{
|
||
const PeakExtremum& current = extremes[k];
|
||
const PeakExtremum& left = extremes[k - 2];
|
||
const PeakExtremum& right = extremes[k + 2];
|
||
if (left.type != current.type || right.type != current.type)
|
||
{
|
||
continue;
|
||
}
|
||
if (!std::isfinite(current.value) || !std::isfinite(left.value) ||
|
||
!std::isfinite(right.value))
|
||
{
|
||
continue;
|
||
}
|
||
const double mean = (left.value + right.value) * 0.5;
|
||
const double lower = std::min(left.value, right.value);
|
||
const double upper = std::max(left.value, right.value);
|
||
if (!(current.type > 0 ? (current.value < mean) : (current.value > mean)))
|
||
{
|
||
// 不是弱峰：本极值点不动。
|
||
continue;
|
||
}
|
||
double destination = current.value;
|
||
if (amount >= 0.0)
|
||
{
|
||
// ---- 正幅度（增强，与旧实现逐位一致）----
|
||
// 目标值分段插值（`amount` = 幅度 0–2）：
|
||
// 0 ≤ a ≤ 1：当前值 ↔ 较温和的一侧（波峰取较低的波峰 lower、波谷取较高的波谷 upper）；
|
||
// 1 < a ≤ 2：该侧 ↔ 另一侧（与原先 0–100% 的语义一致）。
|
||
// 两段在 a = 1 处连续，因此 a = 0 完全不动、a = 2 完全拉平。
|
||
// ⚠️ 波峰从 `lower` **向上**走到 `upper`、波谷从 `upper` **向下**走到 `lower`，
|
||
// 两者方向相反（符号不能写成一样）。
|
||
if (current.type > 0)
|
||
{
|
||
destination = (amount <= 1.0)
|
||
? (current.value + amount * (lower - current.value))
|
||
: (lower + (amount - 1.0) * (upper - lower));
|
||
}
|
||
else
|
||
{
|
||
destination = (amount <= 1.0)
|
||
? (current.value + amount * (upper - current.value))
|
||
: (upper - (amount - 1.0) * (upper - lower));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// ---- 负幅度（削弱）----
|
||
// 参照物改为相邻的**异类**极值（波峰看相邻波谷、波谷看相邻波峰），
|
||
// 并且"较近的那个"对波峰是较高的波谷、对波谷是较低的波峰。
|
||
const PeakExtremum& nearLeft = extremes[k - 1];
|
||
const PeakExtremum& nearRight = extremes[k + 1];
|
||
if (nearLeft.type == current.type || nearRight.type == current.type)
|
||
{
|
||
continue; // 极值序列本应交替；异常时不动这一点
|
||
}
|
||
if (!std::isfinite(nearLeft.value) || !std::isfinite(nearRight.value))
|
||
{
|
||
continue;
|
||
}
|
||
const double nearValue = (current.type > 0) ? std::max(nearLeft.value, nearRight.value)
|
||
: std::min(nearLeft.value, nearRight.value);
|
||
const double farValue = (current.type > 0) ? std::min(nearLeft.value, nearRight.value)
|
||
: std::max(nearLeft.value, nearRight.value);
|
||
const double magnitude = std::min(2.0, -amount);
|
||
destination = (magnitude <= 1.0)
|
||
? (current.value + magnitude * (nearValue - current.value))
|
||
: (nearValue + (magnitude - 1.0) * (farValue - nearValue));
|
||
// ⚠️ 削弱**不得反向增强**：相邻异类极值落在"错误的一侧"时（例如噪声导致的
|
||
// 波峰反而低于相邻波谷），把目标夹回当前值所在的一侧。
|
||
if (current.type > 0)
|
||
{
|
||
destination = std::min(destination, current.value);
|
||
}
|
||
else
|
||
{
|
||
destination = std::max(destination, current.value);
|
||
}
|
||
}
|
||
shift[k] = destination - current.value;
|
||
}
|
||
|
||
// 3) 把偏移量平滑地摊到极值点之间的数据点上：
|
||
// 相邻两个极值点之间用平滑步进过渡（两端导数为 0，波形不会出现折角），
|
||
// 数据首尾则从 0 渐变到最近的极值点偏移。
|
||
// 注意：极值序列的首尾各两个元素的偏移量恒为 0（缺少同类的左右邻居），
|
||
// 因此这里只需要填充 shift 非零的区间。
|
||
bool changed = false;
|
||
const auto applySpan = [&input, &output, count](std::size_t begin, std::size_t end,
|
||
double beginShift, double endShift)
|
||
{
|
||
if (end <= begin)
|
||
{
|
||
if (begin < count && std::isfinite(input[begin]))
|
||
{
|
||
output[begin] = static_cast<float>(input[begin] + beginShift);
|
||
}
|
||
return;
|
||
}
|
||
const double span = static_cast<double>(end - begin);
|
||
for (std::size_t index = begin; index <= end; ++index)
|
||
{
|
||
const float value = input[index];
|
||
if (!std::isfinite(value))
|
||
{
|
||
continue;
|
||
}
|
||
const double t = static_cast<double>(index - begin) / span;
|
||
const double weight = t * t * (3.0 - 2.0 * t);
|
||
output[index] = static_cast<float>(value + beginShift * (1.0 - weight) +
|
||
endShift * weight);
|
||
}
|
||
};
|
||
|
||
for (std::size_t k = 0; k + 1 < extremeCount; ++k)
|
||
{
|
||
if (shift[k] == 0.0 && shift[k + 1] == 0.0)
|
||
{
|
||
continue;
|
||
}
|
||
applySpan(extremes[k].index, extremes[k + 1].index, shift[k], shift[k + 1]);
|
||
changed = true;
|
||
}
|
||
return changed;
|
||
}
|
||
} // namespace
|
||
|
||
void ComputeWeakPeakAdjust(const std::vector<double>& values, double amount, int iterations,
|
||
std::vector<float>& out)
|
||
{
|
||
const std::size_t count = values.size();
|
||
out.assign(count, std::numeric_limits<float>::quiet_NaN());
|
||
if (count == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 第 1 阶：从原始采样值出发（非有限值保持 NaN）。
|
||
// 工作缓冲用线程本地变量复用容量：单条曲线动辄上千万采样，若每次调用都重新分配
|
||
// 并零初始化，单条「弱峰调整」的耗时会被明显放大（内存分配 + page fault）。
|
||
thread_local std::vector<float> currentBuffer;
|
||
thread_local std::vector<float> nextBuffer;
|
||
thread_local std::vector<PeakExtremum> extremesBuffer;
|
||
std::vector<float>& current = currentBuffer;
|
||
current.assign(count, std::numeric_limits<float>::quiet_NaN());
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
const double value = values[index];
|
||
if (std::isfinite(value))
|
||
{
|
||
current[index] = static_cast<float>(value);
|
||
}
|
||
}
|
||
|
||
// 「迭代次数 N」与「均值滤波」的迭代次数语义一致：把同一处理**重复应用 N 次**，
|
||
// 每一阶以上一阶的结果为输入。一阶时改定量已严格等于「幅度」对应的目标值；
|
||
// 多次迭代时相邻的弱峰会互相抬高彼此的基准，从而把较宽的弱峰区逐步恢复（或削弱）。
|
||
const int stages = std::max(1, std::min(iterations, 1000));
|
||
// 调整幅度 -2 – +2（对应面板上的 -200% – +200%）：
|
||
// > 0 增强（0 = 不动，1 = 拉到较温和的一侧，2 = 完全拉平）；
|
||
// < 0 削弱（-1 = 拉到相邻异类极值中较近的一个，-2 = 拉到较远的那个）。
|
||
const double clamped = std::max(-2.0, std::min(2.0, amount));
|
||
std::vector<float>& next = nextBuffer;
|
||
for (int stage = 0; stage < stages; ++stage)
|
||
{
|
||
if (!ApplyWeakPeakStage(current, clamped, next, extremesBuffer))
|
||
{
|
||
// 这一阶没有任何采样点需要调整：后续迭代次数也不会再有变化，提前结束。
|
||
break;
|
||
}
|
||
current.swap(next);
|
||
}
|
||
out.swap(current);
|
||
}
|
||
|
||
const Lane::MeanFilterItem* Lane::FindMeanFilterItem(const SignalRef& ref) const
|
||
{
|
||
for (const MeanFilterItem& item : meanFilterItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
return &item;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
Lane::MeanFilterItem& Lane::EnsureMeanFilterItem(const SignalRef& ref)
|
||
{
|
||
for (MeanFilterItem& item : meanFilterItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
return item;
|
||
}
|
||
}
|
||
MeanFilterItem item;
|
||
item.ref = ref;
|
||
meanFilterItems.push_back(item);
|
||
return meanFilterItems.back();
|
||
}
|
||
|
||
void Lane::RemoveMeanFilterItem(const SignalRef& ref)
|
||
{
|
||
meanFilterItems.erase(
|
||
std::remove_if(meanFilterItems.begin(), meanFilterItems.end(),
|
||
[&ref](const MeanFilterItem& item) { return item.ref == ref; }),
|
||
meanFilterItems.end());
|
||
}
|
||
|
||
const Lane::EdgeCenterItem* Lane::FindEdgeCenterItem(const SignalRef& ref) const
|
||
{
|
||
for (const EdgeCenterItem& item : edgeCenterItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
return &item;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
Lane::EdgeCenterItem& Lane::EnsureEdgeCenterItem(const SignalRef& ref)
|
||
{
|
||
for (EdgeCenterItem& item : edgeCenterItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
return item;
|
||
}
|
||
}
|
||
EdgeCenterItem item;
|
||
item.ref = ref;
|
||
edgeCenterItems.push_back(item);
|
||
return edgeCenterItems.back();
|
||
}
|
||
|
||
void Lane::RemoveEdgeCenterItem(const SignalRef& ref)
|
||
{
|
||
edgeCenterItems.erase(
|
||
std::remove_if(edgeCenterItems.begin(), edgeCenterItems.end(),
|
||
[&ref](const EdgeCenterItem& item) { return item.ref == ref; }),
|
||
edgeCenterItems.end());
|
||
}
|
||
|
||
const Lane::WeakPeakItem* Lane::FindWeakPeakItem(const SignalRef& ref) const
|
||
{
|
||
for (const WeakPeakItem& item : weakPeakItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
return &item;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
Lane::WeakPeakItem& Lane::EnsureWeakPeakItem(const SignalRef& ref)
|
||
{
|
||
for (WeakPeakItem& item : weakPeakItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
return item;
|
||
}
|
||
}
|
||
WeakPeakItem item;
|
||
item.ref = ref;
|
||
weakPeakItems.push_back(item);
|
||
return weakPeakItems.back();
|
||
}
|
||
|
||
void Lane::RemoveWeakPeakItem(const SignalRef& ref)
|
||
{
|
||
weakPeakItems.erase(
|
||
std::remove_if(weakPeakItems.begin(), weakPeakItems.end(),
|
||
[&ref](const WeakPeakItem& item) { return item.ref == ref; }),
|
||
weakPeakItems.end());
|
||
}
|
||
|
||
int FindNearestSample(const DataFile& file, double time)
|
||
{
|
||
const std::size_t count = file.time.size();
|
||
if (count == 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (file.timeMonotonic)
|
||
{
|
||
const std::vector<double>::const_iterator lower =
|
||
std::lower_bound(file.time.begin(), file.time.end(), time);
|
||
if (lower == file.time.begin())
|
||
{
|
||
return 0;
|
||
}
|
||
if (lower == file.time.end())
|
||
{
|
||
return static_cast<int>(count - 1);
|
||
}
|
||
const std::size_t rightIndex = static_cast<std::size_t>(lower - file.time.begin());
|
||
const std::size_t leftIndex = rightIndex - 1;
|
||
const double leftDistance = std::fabs(time - file.time[leftIndex]);
|
||
const double rightDistance = std::fabs(file.time[rightIndex] - time);
|
||
return (leftDistance <= rightDistance) ? static_cast<int>(leftIndex) : static_cast<int>(rightIndex);
|
||
}
|
||
|
||
int best = 0;
|
||
double bestDistance = std::numeric_limits<double>::infinity();
|
||
for (std::size_t index = 0; index < count; ++index)
|
||
{
|
||
if (!std::isfinite(file.time[index]))
|
||
{
|
||
continue;
|
||
}
|
||
const double distance = std::fabs(file.time[index] - time);
|
||
if (distance < bestDistance)
|
||
{
|
||
bestDistance = distance;
|
||
best = static_cast<int>(index);
|
||
}
|
||
}
|
||
return best;
|
||
}
|
||
|
||
bool SampleSignalAt(const DataFile& file, const SignalData& signal, double time, bool interpolate,
|
||
double& value)
|
||
{
|
||
value = kMissing;
|
||
|
||
if (file.time.empty() || signal.values.empty())
|
||
{
|
||
return false;
|
||
}
|
||
if (time < file.minTime || time > file.maxTime)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const std::vector<double>& values = signal.values;
|
||
|
||
if (!file.timeMonotonic)
|
||
{
|
||
const int nearest = FindNearestSample(file, time);
|
||
if (nearest < 0 || static_cast<std::size_t>(nearest) >= values.size())
|
||
{
|
||
return false;
|
||
}
|
||
value = values[static_cast<std::size_t>(nearest)];
|
||
return std::isfinite(value);
|
||
}
|
||
|
||
const std::vector<double>::const_iterator lower = std::lower_bound(file.time.begin(), file.time.end(), time);
|
||
const std::size_t rightIndex = static_cast<std::size_t>(lower - file.time.begin());
|
||
if (rightIndex == 0)
|
||
{
|
||
value = values[0];
|
||
return std::isfinite(value);
|
||
}
|
||
if (rightIndex >= file.time.size())
|
||
{
|
||
value = values.back();
|
||
return std::isfinite(value);
|
||
}
|
||
|
||
const std::size_t leftIndex = rightIndex - 1;
|
||
if (rightIndex >= values.size() || leftIndex >= values.size())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const double t0 = file.time[leftIndex];
|
||
const double t1 = file.time[rightIndex];
|
||
const double v0 = values[leftIndex];
|
||
const double v1 = values[rightIndex];
|
||
|
||
if (!interpolate || !std::isfinite(v0) || !std::isfinite(v1) || !(t1 > t0))
|
||
{
|
||
const double leftDistance = std::fabs(time - t0);
|
||
const double rightDistance = std::fabs(t1 - time);
|
||
value = (leftDistance <= rightDistance) ? v0 : v1;
|
||
return std::isfinite(value);
|
||
}
|
||
|
||
const double ratio = (time - t0) / (t1 - t0);
|
||
value = v0 + (v1 - v0) * ratio;
|
||
return true;
|
||
}
|
||
|
||
// ============================ TabConfig ============================
|
||
|
||
TabConfig::TabConfig()
|
||
: m_name(L"视图 1")
|
||
{
|
||
}
|
||
|
||
void TabConfig::SyncToDataSet(const DataSet& dataSet)
|
||
{
|
||
const std::size_t fileCount = dataSet.FileCount();
|
||
m_visible.resize(fileCount);
|
||
m_collapsed.resize(fileCount, false);
|
||
|
||
for (std::size_t fileIndex = 0; fileIndex < fileCount; ++fileIndex)
|
||
{
|
||
const DataFile* file = dataSet.FileAt(static_cast<int>(fileIndex));
|
||
if (file == nullptr)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 新增信号默认为未勾选（由用户自行决定查看哪些信号），
|
||
// 其显示外观已在 DataSet 中初始化完毕。
|
||
m_visible[fileIndex].resize(file->signals.size(), false);
|
||
}
|
||
|
||
// 清理已失效的网格引用（选中状态由 DataSet 统一维护）。
|
||
for (Lane& lane : m_lanes)
|
||
{
|
||
std::vector<SignalRef>& refs = lane.signals;
|
||
refs.erase(std::remove_if(refs.begin(), refs.end(),
|
||
[&dataSet](const SignalRef& ref) { return dataSet.Resolve(ref) == nullptr; }),
|
||
refs.end());
|
||
}
|
||
m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
|
||
[](const Lane& lane) { return lane.signals.empty(); }),
|
||
m_lanes.end());
|
||
|
||
SyncLanes();
|
||
}
|
||
|
||
void TabConfig::RemapAfterFileRemoval(int fileIndex)
|
||
{
|
||
if (fileIndex < 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
const std::size_t slot = static_cast<std::size_t>(fileIndex);
|
||
if (slot < m_visible.size())
|
||
{
|
||
m_visible.erase(m_visible.begin() + fileIndex);
|
||
}
|
||
if (slot < m_collapsed.size())
|
||
{
|
||
m_collapsed.erase(m_collapsed.begin() + fileIndex);
|
||
}
|
||
|
||
for (Lane& lane : m_lanes)
|
||
{
|
||
std::vector<SignalRef>& refs = lane.signals;
|
||
refs.erase(std::remove_if(refs.begin(), refs.end(),
|
||
[fileIndex](const SignalRef& ref)
|
||
{ return ref.fileIndex == fileIndex; }),
|
||
refs.end());
|
||
for (SignalRef& ref : refs)
|
||
{
|
||
if (ref.fileIndex > fileIndex)
|
||
{
|
||
--ref.fileIndex;
|
||
}
|
||
}
|
||
}
|
||
m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
|
||
[](const Lane& lane) { return lane.signals.empty(); }),
|
||
m_lanes.end());
|
||
}
|
||
|
||
void TabConfig::RemapAfterSignalRemoval(int fileIndex, int signalIndex)
|
||
{
|
||
if (fileIndex < 0 || signalIndex < 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 可见性表：删掉该信号对应的那一列。
|
||
const std::size_t slot = static_cast<std::size_t>(fileIndex);
|
||
if (slot < m_visible.size())
|
||
{
|
||
std::vector<bool>& fileVisible = m_visible[slot];
|
||
if (static_cast<std::size_t>(signalIndex) < fileVisible.size())
|
||
{
|
||
fileVisible.erase(fileVisible.begin() + signalIndex);
|
||
}
|
||
}
|
||
|
||
// 网格归属：删掉该信号本身，并把同一文件内位于其后的引用下标前移一位。
|
||
for (Lane& lane : m_lanes)
|
||
{
|
||
std::vector<SignalRef>& refs = lane.signals;
|
||
refs.erase(std::remove_if(refs.begin(), refs.end(),
|
||
[fileIndex, signalIndex](const SignalRef& ref)
|
||
{
|
||
return ref.fileIndex == fileIndex &&
|
||
ref.signalIndex == signalIndex;
|
||
}),
|
||
refs.end());
|
||
for (SignalRef& ref : refs)
|
||
{
|
||
if (ref.fileIndex == fileIndex && ref.signalIndex > signalIndex)
|
||
{
|
||
--ref.signalIndex;
|
||
}
|
||
}
|
||
|
||
// 均值滤波 / 中心轴边沿计数 / 弱峰调整的条目同样持有信号引用，必须一起删除/前移。
|
||
// 三类条目都是「带 `ref` 的结构体」，因此用泛型 lambda 统一处理
|
||
//（弱峰调整的参数与均值滤波不同，不能再共用同一个具体类型）。
|
||
const auto purgeRefs = [fileIndex, signalIndex](auto& items)
|
||
{
|
||
using ItemType = typename std::decay_t<decltype(items)>::value_type;
|
||
items.erase(std::remove_if(items.begin(), items.end(),
|
||
[fileIndex, signalIndex](const ItemType& item)
|
||
{
|
||
return item.ref.fileIndex == fileIndex &&
|
||
item.ref.signalIndex == signalIndex;
|
||
}),
|
||
items.end());
|
||
for (ItemType& item : items)
|
||
{
|
||
if (item.ref.fileIndex == fileIndex && item.ref.signalIndex > signalIndex)
|
||
{
|
||
--item.ref.signalIndex;
|
||
}
|
||
}
|
||
};
|
||
purgeRefs(lane.meanFilterItems);
|
||
purgeRefs(lane.edgeCenterItems);
|
||
purgeRefs(lane.weakPeakItems);
|
||
}
|
||
// 被移除信号若独占了某个网格，该网格随之消失（与取消勾选的行为一致）。
|
||
m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
|
||
[](const Lane& lane) { return lane.signals.empty(); }),
|
||
m_lanes.end());
|
||
}
|
||
|
||
bool TabConfig::IsVisible(const SignalRef& ref) const
|
||
{
|
||
if (ref.fileIndex < 0 || static_cast<std::size_t>(ref.fileIndex) >= m_visible.size())
|
||
{
|
||
return false;
|
||
}
|
||
const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(ref.fileIndex)];
|
||
if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
|
||
{
|
||
return false;
|
||
}
|
||
return fileVisible[static_cast<std::size_t>(ref.signalIndex)];
|
||
}
|
||
|
||
void TabConfig::SetVisible(const SignalRef& ref, bool visible)
|
||
{
|
||
if (ref.fileIndex < 0 || static_cast<std::size_t>(ref.fileIndex) >= m_visible.size())
|
||
{
|
||
return;
|
||
}
|
||
std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(ref.fileIndex)];
|
||
if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
|
||
{
|
||
return;
|
||
}
|
||
if (fileVisible[static_cast<std::size_t>(ref.signalIndex)] == visible)
|
||
{
|
||
return;
|
||
}
|
||
fileVisible[static_cast<std::size_t>(ref.signalIndex)] = visible;
|
||
|
||
// 合并模式下新勾选的信号独占一个新网格：切到自定义划分后，
|
||
// RebuildLanes 会把尚未分配网格的可见信号各自放入新网格。
|
||
if (visible && m_laneMode == LaneMode::MERGED)
|
||
{
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
}
|
||
|
||
SyncLanes();
|
||
}
|
||
|
||
void TabConfig::ToggleVisible(const SignalRef& ref)
|
||
{
|
||
SetVisible(ref, !IsVisible(ref));
|
||
}
|
||
|
||
void TabConfig::SetFileVisible(int fileIndex, bool visible)
|
||
{
|
||
if (fileIndex < 0 || static_cast<std::size_t>(fileIndex) >= m_visible.size())
|
||
{
|
||
return;
|
||
}
|
||
std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(fileIndex)];
|
||
// 合并模式下“新增”的信号同样应各自独占网格（与 SetVisible 一致）：
|
||
// 先切到自定义划分，RebuildLanes 会把尚未分配网格的可见信号追加到最下方。
|
||
// 只有确实存在“原本不可见”的信号时才切模式，避免重复点击默默改掉划分策略。
|
||
const bool anyHidden =
|
||
std::find(fileVisible.begin(), fileVisible.end(), false) != fileVisible.end();
|
||
if (visible && anyHidden && m_laneMode == LaneMode::MERGED)
|
||
{
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
}
|
||
std::fill(fileVisible.begin(), fileVisible.end(), visible);
|
||
SyncLanes();
|
||
}
|
||
|
||
void TabConfig::SetAllVisible(bool visible)
|
||
{
|
||
bool anyHidden = false;
|
||
for (const std::vector<bool>& fileVisible : m_visible)
|
||
{
|
||
if (std::find(fileVisible.begin(), fileVisible.end(), false) != fileVisible.end())
|
||
{
|
||
anyHidden = true;
|
||
break;
|
||
}
|
||
}
|
||
// 同上：合并模式下新增的信号各自独占网格，且排列在最下方。
|
||
if (visible && anyHidden && m_laneMode == LaneMode::MERGED)
|
||
{
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
}
|
||
for (std::vector<bool>& fileVisible : m_visible)
|
||
{
|
||
std::fill(fileVisible.begin(), fileVisible.end(), visible);
|
||
}
|
||
SyncLanes();
|
||
}
|
||
|
||
void TabConfig::SoloSignal(const SignalRef& ref)
|
||
{
|
||
for (std::vector<bool>& fileVisible : m_visible)
|
||
{
|
||
std::fill(fileVisible.begin(), fileVisible.end(), false);
|
||
}
|
||
SetVisible(ref, true);
|
||
}
|
||
|
||
bool TabConfig::FileHasVisible(int fileIndex) const
|
||
{
|
||
if (fileIndex < 0 || static_cast<std::size_t>(fileIndex) >= m_visible.size())
|
||
{
|
||
return false;
|
||
}
|
||
const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(fileIndex)];
|
||
return std::find(fileVisible.begin(), fileVisible.end(), true) != fileVisible.end();
|
||
}
|
||
|
||
bool TabConfig::FileAllVisible(int fileIndex) const
|
||
{
|
||
if (fileIndex < 0 || static_cast<std::size_t>(fileIndex) >= m_visible.size())
|
||
{
|
||
return false;
|
||
}
|
||
const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(fileIndex)];
|
||
if (fileVisible.empty())
|
||
{
|
||
return false;
|
||
}
|
||
return std::find(fileVisible.begin(), fileVisible.end(), false) == fileVisible.end();
|
||
}
|
||
|
||
bool TabConfig::AnyVisible() const
|
||
{
|
||
for (const std::vector<bool>& fileVisible : m_visible)
|
||
{
|
||
if (std::find(fileVisible.begin(), fileVisible.end(), true) != fileVisible.end())
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
int TabConfig::VisibleCount() const
|
||
{
|
||
int count = 0;
|
||
for (const std::vector<bool>& fileVisible : m_visible)
|
||
{
|
||
count += static_cast<int>(std::count(fileVisible.begin(), fileVisible.end(), true));
|
||
}
|
||
return count;
|
||
}
|
||
|
||
void TabConfig::SetMode(LaneMode mode)
|
||
{
|
||
m_laneMode = mode;
|
||
SyncLanes();
|
||
}
|
||
|
||
void TabConfig::SyncLanes()
|
||
{
|
||
RebuildLanes(m_visible, m_lanes, m_laneMode);
|
||
}
|
||
|
||
int TabConfig::LaneOfSignal(const SignalRef& ref) const
|
||
{
|
||
for (std::size_t lane = 0; lane < m_lanes.size(); ++lane)
|
||
{
|
||
const std::vector<SignalRef>& refs = m_lanes[lane].signals;
|
||
if (std::find(refs.begin(), refs.end(), ref) != refs.end())
|
||
{
|
||
return static_cast<int>(lane);
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int TabConfig::MoveSignalToLane(const DataSet& dataSet, const SignalRef& ref, int laneIndex)
|
||
{
|
||
if (dataSet.Resolve(ref) == nullptr)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
const int sourceLane = LaneOfSignal(ref);
|
||
if (laneIndex >= 0 && laneIndex == sourceLane)
|
||
{
|
||
// 拖回原网格：无需变动，避免因网格回收导致顺序抖动。
|
||
return sourceLane;
|
||
}
|
||
|
||
// 先把目标网格的“锚信号”固定下来：移除信号后空网格会被回收，
|
||
// 下标随之变化，必须用不依赖下标的引用找回真正的目标网格
|
||
// （否则会变成“与原网格交换位置”而不是合并进去）。
|
||
SignalRef targetAnchor;
|
||
bool hasTarget = (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()));
|
||
if (hasTarget)
|
||
{
|
||
const std::vector<SignalRef>& targetSignals = m_lanes[static_cast<std::size_t>(laneIndex)].signals;
|
||
for (const SignalRef& candidate : targetSignals)
|
||
{
|
||
if (!(candidate == ref))
|
||
{
|
||
targetAnchor = candidate;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 手动指定归属意味着切换到自定义划分策略。
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
|
||
for (Lane& lane : m_lanes)
|
||
{
|
||
std::vector<SignalRef>& refs = lane.signals;
|
||
refs.erase(std::remove(refs.begin(), refs.end(), ref), refs.end());
|
||
}
|
||
m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
|
||
[](const Lane& lane) { return lane.signals.empty(); }),
|
||
m_lanes.end());
|
||
|
||
int destination = -1;
|
||
if (hasTarget && targetAnchor.IsValid())
|
||
{
|
||
for (std::size_t index = 0; index < m_lanes.size(); ++index)
|
||
{
|
||
const std::vector<SignalRef>& refs = m_lanes[index].signals;
|
||
if (std::find(refs.begin(), refs.end(), targetAnchor) != refs.end())
|
||
{
|
||
destination = static_cast<int>(index);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (destination >= 0)
|
||
{
|
||
m_lanes[static_cast<std::size_t>(destination)].signals.push_back(ref);
|
||
}
|
||
else
|
||
{
|
||
Lane lane;
|
||
lane.autoRange = true;
|
||
lane.signals.push_back(ref);
|
||
m_lanes.push_back(std::move(lane));
|
||
}
|
||
|
||
for (std::size_t index = 0; index < m_lanes.size(); ++index)
|
||
{
|
||
m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
|
||
}
|
||
return LaneOfSignal(ref);
|
||
}
|
||
|
||
int TabConfig::SplitLane(int laneIndex)
|
||
{
|
||
if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
|
||
{
|
||
return -1;
|
||
}
|
||
const std::vector<SignalRef> signals = m_lanes[static_cast<std::size_t>(laneIndex)].signals;
|
||
if (signals.size() <= 1)
|
||
{
|
||
// 只有一条信号时无需拆分（本就独占一个网格）。
|
||
return -1;
|
||
}
|
||
|
||
// 手动排布 → 切换到自定义划分策略。
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
|
||
// 用原网格的“网格自身状态”（Y 轴自适应/边沿计数等）作为每一份的初始状态，
|
||
// 这样拆分出来的网格保持原网格的显示设置。
|
||
const Lane source = m_lanes[static_cast<std::size_t>(laneIndex)];
|
||
|
||
std::vector<Lane> pieces;
|
||
pieces.reserve(signals.size());
|
||
for (const SignalRef& ref : signals)
|
||
{
|
||
Lane lane;
|
||
lane.autoRange = source.autoRange;
|
||
lane.yMin = source.yMin;
|
||
lane.yMax = source.yMax;
|
||
lane.fitYToSelection = source.fitYToSelection;
|
||
lane.edgeCount = source.edgeCount;
|
||
lane.edgeValue = source.edgeValue;
|
||
lane.edgeValueValid = source.edgeValueValid;
|
||
lane.edgePanelOpen = source.edgePanelOpen;
|
||
lane.edgePanelX = source.edgePanelX;
|
||
lane.edgePanelY = source.edgePanelY;
|
||
lane.edgeCenter = source.edgeCenter;
|
||
lane.edgeCenterPanelOpen = source.edgeCenterPanelOpen;
|
||
lane.edgeCenterPanelX = source.edgeCenterPanelX;
|
||
lane.edgeCenterPanelY = source.edgeCenterPanelY;
|
||
lane.weakPeak = source.weakPeak;
|
||
lane.weakPeakPanelOpen = source.weakPeakPanelOpen;
|
||
lane.weakPeakPanelX = source.weakPeakPanelX;
|
||
lane.weakPeakPanelY = source.weakPeakPanelY;
|
||
lane.meanFilter = source.meanFilter;
|
||
lane.meanFilterPanelOpen = source.meanFilterPanelOpen;
|
||
lane.meanFilterPanelX = source.meanFilterPanelX;
|
||
lane.meanFilterPanelY = source.meanFilterPanelY;
|
||
// 拆分后每个子网格只保留自己那个信号的均值滤波 / 中心轴 / 弱峰调整条目。
|
||
lane.meanFilterItems.clear();
|
||
lane.edgeCenterItems.clear();
|
||
lane.weakPeakItems.clear();
|
||
for (const Lane::MeanFilterItem& item : source.meanFilterItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
lane.meanFilterItems.push_back(item);
|
||
}
|
||
}
|
||
for (const Lane::EdgeCenterItem& item : source.edgeCenterItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
lane.edgeCenterItems.push_back(item);
|
||
}
|
||
}
|
||
for (const Lane::WeakPeakItem& item : source.weakPeakItems)
|
||
{
|
||
if (item.ref == ref)
|
||
{
|
||
lane.weakPeakItems.push_back(item);
|
||
}
|
||
}
|
||
lane.signals.push_back(ref);
|
||
pieces.push_back(std::move(lane));
|
||
}
|
||
// 用 pieces 替换原网格（插入到原位置，因此其后方的网格整体顺次后移）。
|
||
m_lanes.erase(m_lanes.begin() + laneIndex);
|
||
m_lanes.insert(m_lanes.begin() + laneIndex, pieces.begin(), pieces.end());
|
||
|
||
// 统一重命名，保证编号连续（GX 编号在各显示位置均由此位置推导）。
|
||
for (std::size_t index = 0; index < m_lanes.size(); ++index)
|
||
{
|
||
m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
|
||
}
|
||
return laneIndex;
|
||
}
|
||
|
||
void TabConfig::RemapAfterSignalInsert(int fileIndex, int insertPos)
|
||
{
|
||
if (fileIndex < 0 || insertPos < 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 可见性表：在插入点补一列（新信号默认不可见，由调用方按需勾选）。
|
||
const std::size_t slot = static_cast<std::size_t>(fileIndex);
|
||
if (slot < m_visible.size() && static_cast<std::size_t>(insertPos) <= m_visible[slot].size())
|
||
{
|
||
m_visible[slot].insert(m_visible[slot].begin() + insertPos, false);
|
||
}
|
||
|
||
// 网格内的信号引用：同一文件中位于插入点之后的引用下标整体后移。
|
||
for (Lane& lane : m_lanes)
|
||
{
|
||
for (SignalRef& ref : lane.signals)
|
||
{
|
||
if (ref.fileIndex == fileIndex && ref.signalIndex >= insertPos)
|
||
{
|
||
++ref.signalIndex;
|
||
}
|
||
}
|
||
// 均值滤波 / 中心轴条目同样持有信号引用，必须一起后移。
|
||
for (Lane::MeanFilterItem& item : lane.meanFilterItems)
|
||
{
|
||
if (item.ref.fileIndex == fileIndex && item.ref.signalIndex >= insertPos)
|
||
{
|
||
++item.ref.signalIndex;
|
||
}
|
||
}
|
||
for (Lane::EdgeCenterItem& item : lane.edgeCenterItems)
|
||
{
|
||
if (item.ref.fileIndex == fileIndex && item.ref.signalIndex >= insertPos)
|
||
{
|
||
++item.ref.signalIndex;
|
||
}
|
||
}
|
||
for (Lane::WeakPeakItem& item : lane.weakPeakItems)
|
||
{
|
||
if (item.ref.fileIndex == fileIndex && item.ref.signalIndex >= insertPos)
|
||
{
|
||
++item.ref.signalIndex;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool TabConfig::MoveLaneOfSignalBelow(const SignalRef& moved, const SignalRef& anchor)
|
||
{
|
||
const int from = LaneOfSignal(moved);
|
||
if (from < 0 || LaneOfSignal(anchor) < 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Lane lane = std::move(m_lanes[static_cast<std::size_t>(from)]);
|
||
m_lanes.erase(m_lanes.begin() + from);
|
||
|
||
// erase 之后锚点网格的下标可能变化，必须用信号引用重新定位。
|
||
const int target = LaneOfSignal(anchor);
|
||
if (target < 0)
|
||
{
|
||
m_lanes.push_back(std::move(lane));
|
||
}
|
||
else
|
||
{
|
||
m_lanes.insert(m_lanes.begin() + target + 1, std::move(lane));
|
||
}
|
||
|
||
// 手动排布 → 切换到自定义划分策略，避免后续重建网格时顺序被还原。
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
RenameLanes();
|
||
return true;
|
||
}
|
||
|
||
bool TabConfig::MoveLane(int from, int target)
|
||
{
|
||
const int count = static_cast<int>(m_lanes.size());
|
||
if (from < 0 || from >= count || target < 0 || target > count)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// `target` 语义 = 「插入到该下标之前」；向后拖时扣除自身占位后再比较，
|
||
// 保证"拖到自己原来的位置"不会产生无意义的移动。
|
||
int destination = target;
|
||
if (destination > from)
|
||
{
|
||
--destination;
|
||
}
|
||
destination = std::max(0, std::min(destination, count - 1));
|
||
if (destination == from)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Lane moved = std::move(m_lanes[static_cast<std::size_t>(from)]);
|
||
m_lanes.erase(m_lanes.begin() + from);
|
||
m_lanes.insert(m_lanes.begin() + destination, std::move(moved));
|
||
|
||
// 手动排布 → 切换到自定义划分策略，避免后续重建网格时顺序被还原。
|
||
m_laneMode = LaneMode::CUSTOM;
|
||
RenameLanes();
|
||
return true;
|
||
}
|
||
|
||
void TabConfig::RenameLanes()
|
||
{
|
||
for (std::size_t index = 0; index < m_lanes.size(); ++index)
|
||
{
|
||
m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
|
||
}
|
||
}
|
||
|
||
bool TabConfig::IsCollapsed(int fileIndex) const
|
||
{
|
||
if (fileIndex < 0 || static_cast<std::size_t>(fileIndex) >= m_collapsed.size())
|
||
{
|
||
return false;
|
||
}
|
||
return m_collapsed[static_cast<std::size_t>(fileIndex)];
|
||
}
|
||
|
||
void TabConfig::ToggleCollapsed(int fileIndex)
|
||
{
|
||
if (fileIndex < 0)
|
||
{
|
||
return;
|
||
}
|
||
if (static_cast<std::size_t>(fileIndex) >= m_collapsed.size())
|
||
{
|
||
m_collapsed.resize(static_cast<std::size_t>(fileIndex) + 1, false);
|
||
}
|
||
m_collapsed[static_cast<std::size_t>(fileIndex)] = !m_collapsed[static_cast<std::size_t>(fileIndex)];
|
||
}
|
||
|
||
void TabConfig::ComputeLaneRange(const DataSet& dataSet, int laneIndex, double& yMin, double& yMax) const
|
||
{
|
||
if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
|
||
{
|
||
yMin = 0.0;
|
||
yMax = 1.0;
|
||
return;
|
||
}
|
||
|
||
const Lane& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
|
||
if (!lane.autoRange)
|
||
{
|
||
yMin = lane.yMin;
|
||
yMax = lane.yMax;
|
||
if (!(yMax > yMin))
|
||
{
|
||
yMin = 0.0;
|
||
yMax = 1.0;
|
||
}
|
||
return;
|
||
}
|
||
|
||
double low = std::numeric_limits<double>::infinity();
|
||
double high = -std::numeric_limits<double>::infinity();
|
||
for (const SignalRef& ref : lane.signals)
|
||
{
|
||
if (!IsVisible(ref))
|
||
{
|
||
continue;
|
||
}
|
||
const SignalData* signal = dataSet.Resolve(ref);
|
||
if (signal == nullptr || signal->finiteCount == 0)
|
||
{
|
||
continue;
|
||
}
|
||
low = std::min(low, signal->minValue);
|
||
high = std::max(high, signal->maxValue);
|
||
}
|
||
|
||
if (!std::isfinite(low) || !std::isfinite(high))
|
||
{
|
||
low = 0.0;
|
||
high = 1.0;
|
||
}
|
||
PadRange(low, high);
|
||
yMin = low;
|
||
yMax = high;
|
||
}
|
||
|
||
bool TabConfig::ComputeVisibleTimeBounds(const DataSet& dataSet, double& minTime, double& maxTime) const
|
||
{
|
||
double low = std::numeric_limits<double>::infinity();
|
||
double high = -std::numeric_limits<double>::infinity();
|
||
|
||
for (std::size_t fileIndex = 0; fileIndex < m_visible.size(); ++fileIndex)
|
||
{
|
||
const std::vector<bool>& fileVisible = m_visible[fileIndex];
|
||
if (std::find(fileVisible.begin(), fileVisible.end(), true) == fileVisible.end())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
const DataFile* file = dataSet.FileAt(static_cast<int>(fileIndex));
|
||
if (file == nullptr)
|
||
{
|
||
continue;
|
||
}
|
||
if (std::isfinite(file->minTime))
|
||
{
|
||
low = std::min(low, file->minTime);
|
||
}
|
||
if (std::isfinite(file->maxTime))
|
||
{
|
||
high = std::max(high, file->maxTime);
|
||
}
|
||
}
|
||
|
||
if (!std::isfinite(low) || !std::isfinite(high) || !(high > low))
|
||
{
|
||
return false;
|
||
}
|
||
minTime = low;
|
||
maxTime = high;
|
||
return true;
|
||
}
|
||
|
||
} // namespace jdi
|