size=size.
auto)
// Order Block Detector Functions
get_line_style(style) =>
switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
set_order_blocks(ob_top, ob_btm, ob_left, ob_avg, ext_last, bg_css, border_css,
lvl_css) =>
var ob_box = array.new_box(0)
var ob_lvl = array.new_line(0)
if [Link]
for i = 0 to ext_last-1
[Link](ob_box, [Link](na,na,na,na, xloc = xloc.bar_time, extend
= [Link], bgcolor = bg_css, border_color = [Link](border_css, 70)))
[Link](ob_lvl, [Link](na,na,na,na, xloc = xloc.bar_time,
extend = [Link], color = lvl_css, style = get_line_style(line_style), width =
line_width))
if [Link]
if [Link](ob_top) > 0
for i = 0 to [Link](ext_last-1, [Link](ob_top)-1)
get_box = [Link](ob_box, i)
get_lvl = [Link](ob_lvl, i)
box.set_lefttop(get_box, [Link](ob_left, i), [Link](ob_top,
i))
box.set_rightbottom(get_box, [Link](ob_left, i),
[Link](ob_btm, i))
line.set_xy1(get_lvl, [Link](ob_left, i), [Link](ob_avg, i))
line.set_xy2(get_lvl, [Link](ob_left, i)+1, [Link](ob_avg,
i))
// Order Block Detector Logic
var os = 0
var target_bull = 0.
var target_bear = 0.
n = bar_index
upper = [Link](length)
lower = [Link](length)
if mitigation == 'Close'
target_bull := [Link](close, length)
target_bear := [Link](close, length)
else
target_bull := lower
target_bear := upper
os := high[length] > upper ? 0 : low[length] < lower ? 1 : os[1]
phv = [Link](volume, length, length)
[bull_top, bull_btm, bull_avg, bull_left, bull_ob] = get_coordinates(phv and os ==
1, hl2[length], low[length], low[length])
[bear_top, bear_btm, bear_avg, bear_left, bear_ob] = get_coordinates(phv and os ==
0, high[length], hl2[length], high[length])
mitigated_bull = remove_mitigated(bull_top, bull_btm, bull_left, bull_avg,
target_bull, true)
mitigated_bear = remove_mitigated(bear_top, bear_btm, bear_left, bear_avg,
target_bear, false)
set_order_blocks(bull_top, bull_btm, bull_left, bull_avg, bull_ext_last,
bg_bull_css, bull_css, bull_avg_css)
set_order_blocks(bear_top, bear_btm, bear_left, bear_avg, bear_ext_last,
bg_bear_css, bear_css, bear_avg_css)
plot(bull_ob, 'Bull OB', bull_css, 2, plot.style_linebr, offset = -length)
plot(bear_ob, 'Bear OB', bear_css, 2, plot.style_linebr, offset = -length)
// EMA Calculations and Plotting
ema9 = [Link](src_ema, len1)
ema20 = [Link](src_ema, len2)
plot(ema9, title="9 EMA", linewidth=2, color=#0000FF)
plot(ema20, title="20 EMA", linewidth=2, color=#11DCBF)
// UNTESTED
temp0 = [Link](title='••••••••••••••••••• Fractals ••••••••••••••••••••••',
defval=false)
showFractals = [Link](title='Show Fractal Points ?', defval=false)
filterFractal = [Link](title='Filter 3/5 bar fractal', defval='3',
options=['3', '5'])
temp1 = [Link](title='••••••••••••••••••• Orderblocks •••••••••••••••••••',
defval=false)
findObType = [Link](title='Find OB after fractal break of close/HL',
defval='Close', options=['Close', 'HL'])
filterFvgs = [Link](title='Filter only OB that follow with FVG ?', defval=true)
fvgDistance = [Link](3, title='Max bars between the OB and FVG', minval=1,
maxval=6)
lineHeight = [Link](title='Line Height', defval='Body', options=['Body',
'Wick'])
delLines = [Link](title='Delete lines after fill ?', defval=true)
temp3 = [Link](title='•••••••••••••••••••• Styles ••••••••••••••••••••••••',
defval=false)
lines_style = [Link](title='Lines style', defval='Solid', options=['Solid',
'Dashed', 'Dotted'])
line_length = [Link](5, 'Length of lines', minval=1, maxval=100)
lineStyle = lines_style == 'Solid' ? line.style_solid : lines_style == 'Dashed' ?
line.style_dashed : line.style_dotted
linesWidth = [Link](2, 'Lines Width ?', minval=1, maxval=4)
bear_line_color = [Link]([Link], 'Bear OB Line color')
bull_line_color = [Link]([Link], 'Bull OB Line color')
// -------------------- FUNCTIONS --------------------
bullishImb(i=0) => close[i+1] > high[i+2] and low[i] > high[i+2]
bearishImb(i=0) => close[i+1] < low[i+2] and high[i] < low[i+2]
// Fractals
isRegularFractal(mode) =>
ret = mode == 'Buy' ? high[0] < high[1] and (high[2] < high[1] or high[2] ==
high[1] and high[3] < high[2]) : mode == 'Sell' ? low[0] > low[1] and (low[2] >
low[1] or low[2] == low[1] and low[3] > low[2]) : false
ret
isBWFractal(mode) =>
ret = mode == 'Buy' ? high[0] < high[2] and high[1] < high[2] and high[3] <
high[2] and high[4] < high[2] : mode == 'Sell' ? low[0] > low[2] and low[1] >
low[2] and low[3] > low[2] and low[4] > low[2] : false
ret
isFractalHigh() =>
filterFractal == '3' ? isRegularFractal('Buy') : isBWFractal('Buy')
isFractalLow() =>
filterFractal == '3' ? isRegularFractal('Sell') : isBWFractal('Sell')
resolutionInMinutes() =>
resInMinutes = [Link] * ([Link] ? 1. / 60 :
[Link] ? 1. : [Link] ? 60. * 24 : [Link] ? 60.
* 24 * 7 : [Link] ? 60. * 24 * 30.4375 : na)
resInMinutes
f_timeFrom(_from, length, _units, i) =>
var int _timeFrom = na
_unit = str.replace_all(_units, 's', '')
_timeFrom := int(time[i] + resolutionInMinutes() * 60 * 1000 * length)
_timeFrom
// -------------------- FUNCTIONS --------------------
// -------------------- Fractals --------------------
var float fractal_high_val = na
var float fractal_low_val = na
var fractal_highs = array.new_float(0) // array of high fractal values
var fractal_high_times = array.new_int(0) // array of high fractal times
var fractal_lows = array.new_float(0) // array of low fractal values
var fractal_low_times = array.new_int(0) // array or low fractal times
// Check if fractal and add it to array
if isFractalHigh()
if filterFractal == '3'
[Link](fractal_highs, high[1])
[Link](fractal_high_times, time[1])
fractal_high_val := high[1]
else
[Link](fractal_highs, high[2])
[Link](fractal_high_times, time[2])
fractal_high_val := high[2]
if isFractalLow()
if filterFractal == '3'
[Link](fractal_lows, low[1])
[Link](fractal_low_times, time[1])
fractal_low_val := low[1]
else
[Link](fractal_lows, low[2])
[Link](fractal_low_times, time[2])
fractal_low_val := low[2]
// -------------------- Fractals --------------------
var bars_back = 500
// -------------------- Orderblocks --------------------
var line1 = array.new_line()
var line2 = array.new_line()
var line3 = array.new_line()
var line4 = array.new_line()
var label1 = array.new_label()
var label2 = array.new_label()
// Bearish loop
if [Link](fractal_lows) > 0
for i = [Link](fractal_lows) - 1 to 0
if (findObType == 'Close' ? close : low) < [Link](fractal_lows, i)
idx = 0
max = low //current low
gapIndex = 0
for k = 0 to bars_back
bearishGap = (close[k+1] < low[k+2]) and (high[k] < low[k+2])
//stop loop if reached time limit
if time[k] < [Link](fractal_low_times, i)
break
//Get all bullish candles in range
if close[k] > open[k] and high[k] > max
idx := k
max := high[k]
if bearishGap and high[k] > max
gapIndex := k+2
_filterFvg = filterFvgs ? gapIndex > 0 and idx - gapIndex >= 0 and idx
- gapIndex <= fvgDistance : true
// Line on OB
if idx != 0 and _filterFvg
// [Link](bar_index, high, [Link](idx) + "\n" +
[Link](gapIndex))
TimeTo = f_timeFrom('bar', line_length, 'chart', idx)
loc = lineHeight == 'Body' ? open[idx] : low[idx]
[Link](line1, [Link](x1=time[idx], y1=high[idx], x2=TimeTo,
y2=high[idx], xloc=xloc.bar_time, style=lineStyle, color=bear_line_color,
width=linesWidth))
[Link](line2, [Link](x1=time[idx], y1=loc, x2=TimeTo, y2=loc,
xloc=xloc.bar_time, style=lineStyle, color=bear_line_color, width=linesWidth))
[Link](fractal_lows, i)
[Link](fractal_low_times, i)
// Bullish loop
if [Link](fractal_highs) > 0
for i = [Link](fractal_highs) - 1 to 0
if (findObType == 'Close' ? close : high) > [Link](fractal_highs, i)
idx = 0
min = low
gapIndex = 0
for k = 0 to bars_back
bullishGap = (close[k+1] > high[k+2]) and (low[k] > high[k+2])
// Stop the loop once it reaches the last fractal high
if time[k] < [Link](fractal_high_times, i)
break
// if bearish candle
if close[k] < open[k] and low[k] < min
idx := k
min := low[k]
if bullishGap
gapIndex := k+2
_filterFvg = filterFvgs ? gapIndex > 0 and idx - gapIndex >= 0 and idx
- gapIndex <= fvgDistance : true
// Line on OB
if idx != 0 and _filterFvg
// [Link](bar_index, high, [Link](idx) + "\n" +
[Link](gapIndex))
TimeTo = f_timeFrom('bar', line_length, 'chart', idx)
loc = lineHeight == 'Body' ? open[idx] : high[idx]
[Link](line3, [Link](x1=time[idx], y1=low[idx], x2=TimeTo,
y2=low[idx], xloc=xloc.bar_time, style=lineStyle, color=bull_line_color,
width=linesWidth))
[Link](line4, [Link](x1=time[idx], y1=loc, x2=TimeTo, y2=loc,
xloc=xloc.bar_time, style=lineStyle, color=bull_line_color, width=linesWidth))
[Link](fractal_highs, i)
[Link](fractal_high_times, i)
// -------------------- Orderblocks --------------------
// Delete Lines/Labels
if [Link](line1) > 0
var int i = [Link](line1) - 1
while i >= 0
if high >= line.get_y1([Link](line1, i)) and high >=
line.get_y1([Link](line2, i))
if delLines
[Link]([Link](line1, i))
[Link]([Link](line2, i))
//[Link]([Link](label1, i))
[Link](line1, i)
[Link](line2, i)
//[Link](label1,i)
i -= 1
if [Link](line3) > 0
var int j = [Link](line3) - 1
while j >= 0
if low <= line.get_y1([Link](line3, j)) and low <=
line.get_y1([Link](line4, j))
if delLines
[Link]([Link](line3, j))
[Link]([Link](line4, j))
//[Link]([Link](label2, j))
[Link](line3, j)
[Link](line4, j)
//[Link](label2,j)
j -= 1
//Plot fractal points
plotshape(showFractals and isFractalHigh(), title='Fractal High',
style=[Link], location=[Link], color=[Link]([Link],
0), offset=filterFractal == '3' ? -1 : -2, size=[Link])
plotshape(showFractals and isFractalLow(), title='Fractal Low',
style=[Link], location=[Link], color=[Link]([Link], 0),
offset=filterFractal == '3' ? -1 : -2,
'····' => line.style_dotted
remove_mitigated(ob_top, ob_btm, ob_left, ob_avg, target, bull) =>
mitigated = false
target_array = bull ? ob_btm : ob_top
for element in target_array
idx = [Link](target_array, element)
if (bull ? target < element : target > element)
mitigated := true
[Link](ob_top, idx)
[Link](ob_btm, idx)
[Link](ob_avg, idx)
[Link](ob_left, idx)
mitigated
