Oscillator

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © tamth_

//@version=6
indicator("Oscillator", overlay=false, max_bars_back=5000, max_lines_count=500, max_boxes_count=1000, max_labels_count=500)

//-----------------------------------------------------------------------------
// Constants
//-----------------------------------------------------------------------------
color TRANSPARENT_COLOR = #ffffff00
color WHITE_COLOR       = #dee2e6
color BLACK_COLOR       = #000000
color RED_COLOR         = #F72585
color ORANGE_COLOR      = #fb5607
color YELLOW_COLOR      = #ffbe0b
color GREEN_COLOR       = #2a9d8f
color AQUA_COLOR        = #4CC9F0
color BLUE_COLOR        = #4361ee
color PURPLE_COLOR      = #3F37C9
color PINK_COLOR        = #B5179E
color LIGHT_GRAY_COLOR  = #364156
color DARK_GRAY_COLOR   = #212d40
color TEXT_COLOR        = #ced4da

//-----------------------------------------------------------------------------
// Common Variables
//-----------------------------------------------------------------------------
series int barIdx = bar_index
series bool confirmed = barstate.isconfirmed

//-----------------------------------------------------------------------------
// Common Functions
//-----------------------------------------------------------------------------
debug(simple string txt) =>
    var label = label.new(barIdx, na, txt, xloc.bar_index, yloc.price, color(na), label.style_none, WHITE_COLOR, size.large, text.align_left)
    label.set_xy(label, barIdx, ta.highest(10)[1])
    label.set_text(label, txt)

//-----------------------------------------------------------------------------
// Settings
//-----------------------------------------------------------------------------
string thresholdGrp = "Threshold"
bool thresholdShowed = input.bool(true, title="Show", group=thresholdGrp)
int overboughtThreshold = input.int(60, title="Overbought Threshold", group=thresholdGrp)
int oversoldThreshold = input.int(-60, title="Oversold Threshold", group=thresholdGrp)

string wtGrp = "Waves Trend"
bool wtShowed = input.bool(true, title="Show", group=wtGrp)
int wtChlPrd = input.int(9, title="Channel Period", group=wtGrp)
int wtAvgPrd = input.int(12, title="Average Period", group=wtGrp)
float wtMaSrc = input.source(hlc3, title="MA Source", group=wtGrp)
int wtMaLen = input.int(3, title="MA Length", group=wtGrp)
bool wtDivShowed = input.bool(false, title="Show Divergence", group=wtGrp)

string mfoGrp = "MFO"
bool mfoShowed = input.bool(true, title="Show", group=mfoGrp)
int mfoPrd = input.int(60, title="Period", group=mfoGrp)
int mfoMult = input.int(150, title="Area Multiplier", group=mfoGrp)

string vwapGrp = "VWAP"
bool vwapShowed = input.bool(true, title="Show", group=vwapGrp)

//-----------------------------------------------------------------------------
// Methods
//-----------------------------------------------------------------------------
getTopFractal(series float src) =>
    src[4] < src[2] and src[3] < src[2] and src[2] > src[1] and src[2] > src[0]

getBotFractal(series float src) =>
    src[4] > src[2] and src[3] > src[2] and src[2] < src[1] and src[2] < src[0]

fractalize(series float src) =>
    series bool isBotFractal = getBotFractal(src)
    series bool isTopFractal = getTopFractal(src)
    isTopFractal ? 1 : isBotFractal ? -1 : 0

getDivPoints(series float src, int topLimit, int botLimit) =>
    series bool isTopFractal = not na(fractalize(src) > 0 and src[2] >= topLimit ? src[2] : na)
    series bool isBotFractal = not na(fractalize(src) < 0 and src[2] <= botLimit ? src[2] : na)
    float highPrev = ta.valuewhen(isTopFractal, src[2], 0)[2]
    float highPrice = ta.valuewhen(isTopFractal, high[2], 0)[2]
    float lowPrev = ta.valuewhen(isBotFractal, src[2], 0)[2]
    float lowPrice = ta.valuewhen(isBotFractal, low[2], 0)[2]
    bool isBearish = isTopFractal and high[2] > highPrice and src[2] < highPrev
    bool isBullish = isBotFractal and low[2] < lowPrice and src[2] > lowPrev
    [isTopFractal, isBotFractal, lowPrev, isBearish, isBullish]

getWtAndVwap() =>
    float src = request.security(syminfo.tickerid, timeframe.period, wtMaSrc)
    float esa = ta.ema(src, wtChlPrd)
    float d = ta.ema(math.abs(src - esa), wtChlPrd)
    float ci = (src - esa) / (0.015 * d)
    float leadingWt = ta.ema(ci, wtAvgPrd)
    float laggingWt = ta.sma(leadingWt, wtMaLen)
    bool isOversold = laggingWt <= oversoldThreshold
    bool isOverbought = laggingWt >= overboughtThreshold
    bool wtCross = ta.cross(leadingWt, laggingWt)
    bool wtCrossUp = laggingWt - leadingWt <= 0
    bool wtCrossDn = laggingWt - leadingWt >= 0
    float vwap = leadingWt - laggingWt
    [leadingWt, laggingWt, isOversold, isOverbought, wtCross, wtCrossUp, wtCrossDn, vwap]

getHaVal(series float src) =>
    request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, src)

getMfo() =>
    series float haOpen = getHaVal(open)
    series float haClose = getHaVal(close)
    series float haHigh = getHaVal(high)
    series float haLow = getHaVal(low)
    mfo = ta.sma((haClose - haOpen) / (haHigh - haLow) * mfoMult, mfoPrd)

//-----------------------------------------------------------------------------
// Calculate
//-----------------------------------------------------------------------------
int WT_LONG_BEARISH_DIV_LEVEL = 45
int WT_LONG_BULLISH_DIV_LEVEL = -65
int WT_SHORT_BEARISH_DIV_LEVEL = 15
int WT_SHORT_BULLISH_DIV_LEVEL = -40
series float _close = request.security(syminfo.tickerid, timeframe.period, close)
series float _high = request.security(syminfo.tickerid, timeframe.period, high)
series float _low = request.security(syminfo.tickerid, timeframe.period, low)
float mfo = getMfo()
[leadingWt, laggingWt, isOversold, isOverbought, cross, crossUp, crossDn, vwap] = getWtAndVwap()
[wtLongTopFractal, wtLongBotFractal, wtLongLowPrev, isWtLongBearishDiv, isWtLongBullishDiv] = getDivPoints(laggingWt, WT_LONG_BEARISH_DIV_LEVEL, WT_LONG_BULLISH_DIV_LEVEL)
[wtShortTopFractal, wtShortBotFractal, wtShortLowPrev, isWtShortBearishDiv, isWtShortBullishDiv] = getDivPoints(laggingWt, WT_SHORT_BEARISH_DIV_LEVEL, WT_SHORT_BULLISH_DIV_LEVEL)

//-----------------------------------------------------------------------------
// Render
//-----------------------------------------------------------------------------
plot(thresholdShowed ? overboughtThreshold : na, title="Overbought Threshold", color=DARK_GRAY_COLOR, display=display.pane, linewidth=1, style=plot.style_cross)
plot(thresholdShowed ? oversoldThreshold : na, title="Oversold Threshold", color=DARK_GRAY_COLOR, display=display.pane, linewidth=1, style=plot.style_cross)
plot(vwapShowed ? vwap : na, title="VWAP", color=color.new(LIGHT_GRAY_COLOR, 10), style=plot.style_area, display=display.pane)
plot(mfoShowed ? mfo : na, title="MFO", color=mfo > 0 ? color.new(GREEN_COLOR, 80) : color.new(RED_COLOR, 80), linewidth=2, style=plot.style_area, display=display.pane)

color leadingWtColor = leadingWt >= laggingWt ? color.new(WHITE_COLOR, 20) : color.new(BLUE_COLOR, 20)
var leadingWtPlot = plot(wtShowed ? leadingWt : na, title="Leading Wave Trend", color=leadingWtColor, linewidth=2, style=plot.style_line, display=display.pane)
var laggingWtPlot = plot(wtShowed ? laggingWt : na, title="Lagging Wave Trend", color=TRANSPARENT_COLOR, linewidth=1, style=plot.style_line, display=display.pane)
color wtFillColor = leadingWt >= laggingWt ? color.new(WHITE_COLOR, 75) : color.new(BLUE_COLOR, 75)
fill(leadingWtPlot, laggingWtPlot, title='Wave Trend', color=wtFillColor)

color wtLongBearishDivColor = wtDivShowed and isWtLongBearishDiv ? BLUE_COLOR : na
color wtLongBullishDivColor = wtDivShowed and isWtLongBullishDiv ? WHITE_COLOR : na
color wtShortBearishDivColor = wtDivShowed and isWtShortBearishDiv ? color.new(BLUE_COLOR, 50) : na
color wtShortBullishDivColor = wtDivShowed and isWtShortBullishDiv ? color.new(WHITE_COLOR, 50) : na
plot(series=wtLongTopFractal ? laggingWt[2] : na, title="Wave Trend Long Bearish Divergence", color=wtLongBearishDivColor, linewidth=2, offset=-2, display=display.pane)
plot(series=wtLongBotFractal ? laggingWt[2] : na, title="Wave Trend Long Bullish Divergence", color=wtLongBullishDivColor, linewidth=2, offset=-2, display=display.pane)
plot(series=wtShortTopFractal ? laggingWt[2] : na, title="Wave Trend Short Bearish Divergence", color=wtShortBearishDivColor, linewidth=2, offset=-2, display=display.pane)
plot(series=wtShortBotFractal ? laggingWt[2] : na, title="Wave Trend Short Bullish Divergence", color=wtShortBullishDivColor, linewidth=2, offset=-2, display=display.pane)

//-----------------------------------------------------------------------------
// Squeeze Momentum
//-----------------------------------------------------------------------------
// Settings
//-----------------------------------------------------------------------------
const string go  = 'Squeeze Momentum'
const string gd  = 'Directional Flux'
const string gg  = 'Gauges'
const string ss  = 'Sell Signal'
const string sb  = 'Buy Signal'

dfb = input.bool(true, "", inline='1', group=gd)
dfl = input.int(30, "Length", 7, 50, 1, inline='1', group=gd)
smb = input.bool(true, "", inline='1', group=go)
len = input.int(20, "Length", 7, 50, 1, inline='1', group=go)
sig = input.int(3, "Signal", 2, 7, 1, inline='2', group=go)
cgp = input.color(GREEN_COLOR, "", inline='2', group=gg)
cgn = input.color(RED_COLOR, "", inline='2', group=gg)

//-----------------------------------------------------------------------------
// UDTs
//-----------------------------------------------------------------------------
// Bar data type
type bar
    float o = open
    float h = high
    float l = low
    float c = close
    int   i = bar_index

// Oscillator data type
type osc
    float o = na
    float s = na

// Squeeze status type
type squeeze
    bool h = false
    bool m = false
    bool l = false

// Gauge display type
type gauge
    float u = na
    float l = na
    color c = chart.fg_color
    bool  p = true

//-----------------------------------------------------------------------------
// Methods
//-----------------------------------------------------------------------------
method src(bar b, simple string src) =>
    if na(b)
        na
    else
        float x = switch src
            'oc2' => math.avg(b.o, b.c)
            'hl2' => math.avg(b.h, b.l)
            'hlc3' => math.avg(b.h, b.l, b.c)
            'ohlc4' => math.avg(b.o, b.h, b.l, b.c)
            'hlcc4' => math.avg(b.h, b.l, b.c, b.c)
        x

method calcAtr(bar b, simple int len = 1) =>
    float tr = barstate.isfirst or na(b) or na(b.h) or na(b.l) or na(b.c) or na((b[1]).h) or na((b[1]).c) ? na : math.max(math.max(b.h - b.l, math.abs(b.h - (b[1]).c)), math.abs(b.l - (b[1]).c))
    len == 1 ? tr : ta.rma(tr, len)

method stdev(float src, simple int len) =>
    float sq = 0.
    float psq = 0.
    float sum = 0.
    for k = 0 to len - 1
        val = nz(src[k])
        psq := sq
        sq += (val - sq) / (1 + k)
        sum += (val - sq) * (val - psq)
    math.sqrt(sum / (len - 1))

method calcOsc(bar b, simple int sig, simple int len) =>
    float av = ta.sma(b.src('hl2'), len)
    bar z = bar.new(b.o, ta.highest(len), ta.lowest(len), b.c)
    float x = ta.linreg((z.c - math.avg(z.src('hl2'), av)) / z.calcAtr() * 100, len, 0)
    osc.new(x, ta.sma(x, sig))

method calcDfo(bar b, simple int len) =>
    float tr = b.calcAtr(len)
    float up = ta.rma(math.max(ta.change(b.h), 0), len) / tr
    float dn = ta.rma(math.max(ta.change(b.l) * -1, 0), len) / tr
    float x = ta.rma((up - dn) / (up + dn), len / 2) * 100
    osc.new(x, x > 25 ? x - 25 : x < -25 ? x + 25 : na)

method calcSqz(bar b, simple int len) =>
    array<bool> sqz = array.new<bool>()
    float dev = b.c.stdev(len)
    float atr = b.calcAtr(len)
    for i = 2 to 4
        sqz.unshift(dev < atr * 0.25 * i)
    squeeze.new(sqz.pop(), sqz.pop(), sqz.pop())

//-----------------------------------------------------------------------------
// Calculate
//-----------------------------------------------------------------------------
bar     b = bar.new(open, high, low, close)
squeeze s = b.calcSqz(len)
osc     o = b.calcOsc(sig, len)
osc     v = b.calcDfo(dfl)
u = gauge.new(+75, +70, v.o > 0 and o.o > 0 ? cgp : v.o > 0 or o.o > 0 ? color.new(cgp, 40) : DARK_GRAY_COLOR)
d = gauge.new(-75, -70, v.o < 0 and o.o < 0 ? cgn : v.o < 0 or o.o < 0 ? color.new(cgn, 40) : DARK_GRAY_COLOR)

//-----------------------------------------------------------------------------
// Render
//-----------------------------------------------------------------------------
plot(dfb ? v.o : na, "Flux", v.o > 0 ? color.new(GREEN_COLOR, 85) : color.new(RED_COLOR, 85), 1, plot.style_area, display=display.pane)
plot(dfb ? v.s : na, "OverFlux", v.s > 0 ? color.new(GREEN_COLOR, 85) : color.new(RED_COLOR, 85), 1, plot.style_areabr, display=display.pane)
plot(2, "Squeeze", color=s.l ? s.h ? PINK_COLOR : s.m ? PURPLE_COLOR : AQUA_COLOR : LIGHT_GRAY_COLOR, linewidth=1, style=plot.style_columns, trackprice=false, histbase=-2, display=display.pane)

var vaTopLineSt = plot(105, title="Top Trend Bar", color=TRANSPARENT_COLOR, editable=false, display=display.pane)
var vaTopLineNd = plot(100, title="Top Trend Bar", color=TRANSPARENT_COLOR, editable=false, display=display.pane)
var vaBotLineSt = plot(-100, title="Bottom Trend Bar", color=TRANSPARENT_COLOR, editable=false, display=display.pane)
var veBotLineNd = plot(-105, title="Bottom Trend Bar", color=TRANSPARENT_COLOR, editable=false, display=display.pane)
fill(vaTopLineSt, vaTopLineNd, title="Top Trend Bar Color", color=u.c)
fill(vaBotLineSt, veBotLineNd, title="Bottom Trend Bar Color", color=d.c)

//-----------------------------------------------------------------------------