Multi-Timeframe Support / Resistance Lines

yuanyouli88 · study · 1256 行 · 点赞 15 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
// ============================================================================
//  自动支撑 / 压力线  (S/R Lines)
//  源码来源: scripts/draw_kline_srlines.mjs (V7 自动支撑/压力线)
// ----------------------------------------------------------------------------
//  算法与 JS 版逐条对齐:
//   1. 特征预计算:TR / ATR(SMA) / 成交量均值(20) / 上下影线占比与深度
//   2. 候选点  :① 左右各 w 根确认的摆动高低点
//                ② 最近 30 根补充 w=2 的摆动点(quality < 0.35 丢弃)
//                ③ Rejection 候选(同侧影线占比 + 深度达标的非摆动 K 线)
//   3. 分边    :默认按价位相对现价(上方=压力 / 下方=支撑);可选「按摆动类型」
//   4. 聚类    :按价格升序贪心合并,容差 = max(全局下限, 点ATR×倍数, 簇ATR×倍数);
//                簇心与簇 ATR 取成员中位数;成员数不足 min-touches 的簇丢弃
//   5. 评分    :强度 = 触碰25 + 拒绝20 + 反应15 + 反转15 + 量能5 + 突破回测10 + 摆动质量10
//                显示分 = (1-距离权重)×强度 + 距离权重×距离分(越近越大)
//   6. 选择    :距现价过滤 → 近邻去重 → 每侧按显示分取前 N → 编号
//
//  周期(本版新增):
//   • 数据来源可选:当前周期 / 日线 / 4小时 / 1小时 / 15分钟 / 多周期合并。
//   • HTF 一律用 request.security(..., lookahead=barmerge.lookahead_off):
//     只取「已收线」的高周期K线,不会因未来数据重绘;每根高周期K线只入队一次。
//   • 多周期合并:各周期各跑一遍完整识别,再按价差容差跨周期聚类,
//     同一价位被 N 个周期同时认可 → 强度 + (N-1)×共振加分,触碰数累加,时效取最近。
//   • 高周期低于图表周期时该档不可用(Pine 取不到更低周期),自动跳过并在信息表提示。
//
//  Pine 特性导致的差异(非逻辑改动):
//   • JS 运行那一刻算一次画静态线;Pine 每根 bar 按同样的尾部窗口重算,线随行情滚动更新。
//   • 归组 / 周期可见性属于绘图对象 API 能力,Pine 无对应物;突破层位用 alert() 替代。
//   • 历史取数走自维护数组(下标 == 队列内序号),避免动态历史偏移的 history buffer 越界。
// ============================================================================
 
indicator("多周期支撑压力线 SR", overlay=true, max_bars_back=500,
     max_lines_count=120, max_labels_count=120, max_boxes_count=60)
 
// ============================== 参数 ==============================
gD = "识别参数"
lookback     = input.int(250, "回看根数 (--bars)", minval=30, maxval=1000, step=10, group=gD,
     tooltip="每个参与计算的周期各取最近 N 根")
swingWin     = input.int(5, "摆动点窗口 (--window)", minval=2, maxval=20, group=gD)
atrLen       = input.int(14, "ATR 周期 (--atr-len)", minval=2, maxval=100, group=gD)
atrMult      = input.float(0.50, "聚类 Zone 半宽 ATR 倍数 (--atr-mult)", minval=0.01, maxval=3, step=0.05, group=gD)
reactionBars = input.int(12, "Reaction 观察窗口 (--reaction-bars)", minval=2, maxval=60, group=gD)
revBars      = input.int(24, "Reversal 观察窗口 (--rev-bars)", minval=4, maxval=120, group=gD)
revATR       = input.float(6.0, "Reversal 满分位移 ATR 倍数 (--rev-atr)", minval=0.5, maxval=20, step=0.5, group=gD)
recencyDays  = input.float(0.0, "时效衰减天数 (--recency-days, 0=自动=跨度/3)", minval=0, maxval=365, step=1, group=gD)
 
gT = "周期"
tfMode   = input.string("当前周期", "数据来源", options=["当前周期", "日线", "4小时", "1小时", "15分钟", "多周期合并"],
     group=gT, tooltip="选「多周期合并」时,用下面 5 个开关挑选参与计算的周期")
mtfCur   = input.bool(true,  "多周期:含当前周期", group=gT)
mtfD     = input.bool(true,  "多周期:日线", group=gT)
mtf4H    = input.bool(true,  "多周期:4小时", group=gT)
mtf1H    = input.bool(false, "多周期:1小时", group=gT)
mtf15m   = input.bool(false, "多周期:15分钟", group=gT)
mtfTol   = input.float(0.5, "跨周期合并价差容差 %", minval=0.05, maxval=5, step=0.05, group=gT,
     tooltip="不同周期算出的层位,价差在此容差内视为同一层")
mtfBonus = input.float(10, "每多 1 个周期共振的强度加分", minval=0, maxval=30, step=1, group=gT)
 
gR = "候选 / 拒绝"
useRejections = input.bool(true, "启用 Rejection 候选 (--rejections)", group=gR)
rejWick       = input.float(0.40, "同侧影线占振幅比例 (--rej-wick)", minval=0.05, maxval=0.95, step=0.05, group=gR)
rejATR        = input.float(0.30, "影线深度至少 ATR 倍数 (--rej-atr)", minval=0.01, maxval=3, step=0.05, group=gR)
rejHalf       = input.float(0.25, "Rejection 统计 zone 半宽 ATR (--rej-half)", minval=0.05, maxval=2, step=0.05, group=gR)
rejPrior      = input.int(5, "Rejection 贝叶斯先验样本数 (--rej-prior)", minval=0, maxval=50, group=gR)
 
gS = "评分"
touchCurve  = input.string("u", "触碰评分曲线 (--touch-curve)", options=["u", "mono"], group=gS)
touchPeak   = input.int(3, "倒U峰值 (--touch-peak)", minval=1, maxval=7, group=gS)
wickWeight  = input.float(0.5, "SwingQuality 中影线权重 (--wick-weight)", minval=0, maxval=1, step=0.05, group=gS)
wickFull    = input.float(0.6, "影线满分比例 (--wick-full)", minval=0.05, maxval=1, step=0.05, group=gS)
breakoutATR = input.float(0.50, "Breakout 阈值 ATR (--breakout-atr)", minval=0.01, maxval=5, step=0.05, group=gS)
retestATR   = input.float(0.35, "Retest Zone ATR (--retest-atr)", minval=0.01, maxval=5, step=0.05, group=gS)
strongScore = input.float(60, "强等级门槛 (--strong-score)", minval=0, maxval=100, step=1, group=gS)
minTouches  = input.int(2, "最少有效触碰 (--min-touches)", minval=1, maxval=10, group=gS)
onlyStrong  = input.bool(false, "只画强及以上 (--only-strong)", group=gS)
 
gV = "选择 / 显示"
maxLines    = input.int(6, "每侧最多线数 (--max)", minval=1, maxval=20, group=gV)
nearPct     = input.float(0.15, "距现价过滤 % (--near)", minval=0, maxval=5, step=0.05, group=gV)
mergePct    = input.float(0.10, "近邻去重 % (--merge-near)", minval=0, maxval=5, step=0.05, group=gV)
distWeight  = input.float(0.4, "显示分中距离权重 (--dist-weight)", minval=0, maxval=1, step=0.05, group=gV)
rankBy      = input.string("dist", "编号顺序 (--rank-by)", options=["dist", "rel", "str", "off"], group=gV)
sideBySwing = input.bool(false, "side 按摆动类型 (--side-by-swing)", group=gV)
showZone    = input.bool(false, "画 Zone 背景带", group=gV)
leftBars    = input.int(60, "向左延伸根数", minval=0, maxval=500, group=gV)
extendBars  = input.int(50, "向右延伸根数", minval=0, maxval=500, group=gV)
lineWidth   = input.int(1, "线宽", minval=1, maxval=4, group=gV)
lineStyle   = input.string("虚线", "线型", options=["实线", "点线", "虚线"], group=gV)
useCustom   = input.bool(false, "统一使用下面的颜色 (--color)", group=gV)
custColor   = input.color(#FF3B30, "统一颜色", group=gV)
colStrong   = input.color(#FF3B30, "极强 / 强 颜色", group=gV)
colMid      = input.color(#4CAF50, "一般 颜色", group=gV)
colWeak     = input.color(#FF9500, "弱 颜色", group=gV)
showTable   = input.bool(true, "显示层位信息表", group=gV)
 
gA = "告警"
alertOn = input.bool(false, "突破层位时发送 alert", group=gA)
 
// ============================== 数据队列 ==============================
// 每个周期一套队列;每根K线占 STRIDE 个字段位,打包进一个 array<float>
STRIDE = 12
F_T   = 0     // 开盘时间(ms)
F_H   = 1
F_L   = 2
F_C   = 3
F_V   = 4
F_TR  = 5
F_ATR = 6
F_AV  = 7     // 成交量均值(20)
F_WH  = 8
F_WL  = 9
F_DH  = 10
F_DL  = 11
 
VOL_LEN = 20
 
var array<float> qCur = array.new_float(0)
var array<float> qD   = array.new_float(0)
var array<float> qH4  = array.new_float(0)
var array<float> qH1  = array.new_float(0)
var array<float> qM15 = array.new_float(0)
 
fq(array<float> q, int i, int f) => array.get(q, i * STRIDE + f)
 
// 入队一根K线:顺带算好 TR / ATR(SMA) / 量能均值 / 上下影线特征
f_push(array<float> q, float tv, float o, float h, float l, float c, float v) =>
    int n = array.size(q) / STRIDE
    float pc = n > 0 ? fq(q, n - 1, F_C) : c
    float tr = math.max(h - l, math.max(math.abs(h - pc), math.abs(l - pc)))
    float rg = math.max(h - l, 1e-12)
    float bt = math.max(o, c)
    float bb = math.min(o, c)
    float dh = math.max(0.0, h - bt)
    float dl = math.max(0.0, bb - l)
    float vv = na(v) ? 0.0 : math.max(0.0, v)
    float s = tr
    int m = 1
    for j = 0 to atrLen - 2
        int k = n - 1 - j
        if k >= 0
            s += fq(q, k, F_TR)
            m += 1
    float atr = m >= atrLen ? s / atrLen : na
    float s2 = vv
    int m2 = 1
    for j = 0 to VOL_LEN - 2
        int k = n - 1 - j
        if k >= 0
            s2 += fq(q, k, F_V)
            m2 += 1
    float av = m2 >= VOL_LEN ? s2 / VOL_LEN : na
    array.push(q, tv)
    array.push(q, h)
    array.push(q, l)
    array.push(q, c)
    array.push(q, vv)
    array.push(q, tr)
    array.push(q, atr)
    array.push(q, av)
    array.push(q, math.min(1.0, dh / rg))
    array.push(q, math.min(1.0, dl / rg))
    array.push(q, dh)
    array.push(q, dl)
 
// 只保留末尾 keep 个字段位(整条队列重建一次,摊薄开销)
f_trim(array<float> q, int keep) =>
    array<float> t = array.new_float(0)
    int n = array.size(q)
    int st = math.max(0, n - keep)
    if n > st
        for z = st to n - 1
            array.push(t, array.get(q, z))
    t
 
// ---- 当前周期(bar_index 幂等守卫:实时bar重复执行不会重复入队)----
var int lastBar = -1
if bar_index != lastBar
    lastBar := bar_index
    f_push(qCur, na(time) ? 0.0 : time, open, high, low, close, volume)
 
// ---- 高周期:只取已收线的高周期K线 ----
int secChart = timeframe.in_seconds(timeframe.period)
bool avD  = timeframe.in_seconds("D")   >= secChart
bool av4H = timeframe.in_seconds("240") >= secChart
bool av1H = timeframe.in_seconds("60")  >= secChart
bool av15 = timeframe.in_seconds("15")  >= secChart
 
string tfD  = avD  ? "D"   : timeframe.period
string tf4H = av4H ? "240" : timeframe.period
string tf1H = av1H ? "60"  : timeframe.period
string tf15 = av15 ? "15"  : timeframe.period
 
[tsD, oD, hD, lD, cD, vD] = request.security(syminfo.tickerid, tfD,
     [time, open, high, low, close, volume], barmerge.gaps_off, barmerge.lookahead_off)
[ts4, o4, h4, l4, c4, v4] = request.security(syminfo.tickerid, tf4H,
     [time, open, high, low, close, volume], barmerge.gaps_off, barmerge.lookahead_off)
[ts1, o1, h1, l1, c1, v1] = request.security(syminfo.tickerid, tf1H,
     [time, open, high, low, close, volume], barmerge.gaps_off, barmerge.lookahead_off)
[ts5, o5, h5, l5, c5, v5] = request.security(syminfo.tickerid, tf15,
     [time, open, high, low, close, volume], barmerge.gaps_off, barmerge.lookahead_off)
 
var float pdD = na
var float pd4 = na
var float pd1 = na
var float pd5 = na
 
if avD and not na(tsD) and not na(cD) and (na(pdD) or tsD != pdD)
    pdD := tsD
    f_push(qD, tsD, oD, hD, lD, cD, vD)
if av4H and not na(ts4) and not na(c4) and (na(pd4) or ts4 != pd4)
    pd4 := ts4
    f_push(qH4, ts4, o4, h4, l4, c4, v4)
if av1H and not na(ts1) and not na(c1) and (na(pd1) or ts1 != pd1)
    pd1 := ts1
    f_push(qH1, ts1, o1, h1, l1, c1, v1)
if av15 and not na(ts5) and not na(c5) and (na(pd5) or ts5 != pd5)
    pd5 := ts5
    f_push(qM15, ts5, o5, h5, l5, c5, v5)
 
// ---- 队列长度上限(避免撞上 Pine 数组 10 万元素上限)----
int LIMK = (lookback + 20) * STRIDE
int LIMX = LIMK + 300 * STRIDE
if array.size(qCur) > LIMX
    qCur := f_trim(qCur, LIMK)
if array.size(qD) > LIMX
    qD := f_trim(qD, LIMK)
if array.size(qH4) > LIMX
    qH4 := f_trim(qH4, LIMK)
if array.size(qH1) > LIMX
    qH1 := f_trim(qH1, LIMK)
if array.size(qM15) > LIMX
    qM15 := f_trim(qM15, LIMK)
 
// ============================== 窗口访问器(作用于当前队列 qAct)==============================
var array<float> qAct = qCur
var int wBase = 0
var int wN    = 0
 
fH(int i)  => array.get(qAct, (wBase + i) * STRIDE + F_H)
fL(int i)  => array.get(qAct, (wBase + i) * STRIDE + F_L)
fC(int i)  => array.get(qAct, (wBase + i) * STRIDE + F_C)
fV(int i)  => array.get(qAct, (wBase + i) * STRIDE + F_V)
fA(int i)  => array.get(qAct, (wBase + i) * STRIDE + F_ATR)
fAV(int i) => array.get(qAct, (wBase + i) * STRIDE + F_AV)
fWH(int i) => array.get(qAct, (wBase + i) * STRIDE + F_WH)
fWL(int i) => array.get(qAct, (wBase + i) * STRIDE + F_WL)
fDH(int i) => array.get(qAct, (wBase + i) * STRIDE + F_DH)
fDL(int i) => array.get(qAct, (wBase + i) * STRIDE + F_DL)
fT(int i)  => array.get(qAct, (wBase + i) * STRIDE + F_T)
 
// ============================== 工具 ==============================
f_clamp(float x, float lo, float hi) => math.min(hi, math.max(lo, x))
 
f_med(array<float> a) =>
    float r = 0.0
    int sz = array.size(a)
    if sz > 0
        array.sort(a)
        int m = int(math.floor(sz / 2.0))
        r := sz % 2 == 1 ? array.get(a, m) : (array.get(a, m - 1) + array.get(a, m)) / 2.0
    r
 
f_futH(int from, int win) =>
    float r = fH(from)
    int lastI = int(math.min(wN - 1, from + win))
    if lastI >= from + 1
        for j = from + 1 to lastI
            r := math.max(r, fH(j))
    r
 
f_futL(int from, int win) =>
    float r = fL(from)
    int lastI = int(math.min(wN - 1, from + win))
    if lastI >= from + 1
        for j = from + 1 to lastI
            r := math.min(r, fL(j))
    r
 
f_tfLabel() =>
    float nv = str.tonumber(timeframe.period)
    string r = na(nv) ? timeframe.period
       : nv >= 1440 and nv % 1440 == 0 ? str.tostring(nv / 1440, "#") + "D"
       : nv >= 60   and nv % 60   == 0 ? str.tostring(nv / 60, "#") + "H"
       : str.tostring(nv, "#") + "m"
    r
 
f_lstyle(string s) => s == "点线" ? line.style_dotted : s == "虚线" ? line.style_dashed : line.style_solid
f_gradeColor(string g) => (g == "极强" or g == "强") ? colStrong : g == "一般" ? colMid : colWeak
 
string tfTxt = f_tfLabel()
var array<float> U_CURVE = array.from(0.0, 25.0, 55.0, 100.0, 80.0, 55.0, 35.0, 20.0)
 
// 本次分析周期的运行期变量(由主流程在全局作用域赋值,供各评分函数读取)
var float curATR = 0.0
var float gRD    = 30.0
 
// ============================== 候选点 ==============================
var array<int>   cIdx = array.new_int(0)
var array<float> cP   = array.new_float(0)
var array<float> cQ   = array.new_float(0)
var array<float> cW   = array.new_float(0)
var array<float> cA   = array.new_float(0)
var array<int>   cK   = array.new_int(0)
var array<int>   cR   = array.new_int(0)
 
f_addCand(int i, bool isH, float price, float quality, float wick, bool rej) =>
    array.push(cIdx, i)
    array.push(cP, price)
    array.push(cQ, quality)
    array.push(cW, wick)
    array.push(cK, isH ? 1 : 0)
    array.push(cR, rej ? 1 : 0)
    array.push(cA, 0.0)
 
f_popCand() =>
    array.pop(cIdx)
    array.pop(cP)
    array.pop(cQ)
    array.pop(cW)
    array.pop(cK)
    array.pop(cR)
    array.pop(cA)
 
f_hasIdx(int i) =>
    bool r = false
    int cn = array.size(cIdx)
    if cn > 0
        for k = 0 to cn - 1
            if array.get(cIdx, k) == i
                r := true
                break
    r
 
f_swing(int i, int w) =>
    float hc = fH(i)
    float lc = fL(i)
    bool isH = true
    bool isL = true
    for j = 1 to w
        if fH(i - j) > hc or fH(i + j) > hc
            isH := false
        if fL(i - j) < lc or fL(i + j) < lc
            isL := false
    if isH or isL
        float a  = math.max(nz(fA(i), 0.0), fC(i) * 0.001, 1e-9)
        float lh = fH(i - 1)
        float ll = fL(i - 1)
        float rh = fH(i + 1)
        float rl = fL(i + 1)
        for j = 2 to w
            lh := math.max(lh, fH(i - j))
            ll := math.min(ll, fL(i - j))
            rh := math.max(rh, fH(i + j))
            rl := math.min(rl, fL(i + j))
        if isH
            float amp = math.max(0.0, hc - math.min(ll, rl))
            f_addCand(i, true, hc, f_clamp(amp / a, 0.0, 4.0), fWH(i), false)
        else if isL
            float amp = math.max(0.0, math.max(lh, rh) - lc)
            f_addCand(i, false, lc, f_clamp(amp / a, 0.0, 4.0), fWL(i), false)
 
f_collect() =>
    array.clear(cIdx)
    array.clear(cP)
    array.clear(cQ)
    array.clear(cW)
    array.clear(cK)
    array.clear(cR)
    array.clear(cA)
    int W = math.max(2, swingWin)
    if wN > 2 * W
        for i = W to wN - 1 - W
            f_swing(i, W)
    int recent = int(math.min(30, wN))
    int st     = math.max(2, wN - recent)
    int en     = wN - 3
    if en >= st
        for i = st to en
            if not f_hasIdx(i)
                int before = array.size(cIdx)
                f_swing(i, 2)
                if array.size(cIdx) > before and array.get(cQ, array.size(cQ) - 1) < 0.35
                    f_popCand()
    if useRejections
        float rw = f_clamp(rejWick, 0.05, 0.95)
        float ra = math.max(0.01, rejATR)
        if wN > 2
            for i = 1 to wN - 2
                if not f_hasIdx(i)
                    float a = math.max(nz(fA(i), 0.0), fC(i) * 0.001, 1e-9)
                    if fWH(i) >= rw and fDH(i) >= ra * a
                        f_addCand(i, true, fH(i), f_clamp(fDH(i) / a, 0.0, 4.0), fWH(i), true)
                    else if fWL(i) >= rw and fDL(i) >= ra * a
                        f_addCand(i, false, fL(i), f_clamp(fDL(i) / a, 0.0, 4.0), fWL(i), true)
 
// ============================== 聚类 ==============================
var array<float> kC   = array.new_float(0)
var array<float> kA   = array.new_float(0)
var array<int>   kS   = array.new_int(0)
var array<int>   kN   = array.new_int(0)
var array<int>   kF   = array.new_int(0)
var array<int>   cAsg = array.new_int(0)
 
f_medBy(array<float> vals, int cid) =>
    array<float> t = array.new_float(0)
    int cn = array.size(cAsg)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                array.push(t, array.get(vals, i))
    f_med(t)
 
f_resetClusters() =>
    array.clear(kC)
    array.clear(kA)
    array.clear(kS)
    array.clear(kN)
    array.clear(kF)
    array.clear(cAsg)
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            array.push(cAsg, -1)
 
// mode: 0=现价上方(压力) 1=现价下方(支撑) 2=摆动低点(支撑) 3=摆动高点(压力)
f_cluster(int mode) =>
    int cn = array.size(cIdx)
    float lastClose = fC(wN - 1)
    array<int> order = array.new_int(0)
    for i = 0 to cn - 1
        bool keep = mode == 0 ? array.get(cP, i) >= lastClose
                  : mode == 1 ? array.get(cP, i) < lastClose
                  : mode == 2 ? array.get(cK, i) == 0
                  : array.get(cK, i) == 1
        if keep
            array.push(order, i)
    int on = array.size(order)
    if on > 1
        for a = 1 to on - 1
            int ia = array.get(order, a)
            float pa = array.get(cP, ia)
            int b = a - 1
            while b >= 0
                int ib = array.get(order, b)
                if array.get(cP, ib) <= pa
                    break
                array.set(order, b + 1, ib)
                b -= 1
            array.set(order, b + 1, ia)
    float gFloor = math.max(curATR * atrMult, lastClose * 0.001)
    if on > 0
        for oi = 0 to on - 1
            int   p   = array.get(order, oi)
            float pp  = array.get(cP, p)
            float pa2 = array.get(cA, p)
            int   kn  = array.size(kC)
            int   best = -1
            float bd  = 1e30
            if kn > 0
                for k = 0 to kn - 1
                    float tol = math.max(gFloor, math.max(pa2 * atrMult, array.get(kA, k) * atrMult))
                    float d   = math.abs(pp - array.get(kC, k))
                    if d <= tol and d < bd
                        best := k
                        bd   := d
            if best < 0
                array.push(kC, pp)
                array.push(kA, pa2)
                array.push(kS, (mode == 0 or mode == 3) ? 1 : 0)
                array.push(kN, 1)
                array.push(kF, p)
                array.set(cAsg, p, array.size(kC) - 1)
            else
                array.set(cAsg, p, best)
                array.set(kC, best, f_medBy(cP, best))
                array.set(kA, best, f_medBy(cA, best))
                array.set(kN, best, array.get(kN, best) + 1)
 
// ============================== 评分 ==============================
f_touchStats(int cid) =>
    float katr = array.get(kA, cid)
    float half = math.max(katr * atrMult,
         math.max(nz(fA(wN - 1), katr) * atrMult, fC(wN - 1) * 0.001))
    float lo = array.get(kC, cid) - half
    float hi = array.get(kC, cid) + half
    int events = 0
    bool inz   = false
    int firstI = -1
    int lastI  = -1
    int tb     = 0
    for i = 0 to wN - 1
        bool hit = fH(i) >= lo and fL(i) <= hi
        if hit
            tb += 1
            if firstI < 0
                firstI := i
            lastI := i
            if not inz
                events += 1
                inz := true
        else
            inz := false
    int cand = array.get(kN, cid)
    int touches = int(math.max(events, math.min(cand, 6)))
    [touches, events, tb, firstI, lastI, half]
 
f_touchScore(int n) =>
    float r = 0.0
    if touchCurve == "mono"
        r := f_clamp(100.0 * math.log(n + 1) / math.log(9.0), 0.0, 100.0)
    else
        int peak = math.max(1, touchPeak)
        int k = int(f_clamp(n - (peak - 3), 1.0, 7.0))
        r := array.get(U_CURVE, k)
    r
 
f_reaction(int cid) =>
    float s = 0.0
    int cnt = 0
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                int idx = array.get(cIdx, i)
                if idx < wN - 1
                    float a = math.max(nz(fA(idx), array.get(kA, cid)), 1e-9)
                    bool isL = array.get(cK, i) == 0
                    float mv = isL ? f_futH(idx, reactionBars) - array.get(cP, i)
                                  : array.get(cP, i) - f_futL(idx, reactionBars)
                    s += f_clamp(mv / a, 0.0, 5.0)
                    cnt += 1
    cnt > 0 ? f_clamp(s / cnt / 3.0 * 100.0, 0.0, 100.0) : 0.0
 
f_volume(int cid) =>
    float s = 0.0
    int cnt = 0
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                int idx = array.get(cIdx, i)
                float base = fAV(idx)
                if not na(base) and base > 0
                    int endI = int(math.min(wN - 1, idx + 2))
                    float mx = 0.0
                    for j = idx to endI
                        mx := math.max(mx, fV(j))
                    s += mx / base
                    cnt += 1
    cnt > 0 ? f_clamp((math.min(s / cnt, 4.0) - 1.0) / 3.0 * 100.0, 0.0, 100.0) : 0.0
 
f_swq(int cid) =>
    float amp = 0.0
    float wik = 0.0
    int cnt = 0
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                amp += f_clamp(array.get(cQ, i) / 3.0, 0.0, 1.0) * 100.0
                wik += f_clamp(array.get(cW, i) / math.max(wickFull, 0.05), 0.0, 1.0) * 100.0
                cnt += 1
    if cnt > 0
        amp /= cnt
        wik /= cnt
    [f_clamp(amp * (1.0 - wickWeight) + wik * wickWeight, 0.0, 100.0), amp, wik]
 
f_rejection(int cid) =>
    float half = math.max(array.get(kA, cid) * math.max(0.05, rejHalf), fC(wN - 1) * 0.0002)
    float lo = array.get(kC, cid) - half
    float hi = array.get(kC, cid) + half
    float rw = f_clamp(rejWick, 0.05, 0.95)
    float ctr = array.get(kC, cid)
    int hits = 0
    int whits = 0
    for i = 1 to wN - 1
        float h = fH(i)
        float l = fL(i)
        float cl = fC(i)
        if h < lo or l > hi
            continue
        hits += 1
        float pcl = fC(i - 1)
        bool fromBelow = pcl < lo and h >= lo
        bool fromAbove = pcl > hi and l <= hi
        bool touchBelow = l <= lo and cl > ctr
        bool touchAbove = h >= hi and cl < ctr
        bool supRej = (fromBelow or touchBelow) and fWL(i) >= rw and cl >= ctr
        bool resRej = (fromAbove or touchAbove) and fWH(i) >= rw and cl <= ctr
        if supRej or resRej
            whits += 1
    float ratio = 0.0
    float raw = 0.0
    float score = 0.0
    if hits > 0
        raw := whits / hits
        int pn = math.max(0, rejPrior)
        ratio := pn > 0 ? (whits + 0.33 * pn) / (hits + pn) : raw
        score := ratio <= 0.33 ? ratio / 0.33 * 35.0
               : ratio <= 0.66 ? 35.0 + (ratio - 0.33) / 0.33 * 45.0
               : 80.0 + (ratio - 0.66) / 0.34 * 20.0
        score := f_clamp(score, 0.0, 100.0)
    [score, ratio, hits, whits]
 
f_breakRetest(int cid) =>
    float ctr = array.get(kC, cid)
    float a = math.max(array.get(kA, cid), nz(fA(wN - 1), array.get(kA, cid)) * 0.5, 1e-9)
    float bo = math.max(0.01, breakoutATR) * a
    float rt = math.max(0.01, retestATR) * a
    int rb = math.max(2, reactionBars)
    bool isL = array.get(cK, array.get(kF, cid)) == 0
    int minI = wN
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                minI := math.min(minI, array.get(cIdx, i))
    int start = minI + 1
    int brokeAt = -1
    float best = 0.0
    if start <= wN - 1
        for i = start to wN - 1
            float h = fH(i)
            float l = fL(i)
            float cl = fC(i)
            if isL
                if l < ctr - bo
                    brokeAt := i
                    continue
                if brokeAt >= 0 and i - brokeAt <= rb
                    bool rtHit = l <= ctr + rt and h >= ctr - rt
                    if rtHit and cl > ctr
                        best := 100.0
                        break
                if brokeAt >= 0 and i - brokeAt > rb
                    brokeAt := -1
            else
                if h > ctr + bo
                    brokeAt := i
                    continue
                if brokeAt >= 0 and i - brokeAt <= rb
                    bool rtHit = h >= ctr - rt and l <= ctr + rt
                    if rtHit and cl < ctr
                        best := 100.0
                        break
                if brokeAt >= 0 and i - brokeAt > rb
                    brokeAt := -1
    float r = best
    if best == 0.0
        bool brokeAny = false
        if start <= wN - 1
            for i = start to wN - 1
                if isL
                    if fL(i) < ctr - bo
                        brokeAny := true
                        break
                else
                    if fH(i) > ctr + bo
                        brokeAny := true
                        break
        r := brokeAny ? 0.0 : 40.0
    r
 
f_reversal(int cid) =>
    float magS = 0.0
    float spdS = 0.0
    float hldS = 0.0
    int cnt = 0
    int rvB = math.max(4, revBars)
    float rvA = math.max(0.5, revATR)
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                int idx = array.get(cIdx, i)
                if idx < wN - 1
                    float a = math.max(nz(fA(idx), array.get(kA, cid)), 1e-9)
                    bool isL = array.get(cK, i) == 0
                    float px = array.get(cP, i)
                    int endI = int(math.min(wN - 1, idx + rvB))
                    float mx = isL ? f_futH(idx, rvB) - px : px - f_futL(idx, rvB)
                    magS += f_clamp(mx / (rvA * a), 0.0, 1.0) * 100.0
                    int b2 = -1
                    bool pierced = false
                    bool recovered = false
                    if endI >= idx + 1
                        for j = idx + 1 to endI
                            float mv = isL ? fH(j) - px : px - fL(j)
                            if b2 < 0 and mv >= 2.0 * a
                                b2 := j - idx
                            bool broke = isL ? fL(j) < px - a : fH(j) > px + a
                            if broke
                                pierced := true
                            bool back = isL ? fC(j) > px : fC(j) < px
                            if pierced and back
                                recovered := true
                    spdS += b2 < 0 ? 0.0 : f_clamp((12.0 - b2) / 9.0, 0.0, 1.0) * 100.0
                    hldS += not pierced ? 100.0 : recovered ? 50.0 : 0.0
                    cnt += 1
    cnt > 0 ? f_clamp(magS / cnt * 0.5 + spdS / cnt * 0.3 + hldS / cnt * 0.2, 0.0, 100.0) : 0.0
 
f_recency(int cid, float rd) =>
    float latest = 0.0
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            if array.get(cAsg, i) == cid
                latest := math.max(latest, fT(array.get(cIdx, i)))
    float age = math.max(0.0, (fT(wN - 1) - latest) / 86400000.0)
    f_clamp(100.0 * math.exp(-age / math.max(rd, 1.0)), 0.0, 100.0)
 
f_distance(float price, float lc) =>
    float d = math.abs(price - lc) / math.max(lc, 1e-9)
    f_clamp(100.0 * math.exp(-d / 0.12), 0.0, 100.0)
 
// ============================== 层位表 ==============================
var array<float>  lP    = array.new_float(0)
var array<int>    lS    = array.new_int(0)
var array<float>  lStr  = array.new_float(0)
var array<float>  lRel  = array.new_float(0)
var array<float>  lDis  = array.new_float(0)
var array<float>  lDist = array.new_float(0)
var array<float>  lZH   = array.new_float(0)
var array<float>  lAge  = array.new_float(0)
var array<int>    lT    = array.new_int(0)
var array<string> lG    = array.new_string(0)
var array<int>    lRank = array.new_int(0)
var array<string> lTF   = array.new_string(0)
 
// 多周期合并用的临时层位表
var array<float>  tP    = array.new_float(0)
var array<int>    tS    = array.new_int(0)
var array<float>  tStr  = array.new_float(0)
var array<float>  tRel  = array.new_float(0)
var array<float>  tDis  = array.new_float(0)
var array<float>  tDist = array.new_float(0)
var array<float>  tZH   = array.new_float(0)
var array<float>  tAge  = array.new_float(0)
var array<int>    tT    = array.new_int(0)
var array<string> tG    = array.new_string(0)
var array<int>    tRank = array.new_int(0)
var array<string> tTF   = array.new_string(0)
 
f_copyF(array<float> dst, array<float> src) =>
    array.clear(dst)
    int n = array.size(src)
    if n > 0
        for i = 0 to n - 1
            array.push(dst, array.get(src, i))
 
f_copyI(array<int> dst, array<int> src) =>
    array.clear(dst)
    int n = array.size(src)
    if n > 0
        for i = 0 to n - 1
            array.push(dst, array.get(src, i))
 
f_copyS(array<string> dst, array<string> src) =>
    array.clear(dst)
    int n = array.size(src)
    if n > 0
        for i = 0 to n - 1
            array.push(dst, array.get(src, i))
 
f_sortDesc(array<int> idxs, array<float> vals) =>
    int n = array.size(idxs)
    if n > 1
        for a = 1 to n - 1
            int ia = array.get(idxs, a)
            float va = array.get(vals, ia)
            int b = a - 1
            while b >= 0
                int ib = array.get(idxs, b)
                if array.get(vals, ib) >= va
                    break
                array.set(idxs, b + 1, ib)
                b -= 1
            array.set(idxs, b + 1, ia)
    idxs
 
// ============================== 单周期完整识别 ==============================
// 调用前需在全局作用域准备好:qAct / wN / wBase / curATR / gRD
f_analyze(string tag) =>
    float lastClose = fC(wN - 1)
    f_collect()
    int cn = array.size(cIdx)
    if cn > 0
        for i = 0 to cn - 1
            array.set(cA, i, math.max(nz(fA(array.get(cIdx, i)), curATR), curATR * 0.5, 1e-9))
    f_resetClusters()
    if sideBySwing
        f_cluster(2)
        f_cluster(3)
    else
        f_cluster(0)
        f_cluster(1)
    int mt = math.max(1, minTouches)
    int knAll = array.size(kC)
    if knAll > 0
        for k = 0 to knAll - 1
            if array.get(kN, k) < mt
                continue
            float center = array.get(kC, k)
            [touches, events, tb, firstI, lastTI, half] = f_touchStats(k)
            if touches < minTouches
                continue
            float ts   = f_touchScore(touches)
            float rc   = f_reaction(k)
            float vs   = f_volume(k)
            float rcs  = f_recency(k, gRD)
            float br   = f_breakRetest(k)
            float rv   = f_reversal(k)
            [sqs, ampS, wikS] = f_swq(k)
            [rjs, rjr, rjh, rjw] = f_rejection(k)
            float ds = f_distance(center, lastClose)
            float strength = f_clamp(ts * 0.25 + rjs * 0.20 + rc * 0.15 + rv * 0.15 +
                 vs * 0.05 + br * 0.10 + sqs * 0.10, 0.0, 100.0)
            float dw = f_clamp(distWeight, 0.0, 1.0)
            float disp = f_clamp((1.0 - dw) * strength + dw * ds, 0.0, 100.0)
            float rel = f_clamp(strength * (0.6 + 0.4 * rcs / 100.0) *
                 (0.6 + 0.4 * ds / 100.0), 0.0, 100.0)
            string grade = strength >= strongScore + 20.0 ? "极强"
                         : strength >= strongScore ? "强"
                         : strength >= strongScore - 20.0 ? "一般" : "弱"
            float distv = math.abs(center - lastClose) / math.max(lastClose, 1e-9)
            float zh = math.max(array.get(kA, k) * math.max(0.01, atrMult), curATR * 0.001)
            float latestT = 0.0
            if cn > 0
                for i = 0 to cn - 1
                    if array.get(cAsg, i) == k
                        latestT := math.max(latestT, fT(array.get(cIdx, i)))
            float ageD = math.max(0.0, (fT(wN - 1) - latestT) / 86400000.0)
            array.push(lP, center)
            array.push(lS, array.get(kS, k))
            array.push(lStr, strength)
            array.push(lRel, rel)
            array.push(lDis, disp)
            array.push(lDist, distv)
            array.push(lZH, zh)
            array.push(lAge, ageD)
            array.push(lT, touches)
            array.push(lG, grade)
            array.push(lRank, -1)
            array.push(lTF, tag)
 
// ============================== 绘图对象 ==============================
var array<line>  lnArr = array.new<line>()
var array<label> lbArr = array.new<label>()
var array<box>   bxArr = array.new<box>()
 
f_delLines() =>
    int n = array.size(lnArr)
    if n > 0
        for i = 0 to n - 1
            line.delete(array.get(lnArr, i))
    array.clear(lnArr)
 
f_delLabels() =>
    int n = array.size(lbArr)
    if n > 0
        for i = 0 to n - 1
            label.delete(array.get(lbArr, i))
    array.clear(lbArr)
 
f_delBoxes() =>
    int n = array.size(bxArr)
    if n > 0
        for i = 0 to n - 1
            box.delete(array.get(bxArr, i))
    array.clear(bxArr)
 
f_drawLevel(int li, int x1, int x2, string ls) =>
    float p   = array.get(lP, li)
    string g  = array.get(lG, li)
    int rk    = array.get(lRank, li)
    string sd = array.get(lS, li) == 1 ? "压力" : "支撑"
    color cc  = useCustom ? custColor : f_gradeColor(g)
    string tx = array.get(lTF, li) + (rk > 0 ? "第" + str.tostring(rk) : "") + g + sd
    array.push(lnArr, line.new(x1, p, x2, p, xloc=xloc.bar_index, extend=extend.none,
         color=cc, style=ls, width=lineWidth))
    array.push(lbArr, label.new(x2, p, tx, xloc=xloc.bar_index, style=label.style_label_left,
         color=cc, textcolor=color.white, size=size.small))
    if showZone
        float zh = array.get(lZH, li)
        array.push(bxArr, box.new(x1, p + zh, x2, p - zh, xloc=xloc.bar_index,
             border_color=color.new(cc, 100), border_width=1, bgcolor=color.new(cc, 88)))
    if alertOn and not na(close[1])
        if close[1] <= p and close > p
            alert(syminfo.ticker + " " + array.get(lTF, li) + " 上破" + sd + " " +
                 str.tostring(p, format.mintick) + "(" + g + ")", alert.freq_once_per_bar)
        if close[1] >= p and close < p
            alert(syminfo.ticker + " " + array.get(lTF, li) + " 下破" + sd + " " +
                 str.tostring(p, format.mintick) + "(" + g + ")", alert.freq_once_per_bar)
 
// ============================== 主流程 ==============================
var int    diagCand = 0
var int    diagClu  = 0
var int    diagTFn  = 0
var string diagTF   = ""
var table  tbl      = na
 
if barstate.islast
    f_delLines()
    f_delLabels()
    f_delBoxes()
    array.clear(lP)
    array.clear(lS)
    array.clear(lStr)
    array.clear(lRel)
    array.clear(lDis)
    array.clear(lDist)
    array.clear(lZH)
    array.clear(lAge)
    array.clear(lT)
    array.clear(lG)
    array.clear(lRank)
    array.clear(lTF)
    diagCand := 0
    diagClu  := 0
 
    // ---- 参与计算的周期 ----
    bool multi = tfMode == "多周期合并"
    bool wantD  = tfMode == "日线"   or (multi and mtfD)
    bool want4H = tfMode == "4小时"  or (multi and mtf4H)
    bool want1H = tfMode == "1小时"  or (multi and mtf1H)
    bool want15 = tfMode == "15分钟" or (multi and mtf15m)
    bool runD  = wantD  and avD
    bool run4H = want4H and av4H
    bool run1H = want1H and av1H
    bool run15 = want15 and av15
    bool runCur = tfMode == "当前周期" or (multi and mtfCur) or
         (wantD and not avD) or (want4H and not av4H) or (want1H and not av1H) or (want15 and not av15)
 
    string usedTxt = ""
    if runCur
        usedTxt := usedTxt + (usedTxt == "" ? "" : "+") + tfTxt
    if runD
        usedTxt := usedTxt + (usedTxt == "" ? "" : "+") + "1D"
    if run4H
        usedTxt := usedTxt + (usedTxt == "" ? "" : "+") + "4H"
    if run1H
        usedTxt := usedTxt + (usedTxt == "" ? "" : "+") + "1H"
    if run15
        usedTxt := usedTxt + (usedTxt == "" ? "" : "+") + "15m"
    string naTxt = ""
    if wantD and not avD
        naTxt := naTxt + " 日线不可用"
    if want4H and not av4H
        naTxt := naTxt + " 4H不可用"
    if want1H and not av1H
        naTxt := naTxt + " 1H不可用"
    if want15 and not av15
        naTxt := naTxt + " 15m不可用"
    // 样本不足(图表历史不够长,该周期凑不满 30 根)会在下面跳过,这里提示出来
    if runCur and array.size(qCur) / STRIDE < 30
        naTxt := naTxt + " " + tfTxt + "仅" + str.tostring(array.size(qCur) / STRIDE) + "根"
    if runD and array.size(qD) / STRIDE < 30
        naTxt := naTxt + " 1D仅" + str.tostring(array.size(qD) / STRIDE) + "根"
    if run4H and array.size(qH4) / STRIDE < 30
        naTxt := naTxt + " 4H仅" + str.tostring(array.size(qH4) / STRIDE) + "根"
    if run1H and array.size(qH1) / STRIDE < 30
        naTxt := naTxt + " 1H仅" + str.tostring(array.size(qH1) / STRIDE) + "根"
    if run15 and array.size(qM15) / STRIDE < 30
        naTxt := naTxt + " 15m仅" + str.tostring(array.size(qM15) / STRIDE) + "根"
    diagTF := usedTxt + naTxt
    int tfCount = (runCur ? 1 : 0) + (runD ? 1 : 0) + (run4H ? 1 : 0) + (run1H ? 1 : 0) + (run15 ? 1 : 0)
    diagTFn := tfCount
 
    // ---- 各周期各跑一遍完整识别 ----
    if runCur
        qAct := qCur
        int n0 = array.size(qAct) / STRIDE
        wN := int(math.min(lookback, n0))
        wBase := n0 - wN
        if wN >= 30
            curATR := math.max(nz(fA(wN - 1), 0.0), fC(wN - 1) * 0.005, 1e-9)
            gRD := recencyDays > 0 ? math.max(1.0, recencyDays) :
                 math.max(1.0, math.max(1.0, (fT(wN - 1) - fT(0)) / 86400000.0) / 3.0)
            f_analyze(tfTxt)
            diagCand := diagCand + array.size(cIdx)
            diagClu  := diagClu + array.size(kC)
 
    if runD
        qAct := qD
        int n1 = array.size(qAct) / STRIDE
        wN := int(math.min(lookback, n1))
        wBase := n1 - wN
        if wN >= 30
            curATR := math.max(nz(fA(wN - 1), 0.0), fC(wN - 1) * 0.005, 1e-9)
            gRD := recencyDays > 0 ? math.max(1.0, recencyDays) :
                 math.max(1.0, math.max(1.0, (fT(wN - 1) - fT(0)) / 86400000.0) / 3.0)
            f_analyze("1D")
            diagCand := diagCand + array.size(cIdx)
            diagClu  := diagClu + array.size(kC)
 
    if run4H
        qAct := qH4
        int n2 = array.size(qAct) / STRIDE
        wN := int(math.min(lookback, n2))
        wBase := n2 - wN
        if wN >= 30
            curATR := math.max(nz(fA(wN - 1), 0.0), fC(wN - 1) * 0.005, 1e-9)
            gRD := recencyDays > 0 ? math.max(1.0, recencyDays) :
                 math.max(1.0, math.max(1.0, (fT(wN - 1) - fT(0)) / 86400000.0) / 3.0)
            f_analyze("4H")
            diagCand := diagCand + array.size(cIdx)
            diagClu  := diagClu + array.size(kC)
 
    if run1H
        qAct := qH1
        int n3 = array.size(qAct) / STRIDE
        wN := int(math.min(lookback, n3))
        wBase := n3 - wN
        if wN >= 30
            curATR := math.max(nz(fA(wN - 1), 0.0), fC(wN - 1) * 0.005, 1e-9)
            gRD := recencyDays > 0 ? math.max(1.0, recencyDays) :
                 math.max(1.0, math.max(1.0, (fT(wN - 1) - fT(0)) / 86400000.0) / 3.0)
            f_analyze("1H")
            diagCand := diagCand + array.size(cIdx)
            diagClu  := diagClu + array.size(kC)
 
    if run15
        qAct := qM15
        int n4 = array.size(qAct) / STRIDE
        wN := int(math.min(lookback, n4))
        wBase := n4 - wN
        if wN >= 30
            curATR := math.max(nz(fA(wN - 1), 0.0), fC(wN - 1) * 0.005, 1e-9)
            gRD := recencyDays > 0 ? math.max(1.0, recencyDays) :
                 math.max(1.0, math.max(1.0, (fT(wN - 1) - fT(0)) / 86400000.0) / 3.0)
            f_analyze("15m")
            diagCand := diagCand + array.size(cIdx)
            diagClu  := diagClu + array.size(kC)
 
    // ---- 多周期合并:跨周期聚类 + 统一评分 ----
    if tfCount > 1
        array.clear(tP)
        array.clear(tS)
        array.clear(tStr)
        array.clear(tRel)
        array.clear(tDis)
        array.clear(tDist)
        array.clear(tZH)
        array.clear(tAge)
        array.clear(tT)
        array.clear(tG)
        array.clear(tRank)
        array.clear(tTF)
        array<int> ord = array.new_int(0)
        int ln0 = array.size(lP)
        if ln0 > 0
            for i = 0 to ln0 - 1
                array.push(ord, i)
        if ln0 > 1
            for a = 1 to ln0 - 1
                int ia = array.get(ord, a)
                float pa = array.get(lP, ia)
                int b = a - 1
                while b >= 0
                    int ib = array.get(ord, b)
                    if array.get(lP, ib) <= pa
                        break
                    array.set(ord, b + 1, ib)
                    b -= 1
                array.set(ord, b + 1, ia)
        array<float> gP = array.new_float(0)
        array<float> gStr = array.new_float(0)
        array<float> gZH = array.new_float(0)
        array<float> gAge = array.new_float(0)
        array<int>   gTouch = array.new_int(0)
        array<int>   gNTF = array.new_int(0)
        array<int>   gCnt = array.new_int(0)
        array<string> gTF = array.new_string(0)
        if ln0 > 0
            for i = 0 to ln0 - 1
                int li = array.get(ord, i)
                float pp = array.get(lP, li)
                string tg = array.get(lTF, li)
                int gn = array.size(gP)
                int hit = -1
                if gn > 0
                    for g = 0 to gn - 1
                        float tol = math.max(array.get(gP, g) * mtfTol / 100.0, syminfo.mintick)
                        if math.abs(pp - array.get(gP, g)) <= tol
                            hit := g
                            break
                if hit < 0
                    array.push(gP, pp)
                    array.push(gStr, array.get(lStr, li))
                    array.push(gZH, array.get(lZH, li))
                    array.push(gAge, array.get(lAge, li))
                    array.push(gTouch, array.get(lT, li))
                    array.push(gNTF, 1)
                    array.push(gCnt, 1)
                    array.push(gTF, tg)
                else
                    int oc = array.get(gCnt, hit)
                    array.set(gP, hit, (array.get(gP, hit) * oc + pp) / (oc + 1))
                    array.set(gStr, hit, math.max(array.get(gStr, hit), array.get(lStr, li)))
                    array.set(gZH, hit, math.max(array.get(gZH, hit), array.get(lZH, li)))
                    array.set(gAge, hit, math.min(array.get(gAge, hit), array.get(lAge, li)))
                    array.set(gTouch, hit, array.get(gTouch, hit) + array.get(lT, li))
                    array.set(gCnt, hit, oc + 1)
                    if not str.contains(array.get(gTF, hit), tg)
                        array.set(gTF, hit, array.get(gTF, hit) + "·" + tg)
                        array.set(gNTF, hit, array.get(gNTF, hit) + 1)
        int gn2 = array.size(gP)
        if gn2 > 0
            for g = 0 to gn2 - 1
                float price = array.get(gP, g)
                float strength = f_clamp(array.get(gStr, g) + (array.get(gNTF, g) - 1) * mtfBonus, 0.0, 100.0)
                float ds = f_distance(price, close)
                float distv = math.abs(price - close) / math.max(close, 1e-9)
                float rcs = f_clamp(100.0 * math.exp(-array.get(gAge, g) / math.max(gRD, 1.0)), 0.0, 100.0)
                float dw2 = f_clamp(distWeight, 0.0, 1.0)
                float disp = f_clamp((1.0 - dw2) * strength + dw2 * ds, 0.0, 100.0)
                float rel = f_clamp(strength * (0.6 + 0.4 * rcs / 100.0) * (0.6 + 0.4 * ds / 100.0), 0.0, 100.0)
                string grade2 = strength >= strongScore + 20.0 ? "极强"
                              : strength >= strongScore ? "强"
                              : strength >= strongScore - 20.0 ? "一般" : "弱"
                array.push(tP, price)
                array.push(tS, price >= close ? 1 : 0)
                array.push(tStr, strength)
                array.push(tRel, rel)
                array.push(tDis, disp)
                array.push(tDist, distv)
                array.push(tZH, array.get(gZH, g))
                array.push(tAge, array.get(gAge, g))
                array.push(tT, array.get(gTouch, g))
                array.push(tG, grade2)
                array.push(tRank, -1)
                array.push(tTF, array.get(gTF, g))
        f_copyF(lP, tP)
        f_copyI(lS, tS)
        f_copyF(lStr, tStr)
        f_copyF(lRel, tRel)
        f_copyF(lDis, tDis)
        f_copyF(lDist, tDist)
        f_copyF(lZH, tZH)
        f_copyF(lAge, tAge)
        f_copyI(lT, tT)
        f_copyS(lG, tG)
        f_copyI(lRank, tRank)
        f_copyS(lTF, tTF)
 
    // ---- 过滤 / 去重 / 选线 ----
    array<int> cand = array.new_int(0)
    int ln = array.size(lP)
    if ln > 0
        for i = 0 to ln - 1
            if array.get(lDist, i) >= nearPct / 100.0
                array.push(cand, i)
    f_sortDesc(cand, lRel)
    array<int> dedup = array.new_int(0)
    int cn2 = array.size(cand)
    if cn2 > 0
        for i = 0 to cn2 - 1
            int li = array.get(cand, i)
            if onlyStrong and array.get(lStr, li) < strongScore
                continue
            bool clash = false
            int dn0 = array.size(dedup)
            if dn0 > 0
                for u = 0 to dn0 - 1
                    int lu = array.get(dedup, u)
                    if math.abs(array.get(lP, li) - array.get(lP, lu)) /
                       math.max(math.abs(array.get(lP, lu)), 1e-9) <= mergePct / 100.0
                        clash := true
                        break
            if not clash
                array.push(dedup, li)
    array<int> selUp = array.new_int(0)
    array<int> selDn = array.new_int(0)
    int cn3 = array.size(dedup)
    if cn3 > 0
        for i = 0 to cn3 - 1
            int li = array.get(dedup, i)
            if array.get(lS, li) == 1
                array.push(selUp, li)
            else
                array.push(selDn, li)
    f_sortDesc(selUp, lDis)
    f_sortDesc(selDn, lDis)
    int nUp = math.min(maxLines, array.size(selUp))
    int nDn = math.min(maxLines, array.size(selDn))
 
    // ---- 编号 ----
    if rankBy != "off"
        array<int> upR = array.copy(selUp)
        array<int> dnR = array.copy(selDn)
        if rankBy == "rel"
            f_sortDesc(upR, lRel)
            f_sortDesc(dnR, lRel)
        else if rankBy == "str"
            f_sortDesc(upR, lStr)
            f_sortDesc(dnR, lStr)
        if nUp > 0
            for i = 0 to nUp - 1
                array.set(lRank, array.get(upR, i), i + 1)
        if nDn > 0
            for i = 0 to nDn - 1
                array.set(lRank, array.get(dnR, i), i + 1)
 
    // ---- 画线 ----
    int x1 = bar_index - leftBars
    int x2 = math.max(bar_index + extendBars, x1 + 1)
    string ls = f_lstyle(lineStyle)
    if nUp > 0
        for i = 0 to nUp - 1
            f_drawLevel(array.get(selUp, i), x1, x2, ls)
    if nDn > 0
        for i = 0 to nDn - 1
            f_drawLevel(array.get(selDn, i), x1, x2, ls)
 
    // ---- 信息表 ----
    if showTable
        int rows = maxLines * 2 + 3
        if na(tbl)
            tbl := table.new(position.top_right, 7, rows, border_width=1, frame_width=1)
        table.clear(tbl, 0, 0, 6, rows - 1)
        table.cell(tbl, 0, 0, "周期", text_color=color.white, bgcolor=color.gray)
        table.cell(tbl, 1, 0, "方向", text_color=color.white, bgcolor=color.gray)
        table.cell(tbl, 2, 0, "价位", text_color=color.white, bgcolor=color.gray)
        table.cell(tbl, 3, 0, "强度", text_color=color.white, bgcolor=color.gray)
        table.cell(tbl, 4, 0, "触碰", text_color=color.white, bgcolor=color.gray)
        table.cell(tbl, 5, 0, "等级", text_color=color.white, bgcolor=color.gray)
        table.cell(tbl, 6, 0, "距现价%", text_color=color.white, bgcolor=color.gray)
        int rowI = 1
        if nUp > 0
            for i = 0 to nUp - 1
                int li = array.get(selUp, i)
                color cc2 = useCustom ? custColor : f_gradeColor(array.get(lG, li))
                table.cell(tbl, 0, rowI, array.get(lTF, li))
                table.cell(tbl, 1, rowI, "压力", text_color=cc2)
                table.cell(tbl, 2, rowI, str.tostring(array.get(lP, li), format.mintick))
                table.cell(tbl, 3, rowI, str.tostring(array.get(lStr, li), "#.#"))
                table.cell(tbl, 4, rowI, str.tostring(array.get(lT, li)))
                table.cell(tbl, 5, rowI, array.get(lG, li), text_color=cc2)
                table.cell(tbl, 6, rowI, str.tostring(array.get(lDist, li) * 100.0, "#.##"))
                rowI += 1
        if nDn > 0
            for i = 0 to nDn - 1
                int li = array.get(selDn, i)
                color cc3 = useCustom ? custColor : f_gradeColor(array.get(lG, li))
                table.cell(tbl, 0, rowI, array.get(lTF, li))
                table.cell(tbl, 1, rowI, "支撑", text_color=cc3)
                table.cell(tbl, 2, rowI, str.tostring(array.get(lP, li), format.mintick))
                table.cell(tbl, 3, rowI, str.tostring(array.get(lStr, li), "#.#"))
                table.cell(tbl, 4, rowI, str.tostring(array.get(lT, li)))
                table.cell(tbl, 5, rowI, array.get(lG, li), text_color=cc3)
                table.cell(tbl, 6, rowI, str.tostring(array.get(lDist, li) * 100.0, "#.##"))
                rowI += 1
        string dg = "数据源 " + diagTF + "  候选 " + str.tostring(diagCand) +
             "  簇 " + str.tostring(diagClu) + "  层位 " + str.tostring(ln) +
             "  现价 " + str.tostring(close, format.mintick)
        table.cell(tbl, 0, rowI, dg, text_color=color.white, bgcolor=color.gray)

← 返回列表