Custom Indicator - No Trade Zone Warning Back Ground Highlights!Years ago I did an analysis of my trades. Every period of the day was profitable except for two. From 10:00-1030, and 1:00 to 1:30. (I was actively Day Trading Futures) Imagine a vertical graph broken down in to 30 minute time segments. I had nice Green bars in every time slot (Showing Net Profits), and HUGE Red Bars from 10 to 10:30 and 1 to 1:30. After analysis I found I made consistent profits at session open, but then I would enter in to bad setups around 10 to make more money. I also found after I took lunch when I came back at 1:00 I would force trades instead of patiently waiting for a great trade setup. I created an indicator that plotted a red background around those times telling me I was not allowed to enter a trade. Profits went up!!! Details on How to adjust times are in 1st Post. You can adjust times and colors to meet your own trading needs.
Tìm kiếm tập lệnh với "A股+股票筛选器+10元以下"
Yelober - Market Internal direction+ Key levelsYelober – Market Internals + Key Levels is a focused intraday trading tool that helps you spot high-probability price direction by anchoring decisions to structure that matters: yesterday’s RTH High/Low, today’s pre-market High/Low, and a fast Value Area/POC from the prior session. Paired with a compact market internals dashboard (NYSE/NASDAQ UVOL vs. DVOL ratios, VOLD slopes, TICK/TICKQ momentum, and optional VIX trend), it gives you a real-time read on breadth so you can choose which direction to trade, when to enter (breaks, retests, or fades at PMH/PML/VAH/VAL/POC), and how to plan exits as internals confirm or deteriorate. On top of these intraday decision benefits, it also allows traders—in a very subtle but powerful way—to keep an eye on the VIX and immediately recognize significant spikes or sharp decreases that should be factored in before entering a trade, or used as a quick signal to modify an existing position. In short: clear levels for the chart, live internals for the context, and a smarter, rules-based path to execution.
# Yelober – Market Internals + Key Levels
*A TradingView indicator for session key levels + real‑time market internals (NYSE/NASDAQ TICK, UVOL/DVOL/VOLD, and VIX).*
**Script name in Pine:** `Yelober - Market Internal direction+ Key levels` (Pine v6)
---
## 1) What this indicator does
**Purpose:** Help intraday traders quickly find high‑probability reaction zones and read market internals momentum without switching charts. It overlays yesterday/today’s **automatic price levels** on your active chart and shows a **market breadth table** that summarizes NYSE/NASDAQ buying pressure and TICK direction, with an optional VIX trend read.
### Key features at a glance
* **Automatic Price Levels (overlay on chart)**
* Yesterday’s High/Low of Day (**yHoD**, **yLoD**)
* Extended Hours High/Low (**yEHH**, **yEHL**) across yesterday AH + today pre‑market
* Today’s Pre‑Market High/Low (**PMH**, **PML**)
* Yesterday’s **Value Area High/Low** (**VAH/VAL**) and **Point of Control (POC)** computed from a volume profile of yesterday’s **regular session**
* Smart de‑duplication:
* Shows **only the higher** of (yEHH vs PMH) and **only the lower** of (yEHL vs PML) to avoid redundant bands
* **Market Breadth Table (on‑chart table)**
* **NYSE ratio** = UVOL/DVOL (signed) with **VOLD slope** from session open
* **NASDAQ ratio** = UVOLQ/DVOLQ (signed) with **VOLDQ slope** from session open
* **TICK** and **TICKQ**: live cumulative ratio and short‑term slope
* **VIX** (optional): current value + slope over a configurable lookback/timeframe
* Color‑coded trends with sensible thresholds and optional normalization
---
## 2) How to use it (trader workflow)
1. **Mark your reaction zones**
* Watch **yHoD/yLoD**, **PMH/PML**, and **VAH/VAL/POC** for first touches, break/retest, and failure tests.
* Expect increased responsiveness when multiple levels cluster (e.g., PMH ≈ VAH ≈ daily pivot).
2. **Read the breadth panel for context**
* **NYSE/NASDAQ ratio** (>1 = more up‑volume than down‑volume; <−1 = down‑dominant). Strong green across both favors long setups; red favors short setups.
* **VOLD slopes** (NYSE & NASDAQ): positive and accelerating → broadening participation; negative → persistent pressure.
* **TICK/TICKQ**: cumulative ratio and **slope arrows** (↗ / ↘ / →). Use the slope to gauge **near‑term thrust or fade**.
* **VIX slope**: rising VIX (red) often coincides with risk‑off; falling VIX (green) with risk‑on.
3. **Confluence = higher confidence**
* Example: Price reclaims **PMH** while **NYSE/NASDAQ ratios** print green and **TICK slopes** point ↗ — consider break‑and‑go; if VIX slope is ↘, that adds risk‑on confidence.
* Example: Price rejects **VAH** while **VOLD slopes** roll negative and VIX ↗ — consider fade/reversal.
4. **Risk management**
* Place stops just beyond key levels tested; if breadth flips, tighten or exit.
> **Timeframes:** Works best on 1–15m charts for intraday. Value Area is computed from **yesterday’s RTH**; choose a smaller calculation timeframe (e.g., 5–15m) for stable profiles.
---
## 3) Inputs & settings (what each option controls)
### Global Style
* **Enable all automatic price levels**: master toggle for yHoD/yLoD, yEHH/yEHL, PMH/PML, VAH/VAL/POC.
* **Line style/width**: applies to all drawn levels.
* **Label size/style** and **label color linking**: use the same color as the line or override with a global label color.
* **Maximum bars lookback**: how far the script scans to build yesterday metrics (performance‑sensitive).
### Value Area / Volume Profile
* **Enable Value Area calculations** *(on by default)*: computes yesterday’s **POC**, **VAH**, **VAL** from a simplified intraday volume profile built from yesterday’s **regular session bars**.
* **Max Volume Profile Points** *(default 50)*: lower values = faster; higher = more precise.
* **Value Area Calculation Timeframe** *(default 15)*: the security timeframe used when collecting yesterday’s highs/lows/volumes.
### Individual Level Toggles & Colors
* **yHoD / yLoD** (yesterday high/low)
* **yEHH / yEHL** (yesterday AH + today pre‑market extremes)
* **PMH / PML** (today pre‑market extremes)
* **VAH / VAL / POC** (yesterday RTH value area + point of control)
### Market Breadth Panel
* **Show NYSE / NASDAQ / VIX**: choose which series to display in the table.
* **Table Position / Size / Background Color**: UI placement and legibility.
* **Slope Averaging Periods** *(default 5)*: number of recent TICK/TICKQ ratio points used in slope calculation.
* **Candles for Rate** *(default 10)* & **Normalize Rate**: VIX slope calculation as % change between `now` and `n` candles ago; normalize divides by `n`.
* **VIX Timeframe**: optionally compute VIX on a higher TF (e.g., 15, 30, 60) for a smoother regime read.
* **Volume Normalization** (NYSE & NASDAQ): display VOLD slopes scaled to `tens/thousands/millions/10th millions` for readable magnitudes; color thresholds adapt to your choice.
---
## 4) Data sources & definitions
* **UVOL/VOLD (NYSE)** and **UVOLQ/DVOLQ/VOLDQ (NASDAQ)** via `request.security()`
* **Ratio** = `UVOL/DVOL` (signed; negative when down‑volume dominates)
* **VOLD slope** ≈ `(VOLD_now − VOLD_open) / bars_since_open`, then normalized per your setting
* **TICK/TICKQ**: cumulative sum of prints this session with **positives vs negatives ratio**, plus a simple linear regression **slope** of the last `N` ratio values
* **VIX**: value and slope across a user‑selected timeframe and lookback
* **Sessions (EST/EDT)**
* **Regular:** 09:30–16:00
* **Pre‑Market:** 04:00–09:30
* **After Hours:** 16:00–20:00
* **Extended‑hours extremes** combine **yesterday AH** + **today PM**
> **Note:** All session checks are done with TradingView’s `time(…,"America/New_York")` context. If your broker’s RTH differs (e.g., futures), adjust expectations accordingly.
---
## 5) How the algorithms work (plain English)
### A) Key Levels
* **Yesterday’s RTH High/Low**: scans yesterday’s bars within 09:30–16:00 and records the extremes + bar indices.
* **Extended Hours**: scans yesterday AH and today PM to get **yEHH/yEHL**. Script shows **either yEHH or PMH** (whichever is **higher**) and **either yEHL or PML** (whichever is **lower**) to avoid duplicate bands stacked together.
* **Value Area & POC (RTH only)**
* Build a coarse volume profile with `Max Volume Profile Points` buckets across the price range formed by yesterday’s RTH bars.
* Distribute each bar’s volume uniformly across the buckets it spans (fast approximation to keep Pine within execution limits).
* **POC** = bucket with max volume. **VA** expands from POC outward until **70%** of cumulative volume is enclosed → yields **VAH/VAL**.
### B) Market Breadth Table
* **NYSE/NASDAQ Ratio**: signed UVOL/DVOL with basic coloring.
* **VOLD Slopes**: from session open to current, normalized to human‑readable units; colors flip green/red based on thresholds that map to your normalization setting (e.g., ±2M for NYSE, ±3.5×10M for NASDAQ).
* **TICK/TICKQ Slope**: linear regression over the last `N` ratio points → **↗ / → / ↘** with the rounded slope value.
* **VIX Slope**: % change between now and `n` candles ago (optionally divided by `n`). Red when rising beyond threshold; green when falling.
---
## 6) Recommended presets
* **Stocks (liquid, intraday)**
* Value Area **ON**, `Max Volume Points` = **40–60**, **Timeframe** = **5–15**
* Breadth: show **NYSE & NASDAQ & VIX**, `Slope periods` = **5–8**, `Candles for rate` = **10–20**, **Normalize VIX** = **ON**
* **Index futures / very high‑volume symbols**
* If you see Pine timeouts, set `Max Volume Points` = **20–40** or temporarily **disable Value Area**.
* Keep breadth panel **ON** (it’s light). Consider **VIX timeframe = 15/30** for regime clarity.
---
## 7) Tips, edge cases & performance
* **Performance:** The volume profile is capped (`maxBarsToProcess ≤ 500` and bucketed) to keep it responsive. If you experience slowdowns, reduce `Max Volume Points`, `Maximum bars lookback`, or disable Value Area.
* **Redundant lines:** The script **intentionally suppresses** PMH/PML when yEHH/yEHL are more extreme, and vice‑versa.
* **Label visibility:** Use `Label style = none` if you only want clean lines and read values from the right‑end labels.
* **Futures/RTH differences:** Value Area is from **yesterday’s RTH** only; for 24h instruments the RTH period may not reflect overnight structure.
* **Session transitions:** PMH/PML tracking stops as soon as RTH starts; values persist as static levels for the session.
---
## 8) Known limitations
* Uses public TradingView symbols: `UVOL`, `VOLD`, `UVOLQ`, `DVOLQ`, `VOLDQ`, `TICK`, `TICKQ`, `VIX`. If your data plan or region limits any symbol, the corresponding table rows may show `na`.
* The VA/POC approximation assumes uniform distribution of each bar’s volume across its high–low. That’s fast but not a tick‑level profile.
* Works best on US equities with standard NY session; alternative sessions may need code changes.
---
## 9) Troubleshooting
* **“Script is too slow / timed out”** → Lower `Max Volume Points`, lower `Maximum bars lookback`, or toggle **OFF** `Enable Value Area calculations` for that instrument.
* **Missing breadth values** → Ensure the symbols above load on your account; try reloading chart or switching timeframes once.
* **Overlapping labels** → Set `Label style = none` or reduce label size.
---
## 10) Version / license / contribution
* **Version:** Initial public release (Pine v6).
* **Author:** © yelober
* **License:** Free for community use and enhancement. Please keep author credit.
* **Contributing:** Open PRs/ideas: presets, alert conditions, multi‑day VA composites, optional mid‑value (`(VAH+VAL)/2`), session filter for futures, and alertable state machine for breadth regime transitions.
---
## 11) Quick start (TL;DR)
1. Add the indicator and **keep default settings**.
2. Trade **reactions** at yHoD/yLoD/PMH/PML/VAH/VAL/POC.
3. Use the **breadth table**: look for **green ratios + ↗ slopes** (risk‑on) or **red ratios + ↘ slopes** (risk‑off). Check **VIX** slope for confirmation.
4. Manage risk around levels; when breadth flips against you, tighten or exit.
---
### Changelog (public)
* **v1.0:** First community release with automatic RTH levels, VA/POC approximation, breadth dashboard (NYSE/NASDAQ/TICK/TICKQ/VIX) with normalization and adaptive color thresholds.
Volatility Forecast/*==============================================================================
Volatility Forecast — Publishable Documentation
Author: @BB_9791
License: Mozilla Public License 2.0
WHAT THIS INDICATOR SHOWS
- A daily volatility estimate in percent points, called sigma_day.
- A slow volatility anchor, the 10-year EMA of sigma_day.
- A blended volatility series in percent points:
sigma_blend = (1 − p) * sigma_day + p * EMA_10y(sigma_day)
where p is the Slow weight %, default 30.
- Optional annualization by multiplying by 16, this is a daily-to-annual
conversion used by Robert Carver in his writings.
METHODOLOGY, CREDIT
The estimator follows the approach popularized by Robert Carver
("Systematic Trading", "Advanced Futures Trading Strategies", blog qoppac).
Current daily volatility is computed as an exponentially weighted standard
deviation of daily percent returns, with alpha = 2 / (span + 1).
The slow leg is a long EMA of that volatility series, about 10 years.
The blend uses fixed weights. This keeps the slow leg meaningful through
large price level changes, since the blend is done in percent space first.
MATH DETAILS
Let r_t be daily percent return:
r_t = 100 * (Close_t / Close_{t−1} − 1)
EWMA mean and variance:
m_t = α * r_t + (1 − α) * m_{t−1}
v_t = α * (r_t − m_t)^2 + (1 − α) * v_{t−1}
where α = 2 / (span_current + 1)
Current daily sigma in percent points:
sigma_day = sqrt(v_t)
Slow leg:
sigma_10y = EMA(sigma_day, span_long)
Blend:
sigma_blend = (1 − p) * sigma_day + p * sigma_10y
Annualized option:
sigma_ann = 16 * sigma_blend
INPUTS
- Threshold (percent points): horizontal guide level on the chart.
- Short term span (days): EW stdev span for sigma_day.
- Long term span (days): EMA span for the slow leg, choose about 2500 for 10 years.
- Slow weight %: p in the blend.
- Annualize (x16): plot daily or annualized values.
- Show components: toggles Current and 10y EMA lines.
- The script uses the chart symbol by default.
PLOTS
- Blended σ% as the main line.
- Optional Current σ% and 10y EMA σ%.
- Editable horizontal threshold line in the same units as the plot
(percent points per day or per year).
- Optional EMA 9 and EMA 20 cloud on the blended series, green for uptrend
when EMA 9 is above EMA 20, red otherwise. Opacity is configurable.
HOW TO READ
- Values are percent points of movement per day when not annualized,
for example 1.2 means about 1.2% typical daily move.
- With annualize checked, values are percent points per year, for example 18
means about 18% annualized volatility.
- Use the threshold and the EMA cloud to mark high or low volatility regimes.
NOTES
- All calculations use daily data via request.security at the chart symbol.
- The blend is done in percent space, then optionally annualized, which avoids
bias from the price level.
- This script does not produce trading signals by itself, it is a risk and
regime indicator.
CREDITS
Volatility forecasting method and scaling convention credited to Robert Carver.
See his books and blog for background and parameter choices.
VERSION
v1.0 Initial public release.
==============================================================================*/
ATR Extension from Moving Average, with Robust Sigma Bands
# ATR Extension from Moving Average, with Robust Sigma Bands
**What it does**
This indicator measures how far price is from a selected moving average, expressed in **ATR multiples**, then overlays **robust sigma bands** around the long run central tendency of that extension. Positive values mean price is extended above the MA, negative values mean price is extended below the MA. The signal adapts to volatility through ATR, which makes comparisons consistent across symbols and regimes.
**Why it can help**
* Normalizes distance to an MA by ATR, which controls for changing volatility
* Uses the **bar’s extreme** against the MA, not just the close, so it captures true stretch
* Computes a **median** and **standard deviation** of the extension over a multi-year window, which yields simple, intuitive bands for trend and mean-reversion decisions
---
## Inputs
* **MA length**: default 50, options 200, 64, 50, 20, 9, 4, 3
* **MA timeframe**: Daily or Weekly. The MA is computed on the chosen higher timeframe through `request.security`.
* **MA type**: EMA or SMA
* **Years lookback**: 1 to 10 years, default 5. This sets the sample for the median and sigma calculation, `years * 365` bars.
* **Line width**: visual width of the plotted extension series
* **Table**: optional on-chart table that displays the current long run **median** and **sigma** of the extension, with selectable text size
**Fixed parameters in this release**
* **ATR length**: 20 on the daily timeframe
* **ATR type**: classic ATR. ADR percent is not enabled in this version.
---
## Plots and colors
* **Main plot**: “Extension from 50d EMA” by default. Value is in **ATR multiples**.
* **Reference lines**:
* `median` line, black dashed
* +2σ orange, +3σ red
* −2σ blue, −3σ green
---
## How it is calculated
1. **Moving average** on the selected higher timeframe: EMA or SMA of `close`.
2. **Extreme-based distance** from MA, as a percent of price:
* If `close > MA`, use `(high − MA) / close * 100`
* Else, use `(low − MA) / close * 100`
3. **ATR percent** on the daily timeframe: `ATR(20) / close * 100`
4. **ATR multiples**: extension percent divided by ATR percent
5. **Robust center and spread** over the chosen lookback window:
* Center: **median** of the ATR-multiple series
* Spread: **standard deviation** of that series
* Bands: center ± 1σ, 2σ, 3σ, with 2σ and 3σ drawn
This design yields an intuitive unit scale. A value of **+2.0** means price is about 2 ATR above the selected MA by the most stretched side of the current bar. A value of **−3.0** means roughly 3 ATR below.
---
## Practical use
* **Trend continuation**
* Sustained readings near or above **+1σ** together with a rising MA often signal healthy momentum.
* **Mean reversion**
* Spikes into **±2σ** or **±3σ** can identify stretched conditions for fade setups in range or late-trend environments.
* **Regime awareness**
* The **median** moves slowly. When median drifts positive for many months, the market spends more time extended above the MA, which often marks bullish regimes. The opposite applies in bearish regimes.
**Notes**
* The MA can be set to Weekly while ATR remains Daily. This is deliberate, it keeps the normalization stable for most symbols.
* On very short intraday charts, the extension remains meaningful since it references the session’s extreme against a higher-timeframe MA and a daily ATR.
* Symbols with short histories may not fill the lookback window. Bands will adapt as data accrues.
---
## Table overlay
Enable **Table → Show** to see:
* “ATR from \”
* Current **median** and **sigma** of the extension series for your lookback
---
## Recommended settings
* **Swing equities**: 50 EMA on Daily, 5 to 7 years
* **Index trend work**: 200 EMA on Daily, 10 years
* **Position trading**: 20 or 50 EMA on Weekly MA, 5 to 10 years
---
## Interpretation examples
* Reading **+2.7** with price above a rising 50 EMA, near prior highs
* Strong trend extension, consider pyramiding in trend systems or waiting for a pullback if you are a mean-reverter.
* Reading **−2.2** into multi-month support with flattening MA
* Stretch to the downside that often mean-reverts, size entries based on your system rules.
---
## Credits
The concept of measuring stretch from a moving average in ATR units has a rich community history. This implementation and its presentation draw on ideas popularized by **Jeff Sun**, **SugarTrader**, and **Steve D Jacobs**. Thanks to each for their contributions to ATR-based extension thinking.
---
## License
This script and description are distributed under **MPL-2.0**, consistent with the header in the source code.
---
## Changelog
* **v1.0**: Initial public release. Daily ATR normalization, EMA or SMA on D or W timeframe, robust median and sigma bands, optional table.
---
## Disclaimer
This tool is for educational use only. It is not financial advice. Always test on your own data and strategies, then manage risk accordingly.
HSM KILLZONE//@version=5
indicator('HSM KILLZONE', 'HSM KILLZONE', overlay=true, max_bars_back=500, explicit_plot_zorder=true)
import boitoki/AwesomeColor/4 as ac
import boitoki/Utilities/3 as util
///////////////
// Groups
///////////////
g0 = 'GENERAL'
g1_01 = '♯1 SESSION'
g1_02 = '♯2 SESSION'
g1_03 = '♯3 SESSION'
g1_04 = '♯4 SESSION'
g4 = 'BOX'
g6 = 'LABELS'
g5 = 'OPENING RANGE'
g7 = 'FIBONACCI LEVELS'
g8 = 'OPTIONS'
g11 = 'CANDLE'
g10 = 'Alerts visualized'
///////////////
// Defined
///////////////
max_bars = 500
option_yes = 'Yes'
option_no = '× No'
option_extend1 = 'Yes'
option_hide = '× Hide'
option_border_style1 = '────'
option_border_style2 = '- - - - - -'
option_border_style3 = '•••••••••'
option_chart_x = '× No'
option_chart_1 = 'Bar color'
option_chart_2 = 'Candles'
fmt_price = '{0,number,#.#####}'
fmt_pips = '{0,number,#.#}'
icon_separator = ' • '
color_none = color.new(color.black, 100)
color_text = color.new(color.white, 0)
///////////////
// Functions
///////////////
f_get_time_by_bar(bar_count) => timeframe.multiplier * bar_count * 60 * 1000
f_border_style (_style) =>
switch _style
option_border_style1 => line.style_solid
option_border_style2 => line.style_dashed
option_border_style3 => line.style_dotted
=> _style
f_get_period (_session, _start, _lookback) =>
result = math.max(_start, 1)
for i = result to _lookback
if na(_session ) and _session
result := i+1
break
result
f_get_label_position (_y, _side) =>
switch _y
'top' => _side == 'outside' ? label.style_label_lower_left : label.style_label_upper_left
'bottom' => _side == 'outside' ? label.style_label_upper_left : label.style_label_lower_left
f_get_started (_session) => na(_session ) and _session
f_get_ended (_session) => na(_session) and _session
f_message_limit_bars (_v) => '⚠️ This box\'s right position exceeds 500 bars(' + str.tostring(_v) + '). This box is not displayed correctly.'
f_set_line_x1 (_line, _x) =>
if (line.get_x1(_line) != _x)
line.set_x1(_line, _x)
f_set_line_x2 (_line, _x) =>
if (line.get_x2(_line) != _x)
line.set_x2(_line, _x)
f_set_box_right (_box, _x) =>
if box.get_right(_box) != _x
box.set_right(_box, _x)
///////////////
// Inputs
///////////////
// Timezone
i_tz = input.string('GMT-4', title='Timezone', options= , tooltip='e.g. \'America/New_York\', \'Asia/Tokyo\', \'GMT-4\', \'GMT+9\'...', group=g0)
i_history_period = input.int(10, 'History', minval=0, group=g0)
i_show = i_history_period > 0
i_lookback = 12 * 60
// Sessions
i_show_sess1 = input.bool(true, 'Session 1 ', group=g1_01, inline='session1_1') and i_show
i_sess1_label = input.string('New York AM', '', group=g1_01, inline='session1_1')
i_sess1_color = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1_barcolor1 = input.color(#0a0a0a, '•', group=g1_01, inline='session1_1')
i_sess1_barcolor2 = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1 = input.session('0700-1100', 'Time', group=g1_01)
i_sess1_extend = input.string(option_no, 'Extend', options= , group=g1_01)
i_sess1_fib = input.string(option_no, 'Fibonacci levels', group=g1_01, options= ) != option_no
i_sess1_op = input.string(option_no, 'Opening range', group=g1_01, options= ) != option_no and i_show
i_sess1_chart = input.string(option_chart_x, 'Bar', options= , group=g1_01)
i_sess1_barcolor = i_sess1_chart == option_chart_1
i_sess1_plotcandle = i_sess1_chart == option_chart_2
i_show_sess2 = input.bool(true, 'Session 2 ', group=g1_02, inline='session2_1') and i_show
i_sess2_label = input.string('New York PM', '', group=g1_02, inline='session2_1')
i_sess2_color = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2_barcolor1 = input.color(#0a0a0a, '•', group=g1_02, inline='session2_1')
i_sess2_barcolor2 = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2 = input.session('1300-1600', 'Time', group=g1_02)
i_sess2_extend = input.string(option_no, 'Extend', options= , group=g1_02)
i_sess2_fib = input.string(option_no, 'Fibonacci levels', group=g1_02, options= ) != option_no
i_sess2_op = input.string(option_no, 'Opening range', group=g1_02, options= ) != option_no and i_show
i_sess2_chart = input.string(option_chart_x, 'Bar', options= , group=g1_02)
i_sess2_barcolor = i_sess2_chart == option_chart_1
i_sess2_plotcandle = i_sess2_chart == option_chart_2
i_show_sess3 = input.bool(true, 'Session 3 ', group=g1_03, inline='session3_1') and i_show
i_sess3_label = input.string('Asian Sesh', '', group=g1_03, inline='session3_1')
i_sess3_color = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3_barcolor1 = input.color(#0a0a0a, '•', group=g1_03, inline='session3_1')
i_sess3_barcolor2 = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3 = input.session('2000-0000', 'Time', group=g1_03)
i_sess3_extend = input.string(option_no, 'Extend', options= , group=g1_03)
i_sess3_fib = input.string(option_no, 'Fibonacci levels', group=g1_03, options= ) != option_no
i_sess3_op = input.string(option_no, 'Opening range', group=g1_03, options= ) != option_no and i_show
i_sess3_chart = input.string(option_chart_x, 'Bar', options= , group=g1_03)
i_sess3_barcolor = i_sess3_chart == option_chart_1
i_sess3_plotcandle = i_sess3_chart == option_chart_2
i_show_sess4 = input.bool(true, 'Session 4 ', group=g1_04, inline='session4_1') and i_show
i_sess4_label = input.string('London', '', group=g1_04, inline='session4_1')
i_sess4_color = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4_barcolor1 = input.color(#0a0a0a, '•', group=g1_04, inline='session4_1')
i_sess4_barcolor2 = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4 = input.session('0200-0500', 'Time', group=g1_04)
i_sess4_extend = input.string(option_no, 'Extend', options= , group=g1_04)
i_sess4_fib = input.string(option_no, 'Fibonacci levels', group=g1_04, options= ) != option_no
i_sess4_op = input.string(option_no, 'Opening range', group=g1_04, options= ) != option_no and i_show
i_sess4_chart = input.string(option_chart_x, 'Bar', options= , group=g1_04)
i_sess4_barcolor = i_sess4_chart == option_chart_1
i_sess4_plotcandle = i_sess4_chart == option_chart_2
// Show & Styles
i_sess_box_style = input.string('Box', 'Style', options= , group=g4)
i_sess_border_style = f_border_style(input.string(option_border_style2, 'Line style', options= , group=g4))
i_sess_border_width = input.int(1, 'Thickness', minval=0, group=g4)
i_sess_bgopacity = input.int(94, 'Transp', minval=0, maxval=100, step=1, group=g4, tooltip='Setting the 100 is no background color')
// Candle
option_candle_body = 'OC'
option_candle_wick = 'OHLC'
i_candle = input.string(option_hide, 'Display', options= , group=g11)
i_candle_border_width = input.int(2, 'Thickness', minval=0, group=g11)
i_show_candle = (i_candle != option_hide) and (i_candle_border_width > 0)
i_show_candle_wick = i_candle == option_candle_wick
option_candle_color1 = 'Session\'s'
option_candle_color2 = 'Red • Green'
i_candle_color = input.string(option_candle_color2, 'Color ', options= , group=g11, inline='candle_color')
i_candle_color_g = input.color(#A6E22E, '', group=g11, inline='candle_color')
i_candle_color_r = input.color(#F92672, '', group=g11, inline='candle_color')
// Labels
i_label_show = input.bool(true, 'Labels', inline='label_show', group=g6) and i_show
i_label_size = str.lower(input.string('Small', '', options= , inline='label_show', group=g6))
i_label_position_y = str.lower(input.string('Top', '', options= , inline='label_show', group=g6))
i_label_position_s = str.lower(input.string('Outside', '', options= , inline='label_show', group=g6))
i_label_position = f_get_label_position(i_label_position_y, i_label_position_s)
i_label_format_name = input.bool(true, 'Name', inline='label_format', group=g6)
i_label_format_day = input.bool(false, 'Day', inline='label_format', group=g6)
i_label_format_price = input.bool(false, 'Price', inline='label_format', group=g6)
i_label_format_pips = input.bool(false, 'Pips', inline='label_format', group=g6)
// Fibonacci levels
i_f_linestyle = f_border_style(input.string(option_border_style1, title="Style", options= , group=g7))
i_f_linewidth = input.int(1, title="Thickness", minval=1, group=g7)
// Opening range
i_o_minutes = input.int(15, title='Periods (minutes)', minval=1, step=1, group=g5)
i_o_minutes := math.max(i_o_minutes, timeframe.multiplier + 1)
i_o_transp = input.int(88, title='Transp', minval=0, maxval=100, step=1, group=g5)
// Alerts
i_alert1_show = input.bool(false, 'Alerts - Sessions stard/end', group=g10)
i_alert2_show = input.bool(false, 'Alerts - Opening range breakouts', group=g10)
i_alert3_show = input.bool(false, 'Alerts - Price crossed session\'s High/Low after session closed', group=g10)
// ------------------------
// Drawing labels
// ------------------------
f_render_label (_show, _session, _is_started, _color, _top, _bottom, _text, _labels) =>
var label my_label = na
var int start_time = na
v_position_y = (i_label_position_y == 'top') ? _top : _bottom
v_label = array.new_string()
v_chg = _top - _bottom
if _is_started
start_time := time
if i_label_format_name and not na(_text)
array.push(v_label, _text)
if i_label_format_day
array.push(v_label, util.get_day(dayofweek(start_time, i_tz)))
if i_label_format_price
array.push(v_label, str.format(fmt_price, v_chg))
if i_label_format_pips
array.push(v_label, str.format(fmt_pips, util.toPips(v_chg)) + ' pips')
if _show
if _is_started
my_label := label.new(bar_index, v_position_y, array.join(v_label, icon_separator), textcolor=_color, color=color_none, size=i_label_size, style=i_label_position)
array.push(_labels, my_label)
util.clear_labels(_labels, i_history_period)
else if _session
label.set_y(my_label, v_position_y)
label.set_text(my_label, array.join(v_label, icon_separator))
// ------------------------
// Drawing Fibonacci levels
// ------------------------
f_render_fibonacci (_show, _session, _is_started, _x1, _x2, _color, _top, _bottom, _level, _width, _style, _is_extend, _lines) =>
var line my_line = na
if _show
y = (_top - _bottom) * _level + _bottom
if _is_started
my_line := line.new(_x1, y, _x2, y, width=_width, color=color.new(_color, 30), style=_style)
array.push(_lines, my_line)
if _is_extend
line.set_extend(my_line, extend.right)
else if _session
line.set_y1(my_line, y)
line.set_y2(my_line, y)
f_set_line_x2(my_line, _x2)
// ------------------------
// Drawing Opening range
// ------------------------
f_render_oprange (_show, _session, _is_started, _x1, _x2, _color, _max, _is_extend, _boxes) =>
var int start_time = na
var box my_box = na
top = ta.highest(high, _max)
bottom = ta.lowest(low, _max)
is_crossover = ta.crossover(close, box.get_top(my_box))
is_crossunder = ta.crossunder(close, box.get_bottom(my_box))
if _show
if _is_started
util.clear_boxes(_boxes, math.max(0, i_history_period - 1))
start_time := time
my_box := na
else if _session
time_op = start_time + (i_o_minutes * 60 * 1000)
time_op_delay = time_op - f_get_time_by_bar(1)
if time <= time_op and time > time_op_delay
my_box := box.new(_x1, top, _x2, bottom, border_width=0, bgcolor=color.new(_color, i_o_transp))
array.push(_boxes, my_box)
if _is_extend
box.set_extend(my_box, extend.right)
my_box
else
f_set_box_right(my_box, _x2)
if is_crossover
alert('Price crossed over the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_top(my_box), "×", color=color.blue, textcolor=ac.tradingview('blue'), style=label.style_none, size=size.large)
if is_crossunder
alert('Price crossed under the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_bottom(my_box), "×", color=color.red, textcolor=ac.tradingview('red'), style=label.style_none, size=size.large)
my_box
// ------------------------
// Drawing candle
// ------------------------
f_render_candle (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _open, _x1, _x2, _boxes, _lines) =>
var box body = na
var line wick1 = na
var line wick2 = na
border_width = i_candle_border_width
cx = math.round(math.avg(_x2, _x1)) - math.round(border_width / 2)
body_color = i_candle_color == option_candle_color2 ? close > _open ? i_candle_color_g : i_candle_color_r : _color
if _show
if _is_started
body := box.new(_x1, _top, _x2, _bottom, body_color, border_width, line.style_solid, bgcolor=color.new(color.black, 100))
wick1 := i_show_candle_wick ? line.new(cx, _top, cx, _top, color=_color, width=border_width, style=line.style_solid) : na
wick2 := i_show_candle_wick ? line.new(cx, _bottom, cx, _bottom, color=_color, width=border_width, style=line.style_solid) : na
array.push(_boxes, body)
array.push(_lines, wick1)
array.push(_lines, wick2)
util.clear_boxes(_boxes, i_history_period)
util.clear_lines(_lines, i_history_period * 2)
else if _session
top = math.max(_open, close)
bottom = math.min(_open, close)
box.set_top(body, top)
box.set_bottom(body, bottom)
box.set_right(body, _x2)
box.set_border_color(body, body_color)
line.set_y1(wick1, _top)
line.set_y2(wick1, top)
f_set_line_x1(wick1, cx)
f_set_line_x2(wick1, cx)
line.set_color(wick1, body_color)
line.set_y1(wick2, _bottom)
line.set_y2(wick2, bottom)
f_set_line_x1(wick2, cx)
f_set_line_x2(wick2, cx)
line.set_color(wick2, body_color)
else if _is_ended
box.set_right(body, bar_index)
// ------------------------
// Rendering limit message
// ------------------------
f_render_limitmessage (_show, _session, _is_started, _is_ended, _x, _y, _rightbars) =>
var label my_note = na
if _show
if _is_started
if _rightbars > max_bars
my_note := label.new(_x, _y, f_message_limit_bars(_rightbars), style=label.style_label_upper_left, color=color.yellow, textalign=text.align_left, yloc=yloc.price)
else if _session
if _rightbars > max_bars
label.set_y(my_note, _y)
label.set_text(my_note, f_message_limit_bars(_rightbars))
else
label.delete(my_note)
else if _is_ended
label.delete(my_note)
true
// Rendering session
//
f_render_sessionrange (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _lines) =>
var line above_line = na
var line below_line = na
if _show
if _is_started
above_line := line.new(_x1, _top, _x2, _top, width=i_sess_border_width, style=i_sess_border_style, color=_color)
below_line := line.new(_x1, _bottom, _x2, _bottom, width=i_sess_border_width, style=i_sess_border_style, color=_color)
linefill.new(above_line, below_line, color.new(_color, i_sess_bgopacity))
array.push(_lines, above_line)
array.push(_lines, below_line)
util.clear_lines(_lines, i_history_period * 2)
if _is_extend
line.set_extend(above_line, extend.right)
line.set_extend(below_line, extend.right)
else if _session
line.set_y1(above_line, _top)
line.set_y2(above_line, _top)
line.set_x2(above_line, _x2)
line.set_y1(below_line, _bottom)
line.set_y2(below_line, _bottom)
line.set_x2(below_line, _x2)
true
else if _is_ended
true
true
// ------------------------
// Rendering session box
// ------------------------
f_render_session (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _boxes) =>
var box my_box = na
if _show
if _is_started
my_box := box.new(_x1, _top, _x2, _bottom, _color, i_sess_border_width, i_sess_border_style, bgcolor=color.new(_color, i_sess_bgopacity))
array.push(_boxes, my_box)
util.clear_boxes(_boxes, i_history_period)
if _is_extend
box.set_extend(my_box, extend.right)
else if _session
box.set_top(my_box, _top)
box.set_bottom(my_box, _bottom)
f_set_box_right(my_box, _x2)
else if _is_ended
box.set_right(my_box, bar_index)
my_box
// ------------------------
// Drawing market
// ------------------------
f_render_main (_show, _session, _is_started, _is_ended, _color, _top, _bottom) =>
var box my_box = na
var label my_note = na
var x1 = 0
var x2 = 0
var session_open = 0.0
var session_high = 0.0
var session_low = 0.0
x0_1 = ta.valuewhen(na(_session ) and _session, bar_index, 1)
x0_2 = ta.valuewhen(na(_session) and _session , bar_index, 0)
x0_d = math.abs(x0_2 - x0_1)
limit_bars = max_bars
rightbars = x0_d
if _show
if _is_started
x1 := bar_index
x2 := bar_index + (math.min(x0_d, limit_bars))
session_open := open
session_high := _top
session_low := _bottom
else if _session
true_x2 = x1 + x0_d
rightbars := true_x2 - bar_index
limit_bars := bar_index + max_bars
x2 := math.min(true_x2, limit_bars)
session_high := _top
session_low := _bottom
else if _is_ended
session_open := na
// ------------------------
// Drawing
// ------------------------
draw (_show, _session, _color, _label, _extend, _show_fib, _show_op, _lookback, _boxes_session, _lines_session, _boxes_candle_body, _lines_candle_wick, _boxes_op, _lines_fib, _labels) =>
max = f_get_period(_session, 1, _lookback)
top = ta.highest(high, max)
bottom = ta.lowest(low, max)
is_started = f_get_started(_session)
is_ended = f_get_ended(_session)
is_extend = _extend != option_no
= f_render_main(_show, _session, is_started, is_ended, _color, top, bottom)
if i_sess_box_style == 'Box'
f_render_session(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _boxes_session)
if i_sess_box_style == 'Sandwich'
f_render_sessionrange(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _lines_session)
if i_show_candle
f_render_candle(_show, _session, is_started, is_ended, _color, top, bottom, _open, x1, x2, _boxes_candle_body, _lines_candle_wick)
if i_label_show
f_render_label(_show, _session, is_started, _color, top, bottom, _label, _labels)
if _show_op
f_render_oprange(_show, _session, is_started, x1, x2, _color, max, is_extend, _boxes_op)
if _show_fib
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.500, 2, line.style_solid, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.628, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.382, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
util.clear_lines(_lines_fib, i_history_period * 3)
f_render_limitmessage(_show, _session, is_started, is_ended, x1, bottom, _rightbars)
///////////////////
// Calculating
///////////////////
string tz = (i_tz == option_no or i_tz == '') ? na : i_tz
int sess1 = time(timeframe.period, i_sess1, tz)
int sess2 = time(timeframe.period, i_sess2, tz)
int sess3 = time(timeframe.period, i_sess3, tz)
int sess4 = time(timeframe.period, i_sess4, tz)
///////////////////
// Plotting
///////////////////
var sess1_box = array.new()
var sess2_box = array.new()
var sess3_box = array.new()
var sess4_box = array.new()
var sess1_line = array.new()
var sess2_line = array.new()
var sess3_line = array.new()
var sess4_line = array.new()
var sess1_op = array.new()
var sess2_op = array.new()
var sess3_op = array.new()
var sess4_op = array.new()
var sess1_fib = array.new()
var sess2_fib = array.new()
var sess3_fib = array.new()
var sess4_fib = array.new()
var sess1_candle_body = array.new()
var sess2_candle_body = array.new()
var sess3_candle_body = array.new()
var sess4_candle_body = array.new()
var sess1_candle_wick = array.new()
var sess2_candle_wick = array.new()
var sess3_candle_wick = array.new()
var sess4_candle_wick = array.new()
var sess1_labels = array.new()
var sess2_labels = array.new()
var sess3_labels = array.new()
var sess4_labels = array.new()
= draw(i_show_sess1, sess1, i_sess1_color, i_sess1_label, i_sess1_extend, i_sess1_fib, i_sess1_op, i_lookback, sess1_box, sess1_line, sess1_candle_body, sess1_candle_wick, sess1_op, sess1_fib, sess1_labels)
= draw(i_show_sess2, sess2, i_sess2_color, i_sess2_label, i_sess2_extend, i_sess2_fib, i_sess2_op, i_lookback, sess2_box, sess2_line, sess2_candle_body, sess2_candle_wick, sess2_op, sess2_fib, sess2_labels)
= draw(i_show_sess3, sess3, i_sess3_color, i_sess3_label, i_sess3_extend, i_sess3_fib, i_sess3_op, i_lookback, sess3_box, sess3_line, sess3_candle_body, sess3_candle_wick, sess3_op, sess3_fib, sess3_labels)
= draw(i_show_sess4, sess4, i_sess4_color, i_sess4_label, i_sess4_extend, i_sess4_fib, i_sess4_op, i_lookback, sess4_box, sess4_line, sess4_candle_body, sess4_candle_wick, sess4_op, sess4_fib, sess4_labels)
is_positive_bar = close > open
color c_barcolor = na
color c_plotcandle = na
c_sess1_barcolor = (is_sess1) ? (is_positive_bar ? i_sess1_barcolor1 : i_sess1_barcolor2) : na
c_sess2_barcolor = (is_sess2) ? (is_positive_bar ? i_sess2_barcolor1 : i_sess2_barcolor2) : na
c_sess3_barcolor = (is_sess3) ? (is_positive_bar ? i_sess3_barcolor1 : i_sess3_barcolor2) : na
c_sess4_barcolor = (is_sess4) ? (is_positive_bar ? i_sess4_barcolor1 : i_sess4_barcolor2) : na
if (i_sess1_chart != option_chart_x) and is_sess1
c_barcolor := i_sess1_barcolor ? c_sess1_barcolor : na
c_plotcandle := i_sess1_plotcandle ? c_sess1_barcolor : na
if (i_sess2_chart != option_chart_x) and is_sess2
c_barcolor := i_sess2_barcolor ? c_sess2_barcolor : na
c_plotcandle := i_sess2_plotcandle ? c_sess2_barcolor : na
if (i_sess3_chart != option_chart_x) and is_sess3
c_barcolor := i_sess3_barcolor ? c_sess3_barcolor : na
c_plotcandle := i_sess3_plotcandle ? c_sess3_barcolor : na
if (i_sess4_chart != option_chart_x) and is_sess4
c_barcolor := i_sess4_barcolor ? c_sess4_barcolor : na
c_plotcandle := i_sess4_plotcandle ? c_sess4_barcolor : na
barcolor(c_barcolor)
plotcandle(open, high, low, close, color=is_positive_bar ? color_none : c_plotcandle, bordercolor=c_plotcandle, wickcolor=c_plotcandle)
////////////////////
// Alerts
////////////////////
// Session alerts
sess1_started = is_sess1 and not is_sess1 , sess1_ended = not is_sess1 and is_sess1
sess2_started = is_sess2 and not is_sess2 , sess2_ended = not is_sess2 and is_sess2
sess3_started = is_sess3 and not is_sess3 , sess3_ended = not is_sess3 and is_sess3
sess4_started = is_sess4 and not is_sess4 , sess4_ended = not is_sess4 and is_sess4
alertcondition(sess1_started, 'Session #1 started')
alertcondition(sess1_ended, 'Session #1 ended')
alertcondition(sess2_started, 'Session #2 started')
alertcondition(sess2_ended, 'Session #2 ended')
alertcondition(sess3_started, 'Session #3 started')
alertcondition(sess3_ended, 'Session #3 ended')
alertcondition(sess4_started, 'Session #4 started')
alertcondition(sess4_ended, 'Session #4 ended')
alertcondition((not is_sess1) and ta.crossover(close, sess1_high), 'Session #1 High crossed (after session closed)')
alertcondition((not is_sess1) and ta.crossunder(close, sess1_low), 'Session #1 Low crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossover(close, sess2_high), 'Session #2 High crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossunder(close, sess2_low), 'Session #2 Low crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossover(close, sess3_high), 'Session #3 High crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossunder(close, sess3_low), 'Session #3 Low crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossover(close, sess4_high), 'Session #4 High crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossunder(close, sess4_low), 'Session #4 Low crossed (after session closed)')
// Alerts visualized
if i_alert1_show
if i_show_sess1
if sess1_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess1_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess2
if sess2_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess2_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess3
if sess3_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess3_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess4
if sess4_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess4_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
plot(i_alert3_show ? sess1_high : na, 'sess1_high', style=plot.style_linebr, color=i_sess1_color)
plot(i_alert3_show ? sess1_low : na, 'sess1_low' , style=plot.style_linebr, color=i_sess1_color, linewidth=2)
plot(i_alert3_show ? sess2_high : na, 'sess2_high', style=plot.style_linebr, color=i_sess2_color)
plot(i_alert3_show ? sess2_low : na, 'sess2_low' , style=plot.style_linebr, color=i_sess2_color, linewidth=2)
plot(i_alert3_show ? sess3_high : na, 'sess3_high', style=plot.style_linebr, color=i_sess3_color)
plot(i_alert3_show ? sess3_low : na, 'sess3_low' , style=plot.style_linebr, color=i_sess3_color, linewidth=2)
plot(i_alert3_show ? sess4_high : na, 'sess4_high', style=plot.style_linebr, color=i_sess4_color)
plot(i_alert3_show ? sess4_low : na, 'sess4_low' , style=plot.style_linebr, color=i_sess4_color, linewidth=2)
plotshape(i_alert3_show and (not is_sess1) and ta.crossover(close, sess1_high) ? sess1_high : na, 'cross sess1_high', color=i_sess1_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess1) and ta.crossunder(close, sess1_low) ? sess1_low : na, 'cross sess1_low', color=i_sess1_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossover(close, sess2_high) ? sess2_high : na, 'cross sess2_high', color=i_sess2_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossunder(close, sess2_low) ? sess2_low : na, 'cross sess2_low', color=i_sess2_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossover(close, sess3_high) ? sess3_high : na, 'cross sess3_high', color=i_sess3_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossunder(close, sess3_low) ? sess3_low : na, 'cross sess3_low', color=i_sess3_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossover(close, sess4_high) ? sess4_high : na, 'cross sess4_high', color=i_sess4_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossunder(close, sess4_low) ? sess4_low : na, 'cross sess4_low', color=i_sess4_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
HSM MACROS//@version=5
indicator('HSM MACROS', 'HSM MACROS', overlay=true, max_bars_back=500, explicit_plot_zorder=true)
import boitoki/AwesomeColor/4 as ac
import boitoki/Utilities/3 as util
///////////////
// Groups
///////////////
g0 = 'GENERAL'
g1_01 = '♯1 SESSION'
g1_02 = '♯2 SESSION'
g1_03 = '♯3 SESSION'
g1_04 = '♯4 SESSION'
g4 = 'BOX'
g6 = 'LABELS'
g5 = 'OPENING RANGE'
g7 = 'FIBONACCI LEVELS'
g8 = 'OPTIONS'
g11 = 'CANDLE'
g10 = 'Alerts visualized'
///////////////
// Defined
///////////////
max_bars = 500
option_yes = 'Yes'
option_no = '× No'
option_extend1 = 'Yes'
option_hide = '× Hide'
option_border_style1 = '────'
option_border_style2 = '- - - - - -'
option_border_style3 = '•••••••••'
option_chart_x = '× No'
option_chart_1 = 'Bar color'
option_chart_2 = 'Candles'
fmt_price = '{0,number,#.#####}'
fmt_pips = '{0,number,#.#}'
icon_separator = ' • '
color_none = color.new(color.black, 100)
color_text = color.new(color.white, 0)
///////////////
// Functions
///////////////
f_get_time_by_bar(bar_count) => timeframe.multiplier * bar_count * 60 * 1000
f_border_style (_style) =>
switch _style
option_border_style1 => line.style_solid
option_border_style2 => line.style_dashed
option_border_style3 => line.style_dotted
=> _style
f_get_period (_session, _start, _lookback) =>
result = math.max(_start, 1)
for i = result to _lookback
if na(_session ) and _session
result := i+1
break
result
f_get_label_position (_y, _side) =>
switch _y
'top' => _side == 'outside' ? label.style_label_lower_left : label.style_label_upper_left
'bottom' => _side == 'outside' ? label.style_label_upper_left : label.style_label_lower_left
f_get_started (_session) => na(_session ) and _session
f_get_ended (_session) => na(_session) and _session
f_message_limit_bars (_v) => '⚠️ This box\'s right position exceeds 500 bars(' + str.tostring(_v) + '). This box is not displayed correctly.'
f_set_line_x1 (_line, _x) =>
if (line.get_x1(_line) != _x)
line.set_x1(_line, _x)
f_set_line_x2 (_line, _x) =>
if (line.get_x2(_line) != _x)
line.set_x2(_line, _x)
f_set_box_right (_box, _x) =>
if box.get_right(_box) != _x
box.set_right(_box, _x)
///////////////
// Inputs
///////////////
// Timezone
i_tz = input.string('GMT-4', title='Timezone', options= , tooltip='e.g. \'America/New_York\', \'Asia/Tokyo\', \'GMT-4\', \'GMT+9\'...', group=g0)
i_history_period = input.int(10, 'History', minval=0, group=g0)
i_show = i_history_period > 0
i_lookback = 12 * 60
// Sessions
i_show_sess1 = input.bool(true, 'Session 1 ', group=g1_01, inline='session1_1') and i_show
i_sess1_label = input.string('MC1', '', group=g1_01, inline='session1_1')
i_sess1_color = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1_barcolor1 = input.color(#0a0a0a, '•', group=g1_01, inline='session1_1')
i_sess1_barcolor2 = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1 = input.session('0820-0830', 'Time', group=g1_01)
i_sess1_extend = input.string(option_no, 'Extend', options= , group=g1_01)
i_sess1_fib = input.string(option_no, 'Fibonacci levels', group=g1_01, options= ) != option_no
i_sess1_op = input.string(option_no, 'Opening range', group=g1_01, options= ) != option_no and i_show
i_sess1_chart = input.string(option_chart_x, 'Bar', options= , group=g1_01)
i_sess1_barcolor = i_sess1_chart == option_chart_1
i_sess1_plotcandle = i_sess1_chart == option_chart_2
i_show_sess2 = input.bool(true, 'Session 2 ', group=g1_02, inline='session2_1') and i_show
i_sess2_label = input.string('MC2', '', group=g1_02, inline='session2_1')
i_sess2_color = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2_barcolor1 = input.color(#0a0a0a, '•', group=g1_02, inline='session2_1')
i_sess2_barcolor2 = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2 = input.session('0920-0930', 'Time', group=g1_02)
i_sess2_extend = input.string(option_no, 'Extend', options= , group=g1_02)
i_sess2_fib = input.string(option_no, 'Fibonacci levels', group=g1_02, options= ) != option_no
i_sess2_op = input.string(option_no, 'Opening range', group=g1_02, options= ) != option_no and i_show
i_sess2_chart = input.string(option_chart_x, 'Bar', options= , group=g1_02)
i_sess2_barcolor = i_sess2_chart == option_chart_1
i_sess2_plotcandle = i_sess2_chart == option_chart_2
i_show_sess3 = input.bool(true, 'Session 3 ', group=g1_03, inline='session3_1') and i_show
i_sess3_label = input.string('MC3', '', group=g1_03, inline='session3_1')
i_sess3_color = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3_barcolor1 = input.color(#0a0a0a, '•', group=g1_03, inline='session3_1')
i_sess3_barcolor2 = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3 = input.session('0950-1010', 'Time', group=g1_03)
i_sess3_extend = input.string(option_no, 'Extend', options= , group=g1_03)
i_sess3_fib = input.string(option_no, 'Fibonacci levels', group=g1_03, options= ) != option_no
i_sess3_op = input.string(option_no, 'Opening range', group=g1_03, options= ) != option_no and i_show
i_sess3_chart = input.string(option_chart_x, 'Bar', options= , group=g1_03)
i_sess3_barcolor = i_sess3_chart == option_chart_1
i_sess3_plotcandle = i_sess3_chart == option_chart_2
i_show_sess4 = input.bool(true, 'Session 4 ', group=g1_04, inline='session4_1') and i_show
i_sess4_label = input.string('MC4', '', group=g1_04, inline='session4_1')
i_sess4_color = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4_barcolor1 = input.color(#0a0a0a, '•', group=g1_04, inline='session4_1')
i_sess4_barcolor2 = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4 = input.session('1050-1110', 'Time', group=g1_04)
i_sess4_extend = input.string(option_no, 'Extend', options= , group=g1_04)
i_sess4_fib = input.string(option_no, 'Fibonacci levels', group=g1_04, options= ) != option_no
i_sess4_op = input.string(option_no, 'Opening range', group=g1_04, options= ) != option_no and i_show
i_sess4_chart = input.string(option_chart_x, 'Bar', options= , group=g1_04)
i_sess4_barcolor = i_sess4_chart == option_chart_1
i_sess4_plotcandle = i_sess4_chart == option_chart_2
// Show & Styles
i_sess_box_style = input.string('Box', 'Style', options= , group=g4)
i_sess_border_style = f_border_style(input.string(option_border_style2, 'Line style', options= , group=g4))
i_sess_border_width = input.int(1, 'Thickness', minval=0, group=g4)
i_sess_bgopacity = input.int(94, 'Transp', minval=0, maxval=100, step=1, group=g4, tooltip='Setting the 100 is no background color')
// Candle
option_candle_body = 'OC'
option_candle_wick = 'OHLC'
i_candle = input.string(option_hide, 'Display', options= , group=g11)
i_candle_border_width = input.int(2, 'Thickness', minval=0, group=g11)
i_show_candle = (i_candle != option_hide) and (i_candle_border_width > 0)
i_show_candle_wick = i_candle == option_candle_wick
option_candle_color1 = 'Session\'s'
option_candle_color2 = 'Red • Green'
i_candle_color = input.string(option_candle_color2, 'Color ', options= , group=g11, inline='candle_color')
i_candle_color_g = input.color(#A6E22E, '', group=g11, inline='candle_color')
i_candle_color_r = input.color(#F92672, '', group=g11, inline='candle_color')
// Labels
i_label_show = input.bool(true, 'Labels', inline='label_show', group=g6) and i_show
i_label_size = str.lower(input.string('Small', '', options= , inline='label_show', group=g6))
i_label_position_y = str.lower(input.string('Top', '', options= , inline='label_show', group=g6))
i_label_position_s = str.lower(input.string('Outside', '', options= , inline='label_show', group=g6))
i_label_position = f_get_label_position(i_label_position_y, i_label_position_s)
i_label_format_name = input.bool(true, 'Name', inline='label_format', group=g6)
i_label_format_day = input.bool(false, 'Day', inline='label_format', group=g6)
i_label_format_price = input.bool(false, 'Price', inline='label_format', group=g6)
i_label_format_pips = input.bool(false, 'Pips', inline='label_format', group=g6)
// Fibonacci levels
i_f_linestyle = f_border_style(input.string(option_border_style1, title="Style", options= , group=g7))
i_f_linewidth = input.int(1, title="Thickness", minval=1, group=g7)
// Opening range
i_o_minutes = input.int(15, title='Periods (minutes)', minval=1, step=1, group=g5)
i_o_minutes := math.max(i_o_minutes, timeframe.multiplier + 1)
i_o_transp = input.int(88, title='Transp', minval=0, maxval=100, step=1, group=g5)
// Alerts
i_alert1_show = input.bool(false, 'Alerts - Sessions stard/end', group=g10)
i_alert2_show = input.bool(false, 'Alerts - Opening range breakouts', group=g10)
i_alert3_show = input.bool(false, 'Alerts - Price crossed session\'s High/Low after session closed', group=g10)
// ------------------------
// Drawing labels
// ------------------------
f_render_label (_show, _session, _is_started, _color, _top, _bottom, _text, _labels) =>
var label my_label = na
var int start_time = na
v_position_y = (i_label_position_y == 'top') ? _top : _bottom
v_label = array.new_string()
v_chg = _top - _bottom
if _is_started
start_time := time
if i_label_format_name and not na(_text)
array.push(v_label, _text)
if i_label_format_day
array.push(v_label, util.get_day(dayofweek(start_time, i_tz)))
if i_label_format_price
array.push(v_label, str.format(fmt_price, v_chg))
if i_label_format_pips
array.push(v_label, str.format(fmt_pips, util.toPips(v_chg)) + ' pips')
if _show
if _is_started
my_label := label.new(bar_index, v_position_y, array.join(v_label, icon_separator), textcolor=_color, color=color_none, size=i_label_size, style=i_label_position)
array.push(_labels, my_label)
util.clear_labels(_labels, i_history_period)
else if _session
label.set_y(my_label, v_position_y)
label.set_text(my_label, array.join(v_label, icon_separator))
// ------------------------
// Drawing Fibonacci levels
// ------------------------
f_render_fibonacci (_show, _session, _is_started, _x1, _x2, _color, _top, _bottom, _level, _width, _style, _is_extend, _lines) =>
var line my_line = na
if _show
y = (_top - _bottom) * _level + _bottom
if _is_started
my_line := line.new(_x1, y, _x2, y, width=_width, color=color.new(_color, 30), style=_style)
array.push(_lines, my_line)
if _is_extend
line.set_extend(my_line, extend.right)
else if _session
line.set_y1(my_line, y)
line.set_y2(my_line, y)
f_set_line_x2(my_line, _x2)
// ------------------------
// Drawing Opening range
// ------------------------
f_render_oprange (_show, _session, _is_started, _x1, _x2, _color, _max, _is_extend, _boxes) =>
var int start_time = na
var box my_box = na
top = ta.highest(high, _max)
bottom = ta.lowest(low, _max)
is_crossover = ta.crossover(close, box.get_top(my_box))
is_crossunder = ta.crossunder(close, box.get_bottom(my_box))
if _show
if _is_started
util.clear_boxes(_boxes, math.max(0, i_history_period - 1))
start_time := time
my_box := na
else if _session
time_op = start_time + (i_o_minutes * 60 * 1000)
time_op_delay = time_op - f_get_time_by_bar(1)
if time <= time_op and time > time_op_delay
my_box := box.new(_x1, top, _x2, bottom, border_width=0, bgcolor=color.new(_color, i_o_transp))
array.push(_boxes, my_box)
if _is_extend
box.set_extend(my_box, extend.right)
my_box
else
f_set_box_right(my_box, _x2)
if is_crossover
alert('Price crossed over the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_top(my_box), "×", color=color.blue, textcolor=ac.tradingview('blue'), style=label.style_none, size=size.large)
if is_crossunder
alert('Price crossed under the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_bottom(my_box), "×", color=color.red, textcolor=ac.tradingview('red'), style=label.style_none, size=size.large)
my_box
// ------------------------
// Drawing candle
// ------------------------
f_render_candle (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _open, _x1, _x2, _boxes, _lines) =>
var box body = na
var line wick1 = na
var line wick2 = na
border_width = i_candle_border_width
cx = math.round(math.avg(_x2, _x1)) - math.round(border_width / 2)
body_color = i_candle_color == option_candle_color2 ? close > _open ? i_candle_color_g : i_candle_color_r : _color
if _show
if _is_started
body := box.new(_x1, _top, _x2, _bottom, body_color, border_width, line.style_solid, bgcolor=color.new(color.black, 100))
wick1 := i_show_candle_wick ? line.new(cx, _top, cx, _top, color=_color, width=border_width, style=line.style_solid) : na
wick2 := i_show_candle_wick ? line.new(cx, _bottom, cx, _bottom, color=_color, width=border_width, style=line.style_solid) : na
array.push(_boxes, body)
array.push(_lines, wick1)
array.push(_lines, wick2)
util.clear_boxes(_boxes, i_history_period)
util.clear_lines(_lines, i_history_period * 2)
else if _session
top = math.max(_open, close)
bottom = math.min(_open, close)
box.set_top(body, top)
box.set_bottom(body, bottom)
box.set_right(body, _x2)
box.set_border_color(body, body_color)
line.set_y1(wick1, _top)
line.set_y2(wick1, top)
f_set_line_x1(wick1, cx)
f_set_line_x2(wick1, cx)
line.set_color(wick1, body_color)
line.set_y1(wick2, _bottom)
line.set_y2(wick2, bottom)
f_set_line_x1(wick2, cx)
f_set_line_x2(wick2, cx)
line.set_color(wick2, body_color)
else if _is_ended
box.set_right(body, bar_index)
// ------------------------
// Rendering limit message
// ------------------------
f_render_limitmessage (_show, _session, _is_started, _is_ended, _x, _y, _rightbars) =>
var label my_note = na
if _show
if _is_started
if _rightbars > max_bars
my_note := label.new(_x, _y, f_message_limit_bars(_rightbars), style=label.style_label_upper_left, color=color.yellow, textalign=text.align_left, yloc=yloc.price)
else if _session
if _rightbars > max_bars
label.set_y(my_note, _y)
label.set_text(my_note, f_message_limit_bars(_rightbars))
else
label.delete(my_note)
else if _is_ended
label.delete(my_note)
true
// Rendering session
//
f_render_sessionrange (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _lines) =>
var line above_line = na
var line below_line = na
if _show
if _is_started
above_line := line.new(_x1, _top, _x2, _top, width=i_sess_border_width, style=i_sess_border_style, color=_color)
below_line := line.new(_x1, _bottom, _x2, _bottom, width=i_sess_border_width, style=i_sess_border_style, color=_color)
linefill.new(above_line, below_line, color.new(_color, i_sess_bgopacity))
array.push(_lines, above_line)
array.push(_lines, below_line)
util.clear_lines(_lines, i_history_period * 2)
if _is_extend
line.set_extend(above_line, extend.right)
line.set_extend(below_line, extend.right)
else if _session
line.set_y1(above_line, _top)
line.set_y2(above_line, _top)
line.set_x2(above_line, _x2)
line.set_y1(below_line, _bottom)
line.set_y2(below_line, _bottom)
line.set_x2(below_line, _x2)
true
else if _is_ended
true
true
// ------------------------
// Rendering session box
// ------------------------
f_render_session (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _boxes) =>
var box my_box = na
if _show
if _is_started
my_box := box.new(_x1, _top, _x2, _bottom, _color, i_sess_border_width, i_sess_border_style, bgcolor=color.new(_color, i_sess_bgopacity))
array.push(_boxes, my_box)
util.clear_boxes(_boxes, i_history_period)
if _is_extend
box.set_extend(my_box, extend.right)
else if _session
box.set_top(my_box, _top)
box.set_bottom(my_box, _bottom)
f_set_box_right(my_box, _x2)
else if _is_ended
box.set_right(my_box, bar_index)
my_box
// ------------------------
// Drawing market
// ------------------------
f_render_main (_show, _session, _is_started, _is_ended, _color, _top, _bottom) =>
var box my_box = na
var label my_note = na
var x1 = 0
var x2 = 0
var session_open = 0.0
var session_high = 0.0
var session_low = 0.0
x0_1 = ta.valuewhen(na(_session ) and _session, bar_index, 1)
x0_2 = ta.valuewhen(na(_session) and _session , bar_index, 0)
x0_d = math.abs(x0_2 - x0_1)
limit_bars = max_bars
rightbars = x0_d
if _show
if _is_started
x1 := bar_index
x2 := bar_index + (math.min(x0_d, limit_bars))
session_open := open
session_high := _top
session_low := _bottom
else if _session
true_x2 = x1 + x0_d
rightbars := true_x2 - bar_index
limit_bars := bar_index + max_bars
x2 := math.min(true_x2, limit_bars)
session_high := _top
session_low := _bottom
else if _is_ended
session_open := na
// ------------------------
// Drawing
// ------------------------
draw (_show, _session, _color, _label, _extend, _show_fib, _show_op, _lookback, _boxes_session, _lines_session, _boxes_candle_body, _lines_candle_wick, _boxes_op, _lines_fib, _labels) =>
max = f_get_period(_session, 1, _lookback)
top = ta.highest(high, max)
bottom = ta.lowest(low, max)
is_started = f_get_started(_session)
is_ended = f_get_ended(_session)
is_extend = _extend != option_no
= f_render_main(_show, _session, is_started, is_ended, _color, top, bottom)
if i_sess_box_style == 'Box'
f_render_session(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _boxes_session)
if i_sess_box_style == 'Sandwich'
f_render_sessionrange(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _lines_session)
if i_show_candle
f_render_candle(_show, _session, is_started, is_ended, _color, top, bottom, _open, x1, x2, _boxes_candle_body, _lines_candle_wick)
if i_label_show
f_render_label(_show, _session, is_started, _color, top, bottom, _label, _labels)
if _show_op
f_render_oprange(_show, _session, is_started, x1, x2, _color, max, is_extend, _boxes_op)
if _show_fib
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.500, 2, line.style_solid, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.628, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.382, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
util.clear_lines(_lines_fib, i_history_period * 3)
f_render_limitmessage(_show, _session, is_started, is_ended, x1, bottom, _rightbars)
///////////////////
// Calculating
///////////////////
string tz = (i_tz == option_no or i_tz == '') ? na : i_tz
int sess1 = time(timeframe.period, i_sess1, tz)
int sess2 = time(timeframe.period, i_sess2, tz)
int sess3 = time(timeframe.period, i_sess3, tz)
int sess4 = time(timeframe.period, i_sess4, tz)
///////////////////
// Plotting
///////////////////
var sess1_box = array.new()
var sess2_box = array.new()
var sess3_box = array.new()
var sess4_box = array.new()
var sess1_line = array.new()
var sess2_line = array.new()
var sess3_line = array.new()
var sess4_line = array.new()
var sess1_op = array.new()
var sess2_op = array.new()
var sess3_op = array.new()
var sess4_op = array.new()
var sess1_fib = array.new()
var sess2_fib = array.new()
var sess3_fib = array.new()
var sess4_fib = array.new()
var sess1_candle_body = array.new()
var sess2_candle_body = array.new()
var sess3_candle_body = array.new()
var sess4_candle_body = array.new()
var sess1_candle_wick = array.new()
var sess2_candle_wick = array.new()
var sess3_candle_wick = array.new()
var sess4_candle_wick = array.new()
var sess1_labels = array.new()
var sess2_labels = array.new()
var sess3_labels = array.new()
var sess4_labels = array.new()
= draw(i_show_sess1, sess1, i_sess1_color, i_sess1_label, i_sess1_extend, i_sess1_fib, i_sess1_op, i_lookback, sess1_box, sess1_line, sess1_candle_body, sess1_candle_wick, sess1_op, sess1_fib, sess1_labels)
= draw(i_show_sess2, sess2, i_sess2_color, i_sess2_label, i_sess2_extend, i_sess2_fib, i_sess2_op, i_lookback, sess2_box, sess2_line, sess2_candle_body, sess2_candle_wick, sess2_op, sess2_fib, sess2_labels)
= draw(i_show_sess3, sess3, i_sess3_color, i_sess3_label, i_sess3_extend, i_sess3_fib, i_sess3_op, i_lookback, sess3_box, sess3_line, sess3_candle_body, sess3_candle_wick, sess3_op, sess3_fib, sess3_labels)
= draw(i_show_sess4, sess4, i_sess4_color, i_sess4_label, i_sess4_extend, i_sess4_fib, i_sess4_op, i_lookback, sess4_box, sess4_line, sess4_candle_body, sess4_candle_wick, sess4_op, sess4_fib, sess4_labels)
is_positive_bar = close > open
color c_barcolor = na
color c_plotcandle = na
c_sess1_barcolor = (is_sess1) ? (is_positive_bar ? i_sess1_barcolor1 : i_sess1_barcolor2) : na
c_sess2_barcolor = (is_sess2) ? (is_positive_bar ? i_sess2_barcolor1 : i_sess2_barcolor2) : na
c_sess3_barcolor = (is_sess3) ? (is_positive_bar ? i_sess3_barcolor1 : i_sess3_barcolor2) : na
c_sess4_barcolor = (is_sess4) ? (is_positive_bar ? i_sess4_barcolor1 : i_sess4_barcolor2) : na
if (i_sess1_chart != option_chart_x) and is_sess1
c_barcolor := i_sess1_barcolor ? c_sess1_barcolor : na
c_plotcandle := i_sess1_plotcandle ? c_sess1_barcolor : na
if (i_sess2_chart != option_chart_x) and is_sess2
c_barcolor := i_sess2_barcolor ? c_sess2_barcolor : na
c_plotcandle := i_sess2_plotcandle ? c_sess2_barcolor : na
if (i_sess3_chart != option_chart_x) and is_sess3
c_barcolor := i_sess3_barcolor ? c_sess3_barcolor : na
c_plotcandle := i_sess3_plotcandle ? c_sess3_barcolor : na
if (i_sess4_chart != option_chart_x) and is_sess4
c_barcolor := i_sess4_barcolor ? c_sess4_barcolor : na
c_plotcandle := i_sess4_plotcandle ? c_sess4_barcolor : na
barcolor(c_barcolor)
plotcandle(open, high, low, close, color=is_positive_bar ? color_none : c_plotcandle, bordercolor=c_plotcandle, wickcolor=c_plotcandle)
////////////////////
// Alerts
////////////////////
// Session alerts
sess1_started = is_sess1 and not is_sess1 , sess1_ended = not is_sess1 and is_sess1
sess2_started = is_sess2 and not is_sess2 , sess2_ended = not is_sess2 and is_sess2
sess3_started = is_sess3 and not is_sess3 , sess3_ended = not is_sess3 and is_sess3
sess4_started = is_sess4 and not is_sess4 , sess4_ended = not is_sess4 and is_sess4
alertcondition(sess1_started, 'Session #1 started')
alertcondition(sess1_ended, 'Session #1 ended')
alertcondition(sess2_started, 'Session #2 started')
alertcondition(sess2_ended, 'Session #2 ended')
alertcondition(sess3_started, 'Session #3 started')
alertcondition(sess3_ended, 'Session #3 ended')
alertcondition(sess4_started, 'Session #4 started')
alertcondition(sess4_ended, 'Session #4 ended')
alertcondition((not is_sess1) and ta.crossover(close, sess1_high), 'Session #1 High crossed (after session closed)')
alertcondition((not is_sess1) and ta.crossunder(close, sess1_low), 'Session #1 Low crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossover(close, sess2_high), 'Session #2 High crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossunder(close, sess2_low), 'Session #2 Low crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossover(close, sess3_high), 'Session #3 High crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossunder(close, sess3_low), 'Session #3 Low crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossover(close, sess4_high), 'Session #4 High crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossunder(close, sess4_low), 'Session #4 Low crossed (after session closed)')
// Alerts visualized
if i_alert1_show
if i_show_sess1
if sess1_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess1_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess2
if sess2_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess2_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess3
if sess3_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess3_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess4
if sess4_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess4_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
plot(i_alert3_show ? sess1_high : na, 'sess1_high', style=plot.style_linebr, color=i_sess1_color)
plot(i_alert3_show ? sess1_low : na, 'sess1_low' , style=plot.style_linebr, color=i_sess1_color, linewidth=2)
plot(i_alert3_show ? sess2_high : na, 'sess2_high', style=plot.style_linebr, color=i_sess2_color)
plot(i_alert3_show ? sess2_low : na, 'sess2_low' , style=plot.style_linebr, color=i_sess2_color, linewidth=2)
plot(i_alert3_show ? sess3_high : na, 'sess3_high', style=plot.style_linebr, color=i_sess3_color)
plot(i_alert3_show ? sess3_low : na, 'sess3_low' , style=plot.style_linebr, color=i_sess3_color, linewidth=2)
plot(i_alert3_show ? sess4_high : na, 'sess4_high', style=plot.style_linebr, color=i_sess4_color)
plot(i_alert3_show ? sess4_low : na, 'sess4_low' , style=plot.style_linebr, color=i_sess4_color, linewidth=2)
plotshape(i_alert3_show and (not is_sess1) and ta.crossover(close, sess1_high) ? sess1_high : na, 'cross sess1_high', color=i_sess1_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess1) and ta.crossunder(close, sess1_low) ? sess1_low : na, 'cross sess1_low', color=i_sess1_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossover(close, sess2_high) ? sess2_high : na, 'cross sess2_high', color=i_sess2_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossunder(close, sess2_low) ? sess2_low : na, 'cross sess2_low', color=i_sess2_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossover(close, sess3_high) ? sess3_high : na, 'cross sess3_high', color=i_sess3_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossunder(close, sess3_low) ? sess3_low : na, 'cross sess3_low', color=i_sess3_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossover(close, sess4_high) ? sess4_high : na, 'cross sess4_high', color=i_sess4_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossunder(close, sess4_low) ? sess4_low : na, 'cross sess4_low', color=i_sess4_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
HSM BULLET//@version=5
indicator('HSM BULLET', 'HSM BULLET', overlay=true, max_bars_back=500, explicit_plot_zorder=true)
import boitoki/AwesomeColor/4 as ac
import boitoki/Utilities/3 as util
///////////////
// Groups
///////////////
g0 = 'GENERAL'
g1_01 = '♯1 SESSION'
g1_02 = '♯2 SESSION'
g1_03 = '♯3 SESSION'
g1_04 = '♯4 SESSION'
g4 = 'BOX'
g6 = 'LABELS'
g5 = 'OPENING RANGE'
g7 = 'FIBONACCI LEVELS'
g8 = 'OPTIONS'
g11 = 'CANDLE'
g10 = 'Alerts visualized'
///////////////
// Defined
///////////////
max_bars = 500
option_yes = 'Yes'
option_no = '× No'
option_extend1 = 'Yes'
option_hide = '× Hide'
option_border_style1 = '────'
option_border_style2 = '- - - - - -'
option_border_style3 = '•••••••••'
option_chart_x = '× No'
option_chart_1 = 'Bar color'
option_chart_2 = 'Candles'
fmt_price = '{0,number,#.#####}'
fmt_pips = '{0,number,#.#}'
icon_separator = ' • '
color_none = color.new(color.black, 100)
color_text = color.new(color.white, 0)
///////////////
// Functions
///////////////
f_get_time_by_bar(bar_count) => timeframe.multiplier * bar_count * 60 * 1000
f_border_style (_style) =>
switch _style
option_border_style1 => line.style_solid
option_border_style2 => line.style_dashed
option_border_style3 => line.style_dotted
=> _style
f_get_period (_session, _start, _lookback) =>
result = math.max(_start, 1)
for i = result to _lookback
if na(_session ) and _session
result := i+1
break
result
f_get_label_position (_y, _side) =>
switch _y
'top' => _side == 'outside' ? label.style_label_lower_left : label.style_label_upper_left
'bottom' => _side == 'outside' ? label.style_label_upper_left : label.style_label_lower_left
f_get_started (_session) => na(_session ) and _session
f_get_ended (_session) => na(_session) and _session
f_message_limit_bars (_v) => '⚠️ This box\'s right position exceeds 500 bars(' + str.tostring(_v) + '). This box is not displayed correctly.'
f_set_line_x1 (_line, _x) =>
if (line.get_x1(_line) != _x)
line.set_x1(_line, _x)
f_set_line_x2 (_line, _x) =>
if (line.get_x2(_line) != _x)
line.set_x2(_line, _x)
f_set_box_right (_box, _x) =>
if box.get_right(_box) != _x
box.set_right(_box, _x)
///////////////
// Inputs
///////////////
// Timezone
i_tz = input.string('GMT-4', title='Timezone', options= , tooltip='e.g. \'America/New_York\', \'Asia/Tokyo\', \'GMT-4\', \'GMT+9\'...', group=g0)
i_history_period = input.int(10, 'History', minval=0, group=g0)
i_show = i_history_period > 0
i_lookback = 12 * 60
// Sessions
i_show_sess1 = input.bool(true, 'Session 1 ', group=g1_01, inline='session1_1') and i_show
i_sess1_label = input.string('London Silver', '', group=g1_01, inline='session1_1')
i_sess1_color = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1_barcolor1 = input.color(#0a0a0a, '•', group=g1_01, inline='session1_1')
i_sess1_barcolor2 = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1 = input.session('0300-0400', 'Time', group=g1_01)
i_sess1_extend = input.string(option_no, 'Extend', options= , group=g1_01)
i_sess1_fib = input.string(option_no, 'Fibonacci levels', group=g1_01, options= ) != option_no
i_sess1_op = input.string(option_no, 'Opening range', group=g1_01, options= ) != option_no and i_show
i_sess1_chart = input.string(option_chart_x, 'Bar', options= , group=g1_01)
i_sess1_barcolor = i_sess1_chart == option_chart_1
i_sess1_plotcandle = i_sess1_chart == option_chart_2
i_show_sess2 = input.bool(true, 'Session 2 ', group=g1_02, inline='session2_1') and i_show
i_sess2_label = input.string('NY AM Bullet', '', group=g1_02, inline='session2_1')
i_sess2_color = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2_barcolor1 = input.color(#0a0a0a, '•', group=g1_02, inline='session2_1')
i_sess2_barcolor2 = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2 = input.session('1000-1100', 'Time', group=g1_02)
i_sess2_extend = input.string(option_no, 'Extend', options= , group=g1_02)
i_sess2_fib = input.string(option_no, 'Fibonacci levels', group=g1_02, options= ) != option_no
i_sess2_op = input.string(option_no, 'Opening range', group=g1_02, options= ) != option_no and i_show
i_sess2_chart = input.string(option_chart_x, 'Bar', options= , group=g1_02)
i_sess2_barcolor = i_sess2_chart == option_chart_1
i_sess2_plotcandle = i_sess2_chart == option_chart_2
i_show_sess3 = input.bool(true, 'Session 3 ', group=g1_03, inline='session3_1') and i_show
i_sess3_label = input.string('NY PM Bullet', '', group=g1_03, inline='session3_1')
i_sess3_color = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3_barcolor1 = input.color(#0a0a0a, '•', group=g1_03, inline='session3_1')
i_sess3_barcolor2 = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3 = input.session('1400-1500', 'Time', group=g1_03)
i_sess3_extend = input.string(option_no, 'Extend', options= , group=g1_03)
i_sess3_fib = input.string(option_no, 'Fibonacci levels', group=g1_03, options= ) != option_no
i_sess3_op = input.string(option_no, 'Opening range', group=g1_03, options= ) != option_no and i_show
i_sess3_chart = input.string(option_chart_x, 'Bar', options= , group=g1_03)
i_sess3_barcolor = i_sess3_chart == option_chart_1
i_sess3_plotcandle = i_sess3_chart == option_chart_2
i_show_sess4 = input.bool(true, 'Session 4 ', group=g1_04, inline='session4_1') and i_show
i_sess4_label = input.string(' ', '', group=g1_04, inline='session4_1')
i_sess4_color = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4_barcolor1 = input.color(#0a0a0a, '•', group=g1_04, inline='session4_1')
i_sess4_barcolor2 = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4 = input.session('1000-1000', 'Time', group=g1_04)
i_sess4_extend = input.string(option_no, 'Extend', options= , group=g1_04)
i_sess4_fib = input.string(option_no, 'Fibonacci levels', group=g1_04, options= ) != option_no
i_sess4_op = input.string(option_no, 'Opening range', group=g1_04, options= ) != option_no and i_show
i_sess4_chart = input.string(option_chart_x, 'Bar', options= , group=g1_04)
i_sess4_barcolor = i_sess4_chart == option_chart_1
i_sess4_plotcandle = i_sess4_chart == option_chart_2
// Show & Styles
i_sess_box_style = input.string('Box', 'Style', options= , group=g4)
i_sess_border_style = f_border_style(input.string(option_border_style2, 'Line style', options= , group=g4))
i_sess_border_width = input.int(1, 'Thickness', minval=0, group=g4)
i_sess_bgopacity = input.int(94, 'Transp', minval=0, maxval=100, step=1, group=g4, tooltip='Setting the 100 is no background color')
// Candle
option_candle_body = 'OC'
option_candle_wick = 'OHLC'
i_candle = input.string(option_hide, 'Display', options= , group=g11)
i_candle_border_width = input.int(2, 'Thickness', minval=0, group=g11)
i_show_candle = (i_candle != option_hide) and (i_candle_border_width > 0)
i_show_candle_wick = i_candle == option_candle_wick
option_candle_color1 = 'Session\'s'
option_candle_color2 = 'Red • Green'
i_candle_color = input.string(option_candle_color2, 'Color ', options= , group=g11, inline='candle_color')
i_candle_color_g = input.color(#A6E22E, '', group=g11, inline='candle_color')
i_candle_color_r = input.color(#F92672, '', group=g11, inline='candle_color')
// Labels
i_label_show = input.bool(true, 'Labels', inline='label_show', group=g6) and i_show
i_label_size = str.lower(input.string('Small', '', options= , inline='label_show', group=g6))
i_label_position_y = str.lower(input.string('Top', '', options= , inline='label_show', group=g6))
i_label_position_s = str.lower(input.string('Outside', '', options= , inline='label_show', group=g6))
i_label_position = f_get_label_position(i_label_position_y, i_label_position_s)
i_label_format_name = input.bool(true, 'Name', inline='label_format', group=g6)
i_label_format_day = input.bool(false, 'Day', inline='label_format', group=g6)
i_label_format_price = input.bool(false, 'Price', inline='label_format', group=g6)
i_label_format_pips = input.bool(false, 'Pips', inline='label_format', group=g6)
// Fibonacci levels
i_f_linestyle = f_border_style(input.string(option_border_style1, title="Style", options= , group=g7))
i_f_linewidth = input.int(1, title="Thickness", minval=1, group=g7)
// Opening range
i_o_minutes = input.int(15, title='Periods (minutes)', minval=1, step=1, group=g5)
i_o_minutes := math.max(i_o_minutes, timeframe.multiplier + 1)
i_o_transp = input.int(88, title='Transp', minval=0, maxval=100, step=1, group=g5)
// Alerts
i_alert1_show = input.bool(false, 'Alerts - Sessions stard/end', group=g10)
i_alert2_show = input.bool(false, 'Alerts - Opening range breakouts', group=g10)
i_alert3_show = input.bool(false, 'Alerts - Price crossed session\'s High/Low after session closed', group=g10)
// ------------------------
// Drawing labels
// ------------------------
f_render_label (_show, _session, _is_started, _color, _top, _bottom, _text, _labels) =>
var label my_label = na
var int start_time = na
v_position_y = (i_label_position_y == 'top') ? _top : _bottom
v_label = array.new_string()
v_chg = _top - _bottom
if _is_started
start_time := time
if i_label_format_name and not na(_text)
array.push(v_label, _text)
if i_label_format_day
array.push(v_label, util.get_day(dayofweek(start_time, i_tz)))
if i_label_format_price
array.push(v_label, str.format(fmt_price, v_chg))
if i_label_format_pips
array.push(v_label, str.format(fmt_pips, util.toPips(v_chg)) + ' pips')
if _show
if _is_started
my_label := label.new(bar_index, v_position_y, array.join(v_label, icon_separator), textcolor=_color, color=color_none, size=i_label_size, style=i_label_position)
array.push(_labels, my_label)
util.clear_labels(_labels, i_history_period)
else if _session
label.set_y(my_label, v_position_y)
label.set_text(my_label, array.join(v_label, icon_separator))
// ------------------------
// Drawing Fibonacci levels
// ------------------------
f_render_fibonacci (_show, _session, _is_started, _x1, _x2, _color, _top, _bottom, _level, _width, _style, _is_extend, _lines) =>
var line my_line = na
if _show
y = (_top - _bottom) * _level + _bottom
if _is_started
my_line := line.new(_x1, y, _x2, y, width=_width, color=color.new(_color, 30), style=_style)
array.push(_lines, my_line)
if _is_extend
line.set_extend(my_line, extend.right)
else if _session
line.set_y1(my_line, y)
line.set_y2(my_line, y)
f_set_line_x2(my_line, _x2)
// ------------------------
// Drawing Opening range
// ------------------------
f_render_oprange (_show, _session, _is_started, _x1, _x2, _color, _max, _is_extend, _boxes) =>
var int start_time = na
var box my_box = na
top = ta.highest(high, _max)
bottom = ta.lowest(low, _max)
is_crossover = ta.crossover(close, box.get_top(my_box))
is_crossunder = ta.crossunder(close, box.get_bottom(my_box))
if _show
if _is_started
util.clear_boxes(_boxes, math.max(0, i_history_period - 1))
start_time := time
my_box := na
else if _session
time_op = start_time + (i_o_minutes * 60 * 1000)
time_op_delay = time_op - f_get_time_by_bar(1)
if time <= time_op and time > time_op_delay
my_box := box.new(_x1, top, _x2, bottom, border_width=0, bgcolor=color.new(_color, i_o_transp))
array.push(_boxes, my_box)
if _is_extend
box.set_extend(my_box, extend.right)
my_box
else
f_set_box_right(my_box, _x2)
if is_crossover
alert('Price crossed over the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_top(my_box), "×", color=color.blue, textcolor=ac.tradingview('blue'), style=label.style_none, size=size.large)
if is_crossunder
alert('Price crossed under the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_bottom(my_box), "×", color=color.red, textcolor=ac.tradingview('red'), style=label.style_none, size=size.large)
my_box
// ------------------------
// Drawing candle
// ------------------------
f_render_candle (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _open, _x1, _x2, _boxes, _lines) =>
var box body = na
var line wick1 = na
var line wick2 = na
border_width = i_candle_border_width
cx = math.round(math.avg(_x2, _x1)) - math.round(border_width / 2)
body_color = i_candle_color == option_candle_color2 ? close > _open ? i_candle_color_g : i_candle_color_r : _color
if _show
if _is_started
body := box.new(_x1, _top, _x2, _bottom, body_color, border_width, line.style_solid, bgcolor=color.new(color.black, 100))
wick1 := i_show_candle_wick ? line.new(cx, _top, cx, _top, color=_color, width=border_width, style=line.style_solid) : na
wick2 := i_show_candle_wick ? line.new(cx, _bottom, cx, _bottom, color=_color, width=border_width, style=line.style_solid) : na
array.push(_boxes, body)
array.push(_lines, wick1)
array.push(_lines, wick2)
util.clear_boxes(_boxes, i_history_period)
util.clear_lines(_lines, i_history_period * 2)
else if _session
top = math.max(_open, close)
bottom = math.min(_open, close)
box.set_top(body, top)
box.set_bottom(body, bottom)
box.set_right(body, _x2)
box.set_border_color(body, body_color)
line.set_y1(wick1, _top)
line.set_y2(wick1, top)
f_set_line_x1(wick1, cx)
f_set_line_x2(wick1, cx)
line.set_color(wick1, body_color)
line.set_y1(wick2, _bottom)
line.set_y2(wick2, bottom)
f_set_line_x1(wick2, cx)
f_set_line_x2(wick2, cx)
line.set_color(wick2, body_color)
else if _is_ended
box.set_right(body, bar_index)
// ------------------------
// Rendering limit message
// ------------------------
f_render_limitmessage (_show, _session, _is_started, _is_ended, _x, _y, _rightbars) =>
var label my_note = na
if _show
if _is_started
if _rightbars > max_bars
my_note := label.new(_x, _y, f_message_limit_bars(_rightbars), style=label.style_label_upper_left, color=color.yellow, textalign=text.align_left, yloc=yloc.price)
else if _session
if _rightbars > max_bars
label.set_y(my_note, _y)
label.set_text(my_note, f_message_limit_bars(_rightbars))
else
label.delete(my_note)
else if _is_ended
label.delete(my_note)
true
// Rendering session
//
f_render_sessionrange (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _lines) =>
var line above_line = na
var line below_line = na
if _show
if _is_started
above_line := line.new(_x1, _top, _x2, _top, width=i_sess_border_width, style=i_sess_border_style, color=_color)
below_line := line.new(_x1, _bottom, _x2, _bottom, width=i_sess_border_width, style=i_sess_border_style, color=_color)
linefill.new(above_line, below_line, color.new(_color, i_sess_bgopacity))
array.push(_lines, above_line)
array.push(_lines, below_line)
util.clear_lines(_lines, i_history_period * 2)
if _is_extend
line.set_extend(above_line, extend.right)
line.set_extend(below_line, extend.right)
else if _session
line.set_y1(above_line, _top)
line.set_y2(above_line, _top)
line.set_x2(above_line, _x2)
line.set_y1(below_line, _bottom)
line.set_y2(below_line, _bottom)
line.set_x2(below_line, _x2)
true
else if _is_ended
true
true
// ------------------------
// Rendering session box
// ------------------------
f_render_session (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _boxes) =>
var box my_box = na
if _show
if _is_started
my_box := box.new(_x1, _top, _x2, _bottom, _color, i_sess_border_width, i_sess_border_style, bgcolor=color.new(_color, i_sess_bgopacity))
array.push(_boxes, my_box)
util.clear_boxes(_boxes, i_history_period)
if _is_extend
box.set_extend(my_box, extend.right)
else if _session
box.set_top(my_box, _top)
box.set_bottom(my_box, _bottom)
f_set_box_right(my_box, _x2)
else if _is_ended
box.set_right(my_box, bar_index)
my_box
// ------------------------
// Drawing market
// ------------------------
f_render_main (_show, _session, _is_started, _is_ended, _color, _top, _bottom) =>
var box my_box = na
var label my_note = na
var x1 = 0
var x2 = 0
var session_open = 0.0
var session_high = 0.0
var session_low = 0.0
x0_1 = ta.valuewhen(na(_session ) and _session, bar_index, 1)
x0_2 = ta.valuewhen(na(_session) and _session , bar_index, 0)
x0_d = math.abs(x0_2 - x0_1)
limit_bars = max_bars
rightbars = x0_d
if _show
if _is_started
x1 := bar_index
x2 := bar_index + (math.min(x0_d, limit_bars))
session_open := open
session_high := _top
session_low := _bottom
else if _session
true_x2 = x1 + x0_d
rightbars := true_x2 - bar_index
limit_bars := bar_index + max_bars
x2 := math.min(true_x2, limit_bars)
session_high := _top
session_low := _bottom
else if _is_ended
session_open := na
// ------------------------
// Drawing
// ------------------------
draw (_show, _session, _color, _label, _extend, _show_fib, _show_op, _lookback, _boxes_session, _lines_session, _boxes_candle_body, _lines_candle_wick, _boxes_op, _lines_fib, _labels) =>
max = f_get_period(_session, 1, _lookback)
top = ta.highest(high, max)
bottom = ta.lowest(low, max)
is_started = f_get_started(_session)
is_ended = f_get_ended(_session)
is_extend = _extend != option_no
= f_render_main(_show, _session, is_started, is_ended, _color, top, bottom)
if i_sess_box_style == 'Box'
f_render_session(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _boxes_session)
if i_sess_box_style == 'Sandwich'
f_render_sessionrange(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _lines_session)
if i_show_candle
f_render_candle(_show, _session, is_started, is_ended, _color, top, bottom, _open, x1, x2, _boxes_candle_body, _lines_candle_wick)
if i_label_show
f_render_label(_show, _session, is_started, _color, top, bottom, _label, _labels)
if _show_op
f_render_oprange(_show, _session, is_started, x1, x2, _color, max, is_extend, _boxes_op)
if _show_fib
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.500, 2, line.style_solid, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.628, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.382, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
util.clear_lines(_lines_fib, i_history_period * 3)
f_render_limitmessage(_show, _session, is_started, is_ended, x1, bottom, _rightbars)
///////////////////
// Calculating
///////////////////
string tz = (i_tz == option_no or i_tz == '') ? na : i_tz
int sess1 = time(timeframe.period, i_sess1, tz)
int sess2 = time(timeframe.period, i_sess2, tz)
int sess3 = time(timeframe.period, i_sess3, tz)
int sess4 = time(timeframe.period, i_sess4, tz)
///////////////////
// Plotting
///////////////////
var sess1_box = array.new()
var sess2_box = array.new()
var sess3_box = array.new()
var sess4_box = array.new()
var sess1_line = array.new()
var sess2_line = array.new()
var sess3_line = array.new()
var sess4_line = array.new()
var sess1_op = array.new()
var sess2_op = array.new()
var sess3_op = array.new()
var sess4_op = array.new()
var sess1_fib = array.new()
var sess2_fib = array.new()
var sess3_fib = array.new()
var sess4_fib = array.new()
var sess1_candle_body = array.new()
var sess2_candle_body = array.new()
var sess3_candle_body = array.new()
var sess4_candle_body = array.new()
var sess1_candle_wick = array.new()
var sess2_candle_wick = array.new()
var sess3_candle_wick = array.new()
var sess4_candle_wick = array.new()
var sess1_labels = array.new()
var sess2_labels = array.new()
var sess3_labels = array.new()
var sess4_labels = array.new()
= draw(i_show_sess1, sess1, i_sess1_color, i_sess1_label, i_sess1_extend, i_sess1_fib, i_sess1_op, i_lookback, sess1_box, sess1_line, sess1_candle_body, sess1_candle_wick, sess1_op, sess1_fib, sess1_labels)
= draw(i_show_sess2, sess2, i_sess2_color, i_sess2_label, i_sess2_extend, i_sess2_fib, i_sess2_op, i_lookback, sess2_box, sess2_line, sess2_candle_body, sess2_candle_wick, sess2_op, sess2_fib, sess2_labels)
= draw(i_show_sess3, sess3, i_sess3_color, i_sess3_label, i_sess3_extend, i_sess3_fib, i_sess3_op, i_lookback, sess3_box, sess3_line, sess3_candle_body, sess3_candle_wick, sess3_op, sess3_fib, sess3_labels)
= draw(i_show_sess4, sess4, i_sess4_color, i_sess4_label, i_sess4_extend, i_sess4_fib, i_sess4_op, i_lookback, sess4_box, sess4_line, sess4_candle_body, sess4_candle_wick, sess4_op, sess4_fib, sess4_labels)
is_positive_bar = close > open
color c_barcolor = na
color c_plotcandle = na
c_sess1_barcolor = (is_sess1) ? (is_positive_bar ? i_sess1_barcolor1 : i_sess1_barcolor2) : na
c_sess2_barcolor = (is_sess2) ? (is_positive_bar ? i_sess2_barcolor1 : i_sess2_barcolor2) : na
c_sess3_barcolor = (is_sess3) ? (is_positive_bar ? i_sess3_barcolor1 : i_sess3_barcolor2) : na
c_sess4_barcolor = (is_sess4) ? (is_positive_bar ? i_sess4_barcolor1 : i_sess4_barcolor2) : na
if (i_sess1_chart != option_chart_x) and is_sess1
c_barcolor := i_sess1_barcolor ? c_sess1_barcolor : na
c_plotcandle := i_sess1_plotcandle ? c_sess1_barcolor : na
if (i_sess2_chart != option_chart_x) and is_sess2
c_barcolor := i_sess2_barcolor ? c_sess2_barcolor : na
c_plotcandle := i_sess2_plotcandle ? c_sess2_barcolor : na
if (i_sess3_chart != option_chart_x) and is_sess3
c_barcolor := i_sess3_barcolor ? c_sess3_barcolor : na
c_plotcandle := i_sess3_plotcandle ? c_sess3_barcolor : na
if (i_sess4_chart != option_chart_x) and is_sess4
c_barcolor := i_sess4_barcolor ? c_sess4_barcolor : na
c_plotcandle := i_sess4_plotcandle ? c_sess4_barcolor : na
barcolor(c_barcolor)
plotcandle(open, high, low, close, color=is_positive_bar ? color_none : c_plotcandle, bordercolor=c_plotcandle, wickcolor=c_plotcandle)
////////////////////
// Alerts
////////////////////
// Session alerts
sess1_started = is_sess1 and not is_sess1 , sess1_ended = not is_sess1 and is_sess1
sess2_started = is_sess2 and not is_sess2 , sess2_ended = not is_sess2 and is_sess2
sess3_started = is_sess3 and not is_sess3 , sess3_ended = not is_sess3 and is_sess3
sess4_started = is_sess4 and not is_sess4 , sess4_ended = not is_sess4 and is_sess4
alertcondition(sess1_started, 'Session #1 started')
alertcondition(sess1_ended, 'Session #1 ended')
alertcondition(sess2_started, 'Session #2 started')
alertcondition(sess2_ended, 'Session #2 ended')
alertcondition(sess3_started, 'Session #3 started')
alertcondition(sess3_ended, 'Session #3 ended')
alertcondition(sess4_started, 'Session #4 started')
alertcondition(sess4_ended, 'Session #4 ended')
alertcondition((not is_sess1) and ta.crossover(close, sess1_high), 'Session #1 High crossed (after session closed)')
alertcondition((not is_sess1) and ta.crossunder(close, sess1_low), 'Session #1 Low crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossover(close, sess2_high), 'Session #2 High crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossunder(close, sess2_low), 'Session #2 Low crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossover(close, sess3_high), 'Session #3 High crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossunder(close, sess3_low), 'Session #3 Low crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossover(close, sess4_high), 'Session #4 High crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossunder(close, sess4_low), 'Session #4 Low crossed (after session closed)')
// Alerts visualized
if i_alert1_show
if i_show_sess1
if sess1_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess1_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess2
if sess2_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess2_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess3
if sess3_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess3_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess4
if sess4_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess4_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
plot(i_alert3_show ? sess1_high : na, 'sess1_high', style=plot.style_linebr, color=i_sess1_color)
plot(i_alert3_show ? sess1_low : na, 'sess1_low' , style=plot.style_linebr, color=i_sess1_color, linewidth=2)
plot(i_alert3_show ? sess2_high : na, 'sess2_high', style=plot.style_linebr, color=i_sess2_color)
plot(i_alert3_show ? sess2_low : na, 'sess2_low' , style=plot.style_linebr, color=i_sess2_color, linewidth=2)
plot(i_alert3_show ? sess3_high : na, 'sess3_high', style=plot.style_linebr, color=i_sess3_color)
plot(i_alert3_show ? sess3_low : na, 'sess3_low' , style=plot.style_linebr, color=i_sess3_color, linewidth=2)
plot(i_alert3_show ? sess4_high : na, 'sess4_high', style=plot.style_linebr, color=i_sess4_color)
plot(i_alert3_show ? sess4_low : na, 'sess4_low' , style=plot.style_linebr, color=i_sess4_color, linewidth=2)
plotshape(i_alert3_show and (not is_sess1) and ta.crossover(close, sess1_high) ? sess1_high : na, 'cross sess1_high', color=i_sess1_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess1) and ta.crossunder(close, sess1_low) ? sess1_low : na, 'cross sess1_low', color=i_sess1_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossover(close, sess2_high) ? sess2_high : na, 'cross sess2_high', color=i_sess2_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossunder(close, sess2_low) ? sess2_low : na, 'cross sess2_low', color=i_sess2_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossover(close, sess3_high) ? sess3_high : na, 'cross sess3_high', color=i_sess3_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossunder(close, sess3_low) ? sess3_low : na, 'cross sess3_low', color=i_sess3_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossover(close, sess4_high) ? sess4_high : na, 'cross sess4_high', color=i_sess4_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossunder(close, sess4_low) ? sess4_low : na, 'cross sess4_low', color=i_sess4_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
RSI Divergence ProjectionRSI Divergence Projection
Go beyond traditional, lagging indicators with this advanced RSI Divergence tool. It not only identifies four types of confirmed RSI divergence but also introduces a unique, forward-looking engine. This engine spots potential divergences as they form on the current candle and then projects the exact price threshold required to validate them.
Our core innovation is the Divergence Projection Line, a clean, clutter-free visualization that extends this calculated price target into the future, providing a clear and actionable level for your trading decisions.
The Core Logic: Understanding RSI Divergence
For those new to the concept, RSI Divergence is a powerful tool used to spot potential market reversals or continuations. It occurs when the price of an asset is moving in the opposite direction of the Relative Strength Index (RSI). This indicator automatically detects and plots four key types:
Regular Bullish Divergence: Price prints a lower low, but the RSI prints a higher low. This often signals that bearish momentum is fading and a potential reversal to the upside is near.
Hidden Bullish Divergence: Price prints a higher low, but the RSI prints a lower low. This is often seen in an uptrend and can signal a continuation of the bullish move.
Regular Bearish Divergence: Price prints a higher high, but the RSI prints a lower high. This suggests that bullish momentum is weakening and a potential reversal to the downside is coming.
Hidden Bearish Divergence: Price prints a lower high, but the RSI prints a higher high. This is often seen in a downtrend and can signal a continuation of the bearish move.
Confirmed divergences are plotted with solid-colored lines on the price chart and marked with a "B" (Bearish/Bullish) or "HB" (Hidden Bearish/Hidden Bullish) label.
The Core Innovation: The Divergence Projection
This is where the indicator truly shines and sets itself apart. Instead of waiting for a pivot point to be confirmed, our engine analyzes the current, unclosed candle.
Potential Divergence Detection: When the indicator notices that the current price and RSI are setting up for a potential divergence against the last confirmed pivot, it will draw a dashed line on the chart. This gives you a critical head-start before the signal is confirmed.
The Projection Line (Our Innovation): This is the game-changer. Rather than cluttering your chart with messy labels, the indicator calculates the exact closing price the next candle needs to achieve to make the current RSI level equal to the RSI of the last pivot.
It then projects a clean, horizontal dashed line at this price level into the future.
Attached to the end of this line is a single, consolidated label that tells you the type of potential divergence and the exact threshold price.
This unique visualization transforms a vague concept into a precise, actionable price target, completely free of chart clutter.
How to Use This Indicator
1. Trading Confirmed Divergences:
Look for the solid lines and the "B" or "HB" labels that appear after a candle has closed and a pivot is confirmed.
A Regular Bullish divergence can be an entry signal for a long position, often placed after the confirmation candle closes.
A Regular Bearish divergence can be an entry signal for a short position.
Hidden Divergences can be used as confirmation to stay in a trade or to enter a trade in the direction of the prevailing trend.
2. Using the Divergence Projection for a Tactical Advantage:
When a dashed line appears on the current price action, you are seeing a potential divergence in real-time.
Look to the right of the current candle for the Projection Line. The price level of this line is your key level to watch.
Example (Potential Bullish Divergence): You see a dashed green line forming from a previous low to the current lower low. To the right, you see a horizontal line projected with a label: "Potential Bull Div | Thresh: 10,750.50".
Interpretation: This means that if the next candle closes below 10,750.50, the RSI will not be high enough to form a divergence. However, if the price pushes up and the next candle closes above 10,750.50, the bullish divergence remains intact and is more likely to be confirmed. This gives you a concrete price level to monitor for entry or exit decisions.
How the Projection Engine Works: A Deeper Dive
To fully trust this tool, it's helpful to understand the logic behind it. The projection engine is not based on guesswork or repainting; it's based on a precise mathematical reverse-engineering of the RSI formula.
The Concept: The engine calculates the "tipping point." The Threshold Price is the exact closing price at which the new RSI value would be identical to the RSI value of the previous pivot point. It answers the question: "For this potential divergence to remain valid, where does the next candle need to close?"
The Technicals: The script takes the target RSI from the last pivot, reverse-engineers the formula to find the required average gain/loss ratio, and then solves for the one unknown variable: the gain or loss needed on the next candle. This required price change is then added to or subtracted from the previous close to determine the exact threshold price.
This calculation provides the precise closing price needed to hit our target, which is then plotted as the clean and simple Projection Line on your chart.
Features and Customization
- RSI Settings: Adjust the RSI period and source.
- Divergence Detection: Fine-tune the pivot lookback periods and the min/max range for detecting divergences.
- Price Source: Choose whether to detect divergences using candle Wicks or Bodies.
- Display Toggles: Enable or disable any of the four divergence types, as well as the entire projection engine, to keep your chart as clean as you need it.
Summary of Advantages
- Proactive Signals: Get ahead of the market by seeing potential divergences before they are confirmed.
- Unprecedented Clarity: Our unique Projection Line eliminates chart clutter from overlapping labels.
- Actionable Data: The threshold price provides a specific, objective level to watch, removing guesswork.
- Fully Customizable: Tailor the indicator's settings to match any timeframe or trading strategy.
- All-in-One Tool: No need for a separate RSI indicator; everything you need is displayed directly and cleanly on the price action.
We hope this tool empowers you to make more informed and timely trading decisions. Happy trading
EMA–VWAP Strategy (Confirmed crosses, 1 trade/cross)Wait for 10 and 20 ema to cross
Buy between 10 and 20
wait for 20 and 50 to cross
buy at vwap
10/20/50 ema and vwap is plotted
Globex Trap w/ percentage [SLICKRICK]Globex Trap w/ Percentage
Overview
The Globex Trap w/ Percentage indicator is a powerful tool designed to help traders identify high-probability trading opportunities by analyzing price action during the Globex (overnight) session and regular trading hours. By combining Globex session ranges with Supply & Demand zones, this indicator highlights potential "trap" areas where significant price reactions may occur. Additionally, it calculates the Globex session range as a percentage of the daily Average True Range (ATR), providing valuable context for assessing market volatility.
This indicator is ideal for traders in futures markets or other instruments traded during Globex sessions, offering a visual and analytical edge for spotting key price levels and potential reversals or breakouts.
Key Features
Globex Session Tracking:
Visualizes the high and low of the Globex session (default: 3:00 PM to 6:30 AM PST) with customizable time settings.
Displays a semi-transparent box to mark the Globex range, with labels for "Globex High" and "Globex Low."
Calculates the Globex range as a percentage of the daily ATR, displayed as a label for quick reference.
Supply & Demand Zones:
Identifies Supply & Demand zones during regular trading hours (default: 6:00 AM to 8:00 AM PST) with customizable time settings.
Draws semi-transparent boxes to highlight these zones, aiding in the identification of key support and resistance areas.
Trap Area Identification:
Highlights potential trap zones where Globex ranges and Supply & Demand zones overlap, indicating areas where price may reverse or consolidate due to trapped traders.
Customizable Settings:
Adjust Globex and Supply & Demand session times to suit your trading preferences.
Toggle visibility of Globex and Supply & Demand zones independently.
Customize box colors for better chart readability.
Set the lookback period (default: 10 days) to control how many historical zones are displayed.
Configure the ATR length (default: 14) for the percentage calculation.
PST Timezone Default:
All times are based on Pacific Standard Time (PST) by default, ensuring accurate session tracking for users in this timezone or those aligning with U.S. West Coast market hours.
Recommended Usage
Timeframes: Best used on 1-hour charts or lower (e.g., 15-minute, 5-minute) for precise entry and exit points.
Markets: Optimized for futures (e.g., ES, NQ, CL) and other instruments traded during Globex sessions.
Historical Data: Ensure at least 10 days of historical data for optimal visualization of zones.
Strategy Integration: Use the indicator to identify potential reversals or breakouts at Globex highs/lows or Supply & Demand zones. The ATR percentage provides context for whether the Globex range is significant relative to typical daily volatility.
How It Works
Globex Session:
Tracks the high and low prices during the user-defined Globex session (default: 3:00 PM to 6:30 AM PST).
When the session ends, a box is drawn from the start to the end of the session, capturing the high and low prices.
Labels are placed at the midpoint of the session, showing "Globex High," "Globex Low," and the range as a percentage of the daily ATR (e.g., "75.23% of Daily ATR").
Supply & Demand Zones:
Tracks the high and low prices during the user-defined regular trading hours (default: 6:00 AM to 8:00 AM PST).
Draws a box to mark these zones, which often act as key support or resistance levels.
ATR Percentage:
Calculates the Globex range (high minus low) and divides it by the daily ATR to express it as a percentage.
This metric helps traders gauge whether the overnight price movement is significant compared to the instrument’s typical volatility.
Time Handling:
Uses PST (UTC-8) for all time calculations, ensuring accurate session timing for users aligning with this timezone.
Properly handles overnight sessions that cross midnight, ensuring seamless tracking.
Input Settings
Globex Session Settings:
Show Globex Session: Enable/disable Globex session visualization (default: true).
Globex Start/End Time: Set the start and end times for the Globex session (default: 3:00 PM to 6:30 AM PST).
Globex Box Color: Customize the color of the Globex session box (default: semi-transparent gray).
Supply & Demand Zone Settings:
Show Supply & Demand Zone: Enable/disable zone visualization (default: true).
Zone Start/End Time: Set the start and end times for Supply & Demand zones (default: 6:00 AM to 8:00 AM PST).
Zone Box Color: Customize the color of the zone box (default: semi-transparent aqua).
General Settings:
Days to Look Back: Number of historical days to display zones (default: 10).
ATR Length: Period for calculating the daily ATR (default: 14).
Notes
All times are in Pacific Standard Time (PST). Adjust the start and end times if your market operates in a different timezone or if you prefer different session windows.
The indicator is optimized for instruments with active Globex sessions, such as futures. Results may vary for non-24/5 markets.
A typo in the label "Globe Low" (should be "Globex Low") will be corrected in future updates.
Ensure your TradingView chart is set to display sufficient historical data to view the full lookback period.
Why Use This Indicator?
The Globex Trap w/ Percentage indicator provides a unique combination of session-based range analysis, Supply & Demand zone identification, and volatility context via the ATR percentage. Whether you’re a day trader, swing trader, or scalper, this tool helps you:
Pinpoint key price levels where institutional traders may act.
Assess the significance of overnight price movements relative to daily volatility.
Identify potential trap zones for high-probability setups.
Customize the indicator to fit your trading style and market preferences.
HorizonSigma Pro [CHE]HorizonSigma Pro
Disclaimer
Not every timeframe will yield good results . Very short charts are dominated by microstructure noise, spreads, and slippage; signals can flip and the tradable edge shrinks after costs. Very high timeframes adapt more slowly, provide fewer samples, and can lag regime shifts. When you change timeframe, you also change the ratios between horizon, lookbacks, and correlation windows—what works on M5 won’t automatically hold on H1 or D1. Liquidity, session effects (overnight gaps, news bursts), and volatility do not scale linearly with time. Always validate per symbol and timeframe, then retune horizon, z-length, correlation window, and either the neutral band or the z-threshold. On fast charts, “components” mode adapts quicker; on slower charts, “super” reduces noise. Keep prior-shift and calibration enabled, monitor Hit Rate with its confidence interval and the Brier score, and execute only on confirmed (closed-bar) values.
For example, what do “UP 61%” and “DOWN 21%” mean?
“UP 61%” is the model’s estimated probability that the close will be higher after your selected horizon—directional probability, not a price target or profit guarantee. “DOWN 21%” still reports the probability of up; here it’s 21%, which implies 79% for down (a short bias). The label switches to “DOWN” because the probability falls below your short threshold. With a neutral-band policy, for example ±7%, signals are: Long above 57%, Short below 43%, Neutral in between. In z-score mode, fixed z-cutoffs drive the call instead of percentages. The arrow length on the chart is an ATR-scaled projection to visualize reach; treat it as guidance, not a promise.
Part 1 — Scientific description
Objective.
The indicator estimates the probability that price will be higher after a user-defined horizon (a chosen number of bars) and emits long, short, or neutral decisions under explicit thresholds. It combines multi‑feature, z‑normalized inputs, adaptive correlation‑based weighting, a prior‑shifted sigmoid mapping, optional rolling probability calibration, and repaint‑safe confirmation. It also visualizes an ATR‑scaled forward projection and prints a compact statistics panel.
Data and labeling.
For each bar, the target label is whether price increased over the past chosen horizon. Learning is deliberately backward‑looking to avoid look‑ahead: features are associated with outcomes that are only known after that horizon has elapsed.
Feature engineering.
The feature set includes momentum, RSI, stochastic %K, MACD histogram slope, a normalized EMA(20/50) trend spread, ATR as a share of price, Bollinger Band width, and volume normalized by its moving average. All features are standardized over rolling windows. A compressed “super‑feature” is available that aggregates core trend and momentum components while penalizing excessive width (volatility). Users can switch between a “components” mode (weighted sum of individual features) and a “super” mode (single compressed driver).
Weighting and learning.
Weights are the rolling correlations between features (evaluated one horizon ago) and realized directional outcomes, smoothed by an EMA and optionally clamped to a bounded range to stabilize outliers. This produces an adaptive, regime‑aware weighting without explicit machine‑learning libraries.
Scoring and probability mapping.
The raw score is either the weighted component sum or the weighted super‑feature. The score is standardized again and passed through a sigmoid whose steepness is user‑controlled. A “prior shift” moves the sigmoid’s midpoint to the current base rate of up moves, estimated over the evaluation window, so that probabilities remain well‑calibrated when markets drift bullish or bearish. Probabilities and standardized scores are EMA‑smoothed for stability.
Decision policy.
Two modes are supported:
- Neutral band: go long if the probability is above one half plus a user‑set band; go short if it is below one half minus that band; otherwise stay neutral.
- Z‑score thresholds: use symmetric positive/negative cutoffs on the standardized score to trigger long/short.
Repaint protection.
All values used for decisions can be locked to confirmed (closed) bars. Intrabar updates are available as a preview, but confirmed values drive evaluation and stats.
Calibration.
An optional rolling linear calibration maps past confirmed probabilities to realized outcomes over the evaluation window. The mapping is clipped to the unit interval and can be injected back into the decision logic if desired. This improves reliability (probabilities that “mean what they say”) without necessarily improving raw separability.
Evaluation metrics.
The table reports: hit rate on signaled bars; a Wilson confidence interval for that hit rate at a chosen confidence level; Brier score as a measure of probability accuracy; counts of long/short trades; average realized return by side; profit factor; net return; and exposure (signal density). All are computed on rolling windows consistent with the learning scheme.
Visualization.
On the chart, an arrowed projection shows the predicted direction from the current bar to the chosen horizon, with magnitude scaled by ATR (optionally scaled by the square‑root of the horizon). Labels display either the decision probability or the standardized score. Neutral states can display a configurable icon for immediate recognition.
Computational properties.
The design relies on rolling means, standard deviations, correlations, and EMAs. Per‑bar cost is constant with respect to history length, and memory is constant per tracked series. Graphical objects are updated in place to obey platform limits.
Assumptions and limitations.
The method is correlation‑based and will adapt after regime changes, not before them. Calibration improves probability reliability but not necessarily ranking power. Intrabar previews are non‑binding and should not be evaluated as historical performance.
Part 2 — Trader‑facing description
What it does.
This tool tells you how likely price is to be higher after your chosen number of bars and converts that into Long / Short / Neutral calls. It learns, in real time, which components—momentum, trend, volatility, breadth, and volume—matter now, adjusts their weights, and shows you a probability line plus a forward arrow scaled by volatility.
How to set it up.
1) Choose your horizon. Intraday scalps: 5–10 bars. Swings: 10–30 bars. The default of 14 bars is a balanced starting point.
2) Pick a feature mode.
- components: granular and fast to adapt when leadership rotates between signals.
- super: cleaner single driver; less noise, slightly slower to react.
3) Decide how signals are triggered.
- Neutral band (probability based): intuitive and easy to tune. Widen the band for fewer, higher‑quality trades; tighten to catch more moves.
- Z‑score thresholds: consistent numeric cutoffs that ignore base‑rate drift.
4) Keep reliability helpers on. Leave prior shift and calibration enabled to stabilize probabilities across bullish/bearish regimes.
5) Smoothing. A short EMA on the probability or score reduces whipsaws while preserving turns.
6) Overlay. The arrow shows the call and a volatility‑scaled reach for the next horizon. Treat it as guidance, not a promise.
Reading the stats table.
- Hit Rate with a confidence interval: your recent accuracy with an uncertainty range; trust the range, not only the point.
- Brier Score: lower is better; it checks whether a stated “70%” really behaves like 70% over time.
- Profit Factor, Net Return, Exposure: quick triage of tradability and signal density.
- Average Return by Side: sanity‑check that the long and short calls each pull their weight.
Typical adjustments.
- Too many trades? Increase the neutral band or raise the z‑threshold.
- Missing the move? Tighten the band, or switch to components mode to react faster.
- Choppy timeframe? Lengthen the z‑score and correlation windows; keep calibration on.
- Volatility regime change? Revisit the ATR multiplier and enable square‑root scaling of horizon.
Execution and risk.
- Size positions by volatility (ATR‑based sizing works well).
- Enter on confirmed values; use intrabar previews only as early signals.
- Combine with your market structure (levels, liquidity zones). This model is statistical, not clairvoyant.
What it is not.
Not a black‑box machine‑learning model. It is transparent, correlation‑weighted technical analysis with strong attention to probability reliability and repaint safety.
Suggested defaults (robust starting point).
- Horizon 14; components mode; weight EMA 10; correlation window 500; z‑length 200.
- Neutral band around seven percentage points, or z‑threshold around one‑third of a standard deviation.
- Prior shift ON, Calibration ON, Use calibrated for decisions OFF to start.
- ATR multiplier 1.0; square‑root horizon scaling ON; EMA smoothing 3.
- Confidence setting equivalent to about 95%.
Disclaimer
No indicator guarantees profits. HorizonSigma Pro is a decision aid; always combine with solid risk management and your own judgment. Backtest, forward test, and size responsibly.
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Enhance your trading precision and confidence 🚀
Best regards
Chervolino
Standardized Cumulative Deltas [LuxAlgo]The Standardized Cumulative Deltas tool allows traders to compare the cumulative standardized open-close difference for up to 10 different tickers, allowing them to visualize the general sentiment for all selected tickers.
These results allow the construction of two areas showing the average or extreme bullish and bearish cumulative change for all enabled tickers, providing a summarized view of the overall ticker group sentiment.
🔶 USAGE
This tool is meant to give a full picture of the individuals and/or overall selected tickers, and unlike classical indicators, the displayed series of values is not meant to be directly interpreted over time.
Given the selected lookback period, a majority of observations being above 0 indicate an overall bullish market for the asset.
By default, the auto lookback period feature is enabled, allowing the tool to use all the visible bars for its calculations. Traders can also set the lookback period manually. The above chart uses a fixed lookback period of 500.
Up to 10 tickers can be used. While major cryptocurrencies are set by default, the users can set a specific basket of assets, such as US equities, forex pairs, commodities, etc.
🔹 Densities
The provided areas, here called densities, can be used to get an overall sentiment of the selected tickers. The upper density (bullish) processes positive deltas, while the lower one (bearish) processes negative ones.
Interpretation is subject to the selected "Density Mode".
Average: Densities track the average bullish/bearish cumulative deltas for the selected tickers. For example, a more prominent bullish density would indicate that, on average, cumulative deltas were positive across the tickers.
Envelope: Densities track the extreme values made by bullish/bearish cumulative deltas for the selected tickers. Here, a more prominent density would indicate more volatile bullish/bearish movements, depending on the density.
🔹 Dashboard
The tool features a dashboard with active tickers and their respective colors for traders' convenience.
🔶 DETAILS
🔹 Densities
Densities are obtained by applying a forward-backward exponential moving average on the average, or the highest/lowest cumulative series, depending on the selected Density Mode.
The resulting densities are smoothed by the "Smoothing" parameter located in the Settings panel, with higher values returning smoother envelopes with less variability.
Do note that the smoothing method used here is subject to repainting.
🔶 SETTINGS
Lookback: Select the lookback period and enable/disable the Auto Lookback feature
Tickers: Enable/disable and select up to 10 tickers and their colors
Density Mode: Determine how densities are calculated
🔹 Dashboard
Show Dashboard: Enable/disable the dashboard
Position: Select the dashboard position
Size: Select the dashboard size
🔹 Style
Density: Enable/disable the density areas
Bullish Density: Select the color of the top density area
Bearish Density: Select the color of the bottom density area
Smoothing: Select the smoothing constant for the EMA calculation
Liquidity Sweep Breakout - LSBLiquidity Sweep Breakout - LSB
A professional session-based breakout system designed for OANDA:USDJPY and other JPY pairs.
Not guesswork, but precision - built on detailed observation of institutional moves to capture clear trade direction daily.
Master the Market’s Daily Bank Flow.
---
Strategy Detail:
I discovered this strategy after carefully studying how Japanese banks influence the forex market during their daily settlement period. Banks are some of the biggest players in the financial world, and when they adjust or settle their accounts in the morning, it often creates a push in the market. From years of observation, I noticed a consistent pattern, once banks finish their settlements, the market usually continues moving in the same direction that was formed right after those actions. This daily banking flow often sets the tone for the entire trading session, especially for JPY pairs like USDJPY.
To capture this move, I built the indicator so that it follows the bank-driven trend with clear rules for entries, stop-loss (SL), and take-profit (TP). The system is designed with professional risk management in mind. By default, it assumes a $10,000 account size, risks only 1% of that balance per trade, and targets a 1:1.5 reward-to-risk ratio. This means for every $100 risked, the potential profit is $150. Such controlled risk makes the system safer and more sustainable for long-term traders. At the same time, users are not limited to this setup, they can adjust the account balance in the settings, and the indicator will automatically recalculate the lot size and risk levels based on their own capital. This ensures the strategy works for small accounts and larger accounts alike.
🌍 Why It Works
Fundamentally driven: Based on **daily Japanese banking settlement flows**.
Session-specific precision: Targets the exact window when USDJPY liquidity reshapes.
Risk-managed: Always calculates lot size based on account and risk preferences.
Automatable: With webhook + MT5 EA, it can be fully hands-free.
---
✅ Recommended
Pair: USDJPY (best observed behavior).
Timeframe: 3-Minute chart.
Platform: TradingView Premium (for webhooks).
Execution: MT5 via EA.
---
🔎 Strategy Concept
The Tokyo Magic Breakout (TMB) is built on years of session observation and the unique daily rhythm of the Japanese banking system.
Every morning between 5:50 AM – 6:10 AM PKT (09:50 – 10:10 JST), Japanese banks perform daily reconciliation and settlement. This often sets the tone for the USDJPY direction of the day.
This strategy isolates that critical moment of liquidity adjustment and waits for a clean breakout confirmation. Instead of chasing noise, it executes only when price action is aligned with the Tokyo market’s hidden flows.
---
🕒 Timing Logic
Session Start: 5:00 AM PKT (Tokyo market open range).
Magic Candle: The 5:54 AM PKT candle is marked as the reference “breakout selector.”
Checkpoints: First confirmation at 6:30 AM PKT, then every 15 minutes until 8:30 AM PKT.
* If price stays inside the magic range → wait.
* If a breakout happens but the candle wick touches the range → wait for the next checkpoint.
* If by 8:30 AM PKT no clean breakout occurs → the day is marked as No Trade Day (NTD).
👉 Recommended timeframe: 3-Minute chart (3M) for precise signals.
---
📈 Trade Execution
Entry: Clean break above/below the magic candle’s range.
Stop-Loss: Opposite side of the Tokyo session high/low.
Take-Profit: Calculated by Reward\:Risk ratio (default 1.5:1).
Lot Size: Auto-calculated based on your risk model:
* Fixed Dollar
* % of Equity
* Conservative (minimum of both).
Visuals include:
✅ Entry/SL/TP lines
✅ Shaded risk (red) and reward (green) zones
✅ Trade labels (Buy/Sell with lot size & levels)
✅ TP/SL hit markers
---
🔔 Alerts & Automation (AutoTMB)
This strategy is fully automation-ready with EA + MT5:
1. Enable alerts in TMB settings.
2. Insert your PineConnector License Key.
3. Configure your risk management preferences.
4. Create a TradingView alert → in the message box simply type:
Pine Script®
{{alert_message}}
and set the EA webhook.
Now, every breakout trade (with exact entry, SL, TP, and lot size) is sent instantly.
👉 On your MT5:
* Install the EA.
* Use the same license key.
* Run it on a VPS or local MT5 terminal.
You now have a hands-free trading system: AutoTMB.
Quarterly-Inspired EMA Swing Strategy🚀 Quarterly EMA Strategy: Simplified
This strategy uses quarterly trends and pullbacks to EMAs (Exponential Moving Averages) to buy low and sell high in strong uptrends (longs) or short weak stocks in strong downtrends.
⸻
🔧 Core Setup
• Timeframe: Quarterly (1 candle = 3 months or ~65 trading days).
• Stocks: Liquid NSE F&O stocks (e.g., Reliance, Bajaj Finance, Tata Motors, etc.).
• Indicators Used:
• 10-quarter EMA → Shorter-term trend.
• 21-quarter EMA → Long-term trend.
• 13-week EMA → Weekly confirmation.
• ATR → For stop-loss.
• VIX → Volatility control.
• Relative Strength vs Nifty → Filter strong/weak stocks.
⸻
🟢 LONG SETUP (Buy on Pullback in Uptrend)
✅ Conditions:
1. Quarterly Trend is Bullish
Price > 10Q EMA > 21Q EMA
2. Pullback Happens
Price closes within 3% of 10Q or 21Q EMA, or touches it and bounces.
• E.g., Stock close = 8200, 10Q EMA = 8000 → Pullback = Valid (2.5% gap)
3. Previous Trend is Strong
• Last 1-2 quarters were making higher highs OR closing well above 10Q EMA
4. Candle Shows Rejection
• Lower wick (buying pressure from EMA)
• Small body (<5% total candle range)
5. Market Support Filters
• Nifty > its 4-quarter EMA (sloping upward)
• India VIX < 20 (low panic)
• Stock’s last 2 quarters’ return > 1.1× Nifty’s return
6. Weekly Confirmation
• Price > 13-week EMA
• 13W EMA is rising
• Bullish pattern in last 2 candles
• Volume ≥ 75% of 20-week average
⸻
📈 Example (Bajaj Finance):
• Close: 8200,
• 10Q EMA: 8000 (bullish),
• 21Q EMA: 7800
• Weekly price > 13W EMA → Confirmation ✅
⸻
🎯 Trade Plan (Long):
• Entry: 8200 (Quarterly) or near 13W EMA (Weekly)
• Stop-Loss: 2× ATR below 21Q EMA or candle low
• Target: 2:1 reward
• Exit 1: Book 50% at target
• Exit 2: Trail 21Q EMA
• Optional Hedge: Buy Nifty PUT if VIX > 15
⸻
🔴 SHORT SETUP (Sell on Pullback in Downtrend)
✅ Conditions:
1. Quarterly Trend is Bearish
Price < 10Q EMA < 21Q EMA
2. Pullback to EMA
Price closes within 3% of 10Q or 21Q EMA, or touches and gets rejected
3. Prior Trend is Down
Last 1-2 quarters had lower lows or closing >5% below 10Q EMA
4. Bearish Candle Setup
• Upper wick (rejection from EMA)
• Small body
5. Market Support Filters
• Nifty < its 4-quarter EMA (sloping down)
• India VIX < 20
• Stock’s 2-quarter return < 0.9× Nifty’s return
6. Weekly Confirmation
• Price < 13-week EMA
• 13W EMA is falling
• Bearish candles (engulfing, lower highs)
• Volume ≥ 75% of 20-week average
⸻
📉 Example (Vodafone Idea):
• Close: ₹8
• 10Q EMA: ₹8.2 → Close is 2.5% below
• Weekly close < 13W EMA
• Bearish candle → Confirmation ✅
⸻
🔻 Trade Plan (Short):
• Entry: 8
• Stop-Loss: 2× ATR above 21Q EMA or candle high
• Target: 2:1 reward
• Exit 1: Book 50% at target
• Exit 2: Trail 21Q EMA
• Optional Hedge: Buy Nifty CALL if VIX > 15
⸻
📊 Position Sizing (Same for Long & Short):
• Risk per trade: 0.5–1% of total capital
• Example:
• Capital = ₹10 lakh
• Risk = ₹10,000
• Stop = 800 points → Buy 12 shares
⸻
✅ Exit Rules Summary
Trend Display Table (with Change Alerts)📌 Indicator: Trend Display Table (with Change Alerts)
This indicator helps identify trend direction based on a 15-minute 20 SMA compared against a 10 EMA applied to that SMA.
Trend Logic:
Bullish → 20 SMA crosses above 10 EMA (on SMA values)
Bearish → 20 SMA crosses below 10 EMA (on SMA values)
Neutral → No crossover (trend continues from previous state)
Display:
A compact trend table appears on the chart (top-right), showing the current trend with customizable colors, font size, and background.
Alerts:
Alerts are triggered only when the trend changes (from Bullish → Bearish or Bearish → Bullish).
This prevents repeated alerts on every bar.
✅ Useful for:
Confirming higher timeframe trend bias
Filtering trades in choppy markets
Getting notified instantly when the trend flips
Deviation from Mid MA5 & MA10 (%)Title:
Deviation from Mid-Price MA5 & MA10 (%)
Description:
This script calculates and displays the percentage deviation of the current mid-price from its 5-day and 10-day simple moving averages.
The mid-price is defined as the average of the open and close prices: (Open + Close) / 2
Instead of relying on traditional close-based MAs, this version uses mid-price to better reflect actual price flow by incorporating both the opening and closing values.
Main features:
Displays % deviation from both 5-day and 10-day mid-price moving averages
Better alignment with intraday reality due to gap-sensitive mid-price base
Smooths out erratic closing spikes for clearer signals
Helps identify overextended moves and potential pullback zones
Included lines:
Deviation from 5-day Mid MA
Deviation from 10-day Mid MA
Zero baseline for reference
Recommended for:
Traders seeking a cleaner measure of price deviation
Short-term pullback or re-entry strategy users
Anyone analyzing steady, low-volatility uptrends
Ray Dalio's All Weather Strategy - Portfolio CalculatorTHE ALL WEATHER STRATEGY INDICATOR: A GUIDE TO RAY DALIO'S LEGENDARY PORTFOLIO APPROACH
Introduction: The Genesis of Financial Resilience
In the sprawling corridors of Bridgewater Associates, the world's largest hedge fund managing over 150 billion dollars in assets, Ray Dalio conceived what would become one of the most influential investment strategies of the modern era. The All Weather Strategy, born from decades of market observation and rigorous backtesting, represents a paradigm shift from traditional portfolio construction methods that have dominated Wall Street since Harry Markowitz's seminal work on Modern Portfolio Theory in 1952.
Unlike conventional approaches that chase returns through market timing or stock picking, the All Weather Strategy embraces a fundamental truth that has humbled countless investors throughout history: nobody can consistently predict the future direction of markets. Instead of fighting this uncertainty, Dalio's approach harnesses it, creating a portfolio designed to perform reasonably well across all economic environments, hence the evocative name "All Weather."
The strategy emerged from Bridgewater's extensive research into economic cycles and asset class behavior, culminating in what Dalio describes as "the Holy Grail of investing" in his bestselling book "Principles" (Dalio, 2017). This Holy Grail isn't about achieving spectacular returns, but rather about achieving consistent, risk-adjusted returns that compound steadily over time, much like the tortoise defeating the hare in Aesop's timeless fable.
HISTORICAL DEVELOPMENT AND EVOLUTION
The All Weather Strategy's origins trace back to the tumultuous economic periods of the 1970s and 1980s, when traditional portfolio construction methods proved inadequate for navigating simultaneous inflation and recession. Raymond Thomas Dalio, born in 1949 in Queens, New York, founded Bridgewater Associates from his Manhattan apartment in 1975, initially focusing on currency and fixed-income consulting for corporate clients.
Dalio's early experiences during the 1970s stagflation period profoundly shaped his investment philosophy. Unlike many of his contemporaries who viewed inflation and deflation as opposing forces, Dalio recognized that both conditions could coexist with either economic growth or contraction, creating four distinct economic environments rather than the traditional two-factor models that dominated academic finance.
The conceptual breakthrough came in the late 1980s when Dalio began systematically analyzing asset class performance across different economic regimes. Working with a small team of researchers, Bridgewater developed sophisticated models that decomposed economic conditions into growth and inflation components, then mapped historical asset class returns against these regimes. This research revealed that traditional portfolio construction, heavily weighted toward stocks and bonds, left investors vulnerable to specific economic scenarios.
The formal All Weather Strategy emerged in 1996 when Bridgewater was approached by a wealthy family seeking a portfolio that could protect their wealth across various economic conditions without requiring active management or market timing. Unlike Bridgewater's flagship Pure Alpha fund, which relied on active trading and leverage, the All Weather approach needed to be completely passive and unleveraged while still providing adequate diversification.
Dalio and his team spent months developing and testing various allocation schemes, ultimately settling on the 30/40/15/7.5/7.5 framework that balances risk contributions rather than dollar amounts. This approach was revolutionary because it focused on risk budgeting—ensuring that no single asset class dominated the portfolio's risk profile—rather than the traditional approach of equal dollar allocations or market-cap weighting.
The strategy's first institutional implementation began in 1996 with a family office client, followed by gradual expansion to other wealthy families and eventually institutional investors. By 2005, Bridgewater was managing over $15 billion in All Weather assets, making it one of the largest systematic strategy implementations in institutional investing.
The 2008 financial crisis provided the ultimate test of the All Weather methodology. While the S&P 500 declined by 37% and many hedge funds suffered double-digit losses, the All Weather strategy generated positive returns, validating Dalio's risk-balancing approach. This performance during extreme market stress attracted significant institutional attention, leading to rapid asset growth in subsequent years.
The strategy's theoretical foundations evolved throughout the 2000s as Bridgewater's research team, led by co-chief investment officers Greg Jensen and Bob Prince, refined the economic framework and incorporated insights from behavioral economics and complexity theory. Their research, published in numerous institutional white papers, demonstrated that traditional portfolio optimization methods consistently underperformed simpler risk-balanced approaches across various time periods and market conditions.
Academic validation came through partnerships with leading business schools and collaboration with prominent economists. The strategy's risk parity principles influenced an entire generation of institutional investors, leading to the creation of numerous risk parity funds managing hundreds of billions in aggregate assets.
In recent years, the democratization of sophisticated financial tools has made All Weather-style investing accessible to individual investors through ETFs and systematic platforms. The availability of high-quality, low-cost ETFs covering each required asset class has eliminated many of the barriers that previously limited sophisticated portfolio construction to institutional investors.
The development of advanced portfolio management software and platforms like TradingView has further democratized access to institutional-quality analytics and implementation tools. The All Weather Strategy Indicator represents the culmination of this trend, providing individual investors with capabilities that previously required teams of portfolio managers and risk analysts.
Understanding the Four Economic Seasons
The All Weather Strategy's theoretical foundation rests on Dalio's observation that all economic environments can be characterized by two primary variables: economic growth and inflation. These variables create four distinct "economic seasons," each favoring different asset classes. Rising growth benefits stocks and commodities, while falling growth favors bonds. Rising inflation helps commodities and inflation-protected securities, while falling inflation benefits nominal bonds and stocks.
This framework, detailed extensively in Bridgewater's research papers from the 1990s, suggests that by holding assets that perform well in each economic season, an investor can create a portfolio that remains resilient regardless of which season unfolds. The elegance lies not in predicting which season will occur, but in being prepared for all of them simultaneously.
Academic research supports this multi-environment approach. Ang and Bekaert (2002) demonstrated that regime changes in economic conditions significantly impact asset returns, while Fama and French (2004) showed that different asset classes exhibit varying sensitivities to economic factors. The All Weather Strategy essentially operationalizes these academic insights into a practical investment framework.
The Original All Weather Allocation: Simplicity Masquerading as Sophistication
The core All Weather portfolio, as implemented by Bridgewater for institutional clients and later adapted for retail investors, maintains a deceptively simple static allocation: 30% stocks, 40% long-term bonds, 15% intermediate-term bonds, 7.5% commodities, and 7.5% Treasury Inflation-Protected Securities (TIPS). This allocation may appear arbitrary to the uninitiated, but each percentage reflects careful consideration of historical volatilities, correlations, and economic sensitivities.
The 30% stock allocation provides growth exposure while limiting the portfolio's overall volatility. Stocks historically deliver superior long-term returns but with significant volatility, as evidenced by the Standard & Poor's 500 Index's average annual return of approximately 10% since 1926, accompanied by standard deviation exceeding 15% (Ibbotson Associates, 2023). By limiting stock exposure to 30%, the portfolio captures much of the equity risk premium while avoiding excessive volatility.
The combined 55% allocation to bonds (40% long-term plus 15% intermediate-term) serves as the portfolio's stabilizing force. Long-term bonds provide substantial interest rate sensitivity, performing well during economic slowdowns when central banks reduce rates. Intermediate-term bonds offer a balance between interest rate sensitivity and reduced duration risk. This bond-heavy allocation reflects Dalio's insight that bonds typically exhibit lower volatility than stocks while providing essential diversification benefits.
The 7.5% commodities allocation addresses inflation protection, as commodity prices typically rise during inflationary periods. Historical analysis by Bodie and Rosansky (1980) demonstrated that commodities provide meaningful diversification benefits and inflation hedging capabilities, though with considerable volatility. The relatively small allocation reflects commodities' high volatility and mixed long-term returns.
Finally, the 7.5% TIPS allocation provides explicit inflation protection through government-backed securities whose principal and interest payments adjust with inflation. Introduced by the U.S. Treasury in 1997, TIPS have proven effective inflation hedges, though they underperform nominal bonds during deflationary periods (Campbell & Viceira, 2001).
Historical Performance: The Evidence Speaks
Analyzing the All Weather Strategy's historical performance reveals both its strengths and limitations. Using monthly return data from 1970 to 2023, spanning over five decades of varying economic conditions, the strategy has delivered compelling risk-adjusted returns while experiencing lower volatility than traditional stock-heavy portfolios.
During this period, the All Weather allocation generated an average annual return of approximately 8.2%, compared to 10.5% for the S&P 500 Index. However, the strategy's annual volatility measured just 9.1%, substantially lower than the S&P 500's 15.8% volatility. This translated to a Sharpe ratio of 0.67 for the All Weather Strategy versus 0.54 for the S&P 500, indicating superior risk-adjusted performance.
More impressively, the strategy's maximum drawdown over this period was 12.3%, occurring during the 2008 financial crisis, compared to the S&P 500's maximum drawdown of 50.9% during the same period. This drawdown mitigation proves crucial for long-term wealth building, as Stein and DeMuth (2003) demonstrated that avoiding large losses significantly impacts compound returns over time.
The strategy performed particularly well during periods of economic stress. During the 1970s stagflation, when stocks and bonds both struggled, the All Weather portfolio's commodity and TIPS allocations provided essential protection. Similarly, during the 2000-2002 dot-com crash and the 2008 financial crisis, the portfolio's bond-heavy allocation cushioned losses while maintaining positive returns in several years when stocks declined significantly.
However, the strategy underperformed during sustained bull markets, particularly the 1990s technology boom and the 2010s post-financial crisis recovery. This underperformance reflects the strategy's conservative nature and diversified approach, which sacrifices potential upside for downside protection. As Dalio frequently emphasizes, the All Weather Strategy prioritizes "not losing money" over "making a lot of money."
Implementing the All Weather Strategy: A Practical Guide
The All Weather Strategy Indicator transforms Dalio's institutional-grade approach into an accessible tool for individual investors. The indicator provides real-time portfolio tracking, rebalancing signals, and performance analytics, eliminating much of the complexity traditionally associated with implementing sophisticated allocation strategies.
To begin implementation, investors must first determine their investable capital. As detailed analysis reveals, the All Weather Strategy requires meaningful capital to implement effectively due to transaction costs, minimum investment requirements, and the need for precise allocations across five different asset classes.
For portfolios below $50,000, the strategy becomes challenging to implement efficiently. Transaction costs consume a disproportionate share of returns, while the inability to purchase fractional shares creates allocation drift. Consider an investor with $25,000 attempting to allocate 7.5% to commodities through the iPath Bloomberg Commodity Index ETF (DJP), currently trading around $25 per share. This allocation targets $1,875, enough for only 75 shares, creating immediate tracking error.
At $50,000, implementation becomes feasible but not optimal. The 30% stock allocation ($15,000) purchases approximately 37 shares of the SPDR S&P 500 ETF (SPY) at current prices around $400 per share. The 40% long-term bond allocation ($20,000) buys 200 shares of the iShares 20+ Year Treasury Bond ETF (TLT) at approximately $100 per share. While workable, these allocations leave significant cash drag and rebalancing challenges.
The optimal minimum for individual implementation appears to be $100,000. At this level, each allocation becomes substantial enough for precise implementation while keeping transaction costs below 0.4% annually. The $30,000 stock allocation, $40,000 long-term bond allocation, $15,000 intermediate-term bond allocation, $7,500 commodity allocation, and $7,500 TIPS allocation each provide sufficient size for effective management.
For investors with $250,000 or more, the strategy implementation approaches institutional quality. Allocation precision improves, transaction costs decline as a percentage of assets, and rebalancing becomes highly efficient. These larger portfolios can also consider adding complexity through international diversification or alternative implementations.
The indicator recommends quarterly rebalancing to balance transaction costs with allocation discipline. Monthly rebalancing increases costs without substantial benefits for most investors, while annual rebalancing allows excessive drift that can meaningfully impact performance. Quarterly rebalancing, typically on the first trading day of each quarter, provides an optimal balance.
Understanding the Indicator's Functionality
The All Weather Strategy Indicator operates as a comprehensive portfolio management system, providing multiple analytical layers that professional money managers typically reserve for institutional clients. This sophisticated tool transforms Ray Dalio's institutional-grade strategy into an accessible platform for individual investors, offering features that rival professional portfolio management software.
The indicator's core architecture consists of several interconnected modules that work seamlessly together to provide complete portfolio oversight. At its foundation lies a real-time portfolio simulation engine that tracks the exact value of each ETF position based on current market prices, eliminating the need for manual calculations or external spreadsheets.
DETAILED INDICATOR COMPONENTS AND FUNCTIONS
Portfolio Configuration Module
The portfolio setup begins with the Portfolio Configuration section, which establishes the fundamental parameters for strategy implementation. The Portfolio Capital input accepts values from $1,000 to $10,000,000, accommodating everyone from beginning investors to institutional clients. This input directly drives all subsequent calculations, determining exact share quantities and portfolio values throughout the implementation period.
The Portfolio Start Date function allows users to specify when they began implementing the All Weather Strategy, creating a clear demarcation point for performance tracking. This feature proves essential for investors who want to track their actual implementation against theoretical performance, providing realistic assessment of strategy effectiveness including timing differences and implementation costs.
Rebalancing Frequency settings offer two options: Monthly and Quarterly. While monthly rebalancing provides more precise allocation control, quarterly rebalancing typically proves more cost-effective for most investors due to reduced transaction costs. The indicator automatically detects the first trading day of each period, ensuring rebalancing occurs at optimal times regardless of weekends, holidays, or market closures.
The Rebalancing Threshold parameter, adjustable from 0.5% to 10%, determines when allocation drift triggers rebalancing recommendations. Conservative settings like 1-2% maintain tight allocation control but increase trading frequency, while wider thresholds like 3-5% reduce trading costs but allow greater allocation drift. This flexibility accommodates different risk tolerances and cost structures.
Visual Display System
The Show All Weather Calculator toggle controls the main dashboard visibility, allowing users to focus on chart visualization when detailed metrics aren't needed. When enabled, this comprehensive dashboard displays current portfolio value, individual ETF allocations, target versus actual weights, rebalancing status, and performance metrics in a professionally formatted table.
Economic Environment Display provides context about current market conditions based on growth and inflation indicators. While simplified compared to Bridgewater's sophisticated regime detection, this feature helps users understand which economic "season" currently prevails and which asset classes should theoretically benefit.
Rebalancing Signals illuminate when portfolio drift exceeds user-defined thresholds, highlighting specific ETFs that require adjustment. These signals use color coding to indicate urgency: green for balanced allocations, yellow for moderate drift, and red for significant deviations requiring immediate attention.
Advanced Label System
The rebalancing label system represents one of the indicator's most innovative features, providing three distinct detail levels to accommodate different user needs and experience levels. The "None" setting displays simple symbols marking portfolio start and rebalancing events without cluttering the chart with text. This minimal approach suits experienced investors who understand the implications of each symbol.
"Basic" label mode shows essential information including portfolio values at each rebalancing point, enabling quick assessment of strategy performance over time. These labels display "START $X" for portfolio initiation and "RBL $Y" for rebalancing events, providing clear performance tracking without overwhelming detail.
"Detailed" labels provide comprehensive trading instructions including exact buy and sell quantities for each ETF. These labels might display "RBL $125,000 BUY 15 SPY SELL 25 TLT BUY 8 IEF NO TRADES DJP SELL 12 SCHP" providing complete implementation guidance. This feature essentially transforms the indicator into a personal portfolio manager, eliminating guesswork about exact trades required.
Professional Color Themes
Eight professionally designed color themes adapt the indicator's appearance to different aesthetic preferences and market analysis styles. The "Gold" theme reflects traditional wealth management aesthetics, while "EdgeTools" provides modern professional appearance. "Behavioral" uses psychologically informed colors that reinforce disciplined decision-making, while "Quant" employs high-contrast combinations favored by quantitative analysts.
"Ocean," "Fire," "Matrix," and "Arctic" themes provide distinctive visual identities for traders who prefer unique chart aesthetics. Each theme automatically adjusts for dark or light mode optimization, ensuring optimal readability across different TradingView configurations.
Real-Time Portfolio Tracking
The portfolio simulation engine continuously tracks five separate ETF positions: SPY for stocks, TLT for long-term bonds, IEF for intermediate-term bonds, DJP for commodities, and SCHP for TIPS. Each position's value updates in real-time based on current market prices, providing instant feedback about portfolio performance and allocation drift.
Current share calculations determine exact holdings based on the most recent rebalancing, while target shares reflect optimal allocation based on current portfolio value. Trade calculations show precisely how many shares to buy or sell during rebalancing, eliminating manual calculations and potential errors.
Performance Analytics Suite
The indicator's performance measurement capabilities rival professional portfolio analysis software. Sharpe ratio calculations incorporate current risk-free rates obtained from Treasury yield data, providing accurate risk-adjusted performance assessment. Volatility measurements use rolling periods to capture changing market conditions while maintaining statistical significance.
Portfolio return calculations track both absolute and relative performance, comparing the All Weather implementation against individual asset classes and benchmark indices. These metrics update continuously, providing real-time assessment of strategy effectiveness and implementation quality.
Data Quality Monitoring
Sophisticated data quality checks ensure reliable indicator operation across different market conditions and potential data interruptions. The system monitors all five ETF price feeds plus economic data sources, providing quality scores that alert users to potential data issues that might affect calculations.
When data quality degrades, the indicator automatically switches to fallback values or alternative data sources, maintaining functionality during temporary market data interruptions. This robust design ensures consistent operation even during volatile market conditions when data feeds occasionally experience disruptions.
Risk Management and Behavioral Considerations
Despite its sophisticated design, the All Weather Strategy faces behavioral challenges that have derailed countless well-intentioned investment plans. The strategy's conservative nature means it will underperform growth stocks during bull markets, potentially by substantial margins. Maintaining discipline during these periods requires understanding that the strategy optimizes for risk-adjusted returns over absolute returns.
Behavioral finance research by Kahneman and Tversky (1979) demonstrates that investors feel losses approximately twice as intensely as equivalent gains. This loss aversion creates powerful psychological pressure to abandon defensive strategies during bull markets when aggressive portfolios appear more attractive. The All Weather Strategy's bond-heavy allocation will seem overly conservative when technology stocks double in value, as occurred repeatedly during the 2010s.
Conversely, the strategy's defensive characteristics provide psychological comfort during market stress. When stocks crash 30-50%, as they periodically do, the All Weather portfolio's modest losses feel manageable rather than catastrophic. This emotional stability enables investors to maintain their investment discipline when others capitulate, often at the worst possible times.
Rebalancing discipline presents another behavioral challenge. Selling winners to buy losers contradicts natural human tendencies but remains essential for the strategy's success. When stocks have outperformed bonds for several quarters, rebalancing requires selling high-performing stock positions to purchase seemingly stagnant bond positions. This action feels counterintuitive but captures the strategy's systematic approach to risk management.
Tax considerations add complexity for taxable accounts. Frequent rebalancing generates taxable events that can erode after-tax returns, particularly for high-income investors facing elevated capital gains rates. Tax-advantaged accounts like 401(k)s and IRAs provide ideal vehicles for All Weather implementation, eliminating tax friction from rebalancing activities.
Capital Requirements and Cost Analysis
Comprehensive cost analysis reveals the capital requirements for effective All Weather implementation. Annual expenses include management fees for each ETF, transaction costs from rebalancing, and bid-ask spreads from trading less liquid securities.
ETF expense ratios vary significantly across asset classes. The SPDR S&P 500 ETF charges 0.09% annually, while the iShares 20+ Year Treasury Bond ETF charges 0.20%. The iShares 7-10 Year Treasury Bond ETF charges 0.15%, the Schwab US TIPS ETF charges 0.05%, and the iPath Bloomberg Commodity Index ETF charges 0.75%. Weighted by the All Weather allocations, total expense ratios average approximately 0.19% annually.
Transaction costs depend heavily on broker selection and account size. Premium brokers like Interactive Brokers charge $1-2 per trade, resulting in $20-40 annually for quarterly rebalancing. Discount brokers may charge higher per-trade fees but offer commission-free ETF trading for selected funds. Zero-commission brokers eliminate explicit trading costs but often impose wider bid-ask spreads that function as hidden fees.
Bid-ask spreads represent the difference between buying and selling prices for each security. Highly liquid ETFs like SPY maintain spreads of 1-2 basis points, while less liquid commodity ETFs may exhibit spreads of 5-10 basis points. These costs accumulate through rebalancing activities, typically totaling 10-15 basis points annually.
For a $100,000 portfolio, total annual costs including expense ratios, transaction fees, and spreads typically range from 0.35% to 0.45%, or $350-450 annually. These costs decline as a percentage of assets as portfolio size increases, reaching approximately 0.25% for portfolios exceeding $250,000.
Comparing costs to potential benefits reveals the strategy's value proposition. Historical analysis suggests the All Weather approach reduces portfolio volatility by 35-40% compared to stock-heavy allocations while maintaining competitive returns. This volatility reduction provides substantial value during market stress, potentially preventing behavioral mistakes that destroy long-term wealth.
Alternative Implementations and Customizations
While the original All Weather allocation provides an excellent starting point, investors may consider modifications based on personal circumstances, market conditions, or geographic considerations. International diversification represents one potential enhancement, adding exposure to developed and emerging market bonds and equities.
Geographic customization becomes important for non-US investors. European investors might replace US Treasury bonds with German Bunds or broader European government bond indices. Currency hedging decisions add complexity but may reduce volatility for investors whose spending occurs in non-dollar currencies.
Tax-location strategies optimize after-tax returns by placing tax-inefficient assets in tax-advantaged accounts while holding tax-efficient assets in taxable accounts. TIPS and commodity ETFs generate ordinary income taxed at higher rates, making them candidates for retirement account placement. Stock ETFs generate qualified dividends and long-term capital gains taxed at lower rates, making them suitable for taxable accounts.
Some investors prefer implementing the bond allocation through individual Treasury securities rather than ETFs, eliminating management fees while gaining precise maturity control. Treasury auctions provide access to new securities without bid-ask spreads, though this approach requires more sophisticated portfolio management.
Factor-based implementations replace broad market ETFs with factor-tilted alternatives. Value-tilted stock ETFs, quality-focused bond ETFs, or momentum-based commodity indices may enhance returns while maintaining the All Weather framework's diversification benefits. However, these modifications introduce additional complexity and potential tracking error.
Conclusion: Embracing the Long Game
The All Weather Strategy represents more than an investment approach; it embodies a philosophy of financial resilience that prioritizes sustainable wealth building over speculative gains. In an investment landscape increasingly dominated by algorithmic trading, meme stocks, and cryptocurrency volatility, Dalio's methodical approach offers a refreshing alternative grounded in economic theory and historical evidence.
The strategy's greatest strength lies not in its potential for extraordinary returns, but in its capacity to deliver reasonable returns across diverse economic environments while protecting capital during market stress. This characteristic becomes increasingly valuable as investors approach or enter retirement, when portfolio preservation assumes greater importance than aggressive growth.
Implementation requires discipline, adequate capital, and realistic expectations. The strategy will underperform growth-oriented approaches during bull markets while providing superior downside protection during bear markets. Investors must embrace this trade-off consciously, understanding that the strategy optimizes for long-term wealth building rather than short-term performance.
The All Weather Strategy Indicator democratizes access to institutional-quality portfolio management, providing individual investors with tools previously available only to wealthy families and institutions. By automating allocation tracking, rebalancing signals, and performance analysis, the indicator removes much of the complexity that has historically limited sophisticated strategy implementation.
For investors seeking a systematic, evidence-based approach to long-term wealth building, the All Weather Strategy provides a compelling framework. Its emphasis on diversification, risk management, and behavioral discipline aligns with the fundamental principles that have created lasting wealth throughout financial history. While the strategy may not generate headlines or inspire cocktail party conversations, it offers something more valuable: a reliable path toward financial security across all economic seasons.
As Dalio himself notes, "The biggest mistake investors make is to believe that what happened in the recent past is likely to persist, and they design their portfolios accordingly." The All Weather Strategy's enduring appeal lies in its rejection of this recency bias, instead embracing the uncertainty of markets while positioning for success regardless of which economic season unfolds.
STEP-BY-STEP INDICATOR SETUP GUIDE
Setting up the All Weather Strategy Indicator requires careful attention to each configuration parameter to ensure optimal implementation. This comprehensive setup guide walks through every setting and explains its impact on strategy performance.
Initial Setup Process
Begin by adding the indicator to your TradingView chart. Search for "Ray Dalio's All Weather Strategy" in the indicator library and apply it to any chart. The indicator operates independently of the underlying chart symbol, drawing data directly from the five required ETFs regardless of which security appears on the chart.
Portfolio Configuration Settings
Start with the Portfolio Capital input, which drives all subsequent calculations. Enter your exact investable capital, ranging from $1,000 to $10,000,000. This input determines share quantities, trade recommendations, and performance calculations. Conservative recommendations suggest minimum capitals of $50,000 for basic implementation or $100,000 for optimal precision.
Select your Portfolio Start Date carefully, as this establishes the baseline for all performance calculations. Choose the date when you actually began implementing the All Weather Strategy, not when you first learned about it. This date should reflect when you first purchased ETFs according to the target allocation, creating realistic performance tracking.
Choose your Rebalancing Frequency based on your cost structure and precision preferences. Monthly rebalancing provides tighter allocation control but increases transaction costs. Quarterly rebalancing offers the optimal balance for most investors between allocation precision and cost control. The indicator automatically detects appropriate trading days regardless of your selection.
Set the Rebalancing Threshold based on your tolerance for allocation drift and transaction costs. Conservative investors preferring tight control should use 1-2% thresholds, while cost-conscious investors may prefer 3-5% thresholds. Lower thresholds maintain more precise allocations but trigger more frequent trading.
Display Configuration Options
Enable Show All Weather Calculator to display the comprehensive dashboard containing portfolio values, allocations, and performance metrics. This dashboard provides essential information for portfolio management and should remain enabled for most users.
Show Economic Environment displays current economic regime classification based on growth and inflation indicators. While simplified compared to Bridgewater's sophisticated models, this feature provides useful context for understanding current market conditions.
Show Rebalancing Signals highlights when portfolio allocations drift beyond your threshold settings. These signals use color coding to indicate urgency levels, helping prioritize rebalancing activities.
Advanced Label Customization
Configure Show Rebalancing Labels based on your need for chart annotations. These labels mark important portfolio events and can provide valuable historical context, though they may clutter charts during extended time periods.
Select appropriate Label Detail Levels based on your experience and information needs. "None" provides minimal symbols suitable for experienced users. "Basic" shows portfolio values at key events. "Detailed" provides complete trading instructions including exact share quantities for each ETF.
Appearance Customization
Choose Color Themes based on your aesthetic preferences and trading style. "Gold" reflects traditional wealth management appearance, while "EdgeTools" provides modern professional styling. "Behavioral" uses psychologically informed colors that reinforce disciplined decision-making.
Enable Dark Mode Optimization if using TradingView's dark theme for optimal readability and contrast. This setting automatically adjusts all colors and transparency levels for the selected theme.
Set Main Line Width based on your chart resolution and visual preferences. Higher width values provide clearer allocation lines but may overwhelm smaller charts. Most users prefer width settings of 2-3 for optimal visibility.
Troubleshooting Common Setup Issues
If the indicator displays "Data not available" messages, verify that all five ETFs (SPY, TLT, IEF, DJP, SCHP) have valid price data on your selected timeframe. The indicator requires daily data availability for all components.
When rebalancing signals seem inconsistent, check your threshold settings and ensure sufficient time has passed since the last rebalancing event. The indicator only triggers signals on designated rebalancing days (first trading day of each period) when drift exceeds threshold levels.
If labels appear at unexpected chart locations, verify that your chart displays percentage values rather than price values. The indicator forces percentage formatting and 0-40% scaling for optimal allocation visualization.
COMPREHENSIVE BIBLIOGRAPHY AND FURTHER READING
PRIMARY SOURCES AND RAY DALIO WORKS
Dalio, R. (2017). Principles: Life and work. New York: Simon & Schuster.
Dalio, R. (2018). A template for understanding big debt crises. Bridgewater Associates.
Dalio, R. (2021). Principles for dealing with the changing world order: Why nations succeed and fail. New York: Simon & Schuster.
BRIDGEWATER ASSOCIATES RESEARCH PAPERS
Jensen, G., Kertesz, A. & Prince, B. (2010). All Weather strategy: Bridgewater's approach to portfolio construction. Bridgewater Associates Research.
Prince, B. (2011). An in-depth look at the investment logic behind the All Weather strategy. Bridgewater Associates Daily Observations.
Bridgewater Associates. (2015). Risk parity in the context of larger portfolio construction. Institutional Research.
ACADEMIC RESEARCH ON RISK PARITY AND PORTFOLIO CONSTRUCTION
Ang, A. & Bekaert, G. (2002). International asset allocation with regime shifts. The Review of Financial Studies, 15(4), 1137-1187.
Bodie, Z. & Rosansky, V. I. (1980). Risk and return in commodity futures. Financial Analysts Journal, 36(3), 27-39.
Campbell, J. Y. & Viceira, L. M. (2001). Who should buy long-term bonds? American Economic Review, 91(1), 99-127.
Clarke, R., De Silva, H. & Thorley, S. (2013). Risk parity, maximum diversification, and minimum variance: An analytic perspective. Journal of Portfolio Management, 39(3), 39-53.
Fama, E. F. & French, K. R. (2004). The capital asset pricing model: Theory and evidence. Journal of Economic Perspectives, 18(3), 25-46.
BEHAVIORAL FINANCE AND IMPLEMENTATION CHALLENGES
Kahneman, D. & Tversky, A. (1979). Prospect theory: An analysis of decision under risk. Econometrica, 47(2), 263-292.
Thaler, R. H. & Sunstein, C. R. (2008). Nudge: Improving decisions about health, wealth, and happiness. New Haven: Yale University Press.
Montier, J. (2007). Behavioural investing: A practitioner's guide to applying behavioural finance. Chichester: John Wiley & Sons.
MODERN PORTFOLIO THEORY AND QUANTITATIVE METHODS
Markowitz, H. (1952). Portfolio selection. The Journal of Finance, 7(1), 77-91.
Sharpe, W. F. (1964). Capital asset prices: A theory of market equilibrium under conditions of risk. The Journal of Finance, 19(3), 425-442.
Black, F. & Litterman, R. (1992). Global portfolio optimization. Financial Analysts Journal, 48(5), 28-43.
PRACTICAL IMPLEMENTATION AND ETF ANALYSIS
Gastineau, G. L. (2010). The exchange-traded funds manual. 2nd ed. Hoboken: John Wiley & Sons.
Poterba, J. M. & Shoven, J. B. (2002). Exchange-traded funds: A new investment option for taxable investors. American Economic Review, 92(2), 422-427.
Israelsen, C. L. (2005). A refinement to the Sharpe ratio and information ratio. Journal of Asset Management, 5(6), 423-427.
ECONOMIC CYCLE ANALYSIS AND ASSET CLASS RESEARCH
Ilmanen, A. (2011). Expected returns: An investor's guide to harvesting market rewards. Chichester: John Wiley & Sons.
Swensen, D. F. (2009). Pioneering portfolio management: An unconventional approach to institutional investment. Rev. ed. New York: Free Press.
Siegel, J. J. (2014). Stocks for the long run: The definitive guide to financial market returns & long-term investment strategies. 5th ed. New York: McGraw-Hill Education.
RISK MANAGEMENT AND ALTERNATIVE STRATEGIES
Taleb, N. N. (2007). The black swan: The impact of the highly improbable. New York: Random House.
Lowenstein, R. (2000). When genius failed: The rise and fall of Long-Term Capital Management. New York: Random House.
Stein, D. M. & DeMuth, P. (2003). Systematic withdrawal from retirement portfolios: The impact of asset allocation decisions on portfolio longevity. AAII Journal, 25(7), 8-12.
CONTEMPORARY DEVELOPMENTS AND FUTURE DIRECTIONS
Asness, C. S., Frazzini, A. & Pedersen, L. H. (2012). Leverage aversion and risk parity. Financial Analysts Journal, 68(1), 47-59.
Roncalli, T. (2013). Introduction to risk parity and budgeting. Boca Raton: CRC Press.
Ibbotson Associates. (2023). Stocks, bonds, bills, and inflation 2023 yearbook. Chicago: Morningstar.
PERIODICALS AND ONGOING RESEARCH
Journal of Portfolio Management - Quarterly publication featuring cutting-edge research on portfolio construction and risk management
Financial Analysts Journal - Bi-monthly publication of the CFA Institute with practical investment research
Bridgewater Associates Daily Observations - Regular market commentary and research from the creators of the All Weather Strategy
RECOMMENDED READING SEQUENCE
For investors new to the All Weather Strategy, begin with Dalio's "Principles" for philosophical foundation, then proceed to the Bridgewater research papers for technical details. Supplement with Markowitz's original portfolio theory work and behavioral finance literature from Kahneman and Tversky.
Intermediate students should focus on academic papers by Ang & Bekaert on regime shifts, Clarke et al. on risk parity methods, and Ilmanen's comprehensive analysis of expected returns across asset classes.
Advanced practitioners will benefit from Roncalli's technical treatment of risk parity mathematics, Asness et al.'s academic critique of leverage aversion, and ongoing research in the Journal of Portfolio Management.
EMA Distance %# EMA Distance % - Daily Timeframe Analysis
## Overview
This indicator provides real-time analysis of price distance from key Exponential Moving Averages (EMA 10 and EMA 21) on the daily timeframe, regardless of your current chart timeframe. It displays both percentage and volatility-adjusted (ATR) distances in a clean, customizable table format.
## Key Features
- **Daily Timeframe Focus**: Always references daily EMA 10 and EMA 21 values, providing consistent analysis across all chart timeframes
- **Dual Distance Metrics**: Shows both percentage distance and ATR-normalized distance for comprehensive analysis
- **Customizable Table Position**: Position the data table anywhere on your chart (9 different locations available)
- **Color-Coded Results**: Green indicates price above EMA, red indicates price below EMA
- **Volatility Adjustment**: ATR distance provides context relative to the asset's typical price movements
## What It Shows
The indicator displays a table with the following information:
- **EMA Value**: Current daily EMA 10 and EMA 21 values
- **Distance %**: Percentage distance from each EMA (positive = above, negative = below)
- **ATR Distance**: How many Average True Range units the price is from each EMA
## Use Cases
- **Mean Reversion Trading**: Identify when price has moved significantly away from key EMAs
- **Trend Strength Analysis**: Gauge the strength of current trends relative to moving averages
- **Entry/Exit Timing**: Use ATR distances to identify potential reversal zones (typically 2-3+ ATR)
- **Multi-Timeframe Analysis**: View daily EMA relationships while analyzing shorter timeframes
- **Risk Management**: Understand volatility-adjusted distance for better position sizing
## Settings
- **Table Position**: Choose from 9 different table positions on your chart
- **ATR Period**: Customize the ATR calculation period (default: 14)
## Interpretation
- **Small distances (< 1% or < 1 ATR)**: Price near EMA support/resistance
- **Medium distances (1-3% or 1-2 ATR)**: Normal trending movement
- **Large distances (> 3% or > 2-3 ATR)**: Potential overextension, watch for mean reversion
Perfect for swing traders, position traders, and anyone using EMA-based strategies who wants quick access to daily timeframe EMA relationships without switching chart timeframes.
Mutanabby_AI __ OSC+ST+SQZMOMMutanabby_AI OSC+ST+SQZMOM: Multi-Component Trading Analysis Tool
Overview
The Mutanabby_AI OSC+ST+SQZMOM indicator combines three proven technical analysis components into a unified trading system, providing comprehensive market analysis through integrated oscillator signals, trend identification, and volatility assessment.
Core Components
Wave Trend Oscillator (OSC): Identifies overbought and oversold market conditions using exponential moving average calculations. Key threshold levels include overbought zones at 60 and 53, with oversold areas marked at -60 and -53. Crossover signals between the two oscillator lines generate entry opportunities, displayed as colored circles on the chart for easy identification.
Supertrend Indicator (ST): Determines overall market direction using Average True Range calculations with a 2.5 factor and 10-period ATR configuration. Green lines indicate confirmed uptrends while red lines signal downtrend conditions. The indicator automatically adapts to market volatility changes, providing reliable trend identification across different market environments.
Squeeze Momentum (SQZMOM): Compares Bollinger Bands with Keltner Channels to identify consolidation periods and potential breakout scenarios. Black squares indicate squeeze conditions representing low volatility periods, green triangles signal confirmed upward breakouts, and red triangles mark downward breakout confirmations.
Signal Generation Logic
Long Entry Conditions:
Green triangles from Squeeze Momentum component
Supertrend line transitioning to green
Bullish crossovers in Wave Trend Oscillator from oversold territory
Short Entry Conditions:
Red triangles from Squeeze Momentum component
Supertrend line transitioning to red
Bearish crossovers in Wave Trend Oscillator from overbought territory
Automated Risk Management
The indicator incorporates comprehensive risk management through ATR-based calculations. Stop losses are automatically positioned at 3x ATR distance from entry points, while three progressive take profit targets are established at 1x, 2x, and 3x ATR multiples respectively. All risk management levels are clearly displayed on the chart using colored lines and informative labels.
When trend direction changes, the system automatically clears previous risk levels and generates new calculations, ensuring all risk parameters remain current and relevant to existing market conditions.
Alert and Notification System
Comprehensive alert framework includes trend change notifications with complete trade setup details, squeeze release alerts for breakout opportunity identification, and trend weakness warnings for active position management. Alert messages contain specific trading pair information, timeframe specifications, and all relevant entry and exit level data.
Implementation Guidelines
Timeframe Selection: Higher timeframes including 4-hour and daily charts provide the most reliable signals for position trading strategies. One-hour charts demonstrate good performance for day trading applications, while 15-30 minute timeframes enable scalping approaches with enhanced risk management requirements.
Risk Management Integration: Limit individual trade risk to 1-2% of total capital using the automatically calculated stop loss levels for precise position sizing. Implement systematic profit-taking at each target level while adjusting stop loss positions to protect accumulated gains.
Market Volatility Adaptation: The indicator's ATR-based calculations automatically adjust to changing market volatility conditions. During high volatility periods, risk management levels appropriately widen, while low volatility conditions result in tighter risk parameters.
Optimization Techniques
Combine indicator signals with fundamental support and resistance level analysis for enhanced signal validation. Monitor volume patterns to confirm breakout strength, particularly when Squeeze Momentum signals develop. Maintain awareness of scheduled economic events that may influence market behavior independent of technical indicator signals.
The multi-component design provides internal signal confirmation through multiple alignment requirements, significantly reducing false signal occurrence while maintaining reasonable trade frequency for active trading strategies.
Technical Specifications
The Wave Trend Oscillator utilizes customizable channel length (default 10) and average length (default 21) parameters for optimal market sensitivity. Supertrend calculations employ ATR period of 10 with factor multiplier of 2.5 for balanced signal quality. Squeeze Momentum analysis uses Bollinger Band length of 20 periods with 2.0 multiplication factor, combined with Keltner Channel length of 20 periods and 1.5 multiplication factor.
Conclusion
The Mutanabby_AI OSC+ST+SQZMOM indicator provides a systematic approach to technical market analysis through the integration of proven oscillator, trend, and momentum components. Success requires thorough understanding of each element's functionality and disciplined implementation of proper risk management principles.
Practice with demo trading accounts before live implementation to develop familiarity with signal interpretation and trade management procedures. The indicator's systematic approach effectively reduces emotional decision-making while providing clear, objective guidelines for trade entry, management, and exit strategies across various market conditions.
Game Theory Trading StrategyGame Theory Trading Strategy: Explanation and Working Logic
This Pine Script (version 5) code implements a trading strategy named "Game Theory Trading Strategy" in TradingView. Unlike the previous indicator, this is a full-fledged strategy with automated entry/exit rules, risk management, and backtesting capabilities. It uses Game Theory principles to analyze market behavior, focusing on herd behavior, institutional flows, liquidity traps, and Nash equilibrium to generate buy (long) and sell (short) signals. Below, I'll explain the strategy's purpose, working logic, key components, and usage tips in detail.
1. General Description
Purpose: The strategy identifies high-probability trading opportunities by combining Game Theory concepts (herd behavior, contrarian signals, Nash equilibrium) with technical analysis (RSI, volume, momentum). It aims to exploit market inefficiencies caused by retail herd behavior, institutional flows, and liquidity traps. The strategy is designed for automated trading with defined risk management (stop-loss/take-profit) and position sizing based on market conditions.
Key Features:
Herd Behavior Detection: Identifies retail panic buying/selling using RSI and volume spikes.
Liquidity Traps: Detects stop-loss hunting zones where price breaks recent highs/lows but reverses.
Institutional Flow Analysis: Tracks high-volume institutional activity via Accumulation/Distribution and volume spikes.
Nash Equilibrium: Uses statistical price bands to assess whether the market is in equilibrium or deviated (overbought/oversold).
Risk Management: Configurable stop-loss (SL) and take-profit (TP) percentages, dynamic position sizing based on Game Theory (minimax principle).
Visualization: Displays Nash bands, signals, background colors, and two tables (Game Theory status and backtest results).
Backtesting: Tracks performance metrics like win rate, profit factor, max drawdown, and Sharpe ratio.
Strategy Settings:
Initial capital: $10,000.
Pyramiding: Up to 3 positions.
Position size: 10% of equity (default_qty_value=10).
Configurable inputs for RSI, volume, liquidity, institutional flow, Nash equilibrium, and risk management.
Warning: This is a strategy, not just an indicator. It executes trades automatically in TradingView's Strategy Tester. Always backtest thoroughly and use proper risk management before live trading.
2. Working Logic (Step by Step)
The strategy processes each bar (candle) to generate signals, manage positions, and update performance metrics. Here's how it works:
a. Input Parameters
The inputs are grouped for clarity:
Herd Behavior (🐑):
RSI Period (14): For overbought/oversold detection.
Volume MA Period (20): To calculate average volume for spike detection.
Herd Threshold (2.0): Volume multiplier for detecting herd activity.
Liquidity Analysis (💧):
Liquidity Lookback (50): Bars to check for recent highs/lows.
Liquidity Sensitivity (1.5): Volume multiplier for trap detection.
Institutional Flow (🏦):
Institutional Volume Multiplier (2.5): For detecting large volume spikes.
Institutional MA Period (21): For Accumulation/Distribution smoothing.
Nash Equilibrium (⚖️):
Nash Period (100): For calculating price mean and standard deviation.
Nash Deviation (0.02): Multiplier for equilibrium bands.
Risk Management (🛡️):
Use Stop-Loss (true): Enables SL at 2% below/above entry price.
Use Take-Profit (true): Enables TP at 5% above/below entry price.
b. Herd Behavior Detection
RSI (14): Checks for extreme conditions:
Overbought: RSI > 70 (potential herd buying).
Oversold: RSI < 30 (potential herd selling).
Volume Spike: Volume > SMA(20) x 2.0 (herd_threshold).
Momentum: Price change over 10 bars (close - close ) compared to its SMA(20).
Herd Signals:
Herd Buying: RSI > 70 + volume spike + positive momentum = Retail buying frenzy (red background).
Herd Selling: RSI < 30 + volume spike + negative momentum = Retail selling panic (green background).
c. Liquidity Trap Detection
Recent Highs/Lows: Calculated over 50 bars (liquidity_lookback).
Psychological Levels: Nearest round numbers (e.g., $100, $110) as potential stop-loss zones.
Trap Conditions:
Up Trap: Price breaks recent high, closes below it, with a volume spike (volume > SMA x 1.5).
Down Trap: Price breaks recent low, closes above it, with a volume spike.
Visualization: Traps are marked with small red/green crosses above/below bars.
d. Institutional Flow Analysis
Volume Check: Volume > SMA(20) x 2.5 (inst_volume_mult) = Institutional activity.
Accumulation/Distribution (AD):
Formula: ((close - low) - (high - close)) / (high - low) * volume, cumulated over time.
Smoothed with SMA(21) (inst_ma_length).
Accumulation: AD > MA + high volume = Institutions buying.
Distribution: AD < MA + high volume = Institutions selling.
Smart Money Index: (close - open) / (high - low) * volume, smoothed with SMA(20). Positive = Smart money buying.
e. Nash Equilibrium
Calculation:
Price mean: SMA(100) (nash_period).
Standard deviation: stdev(100).
Upper Nash: Mean + StdDev x 0.02 (nash_deviation).
Lower Nash: Mean - StdDev x 0.02.
Conditions:
Near Equilibrium: Price between upper and lower Nash bands (stable market).
Above Nash: Price > upper band (overbought, sell potential).
Below Nash: Price < lower band (oversold, buy potential).
Visualization: Orange line (mean), red/green lines (upper/lower bands).
f. Game Theory Signals
The strategy generates three types of signals, combined into long/short triggers:
Contrarian Signals:
Buy: Herd selling + (accumulation or down trap) = Go against retail panic.
Sell: Herd buying + (distribution or up trap).
Momentum Signals:
Buy: Below Nash + positive smart money + no herd buying.
Sell: Above Nash + negative smart money + no herd selling.
Nash Reversion Signals:
Buy: Below Nash + rising close (close > close ) + volume > MA.
Sell: Above Nash + falling close + volume > MA.
Final Signals:
Long Signal: Contrarian buy OR momentum buy OR Nash reversion buy.
Short Signal: Contrarian sell OR momentum sell OR Nash reversion sell.
g. Position Management
Position Sizing (Minimax Principle):
Default: 1.0 (10% of equity).
In Nash equilibrium: Reduced to 0.5 (conservative).
During institutional volume: Increased to 1.5 (aggressive).
Entries:
Long: If long_signal is true and no existing long position (strategy.position_size <= 0).
Short: If short_signal is true and no existing short position (strategy.position_size >= 0).
Exits:
Stop-Loss: If use_sl=true, set at 2% below/above entry price.
Take-Profit: If use_tp=true, set at 5% above/below entry price.
Pyramiding: Up to 3 concurrent positions allowed.
h. Visualization
Nash Bands: Orange (mean), red (upper), green (lower).
Background Colors:
Herd buying: Red (90% transparency).
Herd selling: Green.
Institutional volume: Blue.
Signals:
Contrarian buy/sell: Green/red triangles below/above bars.
Liquidity traps: Red/green crosses above/below bars.
Tables:
Game Theory Table (Top-Right):
Herd Behavior: Buying frenzy, selling panic, or normal.
Institutional Flow: Accumulation, distribution, or neutral.
Nash Equilibrium: In equilibrium, above, or below.
Liquidity Status: Trap detected or safe.
Position Suggestion: Long (green), Short (red), or Wait (gray).
Backtest Table (Bottom-Right):
Total Trades: Number of closed trades.
Win Rate: Percentage of winning trades.
Net Profit/Loss: In USD, colored green/red.
Profit Factor: Gross profit / gross loss.
Max Drawdown: Peak-to-trough equity drop (%).
Win/Loss Trades: Number of winning/losing trades.
Risk/Reward Ratio: Simplified Sharpe ratio (returns / drawdown).
Avg Win/Loss Ratio: Average win per trade / average loss per trade.
Last Update: Current time.
i. Backtesting Metrics
Tracks:
Total trades, winning/losing trades.
Win rate (%).
Net profit ($).
Profit factor (gross profit / gross loss).
Max drawdown (%).
Simplified Sharpe ratio (returns / drawdown).
Average win/loss ratio.
Updates metrics on each closed trade.
Displays a label on the last bar with backtest period, total trades, win rate, and net profit.
j. Alerts
No explicit alertconditions defined, but you can add them for long_signal and short_signal (e.g., alertcondition(long_signal, "GT Long Entry", "Long Signal Detected!")).
Use TradingView's alert system with Strategy Tester outputs.
3. Usage Tips
Timeframe: Best for H1-D1 timeframes. Shorter frames (M1-M15) may produce noisy signals.
Settings:
Risk Management: Adjust sl_percent (e.g., 1% for volatile markets) and tp_percent (e.g., 3% for scalping).
Herd Threshold: Increase to 2.5 for stricter herd detection in choppy markets.
Liquidity Lookback: Reduce to 20 for faster markets (e.g., crypto).
Nash Period: Increase to 200 for longer-term analysis.
Backtesting:
Use TradingView's Strategy Tester to evaluate performance.
Check win rate (>50%), profit factor (>1.5), and max drawdown (<20%) for viability.
Test on different assets/timeframes to ensure robustness.
Live Trading:
Start with a demo account.
Combine with other indicators (e.g., EMAs, support/resistance) for confirmation.
Monitor liquidity traps and institutional flow for context.
Risk Management:
Always use SL/TP to limit losses.
Adjust position_size for risk tolerance (e.g., 5% of equity for conservative trading).
Avoid over-leveraging (pyramiding=3 can amplify risk).
Troubleshooting:
If no trades are executed, check signal conditions (e.g., lower herd_threshold or liquidity_sensitivity).
Ensure sufficient historical data for Nash and liquidity calculations.
If tables overlap, adjust position.top_right/bottom_right coordinates.
4. Key Differences from the Previous Indicator
Indicator vs. Strategy: The previous code was an indicator (VP + Game Theory Integrated Strategy) focused on visualization and alerts. This is a strategy with automated entries/exits and backtesting.
Volume Profile: Absent in this strategy, making it lighter but less focused on high-volume zones.
Wick Analysis: Not included here, unlike the previous indicator's heavy reliance on wick patterns.
Backtesting: This strategy includes detailed performance metrics and a backtest table, absent in the indicator.
Simpler Signals: Focuses on Game Theory signals (contrarian, momentum, Nash reversion) without the "Power/Ultra Power" hierarchy.
Risk Management: Explicit SL/TP and dynamic position sizing, not present in the indicator.
5. Conclusion
The "Game Theory Trading Strategy" is a sophisticated system leveraging herd behavior, institutional flows, liquidity traps, and Nash equilibrium to trade market inefficiencies. It’s designed for traders who understand Game Theory principles and want automated execution with robust risk management. However, it requires thorough backtesting and parameter optimization for specific markets (e.g., forex, crypto, stocks). The backtest table and visual aids make it easy to monitor performance, but always combine with other analysis tools and proper capital management.
If you need help with backtesting, adding alerts, or optimizing parameters, let me know!
Cryptokazancev Strategy PackCryptokazancev Strategy Pack
Комплексный инструмент для анализа рыночной структуры / Comprehensive Market Structure Analysis Tool
🇷🇺 Описание на русском
Cryptokazancev Strategy Pack by ZeeZeeMon - это мощный набор инструментов для технического анализа, включающий:
• Ордерблоки (Order Blocks) с настройкой количества и цветов
• Пивоты (Pivot Points) различных таймфреймов
• Рыночную структуру с зонами Фибоначчи (0.618, 0.786)
• Разворотные конструкции (пинбары и поглощения)
• Зоны интереса на основе скопления свингов
📊 Основные функции:
1. Ордерблоки
- Автоматическое определение бычьих/медвежьих OB
- Настройка максимального количества блоков (до 30)
- Кастомизация цветов
2. Пивоты
- Поддержка таймфреймов: Дневные/Недельные/Месячные/Квартальные/Годовые
- Уровни Camarilla (P, R1-R4, S1-S4)
3. Рыночная структура
- Четкое определение тренда (UP/DOWN)
- Ключевые уровни Фибо (0.618 и 0.786)
- Настройка глубины анализа (10-1000 баров)
4. Разворотные конструкции
- Обнаружение пинбаров
- Обнаружение поглощений
- Настройка чувствительности
5. Зоны интереса
- Алгоритм кластеризации свингов
- Настройка через ATR-мультипликатор
- Лимит отображаемых зон
🇬🇧 English Description
ZeeZeeMon Pack is a comprehensive market analysis toolkit featuring:
• Order Blocks with customizable count and colors
• Pivot Points for multiple timeframes
• Market Structure with Fibonacci zones
• Reversal patterns (pinbars and engulfings)
• Interest Zones based on swing clustering
📊 Key Features:
1. Order Blocks
- Auto-detection of bullish/bearish OB
- Configurable max blocks (up to 30)
- Custom color schemes
2. Pivot Points
- Supports: Daily/Weekly/Monthly/Quarterly/Yearly
- Camarilla levels (P, R1-R4, S1-S4)
3. Market Structure
- Clear trend detection (UP/DOWN)
- Key Fibonacci levels (0.618 & 0.786)
- Adjustable analysis depth (10-1000 bars)
4. Reversal Patterns
- Smart pinbar detection
- ATR-based engulfing filter
- Sensitivity adjustment
5. Interest Zones
- Swing clustering algorithm
- ATR-multiplier configuration
- Display limit (up to 10 zones)
⚙️ Technical Highlights:
• Built with Pine Script v5
• Performance-optimized
• Well-commented code
• Flexible settings system
⚠️ Важно / Important:
Индикатор в бета-версии. Тестируйте перед использованием в реальной торговле.
This is BETA version. Please test before live trading.
💬 Поддержка / Support:
Комментарии к скрипту / Script comments section
GTrader-ICT All In One-Comumnity VersionMeet the **GTrader-ICT All In One **, a comprehensive toolkit designed to integrate key Inner Circle Trader (ICT) concepts directly onto your chart. This powerful overlay indicator consolidates multiple essential tools, streamlining your technical analysis and helping you identify key temporal and price-based events.
📚 References & Inspiration
This indicator stands on the shoulders of giants. With the help of **tradeforopp** and **LuxAlgo**. The concepts and some implementation details were referenced from the following excellent, publicly available scripts:
ICT Killzones: The session drawing and pivot logic is adapted from tradeforopp
ICT Macros: The macro detection and plotting functionality is inspired by the work of Lux Algo , particularly their widely-used indicators covering ICT concepts.
🎯 Core Features
* **ICT Killzones:** Visualize critical trading sessions with customizable boxes. You can easily toggle and style the **Asia**, **London**, and **New York (AM, Lunch, PM)** sessions to focus on the liquidity and volatility that matter most to your strategy.
* Fully customizable session times and colors.
* Timezone support to align sessions with your local or preferred trading time (defaults to `America/New_York`).
* **ICT Macros:** Automatically identify and plot specific, short-duration time windows where institutional algorithms are known to be active (e.g., `09:50-10:10`, `14:50-15:10`, etc.).
* Plots the high/low range of the macro, providing clear levels of interest.
* Utilizes 1-minute data for precision, even when viewing on 3-minute or 5-minute charts.
📚 Optimization over the other original indicators
We add the custom input for macros session, users just need to input the from/to hour: minute format, and they will be converted into session objects in pinescript
The macro draws function is optimized, removing redundant draws, leading to better performance
Add "Distance from Macro Line to Chart" option
Add "Session Drawings Limit" for better performance
⚠️ Notes on TradingView Warnings
You may encounter some warnings from TradingView when using this script. These are generally expected due to the script's advanced, event-driven nature:
1. **Function Call Consistency:** The function 'box.new' should be called on each calculation for consistency, which may appear. This happens because drawing elements (like session boxes) are intentionally created only on the *first bar* of a new session, not on every single bar. This is a necessary design choice for performance and to prevent duplicate drawings.
2. **Potential for Repainting/Slow Load:** The **Macro** feature uses the `request.security_lower_tf()` function to get accurate 1-minute data. This can trigger warnings about performance or slow loading times. This is a known trade-off for achieving the precision required for the feature.
Morning Break OutThis indicator visualizes a classic morning breakout setup for the DAX and other European markets. The first hour often sets the tone for the trading day — this tool helps you identify that visually and react accordingly.
🔍 How It Works:
Box Range Calculation:
The high and low between 09:00 and 10:00 define the top and bottom of the box.
Color Logic:
Green: Price breaks above the box after 10:00 → bullish breakout
Red: Price breaks below the box after 10:00 → bearish breakout
Gray: No breakout → neutral phase
📈 Use Cases:
Identify breakout setups visually
Ideal for intraday traders and momentum strategies
Combine with volume or trend filters
⚙️ Notes:
Recommended for timeframes 1-minute and above
Uses the chart’s local timezone (e.g. CET/CEST for XETRA/DAX)
Works on all instruments with data before 09:00 — perfect for DAX, EuroStoxx, futures, FX, CFDs, etc.
