Altseason IndexDescription of the "Altseason Index" Indicator
The Altseason Index is a powerful and visually minimalist tool designed to objectively identify the onset and conclusion of an "altseason" in the cryptocurrency market. Moving beyond subjective speculation, this indicator employs a clear, mathematical methodology by comparing the performance of a broad basket of altcoins against Bitcoin.
🎯 Core Concept and Utility
An "Altseason" is a market period where altcoins (cryptocurrencies other than Bitcoin) consistently yield higher returns than BTC. This indicator empowers traders and investors to:
Objectively Identify Market Cycles: Precisely pinpoint when capital is actively rotating from Bitcoin into altcoins and vice versa.
Make Data-Driven Decisions: Adjust their strategy in a timely manner: increasing exposure to altcoins during an altseason or rotating back into BTC upon its conclusion.
Avoid Emotional Pitfalls: Steer clear of FOMO (Fear Of Missing Out) and base decisions on hard data rather than market noise.
⚙️ How the Calculation Works
1. Asset Selection: The indicator tracks the performance of 15 leading altcoins across various market segments (Layer 1s, DeFi, Meme, Payments), ensuring a representative sample.
2. Performance Comparison: For each altcoin, the percentage price change over the user-defined lookback period (default: 90 days) is calculated. This performance is then compared to BTC's performance over the same period.
3. Counting the "Outperformers": The index counts the number of altcoins that have "outperformed" BTC.
4. Calculating the Index: The Altseason Index value is the percentage of altcoins in the basket that are outperforming BTC. For example, a value of 60% means that 9 out of the 15 coins performed better than Bitcoin.
🛠️ Indicator Settings
The settings are kept simple and intuitive, allowing you to customize the indicator to your strategy:
Lookback Period (days) (Default: 90):
- Defines the time horizon for the performance calculation.
- Shorter Periods (30-60 days) react faster to new trends but may produce more false signals.
- Longer Periods (90-180 days) provide smoother and more reliable signals, capturing sustained macro-trends.
Altseason Threshold (%) (Default: 75%):
- This is the key parameter that defines what index value constitutes an official "altseason."
- A threshold of 75% means an altseason is declared when at least 11 out of the 15 altcoins (75%) are outperforming BTC.
- You can increase the threshold (e.g., to 85%) for more conservative and stronger signals, or decrease it (e.g., to 65%) for earlier entries.
📊 Interpreting the Readings and Signals
The indicator uses a clear color-coding system and levels for easy interpretation:
🔴 < 30%: "BTC SEASON"
Bitcoin is dominating. The market is in risk-off mode or a state of anticipation. Growth is concentrated in BTC.
⚪ 30% - 49%: "NEUTRAL"
A transitional phase. The market is uncertain. Some alts show strength, but there is no unified trend.
🔵 50% - 74%: "BULLISH"
Growing strength in altcoins. Capital is beginning to rotate actively. This can be an early stage of an altseason.
🟢 ≥ 75% (or your custom threshold): "ALTSEASON"
The active altseason phase. The vast majority of altcoins are rising faster than BTC. This is the period of maximum potential returns for alts.
Signal Markers:
Green Dot: Signals the potential start of an altseason (the index crosses above the threshold).
Red Dot: Signals the potential end of an altseason (the index crosses below the threshold).
ℹ️ Information Panel
The chart displays two clean information panels:
1. Main Info Label:
Current index value (e.g., ⟠ 80%).
Market status (ALTSEASON, BULLISH, etc.).
The ratio of outperforming altcoins (11/15 alts).
2. Dominance & Market Cap Panel:
Alts: Altcoin Dominance (the market cap share of all coins except BTC).
BTC: Bitcoin Dominance.
Market: Total cryptocurrency market capitalization in billions of USD. This helps assess the overall market context (bullish/bearish).
💎 Conclusion
The Altseason Index is your strategic companion for navigating the crypto markets. It transforms the complex task of identifying market cycles into a simple and visual process. Use it to confirm broad market trends, identify potential entry and exit points, and, most importantly, to maintain discipline in your trading strategy by filtering out noise and emotion.
Disclaimer: This indicator is a tool for analysis and does not constitute investment advice. All trading decisions are taken at your own risk.
อินดิเคเตอร์และกลยุทธ์
Safe Supertrend Strategy (No Repaint)Overview
The Safe Supertrend is a repaint-free version of the popular Supertrend trend-following indicator.
Most Supertrend indicators appear perfect on historical charts because they flip intrabar and then repaint after the candle closes.
This version fixes that by using close-of-bar confirmation only, making every trend flip 100% stable, safe, and non-repainting.
Why This Supertrend Doesn’t Repaint
Most Supertrend indicators calculate their trend direction using the current bar’s data.
But during a live candle:
ATR expands and contracts
The upper/lower bands move
Price moves above/below the band temporarily
A false flip appears → then disappears when the candle closes
That is classic repainting.
This indicator avoids all of that by using:
close > upper
close < lower
This means:
Trend direction flips only based on the previous candle,
No intrabar calculations,
No flickering signals,
No “perfect but fake” historical performance.
Every signal you see on the chart is exactly what was available in real-time.
How It Works
Calculates ATR (Average True Range) and SMA centerline
Builds upper and lower volatility bands
Confirms trend flips only after the previous bar closes
Plots clear bull and bear reversal signals
Works on all markets (crypto, stocks, forex, indices)
No repainting, no recalc, no misleading flips.
Bullish Signal (Trend Up)
A bullish trend begins only when:
The previous candle closes above the upper ATR band,
And this flip is fully confirmed.
A green triangle marks the start of a new uptrend.
Bearish Signal (Trend Down)
A bearish trend begins only when:
The previous candle closes below the lower ATR band,
And the downtrend is confirmed.
A red triangle signals the start of a new downtrend.
Inputs
ATR Length - default 10
ATR Multiplier - default 3.0
Works on all timeframes and market
Simple, but powerful.
Why Use This Version Instead of a Regular Supertrend?
Most Supertrends:
Look great historically
But repaint continuously on live charts
Give false trend flips intrabar
Cannot be reliably used in strategies
This version:
Uses strict previous-bar logic
Never repaints trend direction
Works perfectly in live trading
Backtests accurately
Is ideal for algorithmic strategies
Ideal For:
Trend-following strategies
Breakout trading
Algo trading systems
Reversal detection
Filtering market noise
Swing trading & scalping
Final Note
This is a safer, more reliable Supertrend designed for real-world use — not perfect-looking repaint illusions.
If you use Supertrend in your trading system, this no-repaint version ensures your signals are trustworthy and consistent.
Price Action Concepts [RUDYINDICATOR]/// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) creativecommons.org
// © RUDYBANK INDICATOR - formerly know as RUDY INDICATOR
//@version=5
indicator("Price Action Concepts ", shorttitle = "RUDYINDICATOR-V1
- Price Action RUDYINDICATOR ", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500, max_bars_back = 500, max_polylines_count = 100)
//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BOS = 0
s_CHoCH = 1
i_BOS = 2
i_CHoCH = 3
i_pp_CHoCH = 4
green_candle = 5
red_candle = 6
s_CHoCHP = 7
i_CHoCHP = 8
boolean =
array.from(
false
, false
, false
, false
, false
, false
, false
, false
, false
)
//-----------------------------------------------------------------------------{
// User inputs
//-----------------------------------------------------------------------------{
show_swing_ms = input.string ("All" , "Swing        " , inline = "1", group = "MARKET STRUCTURE" , options = )
show_internal_ms = input.string ("All" , "Internal     " , inline = "2", group = "MARKET STRUCTURE" , options = )
internal_r_lookback = input.int (5 , "" , inline = "2", group = "MARKET STRUCTURE" , minval = 2)
swing_r_lookback = input.int (50 , "" , inline = "1", group = "MARKET STRUCTURE" , minval = 2)
ms_mode = input.string ("Manual" , "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE" , tooltip = " Use selected lenght Use automatic lenght" ,options = )
show_mtf_str = input.bool (true , "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE" , tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green = Bullish. Red = Bearish")
show_eql = input.bool (false , "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE")
plotcandle_bool = input.bool (false , "Plotcandle" , inline = "3", group = "MARKET STRUCTURE" , tooltip = "Displays a cleaner colored candlestick chart in place of the default candles. (requires hiding the current ticker candles)")
barcolor_bool = input.bool (false , "Bar Color" , inline = "4", group = "MARKET STRUCTURE" , tooltip = "Color the candle bodies according to market strucutre trend")
i_ms_up_BOS = input.color (#089981 , "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BOS = input.color (#f23645 , "" , inline = "2", group = "MARKET STRUCTURE")
s_ms_up_BOS = input.color (#089981 , "" , inline = "1", group = "MARKET STRUCTURE")
s_ms_dn_BOS = input.color (#f23645 , "" , inline = "1", group = "MARKET STRUCTURE")
lvl_daily = input.bool (false , "Day   " , inline = "1", group = "HIGHS & LOWS MTF")
lvl_weekly = input.bool (false , "Week " , inline = "2", group = "HIGHS & LOWS MTF")
lvl_monthly = input.bool (false , "Month" , inline = "3", group = "HIGHS & LOWS MTF")
lvl_yearly = input.bool (false , "Year  " , inline = "4", group = "HIGHS & LOWS MTF")
css_d = input.color (color.blue , "" , inline = "1", group = "HIGHS & LOWS MTF")
css_w = input.color (color.blue , "" , inline = "2", group = "HIGHS & LOWS MTF")
css_m = input.color (color.blue , "" , inline = "3", group = "HIGHS & LOWS MTF")
css_y = input.color (color.blue , "" , inline = "4", group = "HIGHS & LOWS MTF")
s_d = input.string ('⎯⎯⎯' , '' , inline = '1', group = 'HIGHS & LOWS MTF' , options = )
s_w = input.string ('⎯⎯⎯' , '' , inline = '2', group = 'HIGHS & LOWS MTF' , options = )
s_m = input.string ('⎯⎯⎯' , '' , inline = '3', group = 'HIGHS & LOWS MTF' , options = )
s_y = input.string ('⎯⎯⎯' , '' , inline = '4', group = 'HIGHS & LOWS MTF' , options = )
ob_show = input.bool (true , "Show Last    " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volumetric order blocks on the chart Ammount of volumetric order blocks to show")
ob_num = input.int (5 , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Orderblocks number", minval = 1, maxval = 10)
ob_metrics_show = input.bool (true , "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volume metrics that have formed the orderblock")
css_metric_up = input.color (color.new(#089981, 50) , "         " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 50) , "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
ob_swings = input.bool (false , "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display swing volumetric order blocks")
css_swing_up = input.color (color.new(color.gray , 90) , "                 " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
css_swing_dn = input.color (color.new(color.silver, 90) , "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
ob_filter = input.string ("None" , "Filtering             " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options = )
ob_mitigation = input.string ("Absolute" , "Mitigation           " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Trigger to remove volumetric order blocks", options = )
ob_pos = input.string ("Precise" , "Positioning          " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Position of the Order Block Cover the whole candle Cover half candle Adjust to volatility Same as Accurate but more precise", options = )
use_grayscale = input.bool (false , "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Use gray as basic order blocks color")
use_show_metric = input.bool (true , "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show volume associated with the orderblock and his relevance")
use_middle_line = input.bool (true , "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true , "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Hide overlapping order blocks")
use_overlap_method = input.string ("Previous" , "Overlap Method    " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = " Preserve the most recent volumetric order blocks Preserve the previous volumetric order blocks", options = )
ob_bull_css = input.color (color.new(#089981 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
ob_bear_css = input.color (color.new(#f23645 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
show_acc_dist_zone = input.bool (false , "" , inline = "1", group = "Accumulation And Distribution")
zone_mode = input.string ("Fast" , "" , inline = "1", group = "Accumulation And Distribution" , tooltip = " Find small zone pattern formation Find bigger zone pattern formation" ,options = )
acc_css = input.color (color.new(#089981 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
dist_css = input.color (color.new(#f23645 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
show_lbl = input.bool (false , "Show swing point" , inline = "1", group = "High and Low" , tooltip = "Display swing point")
show_mtb = input.bool (false , "Show High/Low/Equilibrium" , inline = "2", group = "High and Low" , tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.red , "Premium Zone   " , inline = "3", group = "High and Low")
midlvl = input.color (color.gray , "Equilibrium Zone" , inline = "4", group = "High and Low")
btmlvl = input.color (#089981 , "Discount Zone    " , inline = "5", group = "High and Low")
fvg_enable = input.bool (false , "        " , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap")
what_fvg = input.string ("FVG" , "" , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap", options = )
fvg_num = input.int (5 , "Show Last  " , inline = "1a", group = "FAIR VALUE GAP" , tooltip = "Number of fvg to show")
fvg_upcss = input.color (color.new(#089981, 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_dncss = input.color (color.new(color.red , 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_extend = input.int (10 , "Extend FVG" , inline = "2", group = "FAIR VALUE GAP" , tooltip = "Extend the display of the FVG.")
fvg_src = input.string ("Close" , "Mitigation  " , inline = "3", group = "FAIR VALUE GAP" , tooltip = " Use the close of the body as trigger Use the extreme point of the body as trigger", options = )
fvg_tf = input.timeframe ("" , "Timeframe " , inline = "4", group = "FAIR VALUE GAP" , tooltip = "Timeframe of the fair value gap")
t = color.t (ob_bull_css)
invcol = color.new (color.white , 100)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - UDT }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
type bar
float o = open
float c = close
float h = high
float l = low
float v = volume
int n = bar_index
int t = time
type Zphl
line top
line bottom
label top_label
label bottom_label
bool stopcross
bool sbottomcross
bool itopcross
bool ibottomcross
string txtup
string txtdn
float topy
float bottomy
float topx
float bottomx
float tup
float tdn
int tupx
int tdnx
float itopy
float itopx
float ibottomy
float ibottomx
float uV
float dV
type FVG
box box
line ln
bool bull
float top
float btm
int left
int right
type ms
float p
int n
float l
type msDraw
int n
float p
color css
string txt
bool bull
type obC
float top
float btm
int left
float avg
float dV
float cV
int wM
int blVP
int brVP
int dir
float h
float l
int n
type obD
box ob
box eOB
box blB
box brB
line mL
type zone
chart.point points
float p
int c
int t
type hqlzone
box pbx
box ebx
box lbx
label plb
label elb
label lbl
type ehl
float pt
int t
float pb
int b
type pattern
string found = "None"
bool isfound = false
int period = 0
bool bull = false
type alerts
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool equal = false
bool ob = false
bool swingob = false
bool zone = false
bool fvg = false
bool obtouch = false
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - General Setup }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
bar b = bar.new()
var pattern p = pattern.new()
alerts blalert = alerts.new()
alerts bralert = alerts.new()
if p.isfound
p.period += 1
if p.period == 50
p.period := 0
p.found := "None"
p.isfound := false
p.bull := na
switch
b.c > b.o => boolean.set(green_candle, true)
b.c < b.o => boolean.set(red_candle , true)
f_zscore(src, lookback) =>
(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)
var int iLen = internal_r_lookback
var int sLen = swing_r_lookback
vv = f_zscore(((close - close ) / close ) * 100,iLen)
if ms_mode == "Dynamic"
switch
vv >= 1.5 or vv <= -1.5 => iLen := 10
vv >= 1.6 or vv <= -1.6 => iLen := 9
vv >= 1.7 or vv <= -1.7 => iLen := 8
vv >= 1.8 or vv <= -1.8 => iLen := 7
vv >= 1.9 or vv <= -1.9 => iLen := 6
vv >= 2.0 or vv <= -2.0 => iLen := 5
=> iLen
var msline = array.new(0)
iH = ta.pivothigh(high, iLen, iLen)
sH = ta.pivothigh(high, sLen, sLen)
iL = ta.pivotlow (low , iLen, iLen)
sL = ta.pivotlow (low , sLen, sLen)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - ARRAYS }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
hl () =>
= request.security(syminfo.tickerid , 'D' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'W' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'M' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , '12M', hl() , lookahead = barmerge.lookahead_on)
lstyle(style) =>
out = switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
'····' => line.style_dotted
mtfphl(h, l ,tf ,css, pdhl_style) =>
var line hl = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var line ll = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var label lbl = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}L', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
var label hlb = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}H', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
hy = ta.valuewhen(h != h , h , 1)
hx = ta.valuewhen(h == high , time , 1)
ly = ta.valuewhen(l != l , l , 1)
lx = ta.valuewhen(l == low , time , 1)
if barstate.islast
extension = time + (time - time ) * 50
line.set_xy1(hl , hx , hy)
line.set_xy2(hl , extension , hy)
label.set_xy(hlb, extension , hy)
line.set_xy1(ll , lx , ly)
line.set_xy2(ll , extension , ly)
label.set_xy(lbl, extension , ly)
if lvl_daily
mtfphl(pdh , pdl , 'D' , css_d, s_d)
if lvl_weekly
mtfphl(pwh , pwl , 'W' , css_w, s_w)
if lvl_monthly
mtfphl(pmh , pml, 'M' , css_m, s_m)
if lvl_yearly
mtfphl(pyh , pyl , '12M', css_y, s_y)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Market Structure }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method darkcss(color css, float factor, bool bull) =>
blue = color.b(css) * (1 - factor)
red = color.r(css) * (1 - factor)
green = color.g(css) * (1 - factor)
color.rgb(red, green, blue, 0)
method f_line(msDraw d, size, style) =>
var line id = na
var label lbl = na
id := line.new(
d.n
, d.p
, b.n
, d.p
, color = d.css
, width = 1
, style = style
)
if msline.size() >= 250
line.delete(msline.shift())
msline.push(id)
lbl := label.new(
int(math.avg(d.n, b.n))
, d.p
, d.txt
, color = invcol
, textcolor = d.css
, style = d.bull ? label.style_label_down : label.style_label_up
, size = size
, text_font_family = font.family_monospace
)
structure(bool mtf) =>
msDraw drw = na
bool isdrw = false
bool isdrwS = false
var color css = na
var color icss = na
var int itrend = 0
var int trend = 0
bool bull_ob = false
bool bear_ob = false
bool s_bull_ob = false
bool s_bear_ob = false
n = bar_index
var ms up = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms dn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sup = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sdn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
switch show_swing_ms
"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, true )
"CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, false )
"CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, true )
"BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
=> na
switch show_internal_ms
"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, true )
"CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, false)
"CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, true )
"BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
=> na
switch
iH =>
up.p.unshift(b.h )
up.l.unshift(b.h )
up.n.unshift(n )
iL =>
dn.p.unshift(b.l )
dn.l.unshift(b.l )
dn.n.unshift(n )
sL =>
sdn.p.unshift(b.l )
sdn.l.unshift(b.l )
sdn.n.unshift(n )
sH =>
sup.p.unshift(b.h )
sup.l.unshift(b.h )
sup.n.unshift(n )
// INTERNAL BULLISH STRUCTURE
if up.p.size() > 0 and dn.l.size() > 1
if ta.crossover(b.c, up.p.first())
bool CHoCH = na
string txt = na
if itrend < 0
CHoCH := true
switch
not CHoCH =>
txt := "BOS"
css := i_ms_up_BOS
blalert.bos := true
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS
, txt
, true
)
CHoCH =>
dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch
txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_up_BOS.darkcss(0.25, true)
if (dn.l.first() > dn.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => bull_ob := true
ob_filter == "BOS" and txt == "BOS" => bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bull_ob := true
itrend := 1
up.n.clear()
up.p.clear()
// INTERNAL BEARISH STRUCTURE
if dn.p.size() > 0 and up.l.size() > 1
if ta.crossunder(b.c, dn.p.first())
bool CHoCH = na
string txt = na
if itrend > 0
CHoCH := true
switch
not CHoCH =>
bralert.bos := true
txt := "BOS"
css := i_ms_dn_BOS
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS
, txt
, false
)
CHoCH =>
if up.l.first() < up.l.get(1)
bralert.chochplus := true
else
bralert.choch := true
txt := up.l.first() < up.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_dn_BOS.darkcss(0.25, false)
if (up.l.first() < up.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => bear_ob := true
ob_filter == "BOS" and txt == "BOS" => bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bear_ob := true
itrend := -1
dn.n.clear()
dn.p.clear()
// SWING BULLISH STRUCTURE
if sup.p.size() > 0 and sdn.l.size() > 1
if ta.crossover(b.c, sup.p.first())
bool CHoCH = na
string txt = na
if trend < 0
CHoCH := true
switch
not CHoCH =>
blalert.swingbos := true
txt := "BOS"
icss := s_ms_up_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS
, txt
, true
)
CHoCH =>
if sdn.l.first() > sdn.l.get(1)
blalert.chochplusswing := true
else
blalert.chochswing := true
txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_up_BOS.darkcss(0.25, true)
if (sdn.l.first() > sdn.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => s_bull_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bull_ob := true
trend := 1
sup.n.clear()
sup.p.clear()
// SWING BEARISH STRUCTURE
if sdn.p.size() > 0 and sup.l.size() > 1
if ta.crossunder(b.c, sdn.p.first())
bool CHoCH = na
string txt = na
if trend > 0
CHoCH := true
switch
not CHoCH =>
bralert.swingbos := true
txt := "BOS"
icss := s_ms_dn_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS
, txt
, false
)
CHoCH =>
if sup.l.first() < sup.l.get(1)
bralert.chochplusswing := true
else
bralert.chochswing := true
txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_dn_BOS.darkcss(0.25, false)
if (sup.l.first() < sup.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => s_bear_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bear_ob := true
trend := -1
sdn.n.clear()
sdn.p.clear()
= structure(false)
if isdrw
f_line(drw, size.small, line.style_dashed)
if isdrwS
f_line(drw, size.small, line.style_solid)
= request.security("", "15" , structure(true))
= request.security("", "60" , structure(true))
= request.security("", "240" , structure(true))
= request.security("", "1440" , structure(true))
if show_mtf_str
var tab = table.new(position = position.top_right, columns = 10, rows = 10, bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color = color.rgb(54, 58, 69, 100), border_width = 1)
table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 5, text = "Detected Pattern", text_halign = text.align_center, text_size = size.normal, text_color = color.silver, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center, text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ? i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25, false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.merge_cells(tab, 0, 5, 1, 5)
table.merge_cells(tab, 0, 6, 1, 6)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Strong/Weak High/Low And Equilibrium }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
var phl = Zphl.new(
na
, na
, label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style = label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style = label.style_label_up , size = size.tiny , text = "")
, true
, true
, true
, true
, ""
, ""
, 0
, 0
, 0
, 0
, high
, low
, 0
, 0
, 0
, 0
, 0
, 0
, na
, na
)
zhl(len)=>
upper = ta.highest(len)
lower = ta.lowest(len)
var float out = 0
out := b.h > upper ? 0 : b.l < lower ? 1 : out
top = out == 0 and out != 0 ? b.h : 0
btm = out == 1 and out != 1 ? b.l : 0
= zhl(sLen)
= zhl(iLen)
upphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
if top
phl.stopcross := true
phl.txtup := top > phl.topy ? "HH" : "HL"
if show_lbl
topl = label.new(
b.n - swing_r_lookback
, top
, phl.txtup
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
line.delete(phl.top )
phl.top := line.new(
b.n - sLen
, top
, b.n
, top
, color = toplvl)
phl.topy := top
phl.topx := b.n - sLen
phl.tup := top
phl.tupx := b.n - sLen
if itop
phl.itopcross := true
phl.itopy := itop
phl.itopx := b.n - iLen
phl.tup := math.max(high, phl.tup)
phl.tupx := phl.tup == high ? b.n : phl.tupx
phl.uV := phl.tup != phl.tup ? b.v : phl.uV
if barstate.islast
line.set_xy1(
phl.top
, phl.tupx
, phl.tup
)
line.set_xy2(
phl.top
, b.n + 50
, phl.tup
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tup
)
dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend < 0
? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
dnphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
if btm
phl.sbottomcross := true
phl.txtdn := btm > phl.bottomy ? "LH" : "LL"
if show_lbl
btml = label.new(
b.n - swing_r_lookback
, btm, phl.txtdn
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
line.delete(phl.bottom )
phl.bottom := line.new(
b.n - sLen
, btm
, b.n
, btm
, color = btmlvl
)
phl.bottomy := btm
phl.bottomx := b.n - sLen
phl.tdn := btm
phl.tdnx := b.n - sLen
if ibtm
phl.ibottomcross := true
phl.ibottomy := ibtm
phl.ibottomx := b.n - iLen
phl.tdn := math.min(low, phl.tdn)
phl.tdnx := phl.tdn == low ? b.n : phl.tdnx
phl.dV := phl.tdn != phl.tdn ? b.v : phl.dV
if barstate.islast
line.set_xy1(
phl.bottom
, phl.tdnx
, phl.tdn
)
line.set_xy2(
phl.bottom
, b.n + 50
, phl.tdn
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tdn
)
dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend > 0
? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
midphl() =>
avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2())
var line l = line.new(
y1 = avg
, y2 = avg
, x1 = b.n - sLen
, x2 = b.n + 50
, color = midlvl
, style = line.style_solid
)
var label lbl = label.new(
x = b.n + 50
, y = avg
, text = "Equilibrium"
, style = label.style_label_left
, color = invcol
, textcolor = midlvl
, size = size.small
)
if barstate.islast
more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() + phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1()
line.set_xy1(l , more , avg)
line.set_xy2(l , b.n + 50, avg)
label.set_x (lbl , b.n + 50 )
label.set_y (lbl , avg )
dist = math.abs((l.get_y2() - close) / close) * 100
label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) + "%)")
hqlzone() =>
if barstate.islast
var hqlzone dZone = hqlzone.new(
box.new(
na
, na
, na
, na
, bgcolor = color.new(toplvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(midlvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(btmlvl, 70)
, border_color = na
)
, label.new(na, na, text = "Premium" , color = invcol, textcolor = toplvl, style = label.style_label_down, size = size.small)
, label.new(na, na, text = "Equilibrium", color = invcol, textcolor = midlvl, style = label.style_label_left, size = size.small)
, label.new(na, na, text = "Discount" , color = invcol, textcolor = btmlvl, style = label.style_label_up , size = size.small)
)
dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)) , phl.tup)
dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup + 0.05 * phl.tdn)
dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup + 0.475 * phl.tdn)
dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn + 0.475 * phl.tup)
dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn + 0.05 * phl.tup)
dZone.lbx.set_rightbottom(b.n + 50 , phl.tdn)
dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tup)
dZone.elb.set_xy( int(b.n + 50) , math.avg(phl.tup, phl.tdn))
dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tdn)
if show_mtb
upphl (trend)
dnphl (trend)
hqlzone()
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Volumetric Order Block }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method eB(box b, bool ext, color css, bool swing) =>
b.unshift(
box.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, text_font_family = font.family_monospace
, extend = ext ? extend.right : extend.none
, border_color = swing ? color.new(css, 0) : color.new(color.white,100)
, bgcolor = css
, border_width = 1
)
)
method eL(line l, bool ext, bool solid, color css) =>
l.unshift(
line.new(
na
, na
, na
, na
, width = 1
, color = css
, xloc = xloc.bar_time
, extend = ext ? extend.right : extend.none
, style = solid ? line.style_solid : line.style_dashed
)
)
method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) =>
= request.security(
syminfo.tickerid
, ""
,
, lookahead = barmerge.lookahead_off
)
var obC obj = obC.new(
array.new()
, array.new()
, array.new< int >()
, array.new()
, array.new()
, array.new()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new()
, array.new()
, array.new< int >()
)
var obD draw = obD.new(
array.new()
, array.new()
, array.new()
, array.new()
, array.new()
)
if barstate.isfirst
for i = 0 to ob_num - 1
draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) : color.new(css,0))
draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css, swing)
draw.blB.eB(false, css_metric_up , swing)
draw.brB.eB(false, css_metric_dn , swing)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css, swing)
float pos = ob_pos == "Full"
? (bull ? high : low)
: ob_pos == "Middle"
? ohlc4
: ob_pos == "Accurate"
? hl2
: hl2
if cdn
obj.h.clear()
obj.l.clear()
obj.n.clear()
for i = 0 to math.abs((loc - b.n)) - 1
obj.h.push(hH )
obj.l.push(lL )
obj.n.push(b.t )
// obj.h.reverse()
// obj.l.reverse()
int iU = obj.l.indexof(obj.l.min()) + 1
int iD = obj.h.indexof(obj.h.max()) + 1
obj.dir.unshift(
bull
? (b.c > b.o ? 1 : -1)
: (b.c > b.o ? 1 : -1)
)
obj.top.unshift(
bull
? pos
: obj.h.max()
)
obj.btm.unshift(
bull
? obj.l.min()
: pos
)
obj.left.unshift(
bull
? obj.n.get(obj.l.indexof(obj.l.min()))
: obj.n.get(obj.h.indexof(obj.h.max()))
)
obj.avg.unshift(
math.avg(obj.top.first(), obj.btm.first())
)
obj.cV.unshift(
bull
? b.v
: b.v
)
if ob_pos == "Precise"
switch bull
true =>
if obj.avg.get(0) < (b.c < b.o ? b.c : b.o ) and obj.top.get(0) > hlcc4
obj.top.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
false =>
if obj.avg.get(0) > (b.c < b.o ? b.o : b.c ) and obj.btm.get(0) < hlcc4
obj.btm.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
obj.blVP.unshift ( 0 )
obj.brVP.unshift ( 0 )
obj.wM .unshift ( 1 )
if use_overlap
int rmP = use_overlap_method == "Recent" ? 1 : 0
if obj.avg.size() > 1
if bull
? obj.btm.first() < obj.top.get(1)
: obj.top.first() > obj.btm.get(1)
obj.wM .remove(rmP)
obj.cV .remove(rmP)
obj.dir .remove(rmP)
obj.top .remove(rmP)
obj.avg .remove(rmP)
obj.btm .remove(rmP)
obj.left .remove(rmP)
obj.blVP .remove(rmP)
obj.brVP .remove(rmP)
if barstate.isconfirmed
for x = 0 to ob_num - 1
tg = switch ob_mitigation
"Middle" => obj.avg
"Absolute" => bull ? obj.btm : obj.top
for in tg
if (bull ? cC < pt : cC > pt)
obj.wM .remove(idx)
obj.cV .remove(idx)
obj.dir .remove(idx)
obj.top .remove(idx)
obj.avg .remove(idx)
obj.btm .remove(idx)
obj.left .remove(idx)
obj.blVP .remove(idx)
obj.brVP .remove(idx)
if barstate.islast
if obj.avg.size() > 0
// Alert
if bull
? ta.crossunder(low , obj.top.get(0))
: ta.crossover (high, obj.btm.get(0))
switch bull
true => blalert.obtouch := true
false => bralert.obtouch := true
float tV = 0
obj.dV.clear()
seq = math.min(ob_num - 1, obj.avg.size() - 1)
for j = 0 to seq
tV += obj.cV.get(j)
if j == seq
for y = 0 to seq
obj.dV.unshift(
math.floor(
(obj.cV.get(y) / tV) * 100)
)
obj.dV.reverse()
for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1)
dmL = draw.mL .get(i)
dOB = draw.ob .get(i)
dblB = draw.blB.get(i)
dbrB = draw.brB.get(i)
deOB = draw.eOB.get(i)
dOB.set_lefttop (obj.left .get(i) , obj.top.get(i))
deOB.set_lefttop (b.t , obj.top.get(i))
dOB.set_rightbottom (b.t , obj.btm.get(i))
deOB.set_rightbottom(b.t + (b.t - b.t ) * 100 , obj.btm.get(i))
if use_middle_line
dmL.set_xy1(obj.left.get(i), obj.avg.get(i))
dmL.set_xy2(b.t , obj.avg.get(i))
if ob_metrics_show
dblB.set_lefttop (obj.left.get(i), obj.top.get(i))
dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i))
dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i))
dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i))
rpBL = dblB.get_right()
rpBR = dbrB.get_right()
dbrB.set_right(rpBR + (b.t - b.t ) * obj.brVP.get(i))
dblB.set_right(rpBL + (b.t - b.t ) * obj.blVP.get(i))
if use_show_metric
txt = switch
obj.cV.get(i) >= 1000000000 => str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B"
obj.cV.get(i) >= 1000000 => str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M"
obj.cV.get(i) >= 1000 => str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K"
obj.cV.get(i) < 1000 => str.tostring(math.round(obj.cV.get(i)))
deOB.set_text(
str.tostring(
txt + " (" + str.tostring(obj.dV.get(i)) + "%)")
)
deOB.set_text_size (size.auto)
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.silver : color.new(css, 0))
if ob_metrics_show and barstate.isconfirmed
if obj.wM.size() > 0
for i = 0 to obj.avg.size() - 1
switch obj.dir.get(i)
1 =>
switch obj.wM.get(i)
1 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 1)
-1 =>
switch obj.wM.get(i)
1 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 1)
var hN = array.new(1, b.n)
var lN = array.new(1, b.n)
var hS = array.new(1, b.n)
var lS = array.new(1, b.n)
if iH
hN.pop()
hN.unshift(int(b.n ))
if iL
lN.pop()
lN.unshift(int(b.n ))
if sH
hS.pop()
hS.unshift(int(b.n ))
if sL
lS.pop()
lS.unshift(int(b.n ))
if ob_show
bull_ob.drawVOB(true , ob_bull_css, hN.first(), false)
bear_ob.drawVOB(false, ob_bear_css, lN.first(), false)
if ob_swings
s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true)
s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true)
if bull_ob
blalert.ob := true
if bear_ob
bralert.ob := true
if s_bull_ob
blalert.swingob := true
if s_bear_ob
blalert.swingob := true
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - FVG | VI | OG }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
ghl() => request.security(syminfo.tickerid, fvg_tf, [high , low , close , open ])
tfG() => request.security(syminfo.tickerid, fvg_tf, )
cG(bool bull) =>
= ghl()
= tfG()
var FVG draw = FVG.new(
array.new()
, array.new()
)
var FVG cords = array.new()
float pup = na
float pdn = na
bool cdn = na
int pos = 2
cc = timeframe.change(fvg_tf)
if barstate.isfirst
for i = 0 to fvg_num - 1
draw.box.unshift(box.new (na, na, na, na, border_color = color.new(color.white, 100), xloc = xloc.bar_time))
draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width = 1, style = line.style_solid))
switch what_fvg
"FVG" =>
pup := bull ? gl : l
pdn := bull ? h : gh
cdn := bull ? gl > h and cc : gh < l and cc
pos := 2
"VI" =>
pup := bull
? (gc > go
? go
: gc)
: (gc > go
? go
: gc )
pdn := bull
? (gc > go
? gc
: go )
: (gc > go
? gc
: go)
cdn := bull
? go > gc and gh >
Thirdeyechart Global Gold PercentageThe global gold percentage – Percentage Change Indicator is a TradingView tool developed to help traders monitor multiple currency pairs and precious metals in one glance. This indicator was coded personally, using custom formulas to calculate the percentage change for each symbol over selected timeframes, making it unique and fully tailored to individual analysis needs.
Users can input any symbols they wish to track as a comma-separated list, making it highly flexible. The script automatically calculates percentage changes for Daily (D), 1-Hour (H1), and 4-Hour (H4) timeframes. Positive changes are highlighted in blue and negative changes in red, allowing for an instant visual representation of market movements. The table updates in real-time, giving traders immediate feedback without needing to switch between charts.
Designed with simplicity and functionality in mind, this indicator is ideal for intraday traders, swing traders, or anyone who wants to keep an eye on multiple markets efficiently. It works for currency pairs, metals like gold (XAUUSD, XAUJPY), or any TradingView-available symbol. The table is positioned at the top-right corner of the chart and automatically adapts to the number of symbols entered.
This script is purely informational and educational, providing a clear view of price movements but not offering buy or sell signals. Traders should perform their own analysis and risk management before making any trading decisions.
Disclaimer / Copyright:
© 2025 Thirdeyechart. All rights reserved. This indicator is for educational and informational purposes only. The author is not responsible for any trading losses or financial decisions made based on this script. Redistribution, copying, or commercial use of this code without permission is strictly prohibited.
Fast RSI with Divergence, Signal and Volume Spike1. This is fast RSI, with configurable left and right lookback bars
2. Signal on lower band crossover and upper band crossunder
3. Volume Spike indication with configurable average volume multiplier.
Hold targets when you see higher than average volume spike.
EMA 50/200 Signals with Price-Arrows✔ Plots EMA 50 and EMA 200
✔ Displays arrows when a crossover occurs (signals)
✔ Creates alerts for TradingView
✔ Works for crypto, forex, and stocks
Thirdeyechart Volume Gold//@version=6
indicator("MT5 Style Quotes – Custom Pair Table", overlay=true, max_labels_count=500)
// ==== USER INPUTS ====
// Masukkan pair tambahan kat sini (pisahkan dengan koma)
extraPairsInput = input.string("XAUUSD,XAUJPY,USDJPY,EURJPY", "Custom Pairs (comma separated)")
// Convert input → array
string extraPairs = str.split(extraPairsInput, ",")
// Function kira % change
f_change(sym, tf) =>
o = request.security(sym, tf, open)
c = request.security(sym, tf, close)
pct = ((c - o) / o) * 100
pct
// Table setup
rowCount = array.size(extraPairs) + 1
var tbl = table.new(position.top_right, 4, rowCount, border_width=1)
// Header row
table.cell(tbl, 0, 0, "Symbol", bgcolor=color.new(color.white, 90))
table.cell(tbl, 1, 0, "Day %", bgcolor=color.new(color.white, 90))
table.cell(tbl, 2, 0, "H1 %", bgcolor=color.new(color.white, 90))
table.cell(tbl, 3, 0, "H4 %", bgcolor=color.new(color.white, 90))
// Loop setiap pair
for i = 0 to array.size(extraPairs)-1
sym = str.trim(array.get(extraPairs, i))
day = f_change(sym, "D")
h1 = f_change(sym, "60")
h4 = f_change(sym, "240")
col_day = day >= 0 ? color.blue : color.red
col_h1 = h1 >= 0 ? color.blue : color.red
col_h4 = h4 >= 0 ? color.blue : color.red
table.cell(tbl, 0, i+1, sym)
table.cell(tbl, 1, i+1, str.tostring(day, format.percent), text_color=col_day)
table.cell(tbl, 2, i+1, str.tostring(h1, format.percent), text_color=col_h1)
table.cell(tbl, 3, i+1, str.tostring(h4, format.percent), text_color=col_h4)
EMA 50/200 Strategy Signals - Axis.BhpEMA 50/200 Strategy
Plots EMA 50 and EMA 200
Displays arrows when a crossover occurs (signals)
Creates alerts for TradingView
Works for crypto, forex, and stocks
Fractals Trend [BigBeluga]🔵 OVERVIEW
Fractals Trend is a trend-following overlay that leverages fractal swing points to define dynamic support and resistance zones. By storing and averaging recent high and low fractals, it determines trend direction and plots a smooth band that flips depending on market bias—displaying support during uptrends and resistance during downtrends .
🔵 CONCEPTS
Fractal Swings: Fractals are identified using a customizable length. A high fractal forms when the current high is the highest in a range; a low fractal when the current low is the lowest.
Fractal Memory: The indicator keeps a rolling window of recent high and low fractals inside arrays, limited by the user-defined storage quantity.
switch
upperF => FracrtalsUpper.push(high )
lowerF => FracrtalsLower.push(low )
FracrtalsUpper.size() > fCount => FracrtalsUpper.shift()
FracrtalsLower.size() > fCount => FracrtalsLower.shift()
Trend Detection: Price crossing above the average, min/max or median high fractals signals an uptrend; crossing below average, min/max or median low fractals signals a downtrend.
Dynamic Band Plotting: Depending on the trend, the script plots the average of either the upper or lower fractals as a trailing support or resistance line.
Visual Confirmation: Fractal labels appear as triangle markers at highs and lows, providing additional structural context.
🔵 FEATURES
Automatically detects high and low fractals using customizable length.
Stores a defined number of fractals to smooth out noise and reduce false signals.
Flips trend bias dynamically with colored band and smooth transitions.
Plots fractal-based support in bullish trends, resistance in bearish trends.
Triangle markers show real-time fractal highs and lows.
Fully configurable visuals, color themes, and fractal detection logic.
Clean, non-intrusive overlay that works on any market or timeframe.
🔵 HOW TO USE
Use the colored band as a directional filter: green = uptrend (support), orange = downtrend (resistance).
Combine with entry signals or break/retest strategies when price approaches the band.
Use triangle markers to confirm structural swing points.
Adjust Fractals Length to tune sensitivity—shorter values detect quicker shifts, longer values reduce noise.
Change the fractal bands type to adapt trend detection to different market conditions.
Use in conjunction with momentum or volume tools for confluence.
🔵 CONCLUSION
Fractals Trend offers a lightweight, intuitive way to track market bias using price structure alone. Its smart switching logic and clean visuals make it a powerful tool for trend traders seeking structure-based dynamic S/R—without laggy moving averages or overcomplicated signals.
jhehli LiquidityWhat are BSL and SSL?
In the context of Smart Money Concepts, liquidity simply refers to pending orders—specifically Stop Losses and Buy/Sell Stop orders—resting above old highs and below old lows.
BSL (Buy-Side Liquidity): This is found above Swing Highs. Retail traders who are short the market will place their "Buy Stop" protective orders here. Additionally, breakout traders place "Buy Limit" orders here. Smart Money views this area as a pool of willing buyers. To fill large sell orders, institutions must drive price up into this liquidity to pair their massive sell interest with these buy stops.
SSL (Sell-Side Liquidity): This is found below Swing Lows. Retail traders who are long the market place their "Sell Stop" protective orders here. Smart Money targets these levels to accumulate long positions. They need the market to sell off into these levels so they can buy from the willing sellers at a discount.
How this Indicator Works
This tool automates the process of market structure analysis by identifying key Swing Highs and Swing Lows.
Detection: It scans price action to find fractal highs and lows (classic swing points) where price has rejected a level.
Visualization: It projects a line from these points, clearly marking where the "stops" are likely residing.
Liquidity Raids: When price pierces these levels, it is considered a "Liquidity Raid" or "Stop Hunt."
How to Use This in Your Trading
Do not treat these lines simply as Support and Resistance. In the ICT methodology, old highs and lows are targets, not barriers.
For Reversals: Wait for a "Turtle Soup" or "Judas Swing." This occurs when price aggressively expands into a BSL or SSL level to trigger stops, only to quickly reverse back into the trading range. This indicates that Smart Money has finished their accumulation or distribution.
For Bias: If the higher timeframe trend is Bullish, expect SSL to be raided to fuel the move, while BSL becomes the target (Draw on Liquidity).
By using this indicator, you remove the guesswork of manually marking every swing point, allowing you to focus on price action and the reaction at these critical liquidity pools.
EP CPR Future CPR + 4 MA
1. CPR Trend Direction(Bias):
Bullish: If the current day's price is trading above the TC, it suggests a strong bullish trend where the CPR acts as a support zone.
Bearish: If the current day's price is trading below the BC, it suggests a strong bearish trend where the CPR acts as a resistance zone.
Range-Bound/Consolidation: If the price is trading within the CPR lines, it indicates a lack of clear directional bias and suggests a likely sideways or accumulation phase.
2. Moving average Trend Identification
Uptrend: If the price is above a moving average (and the MA line is sloping up), it confirms a bullish trend.
Downtrend: If the price is below a moving average (and the MA line is sloping down), it confirms a bearish trend.
Crossovers (Trading Signals)
A popular strategy involves using two moving averages—a short-term MA (e.g., 50-period) and a long-term MA (e.g., 200-period).
Golden Cross (Bullish Signal): Occurs when the shorter-term MA crosses above the longer-term MA.
Death Cross (Bearish Signal): Occurs when the shorter-term MA crosses below the longer-term MA.
BTC Dual Cycle: Stats DashboardOverview
"Price takes the elevator down, but takes the stairs up."
This indicator is a macro-analysis tool designed to visualize the true duration of Bitcoin’s market cycles. Unlike standard oscillators that focus on short-term price action, the Macro Cycle Tracker filters out the noise to answer two fundamental questions:
Are we in a phase of Expansion (Price Discovery)?
Are we in a phase of Recovery (Repairing the damage of a crash)?
It visually separates the market into two distinct regimes based on a configurable drawdown threshold (default: -50%) and provides real-time statistics on how long these phases historically last.
How It Works
The script tracks the All-Time High (ATH) and divides market history into two colored zones:
🟢 The Green Zone (Expansion / Price Discovery)
Trigger: Starts immediately when Bitcoin breaks the previous ATH.
Meaning: The market is healthy, profitable, and exploring new valuation levels.
End: The zone ends when price drops by 50% (configurable) from the cycle top.
🔴 The Red Zone (Recovery / Capitulation)
Trigger: Starts when price drops below the 50% threshold from the peak.
Meaning: The asset is "underwater." This zone remains active persistently—even during relief rallies—until the previous ATH is fully reclaimed.
Philosophy: A cycle is not over until the damage is repaired.
Key Features
Cycle Timer: Displays the exact number of days passed for every historical cycle directly on the chart.
Live Counter: Shows the current duration of the active phase (e.g., "ZONE GREEN: 450 Days...").
Statistical Dashboard: A table in the bottom-right corner automatically calculates the Mean and Median duration (in days) for both Green and Red phases. This allows you to compare the current cycle against historical averages.
How to Use
For Investors (HODLers): Use the Red Zone to understand the "Time Cost" of a bear market. It helps visualize that recovery takes patience and that price action below the old ATH is merely accumulation.
For Analysts: Use the Dashboard statistics to project potential cycle turning points based on historical median durations.
Settings
Drop Percent (%): Default is 50%. This defines the "Crash" threshold. You can adjust this to 20% or 30% for more sensitive cycle detection.
Text Size: Adjust the size of the dashboard text to fit your screen resolution.
Disclaimer: This tool is for educational purposes only and does not constitute financial advice. Past performance is not indicative of future results.
Strict Weekly 50/200 WMA Signals True Weekly Only-Strict Weekly 50/200 WMA Signals True Weekly Only => also on other time frames than weekly (like daily, etc.) always indicates the indicators based on the weekly chart
-especially useful for Crypto
-gives buy and sell signals when the 200 WMA or the 50 WMA are crossed
-typically above the 50 WMA indicates a bull market
-reaching below the 200 WMA indicates a bear market and typically for investors with a longer time frame (>2-4 years) a good entry point
BTC -50% Crash to Recovery ZoneGeneral Overview This is a macro-analysis tool designed to visualize the true duration of Bitcoin’s "Suffering & Recovery Cycles." Unlike standard oscillators that only signal oversold conditions, this script highlights the entire timeline required for the market to flush out leverage and return to All-Time Highs (ATH).
Operational Logic The algorithm tracks Bitcoin’s historical All-Time High (ATH).
The Trigger: It activates automatically when the price drops 50% below the last recorded ATH.
The "Recovery Zone": Once triggered, the chart background turns red (indicating a "Drawdown" state). This zone remains active persistently, even during intermediate relief rallies.
The Reset: The zone deactivates only when the price breaks above the previous ATH, marking the official start of a new Price Discovery phase.
How to Read It
Red Background: We are officially in a Bear Market or Recovery Phase. The asset is technically "underwater." For the long-term investor with a low time preference, this visually defines the accumulation window.
Red Horizontal Line: Indicates the "Target." This is the exact price level of the old ATH that Bitcoin must reclaim to close the bearish cycle.
No Background Color: We are in Price Discovery. The market is healthy and pushing for new highs.
The Financial Lesson This indicator visually demonstrates a fundamental market truth: "Price takes the elevator down, but takes the stairs up." It shows that after a halving of value (-50%), Bitcoin may take months or years to recover previous levels, helping investors filter out the noise of short-term pumps that fail to break the macro-bearish structure.
EMA Trend Pro v1Here is a clear, professional English description you can copy-paste directly (suitable for sharing with friends, investors, brokers, or posting on TradingView):
EMA Trend Pro v5.0 – Strategy Overview
This is a trend-following strategy designed for 15-minute charts on assets like XAUUSD, NASDAQ, BTC, and ETH.
Entry Rules
Buy when the 7, 14, and 21-period EMAs are aligned upward and the 14-period EMA crosses above the 144-period EMA (with ADX > 20 and volume confirmation).
Sell short when the EMAs are aligned downward and the 14-period EMA crosses below the 144-period EMA.
Risk Management
Initial stop-loss is placed at 1.8 × ATR below (long) or above (short) the entry price.
Position size is calculated to risk a fixed percentage of equity per trade.
Profit-Taking & Trade Management
When price reaches 1:1 reward-to-risk, 30% of the position is closed.
At the same moment, the stop-loss for the remaining 70% is moved to the entry price (breakeven).
The remaining position is split:
50% targets 1:2 reward-to-risk
50% targets 1:3 reward-to-risk (allowing big wins during strong trends)
Visualization
Clean colored bars extend to the right showing entry, stop-loss, and three take-profit levels.
Price labels clearly display "Entry", "SL", "TP1 1:1", "TP2 1:2", and "TP3 1:3".
Only the current trade is displayed for a clean chart.
Key Advantages
High win rate due to breakeven protection after 1R
Excellent reward-to-risk ratio that lets winners run
Fully automated, works on any market with clear trends
Professional look, easy to understand and explain
Perfect for swing traders who want consistent profits with limited downside risk.
Feel free to use this description on TradingView, in your trading journal, or when explaining the strategy to others!
If you want a shorter version (e.g., for TradingView description box) or a Chinese version, just let me know — I’ll give it to you right away! 😊
EMA Trend Pro v5.0 5M ONLY — 策略版（1:1出30%+保本）Here is a clear, professional English description you can copy-paste directly (suitable for sharing with friends, investors, brokers, or posting on TradingView):
EMA Trend Pro v5.0 – Strategy Overview
This is a trend-following strategy designed for 15-minute charts on assets like XAUUSD, NASDAQ, BTC, and ETH.
Entry Rules
Buy when the 7, 14, and 21-period EMAs are aligned upward and the 14-period EMA crosses above the 144-period EMA (with ADX > 20 and volume confirmation).
Sell short when the EMAs are aligned downward and the 14-period EMA crosses below the 144-period EMA.
Risk Management
Initial stop-loss is placed at 1.8 × ATR below (long) or above (short) the entry price.
Position size is calculated to risk a fixed percentage of equity per trade.
Profit-Taking & Trade Management
When price reaches 1:1 reward-to-risk, 30% of the position is closed.
At the same moment, the stop-loss for the remaining 70% is moved to the entry price (breakeven).
The remaining position is split:
50% targets 1:2 reward-to-risk
50% targets 1:3 reward-to-risk (allowing big wins during strong trends)
Visualization
Clean colored bars extend to the right showing entry, stop-loss, and three take-profit levels.
Price labels clearly display "Entry", "SL", "TP1 1:1", "TP2 1:2", and "TP3 1:3".
Only the current trade is displayed for a clean chart.
Key Advantages
High win rate due to breakeven protection after 1R
Excellent reward-to-risk ratio that lets winners run
Fully automated, works on any market with clear trends
Professional look, easy to understand and explain
Perfect for swing traders who want consistent profits with limited downside risk.
Feel free to use this description on TradingView, in your trading journal, or when explaining the strategy to others!
If you want a shorter version (e.g., for TradingView description box) or a Chinese version, just let me know — I’ll give it to you right away! 😊
Recursive WMA Angle StrategyDescription: This strategy utilizes a recursive Weighted Moving Average (WMA) calculation to determine the trend direction and strength based on the slope (angle) of the curve. By calculating the angle of the smoothed moving average in degrees, the script filters out noise and aims to enter trades only during strong momentum phases.
How it Works:
Recursive WMA: The script calculates a series of nested WMAs (M1 to M5), creating a very smooth yet responsive curve.
Angle Calculation: It measures the rate of change of this curve over a user-defined lookback period and converts it into an angle (in degrees).
Entry Condition (Long): A long position is opened when the calculated angle exceeds the Min Angle for BUY threshold (default: 0.2), indicating a strong upward trend.
Exit Condition: The position is closed when the angle drops below the Min Angle for SELL threshold (default: -0.2), indicating a sharp trend reversal.
Settings:
MA Settings: Adjust the base lengths for the recursive calculation.
Angle Settings: Fine-tune the sensitivity by changing the Buy/Sell angle thresholds.
Date Filter: Restrict the backtest to a specific date range.
Note: This strategy is designed for Long-Only setups.
Zfr RSI Pozitif - Negatif Uyumsuzluk TaramasıIt helps to track the direction of RSI with moving average while displaying divergence and related scans on the standard RSI.
Dynamic Fair-Value Ribbon Pro @darshakssc1. What This Indicator Is (In Simple Terms)
The Dynamic Fair-Value Ribbon Pro is a visual tool that helps you see how price behaves around a statistically derived “fair-value zone”:
A colored ribbon/cloud marks a central “fair” area.
Areas above the ribbon are labeled as “Unfair High Zone”.
Areas below the ribbon are labeled as “Unfair Low Zone”.
A small state panel tells you where price currently sits relative to this ribbon.
All calculations are based only on historical price, volume, and volatility.
It does not predict future price, does not give buy/sell signals, and is not financial advice.
2. Adding the Indicator
Open a chart on TradingView.
Click on Indicators .
Search for “Dynamic Fair-Value Ribbon Pro” .
Click to add it to your chart.
You will see:
A cloud/ribbon around price.
Colored bars when price is outside the ribbon.
A panel in the top right describing the current state.
3. Core Concept: Fair vs Unfair Zones (Analytical Only)
The indicator tries to answer a descriptive question:
“Where is price trading relative to a historically derived central area?”
It does this by:
Calculating a central value (“fair mid”).
Building a band around that mid.
Coloring the chart depending on whether price is inside or outside that band.
It is not claiming that:
Price “must” return to the band.
Price is “overvalued” or “undervalued”.
Any state is good or bad.
It is simply a visual classification tool .
4. Engine Modes — How the Ribbon Is Calculated
Under “Fair-Value Engine” you can choose:
4.1 Mode 1: Range
Looks back over a chosen number of bars (default: 100).
Finds the highest high and lowest low in that window.
Defines a central “slice” of that range as the fair-value ribbon :
Range Mode: Lower Percent → bottom boundary of the slice (e.g., 30%).
Range Mode: Upper Percent → top boundary of the slice (e.g., 70%).
Effect:
The ribbon represents a middle portion of the historical range .
Above the ribbon = “Unfair High Zone” (analytical label only).
Below the ribbon = “Unfair Low Zone”.
This is purely statistical — it does not mean price is wrong or will revert.
4.2 Mode 2: VWAP + Stdev
In this mode, the central value is based on VWAP :
VWAP (Volume-Weighted Average Price) is used as the midline.
A standard deviation envelope is built around VWAP:
VWAP Mode: Stdev Multiplier controls how wide that envelope is.
Effect:
The ribbon shows where price is trading relative to a volume-weighted average .
Again, areas above and below are just described as “unfair” zones in a visual, analytical sense , not a predictive one.
5. ATR Adaptive Width — Making the Ribbon React to Volatility
Under “ATR Adaptive Width” :
Use ATR Adaptive Width:
On: the band width scales with volatility.
Off: band width stays fixed based on Range or VWAP settings.
ATR Length: how many bars to use for ATR.
Reference ATR (% of price): a reference level for normal volatility.
Min Width Scale / Max Width Scale: clamps the scaling so that the band doesn’t get too narrow or too wide.
What this does (analytically):
When volatility (ATR) is higher than the reference, the band can become wider .
When volatility is lower , the band can become narrower .
This is a mathematical rescaling only and does not imply any optimal levels or performance.
6. Visual Elements — What You See on the Chart
6.1 Fair-Value Ribbon (Cloud)
The cloud between Fair Ribbon Low and Fair Ribbon High is the fair zone .
Color can be changed via “Fair Ribbon Color” .
6.2 Midline
If “Show Center Line” is enabled:
A line runs through the middle of the ribbon.
In Range mode, this is the average of the upper and lower band.
In VWAP mode, it’s essentially the VWAP-based mid.
This line is for visual reference only and makes no claims about support, resistance, or reversion.
6.3 Bar Colors
Unfair High Zone: bars are colored with Unfair High Bar Color.
Unfair Low Zone: bars are colored with Unfair Low Bar Color.
Inside the ribbon:
If “Fade Bars Inside Fair Zone” is ON, bars may be more faded/neutral.
These colors are simply classification highlights ; they do not tell you what to do.
6.4 State Panel (Top Right)
If “Show State Panel” is enabled, you’ll see a small box that displays:
Current engine:
Range or VWAP+Stdev.
Current price state:
Inside Ribbon (Fair Zone)
Above Ribbon (Unfair High Zone)
Below Ribbon (Unfair Low Zone)
This is a quick summary of where price sits relative to the computed ribbon.
7. Typical Ways to Use It (Informational Only)
The indicator can help you visually:
See when price is spending time inside a historically defined central zone.
Notice when price is frequently trading outside that zone.
Compare different timeframes (e.g., 5m vs 1h vs 4h) to see how the fair zone shifts.
Experiment with:
Range length (shorter vs longer lookback).
VWAP vs Range mode.
ATR adaptation on/off.
Important:
Any interpretation of these visuals is entirely up to the user.
The script does not tell you to buy, sell, hold, or do anything specific.
8. Limitations and Important Notes
All calculations use past data only (price, volume, volatility).
The ribbon does not guarantee:
that price will revert,
that zones will hold,
or that any outcome will occur.
There are no built-in signals such as “long/short” or automatic entries/exits.
The script is best used as a supporting, visual layer alongside other tools or methods you choose.
9. Disclaimer
This indicator is:
Strictly informational and educational.
Not a trading system or strategy.
Not financial advice or a recommendation.
Not guaranteed to be accurate, complete, or suitable for any specific purpose.
Users should always perform their own research and due diligence.
Past behavior of any visual pattern or zone does not guarantee future behavior.
Universal Scalper Indicator [Crypto/Forex/Gold]Universal Scalper Pro is an all-in-one scalping system designed for the 15-Minute Timeframe. It automates the analysis of trend, volatility, and risk management into a single, high-contrast dashboard.
Unlike standard crossover indicators, this system filters out low-volatility "noise" using a built-in ADX engine and automatically calculates dynamic Stop Loss and Take Profit levels based on market volatility (ATR).
It is engineered to work universally on:
Crypto (BTC, ETH, SOL, Altcoins)
Commodities (Gold, Silver, Oil)
Forex (Major & Minor Pairs)
Stocks (High volume tech stocks like NVDA, TSLA)
📈 How It Works (The Strategy)
1. The Trend Engine (9/21 EMA) The core logic utilizes a Fast (9) and Slow (21) Exponential Moving Average crossover.
Bullish Signal: The 9 EMA crosses above the 21 EMA.
Bearish Signal: The 9 EMA crosses below the 21 EMA. This specific combination is chosen for its responsiveness to 15-minute intraday trends.
2. The Noise Filter (ADX > 15) To prevent "whipsaws" (fake signals during sideways markets), the script includes a Volatility Filter based on the Average Directional Index (ADX).
Signals are rejected if the ADX is below 15.
This ensures you only receive alerts when there is sufficient momentum to sustain a move.
3. Dynamic Risk Management (ATR) The script uses the Average True Range (ATR) to calculate Stop Loss and Take Profit levels that adapt to the specific asset's volatility.
Stop Loss: Placed at 1.5x ATR from the entry. (Tight enough to preserve capital, wide enough to survive standard market noise).
Take Profit: Placed at 2.0x ATR from the entry. (Provides a healthy 1:1.3 Risk/Reward ratio).
🚀 Key Features
Universal Dashboard: A bottom-right panel displays the live Trend Status, Entry Price, Stop Loss, and Take Profit. It automatically formats decimals for any asset (e.g., 2 decimals for Gold, 5 for Forex, 8 for Crypto).
"Sticky" Memory: The dashboard retains the prices of the last valid signal, allowing you to manage your trade even after the signal candle closes.
Trend Cloud: A visual Green/Red zone between the EMAs helps you instantly identify the market bias.
Unified Alerts: A single alert setup ("Any alert() function call") sends the Asset Name, Entry, SL, and TP directly to your phone.
🛠️ How to Use
Timeframe: Set your chart to 15 Minutes (15m).
Wait for the Signal: Look for the "BUY" (Green) or "SELL" (Red) label on the chart.
Check the Dashboard: Ensure the "STATUS" is BULLISH (for buys) or BEARISH (for sells). If the status says "WAIT", do not trade.
Execute: Enter the trade using the exact Stop Loss and Take Profit levels shown on the dashboard.
⚠️ Risk Disclaimer
Trading financial markets involves high risk and may not be suitable for all investors. This indicator is a technical analysis tool and does not constitute financial advice. Past performance is not indicative of future results. Always practice with a demo account before trading real capital.
RRE HARSI4951✅ Buy Signal
RSI crosses above 49
Heikin Ashi green (ha_close > ha_open)
✅ Sell Signal
RSI crosses below 51
Heikin Ashi red (ha_close < ha_open)
Everything else in your code remains unchanged.
RSI Driven ATR Trend [NeuraAlgo]
RSI Driven ATR Trend
Dynamic Trend Detection and Strength Analysis
Unlock the market’s hidden rhythm with the RSI Driven ATR Trend , a sophisticated tool designed to measure trend direction and strength using a combination of RSI momentum and ATR-based volatility . This indicator provides real-time insights into bullish and bearish phases, helping traders identify potential turning points and optimize entry and exit decisions.
1.Core In Logic:
Dynamically calculates trend levels based on RSI and ATR interactions.
Highlights trend direction with intuitive color coding: green for bullish, red for bearish.
Displays trend strength as a percentage to quantify momentum intensity.
Automatic visual cues for potential trend reversals with “Turn Up” and “Turn Down” labels.
Advanced smoothing and dynamic gating ensure responsive yet stable trend detection.
Compatible with all timeframes and instruments.
2.Inputs Explained:
Rsi Factor: Adjusts the sensitivity of the RSI in trend calculation. Higher values make the trend detection more responsive to momentum changes.
Multiplier: Multiplies the effect of Rsi Factor to fine-tune trend responsiveness.
Bar Back: Number of bars used for peak and dip calculations, determining how far back the indicator looks for trend changes.
Period: Lookback period used in trend gating and ATR calculations.
Source: Price source for calculations (default is close).
Main Colors: Customize bullish and bearish trend colors.
3.How it Works:
The indicator calculates RSI values and ATR-based dynamic ranges to determine upper and lower trend levels.
Trend direction is determined by price crossing above (bullish) or below (bearish) the dynamic trend line.
Trend strength is expressed as a percentage relative to the trend line, helping you assess momentum intensity.
Visual cues like "Turn Up" and "Turn Down" labels indicate potential trend reversals.
Bars are colored dynamically based on trend direction for quick interpretation.
Ideal for traders seeking a clear, actionable view of market trends without the clutter of multiple indicators. RSI Driven ATR Trend translates complex price behavior into an easy-to-read visual guide, helping you make smarter trading decisions.
Happy Trading!
Bitcoin Macro Fair Value [Structural]//@version=6
indicator("Bitcoin Macro Fair Value ", overlay=true)
// --- Model Coefficients (Derived from Python Analysis 2019-2025) ---
intercept = input.float(3.156434, "Intercept")
c_m2 = input.float(0.132827, "Real M2 Coef")
c_corp = input.float(0.742593, "Corp Spread Coef")
c_hy = input.float(-0.617968, "HY Spread Coef")
c_dxy = input.float(0.009772, "DXY Coef")
c_real30 = input.float(0.713311, "Real 30Y Coef")
c_be30 = input.float(-1.059273, "Breakeven 30Y Coef")
c_slope = input.float(0.402220, "Slope 10Y-2Y Coef")
// --- Data Fetching ---
m2 = request.security("FRED:M2SL", "M", close)
cpi = request.security("FRED:CPIAUCSL", "M", close)
real_m2 = m2 / cpi
corp = request.security("FRED:BAMLC0A0CM", "D", close)
hy = request.security("FRED:BAMLH0A0HYM2", "D", close)
dxy = request.security("TVC:DXY", "D", close)
real30 = request.security("FRED:DFII30", "D", close)
nom30 = request.security("FRED:DGS30", "D", close)
be30 = nom30 - real30
nom10 = request.security("FRED:DGS10", "D", close)
nom2 = request.security("FRED:DGS2", "D", close)
slope = nom10 - nom2
// --- Calculation ---
log_fv = intercept + (c_m2 * real_m2) + (c_corp * corp) + (c_hy * hy) + (c_dxy * dxy) + (c_real30 * real30) + (c_be30 * be30) + (c_slope * slope)
fair_value = math.exp(log_fv)
plot(fair_value, "Macro Fair Value", color=color.new(color.blue, 0), linewidth=2)
