GG Beluga KHST

indicator("GG Beluga KHST (Presets + NO-TRADE + EarlyFlip + ADX Rising + Frozen TP1/TP2 + Psych Confirm + Alerts)",
     overlay=true, max_lines_count=300, max_labels_count=300)

grpPreset = "Presets"
preset = input.string("Gold", "Symbol Preset", options=["Gold","US100","US30","FX"], group=grpPreset)
usePresetDefaults = input.bool(true, "Use preset defaults (recommended)", group=grpPreset)

measBase = switch preset
    "Gold"  => 10.0
    "US100" => 12.0
    "US30"  => 14.0
    => 16.0

procBase = switch preset
    "Gold"  => 0.010
    "US100" => 0.012
    "US30"  => 0.015
    => 0.020

atrLenBase = switch preset
    "Gold"  => 12
    "US100" => 14
    "US30"  => 14
    => 12

factorBase = switch preset
    "Gold"  => 1.60
    "US100" => 1.70
    "US30"  => 1.80
    => 1.50

entryAtrMultBase = switch preset
    "Gold"  => 0.60
    "US100" => 0.60
    "US30"  => 0.70
    => 0.50

tp1AtrMultBase = switch preset
    "Gold"  => 1.00
    "US100" => 1.00
    "US30"  => 1.10
    => 0.90

tp2AtrMultBase = switch preset
    "Gold"  => 1.70
    "US100" => 1.80
    "US30"  => 2.00
    => 1.50

slAtrMultBase = switch preset
    "Gold"  => 1.20
    "US100" => 1.30
    "US30"  => 1.40
    => 1.10

adxMinBase = switch preset
    "Gold"  => 16.0
    "US100" => 18.0
    "US30"  => 18.0
    => 15.0

earlyBaseThresh = switch preset
    "Gold"  => 0.10
    "US100" => 0.12
    "US30"  => 0.14
    => 0.08

adxSlopeLenBase = switch preset
    "Gold"  => 6
    "US100" => 7
    "US30"  => 8
    => 6

adxSlopeThreshBase = switch preset
    "Gold"  => 0.25
    "US100" => 0.35
    "US30"  => 0.45
    => 0.25

grpTrend = "Trend Engine (Kalman Hull Supertrend)"
src       = input.source(close, "Price Source", group=grpTrend)
measNoise = input.float(12.0, "Measurement Noise (Length)", step=1.0, group=grpTrend)
procNoise = input.float(0.01, "Process Noise", step=0.001, group=grpTrend)
atrLenST  = input.int(12, "Supertrend ATR Period", minval=1, group=grpTrend)
factorST  = input.float(1.7, "Supertrend Factor", step=0.01, group=grpTrend)

showTrend = input.bool(true, "Show KHST Trendline", group=grpTrend)
showFlips = input.bool(true, "Show Flip arrows", group=grpTrend)

colLong   = input.color(color.lime, "Up Color", group=grpTrend, inline="c1")
colShort  = input.color(color.red,  "Down Color", group=grpTrend, inline="c1")

measEff = usePresetDefaults ? measBase   : measNoise
procEff = usePresetDefaults ? procBase   : procNoise
atrLenE = usePresetDefaults ? atrLenBase : atrLenST
facEff  = usePresetDefaults ? factorBase : factorST

grpAlign = "Timeframe Alignment"
useAlign  = input.bool(true, "Use TF Alignment gating", group=grpAlign)
tfCount   = input.int(2, "TFs incl current", minval=1, maxval=4, group=grpAlign)
tf2In     = input.timeframe("", "TF2 (blank=auto x2)", group=grpAlign)
tf3In     = input.timeframe("", "TF3 (blank=auto x3)", group=grpAlign)
tf4In     = input.timeframe("", "TF4 (blank=auto x4)", group=grpAlign)
alignGraceBars = input.int(6, "Alignment grace bars after turning YES", minval=0, maxval=50, group=grpAlign)

grpNT = "NO TRADE Regime"
useNoTrade  = input.bool(true, "Enable NO TRADE regime", group=grpNT)

useATRfloor = input.bool(true, "ATR floor filter", group=grpNT)
atrFloorLen = input.int(14, "ATR length", minval=1, group=grpNT)
atrFloor    = input.float(0.0, "ATR floor (0=off)", step=0.1, group=grpNT)

useTight    = input.bool(true, "Tight range filter", group=grpNT)
tightLen    = input.int(20, "Tight lookback bars", minval=5, group=grpNT)
tightATRMult= input.float(1.2, "Tight if Range <= ATR * mult", step=0.1, group=grpNT)

useADXBase  = input.bool(false, "Base ADX filter (NO-TRADE) (optional)", group=grpNT)
adxMin      = input.float(18.0, "ADX minimum", step=0.5, group=grpNT)

grpADX = "ADX Rising Filter (Soft gate A - Recommended)"
useADXRising = input.bool(true, "Enable ADX Rising soft gate", group=grpADX)
adxLen       = input.int(14, "DMI length", minval=1, group=grpADX)
adxSmooth    = input.int(14, "ADX smoothing", minval=1, group=grpADX)

adxSlopeLenIn    = input.int(6, "ADX slope length (bars)", minval=1, group=grpADX)
adxSlopeThreshIn = input.float(0.30, "ADX slope threshold", step=0.05, group=grpADX)

adxMinEff        = usePresetDefaults ? adxMinBase         : adxMin
adxSlopeLenEff   = usePresetDefaults ? adxSlopeLenBase    : adxSlopeLenIn
adxSlopeThreshEff= usePresetDefaults ? adxSlopeThreshBase : adxSlopeThreshIn

grpEF = "Early Flip (Kalman slope acceleration)"
useEarlyFlip  = input.bool(true, "Enable Early Flip confirmation", group=grpEF)
efLookbackATR = input.int(200, "ATR baseline lookback", minval=20, group=grpEF)
efBaseThresh  = input.float(0.12, "Base threshold", step=0.01, group=grpEF)
efAdaptK      = input.float(1.0, "Volatility adaptation (K)", step=0.1, group=grpEF)
efBaseEff     = usePresetDefaults ? earlyBaseThresh : efBaseThresh

grpA = "Option A: Frozen Entry/TP/SL"
showA        = input.bool(true, "Show Option A (Frozen levels)", group=grpA)

entryMode    = input.string("ATR", "Entry distance mode", options=["ATR","Percent"], group=grpA)
entryAtrMult = input.float(0.6, "Entry ATR mult", step=0.1, group=grpA)
entryPct     = input.float(0.15, "Entry %", step=0.01, group=grpA)

riskMode     = input.string("ATR", "TP/SL mode", options=["ATR","Percent"], group=grpA)
tp1AtrMult   = input.float(1.0, "TP1 ATR mult", step=0.1, group=grpA)
tp2AtrMult   = input.float(1.7, "TP2 ATR mult", step=0.1, group=grpA)
slAtrMult    = input.float(1.2, "SL ATR mult", step=0.1, group=grpA)

tp1Pct       = input.float(0.50, "TP1 %", step=0.05, group=grpA)
tp2Pct       = input.float(0.90, "TP2 %", step=0.05, group=grpA)
slPct        = input.float(0.60, "SL %", step=0.05, group=grpA)

extendBars   = input.int(60, "Extend lines (bars)", minval=10, maxval=500, group=grpA)
staleBars    = input.int(6, "Refreeze if stale (bars)", minval=1, maxval=50, group=grpA)

entryAtrEff = usePresetDefaults ? entryAtrMultBase : entryAtrMult
tp1AtrEff   = usePresetDefaults ? tp1AtrMultBase   : tp1AtrMult
tp2AtrEff   = usePresetDefaults ? tp2AtrMultBase   : tp2AtrMult
slAtrEff    = usePresetDefaults ? slAtrMultBase    : slAtrMult

grpB = "Option B: Market NOW + Pending Early"
showB         = input.bool(true, "Show Market NOW arrow", group=grpB)
showBLabel    = input.bool(true, "Show Market NOW label (Entry+TP1+TP2+SL)", group=grpB)
showPending   = input.bool(true, "Show Pending (EarlyFlip) markers", group=grpB)

grpPC = "Psych Confirmation (Swings)"
showPC        = input.bool(true, "Show swing confirmations (not entries)", group=grpPC)
pcPivotL      = input.int(3, "Pivot left", minval=1, group=grpPC)
pcPivotR      = input.int(3, "Pivot right", minval=1, group=grpPC)
pcCooldownBars= input.int(12, "Cooldown bars", minval=0, group=grpPC)
pcGateOnAlignTradeOK = input.bool(true, "Only when AlignOK & TradeOK", group=grpPC)
pcTrendFilter = input.bool(true, "Filter: SwingHigh only in downtrend, SwingLow only in uptrend", group=grpPC)
pcShowPopupLabel = input.bool(true, "Show tiny popup label at pivot", group=grpPC)
pcSizeOpt     = input.string("tiny", "Marker size", options=["tiny","small","normal"], group=grpPC)
showCooldownViz = input.bool(true, "Cooldown visualization (right-side label)", group=grpPC)

grpUI = "UI"
labelYOffsetATR = input.float(2.0, "Status label Y offset (ATR)", step=0.25, group=grpUI)
rightLabelX     = input.int(10, "Right label X padding (bars)", minval=5, maxval=200, group=grpUI)
showScaleMarks  = input.bool(true, "Show Entry/TP/SL on price scale", group=grpUI)

grpAL = "Alerts"
enableAlerts = input.bool(true, "Enable alerts (uses alert() messages)", group=grpAL)
alertOnConfirmedClose = input.bool(true, "Fire alerts on bar close only", group=grpAL)

f_autoTf(mult) =>
    string out = timeframe.period
    if timeframe.isintraday
        out := str.tostring(timeframe.multiplier * mult)
    else if timeframe.isdaily
        out := str.tostring(timeframe.multiplier * mult) + "D"
    else if timeframe.isweekly
        out := str.tostring(timeframe.multiplier * mult) + "W"
    else if timeframe.ismonthly
        out := str.tostring(timeframe.multiplier * mult) + "M"
    out

tf2Str = (tf2In == "" ? f_autoTf(2) : tf2In)
tf3Str = (tf3In == "" ? f_autoTf(3) : tf3In)
tf4Str = (tf4In == "" ? f_autoTf(4) : tf4In)

f_kalman(_x, _R, _Q) =>
    var float est = na
    var float err = na
    if na(est)
        est := _x
        err := 1.0
    predEst = est
    predErr = err + _Q
    K = predErr / (predErr + _R)
    est := predEst + K * (_x - predEst)
    err := (1.0 - K) * predErr
    est

f_khma(_src, _len, _proc) =>
    a = f_kalman(_src, _len/2.0, _proc)
    b = f_kalman(_src, _len,     _proc)
    raw = 2.0 * a - b
    f_kalman(raw, math.max(1.0, math.sqrt(_len)), _proc)

f_supertrend(_src, _atrLen, _factor) =>
    atr = ta.atr(_atrLen)
    upper = _src + _factor * atr
    lower = _src - _factor * atr

    var float fUpper = na
    var float fLower = na
    var int   d = 1

    fUpper := na(fUpper[1]) ? upper : ((upper < fUpper[1] or close[1] > fUpper[1]) ? upper : fUpper[1])
    fLower := na(fLower[1]) ? lower : ((lower > fLower[1] or close[1] < fLower[1]) ? lower : fLower[1])

    if na(d[1])
        d := 1
    else
        if d[1] == -1 and close > fUpper[1]
            d := 1
        else if d[1] == 1 and close < fLower[1]
            d := -1
        else
            d := d[1]

    stLine = (d == 1) ? fLower : fUpper
    [d, stLine, atr]

khma = f_khma(src, measEff, procEff)
[dirMain, stLineMain, atrSTMain] = f_supertrend(khma, atrLenE, facEff)

buyFlip  = showFlips and dirMain == 1 and dirMain[1] == -1
sellFlip = showFlips and dirMain == -1 and dirMain[1] == 1

f_dir_on_tf() =>
    khTF = f_khma(src, measEff, procEff)
    [dTF, _, _] = f_supertrend(khTF, atrLenE, facEff)
    dTF

dir2 = request.security(syminfo.tickerid, tf2Str, f_dir_on_tf(), barmerge.gaps_off, barmerge.lookahead_off)
dir3 = request.security(syminfo.tickerid, tf3Str, f_dir_on_tf(), barmerge.gaps_off, barmerge.lookahead_off)
dir4 = request.security(syminfo.tickerid, tf4Str, f_dir_on_tf(), barmerge.gaps_off, barmerge.lookahead_off)

aligned = true
if useAlign
    aligned := false
    if tfCount == 1
        aligned := (dirMain != 0)
    else if tfCount == 2
        aligned := (dirMain != 0 and dir2 == dirMain)
    else if tfCount == 3
        aligned := (dirMain != 0 and dir2 == dirMain and dir3 == dirMain)
    else
        aligned := (dirMain != 0 and dir2 == dirMain and dir3 == dirMain and dir4 == dirMain)

alignTurnOn = aligned and not aligned[1]
var int alignOnBar = na
if alignTurnOn
    alignOnBar := bar_index

inGrace = not na(alignOnBar) and (bar_index - alignOnBar <= alignGraceBars)
alignOK = useAlign ? (aligned or inGrace) : true

atrNow = ta.atr(atrFloorLen)

[pdi, mdi, adxVal] = ta.dmi(adxLen, adxSmooth)

atrOK = true
if useATRfloor and atrFloor > 0
    atrOK := (atrNow >= atrFloor)

rangeNow = ta.highest(high, tightLen) - ta.lowest(low, tightLen)
tightOK = true
if useTight

    tightOK := (rangeNow > atrNow * tightATRMult)

adxBaseOK = true
if useADXBase
    adxBaseOK := (adxVal >= adxMinEff)

noTrade = useNoTrade and (not atrOK or not tightOK or not adxBaseOK)
tradeOK = not noTrade

adxSlope = adxVal - adxVal[adxSlopeLenEff]

adxRisingOK = true
if useADXRising
    slopeOK = (not na(adxSlope)) and (adxSlope >= adxSlopeThreshEff)
    levelOK = (adxVal >= adxMinEff)
    adxRisingOK := (levelOK or slopeOK)

slope = khma - khma[1]
accel = slope - slope[1]

atrBase = ta.sma(atrNow, efLookbackATR)
volRatio = (atrBase > 0) ? (atrNow / atrBase) : 1.0
accelNorm = accel / math.max(atrNow, syminfo.mintick)

thresh = efBaseEff * (1.0 + (volRatio - 1.0) * efAdaptK)

earlyBuy  = useEarlyFlip and (slope > 0 and slope[1] <= 0) and (accelNorm >  thresh)
earlySell = useEarlyFlip and (slope < 0 and slope[1] >= 0) and (accelNorm < -thresh)

pendingBuy  = showPending and earlyBuy and not buyFlip
pendingSell = showPending and earlySell and not sellFlip

Показано первые 50% кода (символов: 19138)