Hybrid Moving Average - Market TrendHybrid Moving Average Market Trend System - , designed to visualize market trends using a combination of three moving averages: FRAMA (Fractal Adaptive Moving Average), VIDYA (Variable Index Dynamic Average), and a Hamming windowed Volume-Weighted Moving Average (VWMA).
Key Features:
FRAMA Calculation:
FRAMA adapts to market volatility by dynamically adjusting its smoothing factor based on the fractal dimension of price movement. This allows it to be more responsive during trending periods while filtering out noise in sideways markets. The FRAMA is calculated for both short and long periods
VIDYA with CMO:
The VIDYA (Variable Index Dynamic Average) is based on a Chande Momentum Oscillator (CMO), which adjusts the smoothing factor dynamically depending on the momentum of the market. Higher momentum periods result in more responsive averages, while low momentum periods lead to smoother averages. Like FRAMA, VIDYA is calculated for both short and long periods.
Hamming Windowed VWMA:
This VWMA variation applies a Hamming window to smooth the weighting of volume across the calculation period. This method emphasizes central data points and reduces noise, making the VWMA more adaptive to volume fluctuations. The Hamming VWMA is calculated for short and long periods, offering another layer of adaptability to the hybrid moving average.
Hybrid Moving Averages:
Dynamic Coloring and Filling:
The script uses dynamic color transitions to visually distinguish between bullish and bearish conditions:
Cerca negli script per "如何用wind搜索股票的发行价和份数"
Regime Classifier Oscillator (AiBitcoinTrend)The Regime Classifier Oscillator (AiBitcoinTrend) is an advanced tool for understanding market structure and detecting dynamic price regimes. By combining filtered price trends, clustering algorithms, and an adaptive oscillator, it provides traders with detailed insights into market phases, including accumulation, distribution, advancement, and decline.
This innovative tool simplifies market regime classification, enabling traders to align their strategies with evolving market conditions effectively.
👽 What is a Regime Classifier, and Why is it Useful?
A Regime Classifier is a concept in financial analysis that identifies distinct market conditions or "regimes" based on price behavior and volatility. These regimes often correspond to specific phases of the market, such as trends, consolidations, or periods of high or low volatility. By classifying these regimes, traders and analysts can better understand the underlying market dynamics, allowing them to adapt their strategies to suit prevailing conditions.
👽 Common Uses in Finance
Risk Management: Identifying high-volatility regimes helps traders adjust position sizes or hedge risks.
Strategy Optimization: Traders tailor their approaches—trend-following strategies in trending regimes, mean-reversion strategies in consolidations.
Forecasting: Understanding the current regime aids in predicting potential transitions, such as a shift from accumulation to an upward breakout.
Portfolio Allocation: Investors allocate assets differently based on market regimes, such as increasing cash positions in high-volatility environments.
👽 Why It’s Important
Markets behave differently under varying conditions. A regime classifier provides a structured way to analyze these changes, offering a systematic approach to decision-making. This improves both accuracy and confidence in navigating diverse market scenarios.
👽 How We Implemented the Regime Classifier in This Indicator
The Regime Classifier Oscillator takes the foundational concept of market regime classification and enhances it with advanced computational techniques, making it highly adaptive.
👾 Median Filtering: We smooth price data using a custom median filter to identify significant trends while eliminating noise. This establishes a baseline for price movement analysis.
👾 Clustering Model: Using clustering techniques, the indicator classifies volatility and price trends into distinct regimes:
Advance: Strong upward trends with low volatility.
Decline: Downward trends marked by high volatility.
Accumulation: Consolidation phases with subdued volatility.
Distribution: Topping or bottoming patterns with elevated volatility.
This classification leverages historical price data to refine cluster boundaries dynamically, ensuring adaptive and accurate detection of market states.
Volatility Classification: Price volatility is analyzed through rolling windows, separating data into high and low volatility clusters using distance-based assignments.
Price Trends: The interaction of price levels with the filtered trendline and volatility clusters determines whether the market is advancing, declining, accumulating, or distributing.
👽 Dynamic Cycle Oscillator (DCO):
Captures cyclic behavior and overlays it with smoothed oscillations, providing real-time feedback on price momentum and potential reversals.
Regime Visualization:
Regimes are displayed with intuitive labels and background colors, offering clear, actionable insights directly on the chart.
👽 Why This Implementation Stands Out
Dynamic and Adaptive: The clustering and refit mechanisms adapt to changing market conditions, ensuring relevance across different asset classes and timeframes.
Comprehensive Insights: By combining price trends, volatility, and cyclic behaviors, the indicator provides a holistic view of the market.
This implementation bridges the gap between theoretical regime classification and practical trading needs, making it a powerful tool for both novice and experienced traders.
👽 Applications
👾 Regime-Based Trading Strategies
Traders can use the regime classifications to adapt their strategies effectively:
Advance & Accumulation: Favorable for entering or holding long positions.
Decline & Distribution: Opportunities for short positions or risk management.
👾 Oscillator Insights for Trend Analysis
Overbought/oversold conditions: Early warning of potential reversals.
Dynamic trends: Highlights the strength of price momentum.
👽 Indicator Settings
👾 Filter and Classification Settings
Filter Window Size: Controls trend detection sensitivity.
ATR Lookback: Adjusts the threshold for regime classification.
Clustering Window & Refit Interval: Fine-tunes regime accuracy.
👾 Oscillator Settings
Dynamic Cycle Oscillator Lookback: Defines the sensitivity of cycle detection.
Smoothing Factor: Balances responsiveness and stability.
Disclaimer: This information is for entertainment purposes only and does not constitute financial advice. Please consult with a qualified financial advisor before making any investment decisions.
mathLibrary "math"
It's a library of discrete aproximations of a price or Series float it uses Fourier Discrete transform, Laplace Discrete Original and Modified transform and Euler's Theoreum for Homogenus White noice operations. Calling functions without source value it automatically take close as the default source value.
Here is a picture of Laplace and Fourier approximated close prices from this library:
Copy this indicator and try it yourself:
import AutomatedTradingAlgorithms/math/1 as math
//@version=5
indicator("Close Price with Aproximations", shorttitle="Close and Aproximations", overlay=false)
// Sample input data (replace this with your own data)
inputData = close
// Plot Close Price
plot(inputData, color=color.blue, title="Close Price")
ltf32_result = math.LTF32(a=0.01)
plot(ltf32_result, color=color.green, title="LTF32 Aproximation")
fft_result = math.FFT()
plot(fft_result, color=color.red, title="Fourier Aproximation")
wavelet_result = math.Wavelet()
plot(wavelet_result, color=color.orange, title="Wavelet Aproximation")
wavelet_std_result = math.Wavelet_std()
plot(wavelet_std_result, color=color.yellow, title="Wavelet_std Aproximation")
DFT3(xval, _dir)
Discrete Fourier Transform with last 3 points
Parameters:
xval (float) : Source series
_dir (int) : Direction parameter
Returns: Aproxiated source value
DFT2(xval, _dir)
Discrete Fourier Transform with last 2 points
Parameters:
xval (float) : Source series
_dir (int) : Direction parameter
Returns: Aproxiated source value
FFT(xval)
Fast Fourier Transform once. It aproximates usig last 3 points.
Parameters:
xval (float) : Source series
Returns: Aproxiated source value
DFT32(xval)
Combined Discrete Fourier Transforms of DFT3 and DTF2 it aproximates last point by first
aproximating last 3 ponts and than using last 2 points of the previus.
Parameters:
xval (float) : Source series
Returns: Aproxiated source value
DTF32(xval)
Combined Discrete Fourier Transforms of DFT3 and DTF2 it aproximates last point by first
aproximating last 3 ponts and than using last 2 points of the previus.
Parameters:
xval (float) : Source series
Returns: Aproxiated source value
LFT3(xval, _dir, a)
Discrete Laplace Transform with last 3 points
Parameters:
xval (float) : Source series
_dir (int) : Direction parameter
a (float) : laplace coeficient
Returns: Aproxiated source value
LFT2(xval, _dir, a)
Discrete Laplace Transform with last 2 points
Parameters:
xval (float) : Source series
_dir (int) : Direction parameter
a (float) : laplace coeficient
Returns: Aproxiated source value
LFT(xval, a)
Fast Laplace Transform once. It aproximates usig last 3 points.
Parameters:
xval (float) : Source series
a (float) : laplace coeficient
Returns: Aproxiated source value
LFT32(xval, a)
Combined Discrete Laplace Transforms of LFT3 and LTF2 it aproximates last point by first
aproximating last 3 ponts and than using last 2 points of the previus.
Parameters:
xval (float) : Source series
a (float) : laplace coeficient
Returns: Aproxiated source value
LTF32(xval, a)
Combined Discrete Laplace Transforms of LFT3 and LTF2 it aproximates last point by first
aproximating last 3 ponts and than using last 2 points of the previus.
Parameters:
xval (float) : Source series
a (float) : laplace coeficient
Returns: Aproxiated source value
whitenoise(indic_, _devided, minEmaLength, maxEmaLength, src)
Ehler's Universal Oscillator with White Noise, without extra aproximated src.
It uses dinamic EMA to aproximate indicator and thus reducing noise.
Parameters:
indic_ (float) : Input series for the indicator values to be smoothed
_devided (int) : Divisor for oscillator calculations
minEmaLength (int) : Minimum EMA length
maxEmaLength (int) : Maximum EMA length
src (float) : Source series
Returns: Smoothed indicator value
whitenoise(indic_, dft1, _devided, minEmaLength, maxEmaLength, src)
Ehler's Universal Oscillator with White Noise and DFT1.
It uses src and sproxiated src (dft1) to clearly define white noice.
It uses dinamic EMA to aproximate indicator and thus reducing noise.
Parameters:
indic_ (float) : Input series for the indicator values to be smoothed
dft1 (float) : Aproximated src value for white noice calculation
_devided (int) : Divisor for oscillator calculations
minEmaLength (int) : Minimum EMA length
maxEmaLength (int) : Maximum EMA length
src (float) : Source series
Returns: Smoothed indicator value
smooth(dft1, indic__, _devided, minEmaLength, maxEmaLength, src)
Smoothing source value with help of indicator series and aproximated source value
It uses src and sproxiated src (dft1) to clearly define white noice.
It uses dinamic EMA to aproximate src and thus reducing noise.
Parameters:
dft1 (float) : Value to be smoothed.
indic__ (float) : Optional input for indicator to help smooth dft1 (default is FFT)
_devided (int) : Divisor for smoothing calculations
minEmaLength (int) : Minimum EMA length
maxEmaLength (int) : Maximum EMA length
src (float) : Source series
Returns: Smoothed source (src) series
smooth(indic__, _devided, minEmaLength, maxEmaLength, src)
Smoothing source value with help of indicator series
It uses dinamic EMA to aproximate src and thus reducing noise.
Parameters:
indic__ (float) : Optional input for indicator to help smooth dft1 (default is FFT)
_devided (int) : Divisor for smoothing calculations
minEmaLength (int) : Minimum EMA length
maxEmaLength (int) : Maximum EMA length
src (float) : Source series
Returns: Smoothed src series
vzo_ema(src, len)
Volume Zone Oscillator with EMA smoothing
Parameters:
src (float) : Source series
len (simple int) : Length parameter for EMA
Returns: VZO value
vzo_sma(src, len)
Volume Zone Oscillator with SMA smoothing
Parameters:
src (float) : Source series
len (int) : Length parameter for SMA
Returns: VZO value
vzo_wma(src, len)
Volume Zone Oscillator with WMA smoothing
Parameters:
src (float) : Source series
len (int) : Length parameter for WMA
Returns: VZO value
alma2(series, windowsize, offset, sigma)
Arnaud Legoux Moving Average 2 accepts sigma as series float
Parameters:
series (float) : Input series
windowsize (int) : Size of the moving average window
offset (float) : Offset parameter
sigma (float) : Sigma parameter
Returns: ALMA value
Wavelet(src, len, offset, sigma)
Aproxiates srt using Discrete wavelet transform.
Parameters:
src (float) : Source series
len (int) : Length parameter for ALMA
offset (simple float)
sigma (simple float)
Returns: Wavelet-transformed series
Wavelet_std(src, len, offset, mag)
Aproxiates srt using Discrete wavelet transform with standard deviation as a magnitude.
Parameters:
src (float) : Source series
len (int) : Length parameter for ALMA
offset (float) : Offset parameter for ALMA
mag (int) : Magnitude parameter for standard deviation
Returns: Wavelet-transformed series
LaplaceTransform(xval, N, a)
Original Laplace Transform over N set of close prices
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
Returns: Aproxiated source value
NLaplaceTransform(xval, N, a, repeat)
Y repetirions on Original Laplace Transform over N set of close prices, each time N-k set of close prices
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
repeat (int) : number of repetitions
Returns: Aproxiated source value
LaplaceTransformsum(xval, N, a, b)
Sum of 2 exponent coeficient of Laplace Transform over N set of close prices
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
Returns: Aproxiated source value
NLaplaceTransformdiff(xval, N, a, b, repeat)
Difference of 2 exponent coeficient of Laplace Transform over N set of close prices
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
repeat (int) : number of repetitions
Returns: Aproxiated source value
N_divLaplaceTransformdiff(xval, N, a, b, repeat)
N repetitions of Difference of 2 exponent coeficient of Laplace Transform over N set of close prices, with dynamic rotation
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
repeat (int) : number of repetitions
Returns: Aproxiated source value
LaplaceTransformdiff(xval, N, a, b)
Difference of 2 exponent coeficient of Laplace Transform over N set of close prices
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
Returns: Aproxiated source value
NLaplaceTransformdiffFrom2(xval, N, a, b, repeat)
N repetitions of Difference of 2 exponent coeficient of Laplace Transform over N set of close prices, second element has for 1 higher exponent factor
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
repeat (int) : number of repetitions
Returns: Aproxiated source value
N_divLaplaceTransformdiffFrom2(xval, N, a, b, repeat)
N repetitions of Difference of 2 exponent coeficient of Laplace Transform over N set of close prices, second element has for 1 higher exponent factor, dynamic rotation
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
repeat (int) : number of repetitions
Returns: Aproxiated source value
LaplaceTransformdiffFrom2(xval, N, a, b)
Difference of 2 exponent coeficient of Laplace Transform over N set of close prices, second element has for 1 higher exponent factor
Parameters:
xval (float) : series to aproximate
N (int) : number of close prices in calculations
a (float) : laplace coeficient
b (float) : second laplace coeficient
Returns: Aproxiated source value
Deep Volume [ChartPrime]Deep Volume is an indicator designed to give you high fidelity volume information. It does this by utilizing real time data provided by Tradingview to generate a wide range of metrics. We have included a convenient column chart to visualize the polarity of the volume, and a table to see the real time data. This works by utilizing pine script's varip feature to get information within candles. This is convenient as it allows users to get lower time frame information without the use of ltf functions. The result is seconds level data with out the need to be on a lower time frame chart. As a result, as you increase the time frame of the chart the updates will become slower. This is because Tradingview doesn't update the chart information as frequently on higher time frames as there isn't as much of a need.
This indicator works on real time data so to compensate for this we generate a simulated history based on candle structure. This helps in estimating the state of the moving average before the real time data starts. As a result the estimated history isn't as accurate and should be treated as such. That being said it is nice to have an estimation when the indicator is first loaded onto the chart.
Finally we have included a cumulative volume comparison that shows you how much volume there is compared to the average cumulative volume for the day. This metric utilizes a gradient to help you interpret the information at a glance. Low daily volume is represented with grays by default, while normal volume and greater is represented with a green color by default.
The table is partitioned into two sections; tick data, and average data. On the left you will see color coded information based on the direction of the move. On the left, the information is color coded based on the average movement direction. You can control how much information is displayed in the table within the indicators settings. This is defaulted to 20 but it can be as long or short as you like. Every new candle open the far left of the table you will see a 🗘 symbol and at the start of a new session you will see a 🗓 symbol.
The included metrics are as follows:
Time: This displays the time of the real time data update.
Time Delta: This displays the elapsed time between updates.
Order Size: This is the volume times the price change between updates.
Volume: This is the volume change for the update.
Price Change: This is the change in price since the last update.
Price: This is the price of the asset at the time of the update.
Speed of Tape: This is the average time delta. Use this to see how quickly the market is moving.
Average Order Size: This is the average order size.
Average Volume: This is the average volume
Volume Ratio: This the the ratio of bullish to bearish volume as expressed by a percent. 100% is all bullish within the window and -100% is all bearish within the window.
Average Price Change: This is the average price change within the window.
Sensitivity: This is a volatility metric designed to show you the price change per 1 volume unit.
Relative Sensitivity: This is a volatility metric designed to show you the average price change per average volume.
Enjoy
UtilsLibrary "Utils"
A collection of convenience and helper functions for indicator and library authors on TradingView
formatNumber(num)
My version of format number that doesn't have so many decimal places...
Parameters:
num (float) : (float) the number to be formatted
Returns: (string) The formatted number
getDateString(timestamp)
Convenience function returns timestamp in yyyy/MM/dd format.
Parameters:
timestamp (int) : (int) The timestamp to stringify
Returns: (int) The date string
getDateTimeString(timestamp)
Convenience function returns timestamp in yyyy/MM/dd hh:mm format.
Parameters:
timestamp (int) : (int) The timestamp to stringify
Returns: (int) The date string
getInsideBarCount()
Gets the number of inside bars for the current chart. Can also be passed to request.security to get the same for different timeframes.
Returns: (int) The # of inside bars on the chart right now.
getLabelStyleFromString(styleString, acceptGivenIfNoMatch)
Tradingview doesn't give you a nice way to put the label styles into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
styleString (string)
acceptGivenIfNoMatch (bool) : (bool) If no match for styleString is found and this is true, the function will return styleString, otherwise it will return tradingview's preferred default
Returns: (string) The string expected by tradingview functions
getTime(hourNumber, minuteNumber)
Given an hour number and minute number, adds them together and returns the sum. To be used by getLevelBetweenTimes when fetching specific price levels during a time window on the day.
Parameters:
hourNumber (int) : (int) The hour number
minuteNumber (int) : (int) The minute number
Returns: (int) The sum of all the minutes
getHighAndLowBetweenTimes(start, end)
Given a start and end time, returns the high or low price during that time window.
Parameters:
start (int) : The timestamp to start with (# of seconds)
end (int) : The timestamp to end with (# of seconds)
Returns: (float) The high or low value
getPremarketHighsAndLows()
Returns an expression that can be used by request.security to fetch the premarket high & low levels in a tuple.
Returns: (tuple)
getAfterHoursHighsAndLows()
Returns an expression that can be used by request.security to fetch the after hours high & low levels in a tuple.
Returns: (tuple)
getOvernightHighsAndLows()
Returns an expression that can be used by request.security to fetch the overnight high & low levels in a tuple.
Returns: (tuple)
getNonRthHighsAndLows()
Returns an expression that can be used by request.security to fetch the high & low levels for premarket, after hours and overnight in a tuple.
Returns: (tuple)
getLineStyleFromString(styleString, acceptGivenIfNoMatch)
Tradingview doesn't give you a nice way to put the line styles into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
styleString (string) : (string) Plain english (or TV Standard) version of the style string
acceptGivenIfNoMatch (bool) : (bool) If no match for styleString is found and this is true, the function will return styleString, otherwise it will return tradingview's preferred default
Returns: (string) The string expected by tradingview functions
getPercentFromPrice(price)
Get the % the current price is away from the given price.
Parameters:
price (float)
Returns: (float) The % the current price is away from the given price.
getPositionFromString(position)
Tradingview doesn't give you a nice way to put the positions into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
position (string) : (string) Plain english position string
Returns: (string) The string expected by tradingview functions
getTimeframeOfChart()
Get the timeframe of the current chart for display
Returns: (string) The string of the current chart timeframe
getTimeNowPlusOffset(candleOffset)
Helper function for drawings that use xloc.bar_time to help you know the time offset if you want to place the end of the drawing out into the future. This determines the time-size of one candle and then returns a time n candleOffsets into the future.
Parameters:
candleOffset (int) : (int) The number of items to find singular/plural for.
Returns: (int) The future time
getVolumeBetweenTimes(start, end)
Given a start and end time, returns the sum of all volume across bars during that time window.
Parameters:
start (int) : The timestamp to start with (# of seconds)
end (int) : The timestamp to end with (# of seconds)
Returns: (float) The volume
isToday()
Returns true if the current bar occurs on today's date.
Returns: (bool) True if current bar is today
padLabelString(labelText, labelStyle)
Pads a label string so that it appears properly in or not in a label. When label.style_none is used, this will make sure it is left-aligned instead of center-aligned. When any other type is used, it adds a single space to the right so there is padding against the right end of the label.
Parameters:
labelText (string) : (string) The string to be padded
labelStyle (string) : (string) The style of the label being padded for.
Returns: (string) The padded string
plural(num, singular, plural)
Helps format a string for plural/singular. By default, if you only provide num, it will just return "s" for plural and nothing for singular (eg. plural(numberOfCats)). But you can optionally specify the full singular/plural words for more complicated nomenclature (eg. plural(numberOfBenches, 'bench', 'benches'))
Parameters:
num (int) : (int) The number of items to find singular/plural for.
singular (string) : (string) The string to return if num is singular. Defaults to an empty string.
plural (string) : (string) The string to return if num is plural. Defaults to 's' so you can just add 's' to the end of a word.
Returns: (string) The singular or plural provided strings depending on the num provided.
timeframeInSeconds(timeframe)
Get the # of seconds in a given timeframe. Tradingview's timeframe.in_seconds() expects a simple string, and we often need to use series string, so this is an alternative to get you the value you need.
Parameters:
timeframe (string)
Returns: (int) The number of secondsof that timeframe
timeframeToString(tf)
Convert a timeframe string to a consistent standard.
Parameters:
tf (string) : (string) The timeframe string to convert
Returns: (string) The standard format for the string, or the unchanged value if it is unknown.
buyer_seller_scalping_indicatorThis code is a custom script designed for analyzing trading volume within a specific time window on the TradingView platform. It offers a comprehensive analysis of buying and selling activity during a defined period and provides visual aids and data summaries for traders to make informed decisions. Here's a detailed breakdown of its functionality and how to use it:
1. Custom Time Period: The script starts by allowing you to specify a custom time period for analysis. In this example, it's set from 04:00 to 09:29. You can modify these time values to suit your specific trading needs.
2. Volume Calculation: The script calculates buying and selling volume based on price levels. It takes into account the open, high, low, and close prices to determine whether buying or selling pressure is dominant during the specified time frame.
3. Total Volume Calculation: It calculates the total volume within the custom time period. This can help you gauge the overall activity and liquidity during the chosen time window.
4. Visualizations: The script then plots visual elements on the chart:
- A volume histogram, which provides a graphical representation of the total volume during the time period.
- Buying and selling volume indicators, which are shown as circles on the chart, highlighting the relative strength of buyers and sellers.
- An average volume line, represented in gray, which helps you identify the average trading volume over a 50-period moving average.
5. Volume Type Determination: The script determines whether buyers or sellers dominate the market during the specified time period. It labels this as "Buyers Volume > Sellers Volume," "Sellers Volume > Buyers Volume," or "Buyers Volume = Sellers Volume." This information can be crucial for assessing market sentiment.
6. Percentage Breakdown: The script calculates the percentage of buying and selling volume in relation to the total volume, helping you understand the distribution of market participants. These percentages are displayed in a table.
7. Table Display: Finally, the script creates a table that displays the following information:
- The current volume type (buyers, sellers, or balanced), with corresponding text colors.
- The percentage of buyers and sellers in the market.
How to Use:
1. Copy the script and add it as a custom script on TradingView.
2. Apply the script to your desired financial chart.
3. Adjust the custom time period if needed.
4. Interpret the visual elements and table to gain insights into market sentiment and volume distribution during the specified time frame.
5. Use this information to inform your trading decisions and strategies, especially when trading within the chosen time window.
This script is a valuable tool for traders seeking to understand market dynamics and volume behavior during specific trading hours, ultimately aiding in more informed trading decisions.
Disclaimer:
The indicator provided herein is experimental and has not undergone comprehensive testing. Its usage is solely at your own risk.
The publisher assumes no responsibility for any trading decisions made based on the utilization of this indicator.
ICT Silver Bullet [LuxAlgo]The ICT Silver Bullet indicator is inspired from the lectures of "The Inner Circle Trader" (ICT) and highlights the Silver Bullet (SB) window which is a specific 1-hour interval where a Fair Value Gap (FVG) pattern can be formed.
When a FVG is formed during the Silver Bullet window, Support & Resistance lines will be drawn at the end of the SB session.
There are 3 different Silver Bullet windows (New York local time):
The London Open Silver Bullet (3 AM — 4 AM ~ 03:00 — 04:00)
The AM Session Silver Bullet (10 AM — 11 AM ~ 10:00 — 11:00)
The PM Session Silver Bullet (2 PM — 3 PM ~ 14:00 — 15:00)
🔶 USAGE
The ICT Silver Bullet indicator aims to provide users a comprehensive display as similar as possible to how anyone would manually draw the concept on their charts.
It's important to use anything below the 15-minute timeframe to ensure proper setups can display. In this section, we are purely using the 3-minute timeframe.
In the image below, we can see a bullish setup whereas a FVG was successfully retested during the Silver Bullet session. This was then followed by a move upwards to liquidity as our target.
Alternatively, you can also see below a bearish setup utilizing the ICT Silver Bullet indicator outlined.
At this moment, the indicator has removed all other FVGs within the Silver Bullet session & has confirmed this FVG as the retested one.
There is also a support level marked below to be used as a liquidity target as per the ICT Silver Bullet concept suggests.
In the below chart we can see 4 separate consecutive examples of bullish & bearish setups on the 3-minute chart.
🔶 CONCEPTS
This technique can visualize potential support/resistance lines, which can be used as targets.
The script contains 2 main components:
• forming of a Fair Value Gap (FVG)
• drawing support/resistance (S/R) lines
🔹 Forming of FVG
1 basic principle: when a FVG at the end of the SB session is not retraced, it will be made invisible.
Dependable on the settings, different FVG's will be shown.
• 'All FVG': all FVG's are shown, regardless the trend
• 'Only FVG's in the same direction of trend': Only FVG's are shown that are similar to the trend at that moment (trend can be visualized by enabling ' Show ' -> ' Trend ')
-> only bearish FVG when the trend is bearish vs. bullish FVG when trend is bullish
• 'strict': Besides being similar to the trend, only FVG's are shown when the closing price at the end of the SB session is:
– below the top of the FVG box (bearish FVG)
– above bottom of the FVG box (bullish FVG)
• 'super-strict': Besides being similar to the trend, only FVG's are shown when the FVG box is NOT broken
in the opposite direction AND the closing price at the end of the SB session is:
– below bottom of the FVG box (bearish FVG)
– above the top of the FVG box (bullish FVG)
' Super-Strict ' mode resembles ICT lectures the most.
🔹 Drawing support/resistance lines
When the SB session has ended, the script draws potential support/resistance lines, again, dependable on the settings.
• Previous session (any): S/R lines are fetched between current and previous session.
For example, when current session is ' AM SB Session (10 AM — 11 AM) ', then previous session is
' London Open SB (3 AM — 4 AM) ', S/R lines between these 2 sessions alone will be included.
• Previous session (similar): S/R lines are fetched between current and previous - similar - session.
For example, when current session is ' London Open SB (3 AM — 4 AM)' , only S/R lines between
current session and previous ' London Open SB (3 AM — 4 AM) ' session are included.
When a new session starts, S/R lines will be removed, except when enabling ' Keep lines (only in strict mode) '
This is not possible in ' All FVG ' or ' Only FVG's in the same direction of trend ' mode, since the chart would be cluttered.
Note that in ' All FVG ' or ' Only FVG's in the same direction of trend ' mode, both, Support/Resistance lines will be shown,
while in Strict/Super-Strict mode:
• only Support lines will be shown if a bearish FVG appears
• only Resistance lines if a bullish FVG is shown
The lines will still be drawn the the end of the SB session, when a valid FVG appears,
but the S/R lines will remain visible and keep being updated until price reaches that line.
This publication contains a "Minimum Trade Framework (mTFW)", which represents the best-case expected price delivery, this is not your actual trade entry - exit range.
• 40 ticks for index futures or indices
• 15 pips for Forex pairs.
When on ' Strict/Super-Strict ' mode, only S/R lines will be shown which are:
• higher than the lowest FVG bottom + mTFW, in a bullish scenario
• lower than the highest FVG bottom - mTFW, in a bearish scenario
When on ' All FVG/Only FVG's in the same direction of trend ' mode, or on non-Forex/Futures/Indices symbols, S/R needs to be higher/lower than SB session high/low.
🔶 SETTINGS
(Check CONCEPTS for deeper insights and explanation)
🔹 Swing settings (left): Sets the length, which will set the lookback period/sensitivity of the Zigzag patterns (which directs the trend)
🔹 Silver Bullet Session; Show SB session: show lines and labels of SB session
Labels can be disabled separately in the ' Style ' section, color is set at the ' Inputs ' section.
🔹 FVG
– Mode
• All FVG
• Only FVG's in the same direction of trend
• Strict
• Super-Strict
– Colors
– Extend: extend till last bar of SB session
🔹 Targets – support/resistance lines
– Previous session (any): S/R lines fetched between current and previous SB session
– Previous session (similar): S/R lines fetched between current and previous similar SB session
– Colors
– Keep lines (only in strict mode)
🔹 Show
– MSS ~ Session: Show Market Structure Shift , only when this happens during a SB session
– Trend: Show trend (Zigzag, colored ~ trend)
90cycle @joshuuu90 minute cycle is a concept about certain time windows of the day.
This indicator has two different options. One uses the 90 minute cycle times mentioned by traderdaye, the other uses the cls operational times split up into 90 minutes session.
e.g. we can often see a fake move happening in the 90 minute window between 2.30am and 4am ny time.
The indicator draws vertical lines at the start/end of each session and the user is able to only display certain sessions (asia, london, new york am and pm)
For the traderdayes option, the indicator also counts the windows from 1 to 4 and calls them q1,q2,q3,q4 (q-quarter)
⚠️ Open Source ⚠️
Coders and TV users are authorized to copy this code base, but a paid distribution is prohibited. A mention to the original author is expected, and appreciated.
⚠️ Terms and Conditions ⚠️
This financial tool is for educational purposes only and not financial advice. Users assume responsibility for decisions made based on the tool's information. Past performance doesn't guarantee future results. By using this tool, users agree to these terms.
Nadaraya-Watson CombineThis is a combination of the Lux Algo Nadaraya-Watson Estimator and Envelope. Please note the repainting issue.
In addition, I've added a plot of the actual values of the current barstate of
the Nadaraya-Watson windows as they are computed (lines 92-95). It only plots values for the current data at
each time update. It is interesting to compare the trajectory of the end points of the Estimator and
Envelope to the smoothing function at each time update. Due to the kernel smoothing at each update the
history is lost at each update (repaint).
I've added a feature to allow adjustment to the kernel smoothing algorithm as suggested by thomsonraja (line 59).
The settings and usage are repeated from Lux Algo below.
Settings
Window Size: Determines the number of recent price observations to be used to fit the Nadaraya-Watson Estimator.
Bandwidth: Controls the degree of smoothness of the envelopes , with higher values returning smoother results.
Mult: Controls the envelope width.
Src: Input source of the indicator.
Kernel power: See line 59, adjusts the exponential power (powh) as suggested by thomsonraja
Kernel denominator: See line 59, adjusts the denominator (den) as suggested by thomsonraja
Usage
This tool outlines extremes made by the prices within the selected window size.
This is achieved by estimating the underlying trend in the price using kernel smoothing,
calculating the mean absolute deviations from it, and adding/subtracting it
from the estimated underlying trend.
I repeat Lux Algo's caution: 'we do not recommend this tool to be used alone
or solely for real time applications.'
z_scoreStand-alone Z-score indicator for volatile currency pairs, showing STRONG BUY, BUY, SELL, STRONG SELL zones.
The use can define their own "window" or moving average length, which will affect the frequency and magnitude of trades.
Higher windows reduce trade size but increase frequency and vice versa.
The suggested window values are intended for the daily time-frame. They are selected to maximise returns.
ETHBTC . 64 days.
SOLBTC . 40 days.
Trading decisions must be confirmed by multiple indicators and other factors.
getSeries█ OVERVIEW
This library is a Pine programmer’s tool containing functions that build an array of values meeting specific conditions. Its functions use concepts from our ConditionalAverages library , but instead of returning a single value, they return an array containing all the values meeting the conditions, which can then be processed as needed. This provides more flexibility to the programmer than a single value.
The "getSeries" name of the library stems from the fact that is uses arrays to build the equivalent of custom series which can then be operated on using array-specific functions in the `array.*` namespace, looped through using a for...in structure to implement custom logic, or sent to functions designed to process arrays such as those in these libraries: ArrayStatistics , ArrayOperations , arrayutils or Averages .
The eight examples illustrated in the library's code showcase the diversity of scenarios where the functions can be used.
Look first. Then leap.
█ FUNCTIONS
The library contains the following functions:
whenSince(src, whenCond, sinceCond, length)
Creates an array containing the `length` last `src` values where `whenCond` is true, since the last occurence of `sinceCond`.
Parameters:
src : (series int/float) The source of the values to be included.
whenCond : (series bool) The condition determining which values are included. Optional. The default is `true`.
sinceCond : (series bool) The condition determining when the accumulated series resets. Optional. The default is false, which will not reset.
length : (simple int) The number of last values to return. Optional. The default is all values.
Returns: (float ) The array ID of the accumulated `src` values.
rollOnTimeWhen(src, timeWindow, cond, minBars)
Creates an array of `src` values where `cond` is true, over a moving window of length `timeWindow` milliseconds.
Parameters:
src : (series int/float) The source of the values to be included.
timeWindow : (simple int) The time duration in milliseconds defining the size of the moving window.
cond : (series bool) The condition determining which values are included. Optional. The default is `true`.
minBars : (simple int) The minimum number of values to maintain in the moving window. Optional. The default is 1.
Returns: (float ) The array ID of the accumulated `src` values.
Note that the functions must be called on each bar to work correctly. They must thus be pre-evaluated before using their results in conditional branches.
Simple scalping strategy for SOLThis is a simple scalping strategy for trading SOL made on top of the Rebalance Oscillator and the Rebalance Bear/Bull market indicators.
It is intended mostly as proof that these two indicators have their benefits even in simpler strategies.
This strategy in particular works well for the Bear months (check Nov. in the data window) but considerably underperforms Buy&Hold for the Bull months.
It tries to do a market operation per candle whenever the candle happens in a buy/sell trading window of the
Rebalance Bear/Bull indicator ().
It always buys/sells the same amount by default (you can set it in the cog menu in the option "Base Crypto Amount To Trade"),
for SOL this is set to 1.0SOL.
This is my first attempt at scalping, it differs slightly from the standards because it does not require fast
response candles or immediate market operations (it can work well with limit trading) and on top of this it also
does not require a stop loss since it uses an indicator that provides the trading windows (surprises can still happen though).
The profit that this strategy tries to take for each buy/sell pair is not configurable and is set at 12% each way when it happens.
KLemurs DeviationMarket: Stocks and ETF's
This overlay shows the deviation of the exponential moving average of the mid candle price of the currently loaded chart, away from the exponential moving average of the S&P and DOW combined and averaged mid candle price. The top and bottom lines also give a visual perspective of what a certain percentage (default 1%) looks like on the current charts window. This may help with making quick decisions for things like setting trailing stop trades with a percentage. This can be used for stocks, ETF's, and index's and It may be useful in finding potential stocks or ETF's if you are interested in these kinds of deviations. Defaults are set for a dark screen but can be edited to your taste. It's optimized to be an overlay on the current chart window as opposed to being a separate window.
Percentage Lines (editable)
This is three lines. The upper line (default green) plots the set percentage (default 1%) above the current chart’s ema. The middle line (default white) plots the current chart’s ema. The lower line (default red) plots the set percentage (default 1%) below the current chart’s ema.
Deviation Band (editable)
This is the colored band on the overlay between the upper and lower percentage lines. The band’s fill color indicates the deviation of the current charts ema from the ema of the combined S&P and DOW’s ema as follows:
- Red (default) = Current Chart’s ema is descending and the S&P/DOW ema is descending OR the Current Chart’s ema is below (underperforming) the S&P/DOW ema.
- Orange (default) = The Current Chart and S&P/DOW ema’s are both either ascending or descending together.
- Green (default) = The Current Chart’s ema is ascending but the S&P/DOW ema is descending.
To Set Line Colors
BY default, the upper line color uses the same colors as the ascending band color and the lower line uses the same color as the descending band color. To set the line colors, see "plotColor", "plotColorUp", or" plotColorDown" in variable settings within the script or use the “Central Plot Line”, “Upper Plot Line, or “Lower Plot Line” in the input dialogue to change this.
To Set Band Colors
To set the band colors, see "plotColor", "plotColorUp", or "plotColorDown" in variable settings within the script or use the “Color0”, “Color1", or “Color2” in the input dialogue to change this.
To Set EMA Lookback Period
The ema lookback period defaults to 5. This is the number of candles back that the script will use to determine the ema. See “CCemaN” in variable settings within the script or use the “EMA Period” in the input dialogue to change this.
To Set Percentage
To set the percentage that plots the upper and lower lines, see "CCP" in variable settings within the script or use “Upper/Lower Bands Percentage” in the input dialogue to change this. The default is .01 (or 1%).
Order Blocks + Order-Flow ProxiesOrder Blocks + Order-Flow Proxies
This indicator combines structural analysis of order blocks with lightweight order-flow style proxies, providing a tool for chart annotation and contextual study. It is designed to help users visualize where significant structural shifts occur and how simple volume-based signals behave around those areas. The script does not guarantee profitable outcomes, nor does it issue financial advice. It is intended purely for research, learning, and discretionary use.
Conceptual Background
Order Blocks
An “order block” is a term often used to describe a zone on the chart where price left behind a significant reversal or imbalance before continuing strongly in the opposite direction. In practice, this can mean the last bullish or bearish candle before a strong breakout. Traders sometimes study these regions because they believe that unfilled resting orders may exist there, or simply because they mark important pivots in price structure. This indicator detects such moments by scanning for breaks of structure (BOS). When price pushes above or below recent swing levels with sufficient displacement, the script identifies the prior opposite candle as the potential order block.
Break of Structure
A break of structure in this context is defined when the closing price moves beyond the highest high or lowest low of a short lookback window. The script compares the magnitude of this break to an ATR-based displacement filter. This helps ensure that only meaningful moves are marked rather than small, random fluctuations.
Order-Flow Proxies
Traditional order flow analysis may use bid/ask data, footprint charts, or volume profiles. Because TradingView scripts cannot access true order-book data, this indicator instead uses proxy signals derived from standard chart data:
Delta (proxy): Estimated imbalance of buying vs. selling pressure, approximated using bar direction and volume.
Imbalance ratio: Normalizes delta by total volume, ranging between -1 and +1 in theory.
Cumulative Delta (CVD): Running sum of delta over time.
Effort vs. Result (EvR): A comparison between volume and actual bar movement, highlighting cases where large effort produced little result (or vice versa).
These are not real order-flow measurements, but rather simple mathematical constructs that mimic some of its logic.
How the Script Works
Detecting Break of Structure
The user specifies a swing length. When price closes above the recent high (for bullish BOS) or below the recent low (for bearish BOS), a potential shift is recorded.
To qualify, the breakout must exceed a displacement filter proportional to the ATR. This helps filter out weak moves.
Locating the Order Block Candle
Once a BOS is confirmed, the script looks back within a short window to find the last opposite-colored candle.
The high/low or open/close of that candle (depending on user settings) is marked as the potential order block zone.
Drawing and Maintaining Zones
Each order block is represented as a colored rectangle extending forward in time.
Bullish zones are teal by default, bearish zones are red.
Zones extend until invalidated (price closing or wicking beyond them, depending on user preference) or until a user-defined lifespan expires.
A pruning mechanism ensures that only the most recent set number of zones remain, preventing chart overload.
Monitoring Touches
The script checks whether the current bar’s range overlaps any existing order block.
If so, the “closest” zone is considered touched, and a label may appear on the chart.
Confirmation Filters
Touches can optionally be confirmed by order-flow proxies.
For a bullish confirmation, the following must align:
Imbalance ratio above threshold,
Delta EMA positive,
Effort vs. Result positive.
For a bearish confirmation, the opposite holds true.
Optionally, a higher-timeframe EMA slope filter can gate these confirmations. For example, a bullish confirmation may only be accepted if the higher-timeframe EMA is sloping upward.
Alerts
Users may create alerts based on conditions such as “bullish touch confirmed” or “bearish touch confirmed.”
Alerts can be gated to only fire after bar close, reducing intrabar noise.
Standard alertcondition calls are provided, and optional inline alert() calls can be enabled.
Inputs and Customization
Structure & OB
Swing length: Defines how many bars back to check for BOS.
ATR length & displacement factor: Adjust sensitivity for structural breaks.
Body vs. wick reference: Choose whether zones are based on candle bodies or full ranges.
Invalidation rule: Pick between wick breach or close beyond the level.
Lifespan (bars): Limit how long a zone remains active.
Max keep: Cap the number of zones stored to reduce clutter.
Order-Flow Proxies
Delta mode: Choose between “Close vs Previous Close” or “Body” for delta calculation.
EMA length: Smooths the delta/imbalance series.
Z-score lookback: Defines the averaging window for EvR.
Confirmation thresholds: Adjust the imbalance levels required for long/short confirmation.
Higher Timeframe Filter
Enable HTF gate: Optional filter requiring higher-timeframe EMA slope alignment.
HTF timeframe & EMA length: Configurable for context alignment.
Style
Colors and transparency for bullish and bearish zones.
Border color customization.
Alerts
Enable inline alerts: Optional direct calls to alert().
Alerts on bar close only: Helps avoid multiple firings during bar formation.
Practical Use
This tool is best seen as a way to annotate charts and to study how simple volume-derived signals behave near important structural levels. Some users may:
Observe whether order blocks line up with later price reactions.
Study how imbalance or cumulative delta conditions align with these zones.
Use it in a discretionary workflow to highlight areas of interest for deeper analysis.
Because the proxies are based only on candle OHLCV data, they are approximations. They cannot replace true depth-of-market analysis. Similarly, order block detection here is one specific algorithmic interpretation; other traders may define order blocks differently.
Limitations and Disclaimers
This indicator does not predict future price movement.
It does not access real order book or tick-by-tick data. All signals are derived from bar OHLCV.
Past performance of signals or zones does not guarantee future results.
The script is for educational and informational purposes only. It is not financial advice.
Users should test thoroughly, adjust parameters to their own instruments and timeframes, and use it in combination with broader analysis.
Summary
The Order Blocks + Order-Flow Proxies script is an experimental study tool that:
Detects potential order blocks using a displacement-filtered break of structure.
Marks these zones as boxes that persist until invalidation or expiry.
Provides lightweight order-flow-style proxies such as delta, imbalance, CVD, and effort vs. result.
Allows confirmation of zone touches through these proxies and optional higher-timeframe context.
Offers flexible customization, alerting, and chart-style options.
It is not a trading system by itself but rather a framework for studying price/volume behavior around structurally significant areas. With careful exploration, it can give users new ways to visualize market structure and to understand how simple flow-like measures behave in those contexts.
Order Blocks + Order-Flow ProxiesOrder Blocks + Order-Flow Proxies
This indicator combines structural analysis of order blocks with lightweight order-flow style proxies, providing a tool for chart annotation and contextual study. It is designed to help users visualize where significant structural shifts occur and how simple volume-based signals behave around those areas. The script does not guarantee profitable outcomes, nor does it issue financial advice. It is intended purely for research, learning, and discretionary use.
Conceptual Background
Order Blocks
An “order block” is a term often used to describe a zone on the chart where price left behind a significant reversal or imbalance before continuing strongly in the opposite direction. In practice, this can mean the last bullish or bearish candle before a strong breakout. Traders sometimes study these regions because they believe that unfilled resting orders may exist there, or simply because they mark important pivots in price structure. This indicator detects such moments by scanning for breaks of structure (BOS). When price pushes above or below recent swing levels with sufficient displacement, the script identifies the prior opposite candle as the potential order block.
Break of Structure
A break of structure in this context is defined when the closing price moves beyond the highest high or lowest low of a short lookback window. The script compares the magnitude of this break to an ATR-based displacement filter. This helps ensure that only meaningful moves are marked rather than small, random fluctuations.
Order-Flow Proxies
Traditional order flow analysis may use bid/ask data, footprint charts, or volume profiles. Because TradingView scripts cannot access true order-book data, this indicator instead uses proxy signals derived from standard chart data:
Delta (proxy): Estimated imbalance of buying vs. selling pressure, approximated using bar direction and volume.
Imbalance ratio: Normalizes delta by total volume, ranging between -1 and +1 in theory.
Cumulative Delta (CVD): Running sum of delta over time.
Effort vs. Result (EvR): A comparison between volume and actual bar movement, highlighting cases where large effort produced little result (or vice versa).
These are not real order-flow measurements, but rather simple mathematical constructs that mimic some of its logic.
How the Script Works
Detecting Break of Structure
The user specifies a swing length. When price closes above the recent high (for bullish BOS) or below the recent low (for bearish BOS), a potential shift is recorded.
To qualify, the breakout must exceed a displacement filter proportional to the ATR. This helps filter out weak moves.
Locating the Order Block Candle
Once a BOS is confirmed, the script looks back within a short window to find the last opposite-colored candle.
The high/low or open/close of that candle (depending on user settings) is marked as the potential order block zone.
Drawing and Maintaining Zones
Each order block is represented as a colored rectangle extending forward in time.
Bullish zones are teal by default, bearish zones are red.
Zones extend until invalidated (price closing or wicking beyond them, depending on user preference) or until a user-defined lifespan expires.
A pruning mechanism ensures that only the most recent set number of zones remain, preventing chart overload.
Monitoring Touches
The script checks whether the current bar’s range overlaps any existing order block.
If so, the “closest” zone is considered touched, and a label may appear on the chart.
Confirmation Filters
Touches can optionally be confirmed by order-flow proxies.
For a bullish confirmation, the following must align:
Imbalance ratio above threshold,
Delta EMA positive,
Effort vs. Result positive.
For a bearish confirmation, the opposite holds true.
Optionally, a higher-timeframe EMA slope filter can gate these confirmations. For example, a bullish confirmation may only be accepted if the higher-timeframe EMA is sloping upward.
Alerts
Users may create alerts based on conditions such as “bullish touch confirmed” or “bearish touch confirmed.”
Alerts can be gated to only fire after bar close, reducing intrabar noise.
Standard alertcondition calls are provided, and optional inline alert() calls can be enabled.
Inputs and Customization
Structure & OB
Swing length: Defines how many bars back to check for BOS.
ATR length & displacement factor: Adjust sensitivity for structural breaks.
Body vs. wick reference: Choose whether zones are based on candle bodies or full ranges.
Invalidation rule: Pick between wick breach or close beyond the level.
Lifespan (bars): Limit how long a zone remains active.
Max keep: Cap the number of zones stored to reduce clutter.
Order-Flow Proxies
Delta mode: Choose between “Close vs Previous Close” or “Body” for delta calculation.
EMA length: Smooths the delta/imbalance series.
Z-score lookback: Defines the averaging window for EvR.
Confirmation thresholds: Adjust the imbalance levels required for long/short confirmation.
Higher Timeframe Filter
Enable HTF gate: Optional filter requiring higher-timeframe EMA slope alignment.
HTF timeframe & EMA length: Configurable for context alignment.
Style
Colors and transparency for bullish and bearish zones.
Border color customization.
Alerts
Enable inline alerts: Optional direct calls to alert().
Alerts on bar close only: Helps avoid multiple firings during bar formation.
Practical Use
This tool is best seen as a way to annotate charts and to study how simple volume-derived signals behave near important structural levels. Some users may:
Observe whether order blocks line up with later price reactions.
Study how imbalance or cumulative delta conditions align with these zones.
Use it in a discretionary workflow to highlight areas of interest for deeper analysis.
Because the proxies are based only on candle OHLCV data, they are approximations. They cannot replace true depth-of-market analysis. Similarly, order block detection here is one specific algorithmic interpretation; other traders may define order blocks differently.
Limitations and Disclaimers
This indicator does not predict future price movement.
It does not access real order book or tick-by-tick data. All signals are derived from bar OHLCV.
Past performance of signals or zones does not guarantee future results.
The script is for educational and informational purposes only. It is not financial advice.
Users should test thoroughly, adjust parameters to their own instruments and timeframes, and use it in combination with broader analysis.
Summary
The Order Blocks + Order-Flow Proxies script is an experimental study tool that:
Detects potential order blocks using a displacement-filtered break of structure.
Marks these zones as boxes that persist until invalidation or expiry.
Provides lightweight order-flow-style proxies such as delta, imbalance, CVD, and effort vs. result.
Allows confirmation of zone touches through these proxies and optional higher-timeframe context.
Offers flexible customization, alerting, and chart-style options.
It is not a trading system by itself but rather a framework for studying price/volume behavior around structurally significant areas. With careful exploration, it can give users new ways to visualize market structure and to understand how simple flow-like measures behave in those contexts.
Relative Volatility Mass [SciQua]The ⚖️ Relative Volatility Mass (RVM) is a volatility-based tool inspired by the Relative Volatility Index (RVI) .
While the RVI measures the ratio of upward to downward volatility over a period, RVM takes a different approach:
It sums the standard deviation of price changes over a rolling window, separating upward volatility from downward volatility .
The result is a measure of the total “volatility mass” over a user-defined period, rather than an average or normalized ratio.
This makes RVM particularly useful for identifying sustained high-volatility conditions without being diluted by averaging.
────────────────────────────────────────────────────────────
╭────────────╮
How It Works
╰────────────╯
1. Standard Deviation Calculation
• Computes the standard deviation of the chosen `Source` over a `Standard Deviation Length` (`stdDevLen`).
2. Directional Separation
• Volatility on up bars (`chg > 0`) is treated as upward volatility .
• Volatility on down bars (`chg < 0`) is treated as downward volatility .
3. Rolling Sum
• Over a `Sum Length` (`sumLen`), the upward and downward volatilities are summed separately using `math.sum()`.
4. Relative Volatility Mass
• The two sums are added together to get the total volatility mass for the rolling window.
Formula:
RVM = Σ(σ up) + Σ(σ down)
where σ is the standard deviation over `stdDevLen`.
╭────────────╮
Key Features
╰────────────╯
Directional Volatility Tracking – Differentiates between volatility during price advances vs. declines.
Rolling Volatility Mass – Shows the total standard deviation accumulation over a given period.
Optional Smoothing – Multiple MA types, including SMA, EMA, SMMA (RMA), WMA, VWMA.
Bollinger Band Overlay – Available when SMA is selected, with adjustable standard deviation multiplier.
Configurable Source – Apply RVM to `close`, `open`, `hl2`, or any custom source.
╭─────╮
Usage
╰─────╯
Trend Confirmation: High RVM values can confirm strong trending conditions.
Breakout Detection: Spikes in RVM often precede or accompany price breakouts.
Volatility Cycle Analysis: Compare periods of contraction and expansion.
RVM is not bounded like the RVI, so absolute values depend on market volatility and chosen parameters.
Consider normalizing or using smoothing for easier visual comparison.
╭────────────────╮
Example Settings
╰────────────────╯
Short-term volatility detection: `stdDevLen = 5`, `sumLen = 10`
Medium-term trend volatility: `stdDevLen = 14`, `sumLen = 20`
Enable `SMA + Bollinger Bands` to visualize when volatility is unusually high or low relative to recent history.
╭───────────────────╮
Notes & Limitations
╰───────────────────╯
Not a directional signal by itself — use alongside price structure, volume, or other indicators.
Higher `sumLen` will smooth short-term fluctuations but reduce responsiveness.
Because it sums, not averages, values will scale with both volatility and chosen window size.
╭───────╮
Credits
╰───────╯
Based on the Relative Volatility Index concept by Donald Dorsey (1993).
TradingView
SciQua - Joshua Danford
Renko Price TrackerRenko Sequential Signal – qLine + Moneyball Confirmation
This indicator is designed for Renko chart traders who want to combine price action relative to a key line (qLine) with Moneyball buy/sell signals as a confirmation. It helps filter trades so you only get signals when both conditions align within a chosen time window.
How It Works
First Event – Price Trigger
Detects when the Renko close crosses above/below your selected qLine plot from the qPro indicator.
You can choose between:
Cross – only triggers on an actual crossover/crossunder.
State (Close) – triggers whenever price closes above/below qLine.
Second Event – Moneyball Confirmation
Waits for Moneyball’s Buy Signal (for long) or Bear/Sell Signal (for short) plot to fire.
You select the exact Moneyball plot from the source menu.
You can specify how the Moneyball signal is interpreted (== 1, >= 1, or any nonzero value).
Sequential Logic
The Moneyball signal must occur within N Renko bricks after the price event.
The final buy/sell signal is printed on the Moneyball bar.
Key Features
Works natively on Renko charts.
Adjustable confirmation window (0–5 bricks).
Flexible detection for both qLine and Moneyball signals.
Customizable label sizes, arrow display, and alerts.
Alerts fire for both buy and sell conditions:
BUY: qLine ➜ Moneyball Buy
SELL: qLine ➜ Moneyball Sell
Inputs
qLine Source – Pick the qPro qLine plot.
Price Event Type – Cross or State.
Moneyball Buy/Sell Signal Plots – Select the correct plots from your Moneyball indicator.
Confirmation Window – Bars allowed between events.
Visual Settings – Label size, arrow visibility, etc.
Use Case
Ideal for traders who:
Want a double-confirmation entry system.
Use Renko charts for cleaner trend detection.
Already have qPro and Moneyball loaded, but want an automated, rule-based confluence check.
Fibonacci Sequence Moving Average [BackQuant]Fibonacci Sequence Moving Average with Adaptive Oscillator
1. Overview
The Fibonacci Sequence Moving Average indicator is a two‑part trading framework that combines a custom moving average built from the famous Fibonacci number set with a fully featured oscillator, normalisation engine and divergence suite. The moving average half delivers an adaptive trend line that respects natural market rhythms, while the oscillator half translates that trend information into a bounded momentum stream that is easy to read, easy to compare across assets and rich in confluence signals. Everything from weighting logic to colour palettes can be customised, so the tool comfortably fits scalpers zooming into one‑minute candles as well as position traders running multi‑month trend following campaigns.
2. Core Calculation
Fibonacci periods – The default length array is 5, 8, 13, 21, 34. A single multiplier input lets you scale the whole family up or down without breaking the golden‑ratio spacing. For example a multiplier of 3 yields 15, 24, 39, 63, 102.
Component averages – Each period is passed through Simple Moving Average logic to produce five baseline curves (ma1 through ma5).
Weighting methods – You decide how those five values are blended:
• Equal weighting treats every curve the same.
• Linear weighting applies factors 1‑to‑5 so the slowest curve counts five times as much as the fastest.
• Exponential weighting doubles each step for a fast‑reacting yet still smooth line.
• Fibonacci weighting multiplies each curve by its own period value, honouring the spirit of ratio mathematics.
Smoothing engine – The blended average is then smoothed a second time with your choice of SMA, EMA, DEMA, TEMA, RMA, WMA or HMA. A short smoothing length keeps the result lively, while longer lengths create institution‑grade glide paths that act like dynamic support and resistance.
3. Oscillator Construction
Once the smoothed Fib MA is in place, the script generates a raw oscillator value in one of three flavours:
• Distance – Percentage distance between price and the average. Great for mean‑reversion.
• Momentum – Percentage change of the average itself. Ideal for trend acceleration studies.
• Relative – Distance divided by Average True Range for volatility‑aware scaling.
That raw series is pushed through a look‑back normaliser that rescales every reading into a fixed −100 to +100 window. The normalisation window defaults to 100 bars but can be tightened for fast markets or expanded to capture long regimes.
4. Visual Layer
The oscillator line is gradient‑coloured from deep red through sky blue into bright green, so you can spot subtle momentum shifts with peripheral vision alone. There are four horizontal guide lines: Extreme Bear at −50, Bear Threshold at −20, Bull Threshold at +20 and Extreme Bull at +50. Soft fills above and below the thresholds reinforce the zones without cluttering the chart.
The smoothed Fib MA can be plotted directly on price for immediate trend context, and each of the five component averages can be revealed for educational or research purposes. Optional bar‑painting mirrors oscillator polarity, tinting candles green when momentum is bullish and red when momentum is bearish.
5. Divergence Detection
The script automatically looks for four classes of divergences between price pivots and oscillator pivots:
Regular Bullish, signalling a possible bottom when price prints a lower low but the oscillator prints a higher low.
Hidden Bullish, often a trend‑continuation cue when price makes a higher low while the oscillator slips to a lower low.
Regular Bearish, marking potential tops when price carves a higher high yet the oscillator steps down.
Hidden Bearish, hinting at ongoing downside when price posts a lower high while the oscillator pushes to a higher high.
Each event is tagged with an ℝ or ℍ label at the oscillator pivot, colour‑coded for clarity. Look‑back distances for left and right pivots are fully adjustable so you can fine‑tune sensitivity.
6. Alerts
Five ready‑to‑use alert conditions are included:
• Bullish when the oscillator crosses above +20.
• Bearish when it crosses below −20.
• Extreme Bullish when it pops above +50.
• Extreme Bearish when it dives below −50.
• Zero Cross for momentum inflection.
Attach any of these to TradingView notifications and stay updated without staring at charts.
7. Practical Applications
Swing trading trend filter – Plot the smoothed Fib MA on daily candles and only trade in its direction. Enter on oscillator retracements to the 0 line.
Intraday reversal scouting – On short‑term charts let Distance mode highlight overshoots beyond ±40, then fade those moves back to mean.
Volatility breakout timing – Use Relative mode during earnings season or crypto news cycles to spot momentum surges that adjust for changing ATR.
Divergence confirmation – Layer the oscillator beneath price structure to validate double bottoms, double tops and head‑and‑shoulders patterns.
8. Input Summary
• Source, Fibonacci multiplier, weighting method, smoothing length and type
• Oscillator calculation mode and normalisation look‑back
• Divergence look‑back settings and signal length
• Show or hide options for every visual element
• Full colour and line width customisation
9. Best Practices
Avoid using tiny multipliers on illiquid assets where the shortest Fibonacci window may drop under three bars. In strong trends reduce divergence sensitivity or you may see false counter‑trend flags. For portfolio scanning set oscillator to Momentum mode, hide thresholds and colour bars only, which turns the indicator into a heat‑map that quickly highlights leaders and laggards.
10. Final Notes
The Fibonacci Sequence Moving Average indicator seeks to fuse the mathematical elegance of the golden ratio with modern signal‑processing techniques. It is not a standalone trading system, rather a multi‑purpose information layer that shines when combined with market structure, volume analysis and disciplined risk management. Always test parameters on historical data, be mindful of slippage and remember that past performance is never a guarantee of future results. Trade wisely and enjoy the harmony of Fibonacci mathematics in your technical toolkit.
Info TableOverview
The Info Table V1 is a versatile TradingView indicator tailored for intraday futures traders, particularly those focusing on MESM2 (Micro E-mini S&P 500 futures) on 1-minute charts. It presents essential market insights through two customizable tables: the Main Table for predictive and macro metrics, and the New Metrics Table for momentum and volatility indicators. Designed for high-activity sessions like 9:30 AM–11:00 AM CDT, this tool helps traders assess price alignment, sentiment, and risk in real-time. Metrics update dynamically (except weekly COT data), with optional alerts for key conditions like volatility spikes or momentum shifts.
This indicator builds on foundational concepts like linear regression for predictions and adapts open-source elements for enhanced functionality. Gradient code is adapted from TradingView's Color Library. QQE logic is adapted from LuxAlgo's QQE Weighted Oscillator, licensed under CC BY-NC-SA 4.0. The script is released under the Mozilla Public License 2.0.
Key Features
Two Customizable Tables: Positioned independently (e.g., top-right for Main, bottom-right for New Metrics) with toggle options to show/hide for a clutter-free chart.
Gradient Coloring: User-defined high/low colors (default green/red) for quick visual interpretation of extremes, such as overbought/oversold or high volatility.
Arrows for Directional Bias: In the New Metrics Table, up (↑) or down (↓) arrows appear in value cells based on metric thresholds (top/bottom 25% of range), indicating bullish/high or bearish/low conditions.
Consensus Highlighting: The New Metrics Table's title cells ("Metric" and "Value") turn green if all arrows are ↑ (strong bullish consensus), red if all are ↓ (strong bearish consensus), or gray otherwise.
Predicted Price Plot: Optional line (default blue) overlaying the ML-predicted price for visual comparison with actual price action.
Alerts: Notifications for high/low Frahm Volatility (≥8 or ≤3) and QQE Bias crosses (bullish/bearish momentum shifts).
Main Table Metrics
This table focuses on predictive, positional, and macro insights:
ML-Predicted Price: A linear regression forecast using normalized price, volume, and RSI over a customizable lookback (default 500 bars). Gradient scales from low (red) to high (green) relative to the current price ± threshold (default 100 points).
Deviation %: Percentage difference between current price and predicted price. Gradient highlights extremes (±0.5% default threshold), signaling potential overextensions.
VWAP Deviation %: Percentage difference from Volume Weighted Average Price (VWAP). Gradient indicates if price is above (green) or below (red) fair value (±0.5% default).
FRED UNRATE % Change: Percentage change in U.S. unemployment rate (via FRED data). Cell turns red for increases (economic weakness), green for decreases (strength), gray if zero or disabled.
Open Interest: Total open MESM2 futures contracts. Gradient scales from low (red) to high (green) up to a hardcoded 300,000 threshold, reflecting market participation.
COT Commercial Long/Short: Weekly Commitment of Traders data for commercial positions. Long cell green if longs > shorts (bullish institutional sentiment); Short cell red if shorts > longs (bearish); gray otherwise.
New Metrics Table Metrics
This table emphasizes technical momentum and volatility, with arrows for quick bias assessment:
QQE Bias: Smoothed RSI vs. trailing stop (default length 14, factor 4.236, smooth 5). Green for bullish (RSI > stop, ↑ arrow), red for bearish (RSI < stop, ↓ arrow), gray for neutral.
RSI: Relative Strength Index (default period 14). Gradient from oversold (red, <30 + threshold offset, ↓ arrow if ≤40) to overbought (green, >70 - offset, ↑ arrow if ≥60).
ATR Volatility: Score (1–20) based on Average True Range (default period 14, lookback 50). High scores (green, ↑ if ≥15) signal swings; low (red, ↓ if ≤5) indicate calm.
ADX Trend: Average Directional Index (default period 14). Gradient from weak (red, ↓ if ≤0.25×25 threshold) to strong trends (green, ↑ if ≥0.75×25).
Volume Momentum: Score (1–20) comparing current to historical volume (lookback 50). High (green, ↑ if ≥15) suggests pressure; low (red, ↓ if ≤5) implies weakness.
Frahm Volatility: Score (1–20) from true range over a window (default 24 hours, multiplier 9). Dynamic gradient (green/red/yellow); ↑ if ≥7.5, ↓ if ≤2.5.
Frahm Avg Candle (Ticks): Average candle size in ticks over the window. Blue gradient (or dynamic green/red/yellow); ↑ if ≥0.75 percentile, ↓ if ≤0.25.
Arrows trigger on metric-specific logic (e.g., RSI ≥60 for ↑), providing directional cues without strict color ties.
Customization Options
Adapt the indicator to your strategy:
ML Inputs: Lookback (10–5000 bars) and RSI period (2+) for prediction sensitivity—shorter for volatility, longer for trends.
Timeframes: Individual per metric (e.g., 1H for QQE Bias to match higher frames; blank for chart timeframe).
Thresholds: Adjust gradients and arrows (e.g., Deviation 0.1–5%, ADX 0–100, RSI overbought/oversold).
QQE Settings: Length, factor, and smooth for fine-tuned momentum.
Data Toggles: Enable/disable FRED, Open Interest, COT for focus (e.g., disable macro for pure intraday).
Frahm Options: Window hours (1+), scale multiplier (1–10), dynamic colors for avg candle.
Plot/Table: Line color, positions, gradients, and visibility.
Ideal Use Case
Perfect for MESM2 scalpers and trend traders. Use the Main Table for entry confirmation via predicted deviations and institutional positioning. Leverage the New Metrics Table arrows for short-term signals—enter bullish on green consensus (all ↑), avoid chop on low volatility. Set alerts to catch shifts without constant monitoring.
Why It's Valuable
Info Table V1 consolidates diverse metrics into actionable visuals, answering critical questions: Is price mispriced? Is momentum aligning? Is volatility manageable? With real-time updates, consensus highlights, and extensive customization, it enhances precision in fast markets, reducing guesswork for confident trades.
Note: Optimized for futures; some metrics (OI, COT) unavailable on non-futures symbols. Test on demo accounts. No financial advice—use at your own risk.
The provided script reuses open-source elements from TradingView's Color Library and LuxAlgo's QQE Weighted Oscillator, as noted in the script comments and description. Credits are appropriately given in both the description and code comments, satisfying the requirement for attribution.
Regarding significant improvements and proportion:
The QQE logic comprises approximately 15 lines of code in a script exceeding 400 lines, representing a small proportion (<5%).
Adaptations include integration with multi-timeframe support via request.security, user-customizable inputs for length, factor, and smooth, and application within a broader table-based indicator for momentum bias display (with color gradients, arrows, and alerts). This extends the original QQE beyond standalone oscillator use, incorporating it as one of seven metrics in the New Metrics Table for confluence analysis (e.g., consensus highlighting when all metrics align). These are functional enhancements, not mere stylistic or variable changes.
The Color Library usage is via official import (import TradingView/Color/1 as Color), leveraging built-in gradient functions without copying code, and applied to enhance visual interpretation across multiple metrics.
The script complies with the rules: reused code is minimal, significantly improved through integration and expansion, and properly credited. It qualifies for open-source publication under the Mozilla Public License 2.0, as stated.
Normalized Open InterestNormalized Open Interest (nOI) — Indicator Overview
What it does
Normalized Open Interest (nOI) transforms raw futures open-interest data into a 0-to-100 oscillator, so you can see at a glance whether participation is unusually high or low—similar in spirit to an RSI but applied to open interest. The script positions today’s OI inside a rolling high–low range and paints it with contextual colours.
Core logic
Data source – Loads the built-in “_OI” symbol that TradingView provides for the current market.
Rolling range – Looks back a user-defined number of bars (default 500) to find the highest and lowest OI in that window.
Normalization – Calculates
nOI = (OI – lowest) / (highest – lowest) × 100
so 0 equals the minimum of the window and 100 equals the maximum.
Visual cues – Plots the oscillator plus fixed horizontal levels at 70 % and 30 % (or your own numbers). The line turns teal above the upper level, red below the lower, and neutral grey in between.
User inputs
Window Length (bars) – How many candles the indicator scans for the high–low range; larger numbers smooth the curve, smaller numbers make it more reactive.
Upper Threshold (%) – Default 70. Anything above this marks potentially crowded or overheated interest.
Lower Threshold (%) – Default 30. Anything below this marks low or capitulating interest.
Practical uses
Spot extremes – Values above the upper line can warn that the long side is crowded; values below the lower line suggest disinterest or short-side crowding.
Confirm breakouts – A price breakout backed by a sharp rise in nOI signals genuine engagement.
Look for divergences – If price makes a new high but nOI does not, participation might be fading.
Combine with volume or RSI – Layer nOI with other studies to filter false signals.
Tips
On intraday charts for non-crypto symbols the script automatically fetches daily OI data to avoid gaps.
Adjust the thresholds to 80/20 or 60/40 to fit your market and risk preferences.
Alerts, shading, or additional signal logic can be added easily because the oscillator is already normalised.
CGMALibrary "CGMA"
This library provides a function to calculate a moving average based on Chebyshev-Gauss Quadrature. This method samples price data more intensely from the beginning and end of the lookback window, giving it a unique character that responds quickly to recent changes while also having a long "memory" of the trend's start. Inspired by reading rohangautam.github.io
What is Chebyshev-Gauss Quadrature?
It's a numerical method to approximate the integral of a function f(x) that is weighted by 1/sqrt(1-x^2) over the interval . The approximation is a simple sum: ∫ f(x)/sqrt(1-x^2) dx ≈ (π/n) * Σ f(xᵢ) where xᵢ are special points called Chebyshev nodes.
How is this applied to a Moving Average?
A moving average can be seen as the "mean value" of the price over a lookback window. The mean value of a function with the Chebyshev weight is calculated as:
Mean = /
The math simplifies beautifully, resulting in the mean being the simple arithmetic average of the function evaluated at the Chebyshev nodes:
Mean = (1/n) * Σ f(xᵢ)
What's unique about this MA?
The Chebyshev nodes xᵢ are not evenly spaced. They are clustered towards the ends of the interval . We map this interval to our lookback period. This means the moving average samples prices more intensely from the beginning and the end of the lookback window, and less intensely from the middle. This gives it a unique character, responding quickly to recent changes while also having a long "memory" of the start of the trend.
Volatility Bias ModelVolatility Bias Model
Overview
Volatility Bias Model is a purely mathematical, non-indicator-based trading system that detects directional probability shifts during high volatility market phases. Rather than relying on classic tools like RSI or moving averages, this strategy uses raw price behavior and clustering logic to determine potential breakout direction based on recent market bias.
How It Works
Over a defined lookback window (default 10 bars), the strategy counts how many candles closed in the same direction (i.e., bullish or bearish).
Simultaneously, it calculates the price range during that window.
If volatility is above a minimum threshold and a clear directional bias is detected (e.g., >60% of closes are bullish), a trade is opened in the direction of that bias.
This approach assumes that when high volatility is coupled with directional closing consistency, the market is probabilistically more likely to continue in that direction.
ATR-based stop-loss and take-profit levels are applied, and trades auto-exit after 20 bars if targets are not hit.
Key Features
- 100% non-indicator-based logic
- Statistically-driven directional bias detection
- Works across all timeframes (1H, 4H, 1D)
- ATR-based risk management
- No pyramiding, slippage and commissions included
- Compatible with real-world backtesting conditions
Realism & Assumptions
To make this strategy more aligned with actual trading environments, it includes 0.05% commission per trade and a 1-point slippage on every entry and exit.
Additionally, position sizing is set at 10% of a $10,000 starting capital, and no pyramiding is allowed.
These assumptions help avoid unrealistic backtest results and make the performance metrics more representative of live conditions.
Parameter Explanation
Bias Window (10 bars): Number of past candles used to evaluate directional closings
Bias Threshold (0.60): Required ratio of same-direction candles to consider a bias valid
Minimum Range (1.5%): Ensures the market is volatile enough to avoid noise
ATR Length (14): Used to dynamically define stop-loss and target zones
Risk-Reward Ratio (2.0): Take-profit is set at twice the stop-loss distance
Max Holding Bars (20): Trades are closed automatically after 20 bars to prevent stagnation
Originality Note
Unlike common strategies based on oscillators or moving averages, this script is built on pure statistical inference. It models the market as a probabilistic process and identifies directional intent based on historical closing behavior, filtered by volatility. This makes it a non-linear, adaptive model grounded in real-world price structure — not traditional technical indicators.
Disclaimer
This strategy is for educational and experimental purposes only. It does not constitute financial advice. Always perform your own analysis and test thoroughly before applying with real capital.
Real Time Swing Trap DetectorThe Real Time Swing Trap Detector is a minimalist, pro-grade tool for instantly spotting classic “bull traps” and “bear traps” on any chart.
This indicator identifies swing traps in real time by tracking significant swing highs and lows, then watching for fast, false breakouts (bull traps) and breakdowns (bear traps) within a user-defined window.
How it works:
Detects when price breaks a major swing high/low (using configurable lookback).
If price quickly reclaims the broken level within X bars (trap window), a trap is confirmed and a subtle icon (🐂 for bull, 🐻 for bear) is displayed on the chart—no labels, no clutter.
You can enable/disable alerts for bull/bear traps individually or together, and receive notifications the moment a trap is detected.
Use cases:
Spot and avoid classic market “fakeouts” that trap breakout traders.
Confirm SMC/ICT “Judas swing” setups, or filter for high-probability reversals.
Works on all timeframes and assets: stocks, crypto, forex, indices.
Inputs:
Swing Lookback Bars: How far back to define swing points (default: 50)
Major Swing Filter: Additional filter for only the most significant highs/lows (default: 200)
Trap Bars (Look Ahead): Window in which a trap must be confirmed (default: 10)
Enable Bull/Bear Trap Alerts: Toggle real-time alerts for each trap type.
Visuals:
🐻 icon below bar for bear trap (short squeeze/reversal)
🐂 icon above bar for bull trap (long squeeze/reversal)
How to set up alerts:
Add the indicator to your chart, open TradingView’s Alerts panel, and choose “Bear Trap Alert,” “Bull Trap Alert,” or “Any Trap Alert” for instant notifications.
