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

「弱峰调整」升级：三组识别规则 + 滑动条 ±400% 梯度驱动

Browse Source 
一、三组识别规则（以波峰 k 为例；L/l = 左相邻波峰/波谷，r/R = 右相邻波谷/波峰；
   leftMean = (L+l)/2，rightMean = (r+R)/2）
- 第一类：v < leftMean 且 v < rightMean（两侧的"相邻峰+相邻谷"均值都要低于）
- 第二类：v < leftMean 或 v < rightMean（放宽为"或"）
- 第三类：v < L 且 v < R（只与左右同类极值比较，最宽松）
波谷把"低于"换成"高于"、min/max 互换。三组不是包含关系（第三类不蕴含第二类），
因此确实存在"只满足第三类"的点。

二、梯度驱动（滑动条 |a| ∈ [0,400%]；每组自身仍是 ±200%）
  0–100%   ：只有第一类在动（0–100%）
  100–200% ：第一类 100–200%，第二类开始 0–100%
  200–300% ：第一类到上限，第二类 100–200%，第三类开始 0–100%
  300–400% ：前两类到上限，第三类 100–200%
负值完全对称。实现：first = sign*min(|a|,2)、second = sign*clamp(|a|-1,0,2)、
third = sign*clamp(|a|-2,0,2)；某点同时满足多组时取幅度绝对值最大的一组（= 最严格的那组）。

三、每组自身的目标值映射（±200%）
  0 – +100%  ：当前值 → 左右同类极值中较温和的一侧（波峰取较低者、波谷取较高者）
  +100 – +200%：该侧 → 左右同类极值的均值（不再是"较大的那个"）
  0 – -100%  ：当前值 → 相邻异类极值中较近的一个（波峰取较高的波谷、波谷取较低的波峰）
  -100 – -200%：该侧 → 相邻异类极值的均值（不再是"最小的那个"）
负幅度的"不得反向增强"夹取保持不变；相邻极值之间的 smoothstep 平滑偏移逐字未改。

四、界面
滑动条量程 -400% – +400%（0 在正中间，kWeakPeakSliderScale = 4.0）；数值列按 "+400%" 取宽；
右侧数值始终带符号。

五、验证（全部离屏，不占用鼠标/键盘/屏幕）
- uitest 463/463：第一类点（弱峰 520、相邻峰 620/640）0/50/100/150/200% → 520/570/620/625/630；
  弱谷 580 → 580/540/500/500/500，负值 590/600/605/610；
  只满足第二类的峰 130：100% 不动、150/200/250/300/400% → 140/150/162.5/175/175；
  负值 -100% 不动、-150/-200/-250/-300% → 115/100/97.5/95；
  只满足第三类的峰 195：200% 不动、250/300/400% → 197.5/200/200；
  第一类点 200% 已达上限（400% 不再变化）；±400% 夹取；默认 0%；滑块中间 = 0%、
  两端 = ±400%、轨道 3/4 处 ≈ +200%。
- [Y] 端到端：合成 ripple 弱峰区间 20 → 70（50% 幅度，健康 120）。
- panperf PASS；layercheck clobbers=0/24、pan frames wrong=0/4；cursorcheck 30/30；
  dragcheck 0 绘制错误；make clean && make all 零警告。
This commit is contained in:
DeepSeek V4.1 Flash committed 2026-10-12 19:38:46 +08:00
1 parent 14b60f5d9e
commit 59a84ba126
6 files changed
+217 -111
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Utilities/Inc/DataModel.hpp
+29 -25
View File
@@ -377,7 +377,7 @@ namespace jdi
* @brief 「弱峰调整」中某个信号自己的参数条目。
*
* 与「均值滤波」完全一致：**每个被勾选的信号各自持有参数**
*（增强等级 0–200% + 迭代次数 N），因此同一网格内不同信号可以使用不同强度。
*（调整幅度 -400% – +400% + 迭代次数 N），因此同一网格内不同信号可以使用不同强度。
*
* ⚠️ `iterations` 的**上限由用户自己设定**（`maxIterations`）：面板上「迭代次数 N」
* 滑块的量程就是 `1 … maxIterations`，点击滑块右侧的数值可以把该上限改成其它正整数。
@@ -385,7 +385,7 @@ namespace jdi
struct WeakPeakItem
{
SignalRef ref; /**< 目标信号。 */
int amountPercent = 0; /**< 调整幅度（-200–200，默认 0 = 不改动）。 */
int amountPercent = 0; /**< 调整幅度（-400–400，默认 0 = 不改动）。 */
int iterations = 1; /**< 迭代次数 N（1 … `maxIterations`）。 */
int maxIterations = 10; /**< 「迭代次数 N」滑块的上限（用户可在面板上修改，恒 ≥ 1）。 */
};
@@ -521,7 +521,7 @@ namespace jdi
/**
* @brief 参与弱峰调整预览的信号及其**各自的参数**（只包含被勾选的信号）。
*
* 参数（等级 0–200% + 迭代次数 N）按信号保存，与「均值滤波」的实现方式一致：
* 参数（调整幅度 -400% – +400% + 迭代次数 N）按信号保存，与「均值滤波」的实现方式一致：
* 同一网格内不同信号可以使用不同的增强强度，也可以分别「构建为新信号」。
*/
std::vector<WeakPeakItem> weakPeakItems;
@@ -598,36 +598,40 @@ namespace jdi
* 本算法**不做任何前置滤波**：需要平滑时用户可以先用「均值滤波」构建一条
* 滤波后的信号，再对它做弱峰调整。极值点直接在输入采样上识别。
*
* 「调整幅度」滑动条的量程是 **-400% – +400%**，它按"梯度"同时驱动**三组识别规则**：
* 越宽松的规则参与得越晚，同一滑动条位置上的幅度越小：
* | 滑动条 | 第一类（严格） | 第二类（或） | 第三类（宽松） |
* | --- | --- | --- | --- |
* | 0 – 100% | 0 – 100% | — | — |
* | 100 – 200% | 100 – 200% | 0 – 100% | — |
* | 200 – 300% | 200%（上限） | 100 – 200% | 0 – 100% |
* | 300 – 400% | 200%（上限） | 200%（上限） | 100 – 200% |
* （负值完全对称；某个极值若同时满足多组规则，取**幅度绝对值最大**的那一组。）
*
* 单阶处理（全 O(n)）：
* 1. **识别趋势与极值**：扫描单调段，方向发生翻转处的上一个采样点即为
* 波峰（先升后降）或波谷（先降后升）；波峰与波谷交替出现。
* 2. **判定“弱”**（用户明确定义，正/负幅度一致；与旧实现不同）：
* * 波峰 k 必须**同时**低于「左侧相邻的第一个波谷(k-1) 与第一个波峰(k-2) 的均值」
* 与「右侧相邻的第一个波谷(k+1) 与第一个波峰(k+2) 的均值」；
* * 波谷 k 必须**同时**高于上述两个均值。
* 即与“两侧各自相邻的一个波峰 + 一个波谷”的平均水平比较。
* 3. **目标值**（`amount` = 调整幅度，-2 – +2，对应面板上的 -200% – +200%）：
* * **正幅度（增强）**：以**同类**极值（k±2）为参照。
* 波峰：较小者记为 `lower`、较大者记为 `upper`；
* 0 ≤ a ≤ 1 → 目标 = 当前值 + a × (`lower` − 当前值)；
* 1 < a ≤ 2 → 目标 = `lower` + (a − 1) × (`upper` − `lower`)。
* 波谷：较大者记为 `upper`、较小者记为 `lower`；
* 0 ≤ a ≤ 1 → 目标 = 当前值 + a × (`upper` − 当前值)；
* 1 < a ≤ 2 → 目标 = `upper` − (a − 1) × (`upper` − `lower`)。
* * **负幅度（削弱）**：以相邻的**异类**极值（k±1）为参照。
* 令 `near` = 较靠近当前值的那个（波峰 → 较高的波谷；波谷 → 较低的波峰）、
* `far` = 另一个：
* -1 ≤ a < 0 → 目标 = 当前值 + |a| × (`near` − 当前值)；
* -2 ≤ a < -1 → 目标 = `near` + (|a| − 1) × (`far` − `near`)。
* 即 **-100% 把弱峰拉到相邻异类极值中较近的那个**、**-200% 拉到较远的那个**
* （波形被压平甚至抹除）。削弱**不会反向增强**（目标被夹在"不越过当前值"的一侧）。
* 2. **三组识别规则**（以波峰 k 为例；`L` = 左侧相邻第一个波峰、`l` = 左侧相邻第一个波谷，
* `r` = 右侧相邻第一个波谷、`R` = 右侧相邻第一个波峰）：
* * 第一类：`v < (L+l)/2` **且** `v < (r+R)/2`（两侧均值都要满足）；
* * 第二类：`v < (L+l)/2` **或** `v < (r+R)/2`（放宽为"或"）；
* * 第三类：`v < L` **且** `v < R`（只与左右同类极值比较）。
* 波谷把"低于"换成"高于"、把"且/或"的上下界互换即可。
* 3. **目标值**（每一组的幅度 `a` 都在 -2 – +2，对应其自身的 -200% – +200%）：
* * `0 – +100%`：当前值 → 左右**同类**极值中**较温和**的一侧
* （波峰取较低的波峰、波谷取较高的波谷）；
* * `+100 – +200%`：该侧 → 左右同类极值的**均值**；
* * `0 – -100%`：当前值 → 相邻**异类**极值中**较近**的一个
* （波峰取较高的波谷、波谷取较低的波峰）；
* * `-100 – -200%`：该侧 → 相邻异类极值的**均值**。
* 削弱**不会反向增强**（目标被夹在"不越过当前值"的一侧）。
* 4. **平滑偏移**：极值点本身取其目标值，两侧的数据点按相邻两个极值点的偏移量
* 平滑过渡（平滑步进，两端导数为 0），使波形整体趋势不变、只在弱峰附近被推回。
*
* 正常周期的极值不满足条件、偏移量恒为 0，因此输出与输入逐位相同。
* 不属于任何一类规则点的极值偏移量恒为 0，因此输出与输入逐位相同。
*
* @param [IN] values 原始采样值。
* @param [IN] amount 调整幅度（-2 – +2，对应 -200% – +200%，超出范围会被夹取；0 = 完全不动）。
* @param [IN] amount 调整幅度（-4 – +4，对应 -400% – +400%，超出范围会被夹取；0 = 完全不动）。
* @param [IN] iterations 迭代次数 N（重复应用次数，至少为 1）。
* @param [OUT] out 输出数组（长度与 values 相同；原值为 NaN 处保持 NaN）。
*/
Utilities/Src/DataModel.cpp
+99 -61
View File
@@ -1055,19 +1055,34 @@ namespace jdi
int type = 0; /**< +1 = 波峰，-1 = 波谷。 */
};
/**
* @brief 三组识别规则各自的调整幅度（每一组都在 -2 – +2，即面板上的 -200% – +200%）。
*
* 滑动条的 ±400% 会按"梯度"同时驱动三组规则（见 `ComputeWeakPeakAdjust`）：
* 越宽松的规则参与得越晚、在同一滑动条位置上的幅度越小。
*/
struct WeakPeakAmounts
{
double first = 0.0; /**< 第一类（严格：两侧均值都要满足）。 */
double second = 0.0; /**< 第二类（其中一侧满足即可）。 */
double third = 0.0; /**< 第三类（更宽松：只与左右同类极值比较）。 */
};
/**
* @brief 「弱峰调整」的单阶处理：把偏弱的波峰上拉 / 偏弱的波谷下拉，
* 或（负幅度）把弱峰本身削弱、压平。
*
* **不做任何前置滤波**（需要平滑时用户可以先用「均值滤波」构建一条滤波后的信号）：
* 极值点直接在输入采样上通过单调段的方向翻转识别。
* 极值点直接在输入采样上通过单调段的方向翻转识别。三组识别规则（见 `WeakPeakAmounts`）
* 各自有自己的幅度；某个极值若同时满足多组规则，取**幅度绝对值最大**的那一组
*（= 最严格的那一组），这样"越严格越先被推到目标值"。
*
* @param [IN] input 本阶的输入采样值。
* @param [IN] amount 调整幅度（-2 – +2，已夹取；0 = 完全不动）。
* @param [IN] amounts 三组规则的调整幅度（各 -2 – +2，已夹取；0 = 该组不动）。
* @param [OUT] output 本阶的输出（长度与 input 相同；原值为 NaN 处保持 NaN）。
* @return 确实有采样点被改动返回 true；完全无弱峰时返回 false。
* @return 确实有采样点被改动返回 true；没有任何点需要调整时返回 false。
*/
bool ApplyWeakPeakStage(const std::vector<float>& input, double amount,
bool ApplyWeakPeakStage(const std::vector<float>& input, const WeakPeakAmounts& amounts,
std::vector<float>& output, std::vector<PeakExtremum>& extremes)
{
const std::size_t count = input.size();
@@ -1141,7 +1156,7 @@ namespace jdi
return false;
}
// 2) 逐个极值点判定“是否偏弱”，并算出它自己的目标偏移量。
// 2) 逐个极值点判定它属于哪几类规则点，并算出它自己的目标偏移量。
const std::size_t extremeCount = extremes.size();
thread_local std::vector<double> shiftBuffer;
std::vector<double>& shift = shiftBuffer;
@@ -1160,73 +1175,86 @@ namespace jdi
{
continue;
}
const double lower = std::min(left.value, right.value);
const double upper = std::max(left.value, right.value);
// 「是否偏弱」的判定（用户明确定义，正/负幅度**完全一致**）：
// 波峰：必须**同时**低于
// 「左侧相邻的第一个波谷与第一个波峰的均值」(= k-1 与 k-2 的均值) 与
// 「右侧相邻的第一个波谷与第一个波峰的均值」(= k+1 与 k+2 的均值)；
// 波谷：必须**同时**高于上述两个均值。
// 即：与"两侧各自相邻的一个波峰+一个波谷"的平均水平比较，
// 而不是旧实现只与左右两个**同类**极值比较。
const PeakExtremum& leftNear = extremes[k - 1];
const PeakExtremum& rightNear = extremes[k + 1];
if (leftNear.type == current.type || rightNear.type == current.type)
// 相邻的**异类**极值（波峰旁边的波谷 / 波谷旁边的波峰）。
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(leftNear.value) || !std::isfinite(rightNear.value))
if (!std::isfinite(nearLeft.value) || !std::isfinite(nearRight.value))
{
continue;
}
const double leftMean = (left.value + leftNear.value) * 0.5;
const double rightMean = (rightNear.value + right.value) * 0.5;
const bool weak = (current.type > 0) ? ((current.value < leftMean) && (current.value < rightMean))
: ((current.value > leftMean) && (current.value > rightMean));
if (!weak)
const bool isPeak = (current.type > 0);
// 「左侧/右侧相邻的一个同类极值 + 一个异类极值」的均值。
const double leftMean = (left.value + nearLeft.value) * 0.5;
const double rightMean = (nearRight.value + right.value) * 0.5;
// 同类极值里"较温和"的一侧：波峰取较低者、波谷取较高者。
const double milderSame = isPeak ? std::min(left.value, right.value)
: std::max(left.value, right.value);
const double meanSame = (left.value + right.value) * 0.5;
// 异类极值里"较近"的一个：波峰取较高的波谷、波谷取较低的波峰。
const double nearerOpposite = isPeak ? std::max(nearLeft.value, nearRight.value)
: std::min(nearLeft.value, nearRight.value);
const double meanOpposite = (nearLeft.value + nearRight.value) * 0.5;
// 三组识别规则（以弱峰为例，弱谷把"低于"换成"高于"、max/min 互换）：
// 第一类：**同时**低于左右两侧的（相邻同类极值 + 相邻异类极值）均值；
// 第二类：低于其中**任意一侧**的该均值（从"且"放宽为"或"）；
// 第三类：只与左右**同类**极值比较 —— 低于左右两个同类极值即算弱峰。
const bool firstClass = isPeak ? ((current.value < leftMean) && (current.value < rightMean))
: ((current.value > leftMean) && (current.value > rightMean));
const bool secondClass = isPeak ? ((current.value < leftMean) || (current.value < rightMean))
: ((current.value > leftMean) || (current.value > rightMean));
const bool thirdClass = isPeak ? ((current.value < left.value) && (current.value < right.value))
: ((current.value > left.value) && (current.value > right.value));
// 同时满足多组时取**幅度绝对值最大**的那一组（= 最严格的那一组先被推到目标值）。
double amount = 0.0;
if (firstClass)
{
// 不是弱峰：本极值点不动。
continue;
amount = amounts.first;
}
if (secondClass && std::fabs(amounts.second) > std::fabs(amount))
{
amount = amounts.second;
}
if (thirdClass && std::fabs(amounts.third) > std::fabs(amount))
{
amount = amounts.third;
}
if (amount == 0.0)
{
continue; // 不需要调整
}
double destination = current.value;
if (amount >= 0.0)
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));
}
// ---- 正幅度（增强）----
// 0 – 100%：当前值 → 左右**同类**极值中较温和的一侧（波峰取较低者、波谷取较高者）；
// 100 – 200%：该侧 → 左右**同类**极值的**均值**。
// ⚠️ 波峰从 `milderSame` 走向 `meanSame`（向上）、波谷同样从 `milderSame`
// 走向 `meanSame`（此时 `meanSame` 可能比 `milderSame` **低**），
// 即两者的插值方向一致（都是"milderSame → meanSame"），无需分别取符号。
destination = (amount <= 1.0)
? (current.value + amount * (milderSame - current.value))
: (milderSame + (amount - 1.0) * (meanSame - milderSame));
}
else
{
// ---- 负幅度（削弱）----
// 参照物为相邻的**异类**极值（波峰看相邻波谷、波谷看相邻波峰），
// 并且"较近的那个"对波峰是较高的波谷、对波谷是较低的波峰。
const double nearValue = (current.type > 0) ? std::max(leftNear.value, rightNear.value)
: std::min(leftNear.value, rightNear.value);
const double farValue = (current.type > 0) ? std::min(leftNear.value, rightNear.value)
: std::max(leftNear.value, rightNear.value);
// 0 – -100%：当前值 → 相邻**异类**极值中较近的一个
// （波峰取较高的波谷、波谷取较低的波峰）；
// -100 – -200%：该侧 → 相邻异类极值的**均值**。
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)
? (current.value + magnitude * (nearerOpposite - current.value))
: (nearerOpposite +
(magnitude - 1.0) * (meanOpposite - nearerOpposite));
// ⚠️ 削弱**不得反向增强**：目标被夹在"不越过当前值"的一侧。
if (isPeak)
{
destination = std::min(destination, current.value);
}
@@ -1314,14 +1342,24 @@ namespace jdi
// 每一阶以上一阶的结果为输入。一阶时改定量已严格等于「幅度」对应的目标值；
// 多次迭代时相邻的弱峰会互相抬高彼此的基准，从而把较宽的弱峰区逐步恢复（或削弱）。
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));
// 滑动条量程 ±400%（`amount` = 百分比 / 100，即 -4 – +4），按"梯度"同时驱动三组规则：
// 第一类：始终参与，幅度 = clamp(|a|, 0, 2)；
// 第二类：|a| > 100% 起参与，幅度 = clamp(|a| - 1, 0, 2)；
// 第三类：|a| > 200% 起参与，幅度 = clamp(|a| - 2, 0, 2)。
// 于是滑动条 0–100% 只有第一类在动；100–200% 第一类走完 100–200%、第二类开始走 0–100%；
// 200–300% 第一类已到上限、第二类走 100–200%、第三类开始走 0–100%；
// 300–400% 前两类都已到上限，只有第三类在走 100–200%。负值完全对称。
const double clamped = std::max(-4.0, std::min(4.0, amount));
const double magnitude = std::fabs(clamped);
const double sign = (clamped < 0.0) ? -1.0 : 1.0;
WeakPeakAmounts amounts;
amounts.first = sign * std::min(magnitude, 2.0);
amounts.second = sign * std::max(0.0, std::min(2.0, magnitude - 1.0));
amounts.third = sign * std::max(0.0, std::min(2.0, magnitude - 2.0));
std::vector<float>& next = nextBuffer;
for (int stage = 0; stage < stages; ++stage)
{
if (!ApplyWeakPeakStage(current, clamped, next, extremesBuffer))
if (!ApplyWeakPeakStage(current, amounts, next, extremesBuffer))
{
// 这一阶没有任何采样点需要调整：后续迭代次数也不会再有变化，提前结束。
break;