Rating for each momentMoment Score Labels is a Pine v5 overlay indicator that shows momentum “ratings” (0–100) directly on the chart. It prints a vertical score label on every candle (rolling window to avoid label limits) and adds vertical SETUP/ENTRY/EXIT markers for both long and short signals. Signals are based on a weighted mix of trend (MA alignment + slope), momentum (RSI + MACD histogram), breakout (Donchian high/low), and volatility contraction, with an optional Daily regime filter and optional volume/breakout confirmations.
Buscar en scripts para "daily"
Volume Profiles on Weekly TWAP and Zscore ColoringThis indicator takes (DeadCats) volume profile and starts a new profile when price reaches a new Weekly TWAP line or deviation line.
The candles are also colored by Z score based on the 5 deviations from the Daily TWAP, which is anchored from previous days settlement time, 14:59:30CT. The max number of deviations can be changed in the settings to change the sensitivity of the z score coloring.
Khango's Key//@version=5
//@sbtnc thank you for doing the base code
//Added additional levels for convienience sake.
indicator('Key Levels SpacemanBTC IDWM', shorttitle='Khangos Key', overlay=true, max_lines_count=100)
//35 works
displayStyle = input.string(defval='Standard', title='Display Style', options= , inline='Display')
mergebool = input.bool(defval=true, title='Merge Levels?', inline='Display')
distanceright = input.int(defval=30, title='Distance', minval=5, maxval=500, inline='Dist')
radistance = input.int(defval=250, title='Anchor Distance', minval=5, maxval=500, inline='Dist')
labelsize = input.string(defval='Medium', title='Text Size', options= )
linesize = input.string(defval='Small', title='Line Width', options= , inline='Line')
linestyle = input.string(defval='Solid', title='Line Style', options= , inline='Line')
GlobalTextType = input.bool(defval=false, title='Global Text ShortHand', tooltip='Enable for shorthand text on all text')
var globalcoloring = input.bool(defval=false, title='Global Coloring', tooltip='Enable for all color controls via one color', inline='GC')
GlobalColor = input.color(title='', defval=color.white, inline='GC')
//var show_tails = input(defval = false, title = "Always Show", type = input.bool)
= request.security(syminfo.tickerid, 'D', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'D', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'D', [time , low ], lookahead=barmerge.lookahead_on)
cdailyh_open = request.security(syminfo.tickerid, 'D', high, lookahead=barmerge.lookahead_on)
cdailyl_open = request.security(syminfo.tickerid, 'D', low, lookahead=barmerge.lookahead_on)
var monday_time = time
var monday_high = high
var monday_low = low
= request.security(syminfo.tickerid, 'W', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'W', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'W', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', [time , low ], lookahead=barmerge.lookahead_on)
//------------------------------ Inputs -------------------------------
var is_intra_enabled = input.bool(defval=false, title='Open', group='4H', inline='4H')
var is_intrarange_enabled = input.bool(defval=false, title='Prev H/L', group='4H', inline='4H')
var is_intram_enabled = input.bool(defval=false, title='Prev Mid', group='4H', inline='4H')
IntraTextType = input.bool(defval=false, title='ShortHand', group='4H', inline='4Hsh')
var is_daily_enabled = input.bool(defval=true, title='Open', group='Daily', inline='Daily')
var is_dailyrange_enabled = input.bool(defval=false, title='Prev H/L', group='Daily', inline='Daily')
var is_dailym_enabled = input.bool(defval=false, title='Prev Mid', group='Daily', inline='Daily')
DailyTextType = input.bool(defval=false, title='ShortHand', group='Daily', inline='Dailysh')
var is_monday_enabled = input.bool(defval=true, title='Range', group='Monday Range', inline='Monday')
var is_monday_mid = input.bool(defval=true, title='Mid', group='Monday Range', inline='Monday')
var untested_monday = false
MondayTextType = input.bool(defval=false, title='ShortHand', group='Monday Range', inline='Mondaysh')
var is_weekly_enabled = input.bool(defval=true, title='Open', group='Weekly', inline='Weekly')
var is_weeklyrange_enabled = input.bool(defval=true, title='Prev H/L', group='Weekly', inline='Weekly')
var is_weekly_mid = input.bool(defval=true, title='Prev Mid', group='Weekly', inline='Weekly')
WeeklyTextType = input.bool(defval=false, title='ShortHand', group='Weekly', inline='Weeklysh')
var is_monthly_enabled = input.bool(defval=true, title='Open', group='Monthly', inline='Monthly')
var is_monthlyrange_enabled = input.bool(defval=true, title='Prev H/L', group='Monthly', inline='Monthly')
var is_monthly_mid = input.bool(defval=true, title='Prev Mid', group='Monthly', inline='Monthly')
MonthlyTextType = input.bool(defval=false, title='ShortHand', group='Monthly', inline='Monthlysh')
var is_quarterly_enabled = input.bool(defval=true, title='Open', group='Quarterly', inline='Quarterly')
var is_quarterlyrange_enabled = input.bool(defval=false, title='Prev H/L', group='Quarterly', inline='Quarterly')
var is_quarterly_mid = input.bool(defval=true, title='Prev Mid', group='Quarterly', inline='Quarterly')
QuarterlyTextType = input.bool(defval=false, title='ShortHand', group='Quarterly', inline='Quarterlysh')
var is_yearly_enabled = input.bool(defval=true, title='Open', group='Yearly', inline='Yearly')
var is_yearlyrange_enabled = input.bool(defval=false, title='Current H/L', group='Yearly', inline='Yearly')
var is_yearly_mid = input.bool(defval=true, title='Mid', group='Yearly', inline='Yearly')
YearlyTextType = input.bool(defval=false, title='ShortHand', group='Yearly', inline='Yearlysh')
var is_londonrange_enabled = input.bool(defval=false, title='London Range', group='FX Sessions', inline='FX')
var is_usrange_enabled = input.bool(defval=false, title='New York Range', group='FX Sessions', inline='FX')
var is_asiarange_enabled = input.bool(defval=false, title='Asia Range', group='FX Sessions', inline='FX')
SessionTextType = input.bool(defval=false, title='ShortHand', group='FX Sessions', inline='FXColor')
Londont = input.session("0800-1600", "London Session")
USt = input.session("1400-2100", "New York Session")
Asiat = input.session("0000-0900", "Tokyo Session")
DailyColor = input.color(title='', defval=#08bcd4, group='Daily', inline='Dailysh')
MondayColor = input.color(title='', defval=color.white, group='Monday Range', inline='Mondaysh')
WeeklyColor = input.color(title='', defval=#fffcbc, group='Weekly', inline='Weeklysh')
MonthlyColor = input.color(title='', defval=#08d48c, group='Monthly', inline='Monthlysh')
YearlyColor = input.color(title='', defval=color.red, group='Yearly', inline='Yearlysh')
quarterlyColor = input.color(title='', defval=color.red, group='Quarterly', inline='Quarterlysh')
IntraColor = input.color(title='', defval=color.orange, group='4H', inline='4Hsh')
LondonColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
USColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
AsiaColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
var pdhtext = GlobalTextType or DailyTextType ? 'PDH' : 'Prev Day High'
var pdltext = GlobalTextType or DailyTextType ? 'PDL' : 'Prev Day Low'
var dotext = GlobalTextType or DailyTextType ? 'DO' : 'Daily Open'
var pdmtext = GlobalTextType or DailyTextType ? 'PDM' : 'Prev Day Mid'
var pwhtext = GlobalTextType or WeeklyTextType ? 'PWH' : 'Prev Week High'
var pwltext = GlobalTextType or WeeklyTextType ? 'PWL' : 'Prev Week Low'
var wotext = GlobalTextType or WeeklyTextType ? 'WO' : 'Weekly Open'
var pwmtext = GlobalTextType or WeeklyTextType ? 'PWM' : 'Prev Week Mid'
var pmhtext = GlobalTextType or MonthlyTextType ? 'PMH' : 'Prev Month High'
var pmltext = GlobalTextType or MonthlyTextType ? 'PML' : 'Prev Month Low'
var motext = GlobalTextType or MonthlyTextType ? 'MO' : 'Monthly Open'
var pmmtext = GlobalTextType or MonthlyTextType ? 'PMM' : 'Prev Month Mid'
var pqhtext = GlobalTextType or QuarterlyTextType ? 'PQH' : 'Prev Quarter High'
var pqltext = GlobalTextType or QuarterlyTextType ? 'PQL' : 'Prev Quarter Low'
var qotext = GlobalTextType or QuarterlyTextType ? 'QO' : 'Quarterly Open'
var pqmtext = GlobalTextType or QuarterlyTextType ? 'PQM' : 'Prev Quarter Mid'
var cyhtext = GlobalTextType or YearlyTextType ? 'CYH' : 'Current Year High'
var cyltext = GlobalTextType or YearlyTextType ? 'CYL' : 'Current Year Low'
var yotext = GlobalTextType or YearlyTextType ? 'YO' : 'Yearly Open'
var cymtext = GlobalTextType or YearlyTextType ? 'CYM' : 'Current Year Mid'
var pihtext = GlobalTextType or IntraTextType ? 'P-4H-H' : 'Prev 4H High'
var piltext = GlobalTextType or IntraTextType ? 'P-4H-L' : 'Prev 4H Low'
var iotext = GlobalTextType or IntraTextType ? '4H-O' : '4H Open'
var pimtext = GlobalTextType or IntraTextType ? 'P-4H-M' : 'Prev 4H Mid'
var pmonhtext = GlobalTextType or MondayTextType ? 'MDAY-H' : 'Monday High'
var pmonltext = GlobalTextType or MondayTextType ? 'MDAY-L' : 'Monday Low'
var pmonmtext = GlobalTextType or MondayTextType ? 'MDAY-M' : 'Monday Mid'
var lhtext = GlobalTextType or SessionTextType ? 'Lon-H' : 'London High'
var lltext = GlobalTextType or SessionTextType ? 'Lon-L' : 'London Low'
var lotext = GlobalTextType or SessionTextType ? 'Lon-O' : 'London Open'
var ushtext = GlobalTextType or SessionTextType ? 'NY-H' : 'New York High'
var usltext = GlobalTextType or SessionTextType ? 'NY-L' : 'New York Low'
var usotext = GlobalTextType or SessionTextType ? 'NY-O' : 'New York Open'
var asiahtext = GlobalTextType or SessionTextType ? 'AS-H' : 'Asia High'
var asialtext = GlobalTextType or SessionTextType ? 'AS-L' : 'Asia Low'
var asiaotext = GlobalTextType or SessionTextType ? 'AS-O' : 'Asia Open'
if globalcoloring == true
DailyColor := GlobalColor
MondayColor := GlobalColor
WeeklyColor := GlobalColor
MonthlyColor := GlobalColor
YearlyColor := GlobalColor
quarterlyColor := GlobalColor
IntraColor := GlobalColor
IntraColor
if weekly_time != weekly_time
untested_monday := false
untested_monday
if is_monday_enabled == true and untested_monday == false
untested_monday := true
monday_time := daily_time
monday_high := cdailyh_open
monday_low := cdailyl_open
monday_low
linewidthint = 1
if linesize == 'Small'
linewidthint := 1
linewidthint
if linesize == 'Medium'
linewidthint := 2
linewidthint
if linesize == 'Large'
linewidthint := 3
linewidthint
var DEFAULT_LINE_WIDTH = linewidthint
var DEFAULT_TAIL_WIDTH = linewidthint
fontsize = size.small
if labelsize == 'Small'
fontsize := size.small
fontsize
if labelsize == 'Medium'
fontsize := size.normal
fontsize
if labelsize == 'Large'
fontsize := size.large
fontsize
linestyles = line.style_solid
if linestyle == 'Dashed'
linestyles := line.style_dashed
linestyles
if linestyle == 'Dotted'
linestyles := line.style_dotted
linestyles
var DEFAULT_LABEL_SIZE = fontsize
var DEFAULT_LABEL_STYLE = label.style_none
var DEFAULT_EXTEND_RIGHT = distanceright
London = time(timeframe.period, Londont)
US = time(timeframe.period, USt)
Asia = time(timeframe.period, Asiat)
var clondonhigh = 0.0
var clondonlow = close
var londontime = time
var flondonhigh = 0.0
var flondonlow = 0.0
var flondonopen = 0.0
var onelondonfalse = false
if London
if high > clondonhigh
clondonhigh := high
clondonhigh
if low < clondonlow
clondonlow := low
clondonlow
if onelondonfalse
londontime := time
flondonopen := open
flondonopen
flondonhigh := clondonhigh
flondonlow := clondonlow
onelondonfalse := false
onelondonfalse
else
if onelondonfalse == false
flondonhigh := clondonhigh
flondonlow := clondonlow
flondonlow
onelondonfalse := true
clondonhigh := 0.0
clondonlow := close
clondonlow
//////////////////////////////////
var cushigh = 0.0
var cuslow = close
var ustime = time
var fushigh = 0.0
var fuslow = 0.0
var fusopen = 0.0
var oneusfalse = false
if US
if high > cushigh
cushigh := high
cushigh
if low < cuslow
cuslow := low
cuslow
if oneusfalse
ustime := time
fusopen := open
fusopen
fushigh := cushigh
fuslow := cuslow
oneusfalse := false
oneusfalse
else
if oneusfalse == false
fushigh := cushigh
fuslow := cuslow
fuslow
oneusfalse := true
cushigh := 0.0
cuslow := close
cuslow
//////////////////////////////////
var casiahigh = 0.0
var casialow = close
var asiatime = time
var fasiahigh = 0.0
var fasialow = 0.0
var fasiaopen = 0.0
var oneasiafalse = false
if Asia
if high > casiahigh
casiahigh := high
casiahigh
if low < casialow
casialow := low
casialow
if oneasiafalse
asiatime := time
fasiaopen := open
fasiaopen
fasiahigh := casiahigh
fasialow := casialow
oneasiafalse := false
oneasiafalse
else
if oneasiafalse == false
fasiahigh := casiahigh
fasialow := casialow
fasialow
oneasiafalse := true
casiahigh := 0.0
casialow := close
casialow
//------------------------------ Plotting ------------------------------
var pricearray = array.new_float(0)
var labelarray = array.new_label(0)
f_LevelMerge(pricearray, labelarray, currentprice, currentlabel, currentcolor) =>
if array.includes(pricearray, currentprice)
whichindex = array.indexof(pricearray, currentprice)
labelhold = array.get(labelarray, whichindex)
whichtext = label.get_text(labelhold)
label.set_text(labelhold, label.get_text(currentlabel) + ' / ' + whichtext)
label.set_text(currentlabel, '')
label.set_textcolor(labelhold, currentcolor)
else
array.push(pricearray, currentprice)
array.push(labelarray, currentlabel)
var can_show_daily = is_daily_enabled and timeframe.isintraday
var can_show_weekly = is_weekly_enabled and not timeframe.isweekly and not timeframe.ismonthly
var can_show_monthly = is_monthly_enabled and not timeframe.ismonthly
get_limit_right(bars) =>
timenow + (time - time ) * bars
// the following code doesn't need to be processed on every candle
if barstate.islast
is_weekly_open = dayofweek == dayofweek.monday
is_monthly_open = dayofmonth == 1
can_draw_daily = (is_weekly_enabled ? not is_weekly_open : true) and (is_monthly_enabled ? not is_monthly_open : true)
can_draw_weekly = is_monthly_enabled ? not(is_monthly_open and is_weekly_open) : true
can_draw_intra = is_intra_enabled
can_draw_intrah = is_intrarange_enabled
can_draw_intral = is_intrarange_enabled
can_draw_intram = is_intram_enabled
pricearray := array.new_float(0)
labelarray := array.new_label(0)
/////////////////////////////////
if is_londonrange_enabled
//label.new(bar_index,high)
london_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
londontime := get_limit_right(radistance)
londontime
var londonh_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonhigh, y2=flondonhigh, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londonl_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonlow, y2=flondonlow, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londono_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonopen, y2=flondonopen, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londonh_label = label.new(x=london_limit_right, y=flondonhigh, text=lhtext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var londonl_label = label.new(x=london_limit_right, y=flondonlow, text=lltext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var londono_label = label.new(x=london_limit_right, y=flondonopen, text=lotext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(londonh_line, londontime)
line.set_x2(londonh_line, london_limit_right)
line.set_y1(londonh_line, flondonhigh)
line.set_y2(londonh_line, flondonhigh)
line.set_x1(londonl_line, londontime)
line.set_x2(londonl_line, london_limit_right)
line.set_y1(londonl_line, flondonlow)
line.set_y2(londonl_line, flondonlow)
line.set_x1(londono_line, londontime)
line.set_x2(londono_line, london_limit_right)
line.set_y1(londono_line, flondonopen)
line.set_y2(londono_line, flondonopen)
label.set_x(londonh_label, london_limit_right)
label.set_y(londonh_label, flondonhigh)
label.set_text(londonh_label, lhtext)
label.set_x(londonl_label, london_limit_right)
label.set_y(londonl_label, flondonlow)
label.set_text(londonl_label, lltext)
label.set_x(londono_label, london_limit_right)
label.set_y(londono_label, flondonopen)
label.set_text(londono_label, lotext)
if mergebool
f_LevelMerge(pricearray, labelarray, flondonhigh, londonh_label, LondonColor)
f_LevelMerge(pricearray, labelarray, flondonlow, londonl_label, LondonColor)
f_LevelMerge(pricearray, labelarray, flondonopen, londono_label, LondonColor)
//////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////
if is_usrange_enabled
//label.new(bar_index,high)
us_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
ustime := get_limit_right(radistance)
ustime
var ush_line = line.new(x1=ustime, x2=us_limit_right, y1=fushigh, y2=fushigh, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var usl_line = line.new(x1=ustime, x2=us_limit_right, y1=fuslow, y2=fuslow, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var uso_line = line.new(x1=ustime, x2=us_limit_right, y1=fusopen, y2=fusopen, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var ush_label = label.new(x=us_limit_right, y=fushigh, text=lhtext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var usl_label = label.new(x=us_limit_right, y=fuslow, text=lltext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var uso_label = label.new(x=us_limit_right, y=fusopen, text=lotext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(ush_line, ustime)
line.set_x2(ush_line, us_limit_right)
line.set_y1(ush_line, fushigh)
line.set_y2(ush_line, fushigh)
line.set_x1(usl_line, ustime)
line.set_x2(usl_line, us_limit_right)
line.set_y1(usl_line, fuslow)
line.set_y2(usl_line, fuslow)
line.set_x1(uso_line, ustime)
line.set_x2(uso_line, us_limit_right)
line.set_y1(uso_line, fusopen)
line.set_y2(uso_line, fusopen)
label.set_x(ush_label, us_limit_right)
label.set_y(ush_label, fushigh)
label.set_text(ush_label, ushtext)
label.set_x(usl_label, us_limit_right)
label.set_y(usl_label, fuslow)
label.set_text(usl_label, usltext)
label.set_x(uso_label, us_limit_right)
label.set_y(uso_label, fusopen)
label.set_text(uso_label, usotext)
if mergebool
f_LevelMerge(pricearray, labelarray, fushigh, ush_label, USColor)
f_LevelMerge(pricearray, labelarray, fuslow, usl_label, USColor)
f_LevelMerge(pricearray, labelarray, fusopen, uso_label, USColor)
/////////////////////////////////
if is_asiarange_enabled
//label.new(bar_index,high)
asia_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
asiatime := get_limit_right(radistance)
asiatime
var asiah_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasiahigh, y2=fasiahigh, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asial_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasialow, y2=fasialow, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asiao_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasiaopen, y2=fasiaopen, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asiah_label = label.new(x=asia_limit_right, y=fasiahigh, text=asiahtext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var asial_label = label.new(x=asia_limit_right, y=fasialow, text=asialtext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var asiao_label = label.new(x=asia_limit_right, y=fasiaopen, text=asiaotext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(asiah_line, asiatime)
line.set_x2(asiah_line, asia_limit_right)
line.set_y1(asiah_line, fasiahigh)
line.set_y2(asiah_line, fasiahigh)
line.set_x1(asial_line, asiatime)
line.set_x2(asial_line, asia_limit_right)
line.set_y1(asial_line, fasialow)
line.set_y2(asial_line, fasialow)
line.set_x1(asiao_line, asiatime)
line.set_x2(asiao_line, asia_limit_right)
line.set_y1(asiao_line, fasiaopen)
line.set_y2(asiao_line, fasiaopen)
label.set_x(asiah_label, asia_limit_right)
label.set_y(asiah_label, fasiahigh)
label.set_text(asiah_label, asiahtext)
label.set_x(asial_label, asia_limit_right)
label.set_y(asial_label, fasialow)
label.set_text(asial_label, asialtext)
label.set_x(asiao_label, asia_limit_right)
label.set_y(asiao_label, fasiaopen)
label.set_text(asiao_label, asiaotext)
if mergebool
f_LevelMerge(pricearray, labelarray, fasiahigh, asiah_label, AsiaColor)
f_LevelMerge(pricearray, labelarray, fasialow, asial_label, AsiaColor)
f_LevelMerge(pricearray, labelarray, fasiaopen, asiao_label, AsiaColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
if can_draw_intra
intra_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intra_time := get_limit_right(radistance)
intra_time
var intra_line = line.new(x1=intra_time, x2=intra_limit_right, y1=intra_open, y2=intra_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intra_label = label.new(x=intra_limit_right, y=intra_open, text=iotext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intra_line, intra_time)
line.set_x2(intra_line, intra_limit_right)
line.set_y1(intra_line, intra_open)
line.set_y2(intra_line, intra_open)
label.set_x(intra_label, intra_limit_right)
label.set_y(intra_label, intra_open)
label.set_text(intra_label, iotext)
if mergebool
f_LevelMerge(pricearray, labelarray, intra_open, intra_label, IntraColor)
//////////////////////////////////////////////////////////////////////////////////
//HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH
if can_draw_intrah
intrah_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intrah_time := get_limit_right(radistance)
intrah_time
var intrah_line = line.new(x1=intrah_time, x2=intrah_limit_right, y1=intrah_open, y2=intrah_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intrah_label = label.new(x=intrah_limit_right, y=intrah_open, text=pihtext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intrah_line, intrah_time)
line.set_x2(intrah_line, intrah_limit_right)
line.set_y1(intrah_line, intrah_open)
line.set_y2(intrah_line, intrah_open)
label.set_x(intrah_label, intrah_limit_right)
label.set_y(intrah_label, intrah_open)
label.set_text(intrah_label, pihtext)
if mergebool
f_LevelMerge(pricearray, labelarray, intrah_open, intrah_label, IntraColor)
//////////////////////////////////////////////////////////////////////////////////
//LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW
if can_draw_intral
intral_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intral_time := get_limit_right(radistance)
intral_time
var intral_line = line.new(x1=intral_time, x2=intral_limit_right, y1=intral_open, y2=intral_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intral_label = label.new(x=intral_limit_right, y=intral_open, text=piltext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intral_line, intral_time)
line.set_x2(intral_line, intral_limit_right)
line.set_y1(intral_line, intral_open)
line.set_y2(intral_line, intral_open)
label.set_x(intral_label, intral_limit_right)
label.set_y(intral_label, intral_open)
label.set_text(intral_label, piltext)
if mergebool
f_LevelMerge(pricearray, labelarray, intral_open, intral_label, IntraColor)
///////////////////////////////////////////////////////////////////////////////
if can_draw_intram
intram_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
intram_time = intrah_time
intram_open = (intral_open + intrah_open) / 2
if displayStyle == 'Right Anchored'
intram_time := get_limit_right(radistance)
intram_time
var intram_line = line.new(x1=intram_time, x2=intram_limit_right, y1=intram_open, y2=intram_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intram_label = label.new(x=intram_limit_right, y=intram_open, text=pimtext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intram_line, intram_time)
line.set_x2(intram_line, intram_limit_right)
line.set_y1(intram_line, intram_open)
line.set_y2(intram_line, intram_open)
label.set_x(intram_label, intram_limit_right)
label.set_y(intram_label, intram_open)
label.set_text(intram_label, pimtext)
if mergebool
f_LevelMerge(pricearray, labelarray, intram_open, intram_label, IntraColor)
////////////////////////////////////////// MONDAY
if is_monday_enabled
monday_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var monday_line = line.new(x1=monday_time, x2=monday_limit_right, y1=monday_high, y2=monday_high, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monday_label = label.new(x=monday_limit_right, y=monday_high, text=pmonhtext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monday_line, monday_time)
line.set_x2(monday_line, monday_limit_right)
line.set_y1(monday_line, monday_high)
line.set_y2(monday_line, monday_high)
label.set_x(monday_label, monday_limit_right)
label.set_y(monday_label, monday_high)
label.set_text(monday_label, pmonhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monday_high, monday_label, MondayColor)
if is_monday_enabled
monday_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var monday_low_line = line.new(x1=monday_time, x2=monday_limit_right, y1=monday_low, y2=monday_low, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monday_low_label = label.new(x=monday_limit_right, y=monday_low, text=pmonltext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monday_low_line, monday_time)
line.set_x2(monday_low_line, monday_limit_right)
line.set_y1(monday_low_line, monday_low)
line.set_y2(monday_low_line, monday_low)
label.set_x(monday_low_label, monday_limit_right)
label.set_y(monday_low_label, monday_low)
label.set_text(monday_low_label, pmonltext)
if mergebool
f_LevelMerge(pricearray, labelarray, monday_low, monday_low_label, MondayColor)
if is_monday_mid
mondaym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
mondaym_open = (monday_high + monday_low) / 2
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var mondaym_line = line.new(x1=monday_time, x2=mondaym_limit_right, y1=mondaym_open, y2=mondaym_open, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var mondaym_label = label.new(x=mondaym_limit_right, y=mondaym_open, text=pmonmtext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(mondaym_line, monday_time)
line.set_x2(mondaym_line, mondaym_limit_right)
line.set_y1(mondaym_line, mondaym_open)
line.set_y2(mondaym_line, mondaym_open)
label.set_x(mondaym_label, mondaym_limit_right)
label.set_y(mondaym_label, mondaym_open)
label.set_text(mondaym_label, pmonmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, mondaym_open, mondaym_label, MondayColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN
if is_daily_enabled
daily_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
daily_time := get_limit_right(radistance)
daily_time
var daily_line = line.new(x1=daily_time, x2=daily_limit_right, y1=daily_open, y2=daily_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var daily_label = label.new(x=daily_limit_right, y=daily_open, text=dotext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(daily_line, daily_time)
line.set_x2(daily_line, daily_limit_right)
line.set_y1(daily_line, daily_open)
line.set_y2(daily_line, daily_open)
label.set_x(daily_label, daily_limit_right)
label.set_y(daily_label, daily_open)
label.set_text(daily_label, dotext)
if mergebool
f_LevelMerge(pricearray, labelarray, daily_open, daily_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH
if is_dailyrange_enabled
dailyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
dailyh_time := get_limit_right(radistance)
dailyh_time
// draw tails before lines for better visual
var dailyh_line = line.new(x1=dailyh_time, x2=dailyh_limit_right, y1=dailyh_open, y2=dailyh_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailyh_label = label.new(x=dailyh_limit_right, y=dailyh_open, text=pdhtext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailyh_line, dailyh_time)
line.set_x2(dailyh_line, dailyh_limit_right)
line.set_y1(dailyh_line, dailyh_open)
line.set_y2(dailyh_line, dailyh_open)
label.set_x(dailyh_label, dailyh_limit_right)
label.set_y(dailyh_label, dailyh_open)
label.set_text(dailyh_label, pdhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailyh_open, dailyh_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW
if is_dailyrange_enabled
dailyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
dailyl_time := get_limit_right(radistance)
dailyl_time
var dailyl_line = line.new(x1=dailyl_time, x2=dailyl_limit_right, y1=dailyl_open, y2=dailyl_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailyl_label = label.new(x=dailyl_limit_right, y=dailyl_open, text=pdltext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailyl_line, dailyl_time)
line.set_x2(dailyl_line, dailyl_limit_right)
line.set_y1(dailyl_line, dailyl_open)
line.set_y2(dailyl_line, dailyl_open)
label.set_x(dailyl_label, dailyl_limit_right)
label.set_y(dailyl_label, dailyl_open)
label.set_text(dailyl_label, pdltext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailyl_open, dailyl_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////// Daily MID
if is_dailym_enabled
dailym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
dailym_time = dailyh_time
dailym_open = (dailyl_open + dailyh_open) / 2
if displayStyle == 'Right Anchored'
dailym_time := get_limit_right(radistance)
dailym_time
var dailym_line = line.new(x1=dailym_time, x2=dailym_limit_right, y1=dailym_open, y2=dailym_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailym_label = label.new(x=dailym_limit_right, y=dailym_open, text=pdmtext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailym_line, dailym_time)
line.set_x2(dailym_line, dailym_limit_right)
line.set_y1(dailym_line, dailym_open)
line.set_y2(dailym_line, dailym_open)
label.set_x(dailym_label, dailym_limit_right)
label.set_y(dailym_label, dailym_open)
label.set_text(dailym_label, pdmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailym_open, dailym_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
if is_weekly_enabled
weekly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
cweekly_time = weekly_time
if displayStyle == 'Right Anchored'
cweekly_time := get_limit_right(radistance)
cweekly_time
var weekly_line = line.new(x1=cweekly_time, x2=weekly_limit_right, y1=weekly_open, y2=weekly_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weekly_label = label.new(x=weekly_limit_right, y=weekly_open, text=wotext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weekly_line, cweekly_time)
line.set_x2(weekly_line, weekly_limit_right)
line.set_y1(weekly_line, weekly_open)
line.set_y2(weekly_line, weekly_open)
label.set_x(weekly_label, weekly_limit_right)
label.set_y(weekly_label, weekly_open)
label.set_text(weekly_label, wotext)
if mergebool
f_LevelMerge(pricearray, labelarray, weekly_open, weekly_label, WeeklyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
// if is_weekly_open and can_show_daily
// label.set_text(weekly_label, "DO / WO ")
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// WEEKLY HIGH WEEKLY HIGH WEEKLY HIGH
if is_weeklyrange_enabled
weeklyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
weeklyh_time := get_limit_right(radistance)
weeklyh_time
var weeklyh_line = line.new(x1=weeklyh_time, x2=weeklyh_limit_right, y1=weeklyh_open, y2=weeklyh_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklyh_label = label.new(x=weeklyh_limit_right, y=weeklyh_open, text=pwhtext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklyh_line, weeklyh_time)
line.set_x2(weeklyh_line, weeklyh_limit_right)
line.set_y1(weeklyh_line, weeklyh_open)
line.set_y2(weeklyh_line, weeklyh_open)
label.set_x(weeklyh_label, weeklyh_limit_right)
label.set_y(weeklyh_label, weeklyh_open)
label.set_text(weeklyh_label, pwhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklyh_open, weeklyh_label, WeeklyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// WEEKLY LOW WEEKLY LOW WEEKLY LOW
if is_weeklyrange_enabled
weeklyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
weeklyl_time := get_limit_right(radistance)
weeklyl_time
var weeklyl_line = line.new(x1=weeklyl_time, x2=weeklyl_limit_right, y1=weekly_open, y2=weekly_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklyl_label = label.new(x=weeklyl_limit_right, y=weeklyl_open, text=pwltext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklyl_line, weeklyl_time)
line.set_x2(weeklyl_line, weeklyl_limit_right)
line.set_y1(weeklyl_line, weeklyl_open)
line.set_y2(weeklyl_line, weeklyl_open)
label.set_x(weeklyl_label, weeklyl_limit_right)
label.set_y(weeklyl_label, weeklyl_open)
label.set_text(weeklyl_label, pwltext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklyl_open, weeklyl_label, WeeklyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// Weekly MID
if is_weekly_mid
weeklym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
weeklym_time = weeklyh_time
weeklym_open = (weeklyl_open + weeklyh_open) / 2
if displayStyle == 'Right Anchored'
weeklym_time := get_limit_right(radistance)
weeklym_time
var weeklym_line = line.new(x1=weeklym_time, x2=weeklym_limit_right, y1=weeklym_open, y2=weeklym_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklym_label = label.new(x=weeklym_limit_right, y=weeklym_open, text=pwmtext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklym_line, weeklym_time)
line.set_x2(weeklym_line, weeklym_limit_right)
line.set_y1(weeklym_line, weeklym_open)
line.set_y2(weeklym_line, weeklym_open)
label.set_x(weeklym_label, weeklym_limit_right)
label.set_y(weeklym_label, weeklym_open)
label.set_text(weeklym_label, pwmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklym_open, weeklym_label, WeeklyColor)
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY LOW LOW LOW
if is_yearlyrange_enabled
yearlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearlyl_time := get_limit_right(radistance)
yearlyl_time
var yearlyl_line = line.new(x1=yearlyl_time, x2=yearlyl_limit_right, y1=yearlyl_open, y2=yearlyl_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlyl_label = label.new(x=yearlyl_limit_right, y=yearlyl_open, text=cyltext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlyl_line, yearlyl_time)
line.set_x2(yearlyl_line, yearlyl_limit_right)
line.set_y1(yearlyl_line, yearlyl_open)
line.set_y2(yearlyl_line, yearlyl_open)
label.set_x(yearlyl_label, yearlyl_limit_right)
label.set_y(yearlyl_label, yearlyl_open)
label.set_text(yearlyl_label, cyltext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlyl_open, yearlyl_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY HIGH HIGH HIGH
if is_yearlyrange_enabled
yearlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearlyh_time := get_limit_right(radistance)
yearlyh_time
var yearlyh_line = line.new(x1=yearlyh_time, x2=yearlyh_limit_right, y1=yearlyh_open, y2=yearlyh_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlyh_label = label.new(x=yearlyh_limit_right, y=yearlyh_open, text=cyhtext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlyh_line, yearlyh_time)
line.set_x2(yearlyh_line, yearlyh_limit_right)
line.set_y1(yearlyh_line, yearlyh_open)
line.set_y2(yearlyh_line, yearlyh_open)
label.set_x(yearlyh_label, yearlyh_limit_right)
label.set_y(yearlyh_label, yearlyh_open)
label.set_text(yearlyh_label, cyhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlyh_open, yearlyh_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY OPEN
if is_yearly_enabled
yearly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearly_time := get_limit_right(radistance)
yearly_time
var yearly_line = line.new(x1=yearly_time, x2=yearly_limit_right, y1=yearly_open, y2=yearly_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearly_label = label.new(x=yearly_limit_right, y=yearly_open, text=yotext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearly_line, yearly_time)
line.set_x2(yearly_line, yearly_limit_right)
line.set_y1(yearly_line, yearly_open)
line.set_y2(yearly_line, yearly_open)
label.set_x(yearly_label, yearly_limit_right)
label.set_y(yearly_label, yearly_open)
label.set_text(yearly_label, yotext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearly_open, yearly_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// yearly MID
if is_yearly_mid
yearlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
yearlym_time = yearlyh_time
yearlym_open = (yearlyl_open + yearlyh_open) / 2
if displayStyle == 'Right Anchored'
yearlym_time := get_limit_right(radistance)
yearlym_time
var yearlym_line = line.new(x1=yearlym_time, x2=yearlym_limit_right, y1=yearlym_open, y2=yearlym_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlym_label = label.new(x=yearlym_limit_right, y=yearlym_open, text=cymtext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlym_line, yearlym_time)
line.set_x2(yearlym_line, yearlym_limit_right)
line.set_y1(yearlym_line, yearlym_open)
line.set_y2(yearlym_line, yearlym_open)
label.set_x(yearlym_label, yearlym_limit_right)
label.set_y(yearlym_label, yearlym_open)
label.set_text(yearlym_label, cymtext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlym_open, yearlym_label, YearlyColor)
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY OPEN
if is_quarterly_enabled
quarterly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterly_time := get_limit_right(radistance)
quarterly_time
var quarterly_line = line.new(x1=quarterly_time, x2=quarterly_limit_right, y1=quarterly_open, y2=quarterly_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterly_label = label.new(x=quarterly_limit_right, y=quarterly_open, text=qotext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterly_line, quarterly_time)
line.set_x2(quarterly_line, quarterly_limit_right)
line.set_y1(quarterly_line, quarterly_open)
line.set_y2(quarterly_line, quarterly_open)
label.set_x(quarterly_label, quarterly_limit_right)
label.set_y(quarterly_label, quarterly_open)
label.set_text(quarterly_label, qotext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterly_open, quarterly_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY High
if is_quarterlyrange_enabled
quarterlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterlyh_time := get_limit_right(radistance)
quarterlyh_time
var quarterlyh_line = line.new(x1=quarterlyh_time, x2=quarterlyh_limit_right, y1=quarterlyh_open, y2=quarterlyh_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlyh_label = label.new(x=quarterlyh_limit_right, y=quarterlyh_open, text=pqhtext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlyh_line, quarterlyh_time)
line.set_x2(quarterlyh_line, quarterlyh_limit_right)
line.set_y1(quarterlyh_line, quarterlyh_open)
line.set_y2(quarterlyh_line, quarterlyh_open)
label.set_x(quarterlyh_label, quarterlyh_limit_right)
label.set_y(quarterlyh_label, quarterlyh_open)
label.set_text(quarterlyh_label, pqhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlyh_open, quarterlyh_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY Low
if is_quarterlyrange_enabled
quarterlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterlyl_time := get_limit_right(radistance)
quarterlyl_time
var quarterlyl_line = line.new(x1=quarterlyl_time, x2=quarterlyl_limit_right, y1=quarterlyl_open, y2=quarterlyl_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlyl_label = label.new(x=quarterlyl_limit_right, y=quarterlyl_open, text=pqltext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlyl_line, quarterlyl_time)
line.set_x2(quarterlyl_line, quarterlyl_limit_right)
line.set_y1(quarterlyl_line, quarterlyl_open)
line.set_y2(quarterlyl_line, quarterlyl_open)
label.set_x(quarterlyl_label, quarterlyl_limit_right)
label.set_y(quarterlyl_label, quarterlyl_open)
label.set_text(quarterlyl_label, pqltext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlyl_open, quarterlyl_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY MID
if is_quarterly_mid
quarterlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
quarterlym_time = quarterlyh_time
quarterlym_open = (quarterlyl_open + quarterlyh_open) / 2
if displayStyle == 'Right Anchored'
quarterlym_time := get_limit_right(radistance)
quarterlym_time
var quarterlym_line = line.new(x1=quarterlym_time, x2=quarterlym_limit_right, y1=quarterlym_open, y2=quarterlym_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlym_label = label.new(x=quarterlym_limit_right, y=quarterlym_open, text=pqmtext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlym_line, quarterlym_time)
line.set_x2(quarterlym_line, quarterlym_limit_right)
line.set_y1(quarterlym_line, quarterlym_open)
line.set_y2(quarterlym_line, quarterlym_open)
label.set_x(quarterlym_label, quarterlym_limit_right)
label.set_y(quarterlym_label, quarterlym_open)
label.set_text(quarterlym_label, pqmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlym_open, quarterlym_label, quarterlyColor)
////////////////////////////////////////////////////////////////////////////////// Monthly LOW LOW LOW
if is_monthlyrange_enabled
monthlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthlyl_time := get_limit_right(radistance)
monthlyl_time
var monthlyl_line = line.new(x1=monthlyl_time, x2=monthlyl_limit_right, y1=monthlyl_open, y2=monthlyl_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyl_label = label.new(x=monthlyl_limit_right, y=monthlyl_open, text=pmltext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyl_line, monthlyl_time)
line.set_x2(monthlyl_line, monthlyl_limit_right)
line.set_y1(monthlyl_line, monthlyl_open)
line.set_y2(monthlyl_line, monthlyl_open)
label.set_x(monthlyl_label, monthlyl_limit_right)
label.set_y(monthlyl_label, monthlyl_open)
label.set_text(monthlyl_label, pmltext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlyl_open, monthlyl_label, MonthlyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// MONTHLY HIGH HIGH HIGH
if is_monthlyrange_enabled
monthlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthlyh_time := get_limit_right(radistance)
monthlyh_time
var monthlyh_line = line.new(x1=monthlyh_time, x2=monthlyh_limit_right, y1=monthlyh_open, y2=monthlyh_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyh_label = label.new(x=monthlyh_limit_right, y=monthlyh_open, text=pmhtext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyh_line, monthlyl_time)
line.set_x2(monthlyh_line, monthlyh_limit_right)
line.set_y1(monthlyh_line, monthlyh_open)
line.set_y2(monthlyh_line, monthlyh_open)
label.set_x(monthlyh_label, monthlyh_limit_right)
label.set_y(monthlyh_label, monthlyh_open)
label.set_text(monthlyh_label, pmhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlyh_open, monthlyh_label, MonthlyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
//////////////////////////////////////////////////////////////////////////////// MONTHLY MID
if is_monthly_mid
monthlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
monthlym_time = monthlyh_time
monthlym_open = (monthlyl_open + monthlyh_open) / 2
if displayStyle == 'Right Anchored'
monthlym_time := get_limit_right(radistance)
monthlym_time
var monthlym_line = line.new(x1=monthlym_time, x2=monthlym_limit_right, y1=monthlym_open, y2=monthlym_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlym_label = label.new(x=monthlym_limit_right, y=monthlym_open, text=pmmtext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlym_line, monthlym_time)
line.set_x2(monthlym_line, monthlym_limit_right)
line.set_y1(monthlym_line, monthlym_open)
line.set_y2(monthlym_line, monthlym_open)
label.set_x(monthlym_label, monthlym_limit_right)
label.set_y(monthlym_label, monthlym_open)
label.set_text(monthlym_label, pmmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlym_open, monthlym_label, MonthlyColor)
//////////////////////////////////////////////////////////////////////////////////
if is_monthly_enabled
monthly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthly_time := get_limit_right(radistance)
monthly_time
var monthlyLine = line.new(x1=monthly_time, x2=monthly_limit_right, y1=monthly_open, y2=monthly_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyLabel = label.new(x=monthly_limit_right, y=monthly_open, text=motext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyLine, monthly_time)
line.set_x2(monthlyLine, monthly_limit_right)
line.set_y1(monthlyLine, monthly_open)
line.set_y2(monthlyLine, monthly_open)
label.set_x(monthlyLabel, monthly_limit_right)
label.set_y(monthlyLabel, monthly_open)
label.set_text(monthlyLabel, motext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthly_open, monthlyLabel, MonthlyColor)
/////////////////////////////////////////////////////////////////////////////
// the monthly open can be the weekly open (monday 1st) and/or daily open too
// only the monthly will be draw, in these case we update its label
// if is_monthly_open
// if can_show_daily
// label.set_text(monthlyLabel, "DO / MO ")
// if is_weekly_open
// if can_show_weekly
// label.set_text(monthlyLabel, "WO / MO ")
// if can_show_daily and can_show_weekly
// label.set_text(monthlyLabel, "DO / WO / MO ")
// the start of the line is drew from the first week of the month
// if the first day of the weekly candle (monday) is the 2nd of the month
// we fix the start of the line position on the Prev weekly candle
if timeframe.isweekly and dayofweek(monthly_time) != dayofweek.monday
line.set_x1(monthlyLine, monthly_time - (weekly_time - weekly_time ))
Key Levels//@version=5
//@sbtnc thank you for doing the base code
//Added additional levels for convienience sake.
indicator('Key Levels SpacemanBTC IDWM', shorttitle='SpacemanBTC Key Level V13.1', overlay=true, max_lines_count=100)
//35 works
displayStyle = input.string(defval='Standard', title='Display Style', options= , inline='Display')
mergebool = input.bool(defval=true, title='Merge Levels?', inline='Display')
distanceright = input.int(defval=30, title='Distance', minval=5, maxval=500, inline='Dist')
radistance = input.int(defval=250, title='Anchor Distance', minval=5, maxval=500, inline='Dist')
labelsize = input.string(defval='Medium', title='Text Size', options= )
linesize = input.string(defval='Small', title='Line Width', options= , inline='Line')
linestyle = input.string(defval='Solid', title='Line Style', options= , inline='Line')
GlobalTextType = input.bool(defval=false, title='Global Text ShortHand', tooltip='Enable for shorthand text on all text')
var globalcoloring = input.bool(defval=false, title='Global Coloring', tooltip='Enable for all color controls via one color', inline='GC')
GlobalColor = input.color(title='', defval=color.white, inline='GC')
//var show_tails = input(defval = false, title = "Always Show", type = input.bool)
= request.security(syminfo.tickerid, 'D', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'D', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'D', [time , low ], lookahead=barmerge.lookahead_on)
cdailyh_open = request.security(syminfo.tickerid, 'D', high, lookahead=barmerge.lookahead_on)
cdailyl_open = request.security(syminfo.tickerid, 'D', low, lookahead=barmerge.lookahead_on)
var monday_time = time
var monday_high = high
var monday_low = low
= request.security(syminfo.tickerid, 'W', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'W', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'W', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', [time , low ], lookahead=barmerge.lookahead_on)
//------------------------------ Inputs -------------------------------
var is_intra_enabled = input.bool(defval=false, title='Open', group='4H', inline='4H')
var is_intrarange_enabled = input.bool(defval=false, title='Prev H/L', group='4H', inline='4H')
var is_intram_enabled = input.bool(defval=false, title='Prev Mid', group='4H', inline='4H')
IntraTextType = input.bool(defval=false, title='ShortHand', group='4H', inline='4Hsh')
var is_daily_enabled = input.bool(defval=true, title='Open', group='Daily', inline='Daily')
var is_dailyrange_enabled = input.bool(defval=false, title='Prev H/L', group='Daily', inline='Daily')
var is_dailym_enabled = input.bool(defval=false, title='Prev Mid', group='Daily', inline='Daily')
DailyTextType = input.bool(defval=false, title='ShortHand', group='Daily', inline='Dailysh')
var is_monday_enabled = input.bool(defval=true, title='Range', group='Monday Range', inline='Monday')
var is_monday_mid = input.bool(defval=true, title='Mid', group='Monday Range', inline='Monday')
var untested_monday = false
MondayTextType = input.bool(defval=false, title='ShortHand', group='Monday Range', inline='Mondaysh')
var is_weekly_enabled = input.bool(defval=true, title='Open', group='Weekly', inline='Weekly')
var is_weeklyrange_enabled = input.bool(defval=true, title='Prev H/L', group='Weekly', inline='Weekly')
var is_weekly_mid = input.bool(defval=true, title='Prev Mid', group='Weekly', inline='Weekly')
WeeklyTextType = input.bool(defval=false, title='ShortHand', group='Weekly', inline='Weeklysh')
var is_monthly_enabled = input.bool(defval=true, title='Open', group='Monthly', inline='Monthly')
var is_monthlyrange_enabled = input.bool(defval=true, title='Prev H/L', group='Monthly', inline='Monthly')
var is_monthly_mid = input.bool(defval=true, title='Prev Mid', group='Monthly', inline='Monthly')
MonthlyTextType = input.bool(defval=false, title='ShortHand', group='Monthly', inline='Monthlysh')
var is_quarterly_enabled = input.bool(defval=true, title='Open', group='Quarterly', inline='Quarterly')
var is_quarterlyrange_enabled = input.bool(defval=false, title='Prev H/L', group='Quarterly', inline='Quarterly')
var is_quarterly_mid = input.bool(defval=true, title='Prev Mid', group='Quarterly', inline='Quarterly')
QuarterlyTextType = input.bool(defval=false, title='ShortHand', group='Quarterly', inline='Quarterlysh')
var is_yearly_enabled = input.bool(defval=true, title='Open', group='Yearly', inline='Yearly')
var is_yearlyrange_enabled = input.bool(defval=false, title='Current H/L', group='Yearly', inline='Yearly')
var is_yearly_mid = input.bool(defval=true, title='Mid', group='Yearly', inline='Yearly')
YearlyTextType = input.bool(defval=false, title='ShortHand', group='Yearly', inline='Yearlysh')
var is_londonrange_enabled = input.bool(defval=false, title='London Range', group='FX Sessions', inline='FX')
var is_usrange_enabled = input.bool(defval=false, title='New York Range', group='FX Sessions', inline='FX')
var is_asiarange_enabled = input.bool(defval=false, title='Asia Range', group='FX Sessions', inline='FX')
SessionTextType = input.bool(defval=false, title='ShortHand', group='FX Sessions', inline='FXColor')
Londont = input.session("0800-1600", "London Session")
USt = input.session("1400-2100", "New York Session")
Asiat = input.session("0000-0900", "Tokyo Session")
DailyColor = input.color(title='', defval=#08bcd4, group='Daily', inline='Dailysh')
MondayColor = input.color(title='', defval=color.white, group='Monday Range', inline='Mondaysh')
WeeklyColor = input.color(title='', defval=#fffcbc, group='Weekly', inline='Weeklysh')
MonthlyColor = input.color(title='', defval=#08d48c, group='Monthly', inline='Monthlysh')
YearlyColor = input.color(title='', defval=color.red, group='Yearly', inline='Yearlysh')
quarterlyColor = input.color(title='', defval=color.red, group='Quarterly', inline='Quarterlysh')
IntraColor = input.color(title='', defval=color.orange, group='4H', inline='4Hsh')
LondonColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
USColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
AsiaColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
var pdhtext = GlobalTextType or DailyTextType ? 'PDH' : 'Prev Day High'
var pdltext = GlobalTextType or DailyTextType ? 'PDL' : 'Prev Day Low'
var dotext = GlobalTextType or DailyTextType ? 'DO' : 'Daily Open'
var pdmtext = GlobalTextType or DailyTextType ? 'PDM' : 'Prev Day Mid'
var pwhtext = GlobalTextType or WeeklyTextType ? 'PWH' : 'Prev Week High'
var pwltext = GlobalTextType or WeeklyTextType ? 'PWL' : 'Prev Week Low'
var wotext = GlobalTextType or WeeklyTextType ? 'WO' : 'Weekly Open'
var pwmtext = GlobalTextType or WeeklyTextType ? 'PWM' : 'Prev Week Mid'
var pmhtext = GlobalTextType or MonthlyTextType ? 'PMH' : 'Prev Month High'
var pmltext = GlobalTextType or MonthlyTextType ? 'PML' : 'Prev Month Low'
var motext = GlobalTextType or MonthlyTextType ? 'MO' : 'Monthly Open'
var pmmtext = GlobalTextType or MonthlyTextType ? 'PMM' : 'Prev Month Mid'
var pqhtext = GlobalTextType or QuarterlyTextType ? 'PQH' : 'Prev Quarter High'
var pqltext = GlobalTextType or QuarterlyTextType ? 'PQL' : 'Prev Quarter Low'
var qotext = GlobalTextType or QuarterlyTextType ? 'QO' : 'Quarterly Open'
var pqmtext = GlobalTextType or QuarterlyTextType ? 'PQM' : 'Prev Quarter Mid'
var cyhtext = GlobalTextType or YearlyTextType ? 'CYH' : 'Current Year High'
var cyltext = GlobalTextType or YearlyTextType ? 'CYL' : 'Current Year Low'
var yotext = GlobalTextType or YearlyTextType ? 'YO' : 'Yearly Open'
var cymtext = GlobalTextType or YearlyTextType ? 'CYM' : 'Current Year Mid'
var pihtext = GlobalTextType or IntraTextType ? 'P-4H-H' : 'Prev 4H High'
var piltext = GlobalTextType or IntraTextType ? 'P-4H-L' : 'Prev 4H Low'
var iotext = GlobalTextType or IntraTextType ? '4H-O' : '4H Open'
var pimtext = GlobalTextType or IntraTextType ? 'P-4H-M' : 'Prev 4H Mid'
var pmonhtext = GlobalTextType or MondayTextType ? 'MDAY-H' : 'Monday High'
var pmonltext = GlobalTextType or MondayTextType ? 'MDAY-L' : 'Monday Low'
var pmonmtext = GlobalTextType or MondayTextType ? 'MDAY-M' : 'Monday Mid'
var lhtext = GlobalTextType or SessionTextType ? 'Lon-H' : 'London High'
var lltext = GlobalTextType or SessionTextType ? 'Lon-L' : 'London Low'
var lotext = GlobalTextType or SessionTextType ? 'Lon-O' : 'London Open'
var ushtext = GlobalTextType or SessionTextType ? 'NY-H' : 'New York High'
var usltext = GlobalTextType or SessionTextType ? 'NY-L' : 'New York Low'
var usotext = GlobalTextType or SessionTextType ? 'NY-O' : 'New York Open'
var asiahtext = GlobalTextType or SessionTextType ? 'AS-H' : 'Asia High'
var asialtext = GlobalTextType or SessionTextType ? 'AS-L' : 'Asia Low'
var asiaotext = GlobalTextType or SessionTextType ? 'AS-O' : 'Asia Open'
if globalcoloring == true
DailyColor := GlobalColor
MondayColor := GlobalColor
WeeklyColor := GlobalColor
MonthlyColor := GlobalColor
YearlyColor := GlobalColor
quarterlyColor := GlobalColor
IntraColor := GlobalColor
IntraColor
if weekly_time != weekly_time
untested_monday := false
untested_monday
if is_monday_enabled == true and untested_monday == false
untested_monday := true
monday_time := daily_time
monday_high := cdailyh_open
monday_low := cdailyl_open
monday_low
linewidthint = 1
if linesize == 'Small'
linewidthint := 1
linewidthint
if linesize == 'Medium'
linewidthint := 2
linewidthint
if linesize == 'Large'
linewidthint := 3
linewidthint
var DEFAULT_LINE_WIDTH = linewidthint
var DEFAULT_TAIL_WIDTH = linewidthint
fontsize = size.small
if labelsize == 'Small'
fontsize := size.small
fontsize
if labelsize == 'Medium'
fontsize := size.normal
fontsize
if labelsize == 'Large'
fontsize := size.large
fontsize
linestyles = line.style_solid
if linestyle == 'Dashed'
linestyles := line.style_dashed
linestyles
if linestyle == 'Dotted'
linestyles := line.style_dotted
linestyles
var DEFAULT_LABEL_SIZE = fontsize
var DEFAULT_LABEL_STYLE = label.style_none
var DEFAULT_EXTEND_RIGHT = distanceright
London = time(timeframe.period, Londont)
US = time(timeframe.period, USt)
Asia = time(timeframe.period, Asiat)
var clondonhigh = 0.0
var clondonlow = close
var londontime = time
var flondonhigh = 0.0
var flondonlow = 0.0
var flondonopen = 0.0
var onelondonfalse = false
if London
if high > clondonhigh
clondonhigh := high
clondonhigh
if low < clondonlow
clondonlow := low
clondonlow
if onelondonfalse
londontime := time
flondonopen := open
flondonopen
flondonhigh := clondonhigh
flondonlow := clondonlow
onelondonfalse := false
onelondonfalse
else
if onelondonfalse == false
flondonhigh := clondonhigh
flondonlow := clondonlow
flondonlow
onelondonfalse := true
clondonhigh := 0.0
clondonlow := close
clondonlow
//////////////////////////////////
var cushigh = 0.0
var cuslow = close
var ustime = time
var fushigh = 0.0
var fuslow = 0.0
var fusopen = 0.0
var oneusfalse = false
if US
if high > cushigh
cushigh := high
cushigh
if low < cuslow
cuslow := low
cuslow
if oneusfalse
ustime := time
fusopen := open
fusopen
fushigh := cushigh
fuslow := cuslow
oneusfalse := false
oneusfalse
else
if oneusfalse == false
fushigh := cushigh
fuslow := cuslow
fuslow
oneusfalse := true
cushigh := 0.0
cuslow := close
cuslow
//////////////////////////////////
var casiahigh = 0.0
var casialow = close
var asiatime = time
var fasiahigh = 0.0
var fasialow = 0.0
var fasiaopen = 0.0
var oneasiafalse = false
if Asia
if high > casiahigh
casiahigh := high
casiahigh
if low < casialow
casialow := low
casialow
if oneasiafalse
asiatime := time
fasiaopen := open
fasiaopen
fasiahigh := casiahigh
fasialow := casialow
oneasiafalse := false
oneasiafalse
else
if oneasiafalse == false
fasiahigh := casiahigh
fasialow := casialow
fasialow
oneasiafalse := true
casiahigh := 0.0
casialow := close
casialow
//------------------------------ Plotting ------------------------------
var pricearray = array.new_float(0)
var labelarray = array.new_label(0)
f_LevelMerge(pricearray, labelarray, currentprice, currentlabel, currentcolor) =>
if array.includes(pricearray, currentprice)
whichindex = array.indexof(pricearray, currentprice)
labelhold = array.get(labelarray, whichindex)
whichtext = label.get_text(labelhold)
label.set_text(labelhold, label.get_text(currentlabel) + ' / ' + whichtext)
label.set_text(currentlabel, '')
label.set_textcolor(labelhold, currentcolor)
else
array.push(pricearray, currentprice)
array.push(labelarray, currentlabel)
var can_show_daily = is_daily_enabled and timeframe.isintraday
var can_show_weekly = is_weekly_enabled and not timeframe.isweekly and not timeframe.ismonthly
var can_show_monthly = is_monthly_enabled and not timeframe.ismonthly
get_limit_right(bars) =>
timenow + (time - time ) * bars
// the following code doesn't need to be processed on every candle
if barstate.islast
is_weekly_open = dayofweek == dayofweek.monday
is_monthly_open = dayofmonth == 1
can_draw_daily = (is_weekly_enabled ? not is_weekly_open : true) and (is_monthly_enabled ? not is_monthly_open : true)
can_draw_weekly = is_monthly_enabled ? not(is_monthly_open and is_weekly_open) : true
can_draw_intra = is_intra_enabled
can_draw_intrah = is_intrarange_enabled
can_draw_intral = is_intrarange_enabled
can_draw_intram = is_intram_enabled
pricearray := array.new_float(0)
labelarray := array.new_label(0)
/////////////////////////////////
if is_londonrange_enabled
//label.new(bar_index,high)
london_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
londontime := get_limit_right(radistance)
londontime
var londonh_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonhigh, y2=flondonhigh, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londonl_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonlow, y2=flondonlow, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londono_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonopen, y2=flondonopen, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londonh_label = label.new(x=london_limit_right, y=flondonhigh, text=lhtext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var londonl_label = label.new(x=london_limit_right, y=flondonlow, text=lltext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var londono_label = label.new(x=london_limit_right, y=flondonopen, text=lotext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(londonh_line, londontime)
line.set_x2(londonh_line, london_limit_right)
line.set_y1(londonh_line, flondonhigh)
line.set_y2(londonh_line, flondonhigh)
line.set_x1(londonl_line, londontime)
line.set_x2(londonl_line, london_limit_right)
line.set_y1(londonl_line, flondonlow)
line.set_y2(londonl_line, flondonlow)
line.set_x1(londono_line, londontime)
line.set_x2(londono_line, london_limit_right)
line.set_y1(londono_line, flondonopen)
line.set_y2(londono_line, flondonopen)
label.set_x(londonh_label, london_limit_right)
label.set_y(londonh_label, flondonhigh)
label.set_text(londonh_label, lhtext)
label.set_x(londonl_label, london_limit_right)
label.set_y(londonl_label, flondonlow)
label.set_text(londonl_label, lltext)
label.set_x(londono_label, london_limit_right)
label.set_y(londono_label, flondonopen)
label.set_text(londono_label, lotext)
if mergebool
f_LevelMerge(pricearray, labelarray, flondonhigh, londonh_label, LondonColor)
f_LevelMerge(pricearray, labelarray, flondonlow, londonl_label, LondonColor)
f_LevelMerge(pricearray, labelarray, flondonopen, londono_label, LondonColor)
//////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////
if is_usrange_enabled
//label.new(bar_index,high)
us_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
ustime := get_limit_right(radistance)
ustime
var ush_line = line.new(x1=ustime, x2=us_limit_right, y1=fushigh, y2=fushigh, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var usl_line = line.new(x1=ustime, x2=us_limit_right, y1=fuslow, y2=fuslow, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var uso_line = line.new(x1=ustime, x2=us_limit_right, y1=fusopen, y2=fusopen, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var ush_label = label.new(x=us_limit_right, y=fushigh, text=lhtext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var usl_label = label.new(x=us_limit_right, y=fuslow, text=lltext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var uso_label = label.new(x=us_limit_right, y=fusopen, text=lotext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(ush_line, ustime)
line.set_x2(ush_line, us_limit_right)
line.set_y1(ush_line, fushigh)
line.set_y2(ush_line, fushigh)
line.set_x1(usl_line, ustime)
line.set_x2(usl_line, us_limit_right)
line.set_y1(usl_line, fuslow)
line.set_y2(usl_line, fuslow)
line.set_x1(uso_line, ustime)
line.set_x2(uso_line, us_limit_right)
line.set_y1(uso_line, fusopen)
line.set_y2(uso_line, fusopen)
label.set_x(ush_label, us_limit_right)
label.set_y(ush_label, fushigh)
label.set_text(ush_label, ushtext)
label.set_x(usl_label, us_limit_right)
label.set_y(usl_label, fuslow)
label.set_text(usl_label, usltext)
label.set_x(uso_label, us_limit_right)
label.set_y(uso_label, fusopen)
label.set_text(uso_label, usotext)
if mergebool
f_LevelMerge(pricearray, labelarray, fushigh, ush_label, USColor)
f_LevelMerge(pricearray, labelarray, fuslow, usl_label, USColor)
f_LevelMerge(pricearray, labelarray, fusopen, uso_label, USColor)
/////////////////////////////////
if is_asiarange_enabled
//label.new(bar_index,high)
asia_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
asiatime := get_limit_right(radistance)
asiatime
var asiah_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasiahigh, y2=fasiahigh, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asial_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasialow, y2=fasialow, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asiao_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasiaopen, y2=fasiaopen, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asiah_label = label.new(x=asia_limit_right, y=fasiahigh, text=asiahtext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var asial_label = label.new(x=asia_limit_right, y=fasialow, text=asialtext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var asiao_label = label.new(x=asia_limit_right, y=fasiaopen, text=asiaotext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(asiah_line, asiatime)
line.set_x2(asiah_line, asia_limit_right)
line.set_y1(asiah_line, fasiahigh)
line.set_y2(asiah_line, fasiahigh)
line.set_x1(asial_line, asiatime)
line.set_x2(asial_line, asia_limit_right)
line.set_y1(asial_line, fasialow)
line.set_y2(asial_line, fasialow)
line.set_x1(asiao_line, asiatime)
line.set_x2(asiao_line, asia_limit_right)
line.set_y1(asiao_line, fasiaopen)
line.set_y2(asiao_line, fasiaopen)
label.set_x(asiah_label, asia_limit_right)
label.set_y(asiah_label, fasiahigh)
label.set_text(asiah_label, asiahtext)
label.set_x(asial_label, asia_limit_right)
label.set_y(asial_label, fasialow)
label.set_text(asial_label, asialtext)
label.set_x(asiao_label, asia_limit_right)
label.set_y(asiao_label, fasiaopen)
label.set_text(asiao_label, asiaotext)
if mergebool
f_LevelMerge(pricearray, labelarray, fasiahigh, asiah_label, AsiaColor)
f_LevelMerge(pricearray, labelarray, fasialow, asial_label, AsiaColor)
f_LevelMerge(pricearray, labelarray, fasiaopen, asiao_label, AsiaColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
if can_draw_intra
intra_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intra_time := get_limit_right(radistance)
intra_time
var intra_line = line.new(x1=intra_time, x2=intra_limit_right, y1=intra_open, y2=intra_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intra_label = label.new(x=intra_limit_right, y=intra_open, text=iotext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intra_line, intra_time)
line.set_x2(intra_line, intra_limit_right)
line.set_y1(intra_line, intra_open)
line.set_y2(intra_line, intra_open)
label.set_x(intra_label, intra_limit_right)
label.set_y(intra_label, intra_open)
label.set_text(intra_label, iotext)
if mergebool
f_LevelMerge(pricearray, labelarray, intra_open, intra_label, IntraColor)
//////////////////////////////////////////////////////////////////////////////////
//HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH
if can_draw_intrah
intrah_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intrah_time := get_limit_right(radistance)
intrah_time
var intrah_line = line.new(x1=intrah_time, x2=intrah_limit_right, y1=intrah_open, y2=intrah_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intrah_label = label.new(x=intrah_limit_right, y=intrah_open, text=pihtext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intrah_line, intrah_time)
line.set_x2(intrah_line, intrah_limit_right)
line.set_y1(intrah_line, intrah_open)
line.set_y2(intrah_line, intrah_open)
label.set_x(intrah_label, intrah_limit_right)
label.set_y(intrah_label, intrah_open)
label.set_text(intrah_label, pihtext)
if mergebool
f_LevelMerge(pricearray, labelarray, intrah_open, intrah_label, IntraColor)
//////////////////////////////////////////////////////////////////////////////////
//LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW
if can_draw_intral
intral_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intral_time := get_limit_right(radistance)
intral_time
var intral_line = line.new(x1=intral_time, x2=intral_limit_right, y1=intral_open, y2=intral_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intral_label = label.new(x=intral_limit_right, y=intral_open, text=piltext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intral_line, intral_time)
line.set_x2(intral_line, intral_limit_right)
line.set_y1(intral_line, intral_open)
line.set_y2(intral_line, intral_open)
label.set_x(intral_label, intral_limit_right)
label.set_y(intral_label, intral_open)
label.set_text(intral_label, piltext)
if mergebool
f_LevelMerge(pricearray, labelarray, intral_open, intral_label, IntraColor)
///////////////////////////////////////////////////////////////////////////////
if can_draw_intram
intram_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
intram_time = intrah_time
intram_open = (intral_open + intrah_open) / 2
if displayStyle == 'Right Anchored'
intram_time := get_limit_right(radistance)
intram_time
var intram_line = line.new(x1=intram_time, x2=intram_limit_right, y1=intram_open, y2=intram_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intram_label = label.new(x=intram_limit_right, y=intram_open, text=pimtext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intram_line, intram_time)
line.set_x2(intram_line, intram_limit_right)
line.set_y1(intram_line, intram_open)
line.set_y2(intram_line, intram_open)
label.set_x(intram_label, intram_limit_right)
label.set_y(intram_label, intram_open)
label.set_text(intram_label, pimtext)
if mergebool
f_LevelMerge(pricearray, labelarray, intram_open, intram_label, IntraColor)
////////////////////////////////////////// MONDAY
if is_monday_enabled
monday_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var monday_line = line.new(x1=monday_time, x2=monday_limit_right, y1=monday_high, y2=monday_high, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monday_label = label.new(x=monday_limit_right, y=monday_high, text=pmonhtext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monday_line, monday_time)
line.set_x2(monday_line, monday_limit_right)
line.set_y1(monday_line, monday_high)
line.set_y2(monday_line, monday_high)
label.set_x(monday_label, monday_limit_right)
label.set_y(monday_label, monday_high)
label.set_text(monday_label, pmonhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monday_high, monday_label, MondayColor)
if is_monday_enabled
monday_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var monday_low_line = line.new(x1=monday_time, x2=monday_limit_right, y1=monday_low, y2=monday_low, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monday_low_label = label.new(x=monday_limit_right, y=monday_low, text=pmonltext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monday_low_line, monday_time)
line.set_x2(monday_low_line, monday_limit_right)
line.set_y1(monday_low_line, monday_low)
line.set_y2(monday_low_line, monday_low)
label.set_x(monday_low_label, monday_limit_right)
label.set_y(monday_low_label, monday_low)
label.set_text(monday_low_label, pmonltext)
if mergebool
f_LevelMerge(pricearray, labelarray, monday_low, monday_low_label, MondayColor)
if is_monday_mid
mondaym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
mondaym_open = (monday_high + monday_low) / 2
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var mondaym_line = line.new(x1=monday_time, x2=mondaym_limit_right, y1=mondaym_open, y2=mondaym_open, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var mondaym_label = label.new(x=mondaym_limit_right, y=mondaym_open, text=pmonmtext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(mondaym_line, monday_time)
line.set_x2(mondaym_line, mondaym_limit_right)
line.set_y1(mondaym_line, mondaym_open)
line.set_y2(mondaym_line, mondaym_open)
label.set_x(mondaym_label, mondaym_limit_right)
label.set_y(mondaym_label, mondaym_open)
label.set_text(mondaym_label, pmonmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, mondaym_open, mondaym_label, MondayColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN
if is_daily_enabled
daily_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
daily_time := get_limit_right(radistance)
daily_time
var daily_line = line.new(x1=daily_time, x2=daily_limit_right, y1=daily_open, y2=daily_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var daily_label = label.new(x=daily_limit_right, y=daily_open, text=dotext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(daily_line, daily_time)
line.set_x2(daily_line, daily_limit_right)
line.set_y1(daily_line, daily_open)
line.set_y2(daily_line, daily_open)
label.set_x(daily_label, daily_limit_right)
label.set_y(daily_label, daily_open)
label.set_text(daily_label, dotext)
if mergebool
f_LevelMerge(pricearray, labelarray, daily_open, daily_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH
if is_dailyrange_enabled
dailyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
dailyh_time := get_limit_right(radistance)
dailyh_time
// draw tails before lines for better visual
var dailyh_line = line.new(x1=dailyh_time, x2=dailyh_limit_right, y1=dailyh_open, y2=dailyh_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailyh_label = label.new(x=dailyh_limit_right, y=dailyh_open, text=pdhtext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailyh_line, dailyh_time)
line.set_x2(dailyh_line, dailyh_limit_right)
line.set_y1(dailyh_line, dailyh_open)
line.set_y2(dailyh_line, dailyh_open)
label.set_x(dailyh_label, dailyh_limit_right)
label.set_y(dailyh_label, dailyh_open)
label.set_text(dailyh_label, pdhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailyh_open, dailyh_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW
if is_dailyrange_enabled
dailyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
dailyl_time := get_limit_right(radistance)
dailyl_time
var dailyl_line = line.new(x1=dailyl_time, x2=dailyl_limit_right, y1=dailyl_open, y2=dailyl_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailyl_label = label.new(x=dailyl_limit_right, y=dailyl_open, text=pdltext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailyl_line, dailyl_time)
line.set_x2(dailyl_line, dailyl_limit_right)
line.set_y1(dailyl_line, dailyl_open)
line.set_y2(dailyl_line, dailyl_open)
label.set_x(dailyl_label, dailyl_limit_right)
label.set_y(dailyl_label, dailyl_open)
label.set_text(dailyl_label, pdltext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailyl_open, dailyl_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////// Daily MID
if is_dailym_enabled
dailym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
dailym_time = dailyh_time
dailym_open = (dailyl_open + dailyh_open) / 2
if displayStyle == 'Right Anchored'
dailym_time := get_limit_right(radistance)
dailym_time
var dailym_line = line.new(x1=dailym_time, x2=dailym_limit_right, y1=dailym_open, y2=dailym_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailym_label = label.new(x=dailym_limit_right, y=dailym_open, text=pdmtext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailym_line, dailym_time)
line.set_x2(dailym_line, dailym_limit_right)
line.set_y1(dailym_line, dailym_open)
line.set_y2(dailym_line, dailym_open)
label.set_x(dailym_label, dailym_limit_right)
label.set_y(dailym_label, dailym_open)
label.set_text(dailym_label, pdmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailym_open, dailym_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
if is_weekly_enabled
weekly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
cweekly_time = weekly_time
if displayStyle == 'Right Anchored'
cweekly_time := get_limit_right(radistance)
cweekly_time
var weekly_line = line.new(x1=cweekly_time, x2=weekly_limit_right, y1=weekly_open, y2=weekly_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weekly_label = label.new(x=weekly_limit_right, y=weekly_open, text=wotext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weekly_line, cweekly_time)
line.set_x2(weekly_line, weekly_limit_right)
line.set_y1(weekly_line, weekly_open)
line.set_y2(weekly_line, weekly_open)
label.set_x(weekly_label, weekly_limit_right)
label.set_y(weekly_label, weekly_open)
label.set_text(weekly_label, wotext)
if mergebool
f_LevelMerge(pricearray, labelarray, weekly_open, weekly_label, WeeklyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
// if is_weekly_open and can_show_daily
// label.set_text(weekly_label, "DO / WO ")
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// WEEKLY HIGH WEEKLY HIGH WEEKLY HIGH
if is_weeklyrange_enabled
weeklyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
weeklyh_time := get_limit_right(radistance)
weeklyh_time
var weeklyh_line = line.new(x1=weeklyh_time, x2=weeklyh_limit_right, y1=weeklyh_open, y2=weeklyh_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklyh_label = label.new(x=weeklyh_limit_right, y=weeklyh_open, text=pwhtext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklyh_line, weeklyh_time)
line.set_x2(weeklyh_line, weeklyh_limit_right)
line.set_y1(weeklyh_line, weeklyh_open)
line.set_y2(weeklyh_line, weeklyh_open)
label.set_x(weeklyh_label, weeklyh_limit_right)
label.set_y(weeklyh_label, weeklyh_open)
label.set_text(weeklyh_label, pwhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklyh_open, weeklyh_label, WeeklyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// WEEKLY LOW WEEKLY LOW WEEKLY LOW
if is_weeklyrange_enabled
weeklyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
weeklyl_time := get_limit_right(radistance)
weeklyl_time
var weeklyl_line = line.new(x1=weeklyl_time, x2=weeklyl_limit_right, y1=weekly_open, y2=weekly_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklyl_label = label.new(x=weeklyl_limit_right, y=weeklyl_open, text=pwltext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklyl_line, weeklyl_time)
line.set_x2(weeklyl_line, weeklyl_limit_right)
line.set_y1(weeklyl_line, weeklyl_open)
line.set_y2(weeklyl_line, weeklyl_open)
label.set_x(weeklyl_label, weeklyl_limit_right)
label.set_y(weeklyl_label, weeklyl_open)
label.set_text(weeklyl_label, pwltext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklyl_open, weeklyl_label, WeeklyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// Weekly MID
if is_weekly_mid
weeklym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
weeklym_time = weeklyh_time
weeklym_open = (weeklyl_open + weeklyh_open) / 2
if displayStyle == 'Right Anchored'
weeklym_time := get_limit_right(radistance)
weeklym_time
var weeklym_line = line.new(x1=weeklym_time, x2=weeklym_limit_right, y1=weeklym_open, y2=weeklym_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklym_label = label.new(x=weeklym_limit_right, y=weeklym_open, text=pwmtext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklym_line, weeklym_time)
line.set_x2(weeklym_line, weeklym_limit_right)
line.set_y1(weeklym_line, weeklym_open)
line.set_y2(weeklym_line, weeklym_open)
label.set_x(weeklym_label, weeklym_limit_right)
label.set_y(weeklym_label, weeklym_open)
label.set_text(weeklym_label, pwmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklym_open, weeklym_label, WeeklyColor)
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY LOW LOW LOW
if is_yearlyrange_enabled
yearlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearlyl_time := get_limit_right(radistance)
yearlyl_time
var yearlyl_line = line.new(x1=yearlyl_time, x2=yearlyl_limit_right, y1=yearlyl_open, y2=yearlyl_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlyl_label = label.new(x=yearlyl_limit_right, y=yearlyl_open, text=cyltext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlyl_line, yearlyl_time)
line.set_x2(yearlyl_line, yearlyl_limit_right)
line.set_y1(yearlyl_line, yearlyl_open)
line.set_y2(yearlyl_line, yearlyl_open)
label.set_x(yearlyl_label, yearlyl_limit_right)
label.set_y(yearlyl_label, yearlyl_open)
label.set_text(yearlyl_label, cyltext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlyl_open, yearlyl_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY HIGH HIGH HIGH
if is_yearlyrange_enabled
yearlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearlyh_time := get_limit_right(radistance)
yearlyh_time
var yearlyh_line = line.new(x1=yearlyh_time, x2=yearlyh_limit_right, y1=yearlyh_open, y2=yearlyh_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlyh_label = label.new(x=yearlyh_limit_right, y=yearlyh_open, text=cyhtext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlyh_line, yearlyh_time)
line.set_x2(yearlyh_line, yearlyh_limit_right)
line.set_y1(yearlyh_line, yearlyh_open)
line.set_y2(yearlyh_line, yearlyh_open)
label.set_x(yearlyh_label, yearlyh_limit_right)
label.set_y(yearlyh_label, yearlyh_open)
label.set_text(yearlyh_label, cyhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlyh_open, yearlyh_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY OPEN
if is_yearly_enabled
yearly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearly_time := get_limit_right(radistance)
yearly_time
var yearly_line = line.new(x1=yearly_time, x2=yearly_limit_right, y1=yearly_open, y2=yearly_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearly_label = label.new(x=yearly_limit_right, y=yearly_open, text=yotext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearly_line, yearly_time)
line.set_x2(yearly_line, yearly_limit_right)
line.set_y1(yearly_line, yearly_open)
line.set_y2(yearly_line, yearly_open)
label.set_x(yearly_label, yearly_limit_right)
label.set_y(yearly_label, yearly_open)
label.set_text(yearly_label, yotext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearly_open, yearly_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// yearly MID
if is_yearly_mid
yearlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
yearlym_time = yearlyh_time
yearlym_open = (yearlyl_open + yearlyh_open) / 2
if displayStyle == 'Right Anchored'
yearlym_time := get_limit_right(radistance)
yearlym_time
var yearlym_line = line.new(x1=yearlym_time, x2=yearlym_limit_right, y1=yearlym_open, y2=yearlym_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlym_label = label.new(x=yearlym_limit_right, y=yearlym_open, text=cymtext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlym_line, yearlym_time)
line.set_x2(yearlym_line, yearlym_limit_right)
line.set_y1(yearlym_line, yearlym_open)
line.set_y2(yearlym_line, yearlym_open)
label.set_x(yearlym_label, yearlym_limit_right)
label.set_y(yearlym_label, yearlym_open)
label.set_text(yearlym_label, cymtext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlym_open, yearlym_label, YearlyColor)
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY OPEN
if is_quarterly_enabled
quarterly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterly_time := get_limit_right(radistance)
quarterly_time
var quarterly_line = line.new(x1=quarterly_time, x2=quarterly_limit_right, y1=quarterly_open, y2=quarterly_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterly_label = label.new(x=quarterly_limit_right, y=quarterly_open, text=qotext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterly_line, quarterly_time)
line.set_x2(quarterly_line, quarterly_limit_right)
line.set_y1(quarterly_line, quarterly_open)
line.set_y2(quarterly_line, quarterly_open)
label.set_x(quarterly_label, quarterly_limit_right)
label.set_y(quarterly_label, quarterly_open)
label.set_text(quarterly_label, qotext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterly_open, quarterly_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY High
if is_quarterlyrange_enabled
quarterlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterlyh_time := get_limit_right(radistance)
quarterlyh_time
var quarterlyh_line = line.new(x1=quarterlyh_time, x2=quarterlyh_limit_right, y1=quarterlyh_open, y2=quarterlyh_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlyh_label = label.new(x=quarterlyh_limit_right, y=quarterlyh_open, text=pqhtext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlyh_line, quarterlyh_time)
line.set_x2(quarterlyh_line, quarterlyh_limit_right)
line.set_y1(quarterlyh_line, quarterlyh_open)
line.set_y2(quarterlyh_line, quarterlyh_open)
label.set_x(quarterlyh_label, quarterlyh_limit_right)
label.set_y(quarterlyh_label, quarterlyh_open)
label.set_text(quarterlyh_label, pqhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlyh_open, quarterlyh_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY Low
if is_quarterlyrange_enabled
quarterlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterlyl_time := get_limit_right(radistance)
quarterlyl_time
var quarterlyl_line = line.new(x1=quarterlyl_time, x2=quarterlyl_limit_right, y1=quarterlyl_open, y2=quarterlyl_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlyl_label = label.new(x=quarterlyl_limit_right, y=quarterlyl_open, text=pqltext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlyl_line, quarterlyl_time)
line.set_x2(quarterlyl_line, quarterlyl_limit_right)
line.set_y1(quarterlyl_line, quarterlyl_open)
line.set_y2(quarterlyl_line, quarterlyl_open)
label.set_x(quarterlyl_label, quarterlyl_limit_right)
label.set_y(quarterlyl_label, quarterlyl_open)
label.set_text(quarterlyl_label, pqltext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlyl_open, quarterlyl_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY MID
if is_quarterly_mid
quarterlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
quarterlym_time = quarterlyh_time
quarterlym_open = (quarterlyl_open + quarterlyh_open) / 2
if displayStyle == 'Right Anchored'
quarterlym_time := get_limit_right(radistance)
quarterlym_time
var quarterlym_line = line.new(x1=quarterlym_time, x2=quarterlym_limit_right, y1=quarterlym_open, y2=quarterlym_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlym_label = label.new(x=quarterlym_limit_right, y=quarterlym_open, text=pqmtext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlym_line, quarterlym_time)
line.set_x2(quarterlym_line, quarterlym_limit_right)
line.set_y1(quarterlym_line, quarterlym_open)
line.set_y2(quarterlym_line, quarterlym_open)
label.set_x(quarterlym_label, quarterlym_limit_right)
label.set_y(quarterlym_label, quarterlym_open)
label.set_text(quarterlym_label, pqmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlym_open, quarterlym_label, quarterlyColor)
////////////////////////////////////////////////////////////////////////////////// Monthly LOW LOW LOW
if is_monthlyrange_enabled
monthlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthlyl_time := get_limit_right(radistance)
monthlyl_time
var monthlyl_line = line.new(x1=monthlyl_time, x2=monthlyl_limit_right, y1=monthlyl_open, y2=monthlyl_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyl_label = label.new(x=monthlyl_limit_right, y=monthlyl_open, text=pmltext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyl_line, monthlyl_time)
line.set_x2(monthlyl_line, monthlyl_limit_right)
line.set_y1(monthlyl_line, monthlyl_open)
line.set_y2(monthlyl_line, monthlyl_open)
label.set_x(monthlyl_label, monthlyl_limit_right)
label.set_y(monthlyl_label, monthlyl_open)
label.set_text(monthlyl_label, pmltext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlyl_open, monthlyl_label, MonthlyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// MONTHLY HIGH HIGH HIGH
if is_monthlyrange_enabled
monthlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthlyh_time := get_limit_right(radistance)
monthlyh_time
var monthlyh_line = line.new(x1=monthlyh_time, x2=monthlyh_limit_right, y1=monthlyh_open, y2=monthlyh_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyh_label = label.new(x=monthlyh_limit_right, y=monthlyh_open, text=pmhtext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyh_line, monthlyl_time)
line.set_x2(monthlyh_line, monthlyh_limit_right)
line.set_y1(monthlyh_line, monthlyh_open)
line.set_y2(monthlyh_line, monthlyh_open)
label.set_x(monthlyh_label, monthlyh_limit_right)
label.set_y(monthlyh_label, monthlyh_open)
label.set_text(monthlyh_label, pmhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlyh_open, monthlyh_label, MonthlyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
//////////////////////////////////////////////////////////////////////////////// MONTHLY MID
if is_monthly_mid
monthlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
monthlym_time = monthlyh_time
monthlym_open = (monthlyl_open + monthlyh_open) / 2
if displayStyle == 'Right Anchored'
monthlym_time := get_limit_right(radistance)
monthlym_time
var monthlym_line = line.new(x1=monthlym_time, x2=monthlym_limit_right, y1=monthlym_open, y2=monthlym_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlym_label = label.new(x=monthlym_limit_right, y=monthlym_open, text=pmmtext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlym_line, monthlym_time)
line.set_x2(monthlym_line, monthlym_limit_right)
line.set_y1(monthlym_line, monthlym_open)
line.set_y2(monthlym_line, monthlym_open)
label.set_x(monthlym_label, monthlym_limit_right)
label.set_y(monthlym_label, monthlym_open)
label.set_text(monthlym_label, pmmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlym_open, monthlym_label, MonthlyColor)
//////////////////////////////////////////////////////////////////////////////////
if is_monthly_enabled
monthly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthly_time := get_limit_right(radistance)
monthly_time
var monthlyLine = line.new(x1=monthly_time, x2=monthly_limit_right, y1=monthly_open, y2=monthly_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyLabel = label.new(x=monthly_limit_right, y=monthly_open, text=motext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyLine, monthly_time)
line.set_x2(monthlyLine, monthly_limit_right)
line.set_y1(monthlyLine, monthly_open)
line.set_y2(monthlyLine, monthly_open)
label.set_x(monthlyLabel, monthly_limit_right)
label.set_y(monthlyLabel, monthly_open)
label.set_text(monthlyLabel, motext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthly_open, monthlyLabel, MonthlyColor)
/////////////////////////////////////////////////////////////////////////////
// the monthly open can be the weekly open (monday 1st) and/or daily open too
// only the monthly will be draw, in these case we update its label
// if is_monthly_open
// if can_show_daily
// label.set_text(monthlyLabel, "DO / MO ")
// if is_weekly_open
// if can_show_weekly
// label.set_text(monthlyLabel, "WO / MO ")
// if can_show_daily and can_show_weekly
// label.set_text(monthlyLabel, "DO / WO / MO ")
// the start of the line is drew from the first week of the month
// if the first day of the weekly candle (monday) is the 2nd of the month
// we fix the start of the line position on the Prev weekly candle
if timeframe.isweekly and dayofweek(monthly_time) != dayofweek.monday
line.set_x1(monthlyLine, monthly_time - (weekly_time - weekly_time ))
ADR % RangesThis indicator is designed to visually represent percentage lines from the open of the day. The % amount is determined by X amount of the last days to create an average...or Average Daily Range (ADR).
1. ADR Percentage Lines: The core function of the script is to apply lines to the chart that represent specific percentage changes from the daily open. It first calculates the average over X amount of days and then displays two lines that are 1/3rd of that average. One line goes above the other line goes below. The other two lines are the full "range" of the average. These lines can act as boundaries or targets to know how an asset has moved recently. *Past performance is not indicative of current or future results.
The calculation for ADR is:
Step 1. Calculate Today's Range = DailyHigh - DailyLow
Step 2. Store this average after the day has completed
Step 3. Sum all day's ranges
Step 4. Divide by total number of days
Step 5. Draw on chart
2. Customizable Inputs: Users have the flexibility to customize the script through various inputs. This includes the option to display lines only for the current trading day (`todayonly`), and to select which lines are displayed. The user can also opt to show a table the displays the total range of previous days and the average range of those previous days.
3. No Secondary Timeframe: The ADR is computed based on whatever timeframe the chart is and does not reference secondary periods. Therefore the script cannot be used on charts greater than daily.
This script is can be used by all traders for any market. The trader might have to adjust the "X" number of days back to compute a historical average. Maybe they only want to know the average over the past week (5 days) or maybe the past month (20 days).
Naveen Prabhu with EMA//@version=6
indicator('Naveen Prabhu with EMA', overlay = true, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
a = input(2, title = 'Key Vaule. \'This changes the sensitivity\'')
c = input(5, title = 'ATR Period')
h = input(false, title = 'Signals from Heikin Ashi Candles')
BULLISH_LEG = 1
BEARISH_LEG = 0
BULLISH = +1
BEARISH = -1
GREEN = #089981
RED = #F23645
BLUE = #2157f3
GRAY = #878b94
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b
HISTORICAL = 'Historical'
PRESENT = 'Present'
COLORED = 'Colored'
MONOCHROME = 'Monochrome'
ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'
TINY = size.tiny
SMALL = size.small
NORMAL = size.normal
ATR = 'Atr'
RANGE = 'Cumulative Mean Range'
CLOSE = 'Close'
HIGHLOW = 'High/Low'
SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'
SMART_GROUP = 'Smart Money Concepts'
INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'
modeTooltip = 'Allows to display historical Structure or only the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart'
modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = )
styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = )
showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip)
showInternalsInput = input( false, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = )
internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = )
internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = )
showStructureInput = input( false, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = )
swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = )
swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = )
showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( false, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)
showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob')
internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( true, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = )
internalBullishOrderBlockColor = input.color(color.new(GREEN, 80), 'Internal Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#f77c80, 80), 'Internal Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(GREEN, 80), 'Bullish OB', group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#b22833, 80), 'Bearish OB', group = BLOCKS_GROUP)
showEqualHighsLowsInput = input( false, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = )
showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = )
dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = )
weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = )
monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly')
showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP)
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox
type trend
int bias
type equalDisplay
line l_ine = na
label l_abel = na
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
type orderBlock
float barHigh
float barLow
int barTime
int bias
// @variable current swing pivot high
var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array fairValueGaps = array.new()
// @variable storage for parsed highs
var array parsedHighs = array.new()
// @variable storage for parsed lows
var array parsedLows = array.new()
// @variable storage for raw highs
var array highs = array.new()
// @variable storage for raw lows
var array lows = array.new()
// @variable storage for bar time values
var array times = array.new()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing order blocks)
var array swingOrderBlocks = array.new()
// @variable storage for orderBlock UDTs (internal order blocks)
var array internalOrderBlocks = array.new()
// @variable storage for swing order blocks boxes
var array swingOrderBlocksBoxes = array.new()
// @variable storage for internal order blocks boxes
var array internalOrderBlocksBoxes = array.new()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time
// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
// @variable source to use in bearish order blocks mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high
// @variable source to use in bullish order blocks mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)
leg(int size) =>
var leg = 0
newLegHigh = high > ta.highest( size)
newLegLow = low < ta.lowest( size)
if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg
startOfNewLeg(int leg) => ta.change(leg) != 0
startOfBearishLeg(int leg) => ta.change(leg) == -1
startOfBullishLeg(int leg) => ta.change(leg) == +1
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) =>
var label l_abel = na
if modeInput == PRESENT
l_abel.delete()
l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small)
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay
string tag = 'EQL'
color equalColor = swingBullishColor
string labelStyle = label.style_label_up
if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down
if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)
e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput)
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)
if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow
if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low , size, false)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh
if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high ,size,true)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)
if modeInput == PRESENT
l_ine.delete()
l_abel.delete()
l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle)
l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize)
deleteOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
for in orderBlocks
bool crossedOderBlock = false
if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput)
array a_rray = na
int parsedIndex = na
if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())
orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias)
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
if orderBlocks.size() >= 100
orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)
drawOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
orderBlocksSize = orderBlocks.size()
if orderBlocksSize > 0
maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize))
array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes
for in parsedOrdeBlocks
orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor)
box b_ox = b_oxes.get(index)
b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow))
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true
if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)
pivot p_ivot = internal ? internalHigh : swingHigh
trend t_rend = internal ? internalTrend : swingTrend
lineStyle = internal ? line.style_dashed : line.style_solid
labelSize = internal ? internalStructureSize : swingStructureSize
extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput
if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS
if internal
currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BULLISH
displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)
p_ivot := internal ? internalLow : swingLow
extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput
if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS
if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BEARISH
displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor)
deleteFairValueGaps() =>
for in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)
// @function draw fair value gaps
// @returns fairValueGap ID
drawFairValueGaps() =>
= request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on)
barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)
newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0
bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe
if bullishFairValueGap
currentAlerts.bullishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor)))
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
= request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on)
float parsedTop = sameTimeframe ? high : topLevel
float parsedBottom = sameTimeframe ? low : bottomLevel
int parsedLeftTime = sameTimeframe ? time : leftTime
int parsedRightTime = sameTimeframe ? time : rightTime
int parsedTopTime = time
int parsedBottomTime = time
if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex = times.binary_search_rightmost(parsedRightTime)
array timeArray = times.slice(leftIndex,rightIndex)
array topArray = highs.slice(leftIndex,rightIndex)
array bottomArray = lows.slice(leftIndex,rightIndex)
parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime
var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny)
rightTimeBar = last_bar_time + 20 * (time - time )
topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High')
bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low')
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)
b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))
l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))
// @function draw premium/discount zones
// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down)
equilibriumLevel = math.avg(trailing.top, trailing.bottom)
drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left)
drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up)
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor)
if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()
if showHighLowSwingsInput
drawHighLowSwings()
if showPremiumDiscountZonesInput
drawPremiumDiscountZones()
if showFairValueGapsInput
deleteFairValueGaps()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showInternalOrderBlocksInput or showTrendInput
displayStructure(true)
if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput
displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)
if showSwingOrderBlocksInput
deleteOrderBlocks()
if showFairValueGapsInput
drawFairValueGaps()
if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)
if showSwingOrderBlocksInput
drawOrderBlocks()
lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex
if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)
if showDailyLevelsInput and not higherTimeframe('D')
drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)
if showWeeklyLevelsInput and not higherTimeframe('W')
drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)
if showMonthlyLevelsInput and not higherTimeframe('M')
drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)
xATR = ta.atr(c)
nLoss = a * xATR
src = h ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close, lookahead = barmerge.lookahead_off) : close
xATRTrailingStop = 0.0
iff_1 = src > nz(xATRTrailingStop , 0) ? src - nLoss : src + nLoss
iff_2 = src < nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? math.min(nz(xATRTrailingStop ), src + nLoss) : iff_1
xATRTrailingStop := src > nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? math.max(nz(xATRTrailingStop ), src - nLoss) : iff_2
pos = 0
iff_3 = src > nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? -1 : nz(pos , 0)
pos := src < nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? 1 : iff_3
xcolor = pos == -1 ? color.red : pos == 1 ? color.green : color.blue
ema = ta.ema(src, 1)
above = ta.crossover(ema, xATRTrailingStop)
below = ta.crossover(xATRTrailingStop, ema)
buy = src > xATRTrailingStop and above
sell = src < xATRTrailingStop and below
barbuy = src > xATRTrailingStop
barsell = src < xATRTrailingStop
//---------------------------------------------------------------------------------------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed')
alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed')
alertcondition(buy, 'UT Long', 'UT Long')
alertcondition(sell, 'UT Short', 'UT Short')
plotshape(buy, title = 'Buy', text = 'Buy', style = shape.labelup, location = location.belowbar, color = color.new(color.green, 0), textcolor = color.new(color.white, 0), size = size.tiny)
plotshape(sell, title = 'Sell', text = 'Sell', style = shape.labeldown, location = location.abovebar, color = color.new(color.red, 0), textcolor = color.new(color.white, 0), size = size.tiny)
//--------------------------------------------------------------------------------------
// EMA ADDITIONS (Editable)
//--------------------------------------------------------------------------------------
ema5Len = input.int(5, "5 EMA Length", minval = 1)
ema9Len = input.int(9, "9 EMA Length", minval = 1)
ema5 = ta.ema(src, ema5Len)
ema9 = ta.ema(src, ema9Len)
plot(ema5, "EMA 5", color = color.red, linewidth = 2)
plot(ema9, "EMA 9", color = color.blue, linewidth = 2)
barcolor(barbuy ? color.green : na)
barcolor(barsell ? color.red : na)
Humble Student OB/OS Trifecta indicatorAfter reading Cam Hui's blog post about his "Trifecta" bottom spotting model I thought I'd try my hand at scripting it as an indicator. The results are pretty close to what he describes. Though the data TradingView feeds me doesn't seem to be identical to what he's using on StockCharts.com the results are close enough that I will call the effort a success worth publishing.
MTF 20 SMA Table - DXY**MTF 20 SMA Table - Multi-Timeframe Trend Analysis Dashboard**
**Overview:**
This indicator provides a comprehensive multi-timeframe analysis dashboard that displays the relationship between price and the 20-period Simple Moving Average (SMA) across four key timeframes: 15-minute, 1-hour, 4-hour, and Daily. It's designed to help traders quickly identify trend alignment and potential trading opportunities across multiple timeframes at a glance. It's definitely not perfect but has helped me speed up my backtesting efforts as it's worked well for me eliminating flipping back and forth between timeframes excpet when I have confluence on the table, then I check the HTF.
**How It Works:**
The indicator creates a table overlay on your chart showing three critical metrics for each timeframe:
1. **Price vs SMA (Row 1):** Shows whether price is currently above (bullish) or below (bearish) the 20 SMA
- Green = Price Above SMA
- Red = Price Below SMA
2. **SMA Direction (Row 2):** Indicates the trend direction of the SMA itself over a lookback period
- Green (↗ Rising) = Uptrend
- Red (↘ Falling) = Downtrend
- Gray (→ Flat) = Ranging/Consolidation
3. **Strength (Row 3):** Displays the distance between current price and the SMA in pips
- Purple background = Strong move (>50 pips away)
- Orange background = Moderate move (20-50 pips)
- Gray background = Weak/consolidating (<20 pips)
- Text color: Green for positive distance, Red for negative
**Key Features:**
- **Customizable Table Position:** Place the table anywhere on your chart (9 position options)
- **Adjustable SMA Lengths:** Modify the SMA period for each timeframe independently (default: 20)
- **Direction Lookback Settings:** Fine-tune how far back the indicator looks to determine SMA direction for each timeframe
- **Flat Threshold:** Set the pip threshold for determining when an SMA is "flat" vs trending (default: 5 pips)
- **DXY Optimized:** Calculations are calibrated for the US Dollar Index (1 pip = 0.01)
**Best Use Cases:**
1. **Trend Alignment:** Identify when multiple timeframes align in the same direction for higher probability trades
2. **Divergence Spotting:** Detect when lower timeframes diverge from higher timeframes (potential reversals)
3. **Entry Timing:** Use lower timeframe signals while higher timeframes confirm overall trend
4. **Strength Assessment:** Gauge how extended price is from the mean (SMA) to avoid overextended entries
**Settings Guide:**
- **SMA Settings Group:** Adjust the SMA period for each timeframe (15M, 1H, 4H, Daily)
- **SMA Direction Group:** Control lookback periods to determine trend direction
- 15M: Default 5 candles
- 1H: Default 10 candles
- 4H: Default 15 candles
- Daily: Default 20 candles
- **Flat Threshold:** Set sensitivity for "flat" detection (lower = more sensitive to ranging markets)
**Trading Strategy Examples:**
1. **Trend Following:** Look for all timeframes showing the same direction (all green or all red)
2. **Pullback Trading:** When Daily/4H are green but 15M/1H show red, wait for lower timeframes to flip green for entry
3. **Ranging Markets:** When multiple SMAs show "flat", consider range-bound strategies
**Important Notes:**
- This is a reference tool only, not a standalone trading system
- Always use proper risk management and combine with other analysis methods
- Best suited for trending instruments like indices and major forex pairs
- Calculations are optimized for DXY but can be used on other instruments (pip calculations may need adjustment)
**Credits:**
Feel free to modify and improve this code! Suggestions for enhancements are welcome in the comments.
---
**Installation Instructions:**
1. Add the indicator to your TradingView chart
2. Adjust the table position via settings to avoid overlap with price action
3. Customize SMA lengths and lookback periods to match your trading style
4. Monitor the table for timeframe alignment and trend confirmation
---
This indicator is published as open source for the community to learn from and improve upon. Happy trading! 📈
BTC Backwardation SearcherThis Pine Script code is a custom indicator named "BTC Backwardation Searcher" designed for the TradingView platform. The indicator aims to identify and visualize the price difference between two Bitcoin futures contracts: CME:BTC1! and CME:BTC2!.
Here's a breakdown of the code:
1. The script fetches the daily close prices of CME:BTC1! and CME:BTC2! using the security() function.
2. It calculates the percentage price difference between the two contracts using the formula: (btc1Price - btc2Price) / btc2Price * 100.
3. The script also calculates the price difference for the previous two days (2 days ago and 3 days ago) using the same formula.
4. Two conditions are defined:
(1) dailyGreenCondition: If the price difference is greater than or equal to 0.3% for three
consecutive days, including the current day and the previous two days.
(2) dailyRedCondition(commented): If the price difference is less than or equal to -1% for three consecutive days, including the current day and the previous two days.
(I commented it out because I don't think it's useful.)
5. The plotshape() function is used to display green triangles on the chart when the dailyGreenCondition is met, and red triangles when the dailyRedCondition is met. These triangles are displayed on the daily, weekly, and monthly timeframes.
The purpose of this indicator is to help traders identify potential trading opportunities based on the price difference between the two Bitcoin futures contracts. The green triangles suggest a bullish scenario where CME:BTC1! is significantly higher than CME:BTC2!, while the red triangles indicate a bearish scenario where CME:BTC2! is significantly lower than CME:BTC1!.
However, it's important to note that this indicator should be used in conjunction with other technical analysis tools and fundamental analysis. Traders should also consider their risk tolerance, investment goals, and market conditions before making any trading decisions based on this indicator.
HTF Current/Average RangeThe "HTF(Higher Timeframe) Current/Average Range" indicator calculates and displays the current and average price ranges across multiple timeframes, including daily, weekly, monthly, 4 hour, and user-defined custom timeframes.
Users can customize the lookback period, table size, timeframe, and font color; with the indicator efficiently updating on the final bar to optimize performance.
When the current range surpasses the average range for a given timeframe, the corresponding table cell is highlighted in green, indicating potential maximum price expansion and signaling the possibility of an impending retracement or consolidation.
For day trading strategies, the daily average range can serve as a guide, allowing traders to hold positions until the current daily range approaches or meets the average range, at which point exiting the trade may be considered.
For scalping strategies, the 15min and 5min average range can be utilized to determine optimal holding periods for fast trades.
Other strategies:
Intraday Trading - 1h and 4h Average Range
Swing Trading - Monthly Average Range
Short-term Trading - Weekly Average Range
Also using these statistics in accordance with Power 3 ICT concepts, will assist in holding trades to their statistical average range of the chosen HTF candle.
CODE
The core functionality lies in the data retrieval and table population sections.
The request.security function (e.g., = request.security(syminfo.tickerid, "D", , lookahead = barmerge.lookahead_off)) retrieves high and low prices from specified timeframes without lookahead bias, ensuring accurate historical data.
These values are used to compute current ranges and average ranges (ta.sma(high - low, avgLength)), which are then displayed in a dynamically generated table starting at (if barstate.islast) using table.new, with conditional green highlighting when the current range is greater than average range, providing a clear visual cue for volatility analysis.
HMA & D1 crossover FX (Study)Can work on other Forex pairs if change settings: Period
This example tuned for AUDUSD (FX Version)
Enter new order on HMA ( Hull Moving Average ) and D1 ( Daily Candle) crossovers, Exit orders as basket when profit = Your Target Profit
This study version built for users of Alerts. Crossover of HMA and DailyCandle1 (and/or DailyCandle1 cross DailyCandle2) (also possible Price cross HMA)
Luxy Super-Duper SuperTrend Predictor Engine and Buy/Sell signalA professional trend-following grading system that analyzes historical trend
patterns to provide statistical duration estimates using advanced similarity
matching and k-nearest neighbors analysis. Combines adaptive Supertrend with
intelligent duration statistics, multi-timeframe confluence, volume confirmation,
and quality scoring to identify high-probability setups with data-driven
target ranges across all timeframes.
Note: All duration estimates are statistical calculations based on historical data, not guarantees of future performance.
WHAT MAKES THIS DIFFERENT
Unlike traditional SuperTrend indicators that only tell you trend direction, this system answers the critical question: "What is the typical duration for trends like this?"
The Statistical Analysis Engine:
• Analyzes your chart's last 15+ completed SuperTrend trends (bullish and bearish separately)
• Uses k-nearest neighbors similarity matching to find historically similar setups
• Calculates statistical duration estimates based on current market conditions
• Learns from estimation errors and adapts over time (Advanced mode)
• Displays visual duration analysis box showing median, average, and range estimates
• Tracks Statistical accuracy with backtest statistics
Complete Trading System:
• Statistical trend duration analysis with three intelligence levels
• Adaptive Supertrend with dynamic ATR-based bands
• Multi-timeframe confluence analysis (6 timeframes: 5M to 1W)
• Volume confirmation with spike detection and momentum tracking
• Quality scoring system (0-70 points) rating each setup
• One-click preset optimization for all trading styles
• Anti-repaint guarantee on all signals and duration estimates
METHODOLOGY CREDITS
This indicator's approach is inspired by proven trading methodologies from respected market educators:
• Mark Minervini - Volatility Contraction Pattern (VCP) and pullback entry techniques
• William O'Neil - Volume confirmation principles and institutional buying patterns (CANSLIM methodology)
• Dan Zanger - Volatility expansion entries and momentum breakout strategies
Important: These are educational references only. This indicator does not guarantee any specific trading results. Always conduct your own analysis and risk management.
KEY FEATURES
1. TREND DURATION ANALYSIS SYSTEM - The Core Innovation
The statistical analysis engine is what sets this indicator apart from standard SuperTrend systems. It doesn't just identify trend changes - it provides statistical analysis of potential duration.
How It Works:
Step 1: Historical Tracking
• Automatically records every completed SuperTrend trend (duration in bars)
• Maintains separate databases for bullish trends and bearish trends
• Stores up to 15 most recent trends of each type
• Captures market conditions at each trend flip: volume ratio, ATR ratio, quality score, price distance from SuperTrend, proximity to support/resistance
Step 2: Similarity Matching (k-Nearest Neighbors)
• When new trend begins, system compares current conditions to ALL historical flips
• Calculates similarity score based on:
- Volume similarity (30% weight) - Is volume behaving similarly?
- Volatility similarity (30% weight) - Is ATR/volatility similar?
- Quality similarity (20% weight) - Is setup strength comparable?
- Distance similarity (10% weight) - Is price distance from ST similar?
- Support/Resistance proximity (10% weight) - Similar structural context?
• Selects the 15 MOST SIMILAR historical trends (not just all trends)
• This is like asking: "When conditions looked like this before, how long did trends last?"
Step 3: Statistical Analysis
• Calculates median duration (most common outcome)
• Calculates average duration (mean of similar trends)
• Determines realistic range (min to max of similar trends)
• Applies exponential weighting (recent trends weighted more heavily)
• Outputs confidence-weighted statistical estimate
Step 4: Advanced Intelligence (Advanced Mode Only)
The Advanced mode applies five sophisticated multipliers to refine estimates:
A) Market Structure Multiplier (±30%):
• Detects nearby support/resistance levels using pivot detection
• If flip occurs NEAR a key level: Estimate adjusted -30% (expect bounce/rejection)
• If flip occurs in open space: Estimate adjusted +30% (clear path for continuation)
• Uses configurable lookback period and ATR-based proximity threshold
B) Asset Type Multiplier (±40%):
• Adjusts duration estimates based on asset volatility characteristics
• Small Cap / Biotech: +40% (explosive, extended moves)
• Tech Growth: +20% (momentum-driven, longer trends)
• Blue Chip / Large Cap: 0% (baseline, steady trends)
• Dividend / Value: -20% (slower, grinding trends)
• Cyclical: Variable based on macro regime
• Crypto / High Volatility: +30% (parabolic potential)
C) Flip Strength Multiplier (±20%):
• Analyzes the QUALITY of the trend flip itself
• Strong flip (high volume + expanding ATR + quality score 60+): +20%
• Weak flip (low volume + contracting ATR + quality score under 40): -20%
• Logic: Historical data shows that powerful flips tend to be followed by longer trends
D) Error Learning Multiplier (±15%):
• Tracks Statistical accuracy over last 10 completed trends
• Calculates error ratio: (estimated duration / Actual Duration)
• If system consistently over-estimates: Apply -15% correction
• If system consistently under-estimates: Apply +15% correction
• Learns and adapts to current market regime
E) Regime Detection Multiplier (±20%):
• Analyzes last 3 trends of SAME TYPE (bull-to-bull or bear-to-bear)
• Compares recent trend durations to historical average
• If recent trends 20%+ longer than average: +20% adjustment (trending regime detected)
• If recent trends 20%+ shorter than average: -20% adjustment (choppy regime detected)
• Detects whether market is in trending or mean-reversion mode
Three analysis modes:
SIMPLE MODE - Basic Statistics
• Uses raw median of similar trends only
• No multipliers, no adjustments
• Best for: Beginners, clean trending markets
• Fastest calculations, minimal complexity
STANDARD MODE - Full Statistical Analysis
• Similarity matching with k-nearest neighbors
• Exponential weighting of recent trends
• Median, average, and range calculations
• Best for: Most traders, general market conditions
• Balance of accuracy and simplicity
ADVANCED MODE - Statistics + Intelligence
• Everything in Standard mode PLUS
• All 5 advanced multipliers (structure, asset type, flip strength, learning, regime)
• Highest Statistical accuracy in testing
• Best for: Experienced traders, volatile/complex markets
• Maximum intelligence, most adaptive
Visual Duration Analysis Box:
When a new trend begins (SuperTrend flip), a box appears on your chart showing:
• Analysis Mode (Simple / Standard / Advanced)
• Number of historical trends analyzed
• Median expected duration (most likely outcome)
• Average expected duration (mean of similar trends)
• Range (minimum to maximum from similar trends)
• Advanced multipliers breakdown (Advanced mode only)
• Backtest accuracy statistics (if available)
The box extends from the flip bar to the estimated endpoint based on historical data, giving you a visual target for trend duration. Box updates in real-time as trend progresses.
Backtest & Accuracy Tracking:
• System backtests its own duration estimates using historical data
• Shows accuracy metrics: how well duration estimates matched actual durations
• Tracks last 10 completed duration estimates separately
• Displays statistics in dashboard and duration analysis boxes
• Helps you understand statistical reliability on your specific symbol/timeframe
Anti-Repaint Guarantee:
• duration analysis boxes only appear AFTER bar close (barstate.isconfirmed)
• Historical duration estimates never disappear or change
• What you see in history is exactly what you would have seen real-time
• No future data leakage, no lookahead bias
2. INTELLIGENT PRESET CONFIGURATIONS - One-Click Optimization
Unlike indicators that require tedious parameter tweaking, this system includes professionally optimized presets for every trading style. Select your approach from the dropdown and ALL parameters auto-configure.
"AUTO (DETECT FROM TF)" - RECOMMENDED
The smartest option: automatically selects optimal settings based on your chart timeframe.
• 1m-5m charts → Scalping preset (ATR: 7, Mult: 2.0)
• 15m-1h charts → Day Trading preset (ATR: 10, Mult: 2.5)
• 2h-4h-D charts → Swing Trading preset (ATR: 14, Mult: 3.0)
• W-M charts → Position Trading preset (ATR: 21, Mult: 4.0)
Benefits:
• Zero configuration - works immediately
• Always matched to your timeframe
• Switch timeframe = automatic adjustment
• Perfect for traders who use multiple timeframes
"SCALPING (1-5M)" - Ultra-Fast Signals
Optimized for: 1-5 minute charts, high-frequency trading, quick profits
Target holding period: Minutes to 1-2 hours maximum
Best markets: High-volume stocks, major crypto pairs, active futures
Parameter Configuration:
• Supertrend: ATR 7, Multiplier 2.0 (very sensitive)
• Volume: MA 10, High 1.8x, Spike 3.0x (catches quick surges)
• Volume Momentum: AUTO-DISABLED (too restrictive for fast scalping)
• Quality minimum: 40 points (accepts more setups)
• Duration Analysis: Uses last 15 trends with heavy recent weighting
Trading Logic:
Speed over precision. Short ATR period and low multiplier create highly responsive SuperTrend. Volume momentum filter disabled to avoid missing fast moves. Quality threshold relaxed to catch more opportunities in rapid market conditions.
Signals per session: 5-15 typically
Hold time: Minutes to couple hours
Best for: Active traders with fast execution
"DAY TRADING (15M-1H)" - Balanced Approach
Optimized for: 15-minute to 1-hour charts, intraday moves, session-based trading
Target holding period: 30 minutes to 8 hours (within trading day)
Best markets: Large-cap stocks, major indices, established crypto
Parameter Configuration:
• Supertrend: ATR 10, Multiplier 2.5 (balanced)
• Volume: MA 20, High 1.5x, Spike 2.5x (standard detection)
• Volume Momentum: 5/20 periods (confirms intraday strength)
• Quality minimum: 50 points (good setups preferred)
• Duration Analysis: Balanced weighting of recent vs historical
Trading Logic:
The most balanced configuration. ATR 10 with multiplier 2.5 provides steady trend following that avoids noise while catching meaningful moves. Volume momentum confirms institutional participation without being overly restrictive.
Signals per session: 2-5 typically
Hold time: 30 minutes to full day
Best for: Part-time and full-time active traders
"SWING TRADING (4H-D)" - Trend Stability
Optimized for: 4-hour to Daily charts, multi-day holds, trend continuation
Target holding period: 2-15 days typically
Best markets: Growth stocks, sector ETFs, trending crypto, commodity futures
Parameter Configuration:
• Supertrend: ATR 14, Multiplier 3.0 (stable)
• Volume: MA 30, High 1.3x, Spike 2.2x (accumulation focus)
• Volume Momentum: 10/30 periods (trend stability)
• Quality minimum: 60 points (high-quality setups only)
• Duration Analysis: Favors consistent historical patterns
Trading Logic:
Designed for substantial trend moves while filtering short-term noise. Higher ATR period and multiplier create stable SuperTrend that won't flip on minor corrections. Stricter quality requirements ensure only strongest setups generate signals.
Signals per week: 2-5 typically
Hold time: Days to couple weeks
Best for: Part-time traders, swing style
"POSITION TRADING (D-W)" - Long-Term Trends
Optimized for: Daily to Weekly charts, major trend changes, portfolio allocation
Target holding period: Weeks to months
Best markets: Blue-chip stocks, major indices, established cryptocurrencies
Parameter Configuration:
• Supertrend: ATR 21, Multiplier 4.0 (very stable)
• Volume: MA 50, High 1.2x, Spike 2.0x (long-term accumulation)
• Volume Momentum: 20/50 periods (major trend confirmation)
• Quality minimum: 70 points (excellent setups only)
• Duration Analysis: Heavy emphasis on multi-year historical data
Trading Logic:
Conservative approach focusing on major trend changes. Extended ATR period and high multiplier create SuperTrend that only flips on significant reversals. Very strict quality filters ensure signals represent genuine long-term opportunities.
Signals per month: 1-2 typically
Hold time: Weeks to months
Best for: Long-term investors, set-and-forget approach
"CUSTOM" - Advanced Configuration
Purpose: Complete manual control for experienced traders
Use when: You understand the parameters and want specific optimization
Best for: Testing new approaches, unusual market conditions, specific instruments
Full control over:
• All SuperTrend parameters
• Volume thresholds and momentum periods
• Quality scoring weights
• analysis mode and multipliers
• Advanced features tuning
Preset Comparison Quick Reference:
Chart Timeframe: Scalping (1M-5M) | Day Trading (15M-1H) | Swing (4H-D) | Position (D-W)
Signals Frequency: Very High | High | Medium | Low
Hold Duration: Minutes | Hours | Days | Weeks-Months
Quality Threshold: 40 pts | 50 pts | 60 pts | 70 pts
ATR Sensitivity: Highest | Medium | Lower | Lowest
Time Investment: Highest | High | Medium | Lowest
Experience Level: Expert | Advanced | Intermediate | Beginner+
3. QUALITY SCORING SYSTEM (0-70 Points)
Every signal is rated in real-time across three dimensions:
Volume Confirmation (0-30 points):
• Volume Spike (2.5x+ average): 30 points
• High Volume (1.5x+ average): 20 points
• Above Average (1.0x+ average): 10 points
• Below Average: 0 points
Volatility Assessment (0-30 points):
• Expanding ATR (1.2x+ average): 30 points
• Rising ATR (1.0-1.2x average): 15 points
• Contracting/Stable ATR: 0 points
Volume Momentum (0-10 points):
• Strong Momentum (1.2x+ ratio): 10 points
• Rising Momentum (1.0-1.2x ratio): 5 points
• Weak/Neutral Momentum: 0 points
Score Interpretation:
60-70 points - EXCELLENT:
• All factors aligned
• High conviction setup
• Maximum position size (within risk limits)
• Primary trading opportunities
45-59 points - STRONG:
• Multiple confirmations present
• Above-average setup quality
• Standard position size
• Good trading opportunities
30-44 points - GOOD:
• Basic confirmations met
• Acceptable setup quality
• Reduced position size
• Wait for additional confirmation or trade smaller
Below 30 points - WEAK:
• Minimal confirmations
• Low probability setup
• Consider passing
• Only for aggressive traders in strong trends
Only signals meeting your minimum quality threshold (configurable per preset) generate alerts and labels.
4. MULTI-TIMEFRAME CONFLUENCE ANALYSIS
The system can simultaneously analyze trend alignment across 6 timeframes (optional feature):
Timeframes analyzed:
• 5-minute (scalping context)
• 15-minute (intraday momentum)
• 1-hour (day trading bias)
• 4-hour (swing context)
• Daily (primary trend)
• Weekly (macro trend)
Confluence Interpretation:
• 5-6/6 aligned - Very strong multi-timeframe agreement (highest confidence)
• 3-4/6 aligned - Moderate agreement (standard setup)
• 1-2/6 aligned - Weak agreement (caution advised)
Dashboard shows real-time alignment count with color-coding. Higher confluence typically correlates with longer, stronger trends.
5. VOLUME MOMENTUM FILTER - Institutional Money Flow
Unlike traditional volume indicators that just measure size, Volume Momentum tracks the RATE OF CHANGE in volume:
How it works:
• Compares short-term volume average (fast period) to long-term average (slow period)
• Ratio above 1.0 = Volume accelerating (money flowing IN)
• Ratio above 1.2 = Strong acceleration (institutional participation likely)
• Ratio below 0.8 = Volume decelerating (money flowing OUT)
Why it matters:
• Confirms trend with actual money flow, not just price
• Leading indicator (volume often leads price)
• Catches accumulation/distribution before breakouts
• More intuitive than complex mathematical filters
Integration with signals:
• Optional filter - can be enabled/disabled per preset
• When enabled: Only signals with rising volume momentum fire
• AUTO-DISABLED in Scalping mode (too restrictive for fast trading)
• Configurable fast/slow periods per trading style
6. ADAPTIVE SUPERTREND MULTIPLIER
Traditional SuperTrend uses fixed ATR multiplier. This system dynamically adjusts the multiplier (0.8x to 1.2x base) based on:
• Trend Strength: Price correlation over lookback period
• Volume Weight: Current volume relative to average
Benefits:
• Tighter bands in calm markets (less premature exits)
• Wider bands in volatile conditions (avoids whipsaws)
• Better adaptation to biotech, small-cap, and crypto volatility
• Optional - can be disabled for classic constant multiplier
7. VISUAL GRADIENT RIBBON
26-layer exponential gradient fill between price and SuperTrend line provides instant visual trend strength assessment:
Color System:
• Green shades - Bullish trend + volume confirmation (strongest)
• Blue shades - Bullish trend, normal volume
• Orange shades - Bearish trend + volume confirmation
• Red shades - Bearish trend (weakest)
Opacity varies based on:
• Distance from SuperTrend (farther = more opaque)
• Volume intensity (higher volume = stronger color)
The ribbon provides at-a-glance trend strength without cluttering your chart. Can be toggled on/off.
8. INTELLIGENT ALERT SYSTEM
Two-tier alert architecture for flexibility:
Automatic Alerts:
• Fire automatically on BUY and SELL signals
• Include full context: quality score, volume state, volume momentum
• One alert per bar close (alert.freq_once_per_bar_close)
• Message format: "BUY: Supertrend bullish + Quality: 65/70 | Volume: HIGH | Vol Momentum: STRONG (1.35x)"
Customizable Alert Conditions:
• Appear in TradingView's "Create Alert" dialog
• Three options: BUY Signal Only, SELL Signal Only, ANY Signal (BUY or SELL)
• Use TradingView placeholders: {{ticker}}, {{interval}}, {{close}}, {{time}}
• Fully customizable message templates
All alerts use barstate.isconfirmed - Zero repaint guarantee.
9. ANTI-REPAINT ARCHITECTURE
Every component guaranteed non-repainting:
• Entry signals: Only appear after bar close
• duration analysis boxes: Created only on confirmed SuperTrend flips
• Informative labels: Wait for bar confirmation
• Alerts: Fire once per closed bar
• Multi-timeframe data: Uses lookahead=barmerge.lookahead_off
What you see in history is exactly what you would have seen in real-time. No disappearing signals, no changed duration estimates.
HOW TO USE THE INDICATOR
QUICK START - 3 Steps to Trading:
Step 1: Select Your Trading Style
Open indicator settings → "Quick Setup" section → Trading Style Preset dropdown
Options:
• Auto (Detect from TF) - RECOMMENDED: Automatically configures based on your chart timeframe
• Scalping (1-5m) - For 1-5 minute charts, ultra-fast signals
• Day Trading (15m-1h) - For 15m-1h charts, balanced approach
• Swing Trading (4h-D) - For 4h-Daily charts, trend stability
• Position Trading (D-W) - For Daily-Weekly charts, long-term trends
• Custom - Manual configuration (advanced users only)
Choose "Auto" and you're done - all parameters optimize automatically.
Step 2: Understand the Signals
BUY Signal (Green Triangle Below Price):
• SuperTrend flipped bullish
• Quality score meets minimum threshold (varies by preset)
• Volume confirmation present (if filter enabled)
• Volume momentum rising (if filter enabled)
• duration analysis box shows expected trend duration
SELL Signal (Red Triangle Above Price):
• SuperTrend flipped bearish
• Quality score meets minimum threshold
• Volume confirmation present (if filter enabled)
• Volume momentum rising (if filter enabled)
• duration analysis box shows expected trend duration
Duration Analysis Box:
• Appears at SuperTrend flip (start of new trend)
• Shows median, average, and range duration estimates
• Extends to estimated endpoint based on historical data visually
• Updates mode-specific intelligence (Simple/Standard/Advanced)
Step 3: Use the Dashboard for Context
Dashboard (top-right corner) shows real-time metrics:
• Row 1 - Quality Score: Current setup rating (0-70)
• Row 2 - SuperTrend: Direction and current level
• Row 3 - Volume: Status (Spike/High/Normal/Low) with color
• Row 4 - Volatility: State (Expanding/Rising/Stable/Contracting)
• Row 5 - Volume Momentum: Ratio and trend
• Row 6 - Duration Statistics: Accuracy metrics and track record
Every cell has detailed tooltip - hover for full explanations.
SIGNAL INTERPRETATION BY QUALITY SCORE:
Excellent Setup (60-70 points):
• Quality Score: 60-70
• Volume: Spike or High
• Volatility: Expanding
• Volume Momentum: Strong (1.2x+)
• MTF Confluence (if enabled): 5-6/6
• Action: Primary trade - maximum position size (within risk limits)
• Statistical reliability: Highest - duration estimates most accurate
Strong Setup (45-59 points):
• Quality Score: 45-59
• Volume: High or Above Average
• Volatility: Rising
• Volume Momentum: Rising (1.0-1.2x)
• MTF Confluence (if enabled): 3-4/6
• Action: Standard trade - normal position size
• Statistical reliability: Good - duration estimates reliable
Good Setup (30-44 points):
• Quality Score: 30-44
• Volume: Above Average
• Volatility: Stable or Rising
• Volume Momentum: Neutral to Rising
• MTF Confluence (if enabled): 3-4/6
• Action: Cautious trade - reduced position size, wait for additional confirmation
• Statistical reliability: Moderate - duration estimates less certain
Weak Setup (Below 30 points):
• Quality Score: Below 30
• Volume: Low or Normal
• Volatility: Contracting or Stable
• Volume Momentum: Weak
• MTF Confluence (if enabled): 1-2/6
• Action: Pass or wait for improvement
• Statistical reliability: Low - duration estimates unreliable
USING duration analysis boxES FOR TRADE MANAGEMENT:
Entry Timing:
• Enter on SuperTrend flip (signal bar close)
• duration analysis box appears simultaneously
• Note the median duration - this is your expected hold time
Profit Targets:
• Conservative: Use MEDIAN duration as profit target (50% probability)
• Moderate: Use AVERAGE duration (mean of similar trends)
• Aggressive: Aim for MAX duration from range (best historical outcome)
Position Management:
• Scale out at median duration (take partial profits)
• Trail stop as trend extends beyond median
• Full exit at average duration or SuperTrend flip (whichever comes first)
• Re-evaluate if trend exceeds estimated range
analysis mode Selection:
• Simple: Clean trending markets, beginners, minimal complexity
• Standard: Most markets, most traders (recommended default)
• Advanced: Volatile markets, complex instruments, experienced traders seeking highest accuracy
Asset Type Configuration (Advanced Mode):
If using Advanced analysis mode, configure Asset Type for optimal accuracy:
• Small Cap: Stocks under $2B market cap, low liquidity
• Biotech / Speculative: Clinical-stage pharma, penny stocks, high-risk
• Blue Chip / Large Cap: S&P 500, mega-cap tech, stable large companies
• Tech Growth: High-growth tech (TSLA, NVDA, growth SaaS)
• Dividend / Value: Dividend aristocrats, value stocks, utilities
• Cyclical: Energy, materials, industrials (macro-driven)
• Crypto / High Volatility: Bitcoin, altcoins, highly volatile assets
Correct asset type selection improves Statistical accuracy by 15-20%.
RISK MANAGEMENT GUIDELINES:
1. Stop Loss Placement:
Long positions:
• Place stop below recent swing low OR
• Place stop below SuperTrend level (whichever is tighter)
• Use 1-2 ATR distance as guideline
• Recommended: SuperTrend level (built-in volatility adjustment)
Short positions:
• Place stop above recent swing high OR
• Place stop above SuperTrend level (whichever is tighter)
• Use 1-2 ATR distance as guideline
• Recommended: SuperTrend level
2. Position Sizing by Quality Score:
• Excellent (60-70): Maximum position size (2% risk per trade)
• Strong (45-59): Standard position size (1.5% risk per trade)
• Good (30-44): Reduced position size (1% risk per trade)
• Weak (Below 30): Pass or micro position (0.5% risk - learning trades only)
3. Exit Strategy Options:
Option A - Statistical Duration-Based Exit:
• Exit at median estimated duration (conservative)
• Exit at average estimated duration (moderate)
• Trail stop beyond average duration (aggressive)
Option B - Signal-Based Exit:
• Exit on opposite signal (SELL after BUY, or vice versa)
• Exit on SuperTrend flip (trend reversal)
• Exit if quality score drops below 30 mid-trend
Option C - Hybrid (Recommended):
• Take 50% profit at median estimated duration
• Trail stop on remaining 50% using SuperTrend as trailing level
• Full exit on SuperTrend flip or quality collapse
4. Trade Filtering:
For higher win-rate (fewer trades, better quality):
• Increase minimum quality score (try 60 for swing, 50 for day trading)
• Enable volume momentum filter (ensure institutional participation)
• Require higher MTF confluence (5-6/6 alignment)
• Use Advanced analysis mode with appropriate asset type
For more opportunities (more trades, lower quality threshold):
• Decrease minimum quality score (40 for day trading, 35 for scalping)
• Disable volume momentum filter
• Lower MTF confluence requirement
• Use Simple or Standard analysis mode
SETTINGS OVERVIEW
Quick Setup Section:
• Trading Style Preset: Auto / Scalping / Day Trading / Swing / Position / Custom
Dashboard & Display:
• Show Dashboard (ON/OFF)
• Dashboard Position (9 options: Top/Middle/Bottom + Left/Center/Right)
• Text Size (Auto/Tiny/Small/Normal/Large/Huge)
• Show Ribbon Fill (ON/OFF)
• Show SuperTrend Line (ON/OFF)
• Bullish Color (default: Green)
• Bearish Color (default: Red)
• Show Entry Labels - BUY/SELL signals (ON/OFF)
• Show Info Labels - Volume events (ON/OFF)
• Label Size (Auto/Tiny/Small/Normal/Large/Huge)
Supertrend Configuration:
• ATR Length (default varies by preset: 7-21)
• ATR Multiplier Base (default varies by preset: 2.0-4.0)
• Use Adaptive Multiplier (ON/OFF) - Dynamic 0.8x-1.2x adjustment
• Smoothing Factor (0.0-0.5) - EMA smoothing applied to bands
• Neutral Bars After Flip (0-10) - Hide ST immediately after flip
Volume Momentum:
• Enable Volume Momentum Filter (ON/OFF)
• Fast Period (default varies by preset: 3-20)
• Slow Period (default varies by preset: 10-50)
Volume Analysis:
• Volume MA Length (default varies by preset: 10-50)
• High Volume Threshold (default: 1.5x)
• Spike Threshold (default: 2.5x)
• Low Volume Threshold (default: 0.7x)
Quality Filters:
• Minimum Quality Score (0-70, varies by preset)
• Require Volume Confirmation (ON/OFF)
Trend Duration Analysis:
• Show Duration Analysis (ON/OFF) - Display duration analysis boxes
• analysis mode - Simple / Standard / Advanced
• Asset Type - 7 options (Small Cap, Biotech, Blue Chip, Tech Growth, Dividend, Cyclical, Crypto)
• Use Exponential Weighting (ON/OFF) - Recent trends weighted more
• Decay Factor (0.5-0.99) - How much more recent trends matter
• Structure Lookback (3-30) - Pivot detection period for support/resistance
• Proximity Threshold (xATR) - How close to level qualifies as "near"
• Enable Error Learning (ON/OFF) - System learns from estimation errors
• Memory Depth (3-20) - How many past errors to remember
Box Visual Settings:
• duration analysis box Border Color
• duration analysis box Background Color
• duration analysis box Text Color
• duration analysis box Border Width
• duration analysis box Transparency
Multi-Timeframe (Optional Feature):
• Enable MTF Confluence (ON/OFF)
• Minimum Alignment Required (0-6)
• Individual timeframe enable/disable toggles
• Custom timeframe selection options
All preset configurations override manual inputs except when "Custom" is selected.
ADVANCED FEATURES
1. Scalpel Mode (Optional)
Advanced pullback entry system that waits for healthy retracements within established trends before signaling entry:
• Monitors price distance from SuperTrend levels
• Requires pullback to configurable range (default: 30-50%)
• Ensures trend remains intact before entry signal
• Reduces whipsaw and false breakouts
• Inspired by Mark Minervini's VCP pullback entries
Best for: Swing traders and day traders seeking precision entries
Scalpers: Consider disabling for faster entries
2. Error Learning System (Advanced analysis mode Only)
The system learns from its own estimation errors:
• Tracks last 10-20 completed duration estimates (configurable memory depth)
• Calculates error ratio for each: estimated duration / Actual Duration
• If system consistently over-estimates: Applies negative correction (-15%)
• If system consistently under-estimates: Applies positive correction (+15%)
• Adapts to current market regime automatically
This self-correction mechanism improves accuracy over time as the system gathers more data on your specific symbol and timeframe.
3. Regime Detection (Advanced analysis mode Only)
Automatically detects whether market is in trending or choppy regime:
• Compares last 3 trends to historical average
• Recent trends 20%+ longer → Trending regime (+20% to estimates)
• Recent trends 20%+ shorter → Choppy regime (-20% to estimates)
• Applied separately to bullish and bearish trends
Helps duration estimates adapt to changing market conditions without manual intervention.
4. Exponential Weighting
Option to weight recent trends more heavily than distant history:
• Default decay factor: 0.9
• Recent trends get higher weight in statistical calculations
• Older trends gradually decay in importance
• Rationale: Recent market behavior more relevant than old data
• Can be disabled for equal weighting
5. Backtest Statistics
System backtests its own duration estimates using historical data:
• Walks through past trends chronologically
• Calculates what duration estimate WOULD have been at each flip
• Compares to actual duration that occurred
• Displays accuracy metrics in duration analysis boxes and dashboard
• Helps assess statistical reliability on your specific chart
Note: Backtest uses only data available AT THE TIME of each historical flip (no lookahead bias).
TECHNICAL SPECIFICATIONS
• Pine Script Version: v6
• Indicator Type: Overlay (draws on price chart)
• Max Boxes: 500 (for duration analysis box storage)
• Max Bars Back: 5000 (for comprehensive historical analysis)
• Security Calls: 1 (for MTF if enabled - optimized)
• Repainting: NO - All signals and duration estimates confirmed on bar close
• Lookahead Bias: NO - All HTF data properly offset, all duration estimates use only historical data
• Real-time Updates: YES - Dashboard and quality scores update live
• Alert Capable: YES - Both automatic alerts and customizable alert conditions
• Multi-Symbol: Works on stocks, crypto, forex, futures, indices
Performance Optimization:
• Conditional calculations (duration analysis can be disabled to reduce load)
• Efficient array management (circular buffers for trend storage)
• Streamlined gradient rendering (26 layers, can be toggled off)
• Smart label cooldown system (prevents label spam)
• Optimized similarity matching (analyzes only relevant trends)
Data Requirements:
• Minimum 50-100 bars for initial duration analysis (builds historical database)
• Optimal: 500+ bars for robust statistical analysis
• Longer history = more accurate duration estimates
• Works on any timeframe from 1 minute to monthly
KNOWN LIMITATIONS
• Trending Markets Only: Performs best in clear trends. May generate false signals in choppy/sideways markets (use quality score filtering and regime detection to mitigate)
• Lagging Nature: Like all trend-following systems, signals occur AFTER trend establishment, not at exact tops/bottoms. Use duration analysis boxes to set realistic profit targets.
• Initial Learning Period: Duration analysis system requires 10-15 completed trends to build reliable historical database. Early duration estimates less accurate (first few weeks on new symbol/timeframe).
• Visual Load: 26-layer gradient ribbon may slow performance on older devices. Disable ribbon if experiencing lag.
• Statistical accuracy Variables: Duration estimates are statistical estimates, not guarantees. Accuracy varies by:
- Market regime (trending vs choppy)
- Asset volatility characteristics
- Quality of historical pattern matches
- Timeframe traded (higher TF = more reliable)
• Not Best Suitable For:
- Ultra-short-term scalping (sub-1-minute charts)
- Mean-reversion strategies (designed for trend-following)
- Range-bound trading (requires trending conditions)
- News-driven spikes (estimates based on technical patterns, not fundamentals)
FREQUENTLY ASKED QUESTIONS
Q: Does this indicator repaint?
A: Absolutely not. All signals, duration analysis boxes, labels, and alerts use barstate.isconfirmed checks. They only appear after the bar closes. What you see in history is exactly what you would have seen in real-time. Zero repaint guarantee.
Q: How accurate are the trend duration estimates?
A: Accuracy varies by mode, market conditions, and historical data quality:
• Simple mode: 60-70% accuracy (within ±20% of actual duration)
• Standard mode: 70-80% accuracy (within ±20% of actual duration)
• Advanced mode: 75-85% accuracy (within ±20% of actual duration)
Best accuracy achieved on:
• Higher timeframes (4H, Daily, Weekly)
• Trending markets (not choppy/sideways)
• Assets with consistent behavior (Blue Chip, Large Cap)
• After 20+ historical trends analyzed (builds robust database)
Remember: All duration estimates are statistical calculations based on historical patterns, not guarantees.
Q: Which analysis mode should I use?
A:
• Simple: Beginners, clean trending markets, want minimal complexity
• Standard: Most traders, general market conditions (RECOMMENDED DEFAULT)
• Advanced: Experienced traders, volatile/complex markets (biotech, small-cap, crypto), seeking maximum accuracy
Advanced mode requires correct Asset Type configuration for optimal results.
Q: What's the difference between the trading style presets?
A: Each preset optimizes ALL parameters for a specific trading approach:
• Scalping: Ultra-sensitive (ATR 7, Mult 2.0), more signals, shorter holds
• Day Trading: Balanced (ATR 10, Mult 2.5), moderate signals, intraday holds
• Swing Trading: Stable (ATR 14, Mult 3.0), fewer signals, multi-day holds
• Position Trading: Very stable (ATR 21, Mult 4.0), rare signals, week/month holds
Auto mode automatically selects based on your chart timeframe.
Q: Should I use Auto mode or manually select a preset?
A: Auto mode is recommended for most traders. It automatically matches settings to your timeframe and re-optimizes if you switch charts. Only use manual preset selection if:
• You want scalping settings on a 15m chart (overriding auto-detection)
• You want swing settings on a 1h chart (more conservative than auto would give)
• You're testing different approaches on same timeframe
Q: Can I use this for scalping and day trading?
A: Absolutely! The preset system is specifically designed for all trading styles:
• Select "Scalping (1-5m)" for 1-5 minute charts
• Select "Day Trading (15m-1h)" for 15m-1h charts
• Or use "Auto" mode and it configures automatically
Volume momentum filter is auto-disabled in Scalping mode for faster signals.
Q: What is Volume Momentum and why does it matter?
A: Volume Momentum compares short-term volume (fast MA) to long-term volume (slow MA). It answers: "Is money flowing into this asset faster now than historically?"
Why it matters:
• Volume often leads price (early warning system)
• Confirms institutional participation (smart money)
• No lag like price-based indicators
• More intuitive than complex mathematical filters
When the ratio is above 1.2, you have strong evidence that institutions are accumulating (bullish) or distributing (bearish).
Q: How do I set up alerts?
A: Two options:
Option 1 - Automatic Alerts:
1. Right-click on chart → Add Alert
2. Condition: Select this indicator
3. Choose "Any alert() function call"
4. Configure notification method (app, email, webhook)
5. You'll receive detailed alerts on every BUY and SELL signal
Option 2 - Customizable Alert Conditions:
1. Right-click on chart → Add Alert
2. Condition: Select this indicator
3. You'll see three options in dropdown:
- "BUY Signal" (long signals only)
- "SELL Signal" (short signals only)
- "ANY Signal" (both BUY and SELL)
4. Choose desired option and customize message template
5. Uses TradingView placeholders: {{ticker}}, {{close}}, {{time}}, etc.
All alerts fire only on confirmed bar close (no repaint).
Q: What is Scalpel Mode and should I use it?
A: Scalpel Mode waits for healthy pullbacks within established trends before signaling entry. It reduces whipsaws and improves entry timing.
Recommended ON for:
• Swing traders (want precision entries on pullbacks)
• Day traders (willing to wait for better prices)
• Risk-averse traders (prefer fewer but higher-quality entries)
Recommended OFF for:
• Scalpers (need immediate entries, can't wait for pullbacks)
• Momentum traders (want to enter on breakout, not pullback)
• Aggressive traders (prefer more opportunities over precision)
Q: Why do some duration estimates show wider ranges than others?
A: Range width reflects historical trend variability:
• Narrow range: Similar historical trends had consistent durations (high confidence)
• Wide range: Similar historical trends had varying durations (lower confidence)
Wide ranges often occur:
• Early in analysis (fewer historical trends to learn from)
• In volatile/choppy markets (inconsistent trend behavior)
• On lower timeframes (more noise, less consistency)
The median and average still provide useful targets even when range is wide.
Q: Can I customize the dashboard position and appearance?
A: Yes! Dashboard settings include:
• Position: 9 options (Top/Middle/Bottom + Left/Center/Right)
• Text Size: Auto, Tiny, Small, Normal, Large, Huge
• Show/Hide: Toggle entire dashboard on/off
Choose position that doesn't overlap important price action on your specific chart.
Q: Which timeframe should I trade on?
A: Depends on your trading style and time availability:
• 1-5 minute: Active scalping, requires constant monitoring
• 15m-1h: Day trading, check few times per session
• 4h-Daily: Swing trading, check once or twice daily
• Daily-Weekly: Position trading, check weekly
General principle: Higher timeframes produce:
• Fewer signals (less frequent)
• Higher quality setups (stronger confirmations)
• More reliable duration estimates (better statistical data)
• Less noise (clearer trends)
Start with Daily chart if new to trading. Move to lower timeframes as you gain experience.
Q: Does this work on all markets (stocks, crypto, forex)?
A: Yes, it works on all markets with trending characteristics:
Excellent for:
• Stocks (especially growth and momentum names)
• Crypto (BTC, ETH, major altcoins)
• Futures (indices, commodities)
• Forex majors (EUR/USD, GBP/USD, etc.)
Best results on:
• Trending markets (not range-bound)
• Liquid instruments (tight spreads, good fills)
• Volatile assets (clear trend development)
Less effective on:
• Range-bound/sideways markets
• Ultra-low volatility instruments
• Illiquid small-caps (use caution)
Configure Asset Type (in Advanced analysis mode) to match your instrument for best accuracy.
Q: How many signals should I expect per day/week?
A: Highly variable based on:
By Timeframe:
• 1-5 minute: 5-15 signals per session
• 15m-1h: 2-5 signals per day
• 4h-Daily: 2-5 signals per week
• Daily-Weekly: 1-2 signals per month
By Market Volatility:
• High volatility = more SuperTrend flips = more signals
• Low volatility = fewer flips = fewer signals
By Quality Filter:
• Higher threshold (60-70) = fewer but better signals
• Lower threshold (30-40) = more signals, lower quality
By Volume Momentum Filter:
• Enabled = Fewer signals (only volume-confirmed)
• Disabled = More signals (all SuperTrend flips)
Adjust quality threshold and filters to match your desired signal frequency.
Q: What's the difference between entry labels and info labels?
A:
Entry Labels (BUY/SELL):
• Your primary trading signals
• Based on SuperTrend flip + all confirmations (quality, volume, momentum)
• Include quality score and confirmation icons
• These are actionable entry points
Info Labels (Volume Spike):
• Additional market context
• Show volume events that may support or contradict trend
• 8-bar cooldown to prevent spam
• NOT necessarily entry points - contextual information only
Control separately: Can show entry labels without info labels (recommended for clean charts).
Q: Can I combine this with other indicators?
A: Absolutely! This works well with:
• RSI: For divergences and overbought/oversold conditions
• Support/Resistance: Confluence with key levels
• Fibonacci Retracements: Pullback targets in Scalpel Mode
• Price Action Patterns: Flags, pennants, cup-and-handle
• MACD: Additional momentum confirmation
• Bollinger Bands: Volatility context
This indicator provides trend direction and duration estimates - complement with other tools for entry refinement and additional confluence.
Q: Why did I get a low-quality signal? Can I filter them out?
A: Yes! Increase the Minimum Quality Score in settings.
If you're seeing signals with quality below your preference:
• Day Trading: Set minimum to 50
• Swing Trading: Set minimum to 60
• Position Trading: Set minimum to 70
Only signals meeting the threshold will appear. This reduces frequency but improves win-rate.
Q: How do I interpret the MTF Confluence count?
A: Shows how many of 6 timeframes agree with current trend:
• 6/6 aligned: Perfect agreement (extremely rare, highest confidence)
• 5/6 aligned: Very strong alignment (high confidence)
• 4/6 aligned: Good alignment (standard quality setup)
• 3/6 aligned: Moderate alignment (acceptable)
• 2/6 aligned: Weak alignment (caution)
• 1/6 aligned: Very weak (likely counter-trend)
Higher confluence typically correlates with longer, stronger trends. However, MTF analysis is optional - you can disable it and rely solely on quality scoring.
Q: Is this suitable for beginners?
A: Yes, but requires foundational knowledge:
You should understand:
• Basic trend-following concepts (higher highs, higher lows)
• Risk management principles (position sizing, stop losses)
• How to read candlestick charts
• What volume and volatility mean
Beginner-friendly features:
• Auto preset mode (zero configuration)
• Quality scoring (tells you signal strength)
• Dashboard tooltips (hover for explanations)
• duration analysis boxes (visual profit targets)
Recommended for beginners:
1. Start with "Auto" or "Swing Trading" preset on Daily chart
2. Use Standard Analysis Mode (not Advanced)
3. Set minimum quality to 60 (fewer but better signals)
4. Paper trade first for 2-4 weeks
5. Study methodology references (Minervini, O'Neil, Zanger)
Q: What is the Asset Type setting and why does it matter?
A: Asset Type (in Advanced analysis mode) adjusts duration estimates based on volatility characteristics:
• Small Cap: Explosive moves, extended trends (+30-40%)
• Biotech / Speculative: Parabolic potential, news-driven (+40%)
• Blue Chip / Large Cap: Baseline, steady trends (0% adjustment)
• Tech Growth: Momentum-driven, longer trends (+20%)
• Dividend / Value: Slower, grinding trends (-20%)
• Cyclical: Macro-driven, variable (±10%)
• Crypto / High Volatility: Parabolic potential (+30%)
Correct configuration improves Statistical accuracy by 15-20%. Using Blue Chip settings on a biotech stock may underestimate trend length (you'll exit too early).
Q: Can I backtest this indicator?
A: Yes! TradingView's Strategy Tester works with this indicator's signals.
To backtest:
1. Note the entry conditions (SuperTrend flip + quality threshold + filters)
2. Create a strategy script using same logic
3. Run Strategy Tester on historical data
Additionally, the indicator includes BUILT-IN duration estimate validation:
• System backtests its own duration estimates
• Shows accuracy metrics in dashboard and duration analysis boxes
• Helps assess reliability on your specific symbol/timeframe
Q: Why does Volume Momentum auto-disable in Scalping mode?
A: Scalping requires ultra-fast entries to catch quick moves. Volume Momentum filter adds friction by requiring volume confirmation before signaling, which can cause missed opportunities in rapid scalping.
Scalping preset is optimized for speed and frequency - the filter is counterproductive for that style. It remains enabled for Day Trading, Swing Trading, and Position Trading presets where patience improves results.
You can manually enable it in Custom mode if desired.
Q: How much historical data do I need for accurate duration estimates?
A:
Minimum: 50-100 bars (indicator will function but duration estimates less reliable)
Recommended: 500+ bars (robust statistical database)
Optimal: 1000+ bars (maximum Statistical accuracy)
More history = more completed trends = better pattern matching = more accurate duration estimates.
New symbols or newly-switched timeframes will have lower Statistical accuracy initially. Allow 2-4 weeks for the system to build historical database.
IMPORTANT DISCLAIMERS
No Guarantee of Profit:
This indicator is an educational tool and does not guarantee any specific trading results. All trading involves substantial risk of loss. Duration estimates are statistical calculations based on historical patterns and are not guarantees of future performance.
Past Performance:
Historical backtest results and Statistical accuracy statistics do not guarantee future performance. Market conditions change constantly. What worked historically may not work in current or future markets.
Not Financial Advice:
This indicator provides technical analysis signals and statistical duration estimates only. It is not financial, investment, or trading advice. Always consult with a qualified financial advisor before making investment decisions.
Risk Warning:
Trading stocks, options, futures, forex, and cryptocurrencies involves significant risk. You can lose all of your invested capital. Never trade with money you cannot afford to lose. Only risk capital you can lose without affecting your lifestyle.
Testing Required:
Always test this indicator on a demo account or with paper trading before risking real capital. Understand how it works in different market conditions. Verify Statistical accuracy on your specific instruments and timeframes before trusting it with real money.
User Responsibility:
You are solely responsible for your trading decisions. The developer assumes no liability for trading losses, incorrect duration estimates, software errors, or any other damages incurred while using this indicator.
Statistical Estimation Limitations:
Trend Duration estimates are statistical estimates based on historical pattern matching. They are NOT guarantees. Actual trend durations may differ significantly from duration estimates due to unforeseen news events, market regime changes, or lack of historical precedent for current conditions.
CREDITS & ACKNOWLEDGMENTS
Methodology Inspiration:
• Mark Minervini - Volatility Contraction Pattern (VCP) concepts and pullback entry techniques
• William O'Neil - Volume analysis principles and CANSLIM institutional buying patterns
• Dan Zanger - Momentum breakout strategies and volatility expansion entries
Technical Components:
• SuperTrend calculation - Classic ATR-based trend indicator (public domain)
• Statistical analysis - Standard median, average, range calculations
• k-Nearest Neighbors - Classic machine learning similarity matching concept
• Multi-timeframe analysis - Standard request.security implementation in Pine Script
For questions, feedback, or support, please comment below or send a private message.
Happy Trading!
Composite Time ProfileComposite Time Profile Overlay (CTPO) - Market Profile Compositing Tool
Automatically composite multiple time periods to identify key areas of balance and market structure
What is the Composite Time Profile Overlay?
The Composite Time Profile Overlay (CTPO) is a Pine Script indicator that automatically composites multiple time periods to identify key areas of balance and market structure. It's designed for traders who use market profile concepts and need to quickly identify where price is likely to find support or resistance.
The indicator analyzes TPO (Time Price Opportunity) data across different timeframes and merges overlapping profiles to create composite levels that represent the most significant areas of balance. This helps you spot where institutional traders are likely to make decisions based on accumulated price action.
Why Use CTPO for Market Profile Trading?
Eliminate Manual Compositing Work
Instead of manually drawing and compositing profiles across different timeframes, CTPO does this automatically. You get instant access to composite levels without spending time analyzing each individual period.
Spot Areas of Balance Quickly
The indicator highlights the most significant areas of balance by compositing overlapping profiles. These areas often act as support and resistance levels because they represent where the most trading activity occurred across multiple time periods.
Focus on What Matters
Rather than getting lost in individual session profiles, CTPO shows you the composite levels that have been validated across multiple timeframes. This helps you focus on the levels that are most likely to hold.
How CTPO Works for Market Profile Traders
Automatic Profile Compositing
CTPO uses a proprietary algorithm that:
- Identifies period boundaries based on your selected timeframe (sessions, daily, weekly, monthly, or auto-detection)
- Calculates TPO profiles for each period using the C2M (Composite 2 Method) row sizing calculation
- Merges overlapping profiles using configurable overlap thresholds (default 50% overlap required)
- Updates composite levels as new price action develops in real-time
Key Levels for Market Profile Analysis
The indicator displays:
- Value Area High (VAH) and Value Area Low (VAL) levels calculated from composite TPO data
- Point of Control (POC) levels where most trading occurred across all composited periods
- Composite zones representing areas of balance with configurable transparency
- 1.618 Fibonacci extensions for breakout targets based on composite range
Multiple Timeframe Support
- Sessions: For intraday market profile analysis
- Daily: For swing trading with daily profiles
- Weekly: For position trading with weekly structure
- Monthly: For long-term market profile analysis
- Auto: Automatically selects timeframe based on your chart
Trading Applications for Market Profile Users
Support and Resistance Trading
Use composite levels as dynamic support and resistance zones. These levels often hold because they represent areas where significant trading decisions were made across multiple timeframes.
Breakout Trading
When composite levels break, they often lead to significant moves. The indicator calculates 1.618 Fibonacci extensions to give you clear targets for breakout trades.
Mean Reversion Strategies
Value Area levels represent the price range where most trading activity occurred. These levels often act as magnets, drawing price back when it moves too far from the mean.
Institutional Level Analysis
Composite levels represent areas where institutional traders have made significant decisions. These levels often hold more weight than traditional technical analysis levels because they're based on actual trading activity.
Key Features for Market Profile Traders
Smart Compositing Logic
- Automatic overlap detection using price range intersection algorithms
- Configurable overlap thresholds (minimum 50% overlap required for merging)
- Dead composite identification (profiles that become engulfed by newer composites)
- Real-time updates as new price action develops using barstate.islast optimization
Visual Customization
- Customizable colors for active, broken, and dead composites
- Adjustable transparency levels for each composite state
- Premium/Discount zone highlighting based on current price vs composite range
- TPO aggression coloring using TPO distribution analysis to identify buying/selling pressure
- Fibonacci level extensions with 1.618 target calculations based on composite range
Clean Chart Presentation
- Only shows the most relevant composite levels (maximum 10 active composites)
- Eliminates clutter from individual session profiles
- Focuses on areas of balance that matter most to current price action
Real-World Trading Examples
Day Trading with Session Composites
Use session-based composites to identify intraday areas of balance. The VAH and VAL levels often act as natural profit targets and stop-loss levels for scalping strategies.
Swing Trading with Daily Composites
Daily composites provide excellent swing trading levels. Look for price reactions at composite zones and use the 1.618 extensions for profit targets.
Position Trading with Weekly Composites
Weekly composites help identify major trend changes and long-term areas of balance. These levels often hold for months or even years.
Risk Management
Composite levels provide natural stop-loss levels. If a composite level breaks, it often signals a significant shift in market sentiment, making it an ideal place to exit losing positions.
Why Composite Levels Work
Composite levels work because they represent areas where significant trading decisions were made across multiple timeframes. When price returns to these levels, traders often remember the previous price action and make similar decisions, creating self-fulfilling prophecies.
The compositing process uses a proprietary algorithm that ensures only levels validated across multiple time periods are displayed. This means you're looking at levels that have proven their significance through actual market behavior, not just random technical levels.
Technical Foundation
The indicator uses TPO (Time Price Opportunity) data combined with price action analysis to identify areas of balance. The C2M row sizing method ensures accurate profile calculations, while the overlap detection algorithm (minimum 50% price range intersection) ensures only truly significant composites are displayed. The algorithm calculates row size based on ATR (Average True Range) divided by 10, then converts to tick size for precise level calculations.
How the Code Actually Works
1. Period Detection and ATR Calculation
The code first determines the appropriate timeframe based on your chart:
- 1m-5m charts: Session-based profiles
- 15m-2h charts: Daily profiles
- 4h charts: Weekly profiles
- 1D charts: Monthly profiles
For each period type, it calculates the number of bars needed for ATR calculation:
- Sessions: 540 minutes divided by chart timeframe
- Daily: 1440 minutes divided by chart timeframe
- Weekly: 7 days worth of minutes divided by chart timeframe
- Monthly: 30 days worth of minutes divided by chart timeframe
2. C2M Row Size Calculation
The code calculates True Range for each bar in the determined period:
- True Range = max(high-low, |high-prevClose|, |low-prevClose|)
- Averages all True Range values to get ATR
- Row Size = (ATR / 10) converted to tick size
- This ensures each TPO row represents a meaningful price movement
3. TPO Profile Generation
For each period, the code:
- Creates price levels from lowest to highest price in the range
- Each level is separated by the calculated row size
- Counts how many bars touch each price level (TPO count)
- Finds the level with highest count = Point of Control (POC)
- Calculates Value Area by expanding from POC until 68.27% of total TPO blocks are included
4. Overlap Detection Algorithm
When a new profile is created, the code checks if it overlaps with existing composites:
- Calculates overlap range = min(currentVAH, prevVAH) - max(currentVAL, prevVAL)
- Calculates current profile range = currentVAH - currentVAL
- Overlap percentage = (overlap range / current profile range) * 100
- If overlap >= 50%, profiles are merged into a composite
5. Composite Merging Logic
When profiles overlap, the code creates a new composite by:
- Taking the earliest start bar and latest end bar
- Using the wider VAH/VAL range (max of both profiles)
- Keeping the POC from the profile with more TPO blocks
- Marking the composite as "active" until price breaks through
6. Real-Time Updates
The code uses barstate.islast to optimize performance:
- Only recalculates on the last bar of each period
- Updates active composite with live price action if enabled
- Cleans up old composites to prevent memory issues
- Redraws all visual elements from scratch each bar
7. Visual Rendering System
The code uses arrays to manage drawing objects:
- Clears all lines/boxes arrays on every bar
- Iterates through composites array to redraw everything
- Uses different colors for active, broken, and dead composites
- Calculates 1.618 Fibonacci extensions for broken composites
Getting Started with CTPO
Step 1: Choose Your Timeframe
Select the period type that matches your trading style:
- Use "Sessions" for day trading
- Use "Daily" for swing trading
- Use "Weekly" for position trading
- Use "Auto" to let the indicator choose based on your chart timeframe
Step 2: Customize the Display
Adjust colors, transparency, and display options to match your charting preferences. The indicator offers extensive customization options to ensure it fits seamlessly into your existing analysis.
Step 3: Identify Key Levels
Look for:
- Composite zones (blue boxes) - major areas of balance
- VAH/VAL lines - value area boundaries
- POC lines - areas of highest trading activity
- 1.618 extension lines - breakout targets
Step 4: Develop Your Strategy
Use these levels to:
- Set entry points near composite zones
- Place stop losses beyond composite levels
- Take profits at 1.618 extension levels
- Identify trend changes when major composites break
Perfect for Market Profile Traders
If you're already using market profile concepts in your trading, CTPO eliminates the manual work of compositing profiles across different timeframes. Instead of spending time analyzing each individual period, you get instant access to the composite levels that matter most.
The indicator's automated compositing process ensures you're always looking at the most relevant areas of balance, while its real-time updates keep you informed of changes as they happen. Whether you're a day trader looking for intraday levels or a position trader analyzing long-term structure, CTPO provides the market profile intelligence you need to succeed.
Streamline Your Market Profile Analysis
Stop wasting time on manual compositing. Let CTPO do the heavy lifting while you focus on executing profitable trades based on areas of balance that actually matter.
Ready to Streamline Your Market Profile Trading?
Add the Composite Time Profile Overlay to your charts today and experience the difference that automated profile compositing can make in your trading performance.
AnyTimeAndPrice
This indicator allows users to input a specific start time and display the price of a lower timeframe on a higher timeframe chart. It offers customization options for:
- Display name
- Label color
- Line extension
By adding multiple instances of the AnyTimeframeTimeAndPrice indicator, each customized for different times and prices, you can create a powerful and flexible tool for analyzing market data. Here's a potential setup:
1. Instance 1:
- Time: 08:23
- Price: Open
- Display Name: "8:23 Open"
- Label Color: Green
2. Instance 2:
- Time: 12:47
- Price: High
- Display Name: "12:47 High"
- Label Color: Red
3. Instance 3:
- Time: 15:19
- Price: Low
- Display Name: "3:19 Low"
- Label Color: Blue
4. Instance 4:
- Time: 16:53
- Price: Close
- Display Name: "4:53 Close"
- Label Color: Yellow
By having multiple instances, you can:
- Track different times and prices on the same chart
- Customize the display names, label colors, and line extensions for each instance
- Easily compare and analyze the relationships between different times and prices
This setup can be particularly useful for:
- Identifying key levels and support/resistance areas
- Analyzing market trends and patterns
- Making more informed trading decisions
Inputs:
1. AnyStartHour: Integer input for the start hour (default: 09, range: 0-23)
2. AnyStartMinute: Integer input for the start minute (default: 30, range: 0-59)
3. Sourcename: String input for the display name (default: "Open", options: "Open", "Close", "High", "Low")
4. Src_col: Color input for the label color (default: aqua)
5. linetimeExtMulti: Integer input for the line time extension (default: 1, range: 1-5)
Calculations:
1. AnyinputStartTime: Timestamp for the input start time
2. inputhour and inputminute: Hour and minute components of the input start time
3. formattedAnyTime: Formatted string for the input start time (HH:mm)
4. currenttime: Current timestamp
5. currenthour and currentminute: Hour and minute components of the current time
6. formattedTime: Formatted string for the current time (HH:mm)
7. onTime and okTime: Boolean flags for checking if the current time matches the input start time or is within the session
8. firstbartime: Timestamp for the first bar of the session
9. dailyminutesfromSource: Calculation for the daily minutes from the source
10. anyminSrcArray: Request security lower timeframe array for the source
11. ltf (lower timeframe): Integer variable for tracking the lower timeframe
12. Sourcevalue: Float variable for storing the source value
13. linetimeExt: Integer variable for line extension (calculated from linetimeExtMulti)
Logic:
1. Check if the current time matches the input start time or is within the session
2. If true, plot a line and label with the source value and formatted time
3. If not, check if the current time is within the daily session and plot a line and label accordingly
Notes:
- The script uses request.security_lower_tf to request data from a lower timeframe
- The script uses line.new and label.new to plot lines and labels on the chart
- The script uses str.format_time to format timestamps as strings (HH:mm)
- The script uses xloc.bar_time to position lines and labels at the bar time
This script allows users to input a specific start time and display the price of a lower timeframe on a higher timeframe chart, with options for customizing the display name, label color, and line extension.
Previous Days High & LowRenders the high and low values from previous days.
Useful alert conditions are provided: "Less than low" and "Greater than high".
Configuration:
The number of days is configurable with a default of 1.
The source of the high and low values.
Use the close value instead of high and low values. Default is false.
The example above uses 2 days to demonstrate an exit strategy.
ADR/ATR Session No Probability Table by LKHere you go—clear, English docs you can drop into your script’s description or share with teammates.
ADR/ATR Session by LK — Overview
This indicator summarizes Average Daily Range (ADR) and Average True Range (ATR) for two horizons:
• Session H4 (e.g., 06:00–13:00 on a 4‑hour chart)
• Daily (D)
It shows:
• Current ADR/ATR values (using your chosen smoothing method)
• How much of ADR/ATR today/this bar has already been consumed (% of ADR/ATR)
• ADR/ATR as a percent of price
• Optional probability blocks: likelihood that %ADR will exceed user‑defined thresholds over a lookback window
• Optional on‑chart lines for the current H4 and Daily candles: Open, ADR High, ADR Low
⸻
What the metrics mean
• ADR (H4 / D): Moving average of the bar range (high - low).
• ATR (H4 / D): Moving average of True Range (max(hi-lo, |hi-close |, |lo-close |)).
• % of ADR (curr H4): (H4 range of the current H4 bar) / ADR(H4) × 100. Updates live even if the current time is outside the session.
• % of ADR (Daily): (today’s intra‑day range) / ADR(D) × 100.
• % of ATR (curr H4 / Daily): TR / ATR × 100 for that horizon.
• ADR % of Price / ATR % of Price: ADR or ATR divided by current price × 100 (a quick “volatility vs. price” gauge).
Session logic (H4): ADR/ATR(H4) only update on bars that fall inside the configured session window; outside the window the values hold steady (no recalculation “bleed”).
Daily range tracking: The indicator tracks today’s high/low in real‑time and resets at the day change.
⸻
Inputs (quick reference)
Core
• Length (ADR/ATR): smoothing length for ADR/ATR (default 21).
• Wait for Higher TF Bar Close: if true, updates ADR/ATR only after the higher‑TF bar closes when using request.security.
Timeframes
• Session Timeframe (H4): default 240.
• Daily Timeframe: default D.
Session time
• Session Timezone: “Chart” (default) or a fixed timezone.
• Session Start Hour, End Hour (minutes are fixed to 0 in this version).
Smoothing methods
• H4 ADR Method / H4 ATR Method: SMA/EMA/RMA/WMA.
• Daily ADR Method / Daily ATR Method: SMA/EMA/RMA/WMA.
Table appearance
• Table BG, Table Text, Table Font Size.
Lines (optional)
• Show current H4 segments, Show current Daily segments
• Line colors for Open / ADR High / ADR Low
• Line width
Probability
• H4 Probability Lookback (bars): number of H4 bars to examine (e.g., 300).
• Daily Probability Lookback (days): number of D bars (e.g., 180).
• ADR thresholds (%): CSV list of thresholds (e.g., 25,50,55,60,65,70,75,80,85,90,95,100,125,150).
The table will show the % of lookback bars where %ADR ≥ threshold.
Tip: If you want probabilities only for session H4 bars (not every H4 bar), ask and I can add a toggle to filter by inSess.
⸻
How to read the table
H4 block
• ADR (method) / ATR (method): the session‑aware averages.
• % of ADR (curr H4): live progress of this H4 bar toward the session ADR.
• ADR % of Price: ADR(H4) relative to price.
• % of ATR (curr H4) and ATR % of Price: same idea for ATR.
H4 Probability (lookback N bars)
• Rows like “≥ 80% ADR” show the fraction (in %) of the last N H4 bars that reached at least 80% of ADR(H4).
Daily block
• Mirrors the H4 block, but for Daily.
Daily Probability (lookback M days)
• Rows like “≥ 100% ADR” show the fraction of the last M daily bars whose daily range reached at least 100% of ADR(D).
⸻
Practical usage
• Use % of ADR (curr H4 / Daily) to judge exhaustion or room left in the day/session.
E.g., if Daily %ADR is already 95%, be cautious with momentum continuation trades.
• The probability tables give a quick historical context:
If “≥ 125% ADR” is ~18%, the market rarely stretches that far; your trade sizing/targets can reflect that.
• ADR/ATR % of Price helps normalize volatility between instruments.
⸻
Troubleshooting
• If probability rows are blank: ensure lookback windows are large enough (and that the chart has enough history).
• If ADR/ATR show … (NA): usually you don’t have enough bars for the chosen length/TF yet.
• If line segments are missing: verify you’re on a chart with visible current H4/D bars and the toggles are enabled.
⸻
Notes & customization ideas
• Add a toggle to count only session bars in H4 probability.
• Add separate thresholds for H4 vs Daily.
• Let users pick minutes for session start/end if needed.
• Add alerts when %ADR crosses specified thresholds.
If you want me to bundle any of the “ideas” above into the code, say the word and I’ll ship a clean patch.
Market Position TableMarket Position Table Indicator
Overview
The Market Position Table is a comprehensive multi-timeframe indicator that provides traders with an instant visual snapshot of market position relative to key technical indicators. This tool displays a clean, color-coded table directly on your chart, showing whether price is above or below critical moving averages, the Ichimoku Cloud, and whether the market is in a TTM Squeeze compression.
Key Features
Visual Status Dashboard
Real-time color coding: Green for bullish positioning (above), Red for bearish positioning (below/compressed)
Clean table display: Organized, easy-to-read format that doesn't clutter your chart
Customizable positioning: Place the table anywhere on your chart for optimal viewing
Technical Indicators Monitored
Four Moving Averages (20, 50, 100, 200 period)
Shows whether price is above or below each MA
Helps identify trend direction and strength
Ichimoku Cloud
Displays whether price is above, below, or inside the cloud
Gray color indicates price is within the cloud (neutral zone)
TTM Squeeze Indicator
Shows when the market is in compression (Squeeze ON = Red)
Alerts when the market is expanding (Squeeze OFF = Green)
Helps identify potential breakout opportunities
Flexible Customization
Moving Average Options:
Choose from 5 MA types: SMA, EMA, WMA, VWMA, HMA
Adjust all four MA periods to your preference
Default settings: 20, 50, 100, 200 periods
Timeframe Control:
Lock to Daily: View daily timeframe signals on any chart timeframe
Custom Timeframe: Select any specific timeframe for calculations
Chart Timeframe: Default behavior matches your current chart
Ichimoku Settings:
Customize Tenkan, Kijun, and Senkou B periods
Default: 9, 26, 52 (traditional settings)
Squeeze Settings:
Adjust Bollinger Band length and multiplier
Customize Keltner Channel length and multiplier
Fine-tune sensitivity to match your trading style
Visual Customization:
Table position: 9 placement options on your chart
Table size: Tiny, Small, Normal, or Large
Optional: Toggle MA plot lines on/off
Table Settings: Position and size
Moving Average Settings: Type and periods
Ichimoku Settings: Period adjustments
Squeeze Settings: BB and KC parameters
Timeframe Settings: Lock to daily or use custom timeframe
Interpretation
Moving Averages:
Green (ABOVE): Price is above the MA - bullish signal
Red (BELOW): Price is below the MA - bearish signal
Multiple green MAs indicate strong uptrend
Multiple red MAs indicate strong downtrend
Ichimoku Cloud:
Green (ABOVE): Price above cloud - bullish trend
Red (BELOW): Price below cloud - bearish trend
Gray (INSIDE): Price in cloud - consolidation/neutral
Squeeze Indicator:
Red (ON): Market is in compression - potential breakout setup
Green (OFF): Market is expanding - trend continuation or reversal in progress
Trading Applications
Trend Confirmation:
Use multiple green MAs + price above Ichimoku cloud to confirm strong uptrends
Use multiple red MAs + price below Ichimoku cloud to confirm strong downtrends
Breakout Trading:
Watch for Squeeze ON (red) as compression builds
When Squeeze turns OFF (green), look for directional breakout
Confirm direction with MA alignment
Multi-Timeframe Analysis:
Lock to daily timeframe while trading intraday charts
Ensure intraday trades align with daily trend direction
Example: Only take long setups on 15-min chart when daily shows green MAs
Support/Resistance:
Major MAs (50, 100, 200) often act as dynamic support/resistance
Watch for price reactions when testing these levels
Best Practices
Combine with Price Action: Use the table as confirmation alongside your chart analysis
Multi-Timeframe Confluence: Check that multiple timeframes align for higher probability setups
Don't Trade on Table Alone: Use this as one tool in your complete trading system
Customize to Your Strategy: Adjust MA types and periods to match your trading style
Monitor All Indicators: Look for alignment across all indicators for strongest signals
Tips for Optimal Use
Day Traders: Enable "Lock to Daily" to stay aligned with the daily trend while trading shorter timeframes
Swing Traders: Use default chart timeframe on daily or weekly charts
Trend Followers: Focus on MA alignment - all green or all red indicates strong trends
Breakout Traders: Watch the Squeeze indicator closely for compression/expansion cycles
Position Traders: Use longer MA periods (e.g., 50, 100, 150, 200) for smoother signals
US/SPY- Financial Regime Index Swing Strategy Credits: concept inspired by EdgeTools Bloomberg Financial Conditions Index (Proxy)
Improvements: eight component basket, inverse volatility weights, winsorization option( statistical technique used to limit the influence of outliers in a dataset by replacing extreme values with less extreme ones, rather than removing them entirely), slope and price gates, exit guards, table and gradients.
Summary in one paragraph
A macro regime swing strategy for index ETFs, futures, FX majors, and large cap equities on daily calculation with optional lower time execution. It acts only when a composite Financial Conditions proxy plus slope and an optional price filter align. Originality comes from an eight component macro basket with inverse volatility weights and winsorized return z scores that produce a portable yardstick.
Scope and intent
Markets: SPY and peers, ES futures, ACWI, liquid FX majors, BTC, large cap equities.
Timeframes: calculation daily by default, trade on any chart.
Default demo: SPY on Daily.
Purpose: convert broad financial conditions into clear swing bias and exits.
Originality and usefulness
Unique fusion: return z scores for eight liquid proxies with inverse volatility weighting and optional winsorization, then slope and price gates.
Failure mode addressed: false starts in chop and early shorts during easy liquidity.
Testability: all knobs are inputs and the table shows components and weights.
Portable yardstick: z scores center at zero so thresholds transfer across symbols.
Method overview in plain language
Base measures
Return basis: natural log return over a configurable window, standardized to a z score. Winsorization optional to cap extremes.
Components
EQ US and EQ GLB measure equity tone.
CREDIT uses LQD over HYG. Higher credit quality outperformance is risk off so sign is flipped after z score.
RATES2Y uses two year yield, sign flipped.
SLOPE uses ten minus two year yield spread.
USD uses DXY, sign flipped.
VOL uses VIX, sign flipped.
LIQ uses BIL over SPY, sign flipped.
Each component is smoothed by the composite EMA.
Fusion rule
Weighted sum where weights are equal or inverse volatility with exponent gamma, normalized to percent so they sum to one.
Signal rule
Long when composite crosses up the long threshold and its slope is positive and price is above the SMA filter, or when composite is above the configured always long floor.
Short when composite crosses down the short threshold and its slope is negative and price is below the SMA filter.
Long exit on cross down of the long exit line or on a fresh short signal.
Short exit on cross up of the short exit line or on a fresh long signal, or when composite falls below the force short exit guard.
What you will see on the chart
Markers on suggestion bars: L for long, S for short, LX and SX for exits.
Reference lines at zero and soft regime bands at plus one and minus one.
Optional background gradient by regime intensity.
Compact table with component z, weight percent, and composite readout.
Table fields and quick reading guide
Component: EQ US, EQ GLB, CREDIT, RATES2Y, SLOPE, USD, VOL, LIQ.
Z: current standardized value, green for positive risk tone where applicable.
Weight: contribution percent after normalization.
Composite: current index value.
Reading tip: a broadly green Z column with slope positive often precedes better long context.
Inputs with guidance
Setup
Calc timeframe: default Daily. Leave blank to inherit chart.
Lookback: 50 to 1500. Larger length stabilizes regimes and delays turns.
EMA smoothing: 1 to 200. Higher smooths noise and delays signals.
Normalization
Winsorize z at ±3: caps extremes to reduce one off shocks.
Return window for equities: 5 to 260. Shorter reacts faster.
Weighting
Weight lookback: 20 to 520.
Weight mode: Equal or InvVol.
InvVol exponent gamma: 0.1 to 3. Higher compresses noisy components more.
Signals
Trade side: Long Short or Both.
Entry threshold long and short: portable z thresholds.
Exit line long and short: soft exits that give back less.
Slope lookback bars: 1 to 20.
Always long floor bfci ≥ X: macro easy mode keep long.
Force short exit when bfci < Y: macro stress guard.
Confirm
Use price trend filter and Price SMA length.
View
Glow line and Show component table.
Symbols
SPY ACWI HYG LQD VIX DXY US02Y US10Y BIL are defaults and can be changed.
Realism and responsible publication
No performance claims. Past is not future.
Shapes can move intrabar and settle on close.
Execution is on standard candles only.
Honest limitations and failure modes
Major economic releases and illiquid sessions can break assumptions.
Very quiet regimes reduce contrast. Use longer windows or higher thresholds.
Component proxies are ETFs and indexes and cannot match a proprietary FCI exactly.
Strategy notice
Orders are simulated on standard candles. All security calls use lookahead off. Nonstandard chart types are not supported for strategies.
Entries and exits
Long rule: bfci cross above long threshold with positive slope and optional price filter OR bfci above the always long floor.
Short rule: bfci cross below short threshold with negative slope and optional price filter.
Exit rules: long exit on bfci cross below long exit or on a short signal. Short exit on bfci cross above short exit or on a long signal or on force close guard.
Position sizing
Percent of equity by default. Keep target risk per trade low. One percent is a sensible starting point. For this example we used 3% of the total capital
Commisions
We used a 0.05% comission and 5 tick slippage
Legal
Education and research only. Not investment advice. Test in simulation first. Use realistic costs.
Technical Summary VWAP | RSI | VolatilityTechnical Summary VWAP | RSI | Volatility
The Quantum Trading Matrix is a multi-dimensional market-analysis dashboard designed as an educational and idea-generation tool to help traders read price structure, participation, momentum and volatility in one compact view. It is not an automated execution system; rather, it aggregates lightweight “quantum” signals — VWAP position, momentum oscillator behaviour, multi-EMA trend scoring, volume flow and institutional activity heuristics, market microstructure pivots and volatility measures — and synthesizes them into a single, transparent score and signal recommendation. The primary goal is to make explicit why a given market looks favourable or unfavourable by showing the individual ingredients and how they combine, enabling traders to learn, test and form rules based on observable market mechanics.
Each module of the matrix answers a distinct market question. VWAP and its percentage distance indicate whether the current price is trading above or below the intraday volume-weighted average — a proxy for intraday institutional control and value. The quantum momentum oscillator (fast and slow EMA difference scaled to percent) captures short-to-intermediate momentum shifts, providing a quickly responsive view of directional pressure. Multi-EMA trend scoring (8/21/50) produces a simple, transparent trend score by counting conditions such as price above EMAs and cross-EMAs ordering; this score is used to categorize market trend into descriptive buckets (e.g., STRONG UP, WEAK UP, NEUTRAL, DOWN). Volume analysis compares current volume to a recent moving average and computes a Z-score to detect spikes and unusual participation; additional buy/sell pressure heuristics (buyingPressure, sellingPressure, flowRatio) estimate whether upside or downside participation dominates the bar. Institutional activity is approximated by flagging large orders relative to volume baseline (e.g., volume > 2.5× MA) and estimating a dark pool proxy; this is a heuristic to highlight bars that likely had large players involved.
The dashboard also performs market-structure detection with small pivot windows to identify recent local support/resistance areas and computes price position relative to the daily high/low (dailyMid, pricePosition). Volatility is measured via ATR divided by price and bucketed into LOW/NORMAL/HIGH/EXTREME categories to help you adapt stop sizing and expectational horizons. Finally, all these pieces feed an interpretable scoring function that rewards alignment: VWAP above, strong flow ratio, bullish trend score, bullish momentum, and favorable RSI zone add to the overall score which is presented as a 0–100 metric and a colored emoji indicator for at-a-glance assessment.
The mashup is purposeful: each indicator covers a failure mode of the other. For example, momentum readings can be misleading during volatility spikes; VWAP informs whether institutions are on the bid or offer; volume Z-score detects abnormal participation that can validate a breakout; multi-EMA score mitigates single-EMA whipsaws by requiring a combination of price/EMA conditions. Combining these signals increases information content while keeping each component explainable — a key compliance requirement. The script intentionally emphasizes transparency: when it shows a BUY/SELL/HOLD recommendation, the dashboard shows the underlying sub-components so a trader can see whether VWAP, momentum, volume, trend or structure primarily drove the score.
For practical use, adopt a clear workflow: (1) check the matrix score and read the component tiles (VWAP position, momentum, trend and volume) to understand the drivers; (2) confirm market-structure support/resistance and pricePosition relative to the daily range; (3) require at least two corroborating components (for example, VWAP ABOVE + Momentum BULLISH or Volume spike + Trend STRONG UP) before considering entries; (4) use ATR-based stops or daily pivot distance for stop placement and size positions such that the trade risks a small, pre-defined percent of capital; (5) for intraday scalps shorten holding time and tighten stops, for swing trades increase lookback lengths and require multi-timeframe (higher TF) agreement. Treat the matrix as an idea filter and replay lab: when an alert triggers, replay the bars and observe which components anticipated the move and which lagged.
Parameter tuning matters. Shortening the momentum length makes the oscillator more sensitive (useful for scalping), while lengthening it reduces noise for swing contexts. Volume profile bars and MA length should match the instrument’s liquidity — increase the MA for low-liquidity stocks to reduce false institutional flags. The trend multiplier and signal sensitivity parameters let you calibrate how aggressively the matrix counts micro evidence into the score. Always backtest parameter sets across multiple periods and instruments; run walk-forward tests and keep a simple out-of-sample validation window to reduce overfitting risk.
Limitations and failure modes are explicit: institutional flags and dark-pool estimates are heuristics and cannot substitute for true tape or broker-level order flow; volume split by price range is an approximation and will not perfectly reflect signed volume; pivot detection with small windows may miss larger structural swings; VWAP is typically intraday-centric and less meaningful across multi-day swing contexts; the score is additive and may not capture non-linear relationships between features in extreme market regimes (e.g., flash crashes, circuit breaker events, or overnight gaps). The matrix is also susceptible to false signals during major news releases when price and volume behavior dislocate from typical patterns. Users should explicitly test behavior around earnings, macro data and low-liquidity periods.
To learn with the matrix, perform these experiments: (A) collect all BUY/SELL alerts over a 6-month period and measure median outcome at 5, 20 and 60 bars; (B) require additional gating conditions (e.g., only accept BUY when flowRatio>60 and trendScore≥4) and compare expectancy; (C) vary the institutional threshold (2×, 2.5×, 3× volumeMA) to see how many true positive spikes remain; (D) perform multi-instrument tests to ensure parameters are not tuned to a single ticker. Document every test and prefer robust, slightly lower returns with clearer logic rather than tuned “optimal” results that fail out of sample.
Originality statement: This script’s originality lies in the curated combination of intraday value (VWAP), multi-EMA trend scoring, momentum percent oscillator, volume Z-score plus buy/sell flow heuristics and a compact, interpretable scoring system. The script is not a simple indicator mashup; it is a didactic ensemble specifically designed to make internal rationale visible so traders can learn how each market characteristic contributes to actionable probability. The tool’s novelty is its emphasis on interpretability — showing the exact contributing signals behind a composite score — enabling reproducible testing and educational value.
Finally, for TradingView publication, include a clear description listing the modules, a short non-technical summary of how they interact, the tunable inputs, limitations and a risk disclaimer. Remove any promotional content or external contact links. If you used trademark symbols, either provide registration details or remove them. This transparent documentation satisfies TradingView’s requirement that mashups justify their composition and teach users how to use them.
Quantum Trading Matrix — multi-factor intraday dashboard (educational use only).
Purpose: Combines intraday VWAP position, a fast/slow EMA momentum percent oscillator, multi-EMA trend scoring (8/21/50), volume Z-score and buy/sell flow heuristics, pivot-based microstructure detection, and ATR-based volatility buckets to produce a transparent, componentized market score and trade-idea indicator. The mashup is intentional: VWAP identifies intraday value, momentum detects short bursts, EMAs provide structural trend bias, and volume/flow confirm participation. Signals require alignment of at least two components (for example, VWAP ABOVE + Momentum BULLISH + positive flow) for higher confidence.
Inputs: momentum period, volume MA/profile length, EMA configuration (8/21/50), trend multiplier, signal sensitivity, color and display options. Use shorter momentum lengths for scalps and longer for swing analysis. Increase volume MA for thinly traded instruments.
Limitations: Institutional/dark-pool estimates and flow heuristics are approximations, not actual exchange tape. VWAP is intraday-focused. Expect false signals during major news or low-liquidity sessions. Backtest and paper-trade before applying real capital.
Risk Disclaimer: For education and analysis only. Not financial advice. Use proper risk management. The author is not responsible for trading losses.
________________________________________
Risk & Misuse Disclaimer
This indicator is provided for education, analysis and idea generation only. It is not investment or financial advice and does not guarantee profits. Institutional activity flags, dark-pool estimates and flow heuristics are approximations and should not be treated as exchange tape. Backtest thoroughly and use demo/paper accounts before trading real capital. Always apply appropriate position sizing and stop-loss rules. The author is not responsible for any trading losses resulting from the use or misuse of this tool.
________________________________________
Risk Disclaimer: This tool is provided for education and analysis only. It is not financial advice and does not guarantee returns. Users assume all risk for trades made based on this script. Back test thoroughly and use proper risk management.
Elliott Wave - Impulse + Corrective Detector (Demo) เทคนิคการใช้
สำหรับมือใหม่
ดูเฉพาะ Impulse Wave ก่อน
เทรดตาม direction ของ impulse
ใช้ Fibonacci เป็น support/resistance
สำหรับ Advanced
ใช้ Corrective Wave หาจุด reversal
รวม Triangle กับ breakout strategy
ใช้ Complex correction วางแผนระยะยาว
⚙️ การปรับแต่ง
ถ้าเจอ Pattern น้อยเกินไป
ลด Swing Length เป็น 3-4
เพิ่ม Max History เป็น 500
ถ้าเจอ Pattern เยอะเกินไป
เพิ่ม Swing Length เป็น 8-12
ปิด patterns ที่ไม่ต้องการ
สำหรับ Timeframe ต่างๆ
H1-H4: Swing Length = 5-8
Daily: Swing Length = 3-5
Weekly: Swing Length = 2-3
⚠️ ข้อควรระวัง
Elliott Wave เป็น subjective analysis
ใช้ร่วมกับ indicators อื่นๆ
Backtest ก่อนใช้เงินจริง
Pattern อาจเปลี่ยนได้ตลอดเวลา
🎓 สรุป
โค้ดนี้เป็นเครื่องมือช่วยวิเคราะห์ Elliott Wave ที่:
✅ ใช้งานง่าย
✅ ตรวจจับอัตโนมัติ
✅ มี confidence scoring
✅ แสดงผล Fibonacci levels
✅ ส่ง alerts เรียลไทม์
เหมาะสำหรับ: Trader ที่ต้องการใช้ Elliott Wave ในการวิเคราะห์เทคนิค แต่ไม่มีเวลานั่งหา pattern เอง
💡 Usage Tips
For Beginners
Focus on Impulse Waves first
Trade in the direction of impulse
Use Fibonacci as support/resistance levels
For Advanced Users
Use Corrective Waves to find reversal points
Combine Triangles with breakout strategies
Use Complex corrections for long-term planning
⚙️ Customization
If You See Too Few Patterns
Decrease Swing Length to 3-4
Increase Max History to 500
If You See Too Many Patterns
Increase Swing Length to 8-12
Turn off unwanted pattern types
For Different Timeframes
H1-H4: Swing Length = 5-8
Daily: Swing Length = 3-5
Weekly: Swing Length = 2-3
⚠️ Important Warnings
Elliott Wave is subjective analysis
Use with other technical indicators
Backtest before using real money
Patterns can change at any time
🔧 Troubleshooting
No Patterns Showing
Check if you have enough price history
Adjust Swing Length settings
Make sure pattern detection is enabled
Too Many False Signals
Increase confidence threshold requirements
Use higher timeframes
Combine with trend analysis
Performance Issues
Reduce Max History setting
Turn off unnecessary visual elements
Use on liquid markets only
📈 Trading Applications
Entry Strategies
Wave 3 Entry: After Wave 2 completion (61.8%-78.6% retracement)
Wave 5 Target: Equal to Wave 1 or Fibonacci extensions
Corrective Bounce: Trade reversals at C wave completion
Risk Management
Stop Loss: Beyond pattern invalidation levels
Take Profit: Fibonacci extension targets
Position Sizing: Based on pattern confidence
🎓 Summary
This code is an Elliott Wave analysis tool that offers:
✅ Easy to use interface
✅ Automatic pattern detection
✅ Confidence scoring system
✅ Fibonacci level display
✅ Real-time alerts
Perfect for: Traders who want to use Elliott Wave analysis but don't have time to manually identify patterns.
📚 Quick Reference
Pattern Hierarchy (Most to Least Reliable)
Impulse Waves (90% confidence)
Expanded Flats (85% confidence)
Zigzags (80% confidence)
Triangles (75% confidence)
Complex Corrections (70% confidence)
Best Practices
Start with higher timeframes for main trend
Use lower timeframes for precise entries
Always confirm with volume and momentum
Don't trade against strong fundamental news
Keep a trading journal to track performance
Remember: Elliott Wave is an art as much as a science. This tool helps identify potential patterns, but always use your judgment and additional analysis before making trading decisions.
Highs & Lows - Multi TimeFrame### **📌 HL-MWD (Highs & Lows - Multi Timeframe Indicator) – Community Release**
#### **🔹 Overview**
The **HL-MWD Indicator** is a **multi-timeframe support & resistance tool** that plots **historical highs and lows** from **daily, weekly, and monthly timeframes** onto an intraday chart. It helps traders **identify key levels of support and resistance** that have influenced price action over different timeframes.
This indicator is useful for **day traders, swing traders, and position traders** who rely on **multi-timeframe analysis** to spot critical price levels.
---
### **🔥 Key Features**
✅ **Plots Highs & Lows for Daily, Weekly, and Monthly Timeframes**
✅ **Customizable Lookback Periods for Each Timeframe**
✅ **Adjustable Line Colors, Styles (Solid, Dotted, Dashed), and Widths**
✅ **Extend Lines into the Future to Identify Key Price Levels**
✅ **Option to Display Price Labels for Each Level**
✅ **Gradient Option to Highlight Recent Highs & Lows (Disabled by Default)**
✅ **Compatible with Intraday, Daily, and Weekly Charts**
---
### **📈 How It Works**
- **Daily Highs & Lows:** Captures the **highest and lowest prices** within the selected lookback period (default: **14 bars**).
- **Weekly Highs & Lows:** Marks the **highest and lowest prices** within the chosen weekly lookback (default: **52 bars**).
- **Monthly Highs & Lows:** Displays the **high and low points** from the monthly timeframe (default: **36 bars**).
- **Extended Lines:** Project past highs and lows **into the future** to help identify **potential support & resistance zones**.
---
### **⚠️ TradingView Lookback Limitations**
🔹 **TradingView has a limit on how many historical bars can be accessed per timeframe**, which affects how far back the indicator can retrieve data.
🔹 **Intraday charts (e.g., 5m, 15m) have a limited number of past bars**, meaning:
- **You won’t be able to view 36 months' worth of monthly levels** on a **5-minute chart**, because TradingView doesn’t store that much data in lower timeframes.
- **If multiple timeframes (e.g., weekly + monthly) are enabled at the same time**, some historical data may **not be available on shorter timeframes**.
🔹 **Recommendation:**
- If using **monthly lookbacks (36 months+), view them on a daily or higher timeframe**.
- If using **weekly lookbacks (52 weeks+), higher intraday timeframes (e.g., 1-hour, 4-hour) are better suited**.
- **Lower timeframes (1m, 5m, 15m) may miss some levels** if TradingView's bar limit is exceeded.
---
### **⚙️ Customization Options**
| **Setting** | **Default Value** | **Description** |
|------------------|----------------|----------------|
| **Daily Lookback** | `14` | Number of bars used to calculate daily highs/lows. |
| **Weekly Lookback** | `52` | Number of bars used to calculate weekly highs/lows. |
| **Monthly Lookback** | `36` | Number of bars used to calculate monthly highs/lows. |
| **Line Colors** | Daily: `Blue` Weekly: `Green` Monthly: `Red` | Customizable colors for each timeframe. |
| **Line Style** | `Solid` | Options: Solid, Dashed, Dotted. |
| **Line Width** | `1` | Thickness of the plotted lines. |
| **Extend Line** | `1` | Controls how far the highs/lows extend into the future. |
| **Display Price Labels** | `Enabled` | Shows price labels on each level. |
---
### **🛠️ How to Use It**
- **Enable/disable different timeframes** based on your strategy.
- **Customize colors, line styles, and widths** to match your charting style.
- **Use extended lines to identify support & resistance zones.**
- **Watch price reactions at these levels** for potential entries, exits, and stop-loss placements.
---
### **🚀 Final Thoughts**
The **HL-MWD Indicator** is a **powerful multi-timeframe tool** that helps traders **visualize key support & resistance levels** from higher timeframes on an intraday chart.
⚠️ **However, TradingView’s lookback limits apply—so for longer-term levels, higher timeframes are recommended.**
📌 **Now published for the community!** Let me know if you need any last-minute tweaks! 🔥
Live Economic Calendar by toodegrees⚠️ PLEASE READ ⚠️
Although this indicator is accurate in showcasing live and upcoming News Events, checking the original sources is always suggested. This indicator aims to save Time, but due to limitations it may not be 100% correct 100% of the Time.
Description:
The Live Economic Calendar indicator seamlessly integrates with external news sources to provide real-Time, upcoming, and past financial news directly on your Tradingview chart.
By having a clear understanding of when news are planned to be released, as well as their respective impact, analysts can prepare their weeks and days in advance. These injections of volatility can be harnessed by analysts to support their thesis, or may want to be avoided to ensure higher probability market conditions. Fundamentals and news releases transcend the boundaries of technical analysis, as their effects are difficult to predict or estimate.
Designed for both novice and experienced traders, the Live Economic Calendar indicator enhances your analysis by keeping you informed of the latest and upcoming market-moving news.
This is achieved with three different visual components:
News Table: A dedicated News Table shows the Day of the Week, Date, Time of the Day, Currency, Expected Impact, and News Name for each event (in chronological order). Once a news event has occurred, or the day is over, it will be greyed out – helping to focus on the next upcoming news events.
News Lines: Vertical lines plotted in the future help analysts monitor upcoming news events; vertical lines in the past help analysts spot and backtest previous news events that already occurred.
News Labels: Color-coded news labels will plot once the news events have occurred. This not only gives analysts a minimalistic visual cue, but also retains the information of which news were released at that Time in their tooltips.
Forex Factory Calendar News Feed:
The Forex Factory Data Feed includes news events from January 2007 to the present. The data is updated daily. Please see the Technical Description below for more information.
Forex Factory provides news for all major currencies and markets:
Australia (AUD)
Canada (CAD)
Switzerland (CHF)
China (CNY)
European Union (EUR)
United Kingdom (GBP)
Japan (JPY)
New Zealand (NZD)
United States of America (USD)
Further, there are four types of news impact, defined by respective color-coding which is retained to avoid confusion:
⚪ Holiday
🟡 Low Impact
🟠 Medium Impact
🔴 High Impact
News' Time of the day data is in 24H format, and 'All Day' news are marked at Daily candle open.
⚠️ Original Release Notes ⚠️
The original release of this indicator supports the Forex Factory News Calendar in EST (New York Time). Future updates will include multiple news sources, as well as supporting different Timezones.
Given Data limitations, the Daily chart can omit some data due to the market being close on some days. This will be fixed in the future once an efficient solution is implemented.
Key Features:
Impact-Based News Filtering: Filter news items based on their expected impact (holiday, low, medium, high) to focus on the most market-critical information.
Symbol-Specific News: Automatically filter news to display only what's relevant to the currency pair or trading symbol you are analyzing.
Custom Currency News: Want to see more than the news relevant to the current symbol? Toggle which markets' news you are most interested in.
Chart History: Keep your charts clean by displaying only the drawings of Today's news, or This Week's news.
Custom Lookback: Look further back in Time by choosing a custom number of Lookback Days, allowing you to backtest and keep in mind salient news events from the past.
Line and Label Customization: Both the News Lines and Labels are highly customizable (except the colors), allowing you to make the indicator yours.
Table History: Choose whether to focus on Today's news only, or the news for This Week.
Table Customization: The table colors and position are highly customizable, allowing you to make it fit your visual preference and your layouts' aesthetic.
"Wondering how it's done? 👇"
Technical Description:
This script utilizes Pine Seeds , a service integrated with TradingView for importing custom data. This stunning feature enables users to upload and access custom End Of Day (EOD) data, which can be updated as frequently as five times daily.
This data can be imported in one of two formats:
Single Value: integer or float
Candle Data: open, high, low, close, volume
Upon encountering Pine Seeds, I recognized its potential for importing financial news events. Given that Forex Factory is a primary source of financial news in my personal analysis, integrating it into my layouts seemed like an exciting opportunity. This integration is expected to provide significant value to users looking to integrate additional news feeds all in one place.
Development Challenges:
Format Limitations: News events must be converted into numerical values for import, due to the required Pine Seeds format.
Amount of Data: With all currencies considered, the system may encounter over 40 news events in a single day.
Data Availability: The reliance on End Of Day (EOD) data means that information for the current day is displayed with a delay, and accessing future data is not possible.
Solutions:
Encoding: Each news event is encoded as an integer in the "DCHHMMITYP" format.
D = day of the week
C = currency
HHMM = Time of day
I = news impact
TYP = event ID (see Event Library A and Event Library B )
To ensure data assignment for each candle across the open, high, low, close, and volume series, the value "999" is used as a placeholder:
Importing: Utilizing the encoding system, up to five news events per day can be imported for a singular Pine Seeds custom symbol.
By creating multiple custom Pine Seeds Symbols, efficient imports of a larger number of events is then easily achievable. Nine unique symbols have been established, accommodating up to 45 news events per day.
These symbols are searchable, and accessible as " TOODEGREES_FOREX_FACTORY_SLOT_N " where N ranges from 1 to 9.
The Pine Seeds data feed appears as follows:
Uploading Schedule: To ensure analysts are informed about current and upcoming week's news, events are uploaded one week in advance.
This approach is vital for preparing for potential market impacts across various asset classes and currencies, allowing visibility of an entire week's news ahead of Time.
Data Scraping:
Unfortunately Forex Factory doesn't offer an API to fetch their news feed.
Hence an ad hoc python scraper was developed to read and save news events from January 2007 till the present leveraging Selenium. The scraper algorithm is part of a larger script responsible for scraping data, formatting data, and creating all necessary datasets.
The pseudo-code for the python script is as follows:
Read and save news event data on Forex Factory
Format day of the week, currency, Time of the day, and impact data for the Encoding
Encode and save News Event IDs – Event ID dataset is created
Format news data for Pine Seeds (roll-back date by one week, assign news to open, high, low, close, and volume values)
Create Pine Seeds Datasets
This script is ran everyday at Futures market close (16:00 EST) to update the last part of the each dataset, ensuring accuracy, and taking into account last-minute news additions or revisions.
Once the data (next week's news) is imported by the Live Economic Calendar indicator, it's immediately decoded by leveraging the Forex Factory Decoding Library , and saved into an array.
Upon a new week open, the decoded data is used to plot news events on the chart and in the news table.
See the inner workings of these processes in the Forex Factory Utility Library .
Although these libraries are specifically built for this indicator, feel free to use them to create your own scripts. Looking forward to see what the Pine Script community comes up with!
Thank you for making it this far. Enjoy!
Ciao,
toodegrees
This tool is available ONLY on the TradingView platform.
Terms and Conditions
Our charting tools are provided for informational and educational purposes only and do not constitute financial, investment, or trading advice. Our charting tools are not designed to predict market movements or provide specific recommendations. Users should be aware that past performance is not indicative of future results and should not be relied upon for making financial decisions. By using our charting tools, the user agrees that Toodegrees and the Toodegrees Team are not responsible for any decisions made based on the information provided by these charting tools. The user assumes full responsibility and liability for any actions taken and the consequences thereof, including any loss of money or investments that may occur as a result of using these products. Hence, by using these charting tools, the user accepts and acknowledges that Toodegrees and the Toodegrees Team are not liable nor responsible for any unwanted outcome that arises from the development, or the use of these charting tools. Finally, the user indemnifies Toodegrees and the Toodegrees Team from any and all liability.
By continuing to use these charting tools, the user acknowledges and agrees to the Terms and Conditions outlined in this legal disclaimer.
VMDM - Volume, Momentum & Divergence Master [BullByte]VMDM - Volume, Momentum and Divergence Master
Educational Multi-Layer Market Structure Analysis System
Multi-factor divergence engine that scores RSI momentum, volume pressure, and institutional footprints into one non-repainting confluence rating (0-100).
WHAT THIS INDICATOR IS
VMDM is an educational indicator designed to teach traders how to recognize high-probability reversal and continuation patterns by analyzing four independent market dimensions simultaneously. Instead of relying on a single indicator that may produce frequent false signals, VMDM creates a confluence-based scoring system that weights multiple confirmation factors, helping you understand which setups have stronger technical backing and which are lower quality.
This is NOT a trading system or signal generator. It is a learning tool that visualizes complex market structure concepts in an accessible format for both coders and non-coders.
THE PROBLEM IT SOLVES
Most traders face these common challenges:
Challenge 1 - Indicator Overload: Running RSI, volume analysis, and divergence detection separately creates chart clutter and conflicting signals. You waste time cross-referencing multiple windows trying to determine if all factors align.
Challenge 2 - False Divergences: Standard divergence indicators trigger on every minor pivot, creating noise. Many divergences fail because they lack supporting evidence from volume or market structure.
Challenge 3 - Missed Context: A bullish RSI divergence means nothing if it occurs during weak volume or in the middle of strong distribution. Context determines quality.
Challenge 4 - Repainting Confusion: Many divergence scripts repaint, showing perfect historical signals that never actually triggered in real-time, leading to false confidence.
Challenge 5 - Institutional Pattern Recognition: Absorption zones, stop hunts, and exhaustion patterns are taught in trading education but difficult to identify systematically without manual analysis.
VMDM addresses all five challenges by combining complementary analytical layers into one transparent, non-repainting, confluence-weighted system with visual clarity.
WHY THIS SPECIFIC COMBINATION - MASHUP JUSTIFICATION
This indicator is NOT a random mashup of popular indicators. Each of the four layers serves a specific analytical purpose and together they create a complete market structure assessment framework.
THE FOUR ANALYTICAL LAYERS
LAYER 1 - RSI MOMENTUM DIVERGENCE (Trend Exhaustion Detection)
Purpose: Identifies when price momentum is weakening before price itself reverses.
Why RSI: The Relative Strength Index measures momentum on a bounded 0-100 scale, making divergence detection mathematically consistent across all assets and timeframes. Unlike raw price oscillators, RSI normalizes momentum regardless of volatility regime.
How It Contributes: Divergence between price pivots and RSI pivots reveals early momentum exhaustion. A lower price low with a higher RSI low (bullish regular divergence) signals sellers are losing strength even as price makes new lows. This is the PRIMARY signal generator in VMDM.
Limitation If Used Alone: RSI divergence by itself produces many false signals because momentum can remain weak during continued trends. It needs confirmation from volume and structural evidence.
LAYER 2 - VOLUME PRESSURE ANALYSIS (Buying vs Selling Intensity)
Purpose: Quantifies whether the current bar's volume reflects buying pressure or selling pressure based on where price closed within the bar's range.
Methodology: Instead of just measuring volume size, VMDM calculates WHERE in the bar range the close occurred. A close near the high on high volume indicates strong buying absorption. A close near the low indicates selling pressure. The calculation accounts for wick size (wicks reduce pressure quality) and uses percentile ranking over a lookback period to normalize pressure strength on a 0-100 scale.
Formula Concept:
Buy Pressure = Volume × (Close - Low) / (High - Low) × Wick Quality Factor
Sell Pressure = Volume × (High - Close) / (High - Low) × Wick Quality Factor
Net Pressure = Buy Pressure - Sell Pressure
Pressure Strength = Percentile Rank of Net Pressure over lookback period
Why Percentile Ranking: Absolute volume varies by asset and session. Percentile ranking makes 85th percentile pressure on low-volume crypto comparable to 85th percentile pressure on high-volume forex.
How It Contributes: When a bullish divergence occurs at a pivot low AND pressure strength is above 60 (strong buying), this adds 25 confluence points. It confirms that the divergence is occurring during actual accumulation, not just weak selling.
Limitation If Used Alone: Pressure analysis shows current bar intensity but cannot identify trend exhaustion or reversal timing. High buying pressure can exist during a strong uptrend with no reversal imminent.
LAYER 3 - BEHAVIORAL FOOTPRINT PATTERNS (Volume Anomaly Detection)
CRITICAL DISCLAIMER: The terms "institutional footprint," "absorption," "stop hunt," and "exhaustion" used in this indicator are EDUCATIONAL LABELS for specific price and volume behavioral patterns. These patterns are detected through technical analysis of publicly available price, volume, and bar structure data. This indicator does NOT have access to actual institutional order flow, market maker data, broker stop-loss locations, or any non-public data source. These pattern names are used because they are common terminology in trading education to describe these technical behaviors. The analysis is interpretive and based on observable price action, not privileged information.
Purpose: Detect volume anomalies and price patterns that historically correlate with potential reversal zones or trend continuation failure.
Pattern Type 1 - Absorption (Labeled as "ACCUMULATION" or "DISTRIBUTION")
Detection Criteria: Volume is more than 2x the moving average AND bar range is less than 50 percent of the average bar range.
Interpretation: High volume compressed into a tight range suggests large participants are absorbing supply (accumulation) or distribution (distribution) without allowing price to move significantly. This often precedes directional moves once absorption completes.
Visual: Colored box zone highlighting the absorption area.
Pattern Type 2 - Stop Hunt (Labeled as "BULL HUNT" or "BEAR HUNT")
Detection Criteria: Price penetrates a recent 10-bar high or low by a small margin (0.2 percent), then closes back inside the range on above-average volume (1.5x+).
Interpretation: Price briefly spikes beyond recent structure (likely triggering stop losses placed just beyond obvious levels) then reverses. This is a classic false breakout pattern often seen before reversals.
Visual: Label at the wick extreme showing hunt direction.
Pattern Type 3 - Exhaustion (Labeled as "SELL EXHAUST" or "BUY EXHAUST")
Detection Criteria: Lower wick is more than 2.5x the body size with volume above 1.8x average and RSI below 35 (sell exhaustion), OR upper wick more than 2.5x body size with volume above 1.8x average and RSI above 65 (buy exhaustion).
Interpretation: Large wicks with high volume and extreme RSI suggest aggressive buying or selling was met with equally aggressive rejection. This exhaustion often marks short-term extremes.
Visual: Label showing exhaustion type.
How These Contribute: When a divergence forms at a pivot AND one of these behavioral patterns is active, the confluence score increases by 20 points. This confirms the divergence is occurring during structural anomaly activity, not just normal price flow.
Limitation If Used Alone: These patterns can occur mid-trend and do not indicate direction without momentum context. Absorption in a strong uptrend may just be continuation accumulation.
LAYER 4 - CONFLUENCE SCORING MATRIX (Quality Weighting System)
Purpose: Translate all detected conditions into a single 0-100 quality score so you can objectively compare setups.
Scoring Breakdown:
Divergence Present: +30 points (primary signal)
Pressure Confirmation: +25 points (volume supports direction)
Behavioral Footprint Active: +20 points (structural anomaly present)
RSI Extreme: +15 points (RSI below 30 or above 70 at pivot)
Volume Spike: +10 points (current volume above 1.5x average)
Maximum Possible Score: 100 points
Why These Weights: The weights reflect reliability hierarchy based on backtesting observation. Divergence is the core signal (30 points), but without volume confirmation (25 points) many fail. Behavioral patterns add meaningful context (20 points). RSI extremes and volume spikes are secondary confirmations (15 and 10 points).
Quality Tiers:
90-100: TEXTBOOK (all factors aligned)
75-89: HIGH QUALITY (strong confluence)
60-74: VALID (meets minimum threshold)
Below 60: DEVELOPING (not displayed unless threshold lowered)
How It Contributes: The confluence score allows you to filter noise. You can set your minimum quality threshold in settings. Higher thresholds (75+) show fewer but higher-quality patterns. Lower thresholds (50-60) show more patterns but include lower-confidence setups. This teaches you to distinguish strong setups from weak ones.
Limitation: Confluence scoring is historical observation-based, not predictive guarantee. A 95-point setup can still fail. The score represents technical alignment, not future certainty.
WHY THIS COMBINATION WORKS TOGETHER
Each layer addresses a limitation in the others:
RSI Divergence identifies WHEN momentum is exhausting (timing)
Volume Pressure confirms WHETHER the exhaustion is accompanied by opposite-side accumulation (confirmation)
Behavioral Footprint shows IF structural anomalies support the reversal hypothesis (context)
Confluence Scoring weights ALL factors into an objective quality metric (filtering)
Using only RSI divergence gives you timing without confirmation. Using only volume pressure gives you intensity without directional context. Using only pattern detection gives you anomalies without trend exhaustion context. Using all four together creates a complete analytical framework where each layer compensates for the others' weaknesses.
This is not a mashup for the sake of combining indicators. It is a structured analytical system where each component has a defined role in a multi-dimensional market assessment process.
HOW TO READ THE INDICATOR - VISUAL ELEMENTS GUIDE
VMDM displays up to five visual layer types. You can enable or disable each layer independently in settings under "Visual Layers."
VISUAL LAYER 1 - MARKET STRUCTURE (Pivot Points and Lines)
What You See:
Small labels at swing highs and lows marked "PH" (Pivot High) and "PL" (Pivot Low) with horizontal dashed lines extending right from each pivot.
What It Means:
These are CONFIRMED pivots, not real-time. A pivot low appears AFTER the required right-side confirmation bars pass (default 3 bars). This creates a delay but prevents repainting. The pivot only appears once it is mathematically confirmed.
The horizontal lines represent support (from pivot lows) and resistance (from pivot highs) levels where price previously found significant rejection.
Color Coding:
Green label and line: Pivot Low (potential support)
Red label and line: Pivot High (potential resistance)
How To Use:
These pivots are the foundation for divergence detection. Divergence is only calculated between confirmed pivots, ensuring all signals are non-repainting. The lines help you see historical structure levels.
VISUAL LAYER 2 - PRESSURE ZONES (Background Color)
What You See:
Subtle background color shading on bars - light green or light red tint.
What It Means:
This visualizes volume pressure strength in real-time.
Color Coding:
Light Green Background: Pressure Strength above 70 (strong buying pressure - price closing near highs on volume)
Light Red Background: Pressure Strength below 30 (strong selling pressure - price closing near lows on volume)
No Color: Neutral pressure (pressure between 30-70)
How To Use:
When a bullish divergence pattern appears during green pressure zones, it suggests the divergence is forming during accumulation. When a bearish divergence appears during red zones, distribution is occurring. Pressure zones help you filter divergences - those forming in supportive pressure environments have higher probability.
VISUAL LAYER 3 - DIVERGENCE LINES (Dotted Connectors)
What You See:
Dotted lines connecting two pivot points (either two pivot lows or two pivot highs).
What It Means:
A divergence has been detected between those two pivots. The line connects the price pivots where RSI showed opposite behavior.
Color Coding:
Bright Green Line: Bullish divergence (regular or hidden)
Bright Red Line: Bearish divergence (regular or hidden)
How To Use:
The divergence line appears ONLY after the second pivot is confirmed (delayed by right-side confirmation bars). This is intentional to prevent repainting. When you see the line appear, it means:
For Bullish Regular Divergence:
Price made a lower low (second pivot lower than first)
RSI made a higher low (RSI at second pivot higher than first)
Interpretation: Downtrend losing momentum
For Bullish Hidden Divergence:
Price made a higher low (second pivot higher than first)
RSI made a lower low (RSI at second pivot lower than first)
Interpretation: Uptrend continuation likely (pullback within uptrend)
For Bearish Regular Divergence:
Price made a higher high (second pivot higher than first)
RSI made a lower high (RSI at second pivot lower than first)
Interpretation: Uptrend losing momentum
For Bearish Hidden Divergence:
Price made a lower high (second pivot lower than first)
RSI made a higher high (RSI at second pivot higher than first)
Interpretation: Downtrend continuation likely (bounce within downtrend)
If "Show Consolidated Analysis Label" is disabled, a small label will appear on the divergence line showing the divergence type abbreviation.
VISUAL LAYER 4 - BEHAVIORAL FOOTPRINT MARKERS
What You See:
Boxes, labels, and markers at specific bars showing pattern detection.
ABSORPTION ZONES (Boxes):
Colored rectangular boxes spanning one or more bars.
Purple Box: Accumulation absorption zone (high volume, tight range, bullish close)
Red Box: Distribution absorption zone (high volume, tight range, bearish close)
If absorption continues for multiple consecutive bars, the box extends and a counter appears in the label showing how many bars the absorption lasted.
What It Means: Large volume is being absorbed without significant price movement. This often precedes directional breakouts once the absorption phase completes.
STOP HUNT MARKERS (Labels):
Small labels below or above wicks labeled "BULL HUNT" or "BEAR HUNT" (may show bar count if consecutive).
What It Means:
BULL HUNT : Price spiked below recent lows then reversed back up on volume - likely triggered sell stops before reversing
BEAR HUNT : Price spiked above recent highs then reversed back down on volume - likely triggered buy stops before reversing
EXHAUSTION MARKERS (Labels):
Labels showing "SELL EXHAUST" or "BUY EXHAUST."
What It Means:
SELL EXHAUST : Large lower wick with high volume and low RSI - aggressive selling met with strong rejection
BUY EXHAUST : Large upper wick with high volume and high RSI - aggressive buying met with strong rejection
How To Use:
These markers help you identify WHERE structural anomalies occurred. When a divergence signal appears AT THE SAME TIME as one of these patterns, the confluence score increases. You are looking for alignment - divergence + behavioral pattern + pressure confirmation = high-quality setup.
VISUAL LAYER 5 - CONSOLIDATED ANALYSIS LABEL (Main Pattern Signal)
What You See:
A large label appearing at pivot points (or in real-time mode, at current bar) containing full pattern analysis.
Label Appearance:
Depending on your "Use Compact Label Format" setting:
COMPACT MODE (Single Line):
Example: "BULLISH REGULAR | Q:HIGH QUALITY C:82"
Breakdown:
BULLISH REGULAR: Divergence type detected
Q:HIGH QUALITY: Pattern quality tier
C:82: Confluence score (82 out of 100)
FULL MODE (Multi-Line Detailed):
Example:
PATTERN DETECTED
-------------------
BULLISH REGULAR
Quality: HIGH QUALITY
Price: Lower Low
Momentum: Higher Low
Signal: Weakening Downtrend
CONFLUENCE: 82/100
-------------------
Divergence: 30
Pressure: 25
Institutional: 20
RSI Extreme: 0
Volume: 10
Breakdown:
Top section: Pattern type and quality
Middle section: Divergence explanation (what price did vs what RSI did)
Bottom section: Confluence score with itemized breakdown showing which factors contributed
Label Position:
In Confirmed modes: Label appears AT the pivot point (delayed by confirmation bars)
In Real-time mode: Label appears at current bar as conditions develop
Label Color:
Gold: Textbook quality (90+ confluence)
Green: High quality (75-89 confluence)
Blue: Valid quality (60-74 confluence)
How To Use:
This is your primary decision-making label. When it appears:
Check the divergence type (regular divergences are reversal signals, hidden divergences are continuation signals)
Review the quality tier (textbook and high quality have better historical win rates)
Examine the confluence breakdown to see which factors are present and which are missing
Look at the chart context (trend, support/resistance, timeframe)
Use this information to assess whether the setup aligns with your strategy
The label does NOT tell you to buy or sell. It tells you a technical pattern has formed and provides the quality assessment. Your trading decision must incorporate risk management, market context, and your strategy rules.
UNDERSTANDING THE THREE DETECTION MODES
VMDM offers three signal detection modes in settings to accommodate different trading styles and learning objectives.
MODE 1: "Confluence Only (Real-Time)"
How It Works: Displays signals AS THEY DEVELOP on the current bar without waiting for pivot confirmation. The system calculates confluence score from pressure, volume, RSI extremes, and behavioral patterns. Divergence signals are NOT required in this mode.
Delay: ZERO - signals appear immediately.
Use Case: Real-time scanning for high-confluence zones without divergence requirement. Useful for intraday traders who want immediate alerts when multiple factors align.
Tradeoff: More frequent signals but includes setups without confirmed divergence. Higher false signal rate. Signals can change as the bar develops (not repainting in historical bars, but current bar updates).
Visual Behavior: Labels appear at the current bar. No divergence lines unless divergence happens to be present.
MODE 2: "Divergence + Confluence (Confirmed)" - DEFAULT RECOMMENDED
How It Works: Full system engagement. Signals appear ONLY when:
A pivot is confirmed (requires right-side confirmation bars to pass)
Divergence is detected between current pivot and previous pivot
Total confluence score meets or exceeds your minimum threshold
Delay: Equal to your "Pivot Right Bars" setting (default 3 bars). This means signals appear 3 bars AFTER the actual pivot formed.
Use Case: Highest-quality, non-repainting signals for swing traders and learners who want to study confirmed pattern completion.
Tradeoff: Delayed signals. You will not receive the signal until confirmation occurs. In fast-moving markets, price may have already moved significantly by the time the signal appears.
Visual Behavior: Labels appear at the historical pivot location (in the past). Divergence lines connect the two pivots. This is the most educational mode because it shows completed, confirmed patterns.
Non-Repainting Guarantee: Yes. Once a signal appears, it never disappears or changes.
MODE 3: "Divergence + Confluence (Relaxed)"
How It Works: Same as Confirmed mode but with adaptive thresholds. If confluence is very high (10 points above threshold), the signal may appear even if some factors are weak. If divergence is present but confluence is slightly below threshold (within 10 points), it may still appear.
Delay: Same as Confirmed mode (right-side confirmation bars).
Use Case: Slightly more signals than Confirmed mode for traders willing to accept near-threshold setups.
Tradeoff: More signals but lower average quality than Confirmed mode.
Visual Behavior: Same as Confirmed mode.
DASHBOARD GUIDE - READING THE METRICS
The dashboard appears in the corner of your chart (position selectable in settings) and provides real-time market state analysis.
You can choose between four dashboard detail levels in settings: Off, Compact, Optimized (default), Full.
DASHBOARD ROW EXPLANATIONS
ROW 1 - Header Information
Left: Current symbol and timeframe
Center: "VMDM "
Right: Version number
ROW 2 - Mode and Delay
Shows which detection mode you are using and the signal delay.
Example: "CONFIRMED | Delay: 3 bars"
This reminds you that signals in confirmed mode appear 3 bars after the pivot forms.
ROW 3 - Market Regime
Format: "TREND UP HV" or "RANGING NV"
First Part - Trend State:
TREND UP: 20 EMA above 50 EMA with strong separation
TREND DOWN: 20 EMA below 50 EMA with strong separation
RANGING: EMAs close together, low trend strength
TRANSITION: Between trending and ranging states
Second Part - Volatility State:
HV: High Volatility (current ATR more than 1.3x the 50-bar average ATR)
NV: Normal Volatility (current ATR between 0.7x and 1.3x average)
LV: Low Volatility (current ATR less than 0.7x average)
Third Column: Volatility ratio (example: "1.45x" means current ATR is 1.45 times normal)
How To Use: Regime context helps you interpret signals. Reversal divergences are more reliable in ranging or transitional regimes. Continuation divergences (hidden) are more reliable in trending regimes. High volatility means wider stops may be needed.
ROW 4 - Pressure
Shows current volume pressure state.
Format: "BUYING | ██████████░░░░░░░░░"
States:
BUYING : Pressure strength above 60 (closes near highs)
SELLING : Pressure strength below 40 (closes near lows)
NEUTRAL : Pressure strength between 40-60
Bar Visualization: Each block represents 10 percentile points. A full bar (10 filled blocks) = 100th percentile pressure.
Color: Green for buying, red for selling, gray for neutral.
How To Use: When pressure aligns with divergence direction (bullish divergence during buying pressure), confluence is stronger.
ROW 5 - Volume and RSI
Format: "1.8x | RSI 68 | OB"
First Value: Current volume ratio (1.8x = volume is 1.8 times the moving average)
Second Value: Current RSI reading
Third Value: RSI state
OB: Overbought (RSI above 70)
OS: Oversold (RSI below 30)
Blank: Neutral RSI
How To Use: Volume spikes (above 1.5x) during divergence formation add confluence. RSI extremes at pivots add confluence.
ROW 6 - Behavioral Footprint
Format: "BULL HUNT | 2 bars"
Shows the most recent behavioral pattern detected and how long ago.
States:
ACCUMULATION / DISTRIBUTION: Absorption detected
BULL HUNT / BEAR HUNT: Stop hunt detected
SELL EXHAUST / BUY EXHAUST: Exhaustion detected
SCANNING: No recent pattern
NOW: Pattern is active on current bar
How To Use: When footprint activity is recent (within 50 bars) or active now, it adds context to divergence signals forming in that area.
ROW 7 - Current Pattern
Shows the divergence type currently detected (if any).
Examples: "BULLISH REGULAR", "BEARISH HIDDEN", "Scanning..."
Quality: Shows pattern quality (TEXTBOOK, HIGH QUALITY, VALID)
How To Use: This tells you what type of signal is active. Regular divergences are reversal setups. Hidden divergences are continuation setups.
ROW 8 - Session Summary
Format: "14 events | A3 H8 E3"
First Value: Total institutional events this session
Breakdown:
A: Absorption events
H: Stop hunt events
E: Exhaustion events
How To Use: High event counts suggest an active, volatile session with frequent structural anomalies. Low counts suggest quiet, orderly price action.
ROW 9 - Confluence Score (Optimized/Full mode only)
Format: "78/100 | ████████░░"
Shows current real-time confluence score even if no pattern is confirmed yet.
How To Use: Watch this in real-time to see how close you are to pattern formation. When it exceeds your threshold and divergence forms, a signal will appear (after confirmation delay).
ROW 10 - Patterns Studied (Optimized/Full mode only)
Format: "47 patterns | 12 bars ago"
First Value: Total confirmed patterns detected since chart loaded
Second Value: How many bars since the last confirmed pattern appeared
How To Use: Helps you understand pattern frequency on your selected symbol and timeframe. If many bars have passed since last pattern, market may be trending without reversal opportunities.
ROW 11 - Bull/Bear Ratio (Optimized/Full mode only)
Format: "28:19 | BULL"
Shows count of bullish vs bearish patterns detected.
Balance:
BULL: More bullish patterns detected (suggests market has had more bullish reversals/continuations)
BEAR: More bearish patterns detected
BAL: Equal counts
How To Use: Extreme imbalances can indicate directional bias in the studied period. A heavily bullish ratio in a downtrend might suggest frequent failed rallies (bearish continuation). Context matters.
ROW 12 - Volume Ratio Detail (Optimized/Full mode only)
Shows current volume vs average volume in absolute terms.
Example: "1.4x | 45230 / 32300"
How To Use: Confirms whether current activity is above or below normal.
ROW 13 - Last Institutional Event (Full mode only)
Shows the most recent institutional pattern type and how many bars ago it occurred.
Example: "DISTRIBUTION | 23 bars"
How To Use: Tracks recency of last anomaly for context.
SETTINGS GUIDE - EVERY PARAMETER EXPLAINED
PERFORMANCE SECTION
Enable All Visuals (Master Toggle)
Default: ON
What It Does: Master kill switch for ALL visual elements (labels, lines, boxes, background colors, dashboard). When OFF, only plot outputs remain (invisible unless you open data window).
When To Change: Turn OFF on mobile devices, 1-second charts, or slow computers to improve performance. You can still receive alerts even with visuals disabled.
Impact: Dramatic performance improvement when OFF, but you lose all visual feedback.
Maximum Object History
Default: 50 | Range: 10-100
What It Does: Limits how many of each object type (labels, lines, boxes) are kept in memory. Older objects beyond this limit are deleted.
When To Change: Lower to 20-30 on fast timeframes (1-minute charts) to prevent slowdown. Increase to 100 on daily charts if you want more historical pattern visibility.
Impact: Lower values = better performance but less historical visibility. Higher values = more history visible but potential slowdown on fast timeframes.
Alert Cooldown (Bars)
Default: 5 | Range: 1-50
What It Does: Minimum number of bars that must pass before another alert of the same type can fire. Prevents alert spam when multiple patterns form in quick succession.
When To Change: Increase to 20+ on 1-minute charts to reduce noise. Decrease to 1-2 on daily charts if you want every pattern alerted.
Impact: Higher cooldown = fewer alerts. Lower cooldown = more alerts.
USER EXPERIENCE SECTION
Show Enhanced Tooltips
Default: ON
What It Does: Enables detailed hover-over tooltips on labels and visual elements.
When To Change: Turn OFF if you encounter Pine Script compilation errors related to tooltip arguments (rare, platform-specific issue).
Impact: Minimal. Just adds helpful hover text.
MARKET STRUCTURE DETECTION SECTION
Pivot Left Bars
Default: 3 | Range: 2-10
What It Does: Number of bars to the LEFT of the center bar that must be higher (for pivot low) or lower (for pivot high) than the center bar for a pivot to be valid.
Example: With value 3, a pivot low requires the center bar's low to be lower than the 3 bars to its left.
When To Change:
Increase to 5-7 on noisy timeframes (1-minute charts) to filter insignificant pivots
Decrease to 2 on slow timeframes (daily charts) to catch more pivots
Impact: Higher values = fewer, more significant pivots = fewer signals. Lower values = more frequent pivots = more signals but more noise.
Pivot Right Bars
Default: 3 | Range: 2-10
What It Does: Number of bars to the RIGHT of the center bar that must pass for confirmation. This creates the non-repainting delay.
Example: With value 3, a pivot is confirmed 3 bars AFTER it forms.
When To Change:
Increase to 5-7 for slower, more confirmed signals (better for swing trading)
Decrease to 2 for faster signals (better for intraday, but still non-repainting)
Impact: Higher values = longer delay but more reliable confirmation. Lower values = faster signals but less confirmation. This setting directly controls your signal delay in Confirmed and Relaxed modes.
Minimum Confluence Score
Default: 60 | Range: 40-95
What It Does: The threshold score required for a pattern to be displayed. Patterns with confluence scores below this threshold are not shown.
When To Change:
Increase to 75+ if you only want high-quality textbook setups (fewer signals)
Decrease to 50-55 if you want to see more developing patterns (more signals, lower average quality)
Impact: This is your primary signal filter. Higher threshold = fewer, higher-quality signals. Lower threshold = more signals but includes weaker setups. Recommended starting point is 60-65.
TECHNICAL PERIODS SECTION
RSI Period
Default: 14 | Range: 5-50
What It Does: Lookback period for RSI calculation.
When To Change:
Decrease to 9-10 for faster, more sensitive RSI that detects shorter-term momentum changes
Increase to 21-28 for slower, smoother RSI that filters noise
Impact: Lower values make RSI more volatile (more frequent extremes and divergences). Higher values make RSI smoother (fewer but more significant divergences). 14 is industry standard.
Volume Moving Average Period
Default: 20 | Range: 10-200
What It Does: Lookback period for calculating average volume. Current volume is compared to this average to determine volume ratio.
When To Change:
Decrease to 10-14 for shorter-term volume comparison (more sensitive to recent volume changes)
Increase to 50-100 for longer-term volume comparison (smoother, less sensitive)
Impact: Lower values make volume ratio more volatile. Higher values make it more stable. 20 is standard.
ATR Period
Default: 14 | Range: 5-100
What It Does: Lookback period for Average True Range calculation used for volatility measurement and label positioning.
When To Change: Rarely needs adjustment. Use 7-10 for faster volatility response, 21-28 for slower.
Impact: Affects volatility ratio calculation and visual label spacing. Minimal impact on signals.
Pressure Percentile Lookback
Default: 50 | Range: 10-300
What It Does: Lookback period for calculating volume pressure percentile ranking. Your current pressure is ranked against the pressure of the last X bars.
When To Change:
Decrease to 20-30 for shorter-term pressure context (more responsive to recent changes)
Increase to 100-200 for longer-term pressure context (smoother rankings)
Impact: Lower values make pressure strength more sensitive to recent bars. Higher values provide more stable, long-term pressure assessment. Capped at 300 for performance reasons.
SIGNAL DETECTION SECTION
Signal Detection Mode
Default: "Divergence + Confluence (Confirmed)"
Options:
Confluence Only (Real-time)
Divergence + Confluence (Confirmed)
Divergence + Confluence (Relaxed)
What It Does: Selects which detection logic mode to use (see "Understanding The Three Detection Modes" section above).
When To Change: Use Confirmed for learning and non-repainting signals. Use Real-time for live scanning without divergence requirement. Use Relaxed for slightly more signals than Confirmed.
Impact: Fundamentally changes when and how signals appear.
VISUAL LAYERS SECTION
All toggles default to ON. Each controls visibility of one visual layer:
Show Market Structure: Pivot markers and support/resistance lines
Show Pressure Zones: Background color shading
Show Divergence Lines: Dotted lines connecting pivots
Show Institutional Footprint Markers: Absorption boxes, hunt labels, exhaustion labels
Show Consolidated Analysis Label: Main pattern detection label
Use Compact Label Format
Default: OFF
What It Does: Switches consolidated label between single-line compact format and multi-line detailed format.
When To Change: Turn ON if you find full labels too large or distracting.
Impact: Visual clarity vs. information density tradeoff.
DASHBOARD SECTION
Dashboard Mode
Default: "Optimized"
Options: Off, Compact, Optimized, Full
What It Does: Controls how much information the dashboard displays.
Off: No dashboard
Compact: 8 rows (essential metrics only)
Optimized: 12 rows (recommended balance)
Full: 13 rows (every available metric)
Dashboard Position
Default: "Top Right"
Options: Top Right, Top Left, Bottom Right, Bottom Left
What It Does: Screen corner where dashboard appears.
HOW TO USE VMDM - PRACTICAL WORKFLOW
STEP 1 - INITIAL SETUP
Add VMDM to your chart
Select your detection mode (Confirmed recommended for learning)
Set your minimum confluence score (start with 60-65)
Adjust pivot parameters if needed (default 3/3 is good for most timeframes)
Enable the visual layers you want to see
STEP 2 - CHART ANALYSIS
Let the indicator load and analyze historical data
Review the patterns that appear historically
Examine the confluence scores - notice which patterns had higher scores
Observe which patterns occurred during supportive pressure zones
Notice the divergence line connections - understand what price vs RSI did
STEP 3 - PATTERN RECOGNITION LEARNING
When a consolidated analysis label appears:
Read the divergence type (regular or hidden, bullish or bearish)
Check the quality tier (textbook, high quality, or valid)
Review the confluence breakdown - which factors contributed
Look at the chart context - where is price relative to structure, trend, etc.
Observe the behavioral footprint markers nearby - do they support the pattern
STEP 4 - REAL-TIME MONITORING
Watch the dashboard for real-time regime and pressure state
Monitor the current confluence score in the dashboard
When it approaches your threshold, be alert for potential pattern formation
When a new pattern appears (after confirmation delay), evaluate it using the workflow above
Use your trading strategy rules to decide if the setup aligns with your criteria
STEP 5 - POST-PATTERN OBSERVATION
After a pattern appears:
Mark the level on your chart
Observe what price does after the pattern completes
Did price respect the reversal/continuation signal
What was the confluence score of patterns that worked vs. those that failed
Learn which quality tiers and confluence levels produce better results on your specific symbol and timeframe
RECOMMENDED TIMEFRAMES AND ASSET CLASSES
VMDM is timeframe-agnostic and works on any asset with volume data. However, optimal performance varies:
BEST TIMEFRAMES
15-Minute to 1-Hour: Ideal balance of signal frequency and reliability. Pivot confirmation delay is acceptable. Sufficient volume data for pressure analysis.
4-Hour to Daily: Excellent for swing trading. Very high-quality signals. Lower frequency but higher significance. Recommended for learning because patterns are clearer.
1-Minute to 5-Minute: Works but requires adjustment. Increase pivot bars to 5-7 for filtering. Decrease max object history to 30 for performance. Expect more noise.
Weekly/Monthly: Works but very infrequent signals. Increase confluence threshold to 70+ to ensure only major patterns appear.
BEST ASSET CLASSES
Forex Majors: Excellent volume data and clear trends. Pressure analysis works well.
Crypto (Major Pairs): Good volume data. High volatility makes divergences more pronounced. Works very well.
Stock Indices (SPY, QQQ, etc.): Excellent. Clean price action and reliable volume.
Individual Stocks: Works well on high-volume stocks. Low-volume stocks may produce unreliable pressure readings.
Commodities (Gold, Oil, etc.): Works well. Clear trends and reactions.
WHAT THIS INDICATOR CANNOT DO - LIMITATIONS
LIMITATION 1 - It Does Not Predict The Future
VMDM identifies when technical conditions align historically associated with potential reversals or continuations. It does not predict what will happen next. A textbook 95-confluence pattern can still fail if fundamental events, news, or larger timeframe structure override the setup.
LIMITATION 2 - Confirmation Delay Means You Miss Early Entry
In Confirmed and Relaxed modes, the non-repainting design means you receive signals AFTER the pivot is confirmed. Price may have already moved significantly by the time you receive the signal. This is the tradeoff for non-repainting reliability. You can use Real-time mode for faster signals but sacrifice divergence confirmation.
LIMITATION 3 - It Does Not Tell You Position Sizing or Risk Management
VMDM provides technical pattern analysis. It does not calculate stop loss levels, take profit targets, or position sizing. You must apply your own risk management rules. Never risk more than you can afford to lose based on a technical signal.
LIMITATION 4 - Volume Pressure Analysis Requires Reliable Volume Data
On assets with thin volume or unreliable volume reporting, pressure analysis may be inaccurate. Stick to major liquid assets with consistent volume data.
LIMITATION 5 - It Cannot Detect Fundamental Events
VMDM is purely technical. It cannot predict earnings reports, central bank decisions, geopolitical events, or other fundamental catalysts that can override technical patterns.
LIMITATION 6 - Divergence Requires Two Pivots
The indicator cannot detect divergence until at least two pivots of the same type have formed. In strong trends without pullbacks, you may go long periods without signals.
LIMITATION 7 - Institutional Pattern Names Are Interpretive
The behavioral footprint patterns are named using common trading education terminology, but they are detected through technical analysis, not actual institutional data access. The patterns are interpretations based on price and volume behavior.
CONCEPT FOUNDATION - WHY THIS APPROACH WORKS
MARKET PRINCIPLE 1 - Momentum Divergence Precedes Price Reversal
Price is the final output of market forces, but momentum (the rate of change in those forces) shifts first. When price makes a new low but the momentum behind that move is weaker (higher RSI low), it signals that sellers are losing strength even though they temporarily pushed price lower. This precedes reversal. This is a fundamental principle in technical analysis taught by Charles Dow, widely observed in market behavior.
MARKET PRINCIPLE 2 - Volume Reveals Conviction
Price can move on low volume (low conviction) or high volume (high conviction). When price makes a new low on declining volume while RSI shows improving momentum, it suggests the new low is not confirmed by participant conviction. Adding volume pressure analysis to momentum divergence adds a confirmation layer that filters false divergences.
MARKET PRINCIPLE 3 - Anomalies Mark Structural Extremes
When volume spikes significantly but range contracts (absorption), or when price spikes beyond structure then reverses (stop hunt), or when aggressive moves are met with large-wick rejection (exhaustion), these anomalies often mark short-term extremes. Combining these structural observations with momentum analysis creates context.
MARKET PRINCIPLE 4 - Confluence Improves Probability
No single technical factor is reliable in isolation. RSI divergence alone fails frequently. Volume analysis alone cannot time entries. Combining multiple independent factors into a weighted system increases the probability that observed patterns have structural significance rather than random noise.
THE EDUCATIONAL VALUE
By visualizing all four layers simultaneously and breaking down the confluence scoring transparently, VMDM teaches you to think in terms of multi-dimensional analysis rather than single-indicator reliance. Over time, you will learn to recognize these patterns manually and understand which combinations produce better results on your traded assets.
INSTITUTIONAL TERMINOLOGY - IMPORTANT CLARIFICATION
This indicator uses the following terms that are common in trading education:
Institutional Footprint
Absorption (Accumulation / Distribution)
Stop Hunt
Exhaustion
CRITICAL DISCLAIMER:
These terms are EDUCATIONAL LABELS for specific price action and volume behavior patterns detected through technical analysis of publicly available chart data (open, high, low, close, volume). This indicator does NOT have access to:
Actual institutional order flow or order book data
Market maker positions or intentions
Broker stop-loss databases
Non-public trading data
Proprietary institutional information
The patterns labeled as "institutional footprint" are interpretations based on observable price and volume behavior that educational trading literature often associates with potential large-participant activity. The detection is algorithmic pattern recognition, not privileged data access.
When this indicator identifies "absorption," it means it detected high volume within a small range - a condition that MAY indicate large orders being filled but is not confirmation of actual institutional participation.
When it identifies a "stop hunt," it means price briefly penetrated a structural level then reversed - a pattern that MAY have triggered stop losses but is not confirmation that stops were specifically targeted.
When it identifies "exhaustion," it means high volume with large rejection wicks - a pattern that MAY indicate aggressive participation meeting strong opposition but is not confirmation of institutional involvement.
These are technical analysis interpretations, not factual statements about market participant identity or intent.
DISCLAIMER AND RISK WARNING
EDUCATIONAL PURPOSE ONLY
This indicator is designed as an educational tool to help traders learn to recognize technical patterns, understand multi-factor analysis, and practice systematic market observation. It is NOT a trading system, signal service, or financial advice.
NO PERFORMANCE GUARANTEE
Past pattern behavior does not guarantee future results. A pattern that historically preceded price movement in one direction may fail in the future due to changing market conditions, fundamental events, or random variance. Confluence scores reflect historical technical alignment, not future certainty.
TRADING INVOLVES SUBSTANTIAL RISK
Trading financial instruments involves substantial risk of loss. You can lose more than your initial investment. Never trade with money you cannot afford to lose. Always use proper risk management including stop losses, position sizing, and portfolio diversification.
NO PREDICTIVE CLAIMS
This indicator does NOT predict future price movement. It identifies when technical conditions align in patterns that historically have been associated with potential reversals or continuations. Market behavior is probabilistic, not deterministic.
BACKTESTING LIMITATIONS
If you backtest trading strategies using this indicator, ensure you account for:
Realistic commission costs
Realistic slippage (difference between signal price and actual fill price)
Sufficient sample size (minimum 100 trades for statistical relevance)
Reasonable position sizing (risking no more than 1-2 percent of account per trade)
The confirmation delay inherent in the indicator (you cannot enter at the exact pivot in Confirmed mode)
Backtests that do not account for these factors will produce unrealistic results.
AUTHOR LIABILITY
The author (BullByte) is not responsible for any trading losses incurred using this indicator. By using this indicator, you acknowledge that all trading decisions are your sole responsibility and that you understand the risks involved.
NOT FINANCIAL ADVICE
Nothing in this indicator, its code, its description, or its visual outputs constitutes financial, investment, or trading advice. Consult a licensed financial advisor before making investment decisions.
FREQUENTLY ASKED QUESTIONS
Q: Why do signals appear in the past, not at the current bar
A: In Confirmed and Relaxed modes, signals appear at confirmed pivots, which requires waiting for right-side confirmation bars (default 3). This creates a delay but prevents repainting. Use Real-time mode if you want current-bar signals without pivot confirmation.
Q: Can I use this for automated trading
A: You can create alert-based automation, but understand that Confirmed mode signals appear AFTER the pivot with delay, so your entry will not be at the pivot price. Real-time mode signals can change as the current bar develops. Automation requires careful consideration of these factors.
Q: How do I know which confluence score to use
A: Start with 60. Observe which patterns work on your symbol/timeframe. If too many false signals, increase to 70-75. If too few signals, decrease to 55. Quality vs. quantity tradeoff.
Q: Do regular divergences mean I should enter a reversal trade immediately
A: No. Regular divergences indicate momentum exhaustion, which is a WARNING sign that trend may reverse, not a confirmation that it will. Use confluence score, market context, support/resistance, and your strategy rules to make entry decisions. Many divergences fail.
Q: What's the difference between regular and hidden divergence
A: Regular divergence = price and momentum move in opposite directions at extremes = potential reversal signal. Hidden divergence = price and momentum move in opposite directions during pullbacks = potential continuation signal. Hidden divergence suggests the pullback is just a correction within the larger trend.
Q: Why does the pressure zone color sometimes conflict with the divergence direction
A: Pressure is real-time current bar analysis. Divergence is confirmed pivot analysis from the past. They measure different things at different times. A bullish divergence confirmed 3 bars ago might appear during current selling pressure. This is normal.
Q: Can I use this on stocks without volume data
A: No. Volume is required for pressure analysis and behavioral pattern detection. Use only on assets with reliable volume reporting.
Q: How often should I expect signals
A: Depends on timeframe and settings. Daily charts might produce 5-10 signals per month. 1-hour charts might produce 20-30. 15-minute charts might produce 50-100. Adjust confluence threshold to control frequency.
Q: Can I modify the code
A: Yes, this is open source. You can modify for personal use. If you publish a modified version, please credit the original and ensure your publication meets TradingView guidelines.
Q: What if I disagree with a pattern's confluence score
A: The scoring weights are based on general observations and may not suit your specific strategy or asset. You can modify the code to adjust weights if you have data-driven reasons to do so.
Final Notes
VMDM - Volume, Momentum and Divergence Master is an educational multi-layer market analysis system designed to teach systematic pattern recognition through transparent, confluence-weighted signal detection. By combining RSI momentum divergence, volume pressure quantification, behavioral footprint pattern recognition, and quality scoring into a unified framework, it provides a comprehensive learning environment for understanding market structure.
Use this tool to develop your analytical skills, understand how multiple technical factors interact, and learn to distinguish high-quality setups from noise. Remember that technical analysis is probabilistic, not predictive. No indicator replaces proper education, risk management, and trading discipline.
Trade responsibly. Learn continuously. Risk only what you can afford to lose.
-BullByte
