Signals & Overlays [Jayadev Rana]

JayadevRana · study · 297 行 · 点赞 422 · TradingView 原页

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

Pine Script

//@version=6
indicator("Signals & Overlays  [Jayadev Rana]", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500)
 
// ---------------------------------------------------------------------------
// 1. INPUTS  (mirrors the original dialog: groups, order, defaults, options)
// ---------------------------------------------------------------------------
grpBasic   = "BASIC SETTINGS"
preset     = input.string("None", "Presets/Filters", options = ["None", "Trend Trader [Preset]", "Scalper [Preset]", "Swing Trader [Preset]", "Contrarian Trader [Preset]", "Smart Trail [Filter]", "Trend Tracer [Filter]", "Trend Catcher [Filter]", "Neo Cloud [Filter]", "Trend Strength [Filter]"], group = grpBasic)
sigMode    = input.string("Confirmation + Exits", "Signal Mode", options = ["Confirmation + Exits", "Contrarian + Exits", "None"], group = grpBasic)
sigClass   = input.bool(false, "Signal Classifier", group = grpBasic)
sens       = input.int(12, "Signals Sensitivity", minval = 1, group = grpBasic)
candleMode = input.string("Confirmation Simple", "Candle Coloring", options = ["Confirmation Simple", "Confirmation Gradient", "Contrarian Gradient", "None"], group = grpBasic)
bullCol    = input.color(color.new(#35cd78, 0), "Signal Colors ", inline = "sc", group = grpBasic)
bearCol    = input.color(color.new(#ff0000, 0), "", inline = "sc", group = grpBasic)
exitBullCol= input.color(#2962ff, "Exit Colors    ", inline = "ec", group = grpBasic)
exitBearCol= input.color(#ff8a00, "", inline = "ec", group = grpBasic)
cBullCol   = input.color(#35cd78, "Candle Colors", inline = "cc", group = grpBasic)
cNeutCol   = input.color(#673ab7, "", inline = "cc", group = grpBasic)
cBearCol   = input.color(#ff0000, "", inline = "cc", group = grpBasic)
 
grpOv      = "INDICATOR OVERLAY"
useST      = input.bool(true,  "Smart Trail     ", inline = "st", group = grpOv)
stP        = input.string("3", "", options = ["1","2","3","4","5"], inline = "st", group = grpOv)
stUpCol    = input.color(#3179f5, "", inline = "st", group = grpOv)
stDnCol    = input.color(#f7525f, "", inline = "st", group = grpOv)
useRZ      = input.bool(false, "Reversal Zones", inline = "rz", group = grpOv)
rzP        = input.string("3", "", options = ["1","2","3","4","5"], inline = "rz", group = grpOv)
rzUpCol    = input.color(color.new(#f23645, 70), "", inline = "rz", group = grpOv)
rzDnCol    = input.color(color.new(#089981, 70), "", inline = "rz", group = grpOv)
useTC      = input.bool(false, "Trend Catcher ", inline = "tc", group = grpOv)
tcP        = input.string("3", "", options = ["1","2","3","4","5"], inline = "tc", group = grpOv)
tcUpCol    = input.color(#00ff64, "", inline = "tc", group = grpOv)
tcDnCol    = input.color(#ff1100, "", inline = "tc", group = grpOv)
useTT      = input.bool(false, "Trend Tracer   ", inline = "tt", group = grpOv)
ttP        = input.string("3", "", options = ["1","2","3","4","5"], inline = "tt", group = grpOv)
ttUpCol    = input.color(#2962ff, "", inline = "tt", group = grpOv)
ttDnCol    = input.color(#ff9800, "", inline = "tt", group = grpOv)
useNeo     = input.bool(false, "Neo Cloud      ", inline = "neo", group = grpOv)
neoP       = input.string("2", "", options = ["1","2","3","4","5"], inline = "neo", group = grpOv)
neoUpCol   = input.color(color.new(#0d6719, 40), "", inline = "neo", group = grpOv)
neoDnCol   = input.color(color.new(#892928, 40), "", inline = "neo", group = grpOv)
 
grpTP      = "TAKE PROFITS/STOP LOSSES"
tpMode     = input.string("None", "TP/SL Levels", options = ["None", "Signals", "Smart Trail", "Reversal Zones", "Trend Catcher", "Trend Tracer", "Neo Cloud", "Custom Alert Creator"], group = grpTP)
tpDist     = input.float(5, "Distance", minval = 0.5, step = 0.5, group = grpTP)
tp2Col     = input.color(#2962ff, "TP2", inline = "tp", group = grpTP)
tp1Col     = input.color(#2962ff, "TP1", inline = "tp", group = grpTP)
sl1Col     = input.color(#f23645, "SL1", inline = "sl", group = grpTP)
sl2Col     = input.color(#f23645, "SL2", inline = "sl", group = grpTP)
 
grpAdv     = "ADVANCED SETTINGS"
classFilt  = input.string("1234", "Signal Classifier    ", group = grpAdv)
autopilot  = input.string("Off", "Autopilot Sensitivity", options = ["Off", "Short-Term", "Mid-Term", "Long-Term"], group = grpAdv)
 
grpDash    = "DASHBOARD"
dashLoc    = input.string("Bottom Right", "Dashboard Location", options = ["Hidden", "Top Right", "Bottom Right", "Bottom Left"], group = grpDash)
dashSize   = input.string("Small", "Dashboard Size", options = ["Tiny", "Small", "Normal", "Large"], group = grpDash)
dashCol    = input.color(#252c3f, "Dashboard Color", group = grpDash)
showTS     = input.bool(true,  "Trend Strength", group = grpDash)
showVol    = input.bool(false, "Volatility", group = grpDash)
showSqz    = input.bool(false, "Squeeze         ", group = grpDash)
showVS     = input.bool(false, "Volume Sentiment", group = grpDash)
 
// ---------------------------------------------------------------------------
// 2. SHARED VOLATILITY UNIT                                           [EXACT]
//    Every overlay band in the original is a multiple of ta.atr(200).
// ---------------------------------------------------------------------------
atrUnit = ta.atr(200)
 
// Range filter (DonovanWall form). Moves only when price pushes past the band.
f_rangeFilter(float src, float r) =>
    var float f = na
    f := na(f) ? src : src > f ? (src - r < f ? f : src - r) : (src + r > f ? f : src + r)
    f
 
// ---------------------------------------------------------------------------
// 3. NEO CLOUD                                                        [EXACT]
//    Lead = rangeFilter(close, (p + 0.5) * ATR200)
//    Lag  = rangeFilter(Lead , (p + 0.5) * ATR200)   (cascade)
//    Verified 100% for every period 1..5 on the recorded data.
// ---------------------------------------------------------------------------
neoMult = str.tonumber(neoP) + 0.5
neoLead = f_rangeFilter(close, neoMult * atrUnit)
neoLag  = f_rangeFilter(neoLead, neoMult * atrUnit)
neoBull = neoLead > neoLag
// TODO(cloud colour): the original shades by trend age (brighter = older). Age counter below drives the gradient.
var int neoAge = 0
neoAge := neoBull == neoBull[1] ? neoAge + 1 : 0
neoCol  = neoBull ? neoUpCol : neoDnCol
pLead = plot(useNeo ? neoLead : na, "Neo Lead", color = color.new(neoCol, 100))
pLag  = plot(useNeo ? neoLag  : na, "Neo Lag",  color = color.new(neoCol, 100))
fill(pLead, pLag, color = useNeo ? color.new(neoCol, math.max(40, 85 - math.min(neoAge, 45))) : na)
 
// ---------------------------------------------------------------------------
// 3b. SMART TRAIL                                                    [EXACT]
//     Recursive Bands clamped to close: U = max(close, U[1] + g*(close-U[1])),
//     D = min(close, D[1] + g*(close-D[1])); bull->bear when close < D[1], bear->bull
//     when close > U[1]; line = bull ? D : U; Extremity = (line + (U+D)/2)/2.
//     Gain g = correlation(close, sma(close, L), L) / L, L = 5/7/14/28/56 for period 1..5.
//     From-scratch simulation matches the recorded line, extremity and state on every bar.
// ---------------------------------------------------------------------------
stL = switch stP
    "1" => 5
    "2" => 7
    "3" => 14
    "4" => 28
    => 56
var float stU = na
var float stD = na
var int   stDir = 1
stCorr = ta.correlation(close, ta.sma(close, stL), stL)
if na(stU)
    stU := close
    stD := close
else
    if stDir > 0 and close < stD
        stDir := -1
    else if stDir < 0 and close > stU
        stDir := 1
    stG = nz(stCorr) / stL
    stU := math.max(close, stU + stG * (close - stU))
    stD := math.min(close, stD + stG * (close - stD))
stLine = stDir > 0 ? stD : stU
stExt  = (stLine + (stU + stD) / 2) / 2
pST  = plot(useST ? stLine : na, "Smart Trail", color = stDir > 0 ? stUpCol : stDnCol, linewidth = 2)
pSTx = plot(useST ? stExt : na, "Smart Trail Extremity", color = color.new(stDir > 0 ? stUpCol : stDnCol, 100))
fill(pST, pSTx, color = useST ? color.new(stDir > 0 ? stUpCol : stDnCol, 80) : na)
 
// ---------------------------------------------------------------------------
// 4. TREND TRACER                                                      [EXACT]
//    Adaptive-multiplier trailing line in ATR200 units. m = 0.5/1/1.75/2.5/3.5.
//    d = |close[1]-tt[1]|/ATR[1]; K = m*(5 - 4*d/K[1]); candidates close -/+ K*ATR.
//    Bull: flip when close+K*ATR <= tt[1], else tt = max(tt[1], close-K*ATR). Mirror for bear.
//    100% value + state match for every period (max err 0.11 = ATR warm-up).
// ---------------------------------------------------------------------------
ttMult = switch ttP
    "1" => 0.5
    "2" => 1.0
    "3" => 1.75
    "4" => 2.5
    => 3.5
var float ttLine = na
var int   ttDir  = 1
var float ttK    = ttMult
if na(ttLine)
    ttLine := close - ttMult * atrUnit
else
    dPrev = math.abs(close[1] - ttLine) / atrUnit[1]
    ttK := ttMult * (5 - 4 * dPrev / ttK)
    upC = close - ttK * atrUnit
    dnC = close + ttK * atrUnit
    if ttDir > 0
        if dnC <= ttLine
            ttDir := -1
            ttLine := dnC
        else
            ttLine := math.max(ttLine, upC)
    else
        if upC >= ttLine
            ttDir := 1
            ttLine := upC
        else
            ttLine := math.min(ttLine, dnC)
ttBull = ttDir > 0
plot(useTT ? ttLine : na, "Trend Tracer", color = ttBull ? ttUpCol : ttDnCol, linewidth = 2)
 
// ---------------------------------------------------------------------------
// 4b. TREND CATCHER                                                    [EXACT]
//     Pure price arithmetic. step = 0.1/0.04/0.03/0.02/0.01 for period 1..5.
//     Anchor close Cj = close of the last bar the line moved; a decays by step per move.
//     Flip when the midpoint (close+Cj)/2 crosses the line. Bit-exact on all periods.
// ---------------------------------------------------------------------------
tcStep = switch tcP
    "1" => 0.1
    "2" => 0.04
    "3" => 0.03
    "4" => 0.02
    => 0.01
var float tcLine = na
var int   tcDir  = 1
var float tcCj   = na
var float tcA    = 1 - tcStep
if na(tcLine)
    tcLine := close
    tcCj   := close
else
    mid = (close + tcCj) / 2
    if tcDir * (mid - tcLine) < 0
        tcLine := close - (tcA / 2) * (close - tcCj)
        tcDir  := -tcDir
        tcCj   := close
        tcA    := 1 - tcStep
    else if tcDir * (close - tcCj) > 0
        tcLine := tcA * tcLine + (1 - tcA) * close + (tcA / 2) * (close - tcCj)
        tcCj   := close
        tcA    := tcA - tcStep
tcBull = tcDir > 0
plot(useTC ? tcLine : na, "Trend Catcher", color = tcBull ? tcUpCol : tcDnCol, linewidth = 1)
 
// ---------------------------------------------------------------------------
// 4c. REVERSAL ZONES                                                   [EXACT]
//     N = 14p, L = 7p. Each close carries an ageing bonus (sum of atr(N)/L over
//     the bars since it printed); up/dn = extreme of close +/- bonus over N bars;
//     R1/S1 = ema(up/dn, L); spacing = ema(ema(up-dn, N), L) / 4. MAE 1e-11.
// ---------------------------------------------------------------------------
rzN = 14 * int(str.tonumber(rzP))
rzL = 7 * int(str.tonumber(rzP))
rzA = ta.atr(rzN) / rzL
rzS = ta.cum(rzA)
rzUp = math.max(close + rzS, ta.highest(close + rzS[1], rzN - 1)[1]) - rzS[rzN]
rzDn = math.min(close - rzS, ta.lowest(close - rzS[1], rzN - 1)[1]) + rzS[rzN]
rzR1 = ta.ema(rzUp, rzL)
rzS1 = ta.ema(rzDn, rzL)
rzAvg = (rzR1 + rzS1) / 2
rzSp  = ta.ema(ta.ema(rzUp - rzDn, rzN), rzL) / 4
rzR2 = rzR1 + rzSp
rzR3 = rzR1 + 2 * rzSp
rzS2 = rzS1 - rzSp
rzS3 = rzS1 - 2 * rzSp
pR3 = plot(useRZ ? rzR3 : na, "RZ R3 Band", color = color.new(rzUpCol, 100))
pR2 = plot(useRZ ? rzR2 : na, "RZ R2 Band", color = color.new(rzUpCol, 100))
pR1 = plot(useRZ ? rzR1 : na, "RZ R1 Band", color = color.new(rzUpCol, 100))
plot(useRZ ? rzAvg : na, "Reversal Zones Average", color = color.new(color.gray, 40))
pS1 = plot(useRZ ? rzS1 : na, "RZ S1 Band", color = color.new(rzDnCol, 100))
pS2 = plot(useRZ ? rzS2 : na, "RZ S2 Band", color = color.new(rzDnCol, 100))
pS3 = plot(useRZ ? rzS3 : na, "RZ S3 Band", color = color.new(rzDnCol, 100))
fill(pR1, pR2, color = useRZ ? color.new(rzUpCol, 85) : na)
fill(pR2, pR3, color = useRZ ? color.new(rzUpCol, 75) : na)
fill(pS1, pS2, color = useRZ ? color.new(rzDnCol, 85) : na)
fill(pS2, pS3, color = useRZ ? color.new(rzDnCol, 75) : na)
 
// ---------------------------------------------------------------------------
// 5. SIGNAL ENGINE                          [EXACT at sensitivity 2 / APPROX otherwise]
//    Sensitivity 2: recursive bands with an on/off gain, verified 100% on 9 symbols.
//      g = 0.98 when the previous close change agreed with the state 2 bars ago, else 0;
//      bands freeze (no clamp, no flip test) on the bar after an unchanged close;
//      bull when close >= U[1] from bear, bear when close <= D[1] from bull.
//    Other sensitivities: same band machinery is not yet decoded; placeholder supertrend.
// ---------------------------------------------------------------------------
var float sgU = na
var float sgD = na
var int   sgOs = 1
sgPrevOs = sgOs
if na(sgU)
    sgU := close
    sgD := close
else if nz(close[1] - close[2]) != 0
    sgDir1 = math.sign(close[1] - close[2])
    sgG = sgDir1 * nz(sgOs[2], 1) > 0 ? 0.98 : 0.0
    sgU1 = sgU
    sgD1 = sgD
    sgU := math.max(close, sgU1 + sgG * (close - sgU1))
    sgD := math.min(close, sgD1 + sgG * (close - sgD1))
    sgOs := sgOs == -1 and close >= sgU1 ? 1 : sgOs == 1 and close <= sgD1 ? -1 : sgOs
[sigVal, sigDirST] = ta.supertrend(sens / 4.0, 11)
sigBull = sens == 2 ? (sgOs == 1 and sgPrevOs == -1) : ta.change(sigDirST) < 0
sigBear = sens == 2 ? (sgOs == -1 and sgPrevOs == 1) : ta.change(sigDirST) > 0
sigSide = sigBull ? 1 : sigBear ? -1 : 0
plotshape(sigMode != "None" and sigBull, "Bullish", shape.labelup,   location.belowbar, bullCol, text = "▲", textcolor = color.white, size = size.small)
plotshape(sigMode != "None" and sigBear, "Bearish", shape.labeldown, location.abovebar, bearCol, text = "▼", textcolor = color.white, size = size.small)
 
// ---------------------------------------------------------------------------
// 5b. TREND STRENGTH (dashboard)                                       [EXACT]
//     100 * correlation(close, bar_index, 6 * sensitivity)^2 ; MAE 1e-9 at sens 12.
// ---------------------------------------------------------------------------
tsLen = 6 * sens
trendStrength = 100 * math.pow(ta.correlation(close, bar_index, tsLen), 2)
 
// ---------------------------------------------------------------------------
// 6. TP / SL LEVELS (mode "Signals")                                  [EXACT]
//    Anchor on the signal bar: c0 = close, a0 = ATR200, d = Distance / 2.
//    TP1 = c0 + s*d*a0, TP2 = c0 + s*2d*a0, SL1 = c0 - s*d*a0, SL2 = c0 - s*2d*a0.
//    Displayed TP = close beyond TP1 ? TP2 : TP1 (same for SL).
//    When close reaches TP2 the set re-anchors at that bar. 100% match.
// ---------------------------------------------------------------------------
var int   tpSide = 0
var float tpC0   = na
var float tpA0   = na
d = tpDist / 2.0
if sigSide != 0
    tpSide := sigSide
    tpC0   := close
    tpA0   := atrUnit
tp2Lvl = tpC0 + tpSide * 2 * d * tpA0
if tpSide != 0 and sigSide == 0 and (tpSide == 1 ? close >= tp2Lvl : close <= tp2Lvl)
    tpC0 := close
    tpA0 := atrUnit
tp1 = tpC0 + tpSide * d * tpA0
tp2 = tpC0 + tpSide * 2 * d * tpA0
sl1 = tpC0 - tpSide * d * tpA0
sl2 = tpC0 - tpSide * 2 * d * tpA0
tpShow = tpSide == 1 ? close > tp1 : close < tp1
slShow = tpSide == 1 ? close < sl1 : close > sl1
tpLine = tpShow ? tp2 : tp1
slLine = slShow ? sl2 : sl1
plot(tpMode == "Signals" and tpSide != 0 ? tpLine : na, "Take Profit", color = tp1Col, style = plot.style_linebr)
plot(tpMode == "Signals" and tpSide != 0 ? slLine : na, "Stop Loss",   color = sl1Col, style = plot.style_linebr)

← 返回列表