LuChiChick/Just-DataInspector
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

实验性功能：移除「差异放大」、新增「弱波增强」；修复放大后拖拽光标越出视界

Browse Source 
- 移除差异放大：ComputeDiffAmplify、EdgePanelKind::DIFF_AMP 面板、DIFF_AMP_*
  编辑目标、菜单项与相关缓存，并删除仅供它使用的 SlidingMax / SlidingExtrema /
  float 版滑动平均。
- 新增弱波增强 ComputeWeakWaveBoost(values, level, out)（O(n)）：
  1) 对轻度平滑（5 点滑动平均）后的信号扫描单调段，方向翻转处即为波峰/波谷；
  2) 波峰低于左右两个波峰均值（波谷高于左右两个波谷均值）即判为弱波；
  3) 波峰目标 = 较小波峰 + 等级×(较大−较小)；
     波谷目标 = 较大波谷 − 等级×(较大−较小)；
  4) 极值点取目标值，两侧数据点在相邻极值点的偏移量之间用平滑步进过渡，
     因此健康周期逐位不变、数据端点原样保留。
- 弱波增强面板：逐信号复选框 + 「弱波增强等级」滑块（0–100%，整个网格共用）
  + 「构建为新信号」按钮；构建名形如「<原信号> (弱波增强 M%)」。
  等级进 SceneContentHash，改动即触发重绘；Lane 新增
  weakBoost/weakBoostLevel/weakBoostItems，并在 LaneCarry、SplitLane、
  RemapAfterSignalInsert/Removal 中同步。
- 修复：放大到一定程度后左右拖拽时间光标（尤其抓取较宽的读数标签、抓取偏移较大时）
  会把光标时间推到视界之外；现在 CURSOR_MOVE 与 CURSOR_SPAN_MOVE 结束后
  按可见区间夹取（视图变化仍不移动光标，保留贴边读数与方向三角）。
- 离屏验证（窗口隐藏，不占用鼠标/键盘/屏幕）：295 项检查全部通过，
  含等级 0/50/100% 的目标值与健康区逐位不变、滑块拖拽与左右钳制、
  合成纹波端到端恢复（弱周期峰峰值 100→160，健康周期 200 不变）、
  光标拖拽始终落在可见区间内。
This commit is contained in:
DeepSeek V4.1 Flash committed 2026-10-10 18:46:01 +08:00
1 parent d4206a8d67
commit 67f659ad23
6 files changed
+811 -764
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Utilities/Src/DataModel.cpp
+228 -342
View File
@@ -134,11 +134,12 @@ namespace jdi
bool meanFilterPanelOpen = true;
double meanFilterPanelX = -1.0;
double meanFilterPanelY = -1.0;
bool diffAmp = false;
std::vector<Lane::DiffAmpItem> diffAmpItems;
bool diffAmpPanelOpen = true;
double diffAmpPanelX = -1.0;
double diffAmpPanelY = -1.0;
bool weakBoost = false;
std::vector<Lane::WeakBoostItem> weakBoostItems;
double weakBoostLevel = 0.5;
bool weakBoostPanelOpen = true;
double weakBoostPanelX = -1.0;
double weakBoostPanelY = -1.0;
};
// 先记下每个信号原来所在网格的网格自身状态：
@@ -164,11 +165,12 @@ namespace jdi
carry.meanFilterPanelOpen = lane.meanFilterPanelOpen;
carry.meanFilterPanelX = lane.meanFilterPanelX;
carry.meanFilterPanelY = lane.meanFilterPanelY;
carry.diffAmp = lane.diffAmp;
carry.diffAmpItems = lane.diffAmpItems;
carry.diffAmpPanelOpen = lane.diffAmpPanelOpen;
carry.diffAmpPanelX = lane.diffAmpPanelX;
carry.diffAmpPanelY = lane.diffAmpPanelY;
carry.weakBoost = lane.weakBoost;
carry.weakBoostItems = lane.weakBoostItems;
carry.weakBoostLevel = lane.weakBoostLevel;
carry.weakBoostPanelOpen = lane.weakBoostPanelOpen;
carry.weakBoostPanelX = lane.weakBoostPanelX;
carry.weakBoostPanelY = lane.weakBoostPanelY;
for (const SignalRef& ref : lane.signals)
{
previousCarry.emplace_back(ref, carry);
@@ -205,11 +207,12 @@ namespace jdi
lane.meanFilterPanelOpen = carry.meanFilterPanelOpen;
lane.meanFilterPanelX = carry.meanFilterPanelX;
lane.meanFilterPanelY = carry.meanFilterPanelY;
lane.diffAmp = carry.diffAmp;
lane.diffAmpItems = carry.diffAmpItems;
lane.diffAmpPanelOpen = carry.diffAmpPanelOpen;
lane.diffAmpPanelX = carry.diffAmpPanelX;
lane.diffAmpPanelY = carry.diffAmpPanelY;
lane.weakBoost = carry.weakBoost;
lane.weakBoostItems = carry.weakBoostItems;
lane.weakBoostLevel = carry.weakBoostLevel;
lane.weakBoostPanelOpen = carry.weakBoostPanelOpen;
lane.weakBoostPanelX = carry.weakBoostPanelX;
lane.weakBoostPanelY = carry.weakBoostPanelY;
};
// 收集全部可见信号引用。
@@ -917,60 +920,10 @@ namespace jdi
* @brief 滑动平均的共用实现（输入只要可转成 double）。
*
* 窗口 = [max(0,i-N), min(count-1,i+N)]，每前进一步只增减边界处的两个采样点，
* 整体 O(n)，不额外占用前缀和内存。“差异放大”需要在 float 缓冲上再做一次
* 滑动平均，若先转成 double 会因为亿级采样多占一倍内存，因此做成模板。
* 整体 O(n)，不额外占用前缀和内存。
*/
template <typename T>
void MovingAverageImpl(const std::vector<T>& values, int radius, std::vector<float>& out);
/**
* @brief 滑动窗口最大值（只要最大值）。
*
* 与 `SlidingExtrema` 同一个单调队列思路，但**不额外分配最小值数组**：
* 亿级采样下一次全量计算会多占 100 MB 以上，而“差异放大”只需要最大值。
*
* @param [IN] values 采样值。
* @param [IN] radius 邻域半径（窗口 = [i-radius, i+radius]，两端按实际长度）。
* @param [OUT] outMax 邻域最大值（整窗都是 NaN 时为 NaN）。
*/
template <typename T>
void SlidingMax(const std::vector<T>& values, std::size_t radius, std::vector<float>& outMax)
{
const std::size_t count = values.size();
outMax.assign(count, std::numeric_limits<float>::quiet_NaN());
if (count == 0)
{
return;
}
std::deque<std::size_t> maxQueue; // 递减：队首最大。
std::size_t filled = 0;
for (std::size_t index = 0; index < count; ++index)
{
const std::size_t wantHigh = std::min(count - 1, index + radius);
while (filled <= wantHigh)
{
const double incoming = values[filled];
if (std::isfinite(incoming))
{
while (!maxQueue.empty() && values[maxQueue.back()] <= incoming)
{
maxQueue.pop_back();
}
maxQueue.push_back(filled);
}
++filled;
}
const std::size_t low = (index > radius) ? (index - radius) : 0;
while (!maxQueue.empty() && maxQueue.front() < low)
{
maxQueue.pop_front();
}
if (!maxQueue.empty())
{
outMax[index] = static_cast<float>(values[maxQueue.front()]);
}
}
}
} // namespace
void ComputeMovingAverage(const std::vector<double>& values, int radius, std::vector<float>& out)
@@ -978,11 +931,6 @@ namespace jdi
MovingAverageImpl(values, radius, out);
}
void ComputeMovingAverage(const std::vector<float>& values, int radius, std::vector<float>& out)
{
MovingAverageImpl(values, radius, out);
}
namespace
{
template <typename T>
@@ -1067,73 +1015,6 @@ namespace jdi
}
}
}
/**
* @brief 滑动窗口极值：一次求出每个中心点邻域（±radius）内的最小值与最大值。
*
* 两个单调队列（最小值队列递增、最大值队列递减）同步滑动，O(n) 时间，
* 内存只有窗口长度。NaN 不参与（整窗都是 NaN 时输出 NaN）。
*
* @param [IN] values 采样值。
* @param [IN] radius 邻域半径（窗口 = [i-radius, i+radius]，两端按实际长度）。
* @param [OUT] outMin 邻域最小值。
* @param [OUT] outMax 邻域最大值。
*/
template <typename T>
void SlidingExtrema(const std::vector<T>& values, std::size_t radius,
std::vector<float>& outMin, std::vector<float>& outMax)
{
const std::size_t count = values.size();
outMin.assign(count, std::numeric_limits<float>::quiet_NaN());
outMax.assign(count, std::numeric_limits<float>::quiet_NaN());
if (count == 0)
{
return;
}
std::deque<std::size_t> minQueue; // 递增：队首最小。
std::deque<std::size_t> maxQueue; // 递减：队首最大。
std::size_t filled = 0;
for (std::size_t index = 0; index < count; ++index)
{
const std::size_t wantHigh = std::min(count - 1, index + radius);
while (filled <= wantHigh)
{
const double incoming = values[filled];
if (std::isfinite(incoming))
{
while (!minQueue.empty() && values[minQueue.back()] >= incoming)
{
minQueue.pop_back();
}
minQueue.push_back(filled);
while (!maxQueue.empty() && values[maxQueue.back()] <= incoming)
{
maxQueue.pop_back();
}
maxQueue.push_back(filled);
}
++filled;
}
const std::size_t low = (index > radius) ? (index - radius) : 0;
while (!minQueue.empty() && minQueue.front() < low)
{
minQueue.pop_front();
}
while (!maxQueue.empty() && maxQueue.front() < low)
{
maxQueue.pop_front();
}
if (!minQueue.empty())
{
outMin[index] = static_cast<float>(values[minQueue.front()]);
}
if (!maxQueue.empty())
{
outMax[index] = static_cast<float>(values[maxQueue.front()]);
}
}
}
} // namespace
void ComputeMovingAverageIterated(const std::vector<double>& values, int radius, int order,
@@ -1162,8 +1043,54 @@ namespace jdi
}
}
void ComputeDiffAmplify(const std::vector<double>& values, int window, int gain,
std::vector<float>& out)
namespace
{
/**
* @brief 「弱波增强」内部使用的极值点（波峰 / 波谷）。
*/
struct BoostExtremum
{
std::size_t index = 0; /**< 采样下标。 */
double value = 0.0; /**< 采样值。 */
int type = 0; /**< +1 = 波峰，-1 = 波谷。 */
};
/**
* @brief 取用于“识别波峰/波谷”的轻度平滑值。
*
* 直接对原始采样做方向判定时，采样噪声会被当成大量假波峰/波谷，使增强曲线抖动；
* 因此先看一下 5 点滑动平均（半径 2）之后的“形状”。这里按需就地计算，
* 不额外分配与采样数同量级的缓冲。
*
* @param [IN] values 原始采样值。
* @param [IN] index 采样下标。
* @return 轻度平滑后的取值；邻域内没有有效值时返回 NaN。
*/
double BoostShapeAt(const std::vector<double>& values, std::size_t index)
{
const std::size_t count = values.size();
const std::size_t low = (index > 2) ? (index - 2) : 0;
const std::size_t high = std::min(count - 1, index + 2);
double sum = 0.0;
int used = 0;
for (std::size_t i = low; i <= high; ++i)
{
const double value = values[i];
if (std::isfinite(value))
{
sum += value;
++used;
}
}
if (used == 0)
{
return std::numeric_limits<double>::quiet_NaN();
}
return sum / static_cast<double>(used);
}
} // namespace
void ComputeWeakWaveBoost(const std::vector<double>& values, double level, std::vector<float>& out)
{
const std::size_t count = values.size();
out.assign(count, std::numeric_limits<float>::quiet_NaN());
@@ -1172,192 +1099,155 @@ namespace jdi
return;
}
// 窗口点数 X：局部“差异强度”的统计**窗口长度**（点数），窗口 = [i−r, i+r]，
// r = (X−1)/2。窗口长度**应略大于纹波周期的一半**：
// 只有当窗口跨越的相位达到 180° 时，窗口内才必定包含一个波峰或波谷，
// “局部 |交流分量| 的峰值”因而恒等于纹波振幅 A，与相位无关
//（正常区域恒为 A、弱区恒为 A/2，比值恰为 2）；窗口再小就会跟随相位起伏
//（把正常区域的波峰也一起放大），远大于一个周期时又会把弱区与邻近正常区一起统计掉。
// 窗口越短、混叠区（弱区边界各 ±r）越窄，对“只有一两个周期（甚至半周期）变弱”的
// 情形越有效。
const int span = std::max(3, std::min(window, 1000000));
const int strengthRadius = std::max(1, (span - 1) / 2);
// 趋势窗口取局部窗口的 2 倍（≈ 一个完整纹波周期）：只有按整周期取平均，
// 趋势线才恰好是纹波的中心线（交流分量均值为零），待放大的弱区也就**不会**
// 因为自己变“扁”而把趋势线一起拉偏。
const int trendRadius = std::max(1, strengthRadius * 2);
// 包络窗口固定取局部窗口的 8 倍：用来给出“周边本来的振幅范围”，
// 既作为放大基准（中心值）也作为输出的夹取上下界。
const std::size_t envelopeRadius =
static_cast<std::size_t>(std::max(1, std::min(strengthRadius * 8, 16384)));
const double maxGain = static_cast<double>(std::max(1, gain));
// 1) 周边包络：邻域内采样值的最小/最大值（单调队列，O(n)）。
// 邻域**必须明显大于一个纹波周期**，否则包络会跟着纹波起伏，
// 放大后会把相邻正常区域的相位也一并扭曲。
std::vector<float> envMin;
std::vector<float> envMax;
SlidingExtrema(values, envelopeRadius, envMin, envMax);
// 2) 局部差异强度 = 邻域内 |采样值 − 趋势线| 的**最大值**（即局部纹波振幅）。
//
// 这里刻意**不用**另外两种看起来更自然的做法：
// * “|采样值 − 趋势线| 的平均”：趋势线是低频量，会被待放大的弱区本身拉偏，
// 于是弱区周边本来正常的采样点也会被判成“差异偏小”而被一起放大；
// * “原始采样值的峰峰值”：峰峰值要同时覆盖波峰与波谷才与相位无关，
// 这要求窗口跨越 360°，窗口会大到把弱区与邻近正常区平均掉
// （实测一个周期宽的弱区只能恢复三分之一）。
// |交流分量| 的最大值只需要窗口跨越 180°（窗口约半个周期）就与相位无关，
// 既能准确识别弱区，又因为窗口很短而具备足够好的定位精度。
//
// 又因为增益下界恒为 1（见第 4 步），正常区域的增益恰好是 1，
// 输出与输入**逐位相同**，因此对其它数据点真正没有任何影响。
//
// 极值窗口按**实际长度**（端点截断）统计，端点因此会低估振幅、
// 导致增益被高估；这一端点效应由第 4 步的收敛系数消除。
std::vector<float> trend;
ComputeMovingAverage(values, trendRadius, trend);
std::vector<float> strength;
{
// `ac` 只在求局部最大值时用到：单独放在一个作用域里，
// 亿级采样下这一份 100 MB 级的中转数组能尽早归还给系统。
std::vector<float> ac(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) && std::isfinite(trend[index]))
{
ac[index] = static_cast<float>(std::fabs(value - static_cast<double>(trend[index])));
}
}
SlidingMax(ac, static_cast<std::size_t>(strengthRadius), strength);
}
// 3) 目标强度：差异强度的 75 分位。用直方图统计 → O(1) 额外内存，
// 且不会被个别尖峰抬高（用均值会），也不会被最尖处完全主导（用最大值会）。
//
// ⚠️ 统计时**排除首尾的端点收敛区**（见第 4 步）：那里的趋势窗口被截断，
// “|交流分量| 的最大值”整体偏大，会把分位数抬高、导致目标强度偏大。
// 待统计的采样点数不足时退回全段统计。
const std::size_t edgeGuard =
static_cast<std::size_t>(2) * static_cast<std::size_t>(trendRadius);
// 剩下足够多的采样点时才有必要排除端点区（短信号就直接全段统计）。
constexpr std::size_t kEdgeGuardMinimum = 256;
const bool useGuard = (count > edgeGuard * 2 + kEdgeGuardMinimum);
const auto inGuard = [count, edgeGuard, useGuard](std::size_t index)
{
if (!useGuard)
{
return true;
}
return (index >= edgeGuard) && ((count - 1 - index) >= edgeGuard);
};
float maxStrength = 0.0f;
for (std::size_t index = 0; index < count; ++index)
{
const float value = strength[index];
if (inGuard(index) && std::isfinite(value) && value > maxStrength)
{
maxStrength = value;
}
}
if (!(maxStrength > 0.0f))
{
// 完全平坦（或全为 NaN）的信号：无差异可放大，等价于原样输出。
for (std::size_t index = 0; index < count; ++index)
{
const double value = values[index];
if (std::isfinite(value))
{
out[index] = static_cast<float>(value);
}
}
return;
}
constexpr int kBinCount = 2048;
std::vector<int> histogram(static_cast<std::size_t>(kBinCount), 0);
std::size_t sampleCount = 0;
for (std::size_t index = 0; index < count; ++index)
{
const float value = strength[index];
if (!inGuard(index) || !std::isfinite(value))
{
continue;
}
int bin = static_cast<int>(static_cast<double>(value) /
static_cast<double>(maxStrength) * kBinCount);
bin = std::max(0, std::min(bin, kBinCount - 1));
++histogram[static_cast<std::size_t>(bin)];
++sampleCount;
}
double target = static_cast<double>(maxStrength);
if (sampleCount > 0)
{
const std::size_t wanted = (sampleCount * 75) / 100;
std::size_t accumulated = 0;
for (int bin = 0; bin < kBinCount; ++bin)
{
accumulated += static_cast<std::size_t>(histogram[static_cast<std::size_t>(bin)]);
if (accumulated > wanted)
{
// 取桶中心，避免目标强度贴到桶的下边界而整体偏小。
target = (static_cast<double>(bin) + 0.5) / kBinCount *
static_cast<double>(maxStrength);
break;
}
}
}
// 4) 逐点增益并合成输出。
// * 基准 = 趋势线（纹波的中心线，与信号整体同步，纹波在其中上下摆动）；
// * 增益下界为 1 → 局部振幅不比目标值小的采样点**输出与原值逐位相同**
// （基准被 1 倍增益完全消掉，因此对其它数据点没有任何影响）；
// * 放大后的取值再夹到周边包络内 → **任何一点都不会超出原有的振幅范围**
// （尤其重要：被放大区域两侧自身的振幅本来就很大，不应被继续抬升）。
// 先把有效采样原样拷入输出，之后按“极值点之间的平滑偏移”逐点叠加。
for (std::size_t index = 0; index < count; ++index)
{
const double value = values[index];
if (!std::isfinite(value))
if (std::isfinite(value))
{
out[index] = static_cast<float>(value);
}
}
// 增强等级：波峰取左右两个波峰中较小者为 0%、较大者为 100%，
// 目标值 = 较小 + 等级 × (较大 − 较小)（波谷相反）。
const double strength = std::max(0.0, std::min(1.0, level));
// 1) 识别波峰 / 波谷：扫描单调段，方向翻转处的上一个采样点即为极值点。
// 波峰（先升后降）与波谷（先降后升）必然交替出现，因此同类极值就是下标 ±2 的两个。
std::vector<BoostExtremum> extremes;
{
int direction = 0; // 当前单调段方向（+1 上升、-1 下降）。
bool hasPrevious = false;
std::size_t previousIndex = 0;
double previousShape = 0.0;
for (std::size_t index = 0; index < count; ++index)
{
if (!std::isfinite(values[index]))
{
// 无效采样作为断点：不跨越它判定极值。
hasPrevious = false;
continue;
}
const double shape = BoostShapeAt(values, index);
if (!std::isfinite(shape))
{
hasPrevious = false;
continue;
}
if (!hasPrevious)
{
hasPrevious = true;
previousIndex = index;
previousShape = shape;
continue;
}
const int step = (shape > previousShape) ? 1 : ((shape < previousShape) ? -1 : 0);
if (step != 0)
{
if (direction == 0)
{
direction = step;
}
else if (step != direction)
{
// 方向在此翻转：上一个采样点就是极值（原方向向上则为波峰）。
BoostExtremum extreme;
extreme.index = previousIndex;
extreme.value = values[previousIndex];
extreme.type = direction;
extremes.push_back(extreme);
direction = step;
}
}
previousIndex = index;
previousShape = shape;
}
}
if (extremes.size() < 3)
{
// 找不到足够的极值（例如常量或单调信号）：无可增强之处。
return;
}
// 2) 逐个极值点判定“是否偏弱”，并算出它自己的目标偏移量。
const std::size_t extremeCount = extremes.size();
std::vector<double> shift(extremeCount, 0.0);
for (std::size_t k = 2; k + 2 < extremeCount; ++k)
{
const BoostExtremum& current = extremes[k];
const BoostExtremum& left = extremes[k - 2];
const BoostExtremum& right = extremes[k + 2];
if (left.type != current.type || right.type != current.type)
{
continue;
}
const bool hasEnvelope = std::isfinite(envMin[index]) && std::isfinite(envMax[index]);
const double base =
std::isfinite(trend[index]) ? static_cast<double>(trend[index]) : value;
double pointGain = 1.0;
const float local = strength[index];
if (std::isfinite(local) && local > 0.0f)
if (!std::isfinite(current.value) || !std::isfinite(left.value) ||
!std::isfinite(right.value))
{
pointGain = target / static_cast<double>(local);
continue;
}
pointGain = std::max(1.0, std::min(pointGain, maxGain));
// 端点收敛：首尾各 2r 个采样点的**趋势窗口与极值窗口都被截断**
//（趋势窗口半径 2r、极值窗口半径 r），局部振幅与中心线都被系统性估偏。
// 因此这些采样点一律保持原样（增益恰为 1），再在接下来的 2r 个点内
// 平滑过渡到完整增益，避免记录首尾被整片抬升。
//
// ⚠️ 不能靠“镜像延拓”解决：镜像后的窗口覆盖的真实下标集合与截断窗口相同
//（例如 i=16、r=40 时两者都只覆盖真实下标 0..56），因此不会带来任何新信息。
const double taperStart = static_cast<double>(trendRadius);
const double taperSpan = std::max(1.0, static_cast<double>(trendRadius));
const double distanceToEdge =
static_cast<double>(std::min(index, count - 1 - index));
const double taper =
std::max(0.0, std::min(1.0, (distanceToEdge - taperStart) / taperSpan));
pointGain = 1.0 + (pointGain - 1.0) * taper;
double amplified = base + pointGain * (value - base);
if (hasEnvelope)
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);
double destination = 0.0;
if (current.type > 0)
{
amplified = std::max(static_cast<double>(envMin[index]),
std::min(amplified, static_cast<double>(envMax[index])));
// 波峰：低于左右两个波峰的均值 → 判定为弱波，上拉到等级对应的目标值。
if (!(current.value < mean))
{
continue;
}
destination = lower + strength * (upper - lower);
}
out[index] = static_cast<float>(amplified);
else
{
// 波谷：高于左右两个波谷的均值 → 判定为弱波，下拉到等级对应的目标值。
if (!(current.value > mean))
{
continue;
}
destination = upper - strength * (upper - lower);
}
shift[k] = destination - current.value;
}
// 3) 把偏移量平滑地摊到极值点之间的数据点上：
// 相邻两个极值点之间用平滑步进过渡（两端导数为 0，波形不会出现折角），
// 数据首尾则从 0 渐变到最近的极值点偏移，保证端点原样不动。
const auto applySpan = [&values, &out, count](std::size_t begin, std::size_t end,
double beginShift, double endShift)
{
if (end <= begin)
{
if (begin < count && std::isfinite(values[begin]))
{
out[begin] = static_cast<float>(values[begin] + beginShift);
}
return;
}
const double span = static_cast<double>(end - begin);
for (std::size_t index = begin; index <= end; ++index)
{
const double value = values[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);
out[index] = static_cast<float>(value + beginShift * (1.0 - weight) +
endShift * weight);
}
};
applySpan(0, extremes.front().index, 0.0, shift.front());
for (std::size_t k = 0; k + 1 < extremeCount; ++k)
{
applySpan(extremes[k].index, extremes[k + 1].index, shift[k], shift[k + 1]);
}
applySpan(extremes.back().index, count - 1, shift.back(), 0.0);
}
const Lane::MeanFilterItem* Lane::FindMeanFilterItem(const SignalRef& ref) const
@@ -1430,9 +1320,9 @@ namespace jdi
edgeCenterItems.end());
}
const Lane::DiffAmpItem* Lane::FindDiffAmpItem(const SignalRef& ref) const
const Lane::WeakBoostItem* Lane::FindWeakBoostItem(const SignalRef& ref) const
{
for (const DiffAmpItem& item : diffAmpItems)
for (const WeakBoostItem& item : weakBoostItems)
{
if (item.ref == ref)
{
@@ -1442,32 +1332,27 @@ namespace jdi
return nullptr;
}
Lane::DiffAmpItem& Lane::EnsureDiffAmpItem(const SignalRef& ref)
Lane::WeakBoostItem& Lane::EnsureWeakBoostItem(const SignalRef& ref)
{
for (DiffAmpItem& item : diffAmpItems)
for (WeakBoostItem& item : weakBoostItems)
{
if (item.ref == ref)
{
return item;
}
}
DiffAmpItem item;
WeakBoostItem item;
item.ref = ref;
// 默认参数：窗口点数 X = 80（长度）、放大倍数 N = 2。
// 窗口长度需略大于纹波周期的一半（见 ComputeDiffAmplify 的说明），
// 80 点可覆盖周期约 160 采样以内的纹波。
item.points = 80;
item.order = 2;
diffAmpItems.push_back(item);
return diffAmpItems.back();
weakBoostItems.push_back(item);
return weakBoostItems.back();
}
void Lane::RemoveDiffAmpItem(const SignalRef& ref)
void Lane::RemoveWeakBoostItem(const SignalRef& ref)
{
diffAmpItems.erase(
std::remove_if(diffAmpItems.begin(), diffAmpItems.end(),
[&ref](const DiffAmpItem& item) { return item.ref == ref; }),
diffAmpItems.end());
weakBoostItems.erase(
std::remove_if(weakBoostItems.begin(), weakBoostItems.end(),
[&ref](const WeakBoostItem& item) { return item.ref == ref; }),
weakBoostItems.end());
}
int FindNearestSample(const DataFile& file, double time)
@@ -1714,7 +1599,7 @@ namespace jdi
};
purgeRefs(lane.meanFilterItems);
purgeRefs(lane.edgeCenterItems);
purgeRefs(lane.diffAmpItems);
purgeRefs(lane.weakBoostItems);
}
// 被移除信号若独占了某个网格，该网格随之消失（与取消勾选的行为一致）。
m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
@@ -2006,18 +1891,19 @@ namespace jdi
lane.edgeCenterPanelOpen = source.edgeCenterPanelOpen;
lane.edgeCenterPanelX = source.edgeCenterPanelX;
lane.edgeCenterPanelY = source.edgeCenterPanelY;
lane.diffAmp = source.diffAmp;
lane.diffAmpPanelOpen = source.diffAmpPanelOpen;
lane.diffAmpPanelX = source.diffAmpPanelX;
lane.diffAmpPanelY = source.diffAmpPanelY;
lane.weakBoost = source.weakBoost;
lane.weakBoostLevel = source.weakBoostLevel;
lane.weakBoostPanelOpen = source.weakBoostPanelOpen;
lane.weakBoostPanelX = source.weakBoostPanelX;
lane.weakBoostPanelY = source.weakBoostPanelY;
lane.meanFilter = source.meanFilter;
lane.meanFilterPanelOpen = source.meanFilterPanelOpen;
lane.meanFilterPanelX = source.meanFilterPanelX;
lane.meanFilterPanelY = source.meanFilterPanelY;
// 拆分后每个子网格只保留自己那个信号的均值滤波 / 中心轴 / 差异放大条目。
// 拆分后每个子网格只保留自己那个信号的均值滤波 / 中心轴 / 弱波增强条目。
lane.meanFilterItems.clear();
lane.edgeCenterItems.clear();
lane.diffAmpItems.clear();
lane.weakBoostItems.clear();
for (const Lane::MeanFilterItem& item : source.meanFilterItems)
{
if (item.ref == ref)
@@ -2032,11 +1918,11 @@ namespace jdi
lane.edgeCenterItems.push_back(item);
}
}
for (const Lane::DiffAmpItem& item : source.diffAmpItems)
for (const Lane::WeakBoostItem& item : source.weakBoostItems)
{
if (item.ref == ref)
{
lane.diffAmpItems.push_back(item);
lane.weakBoostItems.push_back(item);
}
}
lane.signals.push_back(ref);
@@ -2093,7 +1979,7 @@ namespace jdi
++item.ref.signalIndex;
}
}
for (Lane::DiffAmpItem& item : lane.diffAmpItems)
for (Lane::WeakBoostItem& item : lane.weakBoostItems)
{
if (item.ref.fileIndex == fileIndex && item.ref.signalIndex >= insertPos)
{