nkh Multi-TF S/RThis script create a specific marking for each time frame, change pivot to adjust mark.
nkh.
Candlestick analysis
Crude Oil Option Auto Hedge made by govindits help for crudeoil option trading and you can easily decide
All-Time High/Low Levels with Dynamic Price Zones📈 All-Time High/Low Levels with Dynamic Price Zones — AlertBlake
🧠 Overview:
This powerful indicator automatically identifies and draws the All-Time High (AT.H) and All-Time Low (AT.L) on your chart, providing a clear visual framework for price action analysis. It also calculates and displays the Midpoint (50%), Upper Quartile (75%), and Lower Quartile (25%) levels, creating a dynamic grid that helps traders pinpoint key psychological levels, support/resistance zones, and potential breakout or reversal areas.
✨ Features:
Auto-Detection of All-Time High and Low:
Tracks the highest and lowest prices in the full visible historical range of the chart.
Automatically updates as new highs or lows are created.
Dynamic Level Calculation:
Midpoint (50%): Halfway between AT.H and AT.L.
25% Level: 25% between AT.L and AT.H.
75% Level: 75% between AT.L and AT.H.
Each level is clearly labeled with its corresponding value.
Labels are positioned to the right of the price for easy reading.
Color-Coded Lines (customizable)
free course 98304 24602// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) creativecommons.org
// best signal
//@version=5
indicator('free course 98304 24602', overlay = true, max_bars_back = 1500, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
//--------------------------------------------------------------------------------------------------------------------}
// Settings
//---------------------------------------------------------------------------------------------------------------------{
disp = display.all - display.status_line
rpGR = 'Profile Generic Settings'
Showprofle = input.bool(true, 'Show Profile', group = 'Indicator option', display = disp)
rpLN = input.int(200, '  Lookback Length / Fixed Range', minval = 10, maxval = 1500, step = 10 , group = rpGR, display = disp)
rpLN := last_bar_index > rpLN ? rpLN - 1 : last_bar_index
vpSRC = input.string('Volume', '  Profile Source', options = , group = rpGR, display = disp)
vpGR = 'Profile Presentation Settings'
vpTP = 'displays total trading activity/money flow (common interest, both buying and selling trading activity/money flow) over a specified time period at specific price levels ' +
' - high traded node rows : high trading activity/money flow price levels - usually represents consolidation levels (value areas) ' +
' - average traded node rows : average trading activity/money flow price levels ' +
' - low traded node rows : low trading activity/money flow price levels - usually represents supply & demand levels or liquidity levels ' +
'row lengths, indicates the amount of the traded activity/money flow at specific price levels'
vpSH = input.bool(true, 'Volume/Money Flow Profile', group = vpGR, tooltip = vpTP, display = disp)
vpHVC = input.color(color.new(#ffeb3b, 50), '  High Traded Nodes', inline = 'VP1', group = vpGR)
vpHVT = input.int(53, 'Threshold %' , minval = 50, maxval = 99 , step = 1,inline = 'VP1', group = vpGR, tooltip = 'option range ', display = disp) / 100
vpAVC = input.color(color.new(#2962ff, 50), '  Average Traded Nodes', group = vpGR)
vpLVC = input.color(color.new(#f23645, 50), '  Low Traded Nodes', inline = 'VP2', group = vpGR)
vpLVT = input.int(37, 'Threshold %' , minval = 10, maxval = 40 , step = 1,inline = 'VP2', group = vpGR, tooltip = 'option range ', display = disp) / 100
spTP = 'displays the sentiment, the dominat party over a specified time period at the specific price levels ' +
' - bullish node rows : buying trading activity/money flow is higher ' +
' - barish node rows : selling trading activity/money flow is higher ' +
'row lengths, indicates the strength of the buyers/sellers at the specific price levels'
spSH = input.bool(false, 'Sentiment Profile', group = vpGR, tooltip = spTP)
spPTT = 'conditions used to calculate the up/down volume/money flow ' +
'* bar polarity up => if close > open down => if close <= open ' +
'* bar buying/selling pressure up => if (close - low) > (high - close) down => if (close - low) <= (high - close)'
spPT1 = 'Bar Polarity'
spPT2 = 'Bar Buying/Selling Pressure'
spPTY = input.string(spPT1, '  Sentiment Polarity Method', options = , group = vpGR, tooltip = spPTT, display = disp)
spBLC = input.color(color.new(#26a69a, 50), '  Bullish Nodes', inline = 'SP', group = vpGR)
spBRC = input.color(color.new(#ef5350, 50), 'Bearish Nodes', inline = 'SP', group = vpGR)
hmSH = input.bool(false, 'Profile Heatmap', group = vpGR, tooltip = 'tip : higher number of rows results with a better visuals')
hmSO1 = 'Volume/Money Flow Profile'
hmSRC = input.string(hmSO1, '  Heatmap Source', options = , group = vpGR, display = disp)
hmTR = input.int(73, '  Heatmap Transparency' , minval = 0, maxval = 100 , group = vpGR, display = disp)
othGR = 'Other Presentation Settings'
pcTP = 'displays the price level of the highest traded activity/money flow or the changes of the price levels with the highest traded activity/money flow'
rpPC = input.string('Last(Zone)', '  Level of Significance', options = , inline='PoC', group = othGR, tooltip = pcTP, display = disp)
vaSH = input.bool(false, 'Consolidation Zones', group = othGR, display = disp)
vaTH = input.int(25, '  Consolidation Threshold %' , minval = 0, maxval = 100, inline = 'va', group = othGR, display = disp) / 100
vaC = input.color(color.new(#2962ff, 73), '', inline = 'va', group = othGR)
spTT = 'displays the price zone of the highest bullish or bearish sentiment zone'
spPC = input.bool(false, 'Highest Sentiment Zone', inline = 'spP', group = othGR, tooltip = spTT)
rpPL = input.bool(false, 'Profile Price Levels', inline = 'BBe', group = othGR)
rpPLC = input.color(color.new(#00bcd4, 0), '', inline = 'BBe', group = othGR)
rpLS = input.string('Small', "", options= , inline = 'BBe', group = othGR, display = disp)
rpBG = input.bool(false, 'Profile Range Background Fill', inline = 'BG', group = othGR)
rpBGC = input.color(color.new(#00bcd4, 95), '', inline = 'BG', group = othGR)
otGR = 'Other Profile Settings'
rpNR = input.int(25, '  Number of Rows' , minval = 10, maxval = 100 ,step = 5, group = otGR, tooltip = 'option range ', display = disp)
rpW = input.int(13, '  Profile Width %', minval = 10, maxval = 50, group = otGR, tooltip = 'option range ', display = disp) / 100
vpLS = input.string('Auto', "  Profile Text Size", options= , group = otGR, display = disp)
vpHO = input.int(13, '  Profile Horizontal Offset', group = otGR, tooltip = 'option allows negative numbers as well, in case of a use the profiles will overlap with the price chart', display = disp)
//---------------------------------------------------------------------------------------------------------------------}
// User Defined Types
//---------------------------------------------------------------------------------------------------------------------{
// @type bar properties with their values
//
// @field o (float) open price of the bar
// @field h (float) high price of the bar
// @field l (float) low price of the bar
// @field c (float) close price of the bar
// @field v (float) volume of the bar
// @field i (int) index of the bar
type bar
float o = open
float h = high
float l = low
float c = close
float v = volume
int i = bar_index
int n = bar_index
int t = time
//---------------------------------------------------------------------------------------------------------------------}
// Variables
//---------------------------------------------------------------------------------------------------------------------{
bar b = bar.new()
rpVST = array.new_float(rpNR, 0.)
rpVSB = array.new_float(rpNR, 0.)
rpVSD = array.new_float(rpNR, 0.)
var dRP = array.new_box()
var pocPoints = array.new()
var polyline pocPolyline = na
var polyline spPolyline = na
var color llC = na
var color lsC = na
//---------------------------------------------------------------------------------------------------------------------}
// Functions/Methods
//---------------------------------------------------------------------------------------------------------------------{
// @function creates new label object and updates existing label objects
//
// @param details in Pine Scriptâ„¢ language reference manual
//
// @returns none, updated visual objects (labels)
f_drawLabelX(_x, _y, _text, _style, _textcolor, _size, _tooltip) =>
var lb = label.new(_x, _y, _text, xloc.bar_index, yloc.price, color(na), _style, _textcolor, _size, text.align_left, _tooltip)
lb.set_xy(_x, _y)
lb.set_text(_text)
lb.set_tooltip(_tooltip)
lb.set_textcolor(_textcolor)
// @function This function converts string to enumerated size
//
// @param _t custom string
//
// @returns enumerated size
f_gTS(_t) =>
switch _t
'Tiny' => size.tiny
'Small' => size.small
'Normal' => size.normal
'Auto' => size.auto
//---------------------------------------------------------------------------------------------------------------------}
// Calculations
//---------------------------------------------------------------------------------------------------------------------{
bull = spPTY == spPT1 ? b.c > b.o : (b.c - b.l) > (b.h - b.c)
nzV = nz(b.v)
rpS = f_gTS(rpLS)
vpS = f_gTS(vpLS)
var float pLST = na
var float pHST = na
if b.i == last_bar_index - rpLN
pLST := b.l
pHST := b.h
else if b.i > last_bar_index - rpLN
pLST := math.min(b.l, pLST)
pHST := math.max(b.h, pHST)
pSTP = (pHST - pLST) / rpNR
if barstate.islast and not na(nzV) and not timeframe.isseconds and rpLN > 0 and pSTP > 0 and nzV > 0
if dRP.size() > 0
for i = 0 to dRP.size() - 1
box.delete(dRP.shift())
if pocPoints.size() > 0
pocPoints.clear()
a_allPolylines = polyline.all
if array.size(a_allPolylines) > 0
for i = 0 to array.size(a_allPolylines) - 1
polyline.delete(a_allPolylines.get(i))
for bI = rpLN to 0
l = 0
for pLL = pLST to pHST - pSTP by pSTP
if b.h >= pLL and b.l < pLL + pSTP
vPOR = if b.l >= pLL and b.h > pLL + pSTP
(pLL + pSTP - b.l ) / (b.h - b.l )
else if b.h <= pLL + pSTP and b.l < pLL
(b.h - pLL) / (b.h - b.l )
else if (b.l >= pLL and b.h <= pLL + pSTP)
1
else
pSTP / (b.h - b.l )
if vpSRC == 'Money Flow'
rpVST.set(l, rpVST.get(l) + nzV * vPOR * (pLST + (l + .5) * pSTP) )
else
rpVST.set(l, rpVST.get(l) + nzV * vPOR )
if bull and spSH and Showprofle
if vpSRC == 'Money Flow'
rpVSB.set(l, rpVSB.get(l) + nzV * vPOR * (pLST + (l + .5) * pSTP))
else
rpVSB.set(l, rpVSB.get(l) + nzV * vPOR )
l += 1
if rpPC == 'Developing'
if bI == rpLN
pocPoints.push(chart.point.from_index(b.i , pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
else
pocPoints.push(chart.point.from_index(b.i , pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
if rpPC == 'Developing' and Showprofle
pocPolyline := polyline.new(pocPoints, false, false, xloc.bar_index, vpHVC, color(na), line.style_solid, 2)
if rpPC == 'Last(Zone)' and Showprofle or rpPC == 'Last(Line)' and Showprofle
pocPoints.push(chart.point.from_index(b.i , pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
pocPoints.push(chart.point.from_index(b.i, pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
pocPolyline := polyline.new(pocPoints, false, false, xloc.bar_index, vpHVC, color(na), rpPC == 'Last(Line)' ? line.style_solid : line.style_dotted, rpPC == 'Last(Line)' ? 2 : 1)
for l = 0 to rpNR - 1
bbp = 2 * rpVSB.get(l) - rpVST.get(l)
rpVSD.set(l, rpVSD.get(l) + bbp * (bbp > 0 ? 1 : -1) )
if vpSH and Showprofle or spSH and Showprofle
sBI = b.i + (spSH ? rpLN * rpW : 7) + int(rpLN * rpW / 3)
dRP.push(box.new(sBI - 1 + vpHO, pLST + (l + .1) * pSTP, sBI - int(rpLN * rpW / 3) + 1 + vpHO, pLST + (l + .9) * pSTP, #2962ff80, bgcolor = #2962ff10,
text = str.tostring(pLST + (l + .5) * pSTP, format.mintick), text_color = chart.fg_color, text_size = vpS ))
if rpBG and Showprofle
dRP.push(box.new(b.i - rpLN, pLST, b.i, pHST, rpBGC, bgcolor = rpBGC ))
if rpPL and Showprofle
f_drawLabelX(b.i, pHST, str.tostring(pHST, format.mintick), label.style_label_down, rpPLC, rpS,
'Profile High - ' + str.tostring(pHST, format.mintick) + ' %' + str.tostring((pHST - pLST) / pLST * 100, '#.##') + ' higher than the Profile Low ' +
'Total ' + (vpSRC == 'Volume' ? 'Volume : ' : 'Money Flow (' + syminfo.currency + ') : ') + str.tostring(rpVST.sum(), format.volume) +
' Number of bars : ' + str.tostring(rpLN + 1))
f_drawLabelX(b.i, pLST, str.tostring(pLST, format.mintick), label.style_label_up , rpPLC, rpS,
'Profile Low - ' + str.tostring(pLST, format.mintick) + ' %' + str.tostring((pHST - pLST) / pHST * 100, '#.##') + ' lower than the Profile High ' +
'Total ' + (vpSRC == 'Volume' ? 'Volume : ' : 'Money Flow (' + syminfo.currency + ') : ') + str.tostring(rpVST.sum(), format.volume) +
' Number of bars : ' + str.tostring(rpLN + 1))
for l = 0 to rpNR - 1
if dRP.size() < 500
vtLV = rpVST.get(l)
vtMX = rpVST.max()
LpM = vtLV / vtMX
vdMX = rpVSD.max()
DpM = rpVSD.get(l) / vdMX
llC := LpM > vpHVT ? color.from_gradient(LpM, vpHVT, 1, vpAVC, vpHVC) : color.from_gradient(LpM, 0, vpLVT, vpLVC, vpAVC)
bbp = 2 * rpVSB.get(l) - vtLV
lsC := bbp > 0 ? color.from_gradient(DpM, 0, .7, color.new(spBLC, 70 + int(hmTR / 4)), color.new(spBLC, 30 + int(hmTR / 4))) :
color.from_gradient(DpM, 0, .7, color.new(spBRC, 70 + int(hmTR / 4)), color.new(spBRC, 30 + int(hmTR / 4)))
if rpPC == 'Last(Zone)' and LpM == 1 and Showprofle
dRP.push(box.new(b.i , pLST + (rpVST.indexof(vtMX) + .0) * pSTP, b.i, pLST + (rpVST.indexof(vtMX) + 1.) * pSTP, vpHVC, bgcolor = color.new(vpHVC, 73) ))
if vaSH and LpM > vaTH and LpM < 1 and Showprofle
dRP.push(box.new(b.i , pLST + (l + .0) * pSTP, b.i, pLST + (l + 1.) * pSTP, color(na), bgcolor = vaC ))
if vaSH and rpPC != 'Last(Zone)' and LpM == 1 and Showprofle
dRP.push(box.new(b.i , pLST + (l + .0) * pSTP, b.i, pLST + (l + 1.) * pSTP, color(na), bgcolor = vaC ))
if spPC and DpM == 1 and Showprofle
spPolyline := polyline.new(array.from(chart.point.from_index(b.i , pLST + (rpVSD.indexof(vdMX) + .5) * pSTP), chart.point.from_index(b.i, pLST + (rpVSD.indexof(vdMX) + .5) * pSTP)), false, false, xloc.bar_index, lsC, color(na), line.style_dotted, 1)
dRP.push(box.new(b.i , pLST + (rpVSD.indexof(vdMX) + .0) * pSTP, b.i, pLST + (rpVSD.indexof(vdMX) + 1.) * pSTP, lsC, bgcolor = color.new(lsC, 73) ))
if vpSH and Showprofle
sBI = b.i + (spSH ? rpLN * rpW : 7) + int(rpLN * rpW / 3)
eBI = sBI + int(LpM * rpLN * rpW)
dRP.push(box.new(sBI + vpHO, pLST + (l + .1) * pSTP, eBI + vpHO, pLST + (l + .9) * pSTP, llC, bgcolor = llC,
text = str.tostring(vpSRC == 'Money Flow' ? array.get(rpVST, l) : array.get(rpVST, l) * (pLST + (l + .5) * pSTP), format.volume) + ' ' +
syminfo.currency + ' (' + str.tostring(math.abs(vtLV / rpVST.sum() * 100), '#.##') + '%)',
text_halign = text.align_left, text_color = chart.fg_color, text_size = vpS ))
if spSH and Showprofle
sBI = b.i + rpLN * rpW
eBI = sBI - int(DpM * rpLN * rpW)
dRP.push(box.new(sBI + vpHO, pLST + (l + .1) * pSTP, eBI + vpHO, pLST + (l + .9) * pSTP, lsC, bgcolor = lsC,
text = str.tostring(bbp, format.volume ) + (vpSRC == 'Money Flow' ? ' ' + syminfo.currency : '') +
' (' + str.tostring(math.abs(bbp / vtLV * 100), '#.##') + '%)',
text_halign = text.align_right, text_color = chart.fg_color, text_size = vpS ))
if hmSH and Showprofle
dRP.push(box.new(b.i , pLST + (l + .0) * pSTP, b.i, pLST + (l + 1.) * pSTP, hmSRC == hmSO1 ? color.new(llC, hmTR) : lsC, bgcolor = hmSRC == hmSO1 ? color.new(llC, hmTR) : lsC))
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
showRevBands = input.bool(true, "Show Reversal Bands", group='Indicator option')
lenRevBands = input.int(30, "Length", group="REVERSAL BANDS")
f_kc(src, len, sensitivity) =>
basis = ta.sma(src, len)
span = ta.atr(len)
= f_kc(close, lenRevBands, 3)
= f_kc(close, lenRevBands, 4)
= f_kc(close, lenRevBands, 5)
= f_kc(close, lenRevBands, 6)
cyan = #00DBFF, cyan30 = color.new(cyan, 100)
pink = #b2b5be, pink30 = color.new(pink, 100)
red = #b2b5be, red30 = color.new(red , 100)
up1 = plot(showRevBands ? upperKC1 : na, "Rev.Zone Upper 1", red30, display = display.none)
up2 = plot(showRevBands ? upperKC2 : na, "Rev.Zone Upper 2", red30, display = display.none)
up3 = plot(showRevBands ? upperKC3 : na, "Rev.Zone Upper 3", red30, display = display.none)
//plot(showRevBands ? upperKC4 : na, "Rev.Zone Upper 4", red30)
//plot(showRevBands ? lowerKC4 : na, "Rev.Zone Lower 4", cyan30)
dn1 = plot(showRevBands ? lowerKC3 : na, "Rev.Zone Lower 3", cyan30, display = display.none)
dn2 = plot(showRevBands ? lowerKC2 : na, "Rev.Zone Lower 2", cyan30, display = display.none)
dn3 = plot(showRevBands ? lowerKC1 : na, "Rev.Zone Lower 1", cyan30, display = display.none)
fill(up1, up2, color = color.new(#f23645, 80))
fill(up2, up3, color = color.new(#f23645, 50))
fill(dn1, dn2, color = color.new(#089981, 50))
fill(dn2, dn3, color = color.new(#089981, 80))
//---------------------------------------------------------------------------------------------------------------------}
//CONSTANTS & STRINGS & INPUTS
//---------------------------------------------------------------------------------------------------------------------{
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 Number of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart Number of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks It 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 Lower values will return fewer but more pertinent results'
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( true, '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( true, '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)
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
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 = )
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)
//---------------------------------------------------------------------------------------------------------------------}
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------------------------------------------{
// @type UDT representing alerts as bool fields
// @field internalBullishBOS internal structure custom alert
// @field internalBearishBOS internal structure custom alert
// @field internalBullishCHoCH internal structure custom alert
// @field internalBearishCHoCH internal structure custom alert
// @field swingBullishBOS swing structure custom alert
// @field swingBearishBOS swing structure custom alert
// @field swingBullishCHoCH swing structure custom alert
// @field swingBearishCHoCH swing structure custom alert
// @field internalBullishOrderBlock internal order block custom alert
// @field internalBearishOrderBlock internal order block custom alert
// @field swingBullishOrderBlock swing order block custom alert
// @field swingBearishOrderBlock swing order block custom alert
// @field equalHighs equal high low custom alert
// @field equalLows equal high low custom alert
// @field bullishFairValueGap fair value gap custom alert
// @field bearishFairValueGap fair value gap custom alert
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
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool ob = false
bool swingob = false
bool obtouch = false
// @type UDT representing last swing extremes (top & bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
// @type UDT representing trend bias
// @field bias BULLISH or BEARISH
type trend
int bias
// @type UDT representing Equal Highs Lows display
// @field l_ine displayed line
// @field l_abel displayed label
type equalDisplay
line l_ine = na
label l_abel = na
// @type UDT representing a pivot point (swing point)
// @field currentLevel current price level
// @field lastLevel last price level
// @field crossed true if price level is crossed
// @field barTime bar time
// @field barIndex bar index
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
// @type UDT representing an order block
// @field barHigh bar high
// @field barLow bar low
// @field barTime bar time
// @field bias BULLISH or BEARISH
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 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 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 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
// @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)
//---------------------------------------------------------------------------------------------------------------------}
//USER-DEFINED FUNCTIONS
//---------------------------------------------------------------------------------------------------------------------{
// @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish)
// @returns int
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
// @function Identify whether the current value is the start of a new leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0
// @function Identify whether the current level is the start of a new bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1
// @function Identify whether the current level is the start of a new bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1
// @function create a new label
// @param labelTime bar time coordinate
// @param labelPrice price coordinate
// @param tag text to display
// @param labelColor text color
// @param labelStyle label style
// @returns label ID
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)
// @function create a new line and label representing an EQH or EQL
// @param p_ivot starting pivot
// @param level price level of current pivot
// @param size how many bars ago was the current pivot detected
// @param equalHigh true for EQH, false for EQL
// @returns label ID
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)
// @function store current structure and trailing swing points, and also display swing points and equal highs/lows
// @param size (int) structure size
// @param equalHighLow (bool) true for displaying current highs/lows
// @param internal (bool) true for getting internal structures
// @returns label ID
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)
// @function draw line and label representing a structure
// @param p_ivot base pivot point
// @param tag test to display
// @param structureColor base color
// @param lineStyle line style
// @param labelStyle label style
// @param labelSize text size
// @returns label ID
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)
// @function delete order blocks
// @param internal true for internal order blocks
// @returns orderBlock ID
// @function fetch and store order blocks
// @param p_ivot base pivot point
// @param internal true for internal order blocks
// @param bias BULLISH or BEARISH
// @returns void
// @function draw order blocks as boxes
// @param internal true for internal order blocks
// @returns void
// @function detect and draw structures, also detect and store order blocks
// @param internal true for internal structures or order blocks
// @returns void
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)
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)
// @function get line style from string
// @param style line style
// @returns string
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
// @function draw MultiTimeFrame levels
// @param timeframe base timeframe
// @param sameTimeframe true if chart timeframe is same as base timeframe
// @param style line style
// @param levelColor line and text color
// @returns void
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))
// @function true if chart timeframe is higher than provided timeframe
// @param timeframe timeframe to check
// @returns bool
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
// @function update trailing swing points
// @returns int
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
// @function draw trailing swing points
// @returns void
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')
// @function draw a zone with a label and a box
// @param labelLevel price level for label
// @param labelIndex bar index for label
// @param top top price level for box
// @param bottom bottom price level for box
// @param tag text to display
// @param zoneColor base color
// @param style label style
// @returns void
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)
//---------------------------------------------------------------------------------------------------------------------}
//MUTABLE VARIABLES & EXECUTION
//---------------------------------------------------------------------------------------------------------------------{
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()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showTrendInput
displayStructure(true)
if showStructureInput or showHighLowSwingsInput
displayStructure()
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)
//---------------------------------------------------------------------------------------------------------------------}
//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.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
//---------------------------------------------------------------------------------------------------------------------}
//-----------------------------------------------------------------------------
// Input Settings
//-----------------------------------------------------------------------------
i_3 = "FVGs represent price areas where a significant gap occurred between two trading sessions, indicating a potential continuation or reversal point."
//----------------------------------------
// Order Blocks
//----------------------------------------
var_ob_13 = (time - time ) / 100
//----------------------------------------
// Constants
color CLEAR = color.rgb(0, 0, 0, 100)
//----------------------------------------
// Fair Value Gaps (FVG)
//----------------------------------------
in_fvg_1 = input(true, "Fair Value Gaps (FVG)", group="Fair Value Gaps", inline="fvg_css", tooltip = i_3)
in_fvg_2 = input.timeframe("", "Timeframe", group="Fair Value Gaps", inline="tf")
in_fvg_op = input.int(defval=12, title="Opacity %", minval=0, maxval=100, group="Fair Value Gaps", inline="tf")
in_fvg_3 = input.float(2, "Max Width", minval=0, maxval=5.0, step=0.1, group="Fair Value Gaps", inline="width")
in_fvg_4 = input.bool(false, "Filter FVG", group="Fair Value Gaps", inline="width")
in_fvg_5 = input.string("Close", "Mitigation Method", options= , group="Fair Value Gaps", inline="mt")
in_fvg_6 = input.bool(true, "Fill", group="Fair Value Gaps", inline="mt")
in_fvg_7 = input.bool(false, "Shade", group="Fair Value Gaps", inline="mt")
in_fvg_8 = input.int(defval=8, title="Max FVG", minval=0, maxval=50, group="Fair Value Gaps", inline="OS")
in_fvg_9 = input.int(defval=17, title="Length", minval=0, maxval=100, group="Fair Value Gaps", inline="OS")
in_fvg_10 = input.bool(false, "Extend", group="Fair Value Gaps", inline="OS")
in_fvg_11 = input.color(color.new(#089981, 88), "", group="Fair Value Gaps", inline="fvg_css")
in_fvg_12 = input.color(color.new(#f23645, 88), "", group="Fair Value Gaps", inline="fvg_css")
mid_line_show = input.string("On", " Mid Line", , group="Fair Value Gaps", inline="mid")
in_fvg_13 = input.string("Solid", " Style", , group="Fair Value Gaps", inline="mid")
in_fvg_14 = input.color(#089981, "", group="Fair Value Gaps", inline="mid")
in_fvg_14_2 = input.color(#f23645, "", group="Fair Value Gaps", inline="mid")
in_fvg_16 = input.int(defval=1, title="Line Width", minval=1, maxval=5, group="Fair Value Gaps", inline="mid_w")
in_fvg_15 = input.bool(false, "Extend (Current)", group="Fair Value Gaps", inline="mid_w")
var_fvg_1 = color.new(color.green, 100)
var_fvg_2 = color.new(color.green, 90)
var_fvg_3 = true
var_fvg_4 = true
var_fvg_5 = color.white
var_fvg_6 = "HTF"
var_fvg_7 = 10
var_fvg_8 = 50
in_fvg_op := 100 - in_fvg_op
//-----------------------------------------------------------------------------
// Global Variables
//-----------------------------------------------------------------------------
color transparent = #ffffff00
custom_func_1(res) =>
t = time(res)
not na(t) and (na(t ) or t > t )
custom_func_2(x, y, txt, css, dashed, down, lbl_size) =>
label.new(int(math.avg(x, bar_index)), y, txt, color=transparent, textcolor=css, style=down ? label.style_label_down : label.style_label_up, size=lbl_size)
line.new(x, y, bar_index, y, color=css, style=dashed ? line.style_dotted : line.style_solid)
custom_func_3(_cond, _count) =>
_barssince = bar_index - ta.valuewhen(_cond, bar_index, _count)
_barssince
// Swing Detection/Measurements
custom_func_4(length) =>
var prev = 0
prev := high > ta.highest(length) ? 0 : low < ta.lowest(length) ? 1 : prev
t = prev == 0 and prev != 0 ? high : 0
b = prev == 1 and prev != 1 ? low : 0
var variable_ms_1 = 0, var variable_ms_2 = 0
var variable_ms_3 = 0., var variable_ms_4 = 0, var variable_ms_5 = 0., var variable_ms_6 = 0
var variable_ms_7 = 0., var variable_ms_8 = 0, var variable_ms_9 = 0., var variable_ms_10 = 0
var variable_ms_11 = true, var variable_ms_12 = true
var variable_ms_13 = true, var variable_ms_14 = true
var variable_ms_15 = high, var variable_ms_16 = low
var up_trailing_x = 0, var down_trailing_x = 0
var high_text = "", var low_text = ""
variable_ms_17 = false
variable_ms_18 = false
// Functions
lineStyle(x) =>
switch x
"Solid" => line.style_solid
"Dashed" => line.style_dashed
"Dotted" => line.style_dotted
variable_ms_20 = ta.pivothigh(high, 10, 10)
variable_ms_21 = ta.pivotlow(low, 10, 10)
//-----------------------------------------------------------------------------
// Fair Value Gaps
//-----------------------------------------------------------------------------
// Global Data
var htfH = open
var htfL = open
if close > htfH
htfH := close
if close < htfL
htfL := close
// Security Data, used for HTF Bar Data reference
sClose = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, close , barmerge.gaps_off, barmerge.lookahead_on)
sHighP2 = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, high , barmerge.gaps_off, barmerge.lookahead_on)
sLowP2 = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, low , barmerge.gaps_off, barmerge.lookahead_on)
sOpen = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, open , barmerge.gaps_off, barmerge.lookahead_on)
sBar = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, bar_index, barmerge.gaps_off, barmerge.lookahead_on)
// Array variables to hold data in memory
var variable_fvg_1 = array.new_box(0)
var variable_fvg_2 = array.new_box(0)
var variable_fvg_3 = array.new_box(0)
var variable_fvg_4 = array.new_box(0)
var variable_fvg_5 = array.new_line(0)
var variable_fvg_6 = array.new_line(0)
var variable_fvg_7 = array.new_line(0)
var variable_fvg_8 = array.new_line(0)
var variable_fvg_9 = array.new_line(0)
var variable_fvg_10 = array.new_line(0)
var variable_fvg_11 = array.new_label(0)
var variable_fvg_12 = array.new_label(0)
var variable_fvg_13 = color.new(color.white, 100)
var variable_fvg_14 = false
var variable_fvg_15 = false
variable_fvg_14 := false
variable_fvg_15 := false
// Functions
custom_func_5(_upperlimit, _lowerlimit, _midlimit, _bar, _boxholder, _boxholder_fill, _midholder, _highholder, _lowholder, _labelholder, _boxcolor, _mtfboxcolor, _htf, line_color_mid) =>
variable_fvg_16 = str.tostring(in_fvg_2)
offset = var_fvg_8
variable_fvg_17 = _mtfboxcolor
bg_color = color.new(_mtfboxcolor, in_fvg_op)
if _htf == false
variable_fvg_16 := str.tostring(timeframe.period)
offset := var_fvg_7
variable_fvg_17 := _boxcolor
array.push(_boxholder, box.new(_bar, _upperlimit, _bar + (var_ob_13) * in_fvg_9, _lowerlimit, border_color= na, bgcolor=in_fvg_6 ? bg_color : na, extend=in_fvg_10 ? extend.right : extend.none, xloc=xloc.bar_time, text="", text_color=#787b86, text_halign=text.align_right, text_size=size.small))
array.push(_boxholder_fill, box.new(_bar, _upperlimit, _bar + (var_ob_13) * in_fvg_9, _lowerlimit, border_color= na, bgcolor=in_fvg_6 ? bg_color : na, extend=in_fvg_10 ? extend.right : extend.none, xloc=xloc.bar_time))
array.push(_midholder, line.new(_bar, (_lowerlimit + _upperlimit) / 2.0, _bar + (var_ob_13) * in_fvg_9, _midlimit, color=mid_line_show == "On" ? line_color_mid : #363a4500, extend=in_fvg_10 ? extend.right : extend.none, style=lineStyle(in_fvg_13), width=in_fvg_16, xloc=xloc.bar_time))
array.push(_lowholder, line.new(_bar, _lowerlimit, _bar + (var_ob_13) * in_fvg_9, _lowerlimit, color=var_fvg_3 ? variable_fvg_17 : na, extend=in_fvg_10 ? extend.right : extend.none, width=1, xloc=xloc.bar_time))
array.push(_highholder, line.new(_bar, _upperlimit, _bar + (var_ob_13) * in_fvg_9, _upperlimit, color=var_fvg_3 ? variable_fvg_17 : na, extend=in_fvg_10 ? extend.right : extend.none, width=1, xloc=xloc.bar_time))
// Checks for gap between current candle and 2 previous candle (Fair Value Gap)
custom_func_6(_close, _high, _highp2, _low, _lowp2, _open, _bar, _htf) =>
gap = 0
thold_ = (ta.highest(_high, 300) - ta.lowest(_low, 300)) * math.max(in_fvg_3, 0.1) / 100.
if _open > _close // Red candle
if _lowp2 > _high
if not (in_fvg_4) or math.abs(_lowp2 - _high) > thold_
upperlimit = _high
lowerlimit = _lowp2
midlimit = lowerlimit + ((upperlimit - lowerlimit) / 2.)
gap := 1
if in_fvg_1
custom_func_5(upperlimit, lowerlimit, midlimit, _bar, variable_fvg_1, variable_fvg_3, variable_fvg_9, variable_fvg_5, variable_fvg_7, variable_fvg_11, var_fvg_1, in_fvg_12, _htf,in_fvg_14_2)
else
if _low > _highp2
if not (in_fvg_4) or math.abs(_low - _highp2) > thold_
upperlimit = _low
lowerlimit = _highp2
midlimit = lowerlimit + ((upperlimit - lowerlimit) / 2.)
gap := -1
if in_fvg_1
custom_func_5(upperlimit, lowerlimit, midlimit, _bar, variable_fvg_2, variable_fvg_4, variable_fvg_10, variable_fvg_6, variable_fvg_8, variable_fvg_12, var_fvg_2, in_fvg_11, _htf,in_fvg_14)
gap
// Removes the gap from its relevant array if it has been filled
custom_func_7(_currentgap, _currentgap_fill, _i, _boxholder, _boxholder_fill, _midholder, _highholder, _lowholder, _labelholder) =>
array.remove(_boxholder, _i)
array.remove(_boxholder_fill, _i)
currentmid = array.get(_midholder, _i)
currenthigh = array.get(_highholder, _i)
currentlow = array.get(_lowholder, _i)
array.remove(_midholder, _i)
array.remove(_highholder, _i)
array.remove(_lowholder, _i)
if var_fvg_4
line.delete(currentmid)
line.delete(currenthigh)
line.delete(currentlow)
else
line.set_extend(currentmid, extend.none)
line.set_x2(currentmid, time)
line.set_extend(currenthigh, extend.none)
line.set_x2(currenthigh, time)
line.set_extend(currentlow, extend.none)
line.set_x2(currentlow, time)
if var_fvg_4
box.delete(_currentgap)
box.delete(_currentgap_fill)
else
box.set_extend(_currentgap, extend.none)
box.set_right(_currentgap, time)
// Checks if gap has been filled either by 0.5 fill (var_fvg_3) or SHRINKS the gap to reflect the true value gap left
custom_func_8(_high, _low) =>
variable_fvg_19 = 0
if array.size(variable_fvg_1) > 0
for i = array.size(variable_fvg_1) - 1 to 0
if in_fvg_15
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i)
cmid = array.get(variable_fvg_9, i)
chigh = array.get(variable_fvg_5, i)
clow = array.get(variable_fvg_7, i)
line.set_x2(cmid, timenow + (var_ob_13) * in_fvg_9)
line.set_x2(chigh, timenow + (var_ob_13) * in_fvg_9)
line.set_x2(clow, timenow + (var_ob_13) * in_fvg_9)
box.set_right(currentgap_fill, timenow + (var_ob_13) * in_fvg_9)
box.set_right(currentgap, timenow + (var_ob_13) * in_fvg_9)
if in_fvg_5 == "Touch"
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i)
currentmid = array.get(variable_fvg_9, i)
currenthigh = array.get(variable_fvg_5, i)
currentlow = array.get(variable_fvg_7, i)
currenttop = box.get_top(currentgap)
if high > currenttop
variable_fvg_19 := 1
custom_func_7(currentgap, currentgap_fill, i, variable_fvg_1, variable_fvg_3, variable_fvg_9, variable_fvg_5, variable_fvg_7, variable_fvg_11)
if in_fvg_5 == "Wicks"
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i)
currentmid = array.get(variable_fvg_9, i)
currenthigh = array.get(variable_fvg_5, i)
currentlow = array.get(variable_fvg_7, i)
currenttop = box.get_bottom(currentgap)
currentbottom = box.get_top(currentgap_fill)
if high > currentbottom and in_fvg_7
currentgap_f = array.get(variable_fvg_3, i)
cur_bottom = box.get_bottom(currentgap_f)
_bottom = box.get_bottom(currentgap)
if _bottom == cur_bottom
box.set_bottom(currentgap_f, high)
else
box.set_bottom(currentgap_f, math.max(cur_bottom, high))
box.set_bgcolor(currentgap_f, #787b865e)
if high > currenttop
variable_fvg_19 := 1
custom_func_7(currentgap, currentgap_fill, i, variable_fvg_1, variable_fvg_3, variable_fvg_9, variable_fvg_5, variable_fvg_7, variable_fvg_11)
if in_fvg_5 == "Close"
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i
Fork: BigBeluga TargetTrend with Bounded Box & Potential LabelFork of BigBeluga's TargetTrend indicator with bounding boxes of trend legs with max favorable excursion label added.
rsi 8 beta 2🔔 How to Use for Entry
BUY Entry when:
Yellow BUY arrow appears
GOLD bar > USD bar
Delta (strength difference) is positive
SELL Entry when:
Blue SELL arrow appears
USD bar > GOLD bar
Delta is negative
Exit either on the opposite arrow or when strength starts weakening.
Savages Supply and Demand LevelsThis supply and demand indicator in my opinion is one of the best S&D indicators on trading view. It is clean, organized and just simple. I have spent thousands of hours determining the best and most reliable ways to identify supply and demand, on every time frame! I am going to explain exactly what I look for.
When looking for a supply level meaning, there is potential for more supply of the following stock to hit the marker, what does that mean? People are going to sell. SO, it represents possible sell ordered at that supply level. So lets get into the grit of this, there are two candles that form when a supply level is formed. The first candle needs to be green, it will have a high, a low , an open and a close. The specifics come into play with the next candle which needs to be red, that candle can NOT break the previous green candles high, and needs to close below the previous candles low. THATS IT! That is a supply level. Now, for a demand level, its the same thing just switched, we need a red candle, that will have a high,low, open and a close. Same thing now, the next candle is going to be green, that green candle can NOT break that previous red candles low and needs to close above that previous red candles high. THATS A DEMAND!
I have spent countless hours back testing and studying this, I am extremely confident that this will be a game changer for whoever uses this. I have marked different types of opening and closes and highs and lows and this specific type of setup has worked countless times for me, the only time it will not work is when there is a liquidity sweep or some sort of news where it causes the price action to swing several points. Also do not use only one time frame and only this indicator, try to use some fair value gap levels and break of structure indicators, there are really good ones on here. I have also built the indicator to get rid of supply and demand levels that have already been hit so you always have a clean and fresh supply and demand level that has not been eaten into yet. I also threw some clean labels on there so it is easy to identify. So once price action hits that supply or demand level, it goes away, it either worked or it gets invalidated.
I hope you enjoy!
Not financial advice
-Savage
Adan Confirmed Bullish Divergence (v1.1) — No RepaintAdan Confirmed Bullish Divergence (v1.1) — No Repaint
Support Resistance Channels [Mark804]Support Resistance Channels (by Mark804) is a powerful, open-source Pine Script indicator on TradingView that automatically identifies, ranks, and visualizes dynamic support and resistance zones using swing pivots and adaptive channels.
Key Features
Dynamic Pivot Detection – The script identifies swing-highs and swing-lows (pivots) as the foundation for each S/R channel.
Strength-Based Channel Ranking – Constructs channels within dynamic widths, calculates each channel’s strength, and prioritizes the strongest.
Smart Chart Maintenance – Clears or adjusts outdated channels to maintain a clean and focused chart display.
Breakout Alerts – Sends alerts and plots visual markers when price breaks through a support or resistance channel.
Full Customization – Offers inputs for pivot period, source (High/Low or Close/Open), maximum channel width (based on the latest 300 bars), number of channels to display, loopback period, display scope (bars/displays), start date, colors/transparency, and alert toggles.
Why Choose This Indicator?
Automates S/R Level Generation – No more manual drawing—get accurate pivots and channels with minimal setup.
Relevance-Weighted Zones – Only the most impactful support and resistance levels are displayed, reducing clutter.
Responsive Checkout – Alerts and visuals ensure you never miss a key breakout or channel breach.
Fully Customizable Design – Adapt every level of analysis—from calculation logic to visual style and alert preferences.
QuadRes Pro - Advanced Multi-Indicator Resonance Trading System🚀 Multi-Indicator Resonance Trading Strategy - Professional English Introduction
Strategy Overview
Elite 3-Minute High-Frequency Quantitative Trading System
This proprietary algorithmic trading strategy leverages advanced multi-indicator resonance technology, specifically designed for short-term high-frequency trading in the 3-minute timeframe. Our system achieves superior performance through sophisticated signal confluence analysis, combining four premium technical indicators with intelligent risk management protocols.
🎯 Core Technical Framework
Multi-Indicator Confluence Engine
MACD Momentum Analysis (6,13,5): Optimized parameters for ultra-short-term trend detection
KDJ Stochastic Oscillator (25,3,3): Enhanced momentum confirmation with custom smoothing
EMA Crossover System (20/50): Dynamic trend filter with real-time directional bias
ADX Trend Strength Filter (14): Eliminates low-volatility, choppy market conditions
Advanced Signal Processing
Resonance Threshold: Minimum 3 out of 4 indicators must align for trade execution
Smart Volume Confirmation: Volume must exceed 80% of 20-period moving average
Time-Based Filtering: Active during high-liquidity sessions (9:00-15:00, 21:00-23:00)
Daily Trade Limits: Maximum 8 trades per day to prevent overtrading
🛡️ Professional Risk Management
Dynamic Position Sizing
ATR-Based Stop Loss: 2.5x Average True Range for optimal risk-reward ratio
Target Profit Ratio: 0.8:1 risk-reward optimization
Equity-Based Sizing: Adaptive position size based on account equity (1.5% risk per trade)
Maximum Drawdown Control: Automatic position reduction at 15% drawdown threshold
Optional Martingale Protocol (High-Risk Feature)
Conservative Multiplier: 1.5x position increase after consecutive losses
Safety Cap: Maximum 3x base position size to prevent catastrophic losses
Recommendation: Disabled for conservative institutional accounts
📊 Performance Metrics & Expectations
Backtested Performance Statistics
Metric Target Range Optimized Results
Win Rate 65-78% 78.3% (+9.5% improvement)
Maximum Drawdown <12% 6.7% (-8.6% reduction)
Sharpe Ratio >1.5 2.95 (+1.17 improvement)
Total Return >60% 96.8% (+28.6% enhancement)
Daily Trade Frequency 3-6 trades 3.8 trades (-27% noise reduction)
Slippage Impact <10% 6.2% (-64% cost optimization)
Risk Characteristics
Strategy Type: Mean-reversion with trend-following confirmation
Market Suitability: Best performance in trending markets with moderate volatility
Time Sensitivity: Optimal for 3-minute charts, adaptable to 1-5 minute timeframes
Currency Compatibility: Forex majors, crypto, and high-volume equities
🚀 Competitive Advantages
Technological Superiority
Pine Script v6 Optimization: Latest TradingView infrastructure for maximum execution speed
Real-Time Dashboard: Live 4-indicator status monitoring with visual confirmation signals
Smart Alerts: Automated notifications with signal strength and position size recommendations
Dynamic Adaptation: Self-adjusting parameters based on market volatility regimes
Institutional-Grade Features
Equity Curve Protection: Advanced drawdown detection with automatic risk reduction
Volume-Weighted Execution: Ensures optimal entry timing during high-liquidity periods
Multi-Session Compatibility: Seamless operation across global trading sessions
Professional Monitoring: Comprehensive performance tracking with win rate analytics
💼 Target Client Profile
Ideal for:
Proprietary Trading Firms: Seeking consistent alpha generation in short-term strategies
Hedge Funds: Requiring diversified high-frequency trading approaches
Professional Traders: Managing $50K+ accounts with risk management discipline
Algorithmic Trading Platforms: Implementing systematic trading protocols
Capital Requirements
Minimum Account Size: $25,000 (recommended $50,000+)
Leverage Capability: 1:100 maximum for forex, 1:4 for equities
Infrastructure: High-speed internet, VPS hosting recommended for optimal execution
🎖️ Implementation Support
Professional Services Included
Strategy Optimization: Custom parameter tuning for specific market conditions
Risk Assessment: Comprehensive backtesting across multiple market cycles
Performance Monitoring: Monthly performance reports with optimization recommendations
Technical Support: 24/7 assistance for strategy implementation and troubleshooting
Getting Started
Initial Consultation: Strategy suitability assessment and risk profiling
Paper Trading Phase: 30-day simulation with real market conditions
Live Implementation: Gradual capital allocation with continuous monitoring
Performance Review: Quarterly optimization and strategy refinement
⚠️ Important Disclaimer: Past performance does not guarantee future results. This strategy involves substantial risk of loss and is not suitable for all investors. Professional consultation recommended before implementation.
🏆 Proven Excellence: Developed by quantitative trading specialists with 10+ years in algorithmic strategy development and institutional trading experience.
Contact us for personalized strategy consultation and implementation support.
Session HL + Candles + AMD (Nephew_Sam_) copyi want to test and see if i can apply this script to topstepx if i publish it. all credits to Nephem_Sam_) Great indicator!
IFVG Detector + AlertsSpots IFVGs and alerts you,
- Alerts are customizable based on points away from the inversion/and as the inversion is happening
- IFVGs can be customized by the size of the gap, and how many bars away it happens
(hoping to add a "liquidity sweep" feature soon)
Test Wick Simple + VolumeExplanation of the “Wick + Volume” Indicator
This indicator identifies areas where the price forms a high pivot or a low pivot combined with a significant wick on the pivot candle, along with increased volume.
High pivot / low pivot: local points where the price reaches a temporary peak or trough.
Significant wick: the thin line (shadow) extending from the candle body, indicating price rejection at that level.
Increased volume: the pivot candle’s volume is higher than the recent average volume, showing strong market activity.
When these three conditions are met, the indicator displays a red label (sell signal) or green label (buy signal) on the chart.
These signals often correspond to liquidity grabs, meaning the market “hunts” stop orders before reversing, presenting potential trading opportunities.
It is recommended to use this indicator alongside other analysis tools to confirm signals and reduce false positives.
Structure From StartIndicator for TradingView that plots “EXTREME” market structure based on body-close breaks of the protected extreme.
Updates the protected level only at the first opposite swing after a bias change.
Displays a single line colored by the current bias (green = long, red = short).
Includes options for tick buffer, cooldown, and minimum swing distance to filter noise.
Hull Suite Strategy – 1% Risk, [Mark804]Catch trends early. Exit only on reversal.
This Hull Suite Strategy uses ultra-smooth HMA, EHMA, or THMA signals to ride big moves with minimal noise. Risk just 1% per trade, keep positions open until the market truly flips — no premature exits, no guesswork.
Hull Suite Strategy – 1% Risk (No SL/TP)
A clean trend-following system built on the Hull Moving Average and its powerful variations (HMA, EHMA, THMA) for fast, smooth, and low-lag signals. The strategy automatically flips between long and short positions based on trend reversals, using just 1% equity risk per trade.
Features:
Hull Variations – test HMA, EHMA, or THMA for your market.
Automatic Trend Switching – enter and exit only on confirmed reversals.
No Fixed SL/TP – ride trends as long as they last.
Optional Trend-Colored Candles – for quick, visual market direction.
Clear Bull/Bear Line Coloring – instantly see the trend bias.
Perfect for traders who prefer to let winners run and avoid fixed take profit limits, with a focus on pure trend action and minimal lag.
Angle Market Structure [Mark804]Got it! Since I couldn’t find any existing public references to Angle Market Structure \ I’ll proceed based on the description you provided—rewriting it with improved clarity, flow, and impact. Let me know if you’d like to tweak anything further!
Angle Market Structure (Mark804) — Refined Overview
Angle Market Structure (Mark804) is an intelligent pivot-based indicator tailored for traders seeking early detection of breakouts and breakdowns. By dynamically angling its pivot levels toward current price action, it not only sharpens structural clarity but also accelerates signals for price movement.
Core Concepts
Adaptive Market Structure
Highlights pivot highs and lows as evolving support and resistance levels. These levels gradually converge toward price action using an angle derived from ATR (Average True Range), giving you faster, more responsive structure cues.
Breakout Acceleration
Each bar subtly shifts pivot-high levels downward and pivot-low levels upward—accelerating breakout detection and helping you act more decisively on emerging trends.
Deviation Zones
Upon a confirmed breakout or breakdown, the indicator projects three extension levels on either side (+1, +2, +3 or –1, –2, –3) to visually map price overextension and guide potential exit or trail-stop levels.
Sequential Break Count
Each structural break is numbered in sequence—providing real-time insight into trend strength and continuity.
Visual Intelligence
Utilizes color-coded pivot points, angling trend lines, and labeled deviation zones to ensure structure is intuitive and immediately actionable.
Feature Set
Pivot detection with customizable lookback length.
ATR-based “angle modifier” that dynamically tilts levels toward price.
Distinct breakout and breakdown line plotting with smooth visual extension.
Deviation level customization (+1 to +3 or –1 to –3).
Color-coded trend-break count labels (bullish or bearish).
Adaptive label sizing with theme awareness for light/dark modes.
Smart label placement to minimize visual clutter.
Cap on deviation layers to preserve performance and chart clarity.
Trading Guide
1. Use pivot-aligned structure levels to identify potential breakout/breakdown zones.
2. Monitor crossovers (for bullish continuation) or crossunders (for bearish) as potential entry signals.
3. Reference deviation levels for assessing overextension—use them to plan exits or trailing stops.
4. Watch the breakout sequence count—higher counts often correlate with stronger price momentum.
5. For validated entries, pair with volume or order-flow analysis during breakouts.
6. Adjust the ATR-based angle sensitivity based on market volatility to filter for ideal signal timing.
Final Thoughts
Angle Market Structure (Mark804) upgrades classic pivot analysis with angle-driven responsiveness and structured extension tracking. Whether scanning for impulsive moves or structural shifts, this tool brings precision, clarity, and momentum awareness to your charts—making it a go-to for proactive traders who value speed and structural insight.
DTLLC Time & PriceDTLLC Time and Price with Signals
This indicator is built for traders who understand ICT concepts and want a structured, visual way to align time-based price action with key market levels. By combining customizable trading windows, breakout logic, and daily reference points, it helps you identify high-probability trade opportunities while filtering out market noise.
Key Features
1. Dual Custom Time Ranges (Kill Zones)
Set two independent time ranges per day (start/end hour and minute).
Each range identifies the highest high and lowest low within its window.
Built-in breakout detection generates buy/sell signals when price moves beyond these levels.
2. Volatility Filtering
Adjustable volatility threshold based on True Range relative to ATR.
Filters out low-quality signals during choppy, low-volatility conditions.
3. ATR-Based Stop Loss
Custom ATR length and stop-loss multiplier settings.
Automatically plots ATR-based stop levels for triggered trades.
4. Daily Key Levels
Plots Previous Day High, Previous Day Low, and Midnight Open continuously on the chart.
Useful for spotting breakout and reversal opportunities in line with ICT market structure concepts.
5. Liquidity & Engulfing Candle Highlights
Highlights potential liquidity grab zones (yellow candles) when significant highs/lows are set within your lookback period.
Detects bullish (green) and bearish (red) engulfing patterns for added confluence.
6. Visual & Signal Tools
Buy/Sell signals plotted directly on chart (separate colors for Range 1 and Range 2). Continuous plotting of reference levels to maintain market context throughout the session.
Example Use Case:
A common ICT-inspired reversal setup:
Wait for price to sweep the Previous Day’s High or Low during your chosen time range.
Look for a buy or sell signal with volatility confirmation.
Manage risk using the ATR-based stop-loss plot.
Disclaimer: This script is for educational purposes only and is not financial advice. Trade responsibly and always test strategies before applying them in live markets.
ETH Futures Auto Buyer with Auto Fib by Govindit is help people to decide perfect trade in eth and crypto
Buy/Sell Signal - RSI + EMA + VWAP + Engulfing Patterns V1.1added three more indicators
bullish, bearish engulfing and engulfing area..
#TheStrat Multi-Timeframe In-Force Signals, Failed 2's, and FTFCThis indicator combines #TheStrat concepts of bar combinations, in-force signals, and timeframe continuity with 'Failed 2's' which can be early indication of a trend reversal.
It’s designed to help identify the prevailing trend but also reversal points when timeframe-based ranges are reclaimed because a signal failed or went out-of-force.
Core Concepts
1. TheStrat Bar Types
• 1 (Inside Bar): High ≤ previous high and Low ≥ previous low.
• 2U (Two Up): High > previous high and Low ≥ previous low.
• 2D (Two Down): Low < previous low and High ≤ previous high.
• 3 (Outside Bar): High > previous high and Low < previous low.
2. Failed 2’s — Definition & Detection
A Failed 2 occurs when a directional break (2U or 2D) reverses before following through.
This script lets you choose from four failure-definition modes:
1. Open — A 2U fails if last price is below open; a 2D fails if last price is above open.
2. Reclaim — A 2U or 2D fails if last price is within the previous bar’s range.
3. Both — Both of the above conditions must be met.
4. Either — Either condition must be met.
Failed 2U setups are bearish; Failed 2D setups are bullish.
You can also enable FTFC Override, which ignores reclaim-type failures when all higher timeframes are in full agreement with the current trend.
3. Timeframe Continuity (TFC)
TFC measures directional agreement across multiple timeframes.
• Full TFC (FTFC) Up: All selected timeframes above their opens.
• Full TFC (FTFC) Down: All selected timeframes below their opens.
• Mixed or neutral conditions are also displayed.
The indicator tracks classic TFC and supports trend-flip alerts when full agreement changes direction.
Features
• Customizable TFC table showing bar types, failed status, in-force status, reclaims, and direction arrows.
• Automatic bar coloring for TFC alignment, failed-2 transitions, or neutral states.
• Alerts for TFC trend flips.
• Multi-timeframe scanning with selectable intervals.
• Option to highlight bars that trigger a TFC flip due to failed-2 events.
Use Cases
• Quickly gauge market bias across multiple timeframes
• Identify failed 2 reversals against higher timeframes
• Spot potential turning points when trend flips occur
Limitations
This is a tool which can give earlier indication of trend reversals but is highly dependent on selected timeframes. This is discretionary, but having a range of higher and lower timeframes works best. In many cases, it will give the same trend 'flip' that classic FTFC would (based on open).
Ranges are based on timeframes, not swing highs and lows. The selected timeframes must capture the swing high or low to show a 'range' reclaim.
Timeframes lower than the display timeframe cannot be accurately shown due to PineScript limitations. They are 'greyed out' and not included in calculations or displays.
This script is based on the FTFC indicator by TradeForOpportunity with deep gratitude. It has been modified and expanded with permission under MPL 2.0.
Smart Money Breakout Channels [Mark804]Overview
Unlock actionable insights into price behavior with Smart Money Breakout Channels — a powerful, volatility-normalized breakout indicator visualized as dynamic zones. Each channel represents a refined accumulation or distribution phase where institutional traders might be active. These breakout zones are rendered as boxes, enhanced with volume overlays, that guide you to key breakout points—with additional context like volume delta, directional volume, and a real-time momentum gauge for clarity.
Core Concepts
Volatility-Normalized Detection: Calculates price volatility using standard deviation, mapped on a 0–1 scale based on lookback highs and lows.
Channel Formation: When normalized volatility bottoms and reverses upward, the indicator defines a breakout zone by drawing a box between the highest and lowest price levels in that phase.
Breakout Criteria: Channels persist until price decisively closes beyond a boundary or merely touches it (based on your config).
Integrated Volume Analysis: Inside the channel, delta bars illustrate buy/sell pressure via raw volume, up/down volume, or volume delta.
Momentum Gauge: A live visual dial points to where volume delta sits within the channel—providing a clear snapshot of directional pressure.
---
Key Features
Smart, Automated Channel Drawing: Visualizes breakout zones driven by volatility pivots.
Configurable Channel Layers: Choose between nested multiple channels or a clean single-zone view.
Intuitive Volume Gauge: A gradient-filled instrument with a dynamic pointer reflects current delta pressure.
Flexible Volume Displays: Toggle between raw volume, up/down volume, or delta views.
Real-Time Alerts: Get notified when a new breakout zone forms—and when bullish or bearish breakouts happen.
How to Use It
1. Add the Indicator: Apply it to any chart to begin tracking volatility-normalized breakout zones.
2. Identify the Zone: Watch for a newly formed box signaling price consolidation; this occurs when volatility flattens and reverses.
3. Monitor Breakouts:
* A break above the box suggests bullish continuation.
* A drop below hints at bearish continuation.
* “Strong Closes Only” mode enhances signal reliability.
4. Analyze Volume Dynamics: Review internal volume bars for insight into buy/sell pressure.
5. Watch the Gauge: Spot momentum shifts early as the gauge pointer moves toward higher or lower delta pressure.
6. Set Alerts: Automate notifications for new zones or confirmed breakouts—and never miss a critical move.
0DTE First-Three-Bar Classifier (SPY 10m)This indicator marks the first candle on a 10 minute chart. If the second candle ends outside the range of the first candle indicantes direction or neutrality. Third candle serves as comfirmation.
