Code: Select all

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ChartPrime

//@version=5
indicator("Trending RSI [ChartPrime]", max_bars_back = 5000, timeframe = "", timeframe_gaps = true)

// Declarations {

convolve(float[] weights, float[] kernel, int iterations)=>
    var float[] convolution = weights.copy()

    if iterations > 0
        if barstate.isfirst
            for iteration = 0 to iterations - 1
                float[] temp = array.new<float>()

                for i = 0 to convolution.size() + kernel.size() - 2
                    float sum = 0.0

                    for j = 0 to kernel.size() - 1
                        int index = i - j

                        if index >= 0 and index < convolution.size()
                            sum += convolution.get(index) * kernel.get(j)
                        else
                            continue

                    temp.push(sum)

                convolution := temp.copy()

    convolution

method truncate_weights(float[] weights, bool enable = true)=>
    if enable
        int max_idx = weights.indexof(weights.max())

        if max_idx > 0
            for i = 0 to weights.indexof(weights.max()) - 1
                weights.shift()
        else
            weights

    weights

binomia_ma(float source, int length, bool enable)=>
    float pre_filter = ta.sma(source, 2)
    float[] h = array.from(0.5, 0.5)
    float[] weights = convolve(h, h, length * 10 - 1).truncate_weights()

    if enable and not na(source)
        float sum = 0
        float weight = 0

        for i = 0 to math.min(weights.size() - 1, bar_index)
            float w = weights.get(i)
            weight += w
            sum += nz(pre_filter[i], nz(source[i])) * w

        sum/weight

    else
        float(na)

precalculate_phi_coefficients(simple int length, simple float phase)=>
    var float[] coefficients = array.new<float>(length)
    var float E = 0.0

    const float SQRT_PIx2  = math.sqrt(2.0 * math.pi)
    const float MULTIPLIER = -0.5 / 0.93
    var int   length_1 = length - 1
    var float length_2 = length * 0.52353
    if barstate.isfirst
        for int i=0 to length_1
            float alpha = (i + phase - length_2) * MULTIPLIER
            float  beta = 1.0 / (0.2316419 * math.abs(alpha) + 1.0)
            float   phi = (math.exp(math.pow(alpha, 2) * -0.5)
                          *-0.398942280) * beta *
                          ( 0.319381530  + beta *
                          (-0.356563782  + beta *
                          ( 1.781477937  + beta *
                          (-1.821255978  + beta 
                          * 1.330274429)))) + 1.011
            if alpha < 0.0
                phi := 1.0 - phi
            float weight = phi / SQRT_PIx2
            E += weight
            coefficients.set(i, weight)
    [coefficients, E]

phi_smoother(series float source, series float[] coefficients, series float E, simple float hf_ratio = 0.5)=>
    float sma2 = source * math.min(math.max(0.5, hf_ratio), 1) + nz(source[1], source) * math.max(math.min(0.5, 1 - hf_ratio), 0)
    int length = coefficients.size()
    if length > 1
        float W = 0.0
        for int i=0 to length - 1
            float weight = coefficients.get(i)
            W  += weight * sma2[i]
        W / E
    else 
        source

rma(float source = close, float length = 9)=>
    float alpha = 1 / length
    var float smoothed = na
    smoothed := alpha * source + (1 - alpha) * nz(smoothed[1])

rsi(float source, int length)=> 
    float up = math.max(source - source[1], 0)
    float down = math.max(source[1] - source, 0)
    float rs = rma(up, length) / rma(down, length)
    float rsi = 100 - 100 / (1 + rs)
    rsi

reverse_rsi(series float source, simple int length, float value)=>
    float src = (source - ta.rma(source, length)) / (length / 2)
    float alpha = 1 / length
    float average_up_count = 0.0
    float average_down_count = 0.0

    average_up_count := src > src[1] 
                                     ? alpha * (src - src[1]) + (1 - alpha) * nz(average_up_count[1], 1) 
                                     : (1 - alpha) * nz(average_up_count[1], 1)

    average_down_count := src > src[1] 
                                     ? (1 - alpha) * nz(average_down_count[1], 1)
                                     : alpha * (src[1] - src) + (1 - alpha) * nz(average_down_count[1], 1)

    float reversed_value = (length - 1) * (average_down_count * value / (100 - value) - average_up_count)
    float reverse_rsi = reversed_value >= 0 ? src + reversed_value : src + reversed_value * (100 - value) / value

// }

// Inputs {

const string group_1 = "Settings"
const string top_value_tip = "Pick what RSI value you want the top range to represent."
const string bottom_value_tip = "Pick what RSI value you want the bottom range to represent"

float source = input.source(close, "Source", group = group_1)
int length = input.int(14, "Length", minval = 1, group = group_1)
float top_value = input.float(70, "Top Range", minval = 50, maxval = 99, tooltip = top_value_tip, group = group_1)
float bottom_value = input.float(30, "Bottom Range", minval = 1, maxval = 50, tooltip = bottom_value_tip, group = group_1) 
bool ma_enable = input.bool(false, "MA Length        ", inline = "MA", group = group_1)
int ma_length = input.int(30, "", minval = 0, maxval = 100, inline = "MA", group = group_1)

const string group_2 = "Smoothing"
const string smoothing_tip = "Adjusts the period of the filter."
const string speed_tip = "Adjusts the responsiveness of the filter."
const string hf_tip = "Adjusts the pre smoothing of the filter." + "\n" + "1 is no pre smoothing while 0.5 is maximum pre smoothing."

int left = input.int(15, "Look Left", minval = 1, tooltip = left_tip, group = group_3)
int right = input.int(15, "Look Right", minval = 1, tooltip = right_tip, group = group_3)
int lower_range = input.int(5, "Lower Range", minval = 1, tooltip = lower_range_tip, group = group_3)
int upper_range = input.int(60, "Upper Range", minval = 1, tooltip = upper_range_tip, group = group_3)
string divergence_label = input.string("Line", "Divergence Drawings", ["Line", "Label", "Line and Label"], group = group_3)
bool bullish_divergence = false // input.bool(false, "Enable Bullish Divergence", group = group_3)
bool bearish_divergence = false // input.bool(false, "Enable Bearish Divergence", group = group_3)

const string group_4 = "Color"
bool glow = false // input.bool(true, "Glow", group = group_4)
color rsi_color = input.color(#ffffff, "RSI", group = group_4)
color ma_color = input.color(#FFEE54, "MA Color", group = group_4)
color bg_color = input.color(#7E57C21A, "BG", group = group_4)
color top_color = input.color(#a222e283, "Upper Range", group = group_4)
color bottom_color = input.color(#e5b60c83, "Lower Range", group = group_4)
color center_bullish_up_color = input.color(#21a110, "Center", inline = "Center", group = group_4)
color center_bullish_down_color = input.color(#005e05, "", inline = "Center", group = group_4)
color center_bearish_up_color = input.color(#FCA0A9, "", inline = "Center", group = group_4)
color center_bearish_down_color = input.color(#FB3E38, "", inline = "Center", group = group_4)
color bullish_divergence_color = input.color(#00B374, "Bullish Divergence", group = group_4)
color bearish_divergence_color = input.color(#F03042, "Bearish Divergence", group = group_4)
color divergence_text_color = input.color(#FEFEFE, "Divergence Text", group = group_4)
color zero_line_color = input.color(#9E9E9E, "0 Line Color", group = group_4)

// }

// Calculations {

[smoothing_coefficients, smoothing_E] = precalculate_phi_coefficients(smoothing, smoothing_phase)
[boundary_coefficients, boundary_E] = precalculate_phi_coefficients(boundary_smoothing, boundary_smoothing_phase)

float top = phi_smoother(reverse_rsi(source, length, top_value), boundary_coefficients, boundary_E, boundary_hf)
float bottom = phi_smoother(reverse_rsi(source, length, bottom_value), boundary_coefficients, boundary_E, boundary_hf)
float center = phi_smoother(reverse_rsi(source, length, 50), smoothing_coefficients, smoothing_E, smoothing_hf)

float rsi = phi_smoother(reverse_rsi(source, length, rsi(source, length)), smoothing_coefficients, smoothing_E, smoothing_hf)
float ma = binomia_ma(rsi, ma_length, ma_enable)

float center_delta = center - center[1]

// }

// Color Calculations {

color center_color = center >= 0 
                                 ? (center_delta > 0 ? center_bullish_up_color : center_bullish_down_color) 
                                 : (center_delta > 0 ? center_bearish_up_color : center_bearish_down_color)

color top_glow_color_max = color.new(top_color, 80)
color bottom_glow_color_max = color.new(bottom_color, 80)
color top_glow_color_min = color.new(top_color, 100)
color bottom_glow_color_min = color.new(bottom_color, 100)

color zero_line_solid = color.new(zero_line_color, 80)
color zero_line_dashed = color.new(zero_line_color, 50)

// }

// Plotting {
plot(0, "0 Line", zero_line_solid, display = display.pane)
top_band = plot(top, "Upper Range", top_color)
bottom_band = plot(bottom, "Lower Range", bottom_color)
fill(top_band, bottom_band, bg_color, "RSI Background Fill")
plot(center, "Center", center_color,2)
plot(ma, "MA", ma_color, display = ma_enable ? display.all : display.pane)
plot(rsi, "RSI", rsi_color)
// }

Code: Select all

//@version=5
indicator("FluidTrades - SMC Lite ", overlay = true, max_labels_count = 500, max_boxes_count = 500, max_lines_count = 500, max_bars_back = 1000)

//
//SETTINGS
//

//      INDICATOR SETTINGS
swing_length = input.int(10, title = 'Swing High/Low Length', group = 'Settings', minval = 1, maxval = 50)
history_of_demand_to_keep = input.int(20, title = 'History To Keep', minval = 5, maxval = 50)
box_width = input.float(2.5, title = 'Supply/Demand Box Width', group = 'Settings', minval = 1, maxval = 10, step = 0.5)

//      INDICATOR VISUAL SETTINGS
show_zigzag = input.bool(false, title = 'Show Zig Zag', group = 'Visual Settings', inline = '1')
show_price_action_labels = input.bool(false, title = 'Show Price Action Labels', group = 'Visual Settings', inline = '2')

supply_color = input.color(color.new(#EDEDED,70), title = 'Supply', group = 'Visual Settings', inline = '3')
supply_outline_color = input.color(color.new(color.white,75), title = 'Outline', group = 'Visual Settings', inline = '3')

demand_color = input.color(color.new(#00FFFF,70), title = 'Demand', group = 'Visual Settings', inline = '4')
demand_outline_color = input.color(color.new(color.white,75), title = 'Outline', group = 'Visual Settings', inline = '4')

bos_label_color = input.color(color.white, title = 'BOS Label', group = 'Visual Settings', inline = '5')
poi_label_color = input.color(color.white, title = 'POI Label', group = 'Visual Settings', inline = '7')

swing_type_color = input.color(color.black, title = 'Price Action Label', group = 'Visual Settings', inline = '8')
zigzag_color = input.color(color.new(#000000,0), title = 'Zig Zag', group = 'Visual Settings', inline = '9')

//
//END SETTINGS
//


//
//FUNCTIONS
//

//      FUNCTION TO ADD NEW AND REMOVE LAST IN ARRAY
f_array_add_pop(array, new_value_to_add) =>
    array.unshift(array, new_value_to_add)
    array.pop(array)

//      FUNCTION SWING H & L LABELS
f_sh_sl_labels(array, swing_type) =>

    var string label_text = na
    if swing_type == 1
        if array.get(array, 0) >= array.get(array, 1)
            label_text := 'HH'
        else
            label_text := 'LH'
        label.new(bar_index - swing_length, array.get(array,0), text = label_text, style=label.style_label_down, textcolor = swing_type_color, color = color.new(swing_type_color, 100), size = size.tiny)
    
    else if swing_type == -1
        if array.get(array, 0) >= array.get(array, 1)
            label_text := 'HL'
        else
            label_text := 'LL'
        label.new(bar_index - swing_length, array.get(array,0), text = label_text, style=label.style_label_up, textcolor = swing_type_color, color = color.new(swing_type_color, 100), size = size.tiny)

//      FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING
f_check_overlapping(new_poi, box_array, atr) =>

    atr_threshold = atr * 2
    okay_to_draw = true

    for i = 0 to array.size(box_array) - 1
        top = box.get_top(array.get(box_array, i))
        bottom = box.get_bottom(array.get(box_array, i))
        poi = (top + bottom) / 2

        upper_boundary = poi + atr_threshold
        lower_boundary = poi - atr_threshold

        if new_poi >= lower_boundary and new_poi <= upper_boundary
            okay_to_draw := false
            break
        else 
            okay_to_draw := true
    okay_to_draw


//      FUNCTION TO DRAW SUPPLY OR DEMAND ZONE
f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atr) =>

    atr_buffer = atr * (box_width / 10)
    box_left = array.get(bn_array, 0)
    box_right = bar_index

    var float box_top = 0.00
    var float box_bottom = 0.00
    var float poi = 0.00


    if box_type == 1
        box_top := array.get(value_array, 0)
        box_bottom := box_top - atr_buffer
        poi := (box_top + box_bottom) / 2
    else if box_type == -1
        box_bottom := array.get(value_array, 0)
        box_top := box_bottom + atr_buffer
        poi := (box_top + box_bottom) / 2

    okay_to_draw = f_check_overlapping(poi, box_array, atr)
    // okay_to_draw = true

    //delete oldest box, and then create a new box and add it to the array
    if box_type == 1 and okay_to_draw
        box.delete( array.get(box_array, array.size(box_array) - 1) )
        f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = supply_outline_color,
             bgcolor = supply_color, extend = extend.right, text = 'SUPPLY', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
        
        box.delete( array.get(label_array, array.size(label_array) - 1) )
        f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = color.new(poi_label_color,90),
             bgcolor = color.new(poi_label_color,90), extend = extend.right, text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))

    else if box_type == -1 and okay_to_draw
        box.delete( array.get(box_array, array.size(box_array) - 1) )
        f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = demand_outline_color,
             bgcolor = demand_color, extend = extend.right,  text = 'DEMAND', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
        
        box.delete( array.get(label_array, array.size(label_array) - 1) )
        f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = color.new(poi_label_color,90),
             bgcolor = color.new(poi_label_color,90), extend = extend.right,  text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))


//      FUNCTION TO CHANGE SUPPLY/DEMAND TO A BOS IF BROKEN
f_sd_to_bos(box_array, bos_array, label_array, zone_type) =>

    if zone_type == 1
        for i = 0 to array.size(box_array) - 1
            level_to_break = box.get_top(array.get(box_array,i))
            // if ta.crossover(close, level_to_break)
            if close >= level_to_break
                copied_box = box.copy(array.get(box_array,i))
                f_array_add_pop(bos_array, copied_box)
                mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
                box.set_top(array.get(bos_array,0), mid)
                box.set_bottom(array.get(bos_array,0), mid)
                box.set_extend( array.get(bos_array,0), extend.none)
                box.set_right( array.get(bos_array,0), bar_index)
                box.set_text( array.get(bos_array,0), 'BOS' )
                box.set_text_color( array.get(bos_array,0), bos_label_color)
                box.set_text_size( array.get(bos_array,0), size.small)
                box.set_text_halign( array.get(bos_array,0), text.align_center)
                box.set_text_valign( array.get(bos_array,0), text.align_center)
                box.delete(array.get(box_array, i))
                box.delete(array.get(label_array, i))


    if zone_type == -1
        for i = 0 to array.size(box_array) - 1
            level_to_break = box.get_bottom(array.get(box_array,i))
            // if ta.crossunder(close, level_to_break)
            if close <= level_to_break
                copied_box = box.copy(array.get(box_array,i))
                f_array_add_pop(bos_array, copied_box)
                mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
                box.set_top(array.get(bos_array,0), mid)
                box.set_bottom(array.get(bos_array,0), mid)
                box.set_extend( array.get(bos_array,0), extend.none)
                box.set_right( array.get(bos_array,0), bar_index)
                box.set_text( array.get(bos_array,0), 'BOS' )
                box.set_text_color( array.get(bos_array,0), bos_label_color)
                box.set_text_size( array.get(bos_array,0), size.small)
                box.set_text_halign( array.get(bos_array,0), text.align_center)
                box.set_text_valign( array.get(bos_array,0), text.align_center)
                box.delete(array.get(box_array, i))
                box.delete(array.get(label_array, i))



//      FUNCTION MANAGE CURRENT BOXES BY CHANGING ENDPOINT
f_extend_box_endpoint(box_array) =>

    for i = 0 to array.size(box_array) - 1
        box.set_right(array.get(box_array, i), bar_index + 100)


//
//END FUNCTIONS
//  


//
//CALCULATIONS
//

//      CALCULATE ATR 
atr = ta.atr(50)

//      CALCULATE SWING HIGHS & SWING LOWS
swing_high = ta.pivothigh(high, swing_length, swing_length)
swing_low = ta.pivotlow(low, swing_length, swing_length)

//      ARRAYS FOR SWING H/L & BN 
var swing_high_values = array.new_float(5,0.00)
var swing_low_values = array.new_float(5,0.00)

var swing_high_bns = array.new_int(5,0)
var swing_low_bns = array.new_int(5,0)

//      ARRAYS FOR SUPPLY / DEMAND
var current_supply_box = array.new_box(history_of_demand_to_keep, na)
var current_demand_box = array.new_box(history_of_demand_to_keep, na)

//      ARRAYS FOR SUPPLY / DEMAND POI LABELS
var current_supply_poi = array.new_box(history_of_demand_to_keep, na)
var current_demand_poi = array.new_box(history_of_demand_to_keep, na)

//      ARRAYS FOR BOS
var supply_bos = array.new_box(5, na)
var demand_bos = array.new_box(5, na)
//
//END CALCULATIONS
//

//      NEW SWING HIGH
if not na(swing_high)

    //MANAGE SWING HIGH VALUES
    f_array_add_pop(swing_high_values, swing_high)
    f_array_add_pop(swing_high_bns, bar_index[swing_length])
    if show_price_action_labels
        f_sh_sl_labels(swing_high_values, 1)

    f_supply_demand(swing_high_values, swing_high_bns, current_supply_box, current_supply_poi, 1, atr)

//      NEW SWING LOW
else if not na(swing_low)

    //MANAGE SWING LOW VALUES
    f_array_add_pop(swing_low_values, swing_low)
    f_array_add_pop(swing_low_bns, bar_index[swing_length])
    if show_price_action_labels
        f_sh_sl_labels(swing_low_values, -1)
    
    f_supply_demand(swing_low_values, swing_low_bns, current_demand_box, current_demand_poi, -1, atr)


f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1)
f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1)

f_extend_box_endpoint(current_supply_box)
f_extend_box_endpoint(current_demand_box)

//ZIG ZAG
h = ta.highest(high, swing_length * 2 + 1)
l = ta.lowest(low, swing_length * 2 + 1)
f_isMin(len) =>
    l == low[len]
f_isMax(len) =>
    h == high[len]

var dirUp = false
var lastLow = high * 100
var lastHigh = 0.0
var timeLow = bar_index
var timeHigh = bar_index
var line li = na

f_drawLine() =>
    _li_color = show_zigzag ? zigzag_color : color.new(#ffffff,100)
    line.new(timeHigh - swing_length, lastHigh, timeLow - swing_length, lastLow, xloc.bar_index, color=_li_color, width=2)

if dirUp
    if f_isMin(swing_length) and low[swing_length] < lastLow
        lastLow := low[swing_length]
        timeLow := bar_index
        line.delete(li)
        li := f_drawLine()
        li

    if f_isMax(swing_length) and high[swing_length] > lastLow
        lastHigh := high[swing_length]
        timeHigh := bar_index
        dirUp := false
        li := f_drawLine()
        li

if not dirUp
    if f_isMax(swing_length) and high[swing_length] > lastHigh
        lastHigh := high[swing_length]
        timeHigh := bar_index
        line.delete(li)
        li := f_drawLine()
        li
    if f_isMin(swing_length) and low[swing_length] < lastHigh
        lastLow := low[swing_length]
        timeLow := bar_index
        dirUp := true
        li := f_drawLine()
        if f_isMax(swing_length) and high[swing_length] > lastLow
            lastHigh := high[swing_length]
            timeHigh := bar_index
            dirUp := false
            li := f_drawLine()
            li
// if barstate.islast
    // label.new(x = bar_index + 10, y = close[1], text = str.tostring( array.size(current_supply_poi) ))
//     label.new(x = bar_index + 20, y = close[1], text = str.tostring( box.get_bottom( array.get(current_supply_box, 0))))
//     label.new(x = bar_index + 30, y = close[1], text = str.tostring( box.get_bottom( array.get(current_supply_box, 1))))
//     label.new(x = bar_index + 40, y = close[1], text = str.tostring( box.get_bottom( array.get(current_supply_box, 2))))
//     label.new(x = bar_index + 50, y = close[1], text = str.tostring( box.get_bottom( array.get(current_supply_box, 3))))
//     label.new(x = bar_index + 60, y = close[1], text = str.tostring( box.get_bottom( array.get(current_supply_box, 4))))

Code: Select all

//@version=5
indicator("Smart Money Concepts [LuxAlgo]", "Smart Money Concepts [LuxAlgo]"
  , overlay = true
  , max_labels_count = 500
  , max_lines_count = 500
  , max_boxes_count = 500
  , max_bars_back = 500)
//-----------------------------------------------------------------------------{
//Constants
//-----------------------------------------------------------------------------{
color TRANSP_CSS = #ffffff00

//Tooltips
string MODE_TOOLTIP          = 'Allows to display historical Structure or only the recent ones'
string STYLE_TOOLTIP         = 'Indicator color theme'
string COLOR_CANDLES_TOOLTIP = 'Display additional candles with a color reflecting the current trend detected by structure'
string SHOW_INTERNAL         = 'Display internal market structure'
string CONFLUENCE_FILTER     = 'Filter non significant internal structure breakouts'
string SHOW_SWING            = 'Display swing market Structure'
string SHOW_SWING_POINTS     = 'Display swing point as labels on the chart'
string SHOW_SWHL_POINTS      = 'Highlight most recent strong and weak high/low points on the chart'
string INTERNAL_OB           = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart'
string SWING_OB              = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart'
string FILTER_OB             = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available'
string SHOW_EQHL             = 'Display equal highs and equal lows on the chart'
string EQHL_BARS             = 'Number of bars used to confirm equal highs and equal lows'
string EQHL_THRESHOLD        = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results'
string SHOW_FVG              = 'Display fair values gaps on the chart'
string AUTO_FVG              = 'Filter out non significant fair value gaps'
string FVG_TF                = 'Fair value gaps timeframe'
string EXTEND_FVG            = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
string PED_ZONES             = 'Display premium, discount, and equilibrium zones on chart'

//-----------------------------------------------------------------------------{
//Settings
//-----------------------------------------------------------------------------{
//General
//----------------------------------------{
mode = input.string('Historical'
  , options = ['Historical', 'Present']
  , group = 'Smart Money Concepts'
  , tooltip = MODE_TOOLTIP)

style = input.string('Colored'
  , options = ['Colored', 'Monochrome']
  , group = 'Smart Money Concepts'
  , tooltip = STYLE_TOOLTIP)

show_trend = input(false, 'Color Candles'
  , group = 'Smart Money Concepts'
  , tooltip = COLOR_CANDLES_TOOLTIP)

//----------------------------------------}
//Internal Structure
//----------------------------------------{
show_internals = input(true, 'Show Internal Structure'
  , group = 'Real Time Internal Structure'
  , tooltip = SHOW_INTERNAL)

show_ibull = input.string('All', 'Bullish Structure'
  , options = ['All', 'BOS', 'CHoCH']
  , inline = 'ibull'
  , group = 'Real Time Internal Structure')

swing_ibull_css = input(#089981, ''
  , inline = 'ibull'
  , group = 'Real Time Internal Structure')

//Bear Structure
show_ibear = input.string('All', 'Bearish Structure'
  , options = ['All', 'BOS', 'CHoCH']
  , inline = 'ibear'
  , group = 'Real Time Internal Structure')

swing_ibear_css = input(#f23645, ''
  , inline = 'ibear'
  , group = 'Real Time Internal Structure')

ifilter_confluence = input(false, 'Confluence Filter'
  , group = 'Real Time Internal Structure'
  , tooltip = CONFLUENCE_FILTER)

internal_structure_size = input.string('Tiny', 'Internal Label Size'
  , options = ['Tiny', 'Small', 'Normal']
  , group = 'Real Time Internal Structure')

//----------------------------------------}
//Swing Structure
//----------------------------------------{
show_Structure = input(true, 'Show Swing Structure'
  , group = 'Real Time Swing Structure'
  , tooltip = SHOW_SWING)

//Bull Structure
show_bull = input.string('All', 'Bullish Structure'
  , options = ['All', 'BOS', 'CHoCH']
  , inline = 'bull'
  , group = 'Real Time Swing Structure')

swing_bull_css = input(#089981, ''
  , inline = 'bull'
  , group = 'Real Time Swing Structure')

//Bear Structure
show_bear = input.string('All', 'Bearish Structure'
  , options = ['All', 'BOS', 'CHoCH']
  , inline = 'bear'
  , group = 'Real Time Swing Structure')

swing_bear_css = input(#f23645, ''
  , inline = 'bear'
  , group = 'Real Time Swing Structure')

swing_structure_size = input.string('Small', 'Swing Label Size'
  , options = ['Tiny', 'Small', 'Normal']
  , group = 'Real Time Swing Structure')

//Swings
show_swings = input(false, 'Show Swings Points'
  , inline = 'swings'
  , group = 'Real Time Swing Structure'
  , tooltip = SHOW_SWING_POINTS)

length = input.int(50, ''
  , minval = 10
  , inline = 'swings'
  , group = 'Real Time Swing Structure')

show_hl_swings = input(true, 'Show Strong/Weak High/Low'
  , group = 'Real Time Swing Structure'
  , tooltip = SHOW_SWHL_POINTS)

//----------------------------------------}
//Order Blocks
//----------------------------------------{
show_iob = input(true, 'Internal Order Blocks'
  , inline = 'iob'
  , group = 'Order Blocks'
  , tooltip = INTERNAL_OB)

iob_showlast = input.int(5, ''
  , minval = 1
  , inline = 'iob'
  , group = 'Order Blocks')

show_ob = input(false, 'Swing Order Blocks'
  , inline = 'ob'
  , group = 'Order Blocks'
  , tooltip = SWING_OB)

ob_showlast = input.int(5, ''
  , minval = 1
  , inline = 'ob'
  , group = 'Order Blocks')

ob_filter = input.string('Atr', 'Order Block Filter'
  , options = ['Atr', 'Cumulative Mean Range']
  , group = 'Order Blocks'
  , tooltip = FILTER_OB)

ibull_ob_css = input.color(color.new(#3179f5, 80), 'Internal Bullish OB'
  , group = 'Order Blocks')

ibear_ob_css = input.color(color.new(#f77c80, 80), 'Internal Bearish OB'
  , group = 'Order Blocks')

bull_ob_css = input.color(color.new(#1848cc, 80), 'Bullish OB'
  , group = 'Order Blocks')

bear_ob_css = input.color(color.new(#b22833, 80), 'Bearish OB'
  , group = 'Order Blocks')

//----------------------------------------}
//EQH/EQL
//----------------------------------------{
show_eq = input(true, 'Equal High/Low'
  , group = 'EQH/EQL'
  , tooltip = SHOW_EQHL)

eq_len = input.int(3, 'Bars Confirmation'
  , minval = 1
  , group = 'EQH/EQL'
  , tooltip = EQHL_BARS)

eq_threshold = input.float(0.1, 'Threshold'
  , minval = 0
  , maxval = 0.5
  , step = 0.1
  , group = 'EQH/EQL'
  , tooltip = EQHL_THRESHOLD)

eq_size = input.string('Tiny', 'Label Size'
  , options = ['Tiny', 'Small', 'Normal']
  , group = 'EQH/EQL')

//----------------------------------------}
//Fair Value Gaps
//----------------------------------------{
show_fvg = input(false, 'Fair Value Gaps'
  , group = 'Fair Value Gaps'
  , tooltip = SHOW_FVG)
  
fvg_auto = input(true, "Auto Threshold"
  , group = 'Fair Value Gaps'
  , tooltip = AUTO_FVG)

fvg_tf = input.timeframe('', "Timeframe"
  , group = 'Fair Value Gaps'
  , tooltip = FVG_TF)

bull_fvg_css = input.color(color.new(#00ff68, 70), 'Bullish FVG'
  , group = 'Fair Value Gaps')

bear_fvg_css = input.color(color.new(#ff0008, 70), 'Bearish FVG'
  , group = 'Fair Value Gaps')

fvg_extend = input.int(1, "Extend FVG"
  , minval = 0
  , group = 'Fair Value Gaps'
  , tooltip = EXTEND_FVG)

//----------------------------------------}
//Previous day/week high/low
//----------------------------------------{
//Daily
show_pdhl = input(false, 'Daily'
  , inline = 'daily'
  , group = 'Highs & Lows MTF')

pdhl_style = input.string('⎯⎯⎯', ''
  , options = ['⎯⎯⎯', '----', '····']
  , inline = 'daily'
  , group = 'Highs & Lows MTF')

pdhl_css = input(#2157f3, ''
  , inline = 'daily'
  , group = 'Highs & Lows MTF')

//Weekly
show_pwhl = input(false, 'Weekly'
  , inline = 'weekly'
  , group = 'Highs & Lows MTF')

pwhl_style = input.string('⎯⎯⎯', ''
  , options = ['⎯⎯⎯', '----', '····']
  , inline = 'weekly'
  , group = 'Highs & Lows MTF')

pwhl_css = input(#2157f3, ''
  , inline = 'weekly'
  , group = 'Highs & Lows MTF')

//Monthly
show_pmhl = input(false, 'Monthly'
  , inline = 'monthly'
  , group = 'Highs & Lows MTF')

pmhl_style = input.string('⎯⎯⎯', ''
  , options = ['⎯⎯⎯', '----', '····']
  , inline = 'monthly'
  , group = 'Highs & Lows MTF')

pmhl_css = input(#2157f3, ''
  , inline = 'monthly'
  , group = 'Highs & Lows MTF')

//----------------------------------------}
//Premium/Discount zones
//----------------------------------------{
show_sd = input(false, 'Premium/Discount Zones'
  , group = 'Premium & Discount Zones'
  , tooltip = PED_ZONES)

premium_css = input.color(#f23645, 'Premium Zone'
  , group = 'Premium & Discount Zones')

eq_css = input.color(#b2b5be, 'Equilibrium Zone'
  , group = 'Premium & Discount Zones')

discount_css = input.color(#089981, 'Discount Zone'
  , group = 'Premium & Discount Zones')

//-----------------------------------------------------------------------------}
//Functions
//-----------------------------------------------------------------------------{
n = bar_index

atr = ta.atr(200)
cmean_range = ta.cum(high - low) / n

//HL Output function
hl() => [high, low]

//Get ohlc values function
get_ohlc()=> [close[1], open[1], high, low, high[2], low[2]]

//Display Structure function
display_Structure(x, y, txt, css, dashed, down, lbl_size)=>
    structure_line = line.new(x, y, n, y
      , color = css
      , style = dashed ? line.style_dashed : line.style_solid)

    structure_lbl = label.new(int(math.avg(x, n)), y, txt
      , color = TRANSP_CSS
      , textcolor = css
      , style = down ? label.style_label_down : label.style_label_up
      , size = lbl_size)

    if mode == 'Present'
        line.delete(structure_line[1])
        label.delete(structure_lbl[1])

//Swings detection/measurements
swings(len)=>
    var os = 0
    
    upper = ta.highest(len)
    lower = ta.lowest(len)

    os := high[len] > upper ? 0 : low[len] < lower ? 1 : os[1]

    top = os == 0 and os[1] != 0 ? high[len] : 0
    btm = os == 1 and os[1] != 1 ? low[len] : 0

    [top, btm]

//Order block coordinates function
ob_coord(use_max, loc, target_top, target_btm, target_left, target_type)=>
    min = 99999999.
    max = 0.
    idx = 1

    ob_threshold = ob_filter == 'Atr' ? atr : cmean_range 

    //Search for highest/lowest high within the structure interval and get range
    if use_max
        for i = 1 to (n - loc)-1
            if (high[i] - low[i]) < ob_threshold[i] * 2
                max := math.max(high[i], max)
                min := max == high[i] ? low[i] : min
                idx := max == high[i] ? i : idx
    else
        for i = 1 to (n - loc)-1
            if (high[i] - low[i]) < ob_threshold[i] * 2
                min := math.min(low[i], min)
                max := min == low[i] ? high[i] : max
                idx := min == low[i] ? i : idx

    array.unshift(target_top, max)
    array.unshift(target_btm, min)
    array.unshift(target_left, time[idx])
    array.unshift(target_type, use_max ? -1 : 1)

//Set order blocks
display_ob(boxes, target_top, target_btm, target_left, target_type, show_last, swing, size)=>
    for i = 0 to math.min(show_last-1, size-1)
        get_box = array.get(boxes, i)

        box.set_lefttop(get_box, array.get(target_left, i), array.get(target_top, i))
        box.set_rightbottom(get_box, array.get(target_left, i), array.get(target_btm, i))
        box.set_extend(get_box, extend.right)

        color css = na
        
        if swing 
            if style == 'Monochrome'
                css := array.get(target_type, i) == 1 ? color.new(#b2b5be, 80) : color.new(#5d606b, 80)
                border_css = array.get(target_type, i) == 1 ? #b2b5be : #5d606b
                box.set_border_color(get_box, border_css)
            else
                css := array.get(target_type, i) == 1 ? bull_ob_css : bear_ob_css
                box.set_border_color(get_box, css)

            box.set_bgcolor(get_box, css)
        else
            if style == 'Monochrome'
                css := array.get(target_type, i) == 1 ? color.new(#b2b5be, 80) : color.new(#5d606b, 80)
            else
                css := array.get(target_type, i) == 1 ? ibull_ob_css : ibear_ob_css
            
            box.set_border_color(get_box, css)
            box.set_bgcolor(get_box, css)
        
//Line Style function
get_line_style(style) =>
    out = switch style
        '⎯⎯⎯'  => line.style_solid
        '----' => line.style_dashed
        '····' => line.style_dotted

//Set line/labels function for previous high/lows
phl(h, l, tf, css)=>
    var line high_line = line.new(na,na,na,na
      , xloc = xloc.bar_time
      , color = css
      , style = get_line_style(pdhl_style))

    var label high_lbl = label.new(na,na
      , xloc = xloc.bar_time
      , text = str.format('P{0}H', tf)
      , color = TRANSP_CSS
      , textcolor = css
      , size = size.small
      , style = label.style_label_left)

    var line low_line = line.new(na,na,na,na
      , xloc = xloc.bar_time
      , color = css
      , style = get_line_style(pdhl_style))

    var label low_lbl = label.new(na,na
      , xloc = xloc.bar_time
      , text = str.format('P{0}L', tf)
      , color = TRANSP_CSS
      , textcolor = css
      , size = size.small
      , style = label.style_label_left)

    hy = ta.valuewhen(h != h[1], h, 1)
    hx = ta.valuewhen(h == high, time, 1)

    ly = ta.valuewhen(l != l[1], l, 1)
    lx = ta.valuewhen(l == low, time, 1)

    if barstate.islast
        ext = time + (time - time[1])*20

        //High
        line.set_xy1(high_line, hx, hy)
        line.set_xy2(high_line, ext, hy)

        label.set_xy(high_lbl, ext, hy)

        //Low
        line.set_xy1(low_line, lx, ly)
        line.set_xy2(low_line, ext, ly)

        label.set_xy(low_lbl, ext, ly)

//-----------------------------------------------------------------------------}
//Global variables
//-----------------------------------------------------------------------------{
var trend = 0, var itrend = 0

var top_y = 0., var top_x = 0
var btm_y = 0., var btm_x = 0

var itop_y = 0., var itop_x = 0
var ibtm_y = 0., var ibtm_x = 0

var trail_up = high, var trail_dn = low
var trail_up_x = 0,  var trail_dn_x = 0

var top_cross = true,  var btm_cross = true
var itop_cross = true, var ibtm_cross = true

var txt_top = '',  var txt_btm = ''

//Alerts
bull_choch_alert = false 
bull_bos_alert   = false 

bear_choch_alert = false 
bear_bos_alert   = false 

bull_ichoch_alert = false 
bull_ibos_alert   = false 

bear_ichoch_alert = false 
bear_ibos_alert   = false 

bull_iob_break = false 
bear_iob_break = false

bull_ob_break = false 
bear_ob_break = false

eqh_alert = false 
eql_alert = false 

//Structure colors
var bull_css = style == 'Monochrome' ? #b2b5be 
  : swing_bull_css

var bear_css = style == 'Monochrome' ? #b2b5be 
  : swing_bear_css

var ibull_css = style == 'Monochrome' ? #b2b5be 
  : swing_ibull_css

var ibear_css = style == 'Monochrome' ? #b2b5be 
  : swing_ibear_css

//Labels size
var internal_structure_lbl_size = internal_structure_size == 'Tiny' 
  ? size.tiny 
  : internal_structure_size == 'Small' 
  ? size.small 
  : size.normal 

var swing_structure_lbl_size = swing_structure_size == 'Tiny' 
  ? size.tiny 
  : swing_structure_size == 'Small' 
  ? size.small 
  : size.normal 

var eqhl_lbl_size = eq_size == 'Tiny' 
  ? size.tiny 
  : eq_size == 'Small' 
  ? size.small
  : size.normal 

//Swings
[top, btm] = swings(length)

[itop, ibtm] = swings(5)

//-----------------------------------------------------------------------------}
//Pivot High
//-----------------------------------------------------------------------------{
var line extend_top = na

var label extend_top_lbl = label.new(na, na
  , color = TRANSP_CSS
  , textcolor = bear_css
  , style = label.style_label_down
  , size = size.tiny)

if top
    top_cross := true
    txt_top := top > top_y ? 'HH' : 'LH'

    if show_swings
        top_lbl = label.new(n-length, top, txt_top
          , color = TRANSP_CSS
          , textcolor = bear_css
          , style = label.style_label_down
          , size = swing_structure_lbl_size)

        if mode == 'Present'
            label.delete(top_lbl[1])

    //Extend recent top to last bar
    line.delete(extend_top[1])
    extend_top := line.new(n-length, top, n, top
      , color = bear_css)

    top_y := top
    top_x := n - length

    trail_up := top
    trail_up_x := n - length

if itop
    itop_cross := true

    itop_y := itop
    itop_x := n - 5

//Trailing maximum
trail_up := math.max(high, trail_up)
trail_up_x := trail_up == high ? n : trail_up_x

//Set top extension label/line
if barstate.islast and show_hl_swings
    line.set_xy1(extend_top, trail_up_x, trail_up)
    line.set_xy2(extend_top, n + 20, trail_up)

    label.set_x(extend_top_lbl, n + 20)
    label.set_y(extend_top_lbl, trail_up)
    label.set_text(extend_top_lbl, trend < 0 ? 'Strong High' : 'Weak High')

//-----------------------------------------------------------------------------}
//Pivot Low
//-----------------------------------------------------------------------------{
var line extend_btm = na 

var label extend_btm_lbl = label.new(na, na
  , color = TRANSP_CSS
  , textcolor = bull_css
  , style = label.style_label_up
  , size = size.tiny)

if btm
    btm_cross := true
    txt_btm := btm < btm_y ? 'LL' : 'HL'
    
    if show_swings
        btm_lbl = label.new(n - length, btm, txt_btm
          , color = TRANSP_CSS
          , textcolor = bull_css
          , style = label.style_label_up
          , size = swing_structure_lbl_size)

        if mode == 'Present'
            label.delete(btm_lbl[1])
    
    //Extend recent btm to last bar
    line.delete(extend_btm[1])
    extend_btm := line.new(n - length, btm, n, btm
      , color = bull_css)

    btm_y := btm
    btm_x := n-length

    trail_dn := btm
    trail_dn_x := n-length

if ibtm
    ibtm_cross := true

    ibtm_y := ibtm
    ibtm_x := n - 5

//Trailing minimum
trail_dn := math.min(low, trail_dn)
trail_dn_x := trail_dn == low ? n : trail_dn_x

//Set btm extension label/line
if barstate.islast and show_hl_swings
    line.set_xy1(extend_btm, trail_dn_x, trail_dn)
    line.set_xy2(extend_btm, n + 20, trail_dn)

    label.set_x(extend_btm_lbl, n + 20)
    label.set_y(extend_btm_lbl, trail_dn)
    label.set_text(extend_btm_lbl, trend > 0 ? 'Strong Low' : 'Weak Low')

//-----------------------------------------------------------------------------}
//Order Blocks Arrays
//-----------------------------------------------------------------------------{
var iob_top = array.new_float(0)
var iob_btm = array.new_float(0)
var iob_left = array.new_int(0)
var iob_type = array.new_int(0)

var ob_top = array.new_float(0)
var ob_btm = array.new_float(0)
var ob_left = array.new_int(0)
var ob_type = array.new_int(0)

//-----------------------------------------------------------------------------}
//Pivot High BOS/CHoCH
//-----------------------------------------------------------------------------{
//Filtering
var bull_concordant = true

if ifilter_confluence
    bull_concordant := high - math.max(close, open) > math.min(close, open - low)

//Detect internal bullish Structure
if ta.crossover(close, itop_y) and itop_cross and top_y != itop_y and bull_concordant
    bool choch = na
    
    if itrend < 0
        choch := true
        bull_ichoch_alert := true
    else 
        bull_ibos_alert := true
    
    txt = choch ? 'CHoCH' : 'BOS'

    if show_internals
        if show_ibull == 'All' or (show_ibull == 'BOS' and not choch) or (show_ibull == 'CHoCH' and choch)
            display_Structure(itop_x, itop_y, txt, ibull_css, true, true, internal_structure_lbl_size)
    
    itop_cross := false
    itrend := 1
    
    //Internal Order Block
    if show_iob
        ob_coord(false, itop_x, iob_top, iob_btm, iob_left, iob_type)

//Detect bullish Structure
if ta.crossover(close, top_y) and top_cross
    bool choch = na
    
    if trend < 0
        choch := true
        bull_choch_alert := true
    else 
        bull_bos_alert := true

    txt = choch ? 'CHoCH' : 'BOS'
    
    if show_Structure
        if show_bull == 'All' or (show_bull == 'BOS' and not choch) or (show_bull == 'CHoCH' and choch)
            display_Structure(top_x, top_y, txt, bull_css, false, true, swing_structure_lbl_size)
    
    //Order Block
    if show_ob
        ob_coord(false, top_x, ob_top, ob_btm, ob_left, ob_type)

    top_cross := false
    trend := 1

//-----------------------------------------------------------------------------}
//Pivot Low BOS/CHoCH
//-----------------------------------------------------------------------------{
var bear_concordant = true

if ifilter_confluence
    bear_concordant := high - math.max(close, open) < math.min(close, open - low)

//Detect internal bearish Structure
if ta.crossunder(close, ibtm_y) and ibtm_cross and btm_y != ibtm_y and bear_concordant
    bool choch = false
    
    if itrend > 0
        choch := true
        bear_ichoch_alert := true
    else 
        bear_ibos_alert := true
    
    txt = choch ? 'CHoCH' : 'BOS'

    if show_internals
        if show_ibear == 'All' or (show_ibear == 'BOS' and not choch) or (show_ibear == 'CHoCH' and choch)
            display_Structure(ibtm_x, ibtm_y, txt, ibear_css, true, false, internal_structure_lbl_size)
    
    ibtm_cross := false
    itrend := -1
    
    //Internal Order Block
    if show_iob
        ob_coord(true, ibtm_x, iob_top, iob_btm, iob_left, iob_type)

//Detect bearish Structure
if ta.crossunder(close, btm_y) and btm_cross
    bool choch = na
    
    if trend > 0
        choch := true
        bear_choch_alert := true
    else 
        bear_bos_alert := true

    txt = choch ? 'CHoCH' : 'BOS'
    
    if show_Structure
        if show_bear == 'All' or (show_bear == 'BOS' and not choch) or (show_bear == 'CHoCH' and choch)
            display_Structure(btm_x, btm_y, txt, bear_css, false, false, swing_structure_lbl_size)
    
    //Order Block
    if show_ob
        ob_coord(true, btm_x, ob_top, ob_btm, ob_left, ob_type)

    btm_cross := false
    trend := -1

//-----------------------------------------------------------------------------}
//Order Blocks
//-----------------------------------------------------------------------------{
//Set order blocks
var iob_boxes = array.new_box(0)
var ob_boxes = array.new_box(0)

//Delete internal order blocks box coordinates if top/bottom is broken
for element in iob_type
    index = array.indexof(iob_type, element)

    if close < array.get(iob_btm, index) and element == 1
        array.remove(iob_top, index) 
        array.remove(iob_btm, index) 
        array.remove(iob_left, index) 
        array.remove(iob_type, index)
        bull_iob_break := true

    else if close > array.get(iob_top, index) and element == -1
        array.remove(iob_top, index) 
        array.remove(iob_btm, index)
        array.remove(iob_left, index) 
        array.remove(iob_type, index)
        bear_iob_break := true

//Delete internal order blocks box coordinates if top/bottom is broken
for element in ob_type
    index = array.indexof(ob_type, element)

    if close < array.get(ob_btm, index) and element == 1
        array.remove(ob_top, index) 
        array.remove(ob_btm, index) 
        array.remove(ob_left, index) 
        array.remove(ob_type, index)
        bull_ob_break := true

    else if close > array.get(ob_top, index) and element == -1
        array.remove(ob_top, index) 
        array.remove(ob_btm, index)
        array.remove(ob_left, index) 
        array.remove(ob_type, index)
        bear_ob_break := true

iob_size = array.size(iob_type)
ob_size = array.size(ob_type)

if barstate.isfirst
    if show_iob
        for i = 0 to iob_showlast-1
            array.push(iob_boxes, box.new(na,na,na,na, xloc = xloc.bar_time))
    if show_ob
        for i = 0 to ob_showlast-1
            array.push(ob_boxes, box.new(na,na,na,na, xloc = xloc.bar_time))

if iob_size > 0
    if barstate.islast
        display_ob(iob_boxes, iob_top, iob_btm, iob_left, iob_type, iob_showlast, false, iob_size)

if ob_size > 0
    if barstate.islast
        display_ob(ob_boxes, ob_top, ob_btm, ob_left, ob_type, ob_showlast, true, ob_size)

//-----------------------------------------------------------------------------}
//EQH/EQL
//-----------------------------------------------------------------------------{
var eq_prev_top = 0.
var eq_top_x = 0

var eq_prev_btm = 0.
var eq_btm_x = 0

if show_eq
    eq_top = ta.pivothigh(eq_len, eq_len)
    eq_btm = ta.pivotlow(eq_len, eq_len)

    if eq_top 
        max = math.max(eq_top, eq_prev_top)
        min = math.min(eq_top, eq_prev_top)
        
        if max < min + atr * eq_threshold
            eqh_line = line.new(eq_top_x, eq_prev_top, n-eq_len, eq_top
              , color = bear_css
              , style = line.style_dotted)

            eqh_lbl = label.new(int(math.avg(n-eq_len, eq_top_x)), eq_top, 'EQH'
              , color = #00000000
              , textcolor = bear_css
              , style = label.style_label_down
              , size = eqhl_lbl_size)

            if mode == 'Present'
                line.delete(eqh_line[1])
                label.delete(eqh_lbl[1])
            
            eqh_alert := true

        eq_prev_top := eq_top
        eq_top_x := n-eq_len

    if eq_btm 
        max = math.max(eq_btm, eq_prev_btm)
        min = math.min(eq_btm, eq_prev_btm)
        
        if min > max - atr * eq_threshold
            eql_line = line.new(eq_btm_x, eq_prev_btm, n-eq_len, eq_btm
              , color = bull_css
              , style = line.style_dotted)

            eql_lbl = label.new(int(math.avg(n-eq_len, eq_btm_x)), eq_btm, 'EQL'
              , color = #00000000
              , textcolor = bull_css
              , style = label.style_label_up
              , size = eqhl_lbl_size)

            eql_alert := true

            if mode == 'Present'
                line.delete(eql_line[1])
                label.delete(eql_lbl[1])

        eq_prev_btm := eq_btm
        eq_btm_x := n-eq_len

//-----------------------------------------------------------------------------}
//Fair Value Gaps
//-----------------------------------------------------------------------------{
var bullish_fvg_max = array.new_box(0)
var bullish_fvg_min = array.new_box(0)

var bearish_fvg_max = array.new_box(0)
var bearish_fvg_min = array.new_box(0)

float bullish_fvg_avg = na
float bearish_fvg_avg = na

bullish_fvg_cnd = false
bearish_fvg_cnd = false

[src_c1, src_o1, src_h, src_l, src_h2, src_l2] =
  request.security(syminfo.tickerid, fvg_tf, get_ohlc())

if show_fvg
    delta_per = (src_c1 - src_o1) / src_o1 * 100

    change_tf = timeframe.change(fvg_tf)

    threshold = fvg_auto ? ta.cum(math.abs(change_tf ? delta_per : 0)) / n * 2 
      : 0

    //FVG conditions
    bullish_fvg_cnd := src_l > src_h2
      and src_c1 > src_h2 
      and delta_per > threshold
      and change_tf

    bearish_fvg_cnd := src_h < src_l2 
      and src_c1 < src_l2 
      and -delta_per > threshold
      and change_tf

    //FVG Areas
    if bullish_fvg_cnd
        array.unshift(bullish_fvg_max, box.new(n-1, src_l, n + fvg_extend, math.avg(src_l, src_h2)
          , border_color = bull_fvg_css
          , bgcolor = bull_fvg_css))
        
        array.unshift(bullish_fvg_min, box.new(n-1, math.avg(src_l, src_h2), n + fvg_extend, src_h2
          , border_color = bull_fvg_css
          , bgcolor = bull_fvg_css))
    
    if bearish_fvg_cnd
        array.unshift(bearish_fvg_max, box.new(n-1, src_h, n + fvg_extend, math.avg(src_h, src_l2)
          , border_color = bear_fvg_css
          , bgcolor = bear_fvg_css))
        
        array.unshift(bearish_fvg_min, box.new(n-1, math.avg(src_h, src_l2), n + fvg_extend, src_l2
          , border_color = bear_fvg_css
          , bgcolor = bear_fvg_css))

    for bx in bullish_fvg_min
        if low < box.get_bottom(bx)
            box.delete(bx)
            box.delete(array.get(bullish_fvg_max, array.indexof(bullish_fvg_min, bx)))
    
    for bx in bearish_fvg_max
        if high > box.get_top(bx)
            box.delete(bx)
            box.delete(array.get(bearish_fvg_min, array.indexof(bearish_fvg_max, bx)))

//-----------------------------------------------------------------------------}
//Previous day/week high/lows
//-----------------------------------------------------------------------------{
//Daily high/low
[pdh, pdl] = request.security(syminfo.tickerid, 'D', hl()
  , lookahead = barmerge.lookahead_on)

//Weekly high/low
[pwh, pwl] = request.security(syminfo.tickerid, 'W', hl()
  , lookahead = barmerge.lookahead_on)

//Monthly high/low
[pmh, pml] = request.security(syminfo.tickerid, 'M', hl()
  , lookahead = barmerge.lookahead_on)

//Display Daily
if show_pdhl
    phl(pdh, pdl, 'D', pdhl_css)

//Display Weekly
if show_pwhl
    phl(pwh, pwl, 'W', pwhl_css)
    
//Display Monthly
if show_pmhl
    phl(pmh, pml, 'M', pmhl_css)

//-----------------------------------------------------------------------------}
//Premium/Discount/Equilibrium zones
//-----------------------------------------------------------------------------{
var premium = box.new(na, na, na, na
  , bgcolor = color.new(premium_css, 80)
  , border_color = na)

var premium_lbl = label.new(na, na
  , text = 'Premium'
  , color = TRANSP_CSS
  , textcolor = premium_css
  , style = label.style_label_down
  , size = size.small)

var eq = box.new(na, na, na, na
  , bgcolor = color.rgb(120, 123, 134, 80)
  , border_color = na)

var eq_lbl = label.new(na, na
  , text = 'Equilibrium'
  , color = TRANSP_CSS
  , textcolor = eq_css
  , style = label.style_label_left
  , size = size.small)

var discount = box.new(na, na, na, na
  , bgcolor = color.new(discount_css, 80)
  , border_color = na)

var discount_lbl = label.new(na, na
  , text = 'Discount'
  , color = TRANSP_CSS
  , textcolor = discount_css
  , style = label.style_label_up
  , size = size.small)

//Show Premium/Discount Areas
if barstate.islast and show_sd
    avg = math.avg(trail_up, trail_dn)

    box.set_lefttop(premium, math.max(top_x, btm_x), trail_up)
    box.set_rightbottom(premium, n, .95 * trail_up + .05 * trail_dn)

    label.set_xy(premium_lbl, int(math.avg(math.max(top_x, btm_x), n)), trail_up)

    box.set_lefttop(eq, math.max(top_x, btm_x), .525 * trail_up + .475*trail_dn)
    box.set_rightbottom(eq, n, .525 * trail_dn + .475 * trail_up)

    label.set_xy(eq_lbl, n, avg)
    
    box.set_lefttop(discount, math.max(top_x, btm_x), .95 * trail_dn + .05 * trail_up)
    box.set_rightbottom(discount, n, trail_dn)
    label.set_xy(discount_lbl, int(math.avg(math.max(top_x, btm_x), n)), trail_dn)

//-----------------------------------------------------------------------------}
//Trend
//-----------------------------------------------------------------------------{
var color trend_css = na

if show_trend
    if style == 'Colored'
        trend_css := itrend == 1 ? bull_css : bear_css
    else if style == 'Monochrome'
        trend_css := itrend == 1 ? #b2b5be : #5d606b

plotcandle(open, high, low, close
  , color = trend_css
  , wickcolor = trend_css
  , bordercolor = trend_css
  , editable = false)

//-----------------------------------------------------------------------------}
//Alerts
//-----------------------------------------------------------------------------{
//Internal Structure
alertcondition(bull_ibos_alert, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(bull_ichoch_alert, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')

alertcondition(bear_ibos_alert, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(bear_ichoch_alert, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')

//Swing Structure
alertcondition(bull_bos_alert, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(bull_choch_alert, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')

alertcondition(bear_bos_alert, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(bear_choch_alert, 'Bearish CHoCH', 'Bearish CHoCH formed')

//order Blocks
alertcondition(bull_iob_break, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(bear_iob_break, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')

alertcondition(bull_ob_break, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(bear_ob_break, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')

//EQH/EQL
alertcondition(eqh_alert, 'Equal Highs', 'Equal highs detected')
alertcondition(eql_alert, 'Equal Lows', 'Equal lows detected')

//FVG
alertcondition(bullish_fvg_cnd, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(bearish_fvg_cnd, 'Bearish FVG', 'Bearish FVG formed')

//-----------------------------------------------------------------------------}

Code: Select all

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

//@version=5
indicator(title = "Musashi_Fractal_Dimension_v2", overlay = false, max_bars_back = 5000)

//===================================
// GENERAL INPUTS
//===================================
// ----------------------------------
show_fdi = input.bool(true, title = "FDI      ", group='STUDIES', inline='studies')
show_rsi = input.bool(false, title = "RSI      ", group='STUDIES', inline='studies')
show_bbwp = input.bool(false, title = "BBWP", group='STUDIES', inline='studies')
// ----------------------------------

//===================================
// FDI INPUTS
//===================================
// ----------------------------------
fdi_src    = input.source(close, title = "FDI Source        ", group='FDI - FRACTAL DIMENSION INDEX', inline='fdi_a')
fdi_length = input.int(21, title = "Slow FDI Length   ", minval = 2, group='FDI - FRACTAL DIMENSION INDEX', inline='fdi_0')
fdi_length_2 = input.int(13, title = "Fast FDIs Length 1:", minval = 2, group='FDI - FRACTAL DIMENSION INDEX', inline='fdi_1')
fdi_length_3 = input.int(12, title = "2:", minval = 2, group='FDI - FRACTAL DIMENSION INDEX', inline='fdi_1')
fdi_length_4 = input.int(11, title = "3:", minval = 2, group='FDI - FRACTAL DIMENSION INDEX', inline='fdi_1')
// ----------------------------------
bandLength = input.int(21, minval = 1, title = "Baseline Length   ", group='FDI - FRACTAL DIMENSION INDEX', inline='base_1')
// ----------------------------------
ultra_show_fdi = input.bool(false, title = "Show Ultra-Slow FDI", group='ULTRA-SLOW FDI', inline='base_0')
ultra_fdi_length = input.int(34, title = "     Length", minval = 2, group='ULTRA-SLOW FDI', inline='base_0')
// ----------------------------------
ultra_show_fdi_baseline = input.bool(false, title = "Show Baseline", group='ULTRA-SLOW FDI', inline='base_2')
ultra_bandLength = input.int(15, minval = 1, title = "          Length", group='ULTRA-SLOW FDI', inline='base_2')
// ----------------------------------

//===================================
// PLOT HORIZONTAL LINES
//===================================
// ----------------------------------
adjust_number = show_fdi or ultra_show_fdi or ultra_show_fdi_baseline ? 1 : 0
// ----------------------------------
p_scaleHi   = hline (show_bbwp or show_rsi ?  1 + adjust_number : na, 'High', color.new(#f57c00,50), hline.style_dotted )
p_scaleHi_1 = hline (show_fdi or show_bbwp or show_rsi ? 0.8 + adjust_number : na, 'Level 6', color.new(#b71c1c,50), hline.style_dotted )
p_scaleHi_2 = hline (show_fdi or show_rsi ? 0.75 + adjust_number : na,'Level 5', color.new(#b71c1c,50), hline.style_dotted )
p_scaleHi_3 = hline (show_fdi? 0.6 + adjust_number : na, 'Level 4', color.new(#b71c1c,50), hline.style_dotted )
p_midLine   = hline (show_fdi or show_bbwp or show_rsi or ultra_show_fdi or ultra_show_fdi_baseline? 0.5 + adjust_number : na, 'Mid-Line', color.new(#f57c00,42), hline.style_dashed )
p_scaleLo   = hline (show_fdi ? 0.4 + adjust_number : na, 'Level 3', color.new(#b71c1c,50), hline.style_dotted )
p_scaleLo_1 = hline (show_fdi or show_rsi ? 0.25 + adjust_number : na,'Level 2', color.new(#b71c1c,50), hline.style_dotted )
p_scaleLo_2 = hline (show_fdi or show_bbwp or show_rsi ? 0.2 + adjust_number : na, 'Level 1', color.new(#b71c1c,50), hline.style_dotted )
p_scaleLo_3 = hline (show_bbwp or show_rsi ? 0 + adjust_number : na, 'Low', color.new(#f57c00,50), hline.style_dotted )
// ----------------------------------

//===================================
// FDI CALCULATIONS
//===================================
// ----------------------------------
calculate_FDI(fdi_src, fdi_length) =>
    highest_high = ta.highest(fdi_src, fdi_length)
    lowest_low   = ta.lowest(fdi_src,  fdi_length)
    // ----------------------------------
    diff = float(0.0)
    length = float(0.0)
    for i = 1 to fdi_length - 1
        diff := (fdi_src[i] - lowest_low) / (highest_high - lowest_low)
        length := length + math.sqrt(math.pow(diff[i] - diff[i+1], 2) + (1 / math.pow(fdi_length, 2)))

    fdi = 1 + (math.log(length) + math.log(2)) / math.log(2*fdi_length)
    fdi
// ----------------------------------
fdi  = float(0.0)
fdi := calculate_FDI(fdi_src, fdi_length)
// ----------------------------------
fdi_2  = float(0.0)
fdi_2 := calculate_FDI(fdi_src, fdi_length_2)
// ----------------------------------
fdi_3  = float(0.0)
fdi_3 := calculate_FDI(fdi_src, fdi_length_3)
// ----------------------------------
fdi_4  = float(0.0)
fdi_4 := calculate_FDI(fdi_src, fdi_length_4)
// ----------------------------------
offs = (1.6185 * ta.stdev(fdi, bandLength))  
ma = ta.sma(fdi, bandLength)
// ------------------------------------
fdi_color = fdi_2 > fdi ? show_fdi ? color.new(color.silver,25) : na :  show_fdi ? color.new(#e92727, 0) : na
fdi_plot   = plot(show_fdi ? fdi : na, title = "Slow FDI", color = fdi_color, linewidth=2)
// ----------------------------------
fdi_color_2 = fdi_2 > fdi ? show_fdi ? color.new(color.silver,66) : na :  show_fdi ? color.new(#e92727, 56) : na
fdi_plot_2   = plot(show_fdi ? fdi_2 : na, title = "Fast FDI 1", color = fdi_color_2, linewidth=2)
// ----------------------------------
fdi_color_3 = fdi_3 > fdi_2 ? show_fdi ? color.new(#434651,46) : na :  show_fdi ? color.new(#e92727, 45) : na
fdi_plot_3   = plot(show_fdi ? fdi_3 : na, title = "Fast FDI 2", color = fdi_color_3, linewidth=1)
// ----------------------------------
fdi_color_4 = fdi_4 > fdi_3 ? show_fdi ? color.new(#434651,46) : na :  show_fdi ? color.new(#e92727, 62) : na
fdi_plot_4   = plot(show_fdi ? fdi_4 : na, title = "Fast FDI 3", color = fdi_color_4, linewidth=1)
// ----------------------------------
plot(show_fdi and ta.cross(fdi, fdi_2) and fdi>=fdi_2? fdi : na, title = "FDI_0 x FDI_1 ABOVE 1.5", color = color.white, linewidth = 2, style = plot.style_circles) //, title = "Slow FDI"
plot(show_fdi and ta.cross(fdi_3, fdi_2) and fdi_3<=fdi_2 and fdi_3>=1.5? fdi_2 : na, title = "FDI_1 x FDI_2 ABOVE 1.5", color = color.new(color.silver, 28), linewidth = 2, style = plot.style_circles)
plot(show_fdi and ta.cross(fdi_4, fdi_3) and fdi_4<=fdi_3 and fdi_4>=1.5? fdi_3 : na, title = "FDI_2 x FDI_3 ABOVE 1.5", color = color.new(color.silver, 36), linewidth = 2, style = plot.style_circles)
// ----------------------------------
plot(show_fdi and ta.cross(fdi, fdi_2) and fdi<=fdi_2? fdi : na, title = "FDI_0 x FDI_1 BELOW 1.4", color = #ff8919, linewidth = 2, style = plot.style_circles)
plot(show_fdi and ta.cross(fdi_3, fdi_2) and fdi_3>=fdi_2 and fdi_3<=1.4? fdi_2 : na, title = "FDI_1 x FDI_2 BELOW 1.4", color = color.new(#e92727, 28), linewidth = 2, style = plot.style_circles)
plot(show_fdi and ta.cross(fdi_4, fdi_3) and fdi_4>=fdi_3 and fdi_4<=1.4? fdi_3 : na, title = "FDI_2 x FDI_3 BELOW 1.4", color = color.new(#e92727, 36), linewidth = 2, style = plot.style_circles)
// ----------------------------------
upb = fdi + offs // Upper Bands
dnb = fdi - offs // Lower Bands
mid = ((ma + offs) + (ma - offs)) / 2

midl = plot(show_fdi ? mid : na, "FDI Baseline", color = color.new(#7e57c2, 38), linewidth = 2, style=plot.style_line)
// ----------------------------------
plot(show_fdi and ta.cross(fdi, mid) ? mid : na, color = color.new(#7e57c2, 0), title = "Primary FDI x Baseline", linewidth = 3, style = plot.style_circles) //plot.style_cross
// ----------------------------------

// ----------------------------------
// FDI - ULTRA SLOW
// ----------------------------------
ultra_fdi  = float(0.0)
ultra_fdi := calculate_FDI(fdi_src, ultra_fdi_length)
// ----------------------------------
ultra_offs = (1.6185 * ta.stdev(ultra_fdi, ultra_bandLength))  
ultra_ma = ta.sma(ultra_fdi, ultra_bandLength)
// ----------------------------------
ultra_upb = ultra_fdi + ultra_offs // Upper Bands
ultra_dnb = ultra_fdi - ultra_offs // Lower Bands
ultra_mid = ((ultra_ma + ultra_offs) + (ultra_ma - ultra_offs)) / 2
// ----------------------------------
ultra_midl = plot(ultra_show_fdi_baseline ? ultra_mid : na, "Ultra-Slow FDI Baseline", color = color.new(#5d606b, 28), linewidth = 2, style=plot.style_line)
// ----------------------------------
plot(ultra_show_fdi_baseline and ta.cross(ultra_fdi, ultra_mid) ? ultra_mid : na, color = color.new(#5d606b, 12), title = "Ultra Slow Baseline x Short Term baseline", linewidth = 3, style = plot.style_circles) //plot.style_cross
// ----------------------------------
ultra_fdi_color = ultra_show_fdi and (ultra_mid < ultra_fdi) ? color.new(color.silver,0) :  color.new(#e92727, 0)
ultra_fdi_plot   = plot(ultra_show_fdi ? ultra_fdi : na, title = "Ultra-Slow FDI", color = ultra_fdi_color, linewidth=2)
// ------------------------------------

//===================================
//=== RSI INPUTS
//===================================
// ----------------------------------
rsiPeriod = input.int(9, minval=1, title='Primary RSI Period', group='RSI - RELATIVE STERNGTH INDEX', inline='base_1')
second_rsiPeriod = input.int(7, minval=1, title='Secondary RSI Period', group='RSI - RELATIVE STERNGTH INDEX', inline='base_1')
// ----------------------------------
rsibandLength = input.int(21, minval = 1, title = "Baseline Length   ", group='RSI - RELATIVE STERNGTH INDEX', inline='base_1')
// ----------------------------------

//===================================
//=== RSI CALCULATIONS & PLOT
//===================================
// ----------------------------------
prim_rsi = ta.rsi(close, rsiPeriod)
second_rsi = ta.rsi(close, second_rsiPeriod)
// ----------------------------------
p_rsi_f = show_rsi ?  adjust_number + prim_rsi/100 : na
s_rsi_f = show_rsi ?  adjust_number + second_rsi/100 : na
// ----------------------------------
offs_rsi = (1.6185 * ta.stdev(p_rsi_f, rsibandLength))  
ma_rsi = ta.sma(p_rsi_f, rsibandLength)
// ----------------------------------
upb_rsi = p_rsi_f + offs_rsi // Upper Bands
dnb_rsi = p_rsi_f - offs_rsi // Lower Bands
mid_rsi = ((ma_rsi + offs_rsi) + (ma_rsi - offs_rsi)) / 2
// ----------------------------------
midl_rsi = plot(show_rsi ? mid_rsi : na, "RSI Baseline", color = color.new(#1848cc, 25), linewidth = 2, style=plot.style_line)
plot(show_rsi and ta.cross(p_rsi_f, mid_rsi) ? mid_rsi : na, color = color.new(#1848cc, 0) , title = "RSI x Baseline", linewidth = 3, style = plot.style_circles) //plot.style_cross
// ----------------------------------
prim_rsi_plot = plot(show_rsi ? p_rsi_f : na, 'Primary RSI', color=color.new(#3179f5, 60), linewidth=2) //#f57c00 color.white
sec_rsi_plot = plot(show_rsi ? s_rsi_f : na, 'Secondary RSI', color=color.new(#3179f5, 80), linewidth=2) //#d1d4dc
// ----------------------------------

//===================================
//=== RSI DIVERGENCES & PLOT
//===================================
// ----------------------------------
// Inputs 
lbR = input(title='Pivot Lookback Right', defval=2, group='RSI - DIVERGENCES', inline='div_1')
lbL = input(title='Pivot Lookback Left', defval=9, group='RSI - DIVERGENCES', inline='div_1')
// ----------------------------------
rangeUpper = input(title='Max of Lookback   ', defval=120, group='RSI - DIVERGENCES', inline='div_2')
rangeLower = input(title='    Min of Lookback', defval=1, group='RSI - DIVERGENCES', inline='div_2')
// ----------------------------------
plotBull = input(title='Bullish', defval=true, group='RSI - DIVERGENCES', inline='div_3')
plotBear = input(title='Bearish       ', defval=true, group='RSI - DIVERGENCES', inline='div_3')
plotHiddenBull = input(title='Hidden Bullish', defval=true, group='RSI - DIVERGENCES', inline='div_3')
plotHiddenBear = input(title='Hidden Bearish', defval=true, group='RSI - DIVERGENCES', inline='div_3')
// ----------------------------------
showLabels = input(title='Show Labels', defval=false, group='RSI - DIVERGENCES', inline='div_4')
// ----------------------------------
// Color setup
bullColor = color.new(#5b9cf6, 28)
hiddenBullColor = color.new(#5b9cf6, 25)  //orange: #ff9800
bearColor = color.new(#d32f2f, 28)  //red: #b71c1c
hiddenBearColor = color.new(#d32f2f, 25)  //gray:#9598a1 red:#d32f2f
textColor = #d1d4dc  //color.white
noneColor = color.new(color.white, 100)
// ----------------------------------
bull_line_width = 2
bear_line_width = 2
// ----------------------------------
plFound = na(ta.pivotlow(p_rsi_f, lbL, lbR)) ? false : true
phFound = na(ta.pivothigh(p_rsi_f, lbL, lbR)) ? false : true
// ----------------------------------
_inRange(cond) =>
    bars = ta.barssince(cond == true)
    rangeLower <= bars and bars <= rangeUpper
// ----------------------------------

// ==================
// RSI DIVERGENCES
// ==================
// ----------------------------------
// Regular Bullish
// ----------------------------------
oscHL = p_rsi_f[lbR] > ta.valuewhen(plFound, p_rsi_f[lbR], 1) and _inRange(plFound[1]) // Osc: Higher Low
priceLL = low[lbR] < ta.valuewhen(plFound, low[lbR], 1) // Price: Lower Low
bullCond = plotBull and priceLL and oscHL and plFound // Regular Bull condition
plot(plFound ? p_rsi_f[lbR] : na, offset=-lbR, title='Regular Bullish line', linewidth=2, color=show_rsi and bullCond ? bullColor : na)
plotshape(show_rsi and showLabels and bullCond ? p_rsi_f[lbR] : na, offset=-lbR, title='Regular Bullish Label', text='R', style=shape.labelup, location=location.absolute, color=bullColor, textcolor=textColor)
// ----------------------------------
// Hidden Bullish
// ----------------------------------
oscLL = p_rsi_f[lbR] < ta.valuewhen(plFound, p_rsi_f[lbR], 1) and _inRange(plFound[1]) // Osc: Lower Low
priceHL = low[lbR] > ta.valuewhen(plFound, low[lbR], 1) // Price: Higher Low
hiddenBullCond = plotHiddenBull and priceHL and oscLL and plFound // Hidden Bull condition
plot(plFound ? p_rsi_f[lbR] : na, offset=-lbR, title='Hidden Bullish line', linewidth=2, color=show_rsi and hiddenBullCond ? hiddenBullColor : na)
plotshape(show_rsi and showLabels and hiddenBullCond ? p_rsi_f[lbR] : na, offset=-lbR, title='Hidden Bullish Label', text=' H', style=shape.labelup, location=location.absolute, color=bullColor, textcolor=textColor)
// ----------------------------------
// Regular Bearish
// ----------------------------------
oscLH = p_rsi_f[lbR] < ta.valuewhen(phFound, p_rsi_f[lbR], 1) and _inRange(phFound[1]) // Osc: Lower High
priceHH = high[lbR] > ta.valuewhen(phFound, high[lbR], 1) // Price: Higher High
bearCond = plotBear and priceHH and oscLH and phFound // Regular Bear condition
plot(phFound ? p_rsi_f[lbR] : na, offset=-lbR, title='Regular Bearish line', linewidth=2, color=show_rsi and bearCond ? bearColor : na)
plotshape(show_rsi and showLabels and bearCond ? p_rsi_f[lbR] : na, offset=-lbR, title='Regular Bearish Label', text='R', style=shape.labeldown, location=location.absolute, color=bearColor, textcolor=textColor)
// ----------------------------------
// Hidden Bearish
// ----------------------------------
oscHH = p_rsi_f[lbR] > ta.valuewhen(phFound, p_rsi_f[lbR], 1) and _inRange(phFound[1]) // Osc: Higher High
priceLH = high[lbR] < ta.valuewhen(phFound, high[lbR], 1) // Price: Lower High
hiddenBearCond = plotHiddenBear and priceLH and oscHH and phFound // Hidden Bear condition
plot(phFound ? p_rsi_f[lbR] : na, offset=-lbR, title='Hidden Bearish line', linewidth=2, color=show_rsi and hiddenBearCond ? hiddenBearColor : na)
plotshape(show_rsi and showLabels and hiddenBearCond ? p_rsi_f[lbR] : na, offset=-lbR, title='Hidden Bearish Label', text='H', style=shape.labeldown, location=location.absolute, color=bearColor, textcolor=textColor)
// ----------------------------------


//===================================
// BBWP
//===================================
// ----------------------------------

hide_lava = input.bool    (true, 'Hide high values', inline='4', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
// ----------------------------------


//===================================
// BBWP FUNCTIONS
//===================================
// ----------------------------------
f_maType ( _price, _len, _type ) =>
    _type == 'SMA' ? ta.sma ( _price, _len ) : _type == 'EMA' ? ta.ema ( _price, _len ) : ta.vwma ( _price, _len )
// ----------------------------------
f_bbwp ( _price, _bbwLen, _bbwpLen, _type ) =>
    float _basis = f_maType ( _price, _bbwLen, _type )
    float _dev = ta.stdev ( _price, _bbwLen )
    _bbw = ( _basis + _dev - ( _basis - _dev )) / _basis
    _bbwSum = 0.0
    _len = bar_index < _bbwpLen ? bar_index : _bbwpLen
    for _i = 1 to _len by 1
        _bbwSum += ( _bbw[_i] > _bbw ? 0 : 1 )
        _bbwSum
    _return = bar_index >= _bbwLen ? ( _bbwSum / _len) * 100 : na
    _return
// ----------------------------------
f_clrSlct ( _percent, _select, _type, _solid, _array1 ) =>
    _select == 'Solid' ? _solid : array.get (_array1, math.round ( _percent ) )
// ----------------------------------
var c_prcntSpctrm2 = array.new_color(na)
if barstate.isfirst
    array.push ( c_prcntSpctrm2, #0000FF )
    array.push ( c_prcntSpctrm2, #0200FC ), array.push ( c_prcntSpctrm2, #0500F9 ), array.push ( c_prcntSpctrm2, #0700F7 ), array.push ( c_prcntSpctrm2, #0A00F4 ), array.push ( c_prcntSpctrm2, #0C00F2 ),
    array.push ( c_prcntSpctrm2, #0F00EF ), array.push ( c_prcntSpctrm2, #1100ED ), array.push ( c_prcntSpctrm2, #1400EA ), array.push ( c_prcntSpctrm2, #1600E8 ), array.push ( c_prcntSpctrm2, #1900E5 ),
    array.push ( c_prcntSpctrm2, #1C00E2 ), array.push ( c_prcntSpctrm2, #1E00E0 ), array.push ( c_prcntSpctrm2, #2100DD ), array.push ( c_prcntSpctrm2, #2300DB ), array.push ( c_prcntSpctrm2, #2600D8 ),
    array.push ( c_prcntSpctrm2, #2800D6 ), array.push ( c_prcntSpctrm2, #2B00D3 ), array.push ( c_prcntSpctrm2, #2D00D1 ), array.push ( c_prcntSpctrm2, #3000CE ), array.push ( c_prcntSpctrm2, #3300CC ),
    array.push ( c_prcntSpctrm2, #3500C9 ), array.push ( c_prcntSpctrm2, #3800C6 ), array.push ( c_prcntSpctrm2, #3A00C4 ), array.push ( c_prcntSpctrm2, #3D00C1 ), array.push ( c_prcntSpctrm2, #3F00BF ),
    array.push ( c_prcntSpctrm2, #4200BC ), array.push ( c_prcntSpctrm2, #4400BA ), array.push ( c_prcntSpctrm2, #4700B7 ), array.push ( c_prcntSpctrm2, #4900B5 ), array.push ( c_prcntSpctrm2, #4C00B2 ),
    array.push ( c_prcntSpctrm2, #4F00AF ), array.push ( c_prcntSpctrm2, #5100AD ), array.push ( c_prcntSpctrm2, #5400AA ), array.push ( c_prcntSpctrm2, #5600A8 ), array.push ( c_prcntSpctrm2, #5900A5 ),
    array.push ( c_prcntSpctrm2, #5B00A3 ), array.push ( c_prcntSpctrm2, #5E00A0 ), array.push ( c_prcntSpctrm2, #60009E ), array.push ( c_prcntSpctrm2, #63009B ), array.push ( c_prcntSpctrm2, #660099 ),
    array.push ( c_prcntSpctrm2, #680096 ), array.push ( c_prcntSpctrm2, #6B0093 ), array.push ( c_prcntSpctrm2, #6D0091 ), array.push ( c_prcntSpctrm2, #70008E ), array.push ( c_prcntSpctrm2, #72008C ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#750089 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #770087 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #7A0084 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #7C0082 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #7F007F ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#82007C ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #84007A ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#870077 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #890075 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #8C0072 ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#8E0070 ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#91006D ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #93006B ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #960068 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #990066 ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#9B0063 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #9E0060 ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#A0005E ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #A3005B ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #A50059 ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#A80056 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #AA0054 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #AD0051 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #AF004F ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #B2004C ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#B50049 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #B70047 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #BA0044 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #BC0042 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #BF003F ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#C1003D ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #C4003A ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#C60038 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #C90035 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #CC0033 ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#CE0030 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #D1002D ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#D3002B ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #D60028 ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#D80026 ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#DB0023 ), array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#DD0021 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #E0001E ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #E2001C ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #E50019 ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#E80016 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #EA0014 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #ED0011 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #EF000F ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #F2000C ),
    array.push ( c_prcntSpctrm2, hide_lava?color.new(color.white,100):#F4000A ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #F70007 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #F90005 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #FC0002 ), array.push ( c_prcntSpctrm2,hide_lava?color.new(color.white,100): #FF0000 )
// ----------------------------------
var string STM = 'Spectrum'
var string SLD = 'Solid'
// var string BGR = 'Blue Green Red'
var string BR  = 'Blue Red'
// ----------------------------------

//===================================
// BBWP INPUTS
//===================================
// ----------------------------------
i_priceSrc      = input.source  ( close, 'Price Source', group='BBWP - BOLLINGER BANDS WITH PERCENTILE', inline='bbwp_0')
i_basisType     = input.string  ( 'SMA', '     Basis Type', options=['SMA', 'EMA', 'VWMA'], group='BBWP - BOLLINGER BANDS WITH PERCENTILE', inline='bbwp_0')
i_bbwpLen       = input.int     ( 13, 'Length     ', minval=1, group='BBWP - BOLLINGER BANDS WITH PERCENTILE', inline='bbwp_1')
i_bbwpLkbk      = input.int     ( 252, '     Lookback ', minval=1, group='BBWP - BOLLINGER BANDS WITH PERCENTILE', inline='bbwp_1')
// ----------------------------------
i_c_bbwpTyped   = input.string  ( STM, 'Color Type  ', options=[STM, SLD], inline='1', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_c_spctrmType  = input.string  ( BR, '    Spectrum  ', options=[BR], inline='1', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_c_bbwpsolid   = color.new(color.silver,50)
// ----------------------------------
i_ma1On         = input.bool    ( true, '', inline='1', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_ma1Type       = input.string  ( 'SMA', 'MA 1 Type   ', options=['SMA', 'EMA', 'VWMA'], inline='1', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_ma1Len        = input.int     ( 5, '   MA 1 Length', minval=1, inline='1', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
// ----------------------------------
i_ma2Type       = input.string  ( 'SMA', 'MA 2 Type  ', options=['SMA', 'EMA', 'VWMA'], inline='2', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_ma2Len        = input.int     ( 55, '  MA 2 Length  ', minval=1, inline='2', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_ma2On         = input.bool    ( true, '', inline='2', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
// ----------------------------------
i_bbwpWidth     = input.int     ( 2, 'Line Width  ', minval=1, maxval=4, inline='3', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_alrtsOn       = input.bool    ( true, 'Highlight extreme values', inline='3', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_upperLevel    = input.int     ( 98, 'Extreme High', minval=1, inline='3', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
i_lowerLevel    = input.int     ( 2, 'Extreme Low', minval=1, inline='3', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
// ----------------------------------
// hide_lava = input.bool    (true, 'Hide high values', inline='4', group='BBWP - BOLLINGER BANDS WITH PERCENTILE')
// ----------------------------------

//===================================
// BBWP CALCULATIONS & PLOT
//===================================
// ----------------------------------
bbwp        = show_bbwp ? f_bbwp ( i_priceSrc, i_bbwpLen, i_bbwpLkbk, i_basisType ) : na
c_bbwp      = show_bbwp ? f_clrSlct ( bbwp, i_c_bbwpTyped, i_c_spctrmType, i_c_bbwpsolid, c_prcntSpctrm2 ) : na
bbwpMA1     = show_bbwp and i_ma1On ? f_maType ( bbwp, i_ma1Len, i_ma1Type ) : na
bbwpMA2     = show_bbwp and i_ma2On ? f_maType ( bbwp, i_ma2Len, i_ma2Type ) : na
// ----------------------------------
bdf = bbwp/100
bdf_calc = adjust_number + bdf
// ----------------------------------
hiAlrtBar   = i_alrtsOn and bbwp >= i_upperLevel ? bdf_calc : na
loAlrtBar   = i_alrtsOn and bbwp <= i_lowerLevel ? bdf_calc : na
// ----------------------------------
p_bbwp      = plot (show_bbwp ? bdf_calc : na, 'BBWP', c_bbwp, i_bbwpWidth, plot.style_line, editable=true )
// ----------------------------------
p_hiAlrt    = plot ( show_bbwp ? hiAlrtBar : na, 'Extreme Hi', color.new(#cb0101,85), 1, plot.style_columns, histbase=adjust_number, editable=true )
p_loAlrt    = plot ( show_bbwp ? loAlrtBar : na, 'Extreme Lo', color.new(#3000d9,60), 1, plot.style_columns, histbase=adjust_number+1, editable=true )
// ----------------------------------

Code: Select all

// 4H Delta//Weekly Delta
// By TheBullTrader-Use Daily Time frame
// Trade Bullish when green and red is above 0.000 and Trade Short when both are below 0.000
study(title="Daily Delta Trend",overlay = false, shorttitle="Daily Delta Trend")


W_C=security(tickerid,"D",close)
W_O=security(tickerid,"D",open)



//
D=W_C-W_O
D1 = sma(W_C-W_O,50)
D2=sma(W_C-W_O,200)

D3=ema(D1,50)
D4=ema(D2,200)
//

//plot(D1,color=green)
//plot(D2,color=red)
plot(D3,color=green,style=histogram)
plot(D4,color=red,style=histogram)