本页源码来自 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/
// © EyeAlgo
//@version=6
indicator("Eye Pattern Failure Trap [EyeAlgo]", "Eye Pattern Failure Trap [Eyealgo]", overlay = true, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500, max_bars_back = 5000)
// ═══════════════════════ INPUTS ═══════════════════════
string G_PAT = "Patterns watched"
bool useRange = input.bool(true, "Range Box", inline = "rg", group = G_PAT)
int rangeLen = input.int(20, "bars", minval = 8, maxval = 100, inline = "rg", group = G_PAT)
float rangeMaxW = input.float(3.0, "Range Box max height (ATR)", minval = 0.5, maxval = 10, step = 0.1, group = G_PAT, tooltip = "A Range Box is drawn when the last N bars stayed inside this many ATRs.")
bool useDouble = input.bool(true, "Double Top / Bottom", inline = "db", group = G_PAT)
float dblTol = input.float(0.5, "tolerance (ATR)", minval = 0.05, maxval = 3, step = 0.05, inline = "db", group = G_PAT)
bool useTri = input.bool(true, "Triangle (ascending / descending / symmetrical)", group = G_PAT)
bool useIB = input.bool(true, "Inside Bar", inline = "ib", group = G_PAT)
float ibMin = input.float(1.0, "min mother bar (ATR)", minval = 0.2, maxval = 5, step = 0.1, inline = "ib", group = G_PAT)
int pivLen = input.int(5, "Swing length (Double / Triangle)", minval = 2, maxval = 20, group = G_PAT)
string G_TRP = "Breakout & trap rules"
float brkBuf = input.float(0.10, "Breakout buffer (ATR)", minval = 0, maxval = 2, step = 0.05, group = G_TRP, tooltip = "A breakout needs a bar CLOSE this far beyond the pattern edge.")
int failWin = input.int(5, "Failure window (bars)", minval = 1, maxval = 30, group = G_TRP, tooltip = "If price closes back inside the pattern within this many bars after the breakout, the breakout is marked FAILED and a trap signal prints in the opposite direction.")
int waitMax = input.int(40, "Pattern expires after (bars)", minval = 5, maxval = 200, group = G_TRP, tooltip = "Inside Bar patterns expire after 12 bars at most.")
float stopPad = input.float(0.10, "Stop beyond trap extreme (ATR)", minval = 0, maxval = 2, step = 0.05, group = G_TRP)
float minRR = input.float(1.0, "Minimum target (R)", minval = 0.5, maxval = 5, step = 0.1, group = G_TRP, tooltip = "Target = opposite edge of the pattern, but never closer than this many R.")
int tradeTO = input.int(60, "Trap trade time-out (bars)", minval = 5, maxval = 300, group = G_TRP)
string G_VIS = "Display"
bool showHeld = input.bool(false, "Show breakouts that held", group = G_VIS)
bool showPlan = input.bool(true, "Show trade plan (entry / stop / target)", group = G_VIS)
int keepN = input.int(25, "Traps kept on chart", minval = 5, maxval = 60, group = G_VIS)
bool showDash = input.bool(true, "Show failure funnel", group = G_VIS)
int fOff = input.int(25, "Funnel distance from last bar (bars)", minval = 5, maxval = 200, group = G_VIS)
float fSize = input.float(1.0, "Funnel height (ATR scale)", minval = 0.3, maxval = 5, step = 0.1, group = G_VIS)
string dashTxt = input.string("Small", "Funnel text size", options = ["Tiny", "Small", "Normal"], group = G_VIS)
int listN = input.int(4, "Failed patterns listed", minval = 0, maxval = 8, group = G_VIS)
color cBuy = input.color(#089981, "Bear trap (buy) colour", group = G_VIS)
color cSell = input.color(#F23645, "Bull trap (sell) colour", group = G_VIS)
color cPat = input.color(#787B86, "Pattern colour", group = G_VIS)
// ═══════════════════════ TYPES ═══════════════════════
type Pat
int kind
string nm
int x1
int born
float uY
int uX
float uS
float lY
int lX
float lS
int state = 0
int brkBar = 0
float lvl
float ext
box bx
line ln1
line ln2
type Trade
int kind
string nm
int dir
int bar
float entry
float stop
float tgt
int grade
int result = 0
line lE
line lS
line lT
label lb
method upAt(Pat p, int b) => p.uY + p.uS * (b - p.uX)
method loAt(Pat p, int b) => p.lY + p.lS * (b - p.lX)
method wipe(Pat p) =>
if not na(p.bx)
box.delete(p.bx)
if not na(p.ln1)
line.delete(p.ln1)
if not na(p.ln2)
line.delete(p.ln2)
method wipe(Trade t) =>
if not na(t.lE)
line.delete(t.lE)
line.delete(t.lS)
line.delete(t.lT)
if not na(t.lb)
label.delete(t.lb)
t.lE := na
t.lS := na
t.lT := na
t.lb := na
f_stars(int g) => g >= 3 ? "⭐⭐⭐" : g == 2 ? "⭐⭐" : g == 1 ? "⭐" : "–"
f_txt(color c) => 0.299 * color.r(c) + 0.587 * color.g(c) + 0.114 * color.b(c) > 140 ? #000000 : #FFFFFF
f_pct(int a, int b) => b > 0 ? 100.0 * a / b : na
f_pt(int x, float y) => chart.point.from_index(x, y)
f_box(int x1, float top, float bot, string nm) =>
box.new(x1, top, bar_index, bot, border_color = color.new(cPat, 30), bgcolor = color.new(cPat, 92), border_style = line.style_dashed, text = nm, text_size = size.tiny, text_color = cPat, text_halign = text.align_left, text_valign = text.align_top)
// ═══════════════════════ DATA ═══════════════════════
float atr = ta.atr(14)
float ph = ta.pivothigh(high, pivLen, pivLen)
float pl = ta.pivotlow(low, pivLen, pivLen)
float rHi = ta.highest(high, rangeLen)[1]
float rLo = ta.lowest(low, rangeLen)[1]
var array<Pat> pats = array.new<Pat>()
var array<Pat> keptP = array.new<Pat>()
var array<Trade> openT = array.new<Trade>()
var array<Trade> allT = array.new<Trade>()
var array<float> phV = array.new<float>()
var array<int> phX = array.new<int>()
var array<float> plV = array.new<float>()
var array<int> plX = array.new<int>()
var array<int> nBrk = array.new<int>(4, 0)
var array<int> nFail = array.new<int>(4, 0)
var array<int> nWin = array.new<int>(4, 0)
var array<int> nLoss = array.new<int>(4, 0)
var array<string> kName = array.from("Range Box", "Double Top/Bottom", "Triangle", "Inside Bar")
var int lastTrapBar = -1
var int lastTrapDir = 0
var Trade lastTrade = na
bool sigBuy = false
bool sigSell = false
string sigTxt = ""
// ═══════════════════════ ENGINE (bar close only) ═══════════════════════
if barstate.isconfirmed and not na(atr)
float buf = brkBuf * atr
// 1) swings
if not na(ph)
phV.unshift(ph)
phX.unshift(bar_index - pivLen)
if phV.size() > 3
phV.pop()
phX.pop()
if not na(pl)
plV.unshift(pl)
plX.unshift(bar_index - pivLen)
if plV.size() > 3
plV.pop()
plX.pop()
// 2) open trap trades → target / stop / time-out
if openT.size() > 0
for i = openT.size() - 1 to 0
Trade tr = openT.get(i)
if bar_index > tr.bar
bool hitS = tr.dir == 1 ? low <= tr.stop : high >= tr.stop
bool hitT = tr.dir == 1 ? high >= tr.tgt : low <= tr.tgt
int res = hitS ? -1 : hitT ? 1 : bar_index - tr.bar >= tradeTO ? 2 : 0
if not na(tr.lE)
line.set_x2(tr.lE, bar_index)
line.set_x2(tr.lS, bar_index)
line.set_x2(tr.lT, bar_index)
if res != 0
tr.result := res
if res == 1
nWin.set(tr.kind, nWin.get(tr.kind) + 1)
else if res == -1
nLoss.set(tr.kind, nLoss.get(tr.kind) + 1)
openT.remove(i)
// 3) patterns → breakout → failed (trap) or held
if pats.size() > 0
for i = pats.size() - 1 to 0
Pat p = pats.get(i)
float up = p.upAt(bar_index)
float lo = p.loAt(bar_index)
if not na(p.bx)
box.set_right(p.bx, bar_index)
if not na(p.ln1)
line.set_xy2(p.ln1, bar_index, up)
line.set_xy2(p.ln2, bar_index, lo)
if p.state == 0
int life = p.kind == 3 ? math.min(waitMax, 12) : waitMax
if close > up + buf
p.state := 1
p.brkBar := bar_index
p.lvl := up
p.ext := high
else if close < lo - buf
p.state := -1
p.brkBar := bar_index
p.lvl := lo
p.ext := low
else if bar_index - p.born > life or up - lo <= 0
p.wipe()
pats.remove(i)
else
bool trapped = false
if p.state == 1
p.ext := math.max(p.ext, high)
trapped := close < p.lvl
else
p.ext := math.min(p.ext, low)
trapped := close > p.lvl
if trapped or bar_index - p.brkBar >= failWin
int prevB = nBrk.get(p.kind)
int prevF = nFail.get(p.kind)
nBrk.set(p.kind, prevB + 1)
if trapped
nFail.set(p.kind, prevF + 1)
int dir = -p.state
int g = 0
g += math.abs(close - p.lvl) >= 0.3 * atr ? 1 : 0
g += bar_index - p.brkBar <= 2 ? 1 : 0
g += prevB >= 5 and prevF * 2 >= prevB ? 1 : 0
float entry = close
float stop = dir == -1 ? p.ext + stopPad * atr : p.ext - stopPad * atr
float risk = math.abs(entry - stop)
float dist = dir == -1 ? entry - lo : up - entry
float tgt = entry + dir * math.max(dist, minRR * risk)
Trade nt = Trade.new(kind = p.kind, nm = p.nm, dir = dir, bar = bar_index, entry = entry, stop = stop, tgt = tgt, grade = g)
color c = dir == 1 ? cBuy : cSell
string head = dir == -1 ? "▼ BULL TRAP" : "▲ BEAR TRAP"
if lastTrapBar == bar_index and lastTrapDir == dir and not na(lastTrade) and not na(lastTrade.lb)
label.set_text(lastTrade.lb, label.get_text(lastTrade.lb) + "\n+ " + p.nm + " " + f_stars(g))
else
nt.lb := label.new(bar_index, dir == -1 ? high : low, head + "\n" + p.nm + " " + f_stars(g), style = dir == -1 ? label.style_label_down : label.style_label_up, color = c, textcolor = f_txt(c), size = size.small, text_formatting = text.format_bold)
if showPlan
nt.lE := line.new(bar_index, entry, bar_index + 1, entry, color = color.new(cPat, 0), style = line.style_dotted, width = 1)
nt.lS := line.new(bar_index, stop, bar_index + 1, stop, color = cSell, style = line.style_dashed, width = 1)
nt.lT := line.new(bar_index, tgt, bar_index + 1, tgt, color = cBuy, style = line.style_dashed, width = 1)
lastTrapBar := bar_index
lastTrapDir := dir
lastTrade := nt
openT.push(nt)
allT.push(nt)
if allT.size() > keepN
allT.shift().wipe()
if dir == 1
sigBuy := true
else
sigSell := true
sigTxt += syminfo.ticker + " " + head + " · " + p.nm + " · entry " + str.tostring(entry, format.mintick) + " stop " + str.tostring(stop, format.mintick) + " target " + str.tostring(tgt, format.mintick) + "\n"
if not na(p.bx)
box.set_border_color(p.bx, c)
box.set_border_style(p.bx, line.style_solid)
box.set_bgcolor(p.bx, color.new(c, 88))
box.set_text_color(p.bx, c)
box.set_text(p.bx, p.nm + " · FAILED")
if not na(p.ln1)
line.set_color(p.ln1, c)
line.set_color(p.ln2, c)
line.set_width(p.ln1, 2)
line.set_width(p.ln2, 2)
keptP.push(p)
else
if showHeld
if not na(p.bx)
box.set_bgcolor(p.bx, color.new(cPat, 96))
box.set_text(p.bx, p.nm + " · held")
keptP.push(p)
else
p.wipe()
if keptP.size() > keepN
keptP.shift().wipe()
pats.remove(i)
// 4) new patterns
array<int> cnt = array.new<int>(4, 0)
for pp in pats
cnt.set(pp.kind, cnt.get(pp.kind) + 1)
// Range Box
if useRange and cnt.get(0) == 0 and not na(rHi) and not na(rLo)
float rh = rHi - rLo
if rh <= rangeMaxW * atr and rh >= 0.5 * atr and close <= rHi and close >= rLo
int x1 = math.max(bar_index - rangeLen, bar_index - 4900)
Pat np = Pat.new(kind = 0, nm = "Range Box", x1 = x1, born = bar_index, uY = rHi, uX = bar_index, uS = 0.0, lY = rLo, lX = bar_index, lS = 0.0)
np.bx := f_box(x1, rHi, rLo, "Range Box")
pats.push(np)
// Double Top
if useDouble and not na(ph) and phV.size() >= 2 and cnt.get(1) < 2
float a = phV.get(0)
float b = phV.get(1)
int xa = phX.get(0)
int xb = phX.get(1)
if math.abs(a - b) <= dblTol * atr and xa - xb >= pivLen and bar_index - xb <= 300
float nl = low[bar_index - xa]
for k = bar_index - xa to bar_index - xb
nl := math.min(nl, low[k])
float top = math.max(a, b)
if top - nl >= atr and close > nl and close < top
int x1 = math.max(xb, bar_index - 4900)
Pat np = Pat.new(kind = 1, nm = "Double Top", x1 = x1, born = bar_index, uY = top, uX = bar_index, uS = 0.0, lY = nl, lX = bar_index, lS = 0.0)
np.bx := f_box(x1, top, nl, "Double Top")
pats.push(np)
// Double Bottom
if useDouble and not na(pl) and plV.size() >= 2 and cnt.get(1) < 2
float a = plV.get(0)
float b = plV.get(1)
int xa = plX.get(0)
int xb = plX.get(1)
if math.abs(a - b) <= dblTol * atr and xa - xb >= pivLen and bar_index - xb <= 300
float nh = high[bar_index - xa]
for k = bar_index - xa to bar_index - xb
nh := math.max(nh, high[k])
float bot = math.min(a, b)
if nh - bot >= atr and close < nh and close > bot
int x1 = math.max(xb, bar_index - 4900)
Pat np = Pat.new(kind = 1, nm = "Double Bottom", x1 = x1, born = bar_index, uY = nh, uX = bar_index, uS = 0.0, lY = bot, lX = bar_index, lS = 0.0)
np.bx := f_box(x1, nh, bot, "Double Bottom")
pats.push(np)
// Triangle
if useTri and (not na(ph) or not na(pl)) and phV.size() >= 2 and plV.size() >= 2 and cnt.get(2) == 0
float h1 = phV.get(0)
float h2 = phV.get(1)
float l1 = plV.get(0)
float l2 = plV.get(1)
int xh1 = phX.get(0)
int xh2 = phX.get(1)
int xl1 = plX.get(0)
int xl2 = plX.get(1)
float uS = (h1 - h2) / (xh1 - xh2)
float lS = (l1 - l2) / (xl1 - xl2)
float ft = 0.015 * atr
int x1 = math.max(math.min(xh2, xl2), bar_index - 4900)
if uS <= ft and lS >= -ft and (uS < -ft or lS > ft) and bar_index - x1 <= 300
float upNow = h1 + uS * (bar_index - xh1)
float loNow = l1 + lS * (bar_index - xl1)
if upNow - loNow >= 0.5 * atr and close < upNow and close > loNow
string tn = uS >= -ft ? "Ascending Triangle" : lS <= ft ? "Descending Triangle" : "Symmetrical Triangle"
Pat np = Pat.new(kind = 2, nm = tn, x1 = x1, born = bar_index, uY = h1, uX = xh1, uS = uS, lY = l1, lX = xl1, lS = lS)
np.ln1 := line.new(x1, np.upAt(x1), bar_index, upNow, color = color.new(cPat, 20), style = line.style_dashed, width = 1)
np.ln2 := line.new(x1, np.loAt(x1), bar_index, loNow, color = color.new(cPat, 20), style = line.style_dashed, width = 1)
pats.push(np)
// Inside Bar (current bar inside the mother bar)
if useIB and cnt.get(3) == 0 and high <= high[1] and low >= low[1] and high[1] - low[1] >= ibMin * atr
Pat np = Pat.new(kind = 3, nm = "Inside Bar", x1 = bar_index - 1, born = bar_index, uY = high[1], uX = bar_index, uS = 0.0, lY = low[1], lX = bar_index, lS = 0.0)
np.bx := f_box(bar_index - 1, high[1], low[1], "Inside Bar")
pats.push(np)
// ═══════════════════════ ALERTS ═══════════════════════
alertcondition(barstate.isconfirmed and sigSell, "Bull Trap (sell)", "Eye Pattern Failure Trap: BULL TRAP (failed upside breakout) on {{ticker}} {{interval}}")
alertcondition(barstate.isconfirmed and sigBuy, "Bear Trap (buy)", "Eye Pattern Failure Trap: BEAR TRAP (failed downside breakout) on {{ticker}} {{interval}}")
alertcondition(barstate.isconfirmed and (sigBuy or sigSell), "Any trap", "Eye Pattern Failure Trap: trap signal on {{ticker}} {{interval}}")
if sigTxt != ""
alert("Eye Pattern Failure Trap\n" + sigTxt, alert.freq_once_per_bar_close)
// ═══════════════════════ FAILURE FUNNEL (beside the last bar) ═══════════════════════
var array<polyline> fPoly = array.new<polyline>()
var array<label> fLab = array.new<label>()
if barstate.islast
for fp in fPoly
polyline.delete(fp)
fPoly.clear()
for fl in fLab
label.delete(fl)
fLab.clear()
if showDash and not na(atr)
string ts = dashTxt == "Tiny" ? size.tiny : dashTxt == "Normal" ? size.normal : size.small
color fg = chart.fg_color
color pb = color.new(fg, 88)
int tB = 0
int tF = 0
int tW = 0
int tL = 0
for k = 0 to 3
tB += nBrk.get(k)
tF += nFail.get(k)
tW += nWin.get(k)
tL += nLoss.get(k)
float allF = f_pct(tF, tB)
float allW = f_pct(tW, tW + tL)
// funnel geometry
int cx = bar_index + fOff + 15
float H = 4.0 * atr * fSize
float h = H / 3.2
float g = H * 0.05
float t1 = close + H / 2
float b1 = t1 - h
float t2 = b1 - g
float b2 = t2 - h
float t3 = b2 - g
float b3 = t3 - h
fPoly.push(polyline.new(array.from(f_pt(cx - 15, t1), f_pt(cx + 15, t1), f_pt(cx + 9, b1), f_pt(cx - 9, b1)), closed = true, line_color = cPat, fill_color = color.new(cPat, 10)))
fPoly.push(polyline.new(array.from(f_pt(cx - 9, t2), f_pt(cx + 9, t2), f_pt(cx + 5, b2), f_pt(cx - 5, b2)), closed = true, line_color = cSell, fill_color = color.new(cSell, 10)))
fPoly.push(polyline.new(array.from(f_pt(cx - 5, t3), f_pt(cx + 5, t3), f_pt(cx + 5, b3), f_pt(cx - 5, b3)), closed = true, line_color = cBuy, fill_color = color.new(cBuy, 10)))
fLab.push(label.new(cx, t1 + 0.45 * atr * fSize, "◉ EYE PATTERN FAILURE TRAP · " + syminfo.ticker, style = label.style_label_center, color = pb, textcolor = fg, size = ts, text_formatting = text.format_bold))
fLab.push(label.new(cx, (t1 + b1) / 2, "BREAKOUTS " + str.tostring(tB), style = label.style_none, textcolor = f_txt(cPat), size = ts, text_formatting = text.format_bold))
fLab.push(label.new(cx, (t2 + b2) / 2, "FAILED " + str.tostring(tF) + "\n" + (na(allF) ? "–" : str.tostring(allF, "0") + "%") + " trap", style = label.style_none, textcolor = f_txt(cSell), size = ts, text_formatting = text.format_bold))
fLab.push(label.new(cx, (t3 + b3) / 2, str.tostring(tW) + "\ntarget", style = label.style_none, textcolor = f_txt(cBuy), size = ts, text_formatting = text.format_bold))
// best pattern + per-pattern failure %
string bestN = "–"
float bestP = na
string perP = ""
for k = 0 to 3
bool on = k == 0 ? useRange : k == 1 ? useDouble : k == 2 ? useTri : useIB
float fpk = f_pct(nFail.get(k), nBrk.get(k))
perP += (k > 0 ? " · " : "") + kName.get(k) + " " + (not on ? "off" : na(fpk) ? "–" : str.tostring(fpk, "0") + "%")
if on and not na(fpk) and (na(bestP) or fpk > bestP)
bestP := fpk
bestN := kName.get(k)
string info = "Trap → target " + (na(allW) ? "–" : str.tostring(allW, "0") + "%") + " (" + str.tostring(tW + tL) + " closed)"
info += "\nMost failed: " + bestN + (na(bestP) ? "" : " " + str.tostring(bestP, "0") + "%")
info += "\n" + perP
int n = allT.size()
if listN > 0 and n > 0
info += "\n\nFAILED PATTERN LIST · latest first"
for j = 0 to math.min(listN, n) - 1
Trade lt = allT.get(n - 1 - j)
string res = lt.result == 1 ? "✔ Target" : lt.result == -1 ? "✖ Stop" : lt.result == 2 ? "⌛ Time-out" : "⏳ Open"
info += "\n" + (lt.dir == -1 ? "▼ Bull trap " : "▲ Bear trap ") + f_stars(lt.grade) + " · " + lt.nm + " · " + str.tostring(bar_index - lt.bar) + " bars ago · " + res
fLab.push(label.new(cx, b3 - g, info, style = label.style_label_up, color = pb, textcolor = fg, size = ts, textalign = text.align_center))