AlgoPoint_PA_Toolkit_V1

//
//@version=5
indicator("AlgoPoint PA Toolkit [V1]", shorttitle = "AlgoPoint PA Toolkit [V1]",
overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count =
500, max_bars_back = 500, max_polylines_count = 100)
//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BOS = 0
s_CHoCH = 1
i_BOS = 2
i_CHoCH = 3
i_pp_CHoCH = 4
green_candle = 5
red_candle = 6
s_CHoCHP = 7
i_CHoCHP = 8
boolean =
array.from(
false
, false
, false
, false
, false
, false
, false
, false
, false
)
//-----------------------------------------------------------------------------{
// User inputs
//-----------------------------------------------------------------------------{
show_swing_ms = input.string ("All"

, "Swing " , inline = "1", group = "MARKET
STRUCTURE" , options = ["All", "CHoCH", "CHoCH+", "BOS", "None"])
show_internal_ms = input.string ("All"
, "Internal " , inline = "2", group = "MARKET STRUCTURE"
, options = ["All", "CHoCH", "CHoCH+", "BOS", "None"])
internal_r_lookback = input.int (5
, "" , inline = "2", group = "MARKET STRUCTURE"
, minval = 2)
swing_r_lookback = input.int (50
, "" , inline = "1", group = "MARKET STRUCTURE"
, minval = 2)
ms_mode = input.string ("Manual"
, "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE"
, tooltip = "[Manual] Use selected lenght\n[Dynamic] Use automatic lenght" ,options
= ["Manual", "Dynamic"])
show_mtf_str = input.bool (true
, "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE"
, tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green =
Bullish. Red = Bearish")
show_eql = input.bool (false
, "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE")
plotcandle_bool = input.bool (false
, "Plotcandle" , inline = "3", group = "MARKET STRUCTURE"
, tooltip = "Displays a cleaner colored candlestick chart in place of the default
candles. (requires hiding the current ticker candles)")
barcolor_bool = input.bool (false
, "Bar Color" , inline = "4", group = "MARKET STRUCTURE"
, tooltip = "Color the candle bodies according to market strucutre trend")
i_ms_up_BOS = input.color (#089981

, "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BOS = input.color (#f23645
s_ms_up_BOS = input.color (#089981
s_ms_dn_BOS = input.color (#f23645
lvl_daily = input.bool (false

, "Day " , inline = "1", group = "HIGHS & LOWS MTF")
lvl_weekly = input.bool (false
, "Week " , inline = "2", group = "HIGHS & LOWS MTF")
lvl_monthly = input.bool (false
, "Month" , inline = "3", group = "HIGHS & LOWS MTF")
lvl_yearly = input.bool (false
, "Year " , inline = "4", group = "HIGHS & LOWS MTF")
css_d = input.color (color.blue
, "" , inline = "1", group = "HIGHS & LOWS MTF")
css_w = input.color (color.blue
css_m = input.color (color.blue
css_y = input.color (color.blue
s_d = input.string ('⎯⎯⎯'
, '' , inline = '1', group = 'HIGHS & LOWS MTF'
, options = ['⎯⎯⎯', '----', '····'])
s_w = input.string ('⎯⎯⎯'
, options = ['⎯⎯⎯', '----', '····'])
s_m = input.string ('⎯⎯⎯'
, options = ['⎯⎯⎯', '----', '····'])
s_y = input.string ('⎯⎯⎯'
, options = ['⎯⎯⎯', '----', '····'])
ob_show = input.bool (true

, "Show Last " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Display volumetric order blocks on the chart \n\n[Input] Ammount of
volumetric order blocks to show")
ob_num = input.int (5
, "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Orderblocks number", minval = 1, maxval = 10)
ob_metrics_show = input.bool (true
, "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Display volume metrics that have formed the orderblock")
css_metric_up = input.color (color.new(#089981, 50)
, " " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 50)
, "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
ob_swings = input.bool (false
, "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Display swing volumetric order blocks")
css_swing_up = input.color (color.new(color.gray , 90)
, " " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
css_swing_dn = input.color (color.new(color.silver, 90)
, "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
ob_filter = input.string ("None"
, "Filtering " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options =
["None", "BOS", "CHoCH", "CHoCH+"])
ob_mitigation = input.string ("Absolute"
, "Mitigation " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Trigger to remove volumetric order blocks", options = ["Absolute",
"Middle"])
ob_pos = input.string ("Precise"
, "Positioning " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Position of the Order Block\n[Full] Cover the whole candle\n[Middle]
Cover half candle\n[Accurate] Adjust to volatility\n[Precise] Same as Accurate but
more precise", options = ["Full", "Middle", "Accurate", "Precise"])
use_grayscale = input.bool (false
, "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Use gray as basic order blocks color")
use_show_metric = input.bool (true
, "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Show volume associated with the orderblock and his relevance")
use_middle_line = input.bool (true
, "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true
, "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Hide overlapping order blocks")
use_overlap_method = input.string ("Previous"
, "Overlap Method " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "[Recent] Preserve the most recent volumetric order blocks\n\
n[Previous] Preserve the previous volumetric order blocks", options = ["Recent",
"Previous"])
ob_bull_css = input.color (color.new(#089981 , 90)
ob_bear_css = input.color (color.new(#f23645 , 90)
show_acc_dist_zone = input.bool (false

, "" , inline = "1", group = "Accumulation And
Distribution")
zone_mode = input.string ("Fast"
Distribution" , tooltip = "[Fast] Find small zone pattern formation\n[Slow] Find
bigger zone pattern formation" ,options = ["Slow", "Fast"])
acc_css = input.color (color.new(#089981 , 60)
Distribution")
dist_css = input.color (color.new(#f23645 , 60)
Distribution")
show_lbl = input.bool (false

, "Show swing point" , inline = "1", group = "High and Low"
, tooltip = "Display swing point")
show_mtb = input.bool (false
, "Show High/Low/Equilibrium" , inline = "2", group = "High and Low"
, tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.red
, "Premium Zone " , inline = "3", group = "High and Low")
midlvl = input.color (color.gray
, "Equilibrium Zone" , inline = "4", group = "High and Low")
btmlvl = input.color (#089981
, "Discount Zone " , inline = "5", group = "High and Low")
fvg_enable = input.bool (false

, " " , inline = "1", group = "FAIR VALUE GAP"
, tooltip = "Display fair value gap")
what_fvg = input.string ("FVG"
, "" , inline = "1", group = "FAIR VALUE GAP"
, tooltip = "Display fair value gap", options = ["FVG", "VI", "OG"])
fvg_num = input.int (5
, "Show Last " , inline = "1a", group = "FAIR VALUE GAP"
, tooltip = "Number of fvg to show")
fvg_upcss = input.color (color.new(#089981, 80)
, "" , inline = "1", group = "FAIR VALUE GAP")
fvg_dncss = input.color (color.new(color.red , 80)
, "" , inline = "1", group = "FAIR VALUE GAP")
fvg_extend = input.int (10
, "Extend FVG" , inline = "2", group = "FAIR VALUE GAP"
, tooltip = "Extend the display of the FVG.")
fvg_src = input.string ("Close"
, "Mitigation " , inline = "3", group = "FAIR VALUE GAP"
, tooltip = "[Close] Use the close of the body as trigger\n\n[Wick] Use the extreme
point of the body as trigger", options = ["Close", "Wick"])
fvg_tf = input.timeframe (""
, "Timeframe " , inline = "4", group = "FAIR VALUE GAP"
, tooltip = "Timeframe of the fair value gap")
t = color.t (ob_bull_css)
invcol = color.new (color.white
, 100)
var user_consensus = input.string(defval="", title="By going to

algopoint.mysellix.io or by clicking on the link in the algopoint instagram bio you
can get the leaked codes for all premium indicators like Elite Algo, EzAlgo and
LuxAlgo. Free products are also available! algopoint.mysellix.io", confirm = true,
group="AlgoPoint")
title = 'AlgoPoint'
subtitle = 'All Leaked Algos \n Instagram: algopoint \n Website:
algopoint.mysellix.io'
textVPosition = 'middle'
textHPosition = 'center'
symVPosition = 'top'
symHPosition = 'left'
widthtata = 0
heighttata = 0
c_title = #b2b5be80
s_title = 'large'
a_title = 'center'
c_subtitle = #b2b5be80
s_subtitle = 'normal'
a_subtitle = 'center'
c_bg = color.new(color.blue, 100)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - UDT
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
type bar
float o = open
float c = close
float h = high
float l = low
float v = volume
int n = bar_index
int t = time
type Zphl
line top
line bottom
label top_label
label bottom_label
bool stopcross
bool sbottomcross
bool itopcross
bool ibottomcross
string txtup
string txtdn
float topy
float bottomy
float topx
float bottomx
float tup
float tdn
int tupx
int tdnx
float itopy
float itopx
float ibottomy
float ibottomx
float uV
float dV
type FVG
box [] box
line[] ln
bool bull
float top
float btm
int left
int right
type ms
float[] p
int [] n
float[] l
type msDraw
int n
float p
color css
string txt
bool bull
type obC
float[] top
float[] btm
int [] left
float[] avg
float[] dV
float[] cV
int [] wM
int [] blVP
int [] brVP
int [] dir
float[] h
float[] l
int [] n
type obD
box [] ob
box [] eOB
box [] blB
box [] brB
line[] mL
type zone
chart.point points
float p
int c
int t
type hqlzone
box pbx
box ebx
box lbx
label plb
label elb
label lbl
type ehl
float pt
int t
float pb
int b
type pattern
string found = "None"
bool isfound = false
int period = 0
bool bull = false
type alerts
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool equal = false
bool ob = false
bool swingob = false
bool zone = false
bool fvg = false
bool obtouch = false
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - General Setup
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
bar b = bar.new()
var pattern p = pattern.new()
alerts blalert = alerts.new()

alerts bralert = alerts.new()
if p.isfound
p.period += 1
if p.period == 50
p.period := 0
p.found := "None"
p.isfound := false
p.bull := na
switch
b.c > b.o => boolean.set(green_candle, true)

b.c < b.o => boolean.set(red_candle , true)
f_zscore(src, lookback) =>
(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)
var int iLen = internal_r_lookback

var int sLen = swing_r_lookback
vv = f_zscore(((close - close[iLen]) / close[iLen]) * 100,iLen)
if ms_mode == "Dynamic"
switch
vv >= 1.5 or vv <= -1.5 => iLen := 10

vv >= 1.6 or vv <= -1.6 => iLen := 9
vv >= 1.7 or vv <= -1.7 => iLen := 8
vv >= 1.8 or vv <= -1.8 => iLen := 7
vv >= 1.9 or vv <= -1.9 => iLen := 6
vv >= 2.0 or vv <= -2.0 => iLen := 5
=> iLen
var msline = array.new<line>(0)
iH = ta.pivothigh(high, iLen, iLen)

sH = ta.pivothigh(high, sLen, sLen)
iL = ta.pivotlow (low , iLen, iLen)
sL = ta.pivotlow (low , sLen, sLen)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - ARRAYS
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
hl () => [high, low]
[pdh, pdl] = request.security(syminfo.tickerid , 'D' , hl() , lookahead =

barmerge.lookahead_on)
[pwh, pwl] = request.security(syminfo.tickerid , 'W' , hl() , lookahead =
[pmh, pml] = request.security(syminfo.tickerid , 'M' , hl() , lookahead =
[pyh, pyl] = request.security(syminfo.tickerid , '12M', hl() , lookahead =
lstyle(style) =>
out = switch style

'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
'····' => line.style_dotted
mtfphl(h, l ,tf ,css, pdhl_style) =>
var line hl = line.new(

na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var line ll = line.new(

na
, na
, na
, na
, color = css
, style = lstyle(pdhl_style)
)
var label lbl = label.new(

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

na
, na
, text = str.format('P{0}H', tf)
, color = invcol
, textcolor = css
, size = size.small
)
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
extension = time + (time - time[1]) * 50
line.set_xy1(hl , hx , hy)
line.set_xy2(hl , extension , hy)
label.set_xy(hlb, extension , hy)
line.set_xy1(ll , lx , ly)
line.set_xy2(ll , extension , ly)
label.set_xy(lbl, extension , ly)
if lvl_daily
mtfphl(pdh , pdl , 'D' , css_d, s_d)
if lvl_weekly
mtfphl(pwh , pwl , 'W' , css_w, s_w)
if lvl_monthly
mtfphl(pmh , pml, 'M' , css_m, s_m)
if lvl_yearly
mtfphl(pyh , pyl , '12M', css_y, s_y)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Market Structure
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
method darkcss(color css, float factor, bool bull) =>
blue = color.b(css) * (1 - factor)

red = color.r(css) * (1 - factor)
green = color.g(css) * (1 - factor)
color.rgb(red, green, blue, 0)
method f_line(msDraw d, size, style) =>

var line id = na
var label lbl = na
id := line.new(
d.n
, d.p
, b.n
, d.p
, color = d.css
, width = 1
, style = style
)
if msline.size() >= 250
line.delete(msline.shift())
msline.push(id)
lbl := label.new(
int(math.avg(d.n, b.n))
, d.p
, d.txt
, color = invcol
, textcolor = d.css
, style = d.bull ? label.style_label_down : label.style_label_up
, size = size
, text_font_family = font.family_monospace
)
structure(bool mtf) =>
msDraw drw = na
bool isdrw = false

bool isdrwS = false
var color css = na

var color icss = na
var int itrend = 0

var int trend = 0
bool bull_ob = false

bool bear_ob = false
bool s_bull_ob = false

bool s_bear_ob = false
n = bar_index
var ms up = ms.new(
array.new<float>()
, array.new< int >()
, array.new<float>()
)
var ms dn = ms.new(
array.new<float>()
)
var ms sup = ms.new(

array.new<float>()
)
var ms sdn = ms.new(

array.new<float>()
)
switch show_swing_ms
"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) ,

boolean.set(s_CHoCHP, true )
"CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) ,
boolean.set(s_CHoCHP, false )
"CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) ,
boolean.set(s_CHoCHP, true )
"BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) ,
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) ,
=> na
switch show_internal_ms
"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ),

boolean.set(i_CHoCHP, true )
"CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ),
boolean.set(i_CHoCHP, false)
"CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ),
boolean.set(i_CHoCHP, true )
"BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ),
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ),
=> na
switch
iH =>
up.p.unshift(b.h[iLen])
up.l.unshift(b.h[iLen])
up.n.unshift(n [iLen])
iL =>
dn.p.unshift(b.l[iLen])
dn.l.unshift(b.l[iLen])
dn.n.unshift(n [iLen])
sL =>
sdn.p.unshift(b.l[sLen])
sdn.l.unshift(b.l[sLen])
sdn.n.unshift(n [sLen])
sH =>
sup.p.unshift(b.h[sLen])
sup.l.unshift(b.h[sLen])
sup.n.unshift(n [sLen])
// INTERNAL BULLISH STRUCTURE

if up.p.size() > 0 and dn.l.size() > 1
if ta.crossover(b.c, up.p.first())
bool CHoCH = na
string txt = na
if itrend < 0
CHoCH := true
switch
not CHoCH =>
txt := "BOS"
css := i_ms_up_BOS
blalert.bos := true
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS
, txt
, true
)
CHoCH =>
dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch
txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" :

"CHoCH"
css := i_ms_up_BOS.darkcss(0.25, true)
if (dn.l.first() > dn.l.get(1) ?

boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" =>

bull_ob := true
ob_filter == "BOS" and txt == "BOS" =>
bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" =>
bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" =>
bull_ob := true
itrend := 1
up.n.clear()
up.p.clear()
// INTERNAL BEARISH STRUCTURE

if dn.p.size() > 0 and up.l.size() > 1
if ta.crossunder(b.c, dn.p.first())
bool CHoCH = na
string txt = na
if itrend > 0
CHoCH := true
switch
not CHoCH =>
bralert.bos := true
txt := "BOS"
css := i_ms_dn_BOS
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS
, txt
, false
)
CHoCH =>
if up.l.first() < up.l.get(1)

bralert.chochplus := true
else
bralert.choch := true
txt := up.l.first() < up.l.get(1) ? "CHoCH+" :
"CHoCH"
css := i_ms_dn_BOS.darkcss(0.25, false)
if (up.l.first() < up.l.get(1) ?

boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch

bear_ob := true
bear_ob := true
bear_ob := true
bear_ob := true
itrend := -1
dn.n.clear()
dn.p.clear()
// SWING BULLISH STRUCTURE

if sup.p.size() > 0 and sdn.l.size() > 1
if ta.crossover(b.c, sup.p.first())
bool CHoCH = na
string txt = na
if trend < 0
CHoCH := true
switch
not CHoCH =>
blalert.swingbos := true
txt := "BOS"
icss := s_ms_up_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS
, txt
, true
)
CHoCH =>
if sdn.l.first() > sdn.l.get(1)

blalert.chochplusswing := true
else
blalert.chochswing := true
txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" :

"CHoCH"
icss := s_ms_up_BOS.darkcss(0.25, true)
if (sdn.l.first() > sdn.l.get(1) ?

boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch

s_bull_ob := true
s_bull_ob := true
s_bull_ob := true
s_bull_ob := true
trend := 1
sup.n.clear()
sup.p.clear()
// SWING BEARISH STRUCTURE

if sdn.p.size() > 0 and sup.l.size() > 1
if ta.crossunder(b.c, sdn.p.first())
bool CHoCH = na
string txt = na
if trend > 0
CHoCH := true
switch
not CHoCH =>
bralert.swingbos := true
txt := "BOS"
icss := s_ms_dn_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS
, txt
, false
)
CHoCH =>
if sup.l.first() < sup.l.get(1)

bralert.chochplusswing := true
else
bralert.chochswing := true
txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" :

"CHoCH"
icss := s_ms_dn_BOS.darkcss(0.25, false)
if (sup.l.first() < sup.l.get(1) ?

boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch

s_bear_ob := true
s_bear_ob := true
s_bear_ob := true
s_bear_ob := true
trend := -1
sdn.n.clear()
sdn.p.clear()
[css, bear_ob, bull_ob, itrend, drw, isdrw, s_bear_ob, s_bull_ob, trend, icss,
isdrwS]
[css, bear_ob, bull_ob, itrend, drw, isdrw, s_bear_ob, s_bull_ob, trend, icss,
isdrwS] = structure(false)
if isdrw
f_line(drw, size.small, line.style_dashed)
if isdrwS
f_line(drw, size.small, line.style_solid)
[_, _, _, itrend15, _, _, _, _, _, _, _] = request.security("", "15" ,

structure(true))
[_, _, _, itrend1H, _, _, _, _, _, _, _] = request.security("", "60" ,
structure(true))
[_, _, _, itrend4H, _, _, _, _, _, _, _] = request.security("", "240" ,
structure(true))
[_, _, _, itrend1D, _, _, _, _, _, _, _] = request.security("", "1440" ,
structure(true))
if show_mtf_str
var tab = table.new(position = position.top_right, columns = 10, rows = 10,

bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color
= color.rgb(54, 58, 69, 100), border_width = 1)
table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign =
text.align_center, text_size = size.normal, bgcolor = chart.bg_color,
text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign =
table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign =
table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign =
table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ?

"BEARISH" : na , text_halign = text.align_center, text_size = size.normal,
text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ?
i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color,
text_font_family = font.family_monospace)
table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ?
text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ?
table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ?
text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ?
table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ?
text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ?
table.cell(tab, 0, 5, text = "Detected Pattern", text_halign =

text.align_center, text_size = size.normal, text_color = color.silver, bgcolor =
chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center,
text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ?
i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25,
false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.merge_cells(tab, 0, 5, 1, 5)
table.merge_cells(tab, 0, 6, 1, 6)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Strong/Weak High/Low And Equilibrium
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
var phl = Zphl.new(

na
, na
, label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style =
label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style =
label.style_label_up , size = size.tiny , text = "")
, true
, true
, true
, true
, ""
, ""
, 0
, 0
, 0
, 0
, high
, low
, 0
, 0
, 0
, 0
, 0
, 0
, na
, na
)
zhl(len)=>
upper = ta.highest(len)
lower = ta.lowest(len)
var float out = 0

out := b.h[len] > upper ? 0 : b.l[len] < lower ? 1 : out[1]
top = out == 0 and out[1] != 0 ? b.h[len] : 0

btm = out == 1 and out[1] != 1 ? b.l[len] : 0
[top, btm]
[top , btm ] = zhl(sLen)

[itop, ibtm] = zhl(iLen)
upphl(trend) =>

na
, na
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
if top
phl.stopcross := true
phl.txtup := top > phl.topy ? "HH" : "HL"
if show_lbl
topl = label.new(
b.n - swing_r_lookback
, top
, phl.txtup
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
line.delete(phl.top[1])
phl.top := line.new(
b.n - sLen
, top
, b.n
, top
, color = toplvl)
phl.topy := top
phl.topx := b.n - sLen
phl.tup := top
phl.tupx := b.n - sLen
if itop
phl.itopcross := true
phl.itopy := itop
phl.itopx := b.n - iLen
phl.tup := math.max(high, phl.tup)

phl.tupx := phl.tup == high ? b.n : phl.tupx
phl.uV := phl.tup != phl.tup[1] ? b.v : phl.uV
if barstate.islast
line.set_xy1(
phl.top
, phl.tupx
, phl.tup
)
line.set_xy2(
phl.top
, b.n + 50
, phl.tup
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tup
)
dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100

label.set_text (lbl, trend < 0
? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)"
: "Weak High | " + str.tostring(phl.uV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)")
dnphl(trend) =>

na
, na
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
if btm
phl.sbottomcross := true
phl.txtdn := btm > phl.bottomy ? "LH" : "LL"
if show_lbl
btml = label.new(
b.n - swing_r_lookback
, btm, phl.txtdn
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
line.delete(phl.bottom[1])
phl.bottom := line.new(
b.n - sLen
, btm
, b.n
, btm
, color = btmlvl
)
phl.bottomy := btm
phl.bottomx := b.n - sLen
phl.tdn := btm
phl.tdnx := b.n - sLen
if ibtm
phl.ibottomcross := true
phl.ibottomy := ibtm
phl.ibottomx := b.n - iLen
phl.tdn := math.min(low, phl.tdn)

phl.tdnx := phl.tdn == low ? b.n : phl.tdnx
phl.dV := phl.tdn != phl.tdn[1] ? b.v : phl.dV
if barstate.islast
line.set_xy1(
phl.bottom
, phl.tdnx
, phl.tdn
)
line.set_xy2(
phl.bottom
, b.n + 50
, phl.tdn
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tdn
)
dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100

label.set_text (lbl, trend > 0
? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)"
: "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)")
midphl() =>
avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2())
var line l = line.new(

y1 = avg
, y2 = avg
, x1 = b.n - sLen
, x2 = b.n + 50
, color = midlvl
, style = line.style_solid
)

x = b.n + 50
, y = avg
, text = "Equilibrium"
, color = invcol
, textcolor = midlvl
, size = size.small
)
if barstate.islast
more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() +

phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1()
line.set_xy1(l , more , avg)
line.set_xy2(l , b.n + 50, avg)
label.set_x (lbl , b.n + 50 )
label.set_y (lbl , avg )
dist = math.abs((l.get_y2() - close) / close) * 100
label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) +
"%)")
hqlzone() =>
if barstate.islast
var hqlzone dZone = hqlzone.new(

box.new(
na
, na
, na
, na
, bgcolor = color.new(toplvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(midlvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(btmlvl, 70)
, border_color = na
)
, label.new(na, na, text = "Premium" , color = invcol, textcolor =

toplvl, style = label.style_label_down, size = size.small)
, label.new(na, na, text = "Equilibrium", color = invcol, textcolor =
midlvl, style = label.style_label_left, size = size.small)
, label.new(na, na, text = "Discount" , color = invcol, textcolor =
btmlvl, style = label.style_label_up , size = size.small)
)
dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx))
, phl.tup)
dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup
+ 0.05 * phl.tdn)
dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup

+ 0.475 * phl.tdn)
dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn
+ 0.475 * phl.tup)
dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn

+ 0.05 * phl.tup)
dZone.lbx.set_rightbottom(b.n + 50
, phl.tdn)
dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n +

50))) , phl.tup)
dZone.elb.set_xy( int(b.n + 50)
, math.avg(phl.tup, phl.tdn))
dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n +
50))) , phl.tdn)
if show_mtb
upphl (trend)
dnphl (trend)
hqlzone()
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Volumetric Order Block
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
method eB(box[] b, bool ext, color css, bool swing) =>

b.unshift(
box.new(
na
, na
, na
, na
, text_font_family = font.family_monospace
, extend = ext ? extend.right : extend.none
, border_color = swing ? color.new(css, 0) :
color.new(color.white,100)
, bgcolor = css
, border_width = 1
)
)
method eL(line[] l, bool ext, bool solid, color css) =>

l.unshift(
line.new(
na
, na
, na
, na
, width = 1
, color = css
, extend = ext ? extend.right : extend.none
, style = solid ? line.style_solid : line.style_dashed
)
)
method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) =>
[cC, oO, hH, lL, vV] = request.security(

syminfo.tickerid
, ""
, [
close
, open
, high
, low
, volume
, lookahead = barmerge.lookahead_off
)
var obC obj = obC.new(
array.new<float>()
)
var obD draw = obD.new(

array.new<box >()
, array.new<box >()
, array.new<box >()
, array.new<box >()
, array.new<line>()
)
if barstate.isfirst
for i = 0 to ob_num - 1
draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) :

color.new(css,0))
draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css,
swing)
draw.blB.eB(false, css_metric_up ,
swing)
draw.brB.eB(false, css_metric_dn ,
swing)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css,
swing)
float pos = ob_pos == "Full"

? (bull ? high : low)
: ob_pos == "Middle"
? ohlc4
: ob_pos == "Accurate"
? hl2
: hl2
if cdn
obj.h.clear()
obj.l.clear()
obj.n.clear()
for i = 0 to math.abs((loc - b.n)) - 1
obj.h.push(hH[i])
obj.l.push(lL[i])
obj.n.push(b.t[i])
// obj.h.reverse()
// obj.l.reverse()
int iU = obj.l.indexof(obj.l.min()) + 1
int iD = obj.h.indexof(obj.h.max()) + 1
obj.dir.unshift(
bull
? (b.c[iU] > b.o[iU] ? 1 : -1)
: (b.c[iD] > b.o[iD] ? 1 : -1)
)
obj.top.unshift(
bull
? pos[iU]
: obj.h.max()
)
obj.btm.unshift(
bull
? obj.l.min()
: pos[iD]
)
obj.left.unshift(
bull
? obj.n.get(obj.l.indexof(obj.l.min()))
: obj.n.get(obj.h.indexof(obj.h.max()))
)
obj.avg.unshift(
math.avg(obj.top.first(), obj.btm.first())
)
obj.cV.unshift(
bull
? b.v[iU]
: b.v[iD]
)
if ob_pos == "Precise"
switch bull
true =>
if obj.avg.get(0) < (b.c[iU] < b.o[iU] ? b.c[iU] : b.o[iU]) and
obj.top.get(0) > hlcc4[iU]
obj.top.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
false =>
if obj.avg.get(0) > (b.c[iU] < b.o[iU] ? b.o[iD] : b.c[iD]) and
obj.btm.get(0) < hlcc4[iD]
obj.btm.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
obj.blVP.unshift ( 0 )
obj.brVP.unshift ( 0 )
obj.wM .unshift ( 1 )
if use_overlap
int rmP = use_overlap_method == "Recent" ? 1 : 0
if obj.avg.size() > 1
if bull
? obj.btm.first() < obj.top.get(1)

: obj.top.first() > obj.btm.get(1)
obj.wM .remove(rmP)
obj.cV .remove(rmP)
obj.dir .remove(rmP)
obj.top .remove(rmP)
obj.avg .remove(rmP)
obj.btm .remove(rmP)
obj.left .remove(rmP)
obj.blVP .remove(rmP)
obj.brVP .remove(rmP)
if barstate.isconfirmed
for x = 0 to ob_num - 1
tg = switch ob_mitigation
"Middle" => obj.avg
"Absolute" => bull ? obj.btm : obj.top
for [idx, pt] in tg
if (bull ? cC < pt : cC > pt)

obj.wM .remove(idx)
obj.cV .remove(idx)
obj.dir .remove(idx)
obj.top .remove(idx)
obj.avg .remove(idx)
obj.btm .remove(idx)
obj.left .remove(idx)
obj.blVP .remove(idx)
obj.brVP .remove(idx)
if barstate.islast
if obj.avg.size() > 0
// Alert
if bull
? ta.crossunder(low , obj.top.get(0))
: ta.crossover (high, obj.btm.get(0))
switch bull
true => blalert.obtouch := true
false => bralert.obtouch := true
float tV = 0
obj.dV.clear()
seq = math.min(ob_num - 1, obj.avg.size() - 1)
for j = 0 to seq
tV += obj.cV.get(j)
if j == seq
for y = 0 to seq
obj.dV.unshift(
math.floor(
(obj.cV.get(y) / tV) * 100)
)
obj.dV.reverse()
for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1)
dmL = draw.mL .get(i)

dOB = draw.ob .get(i)
dblB = draw.blB.get(i)
dbrB = draw.brB.get(i)
deOB = draw.eOB.get(i)
dOB.set_lefttop (obj.left .get(i) , obj.top.get(i))

deOB.set_lefttop (b.t , obj.top.get(i))
dOB.set_rightbottom (b.t , obj.btm.get(i))
deOB.set_rightbottom(b.t + (b.t - b.t[1]) * 100 , obj.btm.get(i))
if use_middle_line
dmL.set_xy1(obj.left.get(i), obj.avg.get(i))
dmL.set_xy2(b.t , obj.avg.get(i))
if ob_metrics_show
dblB.set_lefttop (obj.left.get(i), obj.top.get(i))

dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i))
dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i))
dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i))
rpBL = dblB.get_right()
rpBR = dbrB.get_right()
dbrB.set_right(rpBR + (b.t - b.t[1]) * obj.brVP.get(i))
dblB.set_right(rpBL + (b.t - b.t[1]) * obj.blVP.get(i))
if use_show_metric
txt = switch
obj.cV.get(i) >= 1000000000 =>

str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B"
obj.cV.get(i) >= 1000000 =>
str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M"
obj.cV.get(i) >= 1000 =>
str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K"
obj.cV.get(i) < 1000 =>
str.tostring(math.round(obj.cV.get(i)))
deOB.set_text(
str.tostring(
txt + " (" + str.tostring(obj.dV.get(i)) + "%)")
)
deOB.set_text_size (size.auto)
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.silver :
color.new(css, 0))
if ob_metrics_show and barstate.isconfirmed
if obj.wM.size() > 0
for i = 0 to obj.avg.size() - 1
switch obj.dir.get(i)
1 =>
switch obj.wM.get(i)
1 => obj.blVP.set(i, obj.blVP.get(i) + 1),

obj.wM.set(i, 2)
obj.wM.set(i, 3)
3 => obj.brVP.set(i, obj.brVP.get(i) + 1),
obj.wM.set(i, 1)
-1 =>
switch obj.wM.get(i)

obj.wM.set(i, 2)
obj.wM.set(i, 3)
obj.wM.set(i, 1)
var hN = array.new<int>(1, b.n)

var lN = array.new<int>(1, b.n)
var hS = array.new<int>(1, b.n)
var lS = array.new<int>(1, b.n)
if iH
hN.pop()
hN.unshift(int(b.n[iLen]))
if iL
lN.pop()
lN.unshift(int(b.n[iLen]))
if sH
hS.pop()
hS.unshift(int(b.n[sLen]))
if sL
lS.pop()
lS.unshift(int(b.n[sLen]))
if ob_show
bull_ob.drawVOB(true , ob_bull_css, hN.first(), false)

bear_ob.drawVOB(false, ob_bear_css, lN.first(), false)
if ob_swings
s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true)

s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true)
if bull_ob
blalert.ob := true
if bear_ob
bralert.ob := true
if s_bull_ob
blalert.swingob := true
if s_bear_ob
blalert.swingob := true
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - FVG | VI | OG
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
ghl() => request.security(syminfo.tickerid, fvg_tf, [high[2], low[2], close[1],

open[1]])
tfG() => request.security(syminfo.tickerid, fvg_tf, [open, high, low, close])
cG(bool bull) =>
[h, l, c, o] = ghl()
[go, gh, gl, gc] = tfG()
var FVG draw = FVG.new(

array.new<box>()
, array.new<line>()
)
var FVG[] cords = array.new<FVG>()
float pup = na
float pdn = na
bool cdn = na
int pos = 2
cc = timeframe.change(fvg_tf)
if barstate.isfirst
for i = 0 to fvg_num - 1
draw.box.unshift(box.new (na, na, na, na, border_color =

color.new(color.white, 100), xloc = xloc.bar_time))
draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width =
1, style = line.style_solid))
switch what_fvg
"FVG" =>
pup := bull ? gl : l
pdn := bull ? h : gh
cdn := bull ? gl > h and cc : gh < l and cc
pos := 2
"VI" =>
pup := bull
? (gc > go
? go
: gc)
: (gc[1] > go[1]
? go[1]
: gc[1])
pdn := bull
? (gc[1] > go[1]
? gc[1]
: go[1])
: (gc > go
? gc
: go)
cdn := bull
? go > gc[1] and gh[1] > gl and gc > gc[1] and go > go[1] and
gh[1] < math.min(gc, go) and cc
: go < gc[1] and gl[1] < gh and gc < gc[1] and go < go[1] and
gl[1] > math.max(gc, go) and cc
pos := 1
"OG" =>
pup := bull ? b.l : gl[1]

pdn := bull ? gh[1] : gh
cdn := bull ? gl > gh[1] and cc : gh < gl[1] and cc
pos := 1
if not na(cdn[1]) and cdn[1]
cords.unshift(
FVG.new(
na
, na
, bull
? true
: false
, pup[1]
, pdn[1]
, b.t - (b.t - b.t[1]) * pos + 1
, b.t + (b.t - b.t[1]) * fvg_extend + 1)
)
if bull
blalert.fvg := true
else
bralert.fvg := true
if barstate.isconfirmed
for [idx, obj] in cords
if obj.bull ? b.c < obj.btm : b.c > obj.top
cords.remove(idx)
if barstate.islast
if cords.size() > 0
for i = math.min(fvg_num - 1, cords.size() - 1) to 0
gbx = draw.box.get(i)
gln = draw.ln.get(i)
gcd = cords.get(i)
gtop = gcd.top
gbtm = gcd.btm
left = gcd.left
right = gcd.right
gbx.set_lefttop(left, gtop)
gbx.set_rightbottom(right, gbtm)
gbx.set_bgcolor(gcd.bull ? fvg_upcss : fvg_dncss)
gln.set_xy1(left, math.avg(gbx.get_top(), gbx.get_bottom()))

gln.set_xy2(right, math.avg(gbx.get_top(), gbx.get_bottom()))
gln.set_color(gcd.bull ? fvg_upcss : fvg_dncss)
if fvg_enable
cG(true )
cG(false)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - END
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Accumulation And Distribution
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
drawZone(int len) =>

var zone[] z = array.new<zone>()
if iH
z.unshift(
zone.new(
chart.point.from_time(
time[len]
, high [len]
)
, high [len]
, 1
, time[len]
)
)
if iL
z.unshift(
zone.new(
chart.point.from_time(
time[len]
, low [len]
)
, low [len]
, -1
, time[len]
)
)
if z.size() > 1
if z.get(0).c == z.get(1).c
z.clear()
switch
zone_mode == "Slow" =>
if z.size() > 5
if z.get(0).c == -1 and z.get(1).c == 1 and z.get(2).c == -1 and

z.get(3).c == 1 and z.get(4).c == -1 and z.get(5).c == 1
if z.get(0).p > z.get(2).p and z.get(2).p > z.get(4).p
if z.get(1).p < z.get(3).p and z.get(3).p < z.get(5).p
blalert.zone := true
box.new(top = z.get(5).p, bottom = z.get(4).p, left =

z.get(5).t, right = z.get(0).t, bgcolor = acc_css, border_color =
color.new(color.white, 100), xloc = xloc.bar_time)
slice = array.new<chart.point>()
for i = 0 to 5
slice.unshift(z.get(i).points)
polyline.new(slice, xloc = xloc.bar_time, line_color =

color.new(acc_css, 0), line_width = 2)
p.found := "Accumulation Zone"
p.bull := true
p.isfound := true
p.period := 0
z.clear()
if z.size() > 5
if z.get(0).c == 1 and z.get(1).c == -1 and z.get(2).c == 1 and

z.get(3).c == -1 and z.get(4).c == 1 and z.get(5).c == -1
if z.get(0).p < z.get(2).p and z.get(2).p < z.get(4).p
if z.get(1).p > z.get(3).p and z.get(3).p > z.get(5).p
bralert.zone := true

z.get(5).t, right = z.get(0).t, bgcolor = dist_css, border_color =
for i = 0 to 5

color.new(dist_css, 0), line_width = 2)
p.found := "Distribution Zone"
p.bull := false
p.isfound := true
p.period := 0
z.clear()
zone_mode == "Fast" =>
if z.size() > 3
if z.get(0).c == -1 and z.get(1).c == 1 and z.get(2).c == -1 and

z.get(3).c == 1
if z.get(0).p > z.get(2).p
if z.get(1).p < z.get(3).p
blalert.zone := true

z.get(3).t, right = z.get(0).t, bgcolor = acc_css, border_color =
for i = 0 to 3

color.new(acc_css, 0), line_width = 2)
p.found := "Accumulation Zone"
p.bull := true
p.isfound := true
p.period := 0
z.clear()
if z.size() > 3
if z.get(0).c == 1 and z.get(1).c == -1 and z.get(2).c == 1 and

z.get(3).c == -1
if z.get(0).p < z.get(2).p

if z.get(1).p > z.get(3).p
bralert.zone := true

z.get(3).t, right = z.get(0).t, bgcolor = dist_css, border_color =
for i = 0 to 3

color.new(dist_css, 0), line_width = 2)
p.found := "Distribution Zone"
p.bull := false
p.isfound := true
p.period := 0
z.clear()
if show_acc_dist_zone
drawZone(iLen)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - END
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - EQH / EQL
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
dEHL() =>
var ehl w = ehl.new(0, 0, 0, 0)

top = ta.pivothigh(high, 1, 1)
btm = ta.pivotlow(low , 1, 1)
atr = ta.atr(200)
switch
top =>
mx = math.max(top, w.pt)
mn = math.min(top, w.pt)
switch
mx < mn + atr * 0.1 =>
var aZ = array.new<line>()
var aL = array.new<label>()
if aZ.size() > 50
aZ.pop().delete()
aL.pop().delete()
aZ.unshift(line.new(w.t, w.pt, b.n - 1, top, color =

i_ms_dn_BOS, style = line.style_dotted))
aL.unshift(label.new(int(math.avg(b.n - 1, w.t)), top, "EQH",
color = invcol, textcolor = i_ms_dn_BOS, style = label.style_label_down, size =
size.tiny))
bralert.equal := true
w.pt := top
w.t := b.n - 1
btm =>
mx = math.max(btm, w.pb)
mn = math.min(btm, w.pb)
switch
mn > mx - atr * 0.1 =>
var aZ = array.new<line>()
var aL = array.new<label>()
if aZ.size() > 50
aZ.pop().delete()
aL.pop().delete()
aZ.unshift(line.new(w.b, w.pb, b.n - 1, btm, color =

i_ms_up_BOS, style = line.style_dotted))
aL.unshift(label.new(int(math.avg(b.n - 1, w.b)), btm, "EQL",
color = invcol, textcolor = i_ms_up_BOS, style = label.style_label_up, size =
size.tiny))
blalert.equal := true
w.pb := btm
w.b := b.n - 1
if show_eql
dEHL()
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Plotting And Coloring
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
p_css = css
b_css = css
w_css = css
p_css := plotcandle_bool ? (css) : na

b_css := barcolor_bool ? (css) : na
w_css := plotcandle_bool ? color.rgb(120, 123, 134, 50) : na
plotcandle(open,high,low,close , color = p_css , wickcolor = w_css , bordercolor =

p_css , editable = false)
barcolor(b_css, editable = false)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - END
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
alertcondition(blalert.bos , "Bullish BOS", "Bullish BOS")

alertcondition(blalert.choch , "Bullish CHOCH", "Bullish CHOCH")
alertcondition(blalert.chochplus , "Bullish CHOCH+", "Bullish CHOCH+")
alertcondition(blalert.chochplusswing, "Bullish Swing CHOCH+", "Bullish Swing
CHOCH+")
alertcondition(blalert.chochswing , "Bullish Swing CHOCH", "Bullish CHOCH")
alertcondition(blalert.swingbos , "Bullish Swing BOS", "Bullish Swing BOS")
alertcondition(blalert.equal , "EQL", "EQL")
alertcondition(blalert.fvg , "Bullish FVG", "Bullish FVG")
alertcondition(blalert.ob , "Bullish Order Block", "Bullish Order
Block")
alertcondition(blalert.swingob , "Bullish Swing Order Block", "Bullish Swing
Order Block")
alertcondition(blalert.zone , "Accumulation Zone", "Accumulation Zone")
alertcondition(blalert.obtouch , "Candle Entering in a Bullish Order Block",
"Candle Entering in a Bullish Order Block")
textstylist = table.new(textVPosition + '_' + textHPosition, 1, 3)
alertcondition(bralert.bos , "Bearish BOS", "Bearish BOS")
alertcondition(bralert.choch , "Bearish CHOCH", "Bearish CHOCH")
alertcondition(bralert.chochplus , "Bearish CHOCH+", "Bearish CHOCH+")
alertcondition(bralert.chochplusswing, "Bearish Swing CHOCH+", "Bearish Swing
CHOCH+")
alertcondition(bralert.chochswing , "Bearish Swing CHOCH", "Bearish CHOCH")
alertcondition(bralert.swingbos , "Bearish Swing BOS", "Bearish Swing BOS")
alertcondition(bralert.equal , "EQH", "EQH")
alertcondition(bralert.fvg , "Bearish FVG", "Bearish FVG")
alertcondition(bralert.ob , "Bearish Order Block", "Bearish Order
Block")
alertcondition(bralert.swingob , "Bearish Swing Order Block", "Bearish Swing
Order Block")
alertcondition(bralert.zone , "Distribution Zone", "Distribution Zone")
alertcondition(bralert.obtouch , "Candle Entering in a Bearish Order Block",
"Candle Entering in a Bearish Order Block")
if barstate.isfirst
var table errorBox = table.new(position.bottom_right, 1, 1, bgcolor =
color.new(#363a45, 100))
table.cell(errorBox, 0, 0, "© Stratify", text_color = color.gray,
text_halign = text.align_center, text_size = size.normal)
// # ============================[Liquidity]============================ #
gr_fts = "FEATURES"
liquidity = input(false, "Liquidity", inline = "4", group = gr_fts)
htfTF = input.timeframe("", "", inline = "4", tooltip = "Shows areas of market
liquidity", group = gr_fts)
trendline = input(true, "Trend Lines", inline = "2", group = gr_fts)
trendlilenght = input.int(50, "", inline = "2", step = 1, minval = 2, tooltip =
"Enables automatic drawing of trend lines", group = gr_fts)
// Get Components
mitiOptions = "Remove"
displayStyle_liq = "Boxes"
hh = close
ll = close
timediff=(time[1]-time[101])/100
atr_liq = ta.atr(300)
float thold_liq = atr_liq * (2.5 / 10)
// Functions
tf_multi(tf) =>
ts = timeframe.in_seconds("")
htfs = timeframe.in_seconds(tf)
htfs/ts
display_limit_line(_array) =>
if array.size(_array) > 6/2
a = array.shift(_array)
line.delete(a)
display_limit_box(_array) =>
if array.size(_array) > 6/2
a = array.shift(_array)
box.delete(a)
remove_mitigated_lines(_array, _hl) =>
m = false
if array.size(_array) > 0
for i = array.size(_array) - 1 to 0 by 1
l = array.get(_array, i)
if _hl == "High" and hh > line.get_y1(l)
array.remove(_array, i)
if mitiOptions == "Show"
line.new(line.get_x1(l),line.get_y1(l),time,line.get_y1(l),
xloc=xloc.bar_time, color = color.new(#f23645,50), style=line.style_solid, width =
2)
line.delete(l)
m := true
if _hl == "Low" and ll < line.get_y1(l)
line.new(line.get_x1(l),line.get_y1(l),time,line.get_y1(l),
xloc=xloc.bar_time, color = color.new(#089981,50), style=line.style_solid, width =
2)
line.delete(l)
m := true
display_limit_line(_array)
m
remove_mitigated_boxes(_array, _hl) =>
m = false
if array.size(_array) > 0
for i = array.size(_array) - 1 to 0 by 1
l = array.get(_array, i)
if _hl == "High" and hh > box.get_top(l)
box.new(box.get_left(l),box.get_top(l),time,box.get_bottom(l),
xloc=xloc.bar_time, bgcolor = color.new(#f23645, 90), border_color =
color.new( #f23645, 90), border_style = line.style_solid)
box.delete(l)
m := true
if _hl == "Low" and ll < box.get_top(l)
box.new(box.get_left(l),box.get_top(l),time,box.get_bottom(l),
xloc=xloc.bar_time, bgcolor = color.new(#089981, 90), border_color =
color.new(#089981, 90), border_style = line.style_solid)
box.delete(l)
m := true
display_limit_box(_array)
m
extend_line_to_current(lineArray) =>
if array.size(lineArray) > 0
for i = array.size(lineArray) - 1 to 0 by 1
l = array.get(lineArray, i)
timeExt = timenow + ((timediff)*30)
line.set_x2(l, timeExt)
extend_box_to_current(boxArray) =>
if array.size(boxArray) > 0
for i = array.size(boxArray) - 1 to 0 by 1
b = array.get(boxArray, i)
timeExt = timenow + ((timediff)*30)
box.set_right(b, timeExt)
// ----------------------------------------------------
// Higher TimeFrame
// ----------------------------------------------------
// Varibles
// Lines
var highLineArrayHTF = array.new_line()
var lowLineArrayHTF = array.new_line()
// Boxes
var highBoxArrayHTF = array.new_box()
var lowBoxArrayHTF = array.new_box()
// Get HTF
[_time, _open, _high, _low, _close] = request.security(syminfo.tickerid, htfTF,
[time, open, high, low, close])
// Pivots
pivotHighHTF = ta.pivothigh(_high, 8*tf_multi(htfTF), 8+tf_multi(htfTF))
pivotLowHTF = ta.pivotlow(_low, 8*tf_multi(htfTF), 8+tf_multi(htfTF))
if liquidity
timeExt = time+((time[1]-time[2])*10)
dis = 8+tf_multi(htfTF)
if pivotHighHTF
if displayStyle_liq == "Lines"
array.push(highLineArrayHTF,
line.new(_time[dis],_high[dis],_time[+1],_high[dis],color = color.new(#f23645,50),
style=line.style_solid, xloc=xloc.bar_time, extend=extend.none, width = 2))
else
y1 = _high[dis]-thold_liq//math.max(_open[dis], _close[dis])
array.push(highBoxArrayHTF,
box.new(_time[dis],_high[dis],_time[+1],y1,bgcolor = color.new(#f23645,50) ,
border_color=color.new(#f23645,90), xloc=xloc.bar_time, border_style =
line.style_solid, extend=extend.none, border_width = 2,text="$",text_halign =
text.align_center,text_color = color.white,text_size = size.small))
if pivotLowHTF
if displayStyle_liq == "Lines"
array.push(lowLineArrayHTF,
line.new(_time[dis],_low[dis],_time[+1],_low[dis],color = color.new(#089981,50),
style=line.style_solid, xloc=xloc.bar_time, extend=extend.none, width = 2))
else
y1 = _low[dis]+thold_liq//math.min(_open[dis], _close[dis])
array.push(lowBoxArrayHTF,
box.new(_time[dis],_low[dis],_time[+1],y1,bgcolor = color.new(#089981,50),
border_color=color.new(#089981,90), xloc=xloc.bar_time, border_style =
line.style_solid, extend=extend.none, border_width = 2,text="$",text_halign =
text.align_center,text_color = color.white,text_size = size.small))
// ----------------------------------------------------
// Run Functions
// ----------------------------------------------------
highLineAlertHTF = remove_mitigated_lines(highLineArrayHTF, "High")
lowLineAlertHTF = remove_mitigated_lines(lowLineArrayHTF, "Low")
highBoxAlertHTF = remove_mitigated_boxes(highBoxArrayHTF, "High")
lowBoxAlertHTF = remove_mitigated_boxes(lowBoxArrayHTF, "Low")
extend_line_to_current(highLineArrayHTF)
extend_line_to_current(lowLineArrayHTF)
extend_box_to_current(highBoxArrayHTF)
extend_box_to_current(lowBoxArrayHTF)
// # ============================[Trend Lines]============================ #
//Downtrendline
var int phx1 = na
var float phslope = na
var float phy1 = na
var float upper = na
var float plotH = na
var bool isOnH = false
//Uptrendline
var int plx1 = na
var float plslope = na
var float ply1 = na
var float lower = na
var float plotL = na
var bool isOnL = false
var line testLine = line.new(na, na, na, na, color=color.new(color.blue, 100))

//Calculations
n = bar_index
source = close
ph = ta.pivothigh(trendlilenght, trendlilenght)
pl = ta.pivotlow(trendlilenght, trendlilenght)
bg = chart.bg_color
fg = chart.fg_color
bars = 500 , height = bars / 3
Xaxis = math.min(math.max(1, n), bars)
Yaxis = ta.highest(Xaxis) - ta.lowest(Xaxis)
srcBl = source
srcBr = source
//Function
calculate_slope(x1, x2, y1, y2) =>
diffX = x2 - x1, diffY = y2 - y1
diffY_to_Yaxis = Yaxis / diffY
normalised_slope = (height / diffY_to_Yaxis) / diffX
slope = diffY / diffX
angle = math.round(math.atan(normalised_slope) * 180 / math.pi, 2)
[normalised_slope, slope, angle]
//Execution
if trendline
if not na(ph)
if ph < phy1
[normalised_slope, slope, angle] = calculate_slope(phx1, n -
trendlilenght, phy1, ph)
testLine.set_xy1(phx1, phy1), testLine.set_xy2(n, ph + slope *
trendlilenght)
src = source, max_bars_back(src, 2000)
isOnH := false
broken = false
if math.abs(angle) > 0.1 and math.abs(angle) < 90
for i = trendlilenght to n - plx1
if src[i] > testLine.get_price(n - i)
broken := true
break
if not broken
phslope := slope
isOnH := true
upper := ph + slope * trendlilenght
line.new(phx1, phy1, n, ph + slope * trendlilenght,
color=color.green, style=line.style_dotted)
phy1 := ph
phx1 := n - trendlilenght
upper += phslope
plotH := not na(ph) and ta.change(phslope) ? na : srcBl[1] > upper[1] ? na :
upper
bs_H = ta.barssince(na(plotH))
if not na(pl)
if pl > ply1
[normalised_slope, slope, angle] = calculate_slope(plx1, n - trendlilenght,
ply1, pl)
testLine.set_xy1(plx1, ply1), testLine.set_xy2(n, pl + slope *
trendlilenght)
src = source, max_bars_back(src, 2000)
isOnL := false
broken = false
if angle > 0.1 and angle < 90
for i = trendlilenght to n - plx1
if src[i] < testLine.get_price(n - i)
broken := true
break
if not broken
plslope := slope
isOnL := true
lower := pl + slope * trendlilenght
line.new(plx1, ply1, n, pl + slope * trendlilenght,
color=color.red, style=line.style_dotted)
ply1 := pl
plx1 := n - trendlilenght
lower += plslope
plotL := not na(pl) and ta.change(plslope) ? na : srcBr[1] < lower[1] ? na :
lower
bs_L = ta.barssince(na(plotL))
// New Golden Fibonacci
///
// Pre-DEFINE
//
//---------------------------------------------------
var COLOR_TRANSP = color.new(#ffffff,100)
var COLOR_BLACK = color.new(#000000,0)
//---------------------------------------------------
var basicgr = "🧊 PunkAlgo Smart Fibonacci"
var fb_tooltip = "\nDepth ; The minimum number of bars that will be taken into
account when calculating the indicator.\n\nDeviation ; a multiplier that affects
how much the price should deviate from the previous pivot in order for the bar to
become a new pivot.\n"
// INPUT
fb_depth = input.int (10 ,minval=1,maxval=20 ,title = "How Far

" ,inline='FBR1' ,group=basicgr)
fb_dev_ratio = input.float (3.0 ,minval=1,step=0.5 ,title = "Wave Size
" ,inline='FBR2' ,group=basicgr ,tooltip=fb_tooltip)
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
fb_dev_threshold = (ta.atr(20)/close) * 100 * fb_dev_ratio
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
fb236=input(false,"236 ",inline='fbl' ,group=basicgr)
fb382=input(true ,"382 ",inline='fbl' ,group=basicgr)
fb786=input(false,"786 ",inline='fbl' ,group=basicgr)
fb886=input(false,"886" ,inline='fbl' ,group=basicgr)
//---------------------------------------------------------------------------------
------------------------------------------------------------------
view_gr = '🔴🟠🟡🟢🔵'
draw_pmark_c = input.color (color.new(#ffffff,0) ,""

,inline='pmark' ,group=view_gr)
draw_pmark = input.bool (false ,'◯ Pivot Point'
,inline='pmark' ,group=view_gr)
draw_tline_c = input.color (color.new(#ffffff,0) ,""

,inline='tline' ,group=view_gr)
draw_tline = input.bool (false ,'-- Trend Line'
,inline='tline' ,group=view_gr)
fb_guide_color = input.color (color.new(#ffff00,0) ,title = ""

,inline='retlg' ,group=view_gr )
fb_guide_draw = input.bool (false ,'▮ Retracement
Meter ' ,inline='retlg' ,group=view_gr)
fb_color5 = input.color (color.new(#2157f3,0) ,title = "1.0 Level"

,inline='color1' ,group=view_gr )
fb_color4 = input.color (color.new(#f23645,0) ,title = "0.0 Level"
fb_color3 = input.color (color.new(#b39ddb,0) ,title = "0.5 Level"
fb_color2 = input.color (color.new(#ffa726,0) ,title = "Scheme"
fb_color1 = input.color (color.new(#b2b5be,0) ,title = ""
fb_label_position = input.int (23 ,title = "Ruller
position (X-axis Offset)" ,inline='position' ,group=view_gr )
draw_simplelabel = input.bool (false ,' Extended Info.
(Price, Delta Rate)' ,inline='' ,group=view_gr)
//---------------------------------------------------------------------------------
------------------------------------------------------------------
//---------------------------------------------------------------------------------
------------------------------------------------------------------
//---------------------------------------------------------------------------------
------------------------------------------------------------------
//---------------------------------------------------------------------------------
------------------------------------------------------------------
[k_volume,k_open,k_close,k_high,k_low,k_hlc3,k_hlcc4,k_ohlc4,k_hl2,k_close_mintick,
k_trtrue,k_atr14,k_atr14_mintick,k_rsipvt14]
= request.security(syminfo.tickerid ,'',
[volume,open,close,high,low,hlc3,hlcc4,ohlc4,hl2,str.tostring(close,format.mintick)
,ta.tr(true),ta.atr(14),str.tostring(ta.atr(14),format.mintick),ta.rsi(ta.pvt,14)]
)
//
// Background
//
//
// Fibonacci Retracement - Logic Performance Tuned & Re-Designed Fresh-

Drawing, Automatic Line on/off
//
// pre-define
-----------------------------------------------------------------------------------
---
var line fb_lineLast = na
var label fb_label_start_last = na
var label fb_label_end_last = na
var int fb_iLast = 0
var int fb_iPrev = 0
var float fb_pLast = 0
var fb_isHighLast = false // otherwise the last pivot is a low
pivot
// pivot
-----------------------------------------------------------------------------------
---
high_none = ta.highest(high,fb_depth) > nz(high[fb_depth/2])
fb_iH = high_none ? int(na) : bar_index[fb_depth/2]
fb_pH = high_none ? float(na) : nz(high[fb_depth/2])
low_none = ta.lowest (low ,fb_depth) < nz(low [fb_depth/2])
fb_iL = low_none ? int(na) : bar_index[fb_depth/2]
fb_pL = low_none ? float(na) : nz(low [fb_depth/2])
//---------------------------------------------------------------------------------
-----
calc_dev(_base_price, _price) => 100 * (_price - _base_price) / _price
//---------------------------------------------------------------------------------
-----
pivotFound(dev, isHigh, index, price) =>
if fb_isHighLast == isHigh and not na(fb_lineLast)
// same direction
if fb_isHighLast ? price > fb_pLast : price < fb_pLast
line.set_xy2(fb_lineLast, index, price)
label.set_xy(fb_label_end_last, index, price)
[fb_lineLast, fb_isHighLast,fb_label_start_last,fb_label_end_last]
else
[line(na), bool(na), label(na), label(na)]
else // reverse the direction (or create the very first line)
if math.abs(dev) > fb_dev_threshold
// price move is significant
id_fb_line = line.new(fb_iLast, fb_pLast, index, price,
color=color.new(draw_tline_c,draw_tline?0:100), width=1, style=line.style_dashed)
// ------ FBR start -> end ; slopped line
id_fb_label_start = label.new(fb_iLast, fb_pLast ,color=COLOR_TRANSP,
size=size.huge ,style=label.style_label_center,
textcolor=color.new(draw_pmark_c,draw_pmark?0:100) ,text= '◯' )
id_fb_label_end = label.new(index , price ,color=COLOR_TRANSP,
size=size.huge ,style=label.style_label_center,
textcolor=color.new(draw_pmark_c,draw_pmark?0:100) ,text= '◯' )
[id_fb_line, isHigh, id_fb_label_start, id_fb_label_end]
else
[line(na), bool(na),label(na),label(na)]
//---------------------------------------------------------------------------------
-----
fb_new_line = false
if not na(fb_iH)
fb_dev = calc_dev(fb_pLast, fb_pH)
[fb_id, fb_isHigh, fb_la_s_id, fb_la_e_id] = pivotFound(fb_dev, true, fb_iH,
fb_pH)
if not na(fb_id)
if fb_id != fb_lineLast
line.delete (fb_lineLast)
label.delete(fb_label_start_last)
label.delete(fb_label_end_last)
fb_new_line := true
fb_lineLast := fb_id
fb_label_start_last := fb_la_s_id
fb_label_end_last := fb_la_e_id
fb_isHighLast := fb_isHigh
fb_iPrev := fb_iLast
fb_iLast := fb_iH
fb_pLast := fb_pH
else if not na(fb_iL)
fb_dev = calc_dev(fb_pLast, fb_pL)
[fb_id, fb_isHigh, fb_la_s_id, fb_la_e_id] = pivotFound(fb_dev, false, fb_iL,
fb_pL)
if not na(fb_id)
if fb_id != fb_lineLast
line.delete (fb_lineLast)
label.delete(fb_label_start_last)
label.delete(fb_label_end_last)
fb_new_line := true
fb_lineLast := fb_id
fb_label_start_last := fb_la_s_id
fb_label_end_last := fb_la_e_id
fb_isHighLast := fb_isHigh
fb_iPrev := fb_iLast
fb_iLast := fb_iL
fb_pLast := fb_pL
//---------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------
fb_retracement (_show, _fib_level, _col ,_switch) =>
_price = fb_pLast + ((line.get_y1(fb_lineLast)-fb_pLast))* _fib_level
_fbfb_id_line_show = false
_position = bar_index - line.get_x2(fb_lineLast)
_fbr_max_highest = math.max( ta.highest(high,
nz(math.max(1,_position),1)) , fb_pLast)
_fbr_min_lowest = math.min( ta.lowest (low ,
nz(math.max(1,_position),1)) , fb_pLast)
_fbr_max = fb_pLast < close ? _fbr_max_highest : fb_pLast > close ?
_fbr_min_lowest : fb_pLast
_fbr_line_max = fb_pLast < _price? _fbr_max_highest : fb_pLast > _price ?
_fbr_min_lowest : fb_pLast
_fbfb_id_line_show := fb_pLast < _price and _price-(k_atr14/4) <=
_fbr_line_max ? true
: fb_pLast > _price and _price+(k_atr14/4) >=
_fbr_line_max ? true
: false
if _switch =='auto' and not na(fb_lineLast)
fbfb_id_auto = line.new(line.get_x2(fb_lineLast) ,_price ,bar_index +
6 ,_price ,style=line.style_dashed,
color=color.new(_col,_fbfb_id_line_show?30:100) , width=1, extend=extend.none)
fbfb_id_ext_auto = line.new(bar_index+fb_label_position-
4,_price ,bar_index+fb_label_position+1 ,_price ,color=color.new(_col,0), width=1,
extend=extend.none)
fb_label_auto = label.new(x=bar_index+fb_label_position+1 ,y=_price,
text=str.tostring(_fib_level,"0.000")+(draw_simplelabel ? (' ' +
str.tostring(_price, format.mintick) + ' ' + str.tostring(((_price -
fb_pLast)/fb_pLast)*100,format.percent )):''),textcolor=color.new(_col,40) ,style=l
abel.style_label_left ,textalign=text.align_left , color=#00000000,
size=size.small)
line.delete(fbfb_id_auto[1] )
line.delete(fbfb_id_ext_auto[1] )
label.delete(fb_label_auto[1] )
if not _show
line.delete(fbfb_id_auto )
line.delete(fbfb_id_ext_auto )
label.delete(fb_label_auto )
if _show and _switch ==''
var fbfb_id = line.new(fb_iLast, _price, bar_index, _price,
color=color.new(_col,0) , width=1, extend=extend.none ,style=line.style_dashed )
//--- FBR | line = start to now
var fbfb_id_ext = line.new(fb_iLast, _price, bar_index, _price,
color=color.new(_col,0) , width=1, extend=extend.none) //--- FBR | line = now
to label position
var fb_label = label.new(x=bar_index ,y=_price,
text='' ,textcolor=COLOR_TRANSP ,style=label.style_label_left ,textalign=text.ali
gn_left , color=#00000000, size=size.small)
if not na(fb_lineLast)
line.set_xy1 (fbfb_id ,_fib_level==1.0?
line.get_x1(fb_lineLast):line.get_x2(fb_lineLast), _price)
line.set_xy2 (fbfb_id ,_fib_level==1.0 or _fib_level==0.0? bar_index
+ fb_label_position-4 : bar_index + 6 , _price)
line.set_color(fbfb_id ,color.new(_col, _fib_level==0.0?
0:_fib_level==1.0?0:_fbfb_id_line_show ? 30 : 100))
// line.set_style(fbfb_id ,_fib_level==0.0 or _fib_level==1.0 ?
line.style_dashed : line.style_solid)
//---------------------------------------------------------------------
------------------------------
line.set_xy1 (fbfb_id_ext ,bar_index+fb_label_position-4 ,_price)
line.set_xy2 (fbfb_id_ext ,bar_index+fb_label_position+1 ,_price)
line.set_width (fbfb_id_ext ,1)
//---------------------------------------------------------------------
------------------------------
label.set_xy (fb_label ,bar_index+fb_label_position+1 ,_price)
label.set_text (fb_label ,str.tostring(_fib_level,"0.000")+
(draw_simplelabel ? ' ' + str.tostring(_price, format.mintick) + ' ' +
str.tostring(((_price - fb_pLast)/fb_pLast)*100,format.percent ):''))
// label.set_tooltip (fb_label ,str.tostring(((_price -
fb_pLast)/fb_pLast)*100,format.percent ))
label.set_textcolor (fb_label ,color.new(_col,30))
if _fib_level == 1.0 and fb_guide_draw == true

var fbfb_box_max = box.new (bar_index, close ,bar_index,
fb_pLast, border_color=color.new(fb_guide_color,80) ,border_width=1,
bgcolor=color.new(fb_guide_color,90) )
var fbfb_line_max = line.new (bar_index, close ,bar_index,
fb_pLast, color=fb_guide_color ,width=2)
var fbfb_line_min = line.new (bar_index, close ,bar_index,
var fbfb_box_ext = box.new (bar_index, close ,bar_index,
fb_pLast, border_color=color.new(fb_guide_color,80) ,border_width=0,
bgcolor=color.new(fb_guide_color,70) )
var fbfb_line_ext = line.new (bar_index, close ,bar_index,
//-----------------------------------------------------------------
----------------------------------
box.set_lefttop (fbfb_box_max ,bar_index+fb_label_position-
3 ,_fbr_max_highest)
box.set_rightbottom (fbfb_box_max ,bar_index+fb_label_position-
0 ,_fbr_min_lowest)
//-----------------------------------------------------------------
----------------------------------
line.set_xy1 (fbfb_line_max ,bar_index+fb_label_position-
line.set_xy2 (fbfb_line_max ,bar_index+fb_label_position-
line.set_xy1 (fbfb_line_min ,bar_index+fb_label_position-
3 ,_fbr_min_lowest)
line.set_xy2 (fbfb_line_min ,bar_index+fb_label_position-
0 ,_fbr_min_lowest)
//-----------------------------------------------------------------
----------------------------------
box.set_lefttop (fbfb_box_ext ,bar_index+fb_label_position-
3 ,close)
box.set_rightbottom (fbfb_box_ext ,bar_index+fb_label_position-
1 ,fb_pLast)
//-----------------------------------------------------------------
----------------------------------
line.set_xy1 (fbfb_line_ext ,bar_index+fb_label_position-
3 ,close)
line.set_xy2 (fbfb_line_ext ,bar_index+fb_label_position-
1 ,close)
//---------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------
fb_new = fb_pLast[1] != fb_pLast or fb_new_line or fb_iLast[1] != fb_iLast
table.cell(textstylist, 0, 0, title, widthtata, heighttata, c_title, a_title,
text_size=s_title, bgcolor=c_bg)
//---------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------
fb_over_1618 = false
fb_over_1 = false
fb_over_0786 = false
fb_under_0 = false
fb_under_0382 = false
fb_under_0618 = false
fb_under_m1 = false
//-------------------------
fb_height = line.get_y1(fb_lineLast) - fb_pLast
fb_k_low_cr = ta.lowest (k_low,2)

fb_k_high_cr = ta.highest(k_high,2)
fb_over_1618 := (fb_height < 0 and fb_k_low_cr < (fb_height * 1.618) + fb_pLast

) or (fb_height > 0 and fb_k_high_cr > (fb_height * 1.618) + fb_pLast )
fb_over_1 := (fb_height < 0 and fb_k_low_cr < line.get_y1(fb_lineLast)
) or (fb_height > 0 and fb_k_high_cr > line.get_y1(fb_lineLast) )
fb_over_0786 := (fb_height < 0 and fb_k_low_cr < (fb_height * 0.786) + fb_pLast
) or (fb_height > 0 and fb_k_high_cr > (fb_height * 0.786) + fb_pLast )
fb_under_0 := (fb_height < 0 and fb_k_low_cr > fb_pLast
) or (fb_height > 0 and fb_k_high_cr < fb_pLast )
// fb_under_0382 := (fb_height < 0 and fb_k_low_cr > (fb_height *-0.382) +
fb_pLast ) or (fb_height > 0 and fb_k_high_cr < (fb_height *-0.382) +
fb_pLast )
fb_under_0618 := (fb_height < 0 and fb_k_low_cr > (fb_height *-0.618) + fb_pLast
) or (fb_height > 0 and fb_k_high_cr < (fb_height *-0.618) + fb_pLast )
fb_under_m1 := (fb_height < 0 and fb_k_low_cr > (fb_height *-1 ) + fb_pLast
) or (fb_height > 0 and fb_k_high_cr < (fb_height *-1 ) + fb_pLast )
//---------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------
fb_retracement (fb_under_m1 ,-1.618 ,fb_color1 ,'auto')
fb_retracement (fb_under_0618 ,-1.000 ,fb_color1 ,'auto')
fb_retracement (fb_under_0382 ,-0.618 ,fb_color1 ,'auto')
// fb_retracement (fb_under_0 ,-0.382 ,fb_color1 ,'auto')
// fb_retracement (true ,-0.236 ,fb_color1 ,'auto')
fb_retracement (true , 0.000 ,fb_color4 ,'' )
// fb_retracement (fb236 , 0.236 ,fb_color1 ,'' )
fb_retracement (fb500 , 0.500 ,fb_color3 ,'' )
fb_retracement (true , 1.000 ,fb_color5 ,'' )
// fb_retracement (fb_over_0786 , 1.272 ,fb_color1 ,'auto')
fb_retracement (fb_over_1 , 1.618 ,fb_color2 ,'auto')
fb_retracement (fb_over_1618 , 2.618 ,fb_color2 ,'auto')
import HeWhoMustNotBeNamed/utils/1 as ut
import Trendoscope/ohlc/1 as o
import Trendoscope/LineWrapper/1 as wr
import Trendoscope/ZigzagLite/2 as zg
import Trendoscope/abstractchartpatterns/5 as p
import Trendoscope/basechartpatterns/6 as bp
openSource = input.source(open, '', inline='cs', group='Source', display =
display.none)
highSource = input.source(high, '', inline='cs', group='Source', display =
display.none)
lowSource = input.source(low, '', inline='cs', group='Source', display =
display.none)
closeSource = input.source(close, '', inline='cs', group='Source', display =
display.none, tooltip = 'Source on which the zigzag and pattern calculation is
done')
useZigzag1 = input.bool(true, '', group = 'Zigzag', inline='z1', display =

display.none)
zigzagLength1 = input.int(8, step=5, minval=1, title='', group='Zigzag',
inline='z1', display=display.none)
depth1 = input.int(55, "", step=25, maxval=500, group='Zigzag', inline='z1',
display=display.none, tooltip = 'Enable and set Length and Dept of Zigzag 1')
useZigzag2 = input.bool(false, '', group = 'Zigzag', inline='z2', display =

display.none)

display.none)

display.none)
numberOfPivots = input.int(5, "Number of Pivots", [5, 6], 'Number of pivots used

for pattern identification.', group='Scanning', display = display.none)
errorThresold = input.float(20.0, 'Error Threshold', 0.0, 100, 5, 'Error Threshold
for trend line validation', group='Scanning', display = display.none)
flatThreshold = input.float(20.0, 'Flat Threshold', 0.0, 30, 5, 'Ratio threshold to
identify the slope of trend lines', group='Scanning', display = display.none)
lastPivotDirection = input.string('both', 'Last Pivot Direction', ['up', 'down',
'both', 'custom'], 'Filter pattern based on the last pivot direction. '+
'This option is useful while backtesting individual
patterns. When custom is selected, then the individual pattern last pivot direction
setting is used',
group='Scanning', display=display.none)
checkBarRatio = input.bool(true, 'Verify Bar Ratio ', 'Along with checking the
price, also verify if the bars are proportionately placed.', group='Scanning',
inline = 'br', display = display.none)
barRatioLimit = input.float(0.382, '', group='Scanning', display = display.none,
inline='br')
avoidOverlap = input.bool(true, 'Avoid Overlap', group='Scanning', inline='a',
display = display.none)
repaint = input.bool(false, 'Repaint', 'Avoid Overlap - Will not consider the
pattern if it starts before the end of an existing pattern\n\n'+
'Repaint - Uses real time bars to search for patterns. If
unselected, then only use confirmed bars.',
group='Scanning', inline='a', display = display.none)
allowChannels = input.bool(true, 'Channels', group='Pattern Groups - Geometric

Shapes', display = display.none, inline='g')
allowWedges = input.bool(true, 'Wedge', group='Pattern Groups - Geometric Shapes',
display = display.none, inline='g')
allowTriangles = input.bool(true, 'Triangle', group='Pattern Groups - Geometric
Shapes', display = display.none, inline='g',
tooltip = 'Channels - Trend Lines are parralel to each other creating
equidistance price channels'+
'\n\t- Ascending Channel\n\t- Descending Channel\n\t- Ranging
Channel'+
'\n\nWedges - Trend lines are either converging or diverging
from each other and both the trend lines are moving in the same direction'+
'\n\t- Rising Wedge (Expanding)\n\t- Rising Wedge
(Contracting)\n\t- Falling Wedge (Expanding)\n\t- Falling Wedge (Contracting)'+
'\n\nTriangles - Trend lines are either converging or
diverging from each other and both trend lines are moving in different directions'+
'\n\t- Converging Triangle\n\t- Diverging Triangle\n\t-
Ascending Triangle (Contracting)\n\t- Ascending Triangle (Expanding)\n\t-
Descending Triangle(Contracting)\n\t- Descending Triangle(Expanding)')
allowRisingPatterns = input.bool(true, 'Rising', group='Pattern Groups -

Direction', display = display.none, inline = 'd')
allowFallingPatterns = input.bool(true, 'Falling', group='Pattern Groups -
Direction', display = display.none, inline = 'd')
allowNonDirectionalPatterns = input.bool(true, 'Flat/Bi-Directional',
group='Pattern Groups - Direction', display = display.none, inline = 'd',
tooltip = 'Rising - Either both trend lines are moving up or one trend
line is flat and the other one is moving up.'+
'\n\t- Ascending Channel\n\t- Rising Wedge (Expanding)\n\t-
Rising Wedge (Contracting)\n\t- Ascending Triangle (Expanding)\n\t- Ascending
Triangle (Contracting)'+
'\n\nFalling - Either both trend lines are moving down or one
trend line is flat and the other one is moving down.'+
'\n\t- Descending Channel\n\t- Falling Wedge (Expanding)\n\t-
Falling Wedge (Contracting)\n\t- Descending Triangle (Expanding)\n\t- Descending
Triangle (Contracting)'+
'\n\nFlat/Bi-Directional - Trend Lines move in different
directions or both flat.'+
'\n\t- Ranging Channel\n\t- Converging Triangle\n\t- Diverging
Triangle')
allowExpandingPatterns = input.bool(true, 'Expanding', group='Pattern Groups -

Formation Dynamics', display = display.none, inline = 'f')
allowContractingPatterns = input.bool(true, 'Contracting', group='Pattern Groups -
Formation Dynamics', display = display.none, inline='f')
allowParallelChannels = input.bool(true, 'Parallel', group = 'Pattern Groups -
Formation Dynamics', display = display.none, inline = 'f',
tooltip = 'Expanding - Trend Lines are diverging from each other.'+
'\n\t- Rising Wedge (Expanding)\n\t- Falling Wedge
(Expanding)\n\t- Ascending Triangle (Expanding)\n\t- Descending Triangle
(Expanding)\n\t- Diverging Triangle'+
'\n\nContracting - Trend Lines are converging towards each
other.'+
'\n\t- Rising Wedge (Contracting)\n\t- Falling Wedge
(Contracting)\n\t- Ascending Triangle (Contracting)\n\t- Descending Triangle
(Contracting)\n\t- Converging Triangle'+
'\n\nParallel - Trend Lines are almost parallel to each
other.'+
'\n\t- Ascending Channel\n\t- Descending Channel\n\t- Ranging
Channel')
allowUptrendChannel = input.bool(true, 'Ascending ', group = 'Price Channels',

inline='uc', display = display.none)
upTrendChannelLastPivotDirection = input.string('both', '', ['up', 'down', 'both'],
inline='uc', group='Price Channels', display = display.none,
tooltip='Enable Ascending Channel and select the last pivot direction
filter. Last pivot direction will only be used if the Generic Last Pivot Direction
parameter is set to Custom')
allowDowntrendChannel = input.bool(true, 'Descending', group = 'Price Channels',

inline='dc', display = display.none)
downTrendChannelLastPivotDirection = input.string('both', '', ['up', 'down',
'both'], inline='dc', group='Price Channels', display = display.none,
tooltip='Enable Descending Channel and select the last pivot direction
allowRangingChannel = input.bool(true, 'Ranging ', group = 'Price Channels',

inline='rc', display = display.none)
rangingChannelLastPivotDirection = input.string('both', '', ['up', 'down', 'both'],
inline='rc', group='Price Channels', display = display.none,
tooltip='Enable Ranging Channel and select the last pivot direction
allowRisingWedgeExpanding = input.bool(true, 'Rising ', inline='rwe', group =

'Expanding Wedges', display = display.none)
risingWedgeExpandingLastPivotDirection = input.string('down', '', ['up', 'down',
'both'], inline='rwe', group='Expanding Wedges', display = display.none,
tooltip='Enable Rising Wedge (Expanding) and select the last pivot
direction filter. Last pivot direction will only be used if the Generic Last Pivot
Direction parameter is set to Custom')
allowFallingWedgeExpanding = input.bool(true, 'Falling ', inline='fwe', group =

'Expanding Wedges', display = display.none)
fallingWedgeExpandingLastPivotDirection = input.string('up', '', ['up', 'down',
'both'], inline='fwe', group='Expanding Wedges', display = display.none,
tooltip='Enable Falling Wedge (Expanding) and select the last pivot
allowRisingWedgeContracting = input.bool(true, 'Rising ', inline='rwc', group =

'Contracting Wedges', display = display.none)
risingWedgeContractingLastPivotDirection = input.string('down', '', ['up', 'down',
'both'], inline='rwc', group='Contracting Wedges', display = display.none,
tooltip='Enable Rising Wedge (Contracting) and select the last pivot
allowFallingWedgeContracting = input.bool(true, 'Falling ', inline='fwc', group

= 'Contracting Wedges', display = display.none)
fallingWedgeContractingLastPivotDirection = input.string('up', '', ['up', 'down',
'both'], inline='fwc', group='Contracting Wedges', display = display.none,
tooltip='Enable Falling Wedge (Contracting) and select the last pivot
allowRisingTriangleExpanding = input.bool(true, 'Ascending ', inline='rte', group

= 'Expanding Triangles', display = display.none)
risingTriangleExpandingLastPivotDirection = input.string('up', '', ['up', 'down',
'both'], inline='rte', group='Expanding Triangles', display = display.none,
tooltip='Enable Ascending Triangle (Expanding) and select the last
pivot direction filter. Last pivot direction will only be used if the Generic Last
Pivot Direction parameter is set to Custom')
allowFallingTriangleExpanding = input.bool(true, 'Descending', inline='fte', group

= 'Expanding Triangles', display = display.none)
fallingTriangleExpandingLastPivotDirection = input.string('down', '', ['up',
'down', 'both'], inline='fte', group='Expanding Triangles', display = display.none,
tooltip='Enable Descending Triangle (Expanding) and select the last
allowExpandingTriangle = input.bool(true, 'Diverging ', inline='dt', group =

'Expanding Triangles', display = display.none)
divergineTriangleLastPivotDirection = input.string('both', '', ['up', 'down',
'both'], inline='dt', group='Expanding Triangles', display = display.none,
tooltip='Enable Diverging Triangle and select the last pivot direction
allowRisingTriangleConverging= input.bool(true, 'Ascending ', inline='rtc', group

= 'Contracting Triangles', display = display.none)
risingTriangleContractingLastPivotDirection = input.string('up', '', ['up', 'down',
'both'], inline='rtc', group='Contracting Triangles', display = display.none,
tooltip='Enable Ascending Triangle (Contracting) and select the last
allowFallingTriangleConverging = input.bool(true, 'Descending', inline='ftc', group

= 'Contracting Triangles', display = display.none)
fallingTriangleContractingLastPivotDirection = input.string('down', '', ['up',
'down', 'both'], inline='ftc', group='Contracting Triangles', display =
display.none,
tooltip='Enable Descending Triangle (Contracting) and select the last
allowConvergingTriangle = input.bool(true, 'Converging ', inline='ct', group =

'Contracting Triangles', display = display.none)
convergingTriangleLastPivotDirection = input.string('both', '', ['up', 'down',
'both'], inline='ct', group='Contracting Triangles', display = display.none,
tooltip='Enable Converging Triangle and select the last pivot
allowedPatterns = array.from(
false,
allowUptrendChannel and allowRisingPatterns and allowParallelChannels and
allowChannels,
allowDowntrendChannel and allowFallingPatterns and allowParallelChannels and
allowChannels,
allowRangingChannel and allowNonDirectionalPatterns and allowParallelChannels
and allowChannels,
allowRisingWedgeExpanding and allowRisingPatterns and allowExpandingPatterns
and allowWedges,
allowFallingWedgeExpanding and allowFallingPatterns and allowExpandingPatterns
and allowWedges,
allowExpandingTriangle and allowNonDirectionalPatterns and
allowExpandingPatterns and allowTriangles,
allowRisingTriangleExpanding and allowRisingPatterns and
allowFallingTriangleExpanding and allowFallingPatterns and
allowRisingWedgeContracting and allowRisingPatterns and
allowContractingPatterns and allowWedges,
allowFallingWedgeContracting and allowFallingPatterns and
allowContractingPatterns and allowWedges,
allowConvergingTriangle and allowNonDirectionalPatterns and
allowContractingPatterns and allowTriangles,
allowFallingTriangleConverging and allowFallingPatterns and
allowContractingPatterns and allowTriangles,
allowRisingTriangleConverging and allowRisingPatterns and
allowContractingPatterns and allowTriangles
)
getLastPivotDirectionInt(lastPivotDirection)=>lastPivotDirection == 'up'? 1 :
lastPivotDirection == 'down'? -1 : 0
allowedLastPivotDirections = array.from(
0,
lastPivotDirection == 'custom'?
getLastPivotDirectionInt(upTrendChannelLastPivotDirection) :
getLastPivotDirectionInt(lastPivotDirection),
getLastPivotDirectionInt(downTrendChannelLastPivotDirection) :
getLastPivotDirectionInt(rangingChannelLastPivotDirection) :
getLastPivotDirectionInt(risingWedgeExpandingLastPivotDirection) :
getLastPivotDirectionInt(fallingWedgeExpandingLastPivotDirection) :
getLastPivotDirectionInt(divergineTriangleLastPivotDirection) :
getLastPivotDirectionInt(risingTriangleExpandingLastPivotDirection) :
getLastPivotDirectionInt(fallingTriangleExpandingLastPivotDirection) :
getLastPivotDirectionInt(risingWedgeContractingLastPivotDirection) :
getLastPivotDirectionInt(fallingWedgeContractingLastPivotDirection) :
getLastPivotDirectionInt(convergingTriangleLastPivotDirection) :
getLastPivotDirectionInt(fallingTriangleContractingLastPivotDirection) :
getLastPivotDirectionInt(risingTriangleContractingLastPivotDirection) :
getLastPivotDirectionInt(lastPivotDirection)
)
theme = input.string('Dark', title='Theme', options=['Light', 'Dark'],

group='Display', inline='pc',
tooltip='Chart theme settings. Line and label colors are generted based on
the theme settings. If dark theme is selected, '+
'lighter colors are used and if light theme is selected, darker colors are
used.\n\n'+
'Pattern Line width - to be used for drawing pattern lines',
display=display.none)
patternLineWidth = input.int(2, '', minval=1, inline='pc', group = 'Display',
display = display.none)
showPatternLabel = input.bool(true, 'Pattern Label', inline='pl1', group =

'Display', display = display.none)
patternLabelSize = input.string(size.normal, '', [size.tiny, size.small,
size.normal, size.large, size.huge], inline='pl1', group = 'Display', display =
display.none,
tooltip = 'Option to display Pattern Label and select the
size')
showPivotLabels = input.bool(true, 'Pivot Labels ', inline='pl2', group =

'Display', display = display.none, tooltip = 'Option to display pivot labels and
select the size')
pivotLabelSize = input.string(size.normal, '', [size.tiny, size.small, size.normal,
size.large, size.huge], inline='pl2', group = 'Display', display = display.none)
showZigzag = input.bool(true, 'Zigzag', inline='z', group = 'Display', display =

display.none)
zigzagColor = input.color(color.blue, '', inline='z', group = 'Display', display =
display.none, tooltip = 'Option to display zigzag within pattern and the default
zigzag line color')
deleteOldPatterns = input.bool(true, 'Max Patterns', inline='do', group =

'Display', display = display.none)
maxPatterns = input.int(20, '', minval=1, step=5, inline = 'do', group = 'Display',
display = display.none, tooltip = 'If selected, only last N patterns will be
preserved on the chart.')
errorRatio = errorThresold/100
flatRatio = flatThreshold/100
showLabel = true
offset = 0
type Scanner
bool enabled
string ticker
string timeframe
p.ScanProperties sProperties
p.DrawingProperties dProperties
array<p.Pattern> patterns
array<zg.Zigzag> zigzags
method getZigzagAndPattern(Scanner this, int length, int depth, array<o.OHLC>

ohlcArray, int offset=0)=>
var zg.Zigzag zigzag = zg.Zigzag.new(length, depth, 0)
var map<int, int> lastDBar = map.new<int, int>()
zigzag.calculate(array.from(highSource, lowSource))
var validPatterns = 0
mlzigzag = zigzag
if(zigzag.flags.newPivot)
while(mlzigzag.zigzagPivots.size() >= 6+offset)
lastBar = mlzigzag.zigzagPivots.first().point.index
lastDir = int(math.sign(mlzigzag.zigzagPivots.first().dir))
if(lastDBar.contains(mlzigzag.level)? lastDBar.get(mlzigzag.level) <
lastBar : true)
lastDBar.put(mlzigzag.level, lastBar)
[valid, currentPattern] = mlzigzag.find(this.sProperties,
this.dProperties, this.patterns, ohlcArray)
if(valid)
validPatterns+=1
currentPattern.draw()
this.patterns.push(currentPattern, maxPatterns)
alert('New Pattern Alert')
else
break
mlzigzag := mlzigzag.nextlevel()
true
method scan(Scanner this)=>

var array<o.OHLC> ohlcArray = array.new<o.OHLC>()
var array<p.Pattern> patterns = array.new<p.Pattern>()
ohlcArray.push(o.OHLC.new(openSource, highSource, lowSource, closeSource))
if(useZigzag1)
this.getZigzagAndPattern(zigzagLength1, depth1, ohlcArray)
if(useZigzag2)
if(useZigzag3)
if(useZigzag4)
var scanner = Scanner.new(true, "", "",
p.ScanProperties.new(offset, numberOfPivots, errorRatio, flatRatio,
checkBarRatio, barRatioLimit, avoidOverlap, allowedPatterns=allowedPatterns,
allowedLastPivotDirections= allowedLastPivotDirections, themeColors =
ut.getColors(theme)),
p.DrawingProperties.new(patternLineWidth, showZigzag, 1, zigzagColor,
showPatternLabel, patternLabelSize, showPivotLabels, pivotLabelSize, deleteOnPop =
deleteOldPatterns),
array.new<p.Pattern>())
if(barstate.isconfirmed or repaint)
scanner.scan()
// Get user input

sensitivity = input.float(5.5, "Sensitivity (0.5 - 12)", 0.5, 12, step=0.05, group
= 'Settings')
ShowSmartTrail = input.bool(true, 'Smart Trail ', inline = 'overlayLine1',

group = 'Settings')
maj = input(true, title='TP Points', inline = 'overlayLine1', group = 'Settings')
show_ha = input.bool(false, 'Trend Tracker', inline = 'overlayLine2', group =

'Settings')
usePsar = input.bool(false, 'PSAR', inline = 'overlayLine3', group =

'Settings')
Show_rangefilter = input.bool(true, 'Range Filter', inline = 'overlayLine4', group

= 'Settings')
// Functions
supertrend(_src, factor, atrLen) =>
atrat = ta.atr(atrLen)
upperBand = _src + factor * atrat
lowerBand = _src - factor * atrat
prevLowerBand = nz(lowerBand[1])
prevUpperBand = nz(upperBand[1])
lowerBand := lowerBand > prevLowerBand or close[1] < prevLowerBand ?
lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or close[1] > prevUpperBand ?
upperBand : prevUpperBand
int direction = na
float superTrend = na
prevSuperTrend = superTrend[1]
if na(atrat[1])
direction := 1
else if prevSuperTrend == prevUpperBand
direction := close > upperBand ? -1 : 1
else
direction := close < lowerBand ? 1 : -1
superTrend := direction == -1 ? lowerBand : upperBand
[superTrend, direction]
// Get Components
ocAvg = math.avg(open, close)
ema1 = ta.ema(high, 9)
sma1 = ta.sma(close, 5)
psar = ta.sar(0.02, 0.02, 0.2)
[supertrend, direction] = supertrend(close, sensitivity, 11)
barsL = 10
barsR = 10
pivotHigh = fixnan(ta.pivothigh(barsL, barsR)[1])
pivotLow = fixnan(ta.pivotlow(barsL, barsR)[1])
// Colors
green = #04994b, green2 = #15c02a
red = #b4060d, red2 = #ff0002
p5 = plot(ocAvg, "", na, editable=false)

p6 = plot(psar, "PSAR", usePsar ? (psar < ocAvg ? green : red) : na, 1,
plot.style_circles, editable=false)
fill(p5, p6, usePsar ? (psar < ocAvg ? color.new(green, 90) : color.new(red, 90)) :
na, editable=false)
y1 = low - (ta.atr(30) * 2)
y2 = high + (ta.atr(30) * 2)
bull = ta.crossover(close, supertrend) and close >= sma9
bear = ta.crossunder(close, supertrend) and close <= sma9
buy = bull ? label.new(bar_index, y1, "▲", xloc.bar_index, yloc.price, #04994b,
label.style_label_up, color.white, size.normal) : na
sell = bear ? label.new(bar_index, y2, "▼", xloc.bar_index, yloc.price, #b4060d,
label.style_label_down, color.white, size.normal) : na
// Strong TP Points //
maj_qual = 13
maj_len = 40
min_qual = 5
min_len = 5
min = false
selll = 0.0
buyy = 0.0
lele(qual, len) =>

bindex = 0.0
sindex = 0.0
bindex := nz(bindex[1], 0)
sindex := nz(sindex[1], 0)
ret = 0
if close > close[4]
bindex += 1
bindex
if close < close[4]
sindex += 1
sindex
if bindex > qual and close < open and high >= ta.highest(high, len)
bindex := 0
ret := -1
ret
if sindex > qual and close > open and low <= ta.lowest(low, len)
sindex := 0
ret := 1
ret
return_1 = ret
return_1
major = lele(maj_qual, maj_len)

minor = lele(min_qual, min_len)
if minor == -1 and min == true

selll := 1
selll
if major == -1 and maj == true
selll := 2
selll
if major == -1 and maj == true and minor == -1 and min == true
selll := 3
selll
if minor == 1 and min == true

buyy := 1
buyy
if major == 1 and maj == true
buyy := 2
buyy
if major == 1 and maj == true and minor == 1 and min == true
buyy := 3
buyy
plotshape(selll == 2, style=shape.xcross, location=location.abovebar,

color=color.new(#354996, 0), textcolor=color.new(color.white, 0), offset=0)
plotshape(buyy == 2, style=shape.xcross, location=location.belowbar,

color=color.new(#354996, 0), textcolor=color.new(color.white, 0), offset=0)
// Ha Market Bias //
tf(_res, _exp, gaps_on) =>

gaps_on == 0 ? request.security(syminfo.tickerid, _res, _exp) : gaps_on == true
? request.security(syminfo.tickerid, _res, _exp, barmerge.gaps_on,
barmerge.lookahead_off) : request.security(syminfo.tickerid, _res, _exp,
barmerge.gaps_off, barmerge.lookahead_off)
ha_htf = ''
ha_len = 100
ha_len2 = 100
// Calculations {
o = ta.ema(open, ha_len)
c = ta.ema(close, ha_len)
h = ta.ema(high, ha_len)
l = ta.ema(low, ha_len)
haclose = tf(ha_htf, (o + h + l + c) / 4, 0)
xhaopen = tf(ha_htf, (o + c) / 2, 0)
haopen = na(xhaopen[1]) ? (o + c) / 2 : (xhaopen[1] + haclose[1]) / 2
hahigh = math.max(h, math.max(haopen, haclose))
halow = math.min(l, math.min(haopen, haclose))
o2 = tf(ha_htf, ta.ema(haopen, ha_len2), 0)

c2 = tf(ha_htf, ta.ema(haclose, ha_len2), 0)
h2 = tf(ha_htf, ta.ema(hahigh, ha_len2), 0)
l2 = tf(ha_htf, ta.ema(halow, ha_len2), 0)
ha_avg = (h2 + l2) / 2

// }
// Oscillator {
osc_len = 7
osc_bias = 100 *(c2 - o2)

osc_smooth = ta.ema(osc_bias, osc_len)
sigcolor =
(osc_bias > 0) and (osc_bias >= osc_smooth) ? color.new(color.lime, 35) :
(osc_bias > 0) and (osc_bias < osc_smooth) ? color.new(color.lime, 75) :
(osc_bias < 0) and (osc_bias <= osc_smooth) ? color.new(color.red, 35) :
(osc_bias < 0) and (osc_bias > osc_smooth) ? color.new(color.red, 75) :
na
// }
// Plots {
p_h = plot(h2, "Bias High", color=color(na), display=display.none, editable=false)
p_l = plot(l2, "Bias Low", color=color(na), display=display.none, editable=false)
p_avg = plot(ha_avg, "Bias Avergae", color=color(na), display=display.none,
editable=false)
fill(p_l, p_h, show_ha ? sigcolor : na)

col = o2 > c2 ? color.red : color.lime
// }
// Range Filter DW
//---------------------Range
Filter-----------------------------------------------------------------------------
-----------------------------------------
//Conditional Sampling EMA Function

Cond_EMA(x, cond, n) =>
var val = array.new_float(0)
var ema_val = array.new_float(1)
if cond
array.push(val, x)
if array.size(val) > 1
array.remove(val, 0)
if na(array.get(ema_val, 0))
array.fill(ema_val, array.get(val, 0))
array.set(ema_val, 0, (array.get(val, 0) - array.get(ema_val, 0)) * (2 / (n
+ 1)) + array.get(ema_val, 0))
EMA = array.get(ema_val, 0)
EMA
//Conditional Sampling SMA Function

Cond_SMA(x, cond, n) =>
var vals = array.new_float(0)
if cond
array.push(vals, x)
if array.size(vals) > n
array.remove(vals, 0)
SMA = array.avg(vals)
SMA
//Standard Deviation Function

Stdev(x, n) =>
math.sqrt(Cond_SMA(math.pow(x, 2), 1, n) - math.pow(Cond_SMA(x, 1, n), 2))
//Range Size Function

table.cell(textstylist, 0, 1, subtitle, widthtata, heighttata, c_subtitle,
a_subtitle, text_size=s_subtitle, bgcolor=c_bg)
rng_size(x, scale, qty, n) =>
ATR = Cond_EMA(ta.tr(true), 1, n)
AC = Cond_EMA(math.abs(x - x[1]), 1, n)
SD = Stdev(x, n)
rng_size = scale == 'Pips' ? qty * 0.0001 : scale == 'Points' ? qty *
syminfo.pointvalue : scale == '% of Price' ? close * qty / 100 : scale == 'ATR' ?
qty * ATR : scale == 'Average Change' ? qty * AC : scale == 'Standard Deviation' ?
qty * SD : scale == 'Ticks' ? qty * syminfo.mintick : qty
rng_size
//Two Type Range Filter Function

rng_filt(h, l, rng_, n, type, smooth, sn, av_rf, av_n) =>
rng_smooth = Cond_EMA(rng_, 1, sn)
r = smooth ? rng_smooth : rng_
var rfilt = array.new_float(2, (h + l) / 2)
array.set(rfilt, 1, array.get(rfilt, 0))
if type == 'Type 1'
if h - r > array.get(rfilt, 1)
array.set(rfilt, 0, h - r)
if l + r < array.get(rfilt, 1)
array.set(rfilt, 0, l + r)
if type == 'Type 2'
if h >= array.get(rfilt, 1) + r
array.set(rfilt, 0, array.get(rfilt, 1) + math.floor(math.abs(h -
array.get(rfilt, 1)) / r) * r)
if l <= array.get(rfilt, 1) - r
array.set(rfilt, 0, array.get(rfilt, 1) - math.floor(math.abs(l -
array.get(rfilt, 1)) / r) * r)
rng_filt1 = array.get(rfilt, 0)
hi_band1 = rng_filt1 + r
lo_band1 = rng_filt1 - r
rng_filt2 = Cond_EMA(rng_filt1, rng_filt1 != rng_filt1[1], av_n)
hi_band2 = Cond_EMA(hi_band1, rng_filt1 != rng_filt1[1], av_n)
lo_band2 = Cond_EMA(lo_band1, rng_filt1 != rng_filt1[1], av_n)
rng_filt = av_rf ? rng_filt2 : rng_filt1
hi_band = av_rf ? hi_band2 : hi_band1
lo_band = av_rf ? lo_band2 : lo_band1
[hi_band, lo_band, rng_filt]
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Inputs
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Filter Type
f_type = 'Type 2'
//Movement Source
mov_src = 'Close'
//Range Size Inputs

rng_qty = 2.618
rng_scale = 'Average Change'
//Range Period
rng_per = 14
//Range Smoothing Inputs

smooth_range = true
smooth_per = 27
//Filter Value Averaging Inputs

av_vals = false
av_samples = 2
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Definitions
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//High And Low Values

h_val = mov_src == 'Wicks' ? high : close
l_val = mov_src == 'Wicks' ? low : close
//Range Filter Values

[h_band, l_band, filt] = rng_filt(h_val, l_val, rng_size((h_val + l_val) / 2,
rng_scale, rng_qty, rng_per), rng_per, f_type, smooth_range, smooth_per, av_vals,
av_samples)
//Direction Conditions
var fdir = 0.0
fdir := filt > filt[1] ? 1 : filt < filt[1] ? -1 : fdir
upward = fdir == 1 ? 1 : 0
downward = fdir == -1 ? 1 : 0
//Colors
filt_color = upward ? #36db7f : downward ? #be130f : #cccccc
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Outputs
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Filter Plot
filt_plot = plot(Show_rangefilter ? filt : na, color=filt_color, linewidth=3,
title='Filter', transp=0)
//Bar Color
//External Trend Output

plot(fdir, editable=false, display=display.none, title='External Output - Trend
Signal', transp=100)
// Smart Trail
trailType = input.string('modified', 'Trailtype', options=['modified',
'unmodified'])
ATRPeriod = input(13, 'ATR Period')
ATRFactor = input(4, 'ATR Factor')
smoothing = input(8, 'Smoothing')
norm_o = request.security(ticker.new(syminfo.prefix, syminfo.ticker),

timeframe.period, open)
norm_h = request.security(ticker.new(syminfo.prefix, syminfo.ticker),
timeframe.period, high)
norm_l = request.security(ticker.new(syminfo.prefix, syminfo.ticker),
timeframe.period, low)
norm_c = request.security(ticker.new(syminfo.prefix, syminfo.ticker),
timeframe.period, close)
//}
//////// FUNCTIONS //////////////

//{
// Wilders ma //
Wild_ma(_src, _malength) =>
_wild = 0.0
_wild := nz(_wild[1]) + (_src - nz(_wild[1])) / _malength
_wild
/////////// TRUE RANGE CALCULATIONS /////////////////

HiLo = math.min(norm_h - norm_l, 1.5 * nz(ta.sma(norm_h - norm_l, ATRPeriod)))
HRef = norm_l <= norm_h[1] ? norm_h - norm_c[1] : norm_h - norm_c[1] - 0.5 *

(norm_l - norm_h[1])
LRef = norm_h >= norm_l[1] ? norm_c[1] - norm_l : norm_c[1] - norm_l - 0.5 *

(norm_l[1] - norm_h)
trueRange = trailType == 'modified' ? math.max(HiLo, HRef, LRef) : math.max(norm_h

- norm_l, math.abs(norm_h - norm_c[1]), math.abs(norm_l - norm_c[1]))
//}
/////////// TRADE LOGIC ////////////////////////

//{
loss = ATRFactor * Wild_ma(trueRange, ATRPeriod)
Up = norm_c - loss
Dn = norm_c + loss
TrendUp = Up
TrendDown = Dn
Trend = 1
TrendUp := norm_c[1] > TrendUp[1] ? math.max(Up, TrendUp[1]) : Up

TrendDown := norm_c[1] < TrendDown[1] ? math.min(Dn, TrendDown[1]) : Dn
Trend := norm_c > TrendDown[1] ? 1 : norm_c < TrendUp[1] ? -1 : nz(Trend[1], 1)

trail = Trend == 1 ? TrendUp : TrendDown
ex = 0.0
ex := ta.crossover(Trend, 0) ? norm_h : ta.crossunder(Trend, 0) ? norm_l : Trend ==
1 ? math.max(ex[1], norm_h) : Trend == -1 ? math.min(ex[1], norm_l) : ex[1]
//}
// //////// PLOT TP and SL /////////////
////// FIBONACCI LEVELS ///////////

//{
state = Trend == 1 ? 'long' : 'short'
fib1Level = 61.8
fib2Level = 78.6
fib3Level = 88.6
f1 = ex + (trail - ex) * fib1Level / 100

l100 = trail + 0
fill(plot(ShowSmartTrail ? (ta.sma(trail, smoothing)) : na, 'Trailingstop',

style=plot.style_line, color=Trend == 1 ? color.new(#2157f9, 0) : Trend == -1 ?
color.new(#ff1100, 0) : na),
plot( ShowSmartTrail ? (ta.sma(f2, smoothing)) : na, 'Fib 2',
style=plot.style_line, display=display.none),
color=state == 'long' ? color.new(#2157f9, 80) : state == 'short' ?
color.new(#ff1100, 80) : na)
//}
// Candle Coloring
// Input
fastLength = input(title="Fast Length", defval=12)
slowLength = input(title="Slow Length", defval=26)
srrrc = input(title="Source", defval=close)
signalLength = input.int(title="Signal Smoothing", minval = 1, maxval = 50, defval
= 9)
// Data reference
[macd, signal, hist] = ta.macd(srrrc, fastLength, slowLength, signalLength)
// 4 level of green
greenHigh = #05df09
greenMidHigh = #05df09
greenMidLow = #388E3C
greenLow = #5f3a97
// Yellow
yellowLow = #5f3a97
// 4 level of red
redHigh = #ea0402
redMidHigh = #ea0402
redMidLow = #cc0402
redLow = #5f3a97
// Default color
candleBody = yellowLow
// Ranging trend
if hist > 0
if hist > hist[1] and hist[1] > 0
candleBody := greenLow
if hist < 0
if hist < hist[1] and hist[1] < 0
candleBody := redLow
// Bullish trend
if macd > 0 and hist > 0
candleBody := greenMidLow
if hist > hist[1] and macd[1] > 0 and hist[1] > 0

candleBody := greenMidHigh
if hist > hist[2] and macd[2] > 0 and hist[2] > 0

candleBody := greenHigh
// Bearish trend
if macd < 0 and hist < 0
candleBody := redMidLow
if hist < hist[1] and macd[1] < 0 and hist[1] < 0

candleBody := redMidHigh
if hist < hist[2] and macd[2] < 0 and hist[2] < 0

candleBody := redHigh
barcolor(candleBody) // Include suggestion by Shaheen204

AlgoPoint_PA_Toolkit_V1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AlgoPoint_PA_Toolkit_V1

Uploaded by

Copyright:

Available Formats

//

show_swing_ms = input.string ("All"

i_ms_up_BOS = input.color (#089981

lvl_daily = input.bool (false

ob_show = input.bool (true

show_acc_dist_zone = input.bool (false

show_lbl = input.bool (false

fvg_enable = input.bool (false

var user_consensus = input.string(defval="", title="By going to

alerts blalert = alerts.new()

b.c > b.o => boolean.set(green_candle, true)

f_zscore(src, lookback) =>

(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)

var int iLen = internal_r_lookback

vv = f_zscore(((close - close[iLen]) / close[iLen]) * 100,iLen)

vv >= 1.5 or vv <= -1.5 => iLen := 10

var msline = array.new<line>(0)

iH = ta.pivothigh(high, iLen, iLen)

hl () => [high, low]

[pdh, pdl] = request.security(syminfo.tickerid , 'D' , hl() , lookahead =

out = switch style

mtfphl(h, l ,tf ,css, pdhl_style) =>

var line hl = line.new(

var line ll = line.new(

var label lbl = label.new(

var label hlb = label.new(

extension = time + (time - time[1]) * 50

mtfphl(pdh , pdl , 'D' , css_d, s_d)

mtfphl(pwh , pwl , 'W' , css_w, s_w)

mtfphl(pmh , pml, 'M' , css_m, s_m)

mtfphl(pyh , pyl , '12M', css_y, s_y)

method darkcss(color css, float factor, bool bull) =>

blue = color.b(css) * (1 - factor)

color.rgb(red, green, blue, 0)

method f_line(msDraw d, size, style) =>

if msline.size() >= 250

structure(bool mtf) =>

bool isdrw = false

var color css = na

var int itrend = 0

bool bull_ob = false

bool s_bull_ob = false

var ms sup = ms.new(

var ms sdn = ms.new(

"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) ,

"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ),

// INTERNAL BULLISH STRUCTURE

not CHoCH =>

if boolean.get(i_BOS) and mtf == false and na(drw)

dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch

txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" :

if (dn.l.first() > dn.l.get(1) ?

ob_filter == "None" =>

// INTERNAL BEARISH STRUCTURE

not CHoCH =>

if boolean.get(i_BOS) and mtf == false and na(drw)

if up.l.first() < up.l.get(1)

if (up.l.first() < up.l.get(1) ?

ob_filter == "None" =>

// SWING BULLISH STRUCTURE

not CHoCH =>

if boolean.get(s_BOS) and mtf == false and na(drw)

if sdn.l.first() > sdn.l.get(1)

txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" :