Eye Pattern Failure Trap [EyeAlgo]

eyealgo · study · 424 行 · 点赞 281 · TradingView 原页

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

Pine Script

// 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))

← 返回列表