本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © thescalpeltrader
//@version=6
indicator("Level Evidence Map", shorttitle = "LEM", overlay = true, max_lines_count = 50, max_labels_count = 300, max_boxes_count = 60)
// ─────────────────────────────────────────────────────────────────────────────
// Level Evidence Map
// Do popular chart levels beat random lines on THIS chart?
// 1. Builds candidate levels from 12 concepts (swing, Fibonacci, harmonic deep
// retracements, extensions, supply/demand, fair value gaps, previous period
// H/L/C, floor pivots, Gann Square of 9, round numbers).
// 2. Reaction test on every first touch: wait for a rejection close, then
// check whether price travelled RR x risk before undoing the reaction.
// 3. Scores each level from its type + context, learned only from EARLIER
// confirmed reactions on this chart; grades A / B / C by score and records
// each grade's walk-forward result.
// 4. Random "control" lines go through the same test and give the baseline.
// Historical statistics of this chart only. No buy / sell signals.
// All logic runs on confirmed bars (non-repainting).
// ─────────────────────────────────────────────────────────────────────────────
// ───────────── Inputs
string G0 = "Chart"
string showIn = input.string("A and B", "Grades shown", options = ["A only", "A and B", "All graded"], group = G0, display = display.none)
int nShow = input.int(3, "Bands shown each side of price", minval = 1, maxval = 8, group = G0, display = display.none)
float bandK = input.float(0.15, "Band half-width (x ATR)", minval = 0.05, step = 0.05, group = G0, display = display.none)
float mergeK = input.float(0.5, "Hide a band closer than this to a better one (x ATR)", minval = 0.0, step = 0.1, group = G0, display = display.none)
bool showMarks = input.bool(true, "Mark past reactions of shown grades (✓ / ✗)", group = G0, display = display.none)
string G1 = "Reaction test"
int pivLen = input.int(5, "Swing length (bars each side)", minval = 2, group = G1, display = display.none)
int confBars = input.int(3, "Bars allowed for a rejection close", minval = 1, maxval = 10, group = G1, display = display.none)
float rr = input.float(1.0, "Follow-through needed (x risk)", minval = 0.5, step = 0.25, group = G1, display = display.none)
int maxWait = input.int(40, "Bars allowed to decide a reaction", minval = 5, group = G1, display = display.none)
float minDist = input.float(1.0, "A level must start at least this far from price (x ATR)", minval = 0.25, step = 0.25, group = G1, display = display.none)
int maxAge = input.int(400, "Drop untouched levels after (bars)", minval = 50, group = G1, display = display.none)
float confTol = input.float(0.25, "Confluence tolerance (x ATR)", minval = 0.05, step = 0.05, group = G1, display = display.none)
float dispK = input.float(1.5, "Supply / demand: move bar range (x ATR)", minval = 1.0, step = 0.1, group = G1, display = display.none)
float stepIn = input.float(0.0, "Round-number step (0 = auto)", minval = 0.0, group = G1, display = display.none)
string G2 = "Grading"
float pctA = input.float(20, "Grade A = top % of scores", minval = 5, maxval = 40, group = G2, display = display.none)
float pctB = input.float(30, "Grade B = next % of scores", minval = 5, maxval = 50, group = G2, display = display.none)
int warmN = input.int(150, "Touches needed before grading starts", minval = 50, group = G2, display = display.none)
float kShr = input.float(30, "Caution factor (higher = slower to trust small samples)", minval = 5, group = G2, display = display.none)
int freshBars = input.int(100, "A level is 'fresh' for (bars)", minval = 10, group = G2, display = display.none)
int emaFastL = input.int(50, "Trend: fast EMA", minval = 5, group = G2, display = display.none)
int emaSlowL = input.int(200, "Trend: slow EMA", minval = 20, group = G2, display = display.none)
string G3 = "Table"
bool showTable = input.bool(true, "Show table", group = G3, display = display.none)
bool showGrades = input.bool(true, "Section: grade record", group = G3, display = display.none)
bool showDrivers = input.bool(true, "Section: what helped here (top 3)", group = G3, display = display.none)
bool showTypes = input.bool(true, "Section: best level types", group = G3, display = display.none)
bool showNear = input.bool(true, "Section: nearest bands", group = G3, display = display.none)
string tblPosIn = input.string("Top right", "Position", options = ["Top right", "Top left", "Bottom right", "Bottom left"], group = G3, display = display.none)
string tblSzIn = input.string("Small", "Text size", options = ["Tiny", "Small", "Normal"], group = G3, display = display.none)
// ───────────── Colours
color C_SUP = #2DD4BF
color C_RES = #FB7185
color C_GOLD = #FBBF24
color C_PANEL = #0F172A
color C_HEAD = #1E293B
color C_TEXT = #E2E8F0
color C_MUTE = #94A3B8
// ───────────── Constants
int F_SR = 0
int F_F38 = 1
int F_F50 = 2
int F_F61 = 3
int F_HARM = 4
int F_EXT = 5
int F_ZONE = 6
int F_FVG = 7
int F_PREV = 8
int F_PIV = 9
int F_GANN = 10
int F_ROUND = 11
int F_CTRL = 12
int NFAM = 12
int NFEAT = 6
int minG = showIn == "A only" ? 3 : showIn == "A and B" ? 2 : 1
string tsz = tblSzIn == "Tiny" ? size.tiny : tblSzIn == "Normal" ? size.normal : size.small
string htf = timeframe.isintraday ? (timeframe.in_seconds() >= 3600 ? "W" : "D") : timeframe.isdaily ? "W" : timeframe.isweekly ? "M" : "12M"
string perName = htf == "D" ? "day" : htf == "W" ? "week" : htf == "M" ? "month" : "year"
string modeTxt = timeframe.isintraday ? "Intraday" : timeframe.isdaily ? "Swing" : "Positional"
type Level
float price
int fam
int born
int side // +1 = support (price above), -1 = resistance (price below)
int state = 0 // 0 waiting, 1 touched (awaiting rejection close), 3 reaction confirmed, 2 finished
float atrT = na
int touchBar = na
float ext = na
float entry = na
float stop = na
float tgt = na
int confBar = na
bool fTrend = false
bool fConf = false
bool fFresh = false
bool fCalm = false
bool fZone = false
bool fGentle = false
float score = na
int grade = 0 // 0 not graded yet, 1 C, 2 B, 3 A
var array<Level> lv = array.new<Level>()
var array<int> famS = array.new_int(24, 0) // fam*2 + (0 followed through, 1 failed)
var array<int> featS = array.new_int(24, 0) // (k*2 + v)*2 + outcome
var array<int> gS = array.new_int(8, 0) // grade*2 + outcome
var array<int> tot = array.new_int(2, 0)
var array<int> ctrl = array.new_int(2, 0)
var array<float> scoreHist = array.new<float>()
// ───────────── Helpers
famName(int f) =>
switch f
0 => "Swing"
1 => "Fib 38.2%"
2 => "Fib 50%"
3 => "Fib 61.8%"
4 => "Harmonic 78.6–88.6%"
5 => "Fib extension"
6 => "Supply/demand"
7 => "Fair value gap"
8 => "Prev " + perName + " H/L/C"
9 => "Pivot"
10 => "Gann Sq9"
11 => "Round number"
=> "Random"
featName(int k) =>
switch k
0 => "With trend"
1 => "Confluence"
2 => "Fresh level"
3 => "Calm volatility"
4 => "Discount / premium side"
=> "Gentle approach"
famGroup(int f) =>
f >= 1 and f <= 5 ? 1 : f
gName(int g) =>
g == 3 ? "A" : g == 2 ? "B" : g == 1 ? "C" : "–"
bump(array<int> a, int i) =>
a.set(i, a.get(i) + 1)
clampP(float p) =>
math.min(0.98, math.max(0.02, p))
lg(float p) =>
float q = clampP(p)
math.log(q / (1 - q))
shr(float h, float n, float base) =>
(h + kShr * base) / (n + kShr)
baseRate() =>
float n = tot.get(0) + tot.get(1)
n > 0 ? clampP(tot.get(0) / n) : 0.5
famN(int f) =>
famS.get(f * 2) + famS.get(f * 2 + 1)
famPct(int f) =>
float n = famN(f)
n > 0 ? 100.0 * famS.get(f * 2) / n : na
featPct(int k, bool v) =>
int i = (k * 2 + (v ? 1 : 0)) * 2
float n = featS.get(i) + featS.get(i + 1)
n > 0 ? 100.0 * featS.get(i) / n : na
gradeN(int g) =>
gS.get(g * 2) + gS.get(g * 2 + 1)
gradePct(int g) =>
float n = gradeN(g)
n > 0 ? 100.0 * gS.get(g * 2) / n : na
featTerm(int k, bool v, float base) =>
int i = (k * 2 + (v ? 1 : 0)) * 2
float n = featS.get(i) + featS.get(i + 1)
lg(shr(featS.get(i), n, base)) - lg(base)
scoreOf(int fam, bool f0, bool f1, bool f2, bool f3, bool f4, bool f5) =>
float base = baseRate()
float nf = famN(fam)
float s = lg(shr(famS.get(fam * 2), nf, base))
s += featTerm(0, f0, base)
s += featTerm(1, f1, base)
s += featTerm(2, f2, base)
s += featTerm(3, f3, base)
s += featTerm(4, f4, base)
s += featTerm(5, f5, base)
100 / (1 + math.exp(-s))
gradeOf(float sc) =>
int g = 0
if scoreHist.size() >= warmN
float qA = scoreHist.percentile_linear_interpolation(100 - pctA)
float qB = scoreHist.percentile_linear_interpolation(100 - pctA - pctB)
g := sc >= qA ? 3 : sc >= qB ? 2 : 1
g
hasConf(int i, float a) =>
bool r = false
Level l = lv.get(i)
for j = 0 to lv.size() - 1
if j != i
Level o = lv.get(j)
if (o.state == 0 or o.touchBar == bar_index) and o.fam != F_CTRL and famGroup(o.fam) != famGroup(l.fam) and math.abs(o.price - l.price) <= confTol * a
r := true
break
r
zoneOK(int side, float p, float mid) =>
not na(mid) and (side == 1 ? p < mid : p > mid)
// needSide: 1 = only if price is above the level, -1 = only if below, 0 = either
addLevel(array<Level> arr, float p, int f, float a, int needSide) =>
bool ok = not na(p) and not na(a) and a > 0 and p > 0
if ok
ok := math.abs(close - p) >= minDist * a
if ok and needSide != 0
ok := needSide == 1 ? close > p : close < p
if ok and arr.size() > 0
for i = 0 to arr.size() - 1
Level l = arr.get(i)
if l.fam == f and l.state == 0 and math.abs(l.price - p) < 0.05 * a
ok := false
break
if ok
arr.push(Level.new(price = p, fam = f, born = bar_index, side = close > p ? 1 : -1))
ok
finish(Level l, int res) =>
l.state := 2
if res != 0
int o = res == 1 ? 0 : 1
if l.fam == F_CTRL
bump(ctrl, o)
else
bump(tot, o)
bump(famS, l.fam * 2 + o)
bump(gS, l.grade * 2 + o)
bump(featS, (0 + (l.fTrend ? 1 : 0)) * 2 + o)
bump(featS, (2 + (l.fConf ? 1 : 0)) * 2 + o)
bump(featS, (4 + (l.fFresh ? 1 : 0)) * 2 + o)
bump(featS, (6 + (l.fCalm ? 1 : 0)) * 2 + o)
bump(featS, (8 + (l.fZone ? 1 : 0)) * 2 + o)
bump(featS, (10 + (l.fGentle ? 1 : 0)) * 2 + o)
if showMarks and l.fam != F_CTRL and res != 0 and l.grade >= minG
label.new(l.confBar, l.price, res == 1 ? "✓" : "✗", style = label.style_none,
textcolor = res == 1 ? (l.grade == 3 ? C_GOLD : C_SUP) : C_RES, size = size.normal,
tooltip = "Grade " + gName(l.grade) + " · " + famName(l.fam) + (res == 1 ? " — reaction followed through" : " — reaction failed"))
true
// ───────────── Series used by the engine (global scope on purpose)
float atr = ta.atr(14)
float atrAvg = ta.sma(atr, 100)
float emaF = ta.ema(close, emaFastL)
float emaS = ta.ema(close, emaSlowL)
bool upTr = emaF > emaS
bool calmNow = atr <= atrAvg
bool fastNow = math.abs(close - close[3]) > 1.5 * atr
float ph = ta.pivothigh(high, pivLen, pivLen)
float pl = ta.pivotlow(low, pivLen, pivLen)
bool newPer = timeframe.change(htf)
float prevC = close[1]
float h2 = high[2]
float l2 = low[2]
float rU = math.random(1.0, 3.0, 7)
float rS = math.random(0.0, 1.0, 11)
float rng = high - low
bool upDisp = rng > dispK * atr and close > open and close >= high - 0.3 * rng
bool dnDisp = rng > dispK * atr and close < open and close <= low + 0.3 * rng
bool fvgUp = low > h2 and low - h2 > 0.3 * atr
bool fvgDn = high < l2 and l2 - high > 0.3 * atr
float mag = math.pow(10, math.floor(math.log10(math.max(close, 0.0001))))
float rStep = stepIn > 0 ? stepIn : mag / 20
var float lastHi = na
var float lastLo = na
var float perHi = na
var float perLo = na
var float pMid = na
bool touchA = false
bool confA = false
bool confAB = false
// ───────────── Engine
if barstate.isconfirmed and not na(atr) and not na(atrAvg) and not na(emaS)
// 1. Update existing levels
if lv.size() > 0
for i = lv.size() - 1 to 0
Level l = lv.get(i)
bool real = l.fam != F_CTRL
if l.state == 0
bool touched = l.side == 1 ? low <= l.price : high >= l.price
if touched
l.state := 1
l.atrT := atr
l.touchBar := bar_index
l.ext := l.side == 1 ? low : high
if real
l.fTrend := (l.side == 1 and upTr) or (l.side == -1 and not upTr)
l.fConf := hasConf(i, atr)
l.fFresh := bar_index - l.born <= freshBars
l.fCalm := calmNow
l.fZone := zoneOK(l.side, l.price, pMid)
l.fGentle := not fastNow
l.score := scoreOf(l.fam, l.fTrend, l.fConf, l.fFresh, l.fCalm, l.fZone, l.fGentle)
l.grade := gradeOf(l.score)
scoreHist.push(l.score)
if scoreHist.size() > 600
scoreHist.shift()
if l.grade == 3
touchA := true
else if bar_index - l.born > maxAge
l.state := 2
if l.state == 1
l.ext := l.side == 1 ? math.min(l.ext, low) : math.max(l.ext, high)
float br = high - low
bool fail = l.side == 1 ? close < l.price - 0.25 * l.atrT : close > l.price + 0.25 * l.atrT
bool rej = l.side == 1 ? (close > l.price + 0.1 * l.atrT and close - low >= 0.5 * br) : (close < l.price - 0.1 * l.atrT and high - close >= 0.5 * br)
if fail
l.state := 2
else if rej
float e = close
float s = l.ext - l.side * 0.1 * l.atrT
float rk = math.max(math.abs(e - s), 0.3 * l.atrT)
if rk > 2.0 * l.atrT
l.state := 2
else
l.entry := e
l.stop := e - l.side * rk
l.tgt := e + l.side * rr * rk
l.confBar := bar_index
l.state := 3
if real and l.grade == 3
confA := true
if real and l.grade >= 2
confAB := true
else if bar_index - l.touchBar >= confBars - 1
l.state := 2
else if l.state == 3
bool hs = l.side == 1 ? low <= l.stop : high >= l.stop
bool ht = l.side == 1 ? high >= l.tgt : low <= l.tgt
if hs
finish(l, -1)
else if ht
finish(l, 1)
else if bar_index - l.confBar >= maxWait
finish(l, 0)
for i = lv.size() - 1 to 0
if lv.get(i).state == 2
lv.remove(i)
// 2. Create new levels
if not na(ph)
addLevel(lv, ph, F_SR, atr, 0)
if not na(lastLo) and ph > lastLo
float legU = ph - lastLo
addLevel(lv, ph - 0.382 * legU, F_F38, atr, 1)
addLevel(lv, ph - 0.500 * legU, F_F50, atr, 1)
addLevel(lv, ph - 0.618 * legU, F_F61, atr, 1)
addLevel(lv, ph - 0.786 * legU, F_HARM, atr, 1)
addLevel(lv, ph - 0.886 * legU, F_HARM, atr, 1)
addLevel(lv, ph + 0.272 * legU, F_EXT, atr, -1)
addLevel(lv, ph + 0.618 * legU, F_EXT, atr, -1)
lastHi := ph
addLevel(lv, close + (rS > 0.5 ? 1 : -1) * rU * atr, F_CTRL, atr, 0)
if not na(pl)
addLevel(lv, pl, F_SR, atr, 0)
if not na(lastHi) and pl < lastHi
float legD = lastHi - pl
addLevel(lv, pl + 0.382 * legD, F_F38, atr, -1)
addLevel(lv, pl + 0.500 * legD, F_F50, atr, -1)
addLevel(lv, pl + 0.618 * legD, F_F61, atr, -1)
addLevel(lv, pl + 0.786 * legD, F_HARM, atr, -1)
addLevel(lv, pl + 0.886 * legD, F_HARM, atr, -1)
addLevel(lv, pl - 0.272 * legD, F_EXT, atr, 1)
addLevel(lv, pl - 0.618 * legD, F_EXT, atr, 1)
lastLo := pl
addLevel(lv, close + (rS > 0.5 ? 1 : -1) * rU * atr, F_CTRL, atr, 0)
if upDisp
addLevel(lv, open, F_ZONE, atr, 1)
if dnDisp
addLevel(lv, open, F_ZONE, atr, -1)
if fvgUp
addLevel(lv, (low + h2) / 2, F_FVG, atr, 1)
if fvgDn
addLevel(lv, (high + l2) / 2, F_FVG, atr, -1)
if newPer
if not na(perHi) and not na(perLo)
float pc = prevC
float pp = (perHi + perLo + pc) / 3
addLevel(lv, perHi, F_PREV, atr, 0)
addLevel(lv, perLo, F_PREV, atr, 0)
addLevel(lv, pc, F_PREV, atr, 0)
addLevel(lv, pp, F_PIV, atr, 0)
addLevel(lv, 2 * pp - perLo, F_PIV, atr, 0)
addLevel(lv, 2 * pp - perHi, F_PIV, atr, 0)
addLevel(lv, pp + (perHi - perLo), F_PIV, atr, 0)
addLevel(lv, pp - (perHi - perLo), F_PIV, atr, 0)
float sq = math.sqrt(pc)
addLevel(lv, math.pow(sq + 0.25, 2), F_GANN, atr, 0)
addLevel(lv, math.pow(sq + 0.50, 2), F_GANN, atr, 0)
addLevel(lv, math.pow(sq + 1.00, 2), F_GANN, atr, 0)
addLevel(lv, math.pow(sq - 0.25, 2), F_GANN, atr, 0)
addLevel(lv, math.pow(sq - 0.50, 2), F_GANN, atr, 0)
addLevel(lv, math.pow(sq - 1.00, 2), F_GANN, atr, 0)
pMid := (perHi + perLo) / 2
perHi := high
perLo := low
else
perHi := na(perHi) ? high : math.max(perHi, high)
perLo := na(perLo) ? low : math.min(perLo, low)
addLevel(lv, math.ceil(close / rStep) * rStep, F_ROUND, atr, 0)
addLevel(lv, math.floor(close / rStep) * rStep, F_ROUND, atr, 0)
while lv.size() > 400
lv.shift()
// ───────────── Live map and table
var array<label> dLabels = array.new<label>()
var array<box> dBoxes = array.new<box>()
tblPos = switch tblPosIn
"Top left" => position.top_left
"Bottom right" => position.bottom_right
"Bottom left" => position.bottom_left
=> position.top_right
var table tb = table.new(tblPos, 4, 16, bgcolor = color.new(C_PANEL, 5), border_width = 1, border_color = color.new(C_MUTE, 85), frame_width = 1, frame_color = color.new(C_MUTE, 60))
cell(int c, int r, string s, color tc, color bg) =>
table.cell(tb, c, r, s, text_color = tc, bgcolor = bg, text_size = tsz, text_halign = text.align_left)
pctTxt(float p) =>
na(p) ? "–" : str.tostring(p, "0") + "%"
drawBand(Level l, int g, float a, float rndP, bool active) =>
color base = l.side == 1 ? C_SUP : C_RES
float gp = gradePct(g)
string role = l.side == 1 ? "support" : "resistance"
string txt = (active ? "◆ " : "") + (g == 3 ? "★ A" : gName(g)) + " " + famName(l.fam) + " · " + pctTxt(gp)
string tip = famName(l.fam) + " " + role + " at " + str.tostring(l.price, format.mintick) + "\nGrade " + gName(g) + ": " + pctTxt(gp) + " of " + str.tostring(gradeN(g)) +
" confirmed reactions followed through on this chart (random lines: " + pctTxt(rndP) + ")" +
(active ? "\nReaction confirmed. Reaction extreme: " + str.tostring(l.stop, format.mintick) + " · " + str.tostring(rr) + "x reference: " + str.tostring(l.tgt, format.mintick) : "")
dBoxes.push(box.new(l.born, l.price + bandK * a, bar_index, l.price - bandK * a, border_color = color.new(base, g == 3 ? 40 : 75), border_width = 1,
bgcolor = color.new(base, active ? 60 : g == 3 ? 72 : g == 2 ? 84 : 92), extend = extend.right))
dLabels.push(label.new(bar_index + 4, l.price, txt, style = label.style_label_left, color = g == 3 ? color.new(C_GOLD, 5) : color.new(base, 78),
textcolor = g == 3 ? color.black : base, size = size.small, tooltip = tip))
true
if barstate.islast
while dLabels.size() > 0
label.delete(dLabels.pop())
while dBoxes.size() > 0
box.delete(dBoxes.pop())
float cN = ctrl.get(0) + ctrl.get(1)
float rndP = cN > 0 ? 100.0 * ctrl.get(0) / cN : na
bool ready = scoreHist.size() >= warmN
string nearUp = "none"
string nearDn = "none"
if ready and lv.size() > 0
// live confirmed reactions
for i = 0 to lv.size() - 1
Level l = lv.get(i)
if l.state == 3 and l.fam != F_CTRL and l.grade >= minG
drawBand(l, l.grade, atr, rndP, true)
// waiting levels: nearest candidates each side, best score first, merged
array<float> dUp = array.new<float>()
array<int> iUp = array.new<int>()
array<float> dDn = array.new<float>()
array<int> iDn = array.new<int>()
for i = 0 to lv.size() - 1
Level l = lv.get(i)
if l.state == 0 and l.fam != F_CTRL
if l.price >= close
dUp.push(l.price - close)
iUp.push(i)
else
dDn.push(close - l.price)
iDn.push(i)
array<int> oUp = dUp.sort_indices(order.ascending)
array<int> oDn = dDn.sort_indices(order.ascending)
for sd = 0 to 1
array<int> ord = sd == 0 ? oUp : oDn
array<int> idx = sd == 0 ? iUp : iDn
int cnt = math.min(25, ord.size())
array<int> cI = array.new<int>()
array<float> cS = array.new<float>()
array<int> cG = array.new<int>()
if cnt > 0
for k = 0 to cnt - 1
int li = idx.get(ord.get(k))
Level l = lv.get(li)
bool tr = (l.side == 1 and upTr) or (l.side == -1 and not upTr)
float sc = scoreOf(l.fam, tr, hasConf(li, atr), bar_index - l.born <= freshBars, calmNow, zoneOK(l.side, l.price, pMid), not fastNow)
int g = gradeOf(sc)
if g >= minG
cI.push(li)
cS.push(sc)
cG.push(g)
array<int> so = cS.sort_indices(order.descending)
array<float> picked = array.new<float>()
float bestD = na
if so.size() > 0
for m = 0 to so.size() - 1
if picked.size() < nShow
Level l = lv.get(cI.get(so.get(m)))
int g = cG.get(so.get(m))
bool near = false
if picked.size() > 0
for q = 0 to picked.size() - 1
if math.abs(picked.get(q) - l.price) < mergeK * atr
near := true
break
if not near
picked.push(l.price)
drawBand(l, g, atr, rndP, false)
float d = math.abs(l.price - close)
if na(bestD) or d < bestD
bestD := d
string nr = gName(g) + " · " + str.tostring(l.price, format.mintick) + " · " + famName(l.fam) + " · " + str.tostring(d / atr, "0.0") + " ATR"
if sd == 0
nearUp := nr
else
nearDn := nr
if showTable
int r = 0
cell(0, r, "LEVEL EVIDENCE MAP · " + modeTxt + " mode\nwalk-forward record on this chart", C_GOLD, C_HEAD)
table.merge_cells(tb, 0, r, 3, r)
r += 1
if not ready
cell(0, r, "Learning this chart: " + str.tostring(scoreHist.size()) + " of " + str.tostring(warmN) + " touches seen.\nLoad more history or use a lower timeframe.", C_TEXT, na)
table.merge_cells(tb, 0, r, 3, r)
r += 1
else
if showGrades
cell(0, r, "Grade", C_MUTE, na)
cell(1, r, "Reactions", C_MUTE, na)
cell(2, r, "Followed through", C_MUTE, na)
cell(3, r, "vs random", C_MUTE, na)
r += 1
for g = 3 to 1
float gp = gradePct(g)
float df = gp - rndP
color gc = g == 3 ? C_GOLD : g == 2 ? C_TEXT : C_MUTE
cell(0, r, g == 3 ? "★ A" : g == 2 ? "B" : "C", gc, na)
cell(1, r, str.tostring(gradeN(g)), gc, na)
cell(2, r, pctTxt(gp), gc, na)
cell(3, r, na(df) ? "–" : str.tostring(df, "+0;-0") + " pts", na(df) ? C_MUTE : df >= 5 ? C_SUP : df <= -5 ? C_RES : C_MUTE, na)
r += 1
cell(0, r, "Random lines", C_MUTE, na)
cell(1, r, str.tostring(cN, "0"), C_MUTE, na)
cell(2, r, pctTxt(rndP), C_MUTE, na)
cell(3, r, "baseline", C_MUTE, na)
r += 1
if showDrivers
array<float> gaps = array.new<float>()
for k = 0 to NFEAT - 1
float d = featPct(k, true) - featPct(k, false)
gaps.push(na(d) ? 0.0 : math.abs(d))
array<int> go = gaps.sort_indices(order.descending)
cell(0, r, "WHAT HELPED HERE", C_GOLD, C_HEAD)
cell(1, r, "yes", C_MUTE, C_HEAD)
cell(2, r, "no", C_MUTE, C_HEAD)
cell(3, r, "gap", C_MUTE, C_HEAD)
r += 1
for m = 0 to 2
int k = go.get(m)
float py = featPct(k, true)
float pn = featPct(k, false)
float d = py - pn
cell(0, r, featName(k), C_TEXT, na)
cell(1, r, pctTxt(py), C_TEXT, na)
cell(2, r, pctTxt(pn), C_TEXT, na)
cell(3, r, na(d) ? "–" : str.tostring(d, "+0;-0") + " pts", na(d) ? C_MUTE : d >= 3 ? C_SUP : d <= -3 ? C_RES : C_MUTE, na)
r += 1
if showTypes
array<float> fp = array.new<float>()
for f = 0 to NFAM - 1
fp.push(famN(f) >= 30 ? famPct(f) : -1.0)
array<int> fo = fp.sort_indices(order.descending)
string best = ""
for m = 0 to 2
int f = fo.get(m)
if fp.get(f) >= 0
best += (best == "" ? "" : "\n") + famName(f) + " " + pctTxt(fp.get(f)) + " (" + str.tostring(famN(f)) + ")"
cell(0, r, "Best level types\n" + (best == "" ? "not enough reactions yet" : best), C_TEXT, na)
table.merge_cells(tb, 0, r, 3, r)
r += 1
if showNear
cell(0, r, "Above: " + nearUp + "\nBelow: " + nearDn, C_TEXT, na)
table.merge_cells(tb, 0, r, 3, r)
r += 1
cell(0, r, "Followed through = after a rejection close,\nprice moved " + str.tostring(rr) + "x the risk before undoing it.\nPast behaviour; not a recommendation.", C_MUTE, na)
table.merge_cells(tb, 0, r, 3, r)
// ───────────── Alerts
alertcondition(touchA, "Price touched a Grade A band", "Level Evidence Map: price touched a Grade A band")
alertcondition(confA, "Reaction confirmed at a Grade A band", "Level Evidence Map: reaction confirmed at a Grade A band")
alertcondition(confAB, "Reaction confirmed at a Grade A or B band", "Level Evidence Map: reaction confirmed at a Grade A or B band")