Micro ZigzagMicro zigzag is created based on similar concepts as that of zigzag but by using lower timeframe intra-bar data. The lines join candle's high/low points but also depict how the price movement within the candle happened. That is, if the high of the candle is reached first, pivot from previous candle join the high first and then low and vice versa.
The output can also be viewed as advanced line chart.
🎲 Process
🎯 For every bar identify whether high came first or low by using lower timeframe data.
🎯 If high came before low, add high as high pivot first and then low as low pivot. If otherwise, add low as lower pivot first and then high as higher pivot.
🎯 When adding pivot, check if the last pivot is in the same direction as the new one. If yes, replace existing pivot if the new one goes beyond it. Ignore otherwise.
🎯 If the last pivot is of different direction as that one new one, then simple add the new pivot.
ค้นหาในสคริปต์สำหรับ "high low"
Fair Value Gap [LuxAlgo]Fair value gaps (FVG) highlight imbalances areas between market participants and have become popular amongst technical analysts. The following script aims to display fair value gaps alongside the percentage of filled gaps and the average duration (in bars) before gaps are filled.
Users can be alerted when an FVG is filled using the alerts built into this script.
🔶 USAGE
In practice, FVG's highlight areas of support (bullish FVG) and resistances (bearish FVG). Once a gap is filled, suggesting the end of the imbalance, we can expect the price to reverse.
This approach is more contrarian in nature, users wishing to use a more trend-following approach can use the identification of FVG as direct signals, going long with the identification of a bullish FVG, and short with a bearish FVG.
🔹 Mitigation
By default, the script highlights the areas of only unmitigated FVG's. Users can however highlight the mitigation level of mitigated FVG's, that is the lower extremity of bullish FVG's and the upper extremity of bearish FVG's.
The user can track the evolution of a mitigated FVG's using the "Dynamic" setting.
🔹 Threshold
The gap height can be used to determine the degree of imbalance between buying and selling market participants. Users can filter fair value gaps based on the gap height using the "Threshold %" setting. Using the "Auto" will make use of an automatic threshold, only keeping more volatile FVG's.
🔶 DETAILS
We use the following rules for detecting FVG's in this script:
Bullish FVG
low > high(t-2)
close(t-1) > high(t-2)
(low - high(t-2)) / high(t-2) > threshold
Upper Bullish FVG = low
Lower Bullish FVG = high(t-2)
Bearish FVG
high < low(t-2)
close(t-1) < low(t-2)
(low(t-2) - high) / high < -threshold
Upper Bearish FVG = low(t-2)
Lower Bearish FVG = high
🔶 SETTINGS
Threshold %: Threshold percentage used to filter our FVG's based on their height.
Auto Threshold: Use the cumulative mean of relative FVG heights as threshold.
Unmitigatted Levels: Extent the mitigation level of the number of unmitigated FVG's set by the user.
Mitigation Levels: Show the mitigation levels of mitigated FVG's.
Timeframe : Timeframe of the price data used to detect FVG's.
NYSE New Highs vs New LowsNYSE New Highs vs New Lows is a simple market breadth indicator that compares HIGN, the number of new highs during that day, and LOWN, the number of new lows. The new highs are on top and lows are appropriately on bottom. Without averaging, it's a little chaotic so you can smooth them out as much as you want, and the top-right label shows how much you're smoothing.
Interpretation:
Essentially, we use $SPY or $QQQ as a proxy for what's going on in the market, but because the FAANG stocks are so heavily weighted, it's not always representative. If SPY is flat/down, but there are 200 new highs today, then one of the big boys is weighing down an otherwise very bullish market. It's like looking at one of those heatmap charts, but in a single number.
Bullish Trend
- Lots of new highs
- Very few new lows
Bearish Trend
- Lots of new lows
- Very few new highs
Potential Reversal
- Too high, 250+
- Too low, 150+
Volume-based Support & Resistance ZonesThe new and improved Support & Resistance Zones indicator is here. This indicator is based on high volume at fractal lows or fractal highs with the zones based on the size of the wick for that timeframe’s candle.
This helps traders visualize which price levels are of the most significance for either reversals or continuation of the trend when zones are broken and then re-tested.
Original script is thanks to synapticex and additional modifications is thanks to Lij_MC. Credit to both of them for most of the logic behind this script.
Since then I have made many changes to this script as noted below:
Changed default S/R lines from plots to lines, and gave option to user to change between solid line, dashed line, or dotted line for both S/R lines.
Added additional time frame and gave more TF options for TF1 other than current TF. Now you will have 4 time frames to plot S/R zones from.
Gave user option to easily change line thickness for all S/R lines.
Made it easier to change colors of S/R lines and zones by consolidating the options under settings (rather than under style).
Added extensions to active SR Zones to extend all the way right.
Added option to extend or not extend the previous S/R zones up to next S/R zone.
Added optional time frame labels to active S/R zones, with left and right options as well as option to adjust how far to the right label is set.
Fixed issue where the higher time frame S/R zone was not properly starting from the high/low of fractal. Now any higher time frame S/R will begin exactly at the High/Low points. Note that this may not work perfectly on stocks and if a fractal high/low is too many bars in the past, it will revert to a default max bars back to avoid script errors.
Added to script a function that will prevent S/R zones from lower time frames displaying while on a higher time frame. This helps clean up the chart quite a bit.
Created arrays for each time frame's boxes and lines so that the number of S/R zones can be controlled for each time frame and limit memory consumption.
New alert options added and customized alert messages.
- The way this indicator works is it looks for fractal highs or fractal lows with volume that pierces above the volume's Moving Average. This moving average value can be modified in the settings for each time frame.
- The fractal highs will be confirmed with 3 successive higher highs followed by 2 successive lower highs and vice versa for the fractal lows.
- The zone is created from the fractal high/low and the close of the candle for whatever time frame you selected. The bigger the zone, the more significant that zone is.
- You can disable any zone, change the zones to show lines only, and modify all the colors, transparencies, and thickness of lines for all the zones.
- To create alerts, you first want to enable the types of alerts you want for each time frame in the indicator's settings. Then after you apply changes, right click on one of the zones on the chart, and click "Add Alert on Vol S/R Zones". You do not need to add a title as the correct alert messages are already built-in.
- More changes will be coming in the future!
I hope you find this indicator useful, if so please give it a thumbs up!
If you have any suggestions or features you would like to see, just let me know in the comment section. Thanks and enjoy!
Strat Assistant FTC OnlyStrat Assistant FTC Only
----------------------------
█ OVERVIEW
This script is intended to provide full time frame continuity information for almost all time frames (3, 5, 15, 30, 60, 4H, Day, Week, Month, Quarter)
When added, the script provides a visual indicator to the right at the current price level with indicators for the various time frames in terms of price action and candle type.
█ DETAIL
----------
Output
Time Frames: 3min, 5min, 15min, 30min, 60min, 4 Hour, Day, Week, Month Quarter
Time Frame Labels: 3, 5, 15, 30, 60, H, 4H, D, W, M, Q
Current Candle Time Frame Price Action: displayed below time frame labels. RED + Arrow Down (open > close) or GREEN + Arrow Up (open =< close)
Time Frame Compare: displayed above time frame labels. Current high/low vs prior high/low are compared. IN = Inside/Yellow (current high/low inside prior), O = Outside/Fuchsia (current high/low both greater and less than prior high/low), 2U = Up/Green (current high higher than prior, and low not lower), 2D = Down/Red (current lows lower than prior lows, and high not higher)
Will not show time frames lower than the one currently selected
Best Practices
----------
Had to decouple this from the other scripts because Trading View limits how much you can plot/show
May be a little slow at times, analyzing a lot of time periods/data be patient.
MA DerivativesMA Derivatives basicly using Ichimoku Cloud and some additional moving averages for traders.
A. ICHIMOKU
Tenkan-sen (Conversion Line): (9-period high + 9-period low)/2
On a daily chart , this line is the midpoint of the 9-day high-low range, which is almost two weeks.
Kijun-sen (Base Line): (26-period high + 26-period low)/2
On a daily chart , this line is the midpoint of the 26-day high-low range, which is almost one month.
Senkou Span A (Leading Span A): (Conversion Line + Base Line)/2
This is the midpoint between the Conversion Line and the Base Line. The Leading Span A forms one of the two Cloud boundaries. It is referred to as “Leading” because it is plotted 26 periods in the future and forms the faster Cloud boundary.
Senkou Span B (Leading Span B): (52-period high + 52-period low)/2
On the daily chart , this line is the midpoint of the 52-day high-low range, which is a little less than 3 months. The default calculation setting is 52 periods, but it can be adjusted. This value is plotted 26 periods in the future and forms the slower Cloud boundary.
Chikou Span: Represents the closing price and is plotted 26 days back.
Kumo Cloud: Kumo cloud between Senkuo Span A and Senkou Span B lines. It can be green or red. Color can be change with the trend.
You can use Ichimoku for buy&sell strategy
For Buying Strategy
- Tenkansen (Conversion Line) should crossover Kijunsen (Base line) above the highest line of cloud
- Price should be above the highest line of cloud
- Chikouspan should be above the cloud
For Selling Strategy
- Kijunsen (Base Line) should crossover Tenkansen (Conversion Line) below the lowest line of cloud
- Price should be below the lowest line of cloud
- Chikouspan should be below the cloud
B. SIMPLE MOVING AVERAGES
The indicator has some of Simple Moving Averages
It includes:
-Simple Moving Average 50
-Simple Moving Average 100
-Simple Moving Average 200
C. EXPONENTIAL MOVING AVERAGES
The indicator has some of Simple Moving Averages
It includes:
-Exponential Moving Average 9
-Exponential Moving Average 21
-Exponential Moving Average 50
D. BOLLINGER BAND
Bollinger Bands are a type of price envelope developed by John BollingerOpens in a new window. (Price envelopes define upper and lower price range levels.) Bollinger Bands are envelopes plotted at a standard deviation level above and below a simple moving average of the price. Because the distance of the bands is based on standard deviation, they adjust to volatility swings in the underlying price.
Bollinger Bands use 2 parameters, Period and Standard Deviations, StdDev. The default values are 20 for period, and 2 for standard deviations, although you may customize the combinations.
Bollinger bands help determine whether prices are high or low on a relative basis. They are used in pairs, both upper and lower bands and in conjunction with a moving average. Further, the pair of bands is not intended to be used on its own. Use the pair to confirm signals given with other indicators.
How this indicator works
When the bands tighten during a period of low volatility, it raises the likelihood of a sharp price move in either direction. This may begin a trending move. Watch out for a false move in opposite direction which reverses before the proper trend begins.
When the bands separate by an unusual large amount, volatility increases and any existing trend may be ending.
Prices have a tendency to bounce within the bands' envelope, touching one band then moving to the other band. You can use these swings to help identify potential profit targets. For example, if a price bounces off the lower band and then crosses above the moving average, the upper band then becomes the profit target.
Price can exceed or hug a band envelope for prolonged periods during strong trends. On divergence with a momentum oscillator, you may want to do additional research to determine if taking additional profits is appropriate for you.
A strong trend continuation can be expected when the price moves out of the bands. However, if prices move immediately back inside the band, then the suggested strength is negated.
Calculation
First, calculate a simple moving average. Next, calculate the standard deviation over the same number of periods as the simple moving average. For the upper band, add the standard deviation to the moving average. For the lower band, subtract the standard deviation from the moving average.
Typical values used:
Short term: 10 day moving average, bands at 1.5 standard deviations. (1.5 times the standard dev. +/- the SMA)
Medium term: 20 day moving average, bands at 2 standard deviations.
Long term: 50 day moving average, bands at 2.5 standard deviations.
E. ADJUSTABLE MOVING AVERAGES
And this script has also 2 adjustable moving average
- 1 Adjustable Simple Moving Average
- 1 Adjustable Exponential Moving Average
You can just change the length for using this tool.
Ease of Movement WatcherHere’s a handy Ease of Movement(EMV) Indicator. I tried to include detailed comments so that anyone that’s learning pine can follow along.
The Ease of Movement Indicator is a volume based oscillator that is designed to measure the ease (or movability) of price movement for a security. The EMV is a centered oscillator, meaning that values can fluctuate above and below zero.
To understand how to use and interpret the EMV Indicator, its crucial to first understand its two main calculations :
Distance Moved = ((high + low) / 2) - ((high + low ) / 2)
-This is the difference between the current period’s midpoint and the previous period’s
midpoint.
Box Ratio = (volume / 100,000) / (high - low)
-When calculating the Box Ratio, it is common to divide the volume by 100,000 for a clearer visualization of the data. However, users can choose
to modify this value with the ‘volumeDiv’ input.
The Ease of Movement Value is then pretty simple to calculate:
EMV = (Distance Moved / Box Ratio)
The indicator then plots a SMA of the previous 24 EMV Values.
Looking at the formula, we know that combining low volume with a large {high, low} range will result in a relatively small box ratio value. Thus, we know that the EMV value for that period will be higher since EMV is found by dividing the Distance Moved by the Box Ratio.
Here’s a simple guide to interpreting the EMV:
- If (EMV > 0)
then price is increasing with relative ease.
-If (EMV < 0)
then price is decreasing with relative ease.
- If high-low range is large and volume is low
then ease of movement is high.
-If high-low range is small and volume is high
then ease of movement is low.
The Chart:
-The histogram represents the Simple Moving Average of EMV Values. The default length is 24, but users can adjust this value at the inputs menu(I've
found 24 works best).
-The teal and pink dotted lines represent the standard deviation of the SMA of EMV values multiplied by 2.5.
-The histogram turns dark green when the EMV SMA is greater than the top teal dotted standard deviations line.
-The histogram turns maroon when the EMV SMA falls below the bottom pink standard deviation line.
How To Use:
Enter a long position when the most recent EMV SMA value was below the lower pink stand. dev. line and the current EMV SMA value rises above that
same pink line. That means the previous bar was maroon and the current bar is not.
If the user enables the option to show entry points, a green dot will be plotted when it is time to enter a long position.
Exit the long position when the most recent EMV SMA value was above the upper green standard deviation line and the current EMV SMA value falls
below that same line. If this is true, then the previous bar will be dark green, and the current will be light green.
If the ‘showExits’ option is enabled, then a red dot will be plotted when it is time to exit the long position.
Input Options:
- 'volumeDiv' : Integer. Used in the calculation of Box Ratio.
- 'lenSMA' : Integer. The length of the Simple Moving Average of Ease of Movement Values.
- 'showStDev' : Bool. If true, dotted green and red lines will be shown at values equal to 2.5 * standard deviation of emvSMA and -2.5 * standard deviation of
emvSMA.
- 'showEntries' and 'showExits' : Bool. If true, a green circle will be plotted at long entry points and a red circle will be plotted at long exit points.
- 'changeBgColor': Bool. If true, the background color will change to green when it is time to enter a long position and red when it is time to exit.
Alerts:
- When it is time to enter a long position, an alert with the message "EMV Tracker - Enter Long" is sent.
- When it is time to exit a long position, an alert with the message "EMV Tracker - Exit Long" is sent.
NOTE:
- I usually use this indicator to confirm signals from other indicators rather than relying on it solely.
- Most accurate signals are generated on 30 minutes with the default input values I've set in the script.
Shoot me a message if you have any ideas for modifications or questions.
~ Happy Trading ~
MP SESSIONS, DST, OTTHere’s a clear description you can use for this script (for yourself or as a TradingView “Indicator Description”):
---
### MP SESSIONS, DST, OTT – What this indicator does
This script is a **multi-session market timing tool** that:
1. **Draws full trading sessions on the chart** (Asia, Sydney, Tokyo, Shanghai, Europe, London, New York, NYSE)
2. **Automatically adjusts for Daylight Saving Time (DST)** for Sydney, London, and New York
3. **Shows a live info table** with session times, DST status, and whether each session is currently open or closed
4. **Adds optional custom “OTT” vertical lines** at user-defined intraday times (for your own models, killzones, or time blocks)
---
### Main Features (high level)
#### 1. Market mode & time zone handling
* **Market Mode**:
* `Forex`
* `Stock`
* `User Custom` (you type your own session ranges)
* `TFlab suggestion` (predefined “optimized” session times)
* **Time Zone Mode**:
* `UTC`
* `Session Local Time` (local exchange time: Sydney, Tokyo, London, New York etc.)
* `Your Time Zone` (converts to the user-selected TZ, e.g. `UTC-4:00`)
* Handles separate time zones for:
* Asia, Sydney, Tokyo, Shanghai, Europe, London, New York, NYSE
* Has logic to **recalculate session start/end depending on DST** and the chosen mode.
---
#### 2. Daylight Saving Time (DST) engine
The function `DST_Detector`:
* Calculates when DST **starts and ends** for:
* `Australia/Sydney`
* `Europe/London`
* `America/New_York`
* Detects the correct Sunday (2nd, 4th, etc.) for start/end using day-of-week and week counts.
* Returns `'Active'` or `'Inactive'` for each region.
* These values are then used to **shift the sessions** (e.g. New York 13:00–21:00 vs 12:00–20:00 in UTC).
The script can also **draw vertical lines** on the chart when DST starts/ends and label them:
* “Sydney DST Started / Ended”
* “London DST Started / Ended”
* “New York DST Started / Ended”
---
#### 3. Session timing & sessions on the chart
The function `Market_TimeZone_Calculator`:
* Based on **Market Mode** + **Time Zone Mode** + **DST state**, it returns:
* Time ranges for: Sydney, Tokyo, Shanghai, Asia (combined), Europe, London, New York, NYSE
* These ranges are in `"HHMM-HHMM"` format.
Then the script:
* Converts these to `time()` conditions using the proper time zone
* Creates boolean series like `On_sesAsia`, `On_sesEurope`, `On_sesNewYork`, etc., which are **1 when the session is open and 0 when closed**.
---
#### 4. Session high/low boxes & labels
The function `LowHighSessionDetector`:
* Tracks **high and low of each session** while it’s active.
* When a new session starts:
* Resets and starts recording the session high/low.
* While session is active:
* Updates `High` with the max of current bar high and previous session high.
* Updates `Low` with the min of current bar low and previous session low.
* When the session is "on":
* Draws a **box** from session low to high (`box.new`) and extends it to the right as long as the session continues.
* Places a **label with session name** (Asia, London, New York, etc.) near the high:
* Style depends on the session (down/right/left).
You have visibility toggles per session:
* `Asia Session`, `Sydney Session`, `Tokyo Session`, `Shanghai Session`, `Europe Session`, `London Session`, `New York Session`, `NYSE` (for TFlab mode).
So you visually see:
* A shaded box for each session
* The full H/L range for that session
* A text label with the session name.
---
#### 5. Info table
The indicator builds a **table in a corner of the chart** showing:
* Header:
* “FOREX Session”, “Stock Market Trading Hours”, “User Custom Session”, or “TFlab suggestion” depending on mode.
* Columns:
1. Session name (Asia, Sydney, Tokyo, Shanghai, Europe, London, New York, NYSE)
2. DST status for that region (“Active 🌞 / Inactive 🍂 / Not Observed”)
3. Session **start time**
4. Session **end time**
5. Current **status** (“Open / Closed”, with green/red background)
The function `SplitFunction`:
* Parses the `"HHMM-HHMM"` strings for each session.
* Converts them into:
* Either raw times (if viewing in UTC/session local)
* Or converted times in **Your Time Zone** using `timestamp` and `hour/ minute` with `YourTZ`.
* Returns formatted `Start` and `End` strings like `9:30`, `13:00`, etc.
So the table is effectively a **live session schedule** that:
* Auto-adjusts to DST
* Can show times in your own time zone
* Shows which session is open right now.
---
#### 6. OTT vertical lines (custom intraday markers)
At the bottom, there is an **OTT section** which lets you draw up to **three sets of vertical lines** at specific times:
* Each OTT block has:
* Enable toggle (`Enable OTT 1/2/3`)
* Start hour & minute
* End hour & minute
* Color
* Global OTT settings:
* Line style: `Solid / Dashed / Dotted`
* Line width
* Toggle: “Show OTT Labels?”
Logic:
* `is_ott_time()` checks if current bar’s `hour` and `minute` match the OTT input time.
* `draw_ott()`:
* When the bar time matches, draws a **vertical line** through the candle from low to high (`extend.both`).
* Optionally adds a label above the bar, like `"OTT1 Start"`, `"OTT1 End"`, etc.
Use cases:
* Marking **open/close of your trading session**
* Defining **killzones**, news times, or custom model windows
* Visual anchors for your intraday routine (NY open, 10 AM candle, etc.)
---
### TL;DR
This indicator is a **session toolkit + DST engine + time markers**:
* **Visually paints the main global sessions** with boxes and labels.
* **Handles DST automatically** for Sydney, London, New York.
* **Shows a live table** with session times, DST status, and open/closed status in your time zone.
* **Adds up to three configurable vertical time markers (OTT)** for custom session windows or key times.
If you want, I can also write a **short version** (2–3 sentences) for the TradingView “Description” field.
MP SESSIONS, DST, OTTMP SESSIONS, DST, OTT – What this indicator does
This script is a multi-session market timing tool that:
Draws full trading sessions on the chart (Asia, Sydney, Tokyo, Shanghai, Europe, London, New York, NYSE)
Automatically adjusts for Daylight Saving Time (DST) for Sydney, London, and New York
Shows a live info table with session times, DST status, and whether each session is currently open or closed
Adds optional custom “OTT” vertical lines at user-defined intraday times (for your own models, killzones, or time blocks)
Main Features (high level)
1. Market mode & time zone handling
Market Mode:
Forex
Stock
User Custom (you type your own session ranges)
TFlab suggestion (predefined “optimized” session times)
Time Zone Mode:
UTC
Session Local Time (local exchange time: Sydney, Tokyo, London, New York etc.)
Your Time Zone (converts to the user-selected TZ, e.g. UTC-4:00)
Handles separate time zones for:
Asia, Sydney, Tokyo, Shanghai, Europe, London, New York, NYSE
Has logic to recalculate session start/end depending on DST and the chosen mode.
2. Daylight Saving Time (DST) engine
The function DST_Detector:
Calculates when DST starts and ends for:
Australia/Sydney
Europe/London
America/New_York
Detects the correct Sunday (2nd, 4th, etc.) for start/end using day-of-week and week counts.
Returns 'Active' or 'Inactive' for each region.
These values are then used to shift the sessions (e.g. New York 13:00–21:00 vs 12:00–20:00 in UTC).
The script can also draw vertical lines on the chart when DST starts/ends and label them:
“Sydney DST Started / Ended”
“London DST Started / Ended”
“New York DST Started / Ended”
3. Session timing & sessions on the chart
The function Market_TimeZone_Calculator:
Based on Market Mode + Time Zone Mode + DST state, it returns:
Time ranges for: Sydney, Tokyo, Shanghai, Asia (combined), Europe, London, New York, NYSE
These ranges are in "HHMM-HHMM" format.
Then the script:
Converts these to time() conditions using the proper time zone
Creates boolean series like On_sesAsia, On_sesEurope, On_sesNewYork, etc., which are 1 when the session is open and 0 when closed.
4. Session high/low boxes & labels
The function LowHighSessionDetector:
Tracks high and low of each session while it’s active.
When a new session starts:
Resets and starts recording the session high/low.
While session is active:
Updates High with the max of current bar high and previous session high.
Updates Low with the min of current bar low and previous session low.
When the session is "on":
Draws a box from session low to high (box.new) and extends it to the right as long as the session continues.
Places a label with session name (Asia, London, New York, etc.) near the high:
Style depends on the session (down/right/left).
You have visibility toggles per session:
Asia Session, Sydney Session, Tokyo Session, Shanghai Session, Europe Session, London Session, New York Session, NYSE (for TFlab mode).
So you visually see:
A shaded box for each session
The full H/L range for that session
A text label with the session name.
5. Info table
The indicator builds a table in a corner of the chart showing:
Header:
“FOREX Session”, “Stock Market Trading Hours”, “User Custom Session”, or “TFlab suggestion” depending on mode.
Columns:
Session name (Asia, Sydney, Tokyo, Shanghai, Europe, London, New York, NYSE)
DST status for that region (“Active 🌞 / Inactive 🍂 / Not Observed”)
Session start time
Session end time
Current status (“Open / Closed”, with green/red background)
The function SplitFunction:
Parses the "HHMM-HHMM" strings for each session.
Converts them into:
Either raw times (if viewing in UTC/session local)
Or converted times in Your Time Zone using timestamp and hour/ minute with YourTZ.
Returns formatted Start and End strings like 9:30, 13:00, etc.
So the table is effectively a live session schedule that:
Auto-adjusts to DST
Can show times in your own time zone
Shows which session is open right now.
6. OTT vertical lines (custom intraday markers)
At the bottom, there is an OTT section which lets you draw up to three sets of vertical lines at specific times:
Each OTT block has:
Enable toggle (Enable OTT 1/2/3)
Start hour & minute
End hour & minute
Color
Global OTT settings:
Line style: Solid / Dashed / Dotted
Line width
Toggle: “Show OTT Labels?”
Logic:
is_ott_time() checks if current bar’s hour and minute match the OTT input time.
draw_ott():
When the bar time matches, draws a vertical line through the candle from low to high (extend.both).
Optionally adds a label above the bar, like "OTT1 Start", "OTT1 End", etc.
Use cases:
Marking open/close of your trading session
Defining killzones, news times, or custom model windows
Visual anchors for your intraday routine (NY open, 10 AM candle, etc.)
Razzere Cloned! EzAlgo V.8.1showBuySell = input(true, "Show Buy & Sell", group="BUY & SELL SIGNALS")
hassasiyet = input.float(3, "Hassasiyet (1-6)", 0.1, 99999, group="BUY & SELL SIGNALS")
percentStop = input.float(1, "Stop Loss % (0 to Disable)", 0, group="BUY & SELL SIGNALS")
offsetSignal = input.float(5, "Signals Offset", 0, group="BUY & SELL SIGNALS")
showRibbon = input(true, "Show Trend Ribbon", group="TREND RIBBON")
smooth1 = input.int(5, "Smoothing 1", 1, group="TREND RIBBON")
smooth2 = input.int(8, "Smoothing 2", 1, group="TREND RIBBON")
showreversal = input(true, "Show Reversals", group="REVERSAL SIGNALS")
showPdHlc = input(false, "Show P.D H/L/C", group="PREVIOUS DAY HIGH LOW CLOSE")
lineColor = input.color(color.yellow, "Line Colors", group="PREVIOUS DAY HIGH LOW CLOSE")
lineWidth = input.int(1, "Width Lines", group="PREVIOUS DAY HIGH LOW CLOSE")
lineStyle = input.string("Solid", "Line Style", )
labelSize = input.string("normal", "Label Text Size", )
labelColor = input.color(color.yellow, "Label Text Colors")
showEmas = input(false, "Show EMAs", group="EMA")
srcEma1 = input(close, "Source EMA 1")
lenEma1 = input.int(7, "Length EMA 1", 1)
srcEma2 = input(close, "Source EMA 2")
lenEma2 = input.int(21, "Length EMA 2", 1)
srcEma3 = input(close, "Source EMA 3")
lenEma3 = input.int(144, "Length EMA 3", 1)
showSwing = input(false, "Show Swing Points", group="SWING POINTS")
prdSwing = input.int(10, "Swing Point Period", 2, group="SWING POINTS")
colorPos = input(color.new(color.green, 50), "Positive Swing Color")
colorNeg = input(color.new(color.red, 50), "Negative Swing Color")
showDashboard = input(true, "Show Dashboard", group="TREND DASHBOARD")
locationDashboard = input.string("Middle Right", "Table Location", , group="TREND DASHBOARD")
tableTextColor = input(color.white, "Table Text Color", group="TREND DASHBOARD")
tableBgColor = input(#2A2A2A, "Table Background Color", group="TREND DASHBOARD")
sizeDashboard = input.string("Normal", "Table Size", , group="TREND DASHBOARD")
showRevBands = input.bool(true, "Show Reversal Bands", group="REVERSAL BANDS")
lenRevBands = input.int(30, "Length", group="REVERSAL BANDS")
// Fonksiyonlar
smoothrng(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x ), t)
smoothrng = ta.ema(avrng, wper) * m
rngfilt(x, r) =>
rngfilt = x
rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r
percWidth(len, perc) => (ta.highest(len) - ta.lowest(len)) * perc / 100
securityNoRep(sym, res, src) => request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on)
swingPoints(prd) =>
pivHi = ta.pivothigh(prd, prd)
pivLo = ta.pivotlow (prd, prd)
last_pivHi = ta.valuewhen(pivHi, pivHi, 1)
last_pivLo = ta.valuewhen(pivLo, pivLo, 1)
hh = pivHi and pivHi > last_pivHi ? pivHi : na
lh = pivHi and pivHi < last_pivHi ? pivHi : na
hl = pivLo and pivLo > last_pivLo ? pivLo : na
ll = pivLo and pivLo < last_pivLo ? pivLo : na
f_chartTfInMinutes() =>
float _resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1 :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 60. * 24 :
timeframe.isweekly ? 60. * 24 * 7 :
timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
f_kc(src, len, hassasiyet) =>
basis = ta.sma(src, len)
span = ta.atr(len)
wavetrend(src, chlLen, avgLen) =>
esa = ta.ema(src, chlLen)
d = ta.ema(math.abs(src - esa), chlLen)
ci = (src - esa) / (0.015 * d)
wt1 = ta.ema(ci, avgLen)
wt2 = ta.sma(wt1, 3)
f_top_fractal(src) => src < src and src < src and src > src and src > src
f_bot_fractal(src) => src > src and src > src and src < src and src < src
f_fractalize (src) => f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0
f_findDivs(src, topLimit, botLimit) =>
fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na
fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na
highPrev = ta.valuewhen(fractalTop, src , 0)
highPrice = ta.valuewhen(fractalTop, high , 0)
lowPrev = ta.valuewhen(fractalBot, src , 0)
lowPrice = ta.valuewhen(fractalBot, low , 0)
bearSignal = fractalTop and high > highPrice and src < highPrev
bullSignal = fractalBot and low < lowPrice and src > lowPrev
// Bileşen...
source = close
smrng1 = smoothrng(source, 27, 1.5)
smrng2 = smoothrng(source, 55, hassasiyet)
smrng = (smrng1 + smrng2) / 2
filt = rngfilt(source, smrng)
up = 0.0, up := filt > filt ? nz(up ) + 1 : filt < filt ? 0 : nz(up )
dn = 0.0, dn := filt < filt ? nz(dn ) + 1 : filt > filt ? 0 : nz(dn )
bullCond = bool(na), bullCond := source > filt and source > source and up > 0 or source > filt and source < source and up > 0
bearCond = bool(na), bearCond := source < filt and source < source and dn > 0 or source < filt and source > source and dn > 0
lastCond = 0, lastCond := bullCond ? 1 : bearCond ? -1 : lastCond
bull = bullCond and lastCond == -1
bear = bearCond and lastCond == 1
countBull = ta.barssince(bull)
countBear = ta.barssince(bear)
trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0
ribbon1 = ta.sma(close, smooth1)
ribbon2 = ta.sma(close, smooth2)
rsi = ta.rsi(close, 21)
rsiOb = rsi > 70 and rsi > ta.ema(rsi, 10)
rsiOs = rsi < 30 and rsi < ta.ema(rsi, 10)
dHigh = securityNoRep(syminfo.tickerid, "D", high )
dLow = securityNoRep(syminfo.tickerid, "D", low )
dClose = securityNoRep(syminfo.tickerid, "D", close )
ema1 = ta.ema(srcEma1, lenEma1)
ema2 = ta.ema(srcEma2, lenEma2)
ema3 = ta.ema(srcEma3, lenEma3)
= swingPoints(prdSwing)
ema = ta.ema(close, 144)
emaBull = close > ema
equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes() and not timeframe.isseconds
higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes() or timeframe.isseconds
too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10)
securityNoRep1(sym, res, src) =>
bool bull_ = na
bull_ := equal_tf(res) ? src : bull_
bull_ := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) : bull_
bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) + (timeframe.isseconds ? "S" : "") : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)
if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)
bull_ := array.pop(bull_array)
array.clear(bull_array)
bull_
TF1Bull = securityNoRep1(syminfo.tickerid, "1" , emaBull)
TF3Bull = securityNoRep1(syminfo.tickerid, "3" , emaBull)
TF5Bull = securityNoRep1(syminfo.tickerid, "5" , emaBull)
TF15Bull = securityNoRep1(syminfo.tickerid, "15" , emaBull)
TF30Bull = securityNoRep1(syminfo.tickerid, "30" , emaBull)
TF60Bull = securityNoRep1(syminfo.tickerid, "60" , emaBull)
TF120Bull = securityNoRep1(syminfo.tickerid, "120" , emaBull)
TF240Bull = securityNoRep1(syminfo.tickerid, "240" , emaBull)
TF480Bull = securityNoRep1(syminfo.tickerid, "480" , emaBull)
TFDBull = securityNoRep1(syminfo.tickerid, "1440", emaBull)
= f_kc(close, lenRevBands, 3)
= f_kc(close, lenRevBands, 4)
= f_kc(close, lenRevBands, 5)
= f_kc(close, lenRevBands, 6)
= wavetrend(hlc3, 9, 12)
= f_findDivs(wt2, 15, -40)
= f_findDivs(wt2, 45, -65)
wtDivBull = wtDivBull1 or wtDivBull2
wtDivBear = wtDivBear1 or wtDivBear2
// Renkler
cyan = #00DBFF, cyan30 = color.new(cyan, 70)
pink = #E91E63, pink30 = color.new(pink, 70)
red = #FF5252, red30 = color.new(red , 70)
// Plotlar
off = percWidth(300, offsetSignal)
plotshape(showBuySell and bull ? low - off : na, "Buy Label" , shape.labelup , location.absolute, cyan, 0, "Buy" , color.white, size=size.normal)
plotshape(showBuySell and bear ? high + off : na, "Sell Label", shape.labeldown, location.absolute, pink, 0, "Sell", color.white, size=size.normal)
plotshape(ta.crossover(wt1, wt2) and wt2 <= -53, "Mild Buy" , shape.xcross, location.belowbar, cyan, size=size.tiny)
plotshape(ta.crossunder(wt1, wt2) and wt2 >= 53, "Mild Sell", shape.xcross, location.abovebar, pink, size=size.tiny)
plotshape(wtDivBull, "Divergence Buy ", shape.triangleup , location.belowbar, cyan, size=size.tiny)
plotshape(wtDivBear, "Divergence Sell", shape.triangledown, location.abovebar, pink, size=size.tiny)
barcolor(up > dn ? cyan : pink)
plotshape(showreversal and rsiOs, "Reversal Buy" , shape.diamond, location.belowbar, cyan30, size=size.tiny)
plotshape(showreversal and rsiOb, "Reversal Sell", shape.diamond, location.abovebar, pink30, size=size.tiny)
lStyle = lineStyle == "Solid" ? line.style_solid : lineStyle == "Dotted" ? line.style_dotted : line.style_dashed
lSize = labelSize == "small" ? size.small : labelSize == "normal" ? size.normal : size.large
dHighLine = showPdHlc ? line.new(bar_index, dHigh, bar_index + 1, dHigh , xloc.bar_index, extend.both, lineColor, lStyle, lineWidth) : na, line.delete(dHighLine )
dLowLine = showPdHlc ? line.new(bar_index, dLow , bar_index + 1, dLow , xloc.bar_index, extend.both, lineColor, lStyle, lineWidth) : na, line.delete(dLowLine )
dCloseLine = showPdHlc ? line.new(bar_index, dClose, bar_index + 1, dClose, xloc.bar_index, extend.both, lineColor, lStyle, lineWidth) : na, line.delete(dCloseLine )
dHighLabel = showPdHlc ? label.new(bar_index + 100, dHigh , "P.D.H", xloc.bar_index, yloc.price, #000000, label.style_none, labelColor, lSize) : na, label.delete(dHighLabel )
dLowLabel = showPdHlc ? label.new(bar_index + 100, dLow , "P.D.L", xloc.bar_index, yloc.price, #000000, label.style_none, labelColor, lSize) : na, label.delete(dLowLabel )
dCloseLabel = showPdHlc ? label.new(bar_index + 100, dClose, "P.D.C", xloc.bar_index, yloc.price, #000000, label.style_none, labelColor, lSize) : na, label.delete(dCloseLabel )
plot(showEmas ? ema1 : na, "EMA 1", color.green , 2)
plot(showEmas ? ema2 : na, "EMA 2", color.purple, 2)
plot(showEmas ? ema3 : na, "EMA 3", color.yellow, 2)
plotshape(showSwing ? hh : na, "", shape.triangledown, location.abovebar, color.new(color.green, 50), -prdSwing, "HH", colorPos, false)
plotshape(showSwing ? hl : na, "", shape.triangleup , location.belowbar, color.new(color.green, 50), -prdSwing, "HL", colorPos, false)
plotshape(showSwing ? lh : na, "", shape.triangledown, location.abovebar, color.new(color.red , 50), -prdSwing, "LH", colorNeg, false)
plotshape(showSwing ? ll : na, "", shape.triangleup , location.belowbar, color.new(color.red , 50), -prdSwing, "LL", colorNeg, false)
srcStop = close
atrBand = srcStop * (percentStop / 100)
atrStop = trigger ? srcStop - atrBand : srcStop + atrBand
lastTrade(src) => ta.valuewhen(bull or bear, src, 0)
entry_y = lastTrade(srcStop)
stop_y = lastTrade(atrStop)
tp1_y = (entry_y - lastTrade(atrStop)) * 1 + entry_y
tp2_y = (entry_y - lastTrade(atrStop)) * 2 + entry_y
tp3_y = (entry_y - lastTrade(atrStop)) * 3 + entry_y
labelTpSl(y, txt, color) =>
label labelTpSl = percentStop != 0 ? label.new(bar_index + 1, y, txt, xloc.bar_index, yloc.price, color, label.style_label_left, color.white, size.normal) : na
label.delete(labelTpSl )
labelTpSl(entry_y, "Entry: " + str.tostring(math.round_to_mintick(entry_y)), color.gray)
labelTpSl(stop_y , "Stop Loss: " + str.tostring(math.round_to_mintick(stop_y)), color.red)
labelTpSl(tp1_y, "Take Profit 1: " + str.tostring(math.round_to_mintick(tp1_y)), color.green)
labelTpSl(tp2_y, "Take Profit 2: " + str.tostring(math.round_to_mintick(tp2_y)), color.green)
labelTpSl(tp3_y, "Take Profit 3: " + str.tostring(math.round_to_mintick(tp3_y)), color.green)
lineTpSl(y, color) =>
line lineTpSl = percentStop != 0 ? line.new(bar_index - (trigger ? countBull : countBear) + 4, y, bar_index + 1, y, xloc.bar_index, extend.none, color, line.style_solid) : na
line.delete(lineTpSl )
lineTpSl(entry_y, color.gray)
lineTpSl(stop_y, color.red)
lineTpSl(tp1_y, color.green)
lineTpSl(tp2_y, color.green)
lineTpSl(tp3_y, color.green)
var dashboard_loc = locationDashboard == "Top Right" ? position.top_right : locationDashboard == "Middle Right" ? position.middle_right : locationDashboard == "Bottom Right" ? position.bottom_right : locationDashboard == "Top Center" ? position.top_center : locationDashboard == "Middle Center" ? position.middle_center : locationDashboard == "Bottom Center" ? position.bottom_center : locationDashboard == "Top Left" ? position.top_left : locationDashboard == "Middle Left" ? position.middle_left : position.bottom_left
var dashboard_size = sizeDashboard == "Large" ? size.large : sizeDashboard == "Normal" ? size.normal : sizeDashboard == "Small" ? size.small : size.tiny
var dashboard = showDashboard ? table.new(dashboard_loc, 2, 15, tableBgColor, #000000, 2, tableBgColor, 1) : na
dashboard_cell(column, row, txt, signal=false) => table.cell(dashboard, column, row, txt, 0, 0, signal ? #000000 : tableTextColor, text_size=dashboard_size)
dashboard_cell_bg(column, row, col) => table.cell_set_bgcolor(dashboard, column, row, col)
if barstate.islast and showDashboard
dashboard_cell(0, 0 , "EzAlgo")
dashboard_cell(0, 1 , "Current Position")
dashboard_cell(0, 2 , "Current Trend")
dashboard_cell(0, 3 , "Volume")
dashboard_cell(0, 4 , "Timeframe")
dashboard_cell(0, 5 , "1 min:")
dashboard_cell(0, 6 , "3 min:")
dashboard_cell(0, 7 , "5 min:")
dashboard_cell(0, 8 , "15 min:")
dashboard_cell(0, 9 , "30 min:")
dashboard_cell(0, 10, "1 H:")
dashboard_cell(0, 11, "2 H:")
dashboard_cell(0, 12, "4 H:")
dashboard_cell(0, 13, "8 H:")
dashboard_cell(0, 14, "Daily:")
dashboard_cell(1, 0 , "V.8.1")
dashboard_cell(1, 1 , trigger ? "Buy" : "Sell", true), dashboard_cell_bg(1, 1, trigger ? color.green : color.red)
dashboard_cell(1, 2 , emaBull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 2, emaBull ? color.green : color.red)
dashboard_cell(1, 3 , str.tostring(volume))
dashboard_cell(1, 4 , "Trends")
dashboard_cell(1, 5 , TF1Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 5 , TF1Bull ? color.green : color.red)
dashboard_cell(1, 6 , TF3Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 6 , TF3Bull ? color.green : color.red)
dashboard_cell(1, 7 , TF5Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 7 , TF5Bull ? color.green : color.red)
dashboard_cell(1, 8 , TF15Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 8 , TF15Bull ? color.green : color.red)
dashboard_cell(1, 9 , TF30Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 9 , TF30Bull ? color.green : color.red)
dashboard_cell(1, 10, TF60Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 10, TF60Bull ? color.green : color.red)
dashboard_cell(1, 11, TF120Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 11, TF120Bull ? color.green : color.red)
dashboard_cell(1, 12, TF240Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 12, TF240Bull ? color.green : color.red)
dashboard_cell(1, 13, TF480Bull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 13, TF480Bull ? color.green : color.red)
dashboard_cell(1, 14, TFDBull ? "Bullish" : "Bearish", true), dashboard_cell_bg(1, 14, TFDBull ? color.green : color.red)
plot(showRevBands ? upperKC1 : na, "Rev.Zone Upper 1", red30)
plot(showRevBands ? upperKC2 : na, "Rev.Zone Upper 2", red30)
plot(showRevBands ? upperKC3 : na, "Rev.Zone Upper 3", red30)
plot(showRevBands ? upperKC4 : na, "Rev.Zone Upper 4", red30)
plot(showRevBands ? lowerKC4 : na, "Rev.Zone Lower 4", cyan30)
plot(showRevBands ? lowerKC3 : na, "Rev.Zone Lower 3", cyan30)
plot(showRevBands ? lowerKC2 : na, "Rev.Zone Lower 2", cyan30)
plot(showRevBands ? lowerKC1 : na, "Rev.Zone Lower 1", cyan30)
fill(plot(showRibbon ? ribbon1 : na, "", na, editable=false), plot(showRibbon ? ribbon2 : na, "", na, editable=false), ribbon1 > ribbon2 ? cyan30 : pink30, "Ribbon Fill Color")
// Alarmlar
alert01 = ta.crossover(ribbon1, ribbon2)
alert02 = bull
alert03 = wtDivBull
alert04 = wtDivBear
alert05 = bull or bear
alert06 = ta.crossover(wt1, wt2) and wt2 <= -53
alert07 = ta.crossunder(wt1, wt2) and wt2 >= 53
alert08 = ta.crossunder(ribbon1, ribbon2)
alert09 = rsiOb or rsiOs
alert10 = bear
alert11 = ta.cross(ribbon1, ribbon2)
alerts(sym) =>
if alert02 or alert03 or alert04 or alert06 or alert07 or alert10
alert_text = alert02 ? "Buy Signal EzAlgo" : alert03 ? "Strong Buy Signal EzAlgo" : alert04 ? "Strong Sell Signal EzAlgo" : alert06 ? "Mild Buy Signal EzAlgo" : alert07 ? "Mild Sell Signal EzAlgo" : "Sell Signal EzAlgo"
alert(alert_text, alert.freq_once_per_bar_close)
alerts(syminfo.tickerid)
alertcondition(alert01, "Blue Trend Ribbon Alert", "Blue Trend Ribbon, TimeFrame={{interval}}")
alertcondition(alert02, "Buy Signal", "Buy Signal EzAlgo")
alertcondition(alert03, "Divergence Buy Alert", "Strong Buy Signal EzAlgo, TimeFrame={{interval}}")
alertcondition(alert04, "Divergence Sell Alert", "Strong Sell Signal EzAlgo, TimeFrame={{interval}}")
alertcondition(alert05, "Either Buy or Sell Signal", "EzAlgo Signal")
alertcondition(alert06, "Mild Buy Alert", "Mild Buy Signal EzAlgo, TimeFrame={{interval}}")
alertcondition(alert07, "Mild Sell Alert", "Mild Sell Signal EzAlgo, TimeFrame={{interval}}")
alertcondition(alert08, "Red Trend Ribbon Alert", "Red Trend Ribbon, TimeFrame={{interval}}")
alertcondition(alert09, "Reversal Signal", "Reversal Signal")
alertcondition(alert10, "Sell Signal", "Sell Signal EzAlgo")
alertcondition(alert11, "Trend Ribbon Color Change Alert", "Trend Ribbon Color Change, TimeFrame={{interval}}")
Pivot Oscillator█ OVERVIEW
Pivot Oscillator is a versatile oscillator that measures market strength by comparing the current price to local price pivots. Values are scaled by ATR, normalized to a 0–100 range, and displayed along with an SMA line.
Oscillator: generates signals suitable for pullback strategies.
SMA line: serves as a momentum indicator.
█ CONCEPTS
Pivot Oscillator is designed with dual functionality:
- Oscillator & signals: ideal for pullback strategies, detecting local highs/lows and short-term reversals.
- SMA (Momentum): shows stable market-side dominance and filters price impulses.
Calculation logic:
- Oscillator = closing price − pivot line (derived from average high/low pivots).
Scaled by ATR and normalized to 0–100:
50 – bullish dominance,
< 50 – bearish dominance.
SMA is computed from smoothed oscillator values and serves as a momentum indicator.
█ FEATURES
Pivot Calculation:
- Pivot Length (lenSwing) – the number of bars used to identify local pivots (highs/lows). Higher values filter only larger extremes, while lower values make the oscillator react faster to local highs and lows.
- Pivot Level (pivotLevel) – determines the position of the pivot line between the average low and high pivots. A value of 0.5 places the pivotLine exactly halfway between the average high and low pivots; values closer to 0 or 1 shift the line toward the low or high pivots, respectively.
- Pivot Lookback (lookback) – the number of recent pivots used to calculate the average pivot, which smooths the pivotLine and reduces noise caused by individual extremes.
- Oscillator calculation: closing price − pivotLine (average of pivots computed from the above parameters).
The pivotLine is then scaled by ATR and normalized to a 0–100 range.
ATR Scaling:
- ATR period (atrLen)
- Multipliers (multUp / multDown) for upper and lower scaling.
Dynamic Colors:
- Oscillator > 50 → green (bullish)
- Oscillator < 50 → red (bearish)
SMA Line (Momentum):
- Smoothed oscillator (SMA) serves as a momentum indicator.
- Dynamic color indicates direction of SMA.
- Helps identify dominant market side and trend.
Overbought / Oversold Zones:
- Configurable OB/OS levels for both oscillator and SMA.
- Dynamic band colors: change depending on SMA relative to maOverbought / maOversold.
- Provides visual confirmation for potential corrections or strong momentum.
Gradients & Visualization:
- Oscillator and SMA gradients (3 layers) with adjustable transparency.
- Gradient visualization for OB/OS zones and oscillator.
- Full customization of colors, line width, and transparency.
Signals:
- Oscillator leaving oversold zone → long signal
- Oscillator leaving overbought zone → short signal
- OB/OS band colors dynamically reflect SMA levels for additional confirmation.
Alerts:
- OB/OS cross alerts.
█ HOW TO USE
Add the indicator to your TradingView chart → Indicators → search for “Pivot Oscillator”.
Parameter Configuration:
- Pivot Settings: pivot length, pivot level, pivot lookback.
- ATR Settings: ATR period, scaling multipliers.
- Threshold Levels: OB/OS levels for oscillator and SMA.
- Signal Settings: SMA length, extra smoothing.
- Style Settings: bullish/bearish colors, OB/OS lines, midline, text colors.
- Gradient Settings: enable/disable gradients and transparency.
Signal Interpretation:
BUY (Long):
- Oscillator leaves the oversold zone (OS crossover).
- OB/OS band color may additionally confirm the signal when SMA < maOversold.
SELL (Short):
- Oscillator leaves the overbought zone (OB crossunder).
- OB/OS band color may additionally confirm the signal when SMA > maOverbought.
█ APPLICATIONS
Pivot Oscillator and SMA can be scaled for different strategies:
- Pullback strategies: oscillator detects local highs/lows.
- Momentum / Trend: SMA shows market-side dominance and trend direction.
Adjust pivot and ATR parameters:
- Lower settings: faster reaction, suitable for scalping or intraday trading.
- Higher settings: more stable readings, suitable for swing trading or longer timeframes.
█ NOTES
- In strong trends, the oscillator may remain in extreme zones for extended periods – reflects dominance, not necessarily a reversal.
- OB/OS levels should be adapted to the instrument and pivot/ATR settings.
- Works best when combined with other tools: support/resistance, market structure, and volume analysis.
DR/IDR Break .5 TPDR/IDR Extension Breakout with Custom Stop
This strategy is a systematic, counter-trend, and momentum-based system designed for intraday trading. It operates on the principle of an Opening Range Breakout (ORB), utilizing the initial market consolidation to project high-probability targets, while offering multiple methods for managing risk.
1. Market Identification (The Opening Range)
The strategy begins by defining the market's initial boundaries and volatility:
Session Window: The strategy calculates the Opening Range (OR) over a user-defined time period (default: 9:30 AM to 10:30 AM New York Time).
ORB Levels: Two key price levels are established and locked once the time window closes:
Wick High/Low: The absolute highest and lowest prices of the session. These serve as the entry trigger lines.
Body High/Low (Shaded Range): The highest and lowest open/close prices of the session. The height of this range is used to calculate the Take Profit and Stop Loss levels.
2. Entry Rule (The Breakout)
The strategy is passive until the range is violated, looking for a strong move out of the consolidation area.
Trigger Condition: A trade is signaled when a candle closes either:
Above the Wick High (for a Long entry).
Below the Wick Low (for a Short entry).
Execution: The entry is a Market Order executed on the candle that meets the trigger condition, subject to a user-defined Entry Delay (default 0 bars, meaning the entry is taken immediately upon the breakout candle's close).
Direction Control: The user can select to trade Long Only, Short Only, or Both.
3. Exit and Risk Management
All trades are placed with simultaneous Take Profit and Stop Loss orders (a bracket order) once the entry is filled.
A. Take Profit (TP)
The Take Profit is set at the 0.5 Extension of the Shaded Range (Body Range).
Calculation: The distance from the Body High/Low to the TP level is exactly 50% of the total height of the Shaded Range.
B. Stop Loss (SL)
The Stop Loss is dynamically calculated based on a user-selected method for risk control:
Range 0.5 (Body Range): The Stop Loss is placed an equal distance (0.5 times the Body Range height) outside the opposite side of the Body Range.
Example (Long): If entry is above the Wick High, the SL is set 0.5 times the Body Range height below the Body Low.
ATR Multiple: The Stop Loss distance is determined by the asset's recent volatility.
Calculation: The distance is calculated as a user-defined Multiplier (default 2.0) times the Average True Range (ATR).
Recent Swing Low/High: The Stop Loss is placed based on a structural level defined by recent price action.
Long Entry: SL is placed at the Lowest Swing Low within a user-defined lookback period.
Short Entry: SL is placed at the Highest Swing High within a user-defined lookback period.
Summary of Workflow
The market sets the Wick and Body boundaries (e.g., 9:30–10:30 AM).
Price breaks and closes beyond a Wick boundary, triggering a signal.
The trade enters after the specified delay.
A bracket order is placed: TP is fixed at the 0.5 Extension, and SL is set based on the user's chosen risk method.
The trade is closed upon reaching either the TP or the SL level.
TRZigZagLibLibrary "TRZigZagLib"
method directionName(this)
Gets pivot direction as string
Namespace types: Pivot
Parameters:
this (Pivot) : Pivot instance
Returns: "HIGH" or "LOW"
method isHigh(this)
Checks if pivot is a high
Namespace types: Pivot
Parameters:
this (Pivot) : Pivot instance
Returns: true if pivot is a high
method isLow(this)
Checks if pivot is a low
Namespace types: Pivot
Parameters:
this (Pivot) : Pivot instance
Returns: true if pivot is a low
method newSettings(minLength, minBarSize, maxBarSize)
Creates default ZigZag settings
Namespace types: series int, simple int, input int, const int
Parameters:
minLength (int) : Minimum pivot length (default: 10)
minBarSize (int) : Minimum bars between pivots (default: 5)
maxBarSize (int) : Maximum bars to lookback (default: 300)
Returns: New ZigZagSettings instance
method setLineStyle(this, lineColor, lineWidth, lineStyle)
Sets line appearance
Namespace types: ZigZagSettings
Parameters:
this (ZigZagSettings) : Settings instance
lineColor (color)
lineWidth (int)
lineStyle (string)
Returns: Modified settings instance
method newZigZag(settings, depth)
Creates a new ZigZag instance
Namespace types: ZigZagSettings
Parameters:
settings (ZigZagSettings) : ZigZag settings
depth (int) : Depth value for this ZigZag
Returns: New ZigZag instance
method calculate(this)
Calculates ZigZag using LuxAlgo-style pivot detection
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
method getLastPivots(this, count)
Gets the last N pivots
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
count (int) : Number of pivots to get (default: 5)
Returns: Array of pivots
method getPivot(this, index)
Gets pivot at index
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
index (int) : Index (0 = most recent)
Returns: Pivot or na
method truncate(this, maxBars)
Truncates old pivots beyond lookback window
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
maxBars (int) : Maximum bars to keep
method newMultiZigZag(settings, minDepth, maxDepth, count)
Creates a new MultiZigZag manager
Namespace types: ZigZagSettings
Parameters:
settings (ZigZagSettings) : Base settings for all ZigZags
minDepth (int) : Minimum depth value
maxDepth (int) : Maximum depth value
count (int) : Number of ZigZag instances (max 11)
Returns: New MultiZigZag instance
method calculateAll(this)
Updates all ZigZag instances
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
method getZigZag(this, index)
Gets ZigZag at index
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
index (int) : Index (0 to count-1)
Returns: ZigZag instance or na
method getDepth(this, index)
Gets depth value at index
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
index (int) : Index (0 to count-1)
Returns: Depth value
method size(this)
Gets total number of ZigZag instances
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
Returns: Count of ZigZag instances
method truncateAll(this, maxBars)
Truncates all ZigZag instances
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
maxBars (int) : Maximum bars to keep
method distance(p1, p2)
Calculates distance between two pivots
Namespace types: Pivot
Parameters:
p1 (Pivot) : First pivot
p2 (Pivot) : Second pivot
Returns: Price distance (absolute)
method barSpan(p1, p2)
Calculates bar span between two pivots
Namespace types: Pivot
Parameters:
p1 (Pivot) : First pivot
p2 (Pivot) : Second pivot
Returns: Bar span (absolute)
method isAlternating(pivots)
Checks if pivots are alternating (high-low-high or low-high-low)
Namespace types: array
Parameters:
pivots (array) : Array of pivots
Returns: true if alternating pattern exists
Pivot
Pivot point in the chart
Fields:
d (series int) : Direction: 1=high, -1=low
x (series int) : Bar index
y (series float) : Price
confirmed (series bool) : Pivot confirmation flag
ZigZagSettings
ZigZag configuration settings
Fields:
minLength (series int) : Minimum pivot detection length
minBarSize (series int) : Minimum bars between pivots
maxBarSize (series int) : Maximum bars to lookback
lineColor (series color) : ZigZag line color
lineWidth (series int) : ZigZag line width
lineStyle (series string) : ZigZag line style
ZigZag
Single ZigZag instance
Fields:
settings (ZigZagSettings) : Configuration settings
pivots (array) : Array of pivot points (max 25 for patterns)
lastUpdateBar (series int) : Last bar index when updated
depth (series int) : Current depth value
MultiZigZag
Multi-depth ZigZag manager
Fields:
zigzags (array) : Array of ZigZag instances (max 11)
depthValues (array) : Array of depth values being used
currentBar (series int) : Current bar index being processed
Trend Following $ZEC - Multi-Timeframe Structure Filter + Revers# Trend Following CRYPTOCAP:ZEC - Strategy Guide
## 📊 Strategy Overview
Trend Following CRYPTOCAP:ZEC is an enhanced Turtle Trading system designed for cryptocurrency spot trading, combining Donchian Channel breakouts, multi-timeframe structure filtering, and ATR-based dynamic risk management for both long and short positions.
---
## 🎯 Core Features
1. Multi-Timeframe Structure Filtering
- Uses Swing High/Low to identify market structure
- Customizable structure timeframe (default: 1 minute)
- Only enters trades in the direction of the trend, avoiding counter-trend positions
2. Reverse Signal Exit
- No fixed stop-loss or fixed-period exits
- Exits only when a reverse entry signal triggers
- Maximizes trend profits, reduces premature exits
3. ATR Dynamic Pyramiding
- Adds positions when price moves 0.5 ATR in favorable direction
- Supports up to 2 units maximum (adjustable)
- Pyramid scaling to enhance profitability
4. Complete Risk Management
- Fixed position size (5000 USD per unit)
- Commission fee 0.06% (Binance spot rate)
- Initial capital 10,000 USD
---
## 📈 Trading Logic
Entry Conditions
✅ Long Entry:
- Close price breaks above 20-period high
- Structure trend is bullish (price breaks above Swing High)
✅ Short Entry:
- Close price breaks below 20-period low
- Structure trend is bearish (price breaks below Swing Low)
Add Position Conditions
- Long: Price rises ≥ 0.5 ATR
- Short: Price falls ≥ 0.5 ATR
- Maximum 2 units including initial entry
Exit Conditions
- Long Exit: When short entry signal triggers (price breaks 20-period low + structure turns bearish)
- Short Exit: When long entry signal triggers (price breaks 20-period high + structure turns bullish)
---
## ⚙️ Parameter Settings
Channel Settings
- Entry Channel Period: 20 (Donchian Channel breakout period)
- Exit Channel Period: 10 (reserved parameter, actually uses reverse signal exit)
ATR Settings
- ATR Period: 20
- Stop Loss ATR Multiplier: 2.0 (reserved parameter)
- Add Position ATR Multiplier: 0.5
Structure Filter
- Swing Length: 160 (Swing High/Low calculation period)
- Structure Timeframe: 1 minute (can change to 5/15/60, etc.)
Position Management
- Maximum Units: 2 (including initial entry)
- Capital Per Unit: 5000 USD
---
## 🎨 Visualization Features
Background Colors
- Light Green: Bullish structure
- Light Red: Bearish structure
- Dark Green: Long entry
- Dark Red: Short entry
Optional Display (Default: OFF)
- Entry/exit channel lines
- Structure high/low lines
- ATR stop-loss line
- Next add position indicator
- Entry/exit labels
---
## 📱 Alert Message Format
Strategy sends notifications on entry/exit with the following format:
- Entry: `1m Long EP:428.26`
- Add Position: `15m Add Long 2/2 EP:429.50`
- Exit: `1m Close Long Reverse Signal`
Where:
- `1m`/`15m` = Current chart timeframe
- `EP` = Entry Price
---
## 💰 Backtest Settings
Capital Allocation
- Initial Capital: 10,000 USD
- Per Entry: 5,000 USD (split into 2 entries)
- Leverage: 0x (spot trading)
Trading Costs
- Commission: 0.06% (Binance spot VIP0)
- Slippage: 0
---
## 🎯 Use Cases
✅ Best Scenarios
- Trending markets
- Moderate volatility assets
- 1-minute to 4-hour timeframes
⚠️ Not Suitable For
- Highly volatile choppy markets
- Low liquidity small-cap coins
- Extreme market conditions (black swan events)
---
## 📊 Usage Recommendations
Timeframe Suggestions
| Timeframe | Trading Style | Suggested Parameter Adjustment |
|-----------|--------------|-------------------------------|
| 1-5 min | Scalping | Swing Length 100-160 |
| 15-30 min | Short-term | Swing Length 50-100 |
| 1-4 hour | Swing Trading | Swing Length 20-50 |
Optimization Tips
1. Adjust swing length based on backtest results
2. Different coins may require different parameters
3. Recommend backtesting on 1-minute chart first before live trading
4. Enable labels to observe entry/exit points
---
## ⚠️ Risk Disclaimer
1. Past Performance Does Not Guarantee Future Results
- Backtest data is for reference only
- Live trading may be affected by slippage, delays, etc.
2. Market Condition Changes
- Strategy performs better in trending markets
- May experience frequent stops in ranging markets
3. Capital Management
- Do not invest more than you can afford to lose
- Recommend setting total capital stop-loss threshold
4. Commission Impact
- Frequent trading accumulates commission fees
- Recommend using exchange discounts (BNB fee reduction, etc.)
---
## 🔧 Troubleshooting
Q: No entry signals?
A: Check if structure filter is too strict, adjust swing length or timeframe
Q: Too many labels displayed?
A: Turn off "Show Labels" option in settings
Q: Poor backtest performance?
A:
1. Check if the coin is suitable for trend-following strategies
2. Adjust parameters (swing length, channel period)
3. Try different timeframes
Q: How to set alerts?
A:
1. Click "Alert" in top-right corner of chart
2. Condition: Select "Strategy - Trend Following CRYPTOCAP:ZEC "
3. Choose "Order filled"
4. Set notification method (Webhook/Email/App)
---
## 📞 Contact Information
Strategy Name: Trend Following CRYPTOCAP:ZEC
Version: v1.0
Pine Script Version: v6
Last Updated: December 2025
---
## 📄 Copyright Notice
This strategy is for educational and research purposes only.
All risks of using this strategy for live trading are borne by the user.
Commercial use without authorization is prohibited.
---
## 🎓 Learning Resources
To understand the strategy principles in depth, recommended reading:
- "The Complete TurtleTrader" - Curtis Faith
- "Trend Following" - Michael Covel
- TradingView Pine Script Official Documentation
---
Happy Trading! Remember to manage your risk 📈
FVG Maxing - Fair Value Gaps, Equilibrium, and Candle Patterns
What this script does
This open-source indicator highlights 3-candle fair value gaps (FVGs) on the active chart timeframe, draws their midpoint ("equilibrium") line, tracks when each gap is mitigated, and optionally marks simple candle patterns (engulfing and doji) for confluence. It is intended as an educational tool to study how price interacts with imbalances.
3-candle bullish and bearish FVG zones drawn as forward-extending boxes.
Equilibrium line at 50% of each gap.
Different styling for mitigated vs unmitigated gaps.
Compact statistics panel showing how many gaps are currently active and filled.
Optional overlays for bullish/bearish engulfing patterns and doji candles.
1. FVG logic (3-candle gaps)
The script focuses on a strict 3-candle definition of a fair value gap:
Three consecutive candles with the same body direction.
The wick of candle 3 is separated from the wick of candle 1 (no overlap).
A bullish gap is created when price moves up fast enough to leave a gap between candle 1 and 3. A bearish gap is the mirror case to the downside.
In Pine, the core detection looks like this:
// Three candles with the same body direction
bull_seq = close > open and close > open and close > open
bear_seq = close < open and close < open and close < open
// Wick gap between candle 1 and candle 3
bull_gap = bull_seq and low > high
bear_gap = bear_seq and high < low
// Final FVG flags
is_bull_fvg = bull_gap
is_bear_fvg = bear_gap
For each detected FVG:
Bullish FVG range: from high up to low (gap below current price).
Bearish FVG range: from low down to high (gap above current price).
Each zone is stored in a custom FVGData structure so it can be updated when price later trades back inside it.
2. Equilibrium line (0.5 of the gap)
Every FVG box gets an optional equilibrium line plotted at the midpoint between its top and bottom:
eq_level = (top + bottom) / 2.0
right_index = extend_boxes ? bar_index + extend_length_bars : bar_index
bx = box.new(bar_index - 2, top, right_index, bottom)
eq_ln = line.new(bar_index - 2, eq_level, right_index, eq_level)
line.set_style(eq_ln, line.style_dashed)
line.set_color(eq_ln, eq_color)
You can use this line as a neutral “fair value” reference inside the zone, or as a simple way to think in terms of premium/discount within each gap.
3. Mitigation rules and styling
Each FVG stays active until price trades back into the gap:
Bullish FVG is considered mitigated when the low touches or moves below the top of the gap.
Bearish FVG is considered mitigated when the high touches or moves above the bottom of the gap.
When that happens, the script:
Marks the internal FVGData entry as mitigated.
Softens the box fill and border colors.
Optionally updates the label text from "BULL EQ / BEAR EQ" to "BULL FILLED / BEAR FILLED".
Can hide mitigated zones almost completely if you only want to see unfilled imbalances.
This allows you to distinguish between current areas of interest and zones that have already been traded through.
4. Candle pattern overlays (engulfing and doji)
For additional confluence, the script can mark simple candle patterns on top of the FVG view:
Bullish engulfing — current candle body fully wraps the previous bearish body and is larger in size.
Bearish engulfing — current candle body fully wraps the previous bullish body and is larger in size.
Doji — candles where the real body is small relative to the full range (high–low).
The detection is based on basic body and range geometry:
curr_body = math.abs(close - open)
prev_body = math.abs(close - open )
curr_range = high - low
body_ratio = curr_range > 0 ? curr_body / curr_range : 1.0
bull_engulfing = close > open and close < open and open <= close and close >= open and curr_body > prev_body
bear_engulfing = close < open and close > open and open >= close and close <= open and curr_body > prev_body
is_doji = curr_range > 0 and body_ratio <= doji_body_ratio
On the chart, they appear as:
Small triangle markers below bullish engulfing candles.
Small triangle markers above bearish engulfing candles.
Small circles above doji candles.
All three overlays are optional and can be turned on or off and recolored in the CANDLE PATTERNS group of inputs.
5. Inputs overview
The script organizes settings into clear groups:
DISPLAY SETTINGS : Show bullish/bearish FVGs, show/hide mitigated zones, box extension length, box border width, and maximum number of boxes.
EQUILIBRIUM : Toggle equilibrium lines, color, and line width.
LABELS : Enable labels, choose whether to label unmitigated and/or mitigated zones, and select label size.
BULLISH COLORS / BEARISH COLORS : Separate fill and border colors for bullish and bearish gaps.
MITIGATED STYLE : Opacity used when a gap is marked as mitigated.
STATISTICS : Toggle the on-chart FVG statistics panel.
CANDLE PATTERNS : Show engulfing patterns, show dojis, colors, and the body-to-range threshold that defines a doji.
6. Statistics panel
An optional table in the corner of the chart summarizes the current state of all tracked gaps:
Total number of FVGs still being tracked.
Number of bullish vs bearish FVGs.
Number of unfilled vs mitigated FVGs.
Simple fill rate: percentage of tracked FVGs that have been marked as mitigated.
This can help you study how a particular market tends to treat gaps over time.
7. How you might use it (examples)
These are usage ideas only, not recommendations:
Study how often your symbol mitigates gaps and where inside the zone price tends to react.
Use higher-timeframe context and then refine entries near the equilibrium line on your trading timeframe.
Combine FVG zones with basic candle patterns (engulfing/doji) as an extra visual anchor, if that fits your process.
Hope you enjoy, give your feedback in the comments!
- officialjackofalltrades
Session Candle Hunter 🎯🎯 Session Candle Hunter — Precision Session Mapping for Smart Traders
Session Candle Hunter 🎯 is a powerful tool designed to help traders identify and track the most important session candle of the trading day—commonly used for liquidity grabs, range mapping, volatility zones, and breakout anticipation.
Whether you trade NY session, London session, or custom time windows, this indicator automatically detects the candle at your chosen New York Time, extracts its high and low, and visually projects these levels into the current session.
🔍 What This Indicator Does
1️⃣ Detects the Key Session Candle
You select:
Hour of the candle (NY Time)
Candle timeframe (1H, 4H, 15m, etc.)
The script automatically:
Identifies the candle when it forms
Stores its High/Low
Prepares levels for visual projection
🎨 2️⃣ Highlights the Candle Zone
Optionally displays a colored zone (box) between the candle’s high and low:
Helps visualize the liquidity pocket
Useful for session traps, expansion moves, and fair value interpretation
You can choose:
Zone color
Whether to show it or not
Whether it should update only for the latest candle
📈 3️⃣ Draws High/Low Lines With Extensions
High and Low of the detected candle can be plotted as:
Standard lines
Or infinitely extended to the right
Great for identifying:
Breakouts
Retests
Range boundaries
Session expansion models
Optional labels display exact price levels.
🕐 4️⃣ Delayed Display Logic
The indicator only shows levels after a user-defined NY time.
For example:
Show lines only after 8:30 NY — perfect for traders who want pre-session levels hidden until relevant.
🔄 5️⃣ “Show Only Last” Mode
A clean, uncluttered mode that removes all historical drawings and only displays:
The latest zone
The latest high/low lines
Latest labels
Perfect for minimal-chart traders.
⚠️ 6️⃣ Alert System
Receive alerts the moment the targeted session candle forms:
“New Candle Detected”
🧾 7️⃣ Info Panel (Top-Left Corner)
Displays:
Target session hour
Display start time
Candle timeframe
Stored High/Low
Indicator name
Always visible and automatically updates.
⭐ Why Traders Love This Tool
✔ Helps visualize major liquidity zones
✔ Works on all markets & timeframes
✔ Perfect for ICT-style session concepts
✔ Helps anticipate session expansion
✔ Automates manual level drawing
✔ Clean visuals with optional minimal mode
BB Breakout-Momentum + Reversion Strategies# BB Breakout-Momentum + Reversion Strategies
## Overview
This indicator combines two complementary Bollinger Band trading strategies that automatically adapt to market conditions. Strategy 1 capitalizes on trending markets with breakout-pullback-momentum setups, while Strategy 2 exploits mean reversion in ranging markets. Advanced filtering using ADX and BB Width ensures each strategy only fires in its optimal market environment.
---
## Strategy 1: Breakout → Pullback → Renewed Momentum (Long B / Short B)
### Best Market Conditions
- **Trending Markets**: ADX ≥ 25
- **High Volatility**: BB Width ≥ 1.0× average
- Directional price action with sustained momentum
### Entry Logic
**Long B (Bullish Breakout):**
1. **Initial Breakout**: Price breaks above upper Bollinger Band with strong momentum
2. **Controlled Pullback**: Price pulls back 1-12 bars but holds above lower band (stays in trend)
3. **Defended Zone**: Pullback creates a support zone based on swing lows (validated by multiple touches)
4. **Renewed Momentum**: Price reclaims with green candle, volume confirmation, bullish MACD
5. **Position Check**: Entry must have cushion below upper band and room to reach targets
**Short B (Bearish Breakdown):**
- Mirror logic for downtrends: breakdown below lower band, pullback stays below upper band, renewed selling pressure
### Risk Management
- **Stop Loss**: Lower of (zone floor/previous low) OR (1.5 × ATR from entry)
- **Targets**:
- T1: Entry + 0.85R (0.85 × 1.5 ATR)
- T2: Entry + 1.40R (1.40 × 1.5 ATR)
- T3: Entry + 2.50R (2.50 × 1.5 ATR)
- T4: Entry + 4.50R (4.50 × 1.5 ATR)
- Risk is calculated using ATR (ATRX = 1.5 ATR), stop uses tighter of structural level (ATRL) or ATRX
---
## Strategy 2: Bollinger Band Mean Reversion (Long R / Short R)
### Best Market Conditions
- **Ranging Markets**: ADX ≤ 20
- **Low Volatility**: BB Width ≤ 0.8× average
- Price oscillating around the mean without sustained trend
### Entry Logic
**Long R (Long Reversion):**
1. **Overextension**: Price breaks below lower Bollinger Band (2 consecutive closes)
2. **Snap Back**: Price crosses back above lower band (re-enters the range)
3. **Entry Window**: Within 2 candles of re-entry, look for:
- **Green candle** (close > open) confirming bullish strength
- Close above previous candle (close > close )
4. **Trigger**: First qualifying candle within 2-bar window executes the trade
**Short R (Short Reversion):**
1. **Overextension**: Price breaks above upper Bollinger Band (2 consecutive closes)
2. **Snap Back**: Price crosses back below upper band (re-enters the range)
3. **Entry Window**: Within 2 candles of re-entry, look for:
- **Red candle** (close < open) confirming bearish pressure
- Close below previous candle (close < close )
4. **Trigger**: First qualifying candle within 2-bar window executes the trade
### Risk Management
- **Stop Loss**: Lower of (previous high/low) OR (1.5 × ATR from entry)
- **Targets**: Same as Strategy 1 (0.85R, 1.4R, 2.5R, 4.5R based on 1.5 ATR)
- Betting on return to Bollinger Band basis (mean)
---
## Advanced Filtering System
### ADX Filter (Average Directional Index)
- **Purpose**: Measures trend strength vs choppy/ranging conditions
- **Trending**: ADX ≥ 25 → Enables Strategy 1 (Breakout)
- **Ranging**: ADX ≤ 20 → Enables Strategy 2 (Reversion)
- **Neutral**: ADX 20-25 → No signals (indecisive market)
### BB Width Filter
- **Purpose**: Confirms volatility expansion/contraction
- **Wide Bands**: Current width ≥ 1.0× 50-bar average → Trending environment
- **Narrow Bands**: Current width ≤ 0.8× 50-bar average → Ranging environment
- **Logic**: Both ADX and BB Width must agree on market state before signaling
### Combined Logic
- **Strategy 1 fires**: When BOTH ADX shows trending AND bands are wide
- **Strategy 2 fires**: When BOTH ADX shows ranging AND bands are narrow
- **Visual Display**: Table at bottom-right shows ADX value, BB Width ratio, and current market state
---
## Visual Elements
### Bollinger Bands
- **Gray line**: 20-period SMA (basis/mean)
- **Green line**: Upper band (basis + 2 standard deviations)
- **Red line**: Lower band (basis - 2 standard deviations)
### Strategy 1 Markers
- **Long B**: Green triangle below bar with "Long B" text
- **Short B**: Orange triangle above bar with "Short B" text
- **Defended Zones**: Green/red boxes showing pullback support/resistance areas
- **Targets**: Green/orange crosses showing T1-T4 and stop loss levels
### Strategy 2 Markers
- **Long R**: Blue label below bar with "Long R" text
- **Short R**: Purple label above bar with "Short R" text
- **Trade Levels**: Horizontal lines extending 50 bars forward
- Blue solid = Entry price
- Red dashed = Stop loss
- Green/Orange dotted = Targets (T1-T4)
### Market State Table
- **ADX**: Current value with color coding (green=trending, orange=ranging, gray=neutral)
- **BB Width**: Ratio vs 50-bar average (e.g., "1.15x" = 15% wider than average)
- **State**: TREND / RANGE / NEUTRAL classification
---
## Settings & Customization
### Bollinger Bands
- **BB Length**: 20 (default) - period for moving average
- **BB Std Dev**: 2.0 (default) - standard deviation multiplier
### ATR & Risk
- **ATR Length**: 14 (default) - period for Average True Range calculation
- All stop losses and targets are derived from 1.5 × ATR
### Trend/Range Filters
- **ADX Length**: 14 (default)
- **ADX Trending Threshold**: 25 (higher = stronger trend required)
- **ADX Ranging Threshold**: 20 (lower = tighter ranging condition)
- **BB Width Average Length**: 50 (period for comparing current width)
- **BB Width Trend Multiplier**: 1.0 (width must be ≥ this × average)
- **BB Width Range Multiplier**: 0.8 (width must be ≤ this × average)
- **Use ADX Filter**: Toggle on/off
- **Use BB Width Filter**: Toggle on/off
### Strategy 1 (Breakout-Momentum)
- **Breakout Lookback**: 15 bars (how far back to search for initial breakout)
- **Min Pullback Bars**: 1 (minimum consolidation period)
- **Max Pullback Bars**: 12 (maximum consolidation period)
- **Show Defended Zone**: Display support/resistance boxes
- **Show Signals**: Display Long B / Short B markers
- **Show Targets**: Display stop loss and target levels
### Strategy 2 (Reversion)
- **Show Signals**: Display Long R / Short R markers
- **Show Trade Levels**: Display entry, stop, and target lines
---
## How to Use This Indicator
### Step 1: Identify Market State
- Check the table in bottom-right corner
- **TREND**: Look for Strategy 1 signals (Long B / Short B)
- **RANGE**: Look for Strategy 2 signals (Long R / Short R)
- **NEUTRAL**: Wait for clearer conditions
### Step 2: Wait for Signal
- Signals only fire when ALL conditions are met (structural + momentum + filters + room-to-target)
- Signals are relatively rare but high-probability
### Step 3: Execute Trade
- **Entry**: Close of signal candle
- **Stop Loss**: Shown as red cross (Strategy 1) or red dashed line (Strategy 2)
- **Targets**: Scale out at T1, T2, T3, T4 or hold for maximum R:R
### Step 4: Management
- Consider moving stop to breakeven after T1
- Trail stop using swing lows/highs in Strategy 1
- Exit full position at T2-T3 in Strategy 2 (mean reversion has limited upside)
---
## Key Principles
### Why This Works
1. **Market Adaptation**: Uses right strategy for right conditions (trend vs range)
2. **Confluence**: Multiple confirmations required (structure + momentum + volatility + room)
3. **Risk-Defined**: Every trade has pre-calculated stop and targets based on ATR
4. **Probability**: Filters reduce noise and increase win rate by waiting for ideal setups
### Common Pitfalls to Avoid
- ❌ Taking signals in NEUTRAL market state (indicators disagree)
- ❌ Overriding the stop loss (it's calculated for a reason)
- ❌ Expecting signals on every swing (quality over quantity)
- ❌ Using Strategy 1 in ranging markets or Strategy 2 in trending markets
- ❌ Ignoring the room-to-target check (signal won't fire if targets are blocked)
### Complementary Analysis
This indicator works best when combined with:
- Higher timeframe trend analysis
- Key support/resistance levels
- Volume analysis
- Market structure (swing highs/lows)
- Risk management rules (position sizing, max daily loss, etc.)
---
## Technical Details
### Indicators Used
- **Bollinger Bands**: 20-period SMA ± 2 standard deviations
- **ATR**: 14-period Average True Range for volatility measurement
- **ADX**: 14-period Average Directional Index for trend strength
- **EMA**: 10 and 20-period exponential moving averages (Strategy 1 filter)
- **MACD**: 12/26/9 settings (Strategy 1 momentum confirmation)
- **Volume**: Compared to 15-bar average (Strategy 1 confirmation)
### Calculation Methodology
- **ATRL** (Structural Risk): Previous swing high/low or defended zone boundary
- **ATRX** (ATR Risk): 1.5 × 14-period ATR from entry price
- **Stop Loss**: Minimum of ATRL and ATRX (tightest protection)
- **Targets**: Always calculated from ATRX (consistent R-multiples)
- **BB Width Ratio**: Current BB width ÷ 50-period SMA of BB width
---
## Performance Notes
### Strengths
- Adapts to changing market conditions automatically
- Clear, objective entry and exit criteria
- Pre-defined risk on every trade
- Filters reduce false signals significantly
- Works across multiple timeframes and instruments
### Limitations
- Signals are infrequent (by design - quality over quantity)
- Requires patience to wait for all conditions to align
- May miss explosive moves if pullback doesn't form properly (Strategy 1)
- Ranging markets can transition to trending (Strategy 2 risk)
- Filters may delay entry in fast-moving markets
### Best Timeframes
- **Strategy 1**: 1H, 4H, Daily (needs time for proper pullback structure)
- **Strategy 2**: 15M, 30M, 1H (mean reversion works best intraday)
- Both strategies can work on any timeframe if market conditions are right
### Best Instruments
- **Liquid markets**: Major stocks, indices, forex pairs, liquid crypto
- **Sufficient volatility**: ATR should be meaningful relative to price
- **Clear trend/range cycles**: Markets that respect technical levels
---
## IMPORTANT DISCLAIMER
### Risk Warning
**TRADING INVOLVES SUBSTANTIAL RISK OF LOSS AND IS NOT SUITABLE FOR ALL INVESTORS.**
This indicator is provided for **educational and informational purposes only**. It does not constitute financial advice, investment advice, trading advice, or any other sort of advice. You should not treat any of the indicator's content as such.
### No Guarantee of Profit
Past performance is not indicative of future results. No trading strategy, including this indicator, can guarantee profits or protect against losses. The market is inherently unpredictable and all trading involves risk.
### User Responsibility
- **Do Your Own Research**: Always conduct your own analysis before making trading decisions
- **Test First**: Backtest and paper trade this strategy before risking real capital
- **Risk Management**: Never risk more than you can afford to lose
- **Position Sizing**: Use appropriate position sizes relative to your account
- **Stop Losses**: Always use stop losses and respect them
- **Market Conditions**: Understand that market conditions change and past behavior may not repeat
### No Liability
The creator of this indicator accepts no liability for any financial losses incurred through the use of this tool. All trading decisions are made at your own risk. You are solely responsible for evaluating the merits and risks associated with the use of any trading systems, signals, or content provided.
### Not Financial Advice
This indicator does not take into account your personal financial situation, investment objectives, risk tolerance, or specific needs. You should consult with a licensed financial advisor before making any investment decisions.
### Technical Limitations
- Indicators can repaint or lag in real-time
- Past signals may look different than real-time signals
- Code bugs or errors may exist despite testing
- TradingView platform limitations may affect functionality
### Market Risks
- Markets can gap, causing stops to be executed at worse prices
- Slippage and commissions can significantly impact results
- High volatility can cause unexpected losses
- Counterparty risk exists in all leveraged products
---
## Version History
- **v1.0**: Initial release combining breakout-momentum and mean reversion strategies
- Includes ADX and BB Width filtering
- ATRL/ATRX risk calculation system
- 2-candle entry window for reversion trades
---
## Credits & License
This indicator combines concepts from classical technical analysis including Bollinger Bands (John Bollinger), ATR (Welles Wilder), and ADX (Welles Wilder). The specific implementation and combination of filters is original work.
**Use at your own risk. Trade responsibly.**
---
*For questions, suggestions, or to report bugs, please comment below or contact the author.*
**Remember: The best indicator is the one between your ears. Use this tool as part of a comprehensive trading plan, not as a standalone solution.**
Omega Correlation [OmegaTools]Omega Correlation (Ω CRR) is a cross-asset analytics tool designed to quantify both the strength of the relationship between two instruments and the tendency of one to move ahead of the other. It is intended for traders who work with indices, futures, FX, commodities, equities and ETFs, and who require something more robust than a simple linear correlation line.
The indicator operates in two distinct modes, selected via the “Show” parameter: Correlation and Anticipation. In Correlation mode, the script focuses on how tightly the current chart and the chosen second asset move together. In Anticipation mode, it shifts to a lead–lag perspective and estimates whether the second asset tends to behave as a leader or a follower relative to the symbol on the chart.
In both modes, the core inputs are the chart symbol and a user-selected second symbol. Internally, both assets are transformed into normalized log-returns: the script computes logarithmic returns, removes short-term mean and scales by realized volatility, then clips extreme values. This normalisation allows the tool to compare behaviour across assets with different price levels and volatility profiles.
In Correlation mode, the indicator computes a composite correlation score that typically ranges between –1 and +1. Values near +1 indicate strong and persistent positive co-movement, values near zero indicate an unstable or weak link, and values near –1 indicate a stable anti-correlation regime. The composite score is constructed from three components.
The first component is a normalized return co-movement measure. After transforming both instruments into normalized returns, the script evaluates how similar those returns are bar by bar. When the two assets consistently deliver returns of similar sign and magnitude, this component is high and positive. When they frequently diverge or move in opposite directions, it becomes negative. This captures short-term co-movement in a volatility-adjusted way.
The second component focuses on high–low swing alignment. Rather than looking only at closes, it examines the direction of changes in highs and lows for each bar. If both instruments are printing higher highs and higher lows together, or lower highs and lower lows together, the swing structure is considered aligned. Persistent alignment contributes positively to the correlation score, while repeated mismatches between the swing directions reduce it. This helps differentiate between superficial price noise and structural similarity in trend behaviour.
The third component is a classical Pearson correlation on closing prices, computed over a longer lookback. This serves as a stabilising backbone that summarises general co-movement over a broader window. By combining normalized return co-movement, swing alignment and standard price correlation with calibrated weights, the Correlation mode provides a richer view than a single linear measure, capturing both short-term dynamic interaction and longer-term structural linkage.
In Anticipation mode, Omega Correlation estimates whether the second asset tends to lead or lag the current chart. The output is again a continuous score around the range. Positive values suggest that the second asset is acting more as a leader, with its past moves bearing informative value for subsequent moves of the chart symbol. Negative values indicate that the second asset behaves more like a laggard or follower. Values near zero suggest that no stable lead–lag structure can be identified.
The anticipation score is built from four elements inspired by quantitative lead–lag and price discovery analysis. The first element is a residual lead correlation, conceptually similar to Granger-style logic. The script first measures how much of the chart symbol’s normalized returns can be explained by its own lagged values. It then removes that component and studies the correlation between the residuals and lagged returns of the second asset. If the second asset’s past returns consistently explain what the chart symbol does beyond its own autoregressive behaviour, this residual correlation becomes significantly positive.
The second element is an asymmetric lead–lag structure measure. It compares the strength of relationships in both directions across multiple lags: the correlation of the current symbol with lagged versions of the second asset (candidate leader) versus the correlation of lagged values of the current symbol with the present values of the second asset. If the forward direction (second asset leading the first) is systematically stronger than the backward direction, the structure is skewed toward genuine leadership of the second asset.
The third element is a relative price discovery score, constructed by building a dynamic hedge ratio between the two prices and defining a spread. The indicator looks at how changes in each asset contribute to correcting deviations in this spread over time. When the chart symbol tends to do most of the adjustment while the second asset remains relatively stable, it suggests that the second asset is taking a greater role in determining the equilibrium price and the chart symbol is adjusting to it. The difference in adjustment intensity between the two instruments is summarised into a single score.
The fourth element is a breakout follow-through causality component. The script scans for breakout events on the second asset, where its price breaks out of a recent high or low range while the chart symbol has not yet done so. It then evaluates whether the chart symbol subsequently confirms the breakout direction, remains neutral, or moves against it. Events where the second asset breaks and the first asset later follows in the same direction add positive contribution, while failed or contrarian follow-through reduce this component. The contribution is also lightly modulated by the strength of the breakout, via the underlying normalized return.
The four elements of the Anticipation mode are combined into a single leading correlation score, providing a compact and interpretable measure of whether the second asset currently behaves as an effective early signal for the symbol you trade.
To aid interpretation, Omega Correlation builds dynamic bands around the active series (correlation or anticipation). It estimates a long-term central tendency and a typical deviation around it, plotting upper and lower bands that highlight unusually high or low values relative to recent history. These bands can be used to distinguish routine fluctuations from genuinely extreme regimes.
The script also computes percentile-based levels for the correlation series and uses them to track two special price levels on the main chart: lost correlation levels and gained correlation levels. When the correlation drops below an upper percentile threshold, the current price is stored as a lost correlation level and plotted as a horizontal line. When the correlation rises above a lower percentile threshold, the current price is stored as a gained correlation level. These levels mark zones where a historically strong relationship between the two markets broke down or re-emerged, and can be used to frame divergence, convergence and spread opportunities.
An information panel summarises, in real time, whether the second asset is behaving more as a leading, lagging or independent instrument according to the anticipation score, and suggests whether the current environment is more conducive to de-alignment, re-alignment or classic spread behaviour based on the correlation regime. This makes the tool directly interpretable even for users who are not familiar with all the underlying statistical details.
Typical applications for Omega Correlation include intermarket analysis (for example, index vs index, commodity vs related equity sector, FX vs bonds), dynamic hedge sizing, regime detection for algorithmic strategies, and the identification of lead–lag structures where a macro driver or benchmark can be monitored as an early signal for the instrument actually traded. The indicator can be applied across intraday and higher timeframes, with the understanding that the strength and nature of relationships will differ across horizons.
Omega Correlation is designed as an advanced analytical framework, not as a standalone trading system. Correlation and lead–lag relationships are statistical in nature and can change abruptly, especially around macro events, regime shifts or liquidity shocks. A positive anticipation reading does not guarantee that the second asset will always move first, and a high correlation regime can break without warning. All outputs of this tool should be combined with independent analysis, sound risk management and, when appropriate, backtesting or forward testing on the user’s specific instruments and timeframes.
The intention behind Omega Correlation is to bring techniques inspired by quantitative research, such as normalized return analysis, residual correlation, asymmetric lead–lag structure, price discovery logic and breakout event studies, into an accessible TradingView indicator. It is intended for traders who want a structured, professional way to understand how markets interact and to incorporate that information into their discretionary or systematic decision-making processes.
Advanced Trading System - Volume Profile + BB + RSI + FVG + FibAdvanced Multi-Indicator Trading System with Volume Profile, Bollinger Bands, RSI, FVG & Fibonacci
Overview
This comprehensive trading indicator combines five powerful technical analysis tools into one unified system, designed to identify high-probability trading opportunities with precision entry and exit signals. The indicator integrates Volume Profile analysis, Bollinger Bands, RSI momentum, Fair Value Gaps (FVG), and Fibonacci retracement levels to provide traders with a complete market analysis framework.
Key Features
1. Volume Profile & Point of Control (POC)
Automatically calculates the Point of Control - the price level with the highest trading volume
Identifies Value Area High (VAH) and Value Area Low (VAL)
Updates dynamically based on customizable lookback periods
Helps identify key support and resistance zones where institutional traders are active
2. Bollinger Bands Integration
Standard 20-period Bollinger Bands with customizable multiplier
Identifies overbought and oversold conditions
Measures market volatility through band width
Signals generated when price approaches extreme levels
3. RSI Momentum Analysis
14-period Relative Strength Index with visual background coloring
Overbought (70) and oversold (30) threshold alerts
Integrated into buy/sell signal logic for confirmation
Real-time momentum tracking in info dashboard
4. Fair Value Gap (FVG) Detection
Automatically identifies bullish and bearish fair value gaps
Visual representation with colored boxes
Highlights imbalance zones where price may return
Used for high-probability entry confirmation
5. Fibonacci Retracement Levels
Auto-calculated based on recent swing high/low
Key levels: 23.6%, 38.2%, 50%, 61.8%, 78.6%
Perfect for identifying profit-taking zones
Dynamic lines that update with market movement
6. Smart Signal Generation
The indicator generates BUY and SELL signals based on multi-condition confluence:
BUY Signal Requirements:
Price near lower Bollinger Band
RSI in oversold territory (< 30)
High volume confirmation (optional)
Bullish FVG or POC alignment
SELL Signal Requirements:
Price near upper Bollinger Band
RSI in overbought territory (> 70)
High volume confirmation (optional)
Bearish FVG or POC alignment
7. Automated Take Profit Levels
Three dynamic profit targets: 1%, 2%, and 3%
Automatically calculated from entry price
Visual markers on chart
Individual alerts for each level
8. Comprehensive Alert System
The indicator includes 10+ alert types:
Buy signal alerts
Sell signal alerts
Take profit level alerts (TP1, TP2, TP3)
Fibonacci level cross alerts
RSI overbought/oversold alerts
Bullish/Bearish FVG detection alerts
9. Real-Time Info Dashboard
Live display of all key metrics
Color-coded for quick visual analysis
Shows RSI, BB Width, Volume ratio, POC, Fib levels
Current signal status (BUY/SELL/WAIT)
How to Use
Setup
Add the indicator to your chart
Adjust parameters based on your trading style and timeframe
Set up alerts by clicking "Create Alert" and selecting desired conditions
Recommended Timeframes
Scalping: 5m - 15m
Day Trading: 15m - 1H
Swing Trading: 4H - Daily
Parameter Customization
Volume Profile Settings:
Length: 100 (adjust for more/less historical data)
Rows: 24 (granularity of volume distribution)
Bollinger Bands:
Length: 20 (standard period)
Multiplier: 2.0 (adjust for tighter/wider bands)
RSI Settings:
Length: 14 (standard momentum period)
Overbought: 70
Oversold: 30
Fibonacci:
Lookback: 50 (swing high/low detection period)
Signal Settings:
Volume Filter: Enable/disable volume confirmation
Volume MA Length: 20 (for volume comparison)
Trading Strategy Examples
Strategy 1: Trend Reversal
Wait for BUY signal at lower Bollinger Band
Confirm with bullish FVG or POC support
Enter position
Take partial profits at Fib 38.2% and 50%
Exit remaining position at TP3 or SELL signal
Strategy 2: Breakout Confirmation
Monitor price approaching POC level
Wait for volume spike
Enter on signal confirmation with FVG alignment
Use Fibonacci levels for scaling out
Strategy 3: Range Trading
Identify POC as range midpoint
Buy at lower BB with oversold RSI
Sell at upper BB with overbought RSI
Use FVG zones for additional confirmation
Best Practices
✅ Do:
Use multiple timeframe analysis
Combine with price action analysis
Set stop losses below/above recent swing points
Scale out at Fibonacci levels
Wait for volume confirmation on signals
❌ Don't:
Trade every signal blindly
Ignore overall market context
Use on extremely low timeframes without testing
Neglect risk management
Trade during low liquidity periods
Risk Management
Always use stop losses
Risk no more than 1-2% per trade
Consider market conditions and volatility
Scale position sizes based on signal strength
Use the volume filter for additional confirmation
Technical Specifications
Pine Script Version: 6
Overlay: Yes (displays on main chart)
Max Boxes: 500 (for FVG visualization)
Max Lines: 500 (for Fibonacci levels)
Alerts: 10+ customizable conditions
Performance Notes
This indicator works best in:
Trending markets with clear momentum
High-volume trading sessions
Assets with good liquidity
When multiple signals align
Less effective in:
Extremely choppy/sideways markets
Low-volume periods
During major news events (high volatility)
Updates & Support
This indicator is actively maintained and updated. Future enhancements may include:
Additional volume profile features
More sophisticated FVG tracking
Enhanced alert customization
Backtesting integration
Disclaimer
This indicator is for educational and informational purposes only. It does not constitute financial advice. Past performance does not guarantee future results. Always conduct your own research and consider consulting with a financial advisor before making trading decisions. Trading involves substantial risk of loss.
Day-Type Detector — Rejection / FNL / Outside / StopRun (Clean)Day-Type Detector — Rejection / FNL / Outside / Stop-Run (Clean Version)
This indicator identifies four high-impact candlestick day-types commonly used in professional price-action and auction-market trading: Rejection Days, Failed New Low (FNL) Days, Outside Days, and Stop-Run Days. These patterns often precede major directional moves, reversals, and absorption events, making them particularly valuable for swing traders, positional traders, and short-term discretionary traders.
The script is designed to work across all timeframes and is built around volatility-adjusted measurements using Average Daily Range (ADR) for accuracy and consistency.
What This Indicator Detects
1. Rejection Day (Bullish & Bearish)
A Rejection Day is a wide-range bar that rejects a previous extreme.
The indicator identifies rejection based on:
Range > ADR × threshold
Long lower wick (for bullish) or long upper wick (for bearish)
Close located in the strong zone of the day’s range
These conditions highlight areas where aggressive counter-orderflow entered the market.
2. Failed New Low (FNL) / Failed New High
An FNL day traps traders who attempted breakout selling or buying.
The indicator checks for:
A break beyond the previous session’s low or high
Immediate rejection back inside
Midpoint recapture conditions
ADR-normalized range requirements
These days often trigger powerful directional reversals.
3. Outside Day (Bullish & Bearish)
An Outside Day is a statistically significant expansion day that breaks both the previous high and low.
The script validates:
High > previous high and low < previous low
Range > ADR threshold
Close beyond prior session extreme to complete the rejection sequence
Outside Days often represent stop runs, shakeouts, or trend accelerations.
4. Stop-Run Day (Bullish & Bearish)
Stop-Run Days are aggressive volatility expansions and tend to be the largest ranges within short windows.
This detector identifies them using:
Range > ADR × multiplier
Close located near the extreme of the day (top for bullish, bottom for bearish)
Strong body relative to total range
Break above/below previous session extreme
These patterns indicate capitulation or forced liquidation and are often followed by continuation or sharp counter-rotation.
Key Features
✔ Historical Pattern Marking
All qualifying bars are marked on the chart using plotshape() in global scope, ensuring full historical visibility.
✔ Event Logging & Table Display
A table (top-right of the chart) displays the most recent pattern detections, including:
Timestamp
Pattern type
Bar index
This allows users to monitor and study past pattern occurrences without scanning the chart manually.
✔ ADR-Adjusted Detection
Volatility uncertainty is removed by anchoring all thresholds to ADR.
This ensures consistency across:
Different symbols
Different timeframes
Different market regimes
✔ Alerts Included
Alerts are preconfigured for:
Rejection Day Bull / Bear
FNL Bull / Bear
Outside Day Bull / Bear
Stop-Run Bull / Bear
This allows the user to receive real-time notifications when major day-type structures develop.
How to Use
Add the indicator to any timeframe chart.
Enable or disable:
Historical markers
History table
ADR diagnostics
Watch for shape markers or use alerts for real-time signals.
Use the history table to review recent occurrences.
Combine these day-types with:
Market structure levels
High/low volume nodes (LVNs)
Support/resistance zones
Trend context
These day-types are most effective when they occur near meaningful structural levels because they show where strong order-flow entered the market.
Best Practices
Use higher timeframes (1H–1D) for swing entries.
Confirm signals with market structure or volume profile.
Treat these day-types as context, not standalone signals.
Observe follow-through behavior in the next 1–3 bars after detection.
Credits
This script is based on concepts commonly seen in auction-market theory and professional price-action frameworks, such as Rejection Days, Failed New Lows, Outside Days, and Stop-Run behaviors.
All calculations and logic have been rebuilt from scratch to ensure clean, reliable, and optimized Pine Script v6 execution.
DAO - Demand Advanced Oscillator# DAO - Demand Advanced Oscillator
## 📊 Overview
DAO (Demand Advanced Oscillator) is a powerful momentum oscillator that measures buying and selling pressure by analyzing consecutive high-low relationships. It helps identify market extremes, divergences, and potential trend reversals.
**Values range from 0 to 1:**
- **Above 0.70** = Overbought (potential reversal down)
- **Below 0.30** = Oversold (potential reversal up)
- **0.30 - 0.70** = Neutral zone
---
## ✨ Key Features
✅ **Automatic Divergence Detection**
- Bullish divergences (price lower low + DAO higher low)
- Bearish divergences (price higher high + DAO lower high)
- Visual lines connecting divergence points
✅ **Multi-Timeframe Analysis**
- View higher timeframe DAO on current chart
- Perfect for trend alignment strategies
✅ **Signal Line (EMA)**
- Customizable EMA for trend confirmation
- Crossover signals for momentum shifts
✅ **Real-Time Statistics Dashboard**
- Current DAO value
- Market status (Overbought/Oversold/Neutral)
- Trend direction indicator
✅ **Complete Alert System**
- Overbought/Oversold signals
- Bullish/Bearish divergences
- Signal line crosses
- Level crosses
✅ **Fully Customizable**
- Adjustable periods and levels
- Customizable colors and zones
- Toggle features on/off
---
## 📈 Trading Signals
### 1. Divergences (Most Powerful)
**Bullish Divergence:**
- Price makes lower low
- DAO makes higher low
- Signal: Strong reversal up likely
**Bearish Divergence:**
- Price makes higher high
- DAO makes lower high
- Signal: Strong reversal down likely
### 2. Overbought/Oversold
**Overbought (>0.70):**
- Market may be overextended
- Consider taking profits or looking for shorts
- Can remain overbought in strong trends
**Oversold (<0.30):**
- Market may be oversold
- Consider buying opportunities
- Can remain oversold in strong downtrends
### 3. Signal Line Crossovers
**Bullish Cross:**
- DAO crosses above signal line
- Momentum turning positive
**Bearish Cross:**
- DAO crosses below signal line
- Momentum turning negative
### 4. Level Crosses
**Cross Above 0.30:** Exiting oversold zone (potential uptrend)
**Cross Below 0.70:** Exiting overbought zone (potential downtrend)
---
## ⚙️ Default Settings
📊 Oscillator Period: 14
Number of bars for calculation
📈 Signal Line Period: 9
EMA period for signal line
🔴 Overbought Level: 0.70
Upper threshold
🟢 Oversold Level: 0.30
Lower threshold
🎯 Divergence Detection: ON
Auto divergence identification
⏰ Multi-Timeframe: OFF
Higher TF overlay (optional)
All parameters are fully customizable!
---
## 🔔 Alerts
Six pre-configured alerts available:
1. DAO Overbought
2. DAO Oversold
3. DAO Bullish Divergence
4. DAO Bearish Divergence
5. DAO Signal Cross Up
6. DAO Signal Cross Down
**Setup:** Right-click indicator → Add Alert → Choose condition
---
## 💡 How to Use
### Best Practices:
✅ Focus on divergences (strongest signals)
✅ Combine with support/resistance levels
✅ Use multiple timeframes for confirmation
✅ Wait for price action confirmation
✅ Practice proper risk management
### Avoid:
❌ Trading on indicator alone
❌ Fighting strong trends
❌ Ignoring market context
❌ Overtrading
### Recommended Settings by Trading Style:
**Day Trading:** Period 7-10, All alerts ON
**Swing Trading:** Period 14-21, Divergence alerts
**Scalping:** Period 5-7, Signal crosses
**Position Trading:** Period 21-30, Weekly/Daily TF
---
## 🌍 Markets & Timeframes
**Works on all markets:**
- Forex (all pairs)
- Stocks (all exchanges)
- Cryptocurrencies
- Commodities
- Indices
- Futures
**Works on all timeframes:** 1m to Monthly
---
## 📊 How It Works
DAO calculates the ratio of buying pressure to total market pressure:
1. **Calculate Buying Pressure (DemandMax):**
- If current high > previous high: DemandMax = difference
- Otherwise: DemandMax = 0
2. **Calculate Selling Pressure (DemandMin):**
- If previous low > current low: DemandMin = difference
- Otherwise: DemandMin = 0
3. **Apply Smoothing:**
- Calculate SMA of DemandMax over N periods
- Calculate SMA of DemandMin over N periods
4. **Final Formula:**
```
DAO = SMA(DemandMax) / (SMA(DemandMax) + SMA(DemandMin))
```
This produces a normalized value (0-1) representing market demand strength.
---
## 🎯 Trading Strategies
### Strategy 1: Divergence Trading
- Wait for divergence label
- Confirm at support/resistance
- Enter on confirming candle
- Stop loss beyond recent swing
- Target: opposite level or 0.50
### Strategy 2: Overbought/Oversold
- Best for ranging markets
- Wait for extreme readings
- Enter on reversal from extremes
- Target: middle line (0.50)
### Strategy 3: Trend Following
- Identify trend direction first
- Use DAO to time entries in trend direction only
- Enter on pullbacks to oversold (uptrend) or overbought (downtrend)
- Trade with the trend
### Strategy 4: Multi-Timeframe
- Enable MTF feature
- Trade only when both timeframes align
- Higher TF = trend direction
- Lower TF = precise entry
---
## 📂 Category
**Primary:** Oscillators
**Secondary:** Statistics, Volatility, Momentum
---
## 🏷️ Tags
dao, oscillator, momentum, overbought-oversold, divergence, reversal, demand-indicator, price-exhaustion, statistics, volatility, forex, stocks, crypto, multi-timeframe, technical-analysis
---
## ⚠️ Disclaimer
**This indicator is for educational purposes only.** It does not constitute financial advice. Trading involves substantial risk of loss. Always conduct your own research, use proper risk management, and consult with financial professionals before making trading decisions. Past performance does not guarantee future results.
---
## 📄 License
Open source - Free to use for personal trading, modify as needed, and share with attribution.
---
**Version:** 1.0
**Status:** Production Ready ✅
**Pine Script:** v5
**Trademark-Free:** 100% Safe to Publish
---
*Made with 💙 for traders worldwide*
[FS] Pivot Measurements# Pivot Measurements
An advanced TradingView indicator that combines LuxAlgo's pivot point detection algorithm with automatic measurement calculations between consecutive pivots.
## Features
### Pivot Detection
- **Regular Pivots**: Detects standard pivot highs and lows using configurable pivot length
- **Missed Pivots**: Identifies missed reversal levels that occurred between regular pivots
- **Visual Indicators**:
- Regular pivot highs: Red downward triangle (▼)
- Regular pivot lows: Teal upward triangle (▲)
- Missed pivots: Ghost emoji (👻)
- **Zigzag Lines**: Connects pivots with colored lines (solid for regular, dashed for missed)
- **Ghost Levels**: Horizontal lines indicating missed pivot levels
### Measurement System
- **Automatic Measurements**: Calculates price movements between consecutive pivots
- **Visual Display**:
- Transparent colored boxes (blue for upward, red for downward movements)
- Measurement labels showing:
- Price change (absolute and percentage)
- Duration (bars, days, hours, minutes)
- Volume approximation
- **Smart Positioning**: Labels positioned outside boxes (above for upward, below for downward)
- **Color Coding**: Blue for positive movements, red for negative movements
## Parameters
### Pivot Detection
- **Pivot Length** (default: 50): Number of bars on each side to identify a pivot point
- **Regular Pivots**: Toggle and colors for regular pivot highs and lows
- **Missed Pivots**: Toggle and colors for missed pivot detection
### Measurements
- **Number of Measurements** (1-10, default: 10): Maximum number of measurements to display
- **Show Measurement Boxes**: Toggle to show/hide measurement boxes and labels
- **Box Transparency** (0-100, default: 90): Transparency level for measurement boxes
- **Border Transparency** (0-100, default: 50): Transparency level for box borders
- **Label Background Transparency** (0-100, default: 30): Transparency level for label backgrounds
- **Label Size**: Size of measurement labels (tiny, small, normal, large)
## Usage
1. Add the indicator to your chart
2. Configure the **Pivot Length** based on your timeframe:
- Lower values for shorter timeframes (e.g., 10-20 for 1-5 min)
- Higher values for longer timeframes (e.g., 50-100 for daily)
3. Adjust pivot colors and visibility as needed
4. Customize measurement display settings:
- Set the number of measurements to display
- Adjust transparency levels for boxes, borders, and labels
- Choose label size
## Technical Details
- **Pine Script Version**: v6
- **Pivot Detection**: Based on () algorithm for detecting regular and missed pivots
- **Measurement Calculation**:
- Measures between consecutive pivots (from most recent to older)
- Calculates price change, percentage change, duration, and approximate volume
- Automatically sorts pivots chronologically
- **Performance**: Optimized with helper functions to reduce code duplication
## Notes
- The indicator automatically limits the number of stored pivots to optimize performance
- Measurements are only created when there are at least 2 pivots detected
- All measurements are recalculated on each bar update
- The indicator uses `max_bars_back=5000` to ensure sufficient historical data
## License
This indicator uses LuxAlgo's pivot detection algorithm from (). Please refer to the original LuxAlgo license for pivot detection components.
LibPvotLibrary "LibPvot"
This is a library for advanced technical analysis, specializing
in two core areas: the detection of price-oscillator
divergences and the analysis of market structure. It provides
a back-end engine for signal detection and a toolkit for
indicator plotting.
Key Features:
1. **Complete Divergence Suite (Class A, B, C):** The engine detects
all three major types of divergences, providing a full spectrum of
analytical signals:
- **Regular (A):** For potential trend reversals.
- **Hidden (B):** For potential trend continuations.
- **Exaggerated (C):** For identifying weakness at double tops/bottoms.
2. **Advanced Signal Filtering:** The detection logic uses a
percentage-based price tolerance (`prcTol`). This feature
enables the practical detection of Exaggerated divergences
(which rarely occur at the exact same price) and creates a
"dead zone" to filter insignificant noise from triggering
Regular divergences.
3. **Pivot Synchronization:** A bar tolerance (`barTol`) is used
to reliably match price and oscillator pivots that do not
align perfectly on the same bar, preventing missed signals.
4. **Signal Invalidation Logic:** Features two built-in invalidation
rules:
- An optional `invalidate` parameter automatically terminates
active divergences if the price or the oscillator breaks
the level of the confirming pivot.
- The engine also discards 'half-pivots' (e.g., a price pivot)
if a corresponding oscillator pivot does not appear within
the `barTol` window.
5. **Stateful Plotting Helpers:** Provides helper functions
(`bullDivPos` and `bearDivPos`) that abstract away the
state management issues of visualizing persistent signals.
They generate gap-free, accurately anchored data series
ready to be used in `plotshape` functions, simplifying
indicator-side code.
6. **Rich Data Output:** The core detection functions (`bullDiv`, `bearDiv`)
return a comprehensive 9-field data tuple. This includes the
boolean flags for each divergence type and the precise
coordinates (price, oscillator value, bar index) of both the
starting and the confirming pivots.
7. **Market Structure & Trend Analysis:** Includes a
`marketStructure` function to automatically identify pivot
highs/lows, classify their relationship (HH, LH, LL, HL),
detect structure breaks, and determine the current trend
state (Up, Down, Neutral) based on pivot sequences.
---
**DISCLAIMER**
This library is provided "AS IS" and for informational and
educational purposes only. It does not constitute financial,
investment, or trading advice.
The author assumes no liability for any errors, inaccuracies,
or omissions in the code. Using this library to build
trading indicators or strategies is entirely at your own risk.
As a developer using this library, you are solely responsible
for the rigorous testing, validation, and performance of any
scripts you create based on these functions. The author shall
not be held liable for any financial losses incurred directly
or indirectly from the use of this library or any scripts
derived from it.
bullDiv(priceSrc, oscSrc, leftLen, rightLen, depth, barTol, prcTol, persist, invalidate)
Detects bullish divergences (Regular, Hidden, Exaggerated) based on pivot lows.
Parameters:
priceSrc (float) : series float Price series to check for pivots (e.g., `low`).
oscSrc (float) : series float Oscillator series to check for pivots.
leftLen (int) : series int Number of bars to the left of a pivot (default 5).
rightLen (int) : series int Number of bars to the right of a pivot (default 5).
depth (int) : series int Maximum number of stored pivot pairs to check against (default 2).
barTol (int) : series int Maximum bar distance allowed between the price pivot and the oscillator pivot (default 3).
prcTol (float) : series float The percentage tolerance for comparing pivot prices. Used to detect Exaggerated
divergences and filter out market noise (default 0.05%).
persist (bool) : series bool If `true` (default), the divergence flag stays active for the entire duration of the signal.
If `false`, it returns a single-bar pulse on detection.
invalidate (bool) : series bool If `true` (default), terminates an active divergence if price or oscillator break
below the confirming pivot low.
Returns: A tuple containing comprehensive data for a detected bullish divergence.
regBull series bool `true` if a Regular bullish divergence (Class A) is active.
hidBull series bool `true` if a Hidden bullish divergence (Class B) is active.
exgBull series bool `true` if an Exaggerated bullish divergence (Class C) is active.
initPivotPrc series float Price value of the initial (older) pivot low.
initPivotOsz series float Oscillator value of the initial pivot low.
initPivotBar series int Bar index of the initial pivot low.
lastPivotPrc series float Price value of the last (confirming) pivot low.
lastPivotOsz series float Oscillator value of the last pivot low.
lastPivotBar series int Bar index of the last pivot low.
bearDiv(priceSrc, oscSrc, leftLen, rightLen, depth, barTol, prcTol, persist, invalidate)
Detects bearish divergences (Regular, Hidden, Exaggerated) based on pivot highs.
Parameters:
priceSrc (float) : series float Price series to check for pivots (e.g., `high`).
oscSrc (float) : series float Oscillator series to check for pivots.
leftLen (int) : series int Number of bars to the left of a pivot (default 5).
rightLen (int) : series int Number of bars to the right of a pivot (default 5).
depth (int) : series int Maximum number of stored pivot pairs to check against (default 2).
barTol (int) : series int Maximum bar distance allowed between the price pivot and the oscillator pivot (default 3).
prcTol (float) : series float The percentage tolerance for comparing pivot prices. Used to detect Exaggerated
divergences and filter out market noise (default 0.05%).
persist (bool) : series bool If `true` (default), the divergence flag stays active for the entire duration of the signal.
If `false`, it returns a single-bar pulse on detection.
invalidate (bool) : series bool If `true` (default), terminates an active divergence if price or oscillator break
above the confirming pivot high.
Returns: A tuple containing comprehensive data for a detected bearish divergence.
regBear series bool `true` if a Regular bearish divergence (Class A) is active.
hidBear series bool `true` if a Hidden bearish divergence (Class B) is active.
exgBear series bool `true` if an Exaggerated bearish divergence (Class C) is active.
initPivotPrc series float Price value of the initial (older) pivot high.
initPivotOsz series float Oscillator value of the initial pivot high.
initPivotBar series int Bar index of the initial pivot high.
lastPivotPrc series float Price value of the last (confirming) pivot high.
lastPivotOsz series float Oscillator value of the last pivot high.
lastPivotBar series int Bar index of the last pivot high.
bullDivPos(regBull, hidBull, exgBull, rightLen, yPos)
Calculates the plottable data series for bullish divergences. It manages
the complex state of a persistent signal's plotting window to ensure
gap-free and accurately anchored visualization.
Parameters:
regBull (bool) : series bool The regular bullish divergence flag from `bullDiv`.
hidBull (bool) : series bool The hidden bullish divergence flag from `bullDiv`.
exgBull (bool) : series bool The exaggerated bullish divergence flag from `bullDiv`.
rightLen (int) : series int The same `rightLen` value used in `bullDiv` for correct timing.
yPos (float) : series float The series providing the base Y-coordinate for the shapes (e.g., `low`).
Returns: A tuple of three `series float` for plotting bullish divergences.
regBullPosY series float Contains the static anchor Y-value for Regular divergences where a shape should be plotted; `na` otherwise.
hidBullPosY series float Contains the static anchor Y-value for Hidden divergences where a shape should be plotted; `na` otherwise.
exgBullPosY series float Contains the static anchor Y-value for Exaggerated divergences where a shape should be plotted; `na` otherwise.
bearDivPos(regBear, hidBear, exgBear, rightLen, yPos)
Calculates the plottable data series for bearish divergences. It manages
the complex state of a persistent signal's plotting window to ensure
gap-free and accurately anchored visualization.
Parameters:
regBear (bool) : series bool The regular bearish divergence flag from `bearDiv`.
hidBear (bool) : series bool The hidden bearish divergence flag from `bearDiv`.
exgBear (bool) : series bool The exaggerated bearish divergence flag from `bearDiv`.
rightLen (int) : series int The same `rightLen` value used in `bearDiv` for correct timing.
yPos (float) : series float The series providing the base Y-coordinate for the shapes (e.g., `high`).
Returns: A tuple of three `series float` for plotting bearish divergences.
regBearPosY series float Contains the static anchor Y-value for Regular divergences where a shape should be plotted; `na` otherwise.
hidBearPosY series float Contains the static anchor Y-value for Hidden divergences where a shape should be plotted; `na` otherwise.
exgBearPosY series float Contains the static anchor Y-value for Exaggerated divergences where a shape should be plotted; `na` otherwise.
marketStructure(highSrc, lowSrc, leftLen, rightLen, srcTol)
Analyzes the market structure by identifying pivot points, classifying
their sequence (e.g., Higher Highs, Lower Lows), and determining the
prevailing trend state.
Parameters:
highSrc (float) : series float Price series for pivot high detection (e.g., `high`).
lowSrc (float) : series float Price series for pivot low detection (e.g., `low`).
leftLen (int) : series int Number of bars to the left of a pivot (default 5).
rightLen (int) : series int Number of bars to the right of a pivot (default 5).
srcTol (float) : series float Percentage tolerance to consider two pivots as 'equal' (default 0.05%).
Returns: A tuple containing detailed market structure information.
pivType series PivType The type of the most recently formed pivot (e.g., `hh`, `ll`).
lastPivHi series float The price level of the last confirmed pivot high.
lastPivLo series float The price level of the last confirmed pivot low.
lastPiv series float The price level of the last confirmed pivot (either high or low).
pivHiBroken series bool `true` if the price has broken above the last pivot high.
pivLoBroken series bool `true` if the price has broken below the last pivot low.
trendState series TrendState The current trend state (`up`, `down`, or `neutral`).
