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