BarbwireThis indicator looks for where market momentum is waning.
It uses Heikin-Ahi for that.
Heikin-Ashi averages the Open and Close prices, so the entity is not compressed as often as candles.
Using this characteristic, the continued compression of the entity is indicated as a decline in the market.
Settings:
Period - The degree of compression is calculated as a stochastic-like percentage. Specify the period to be used for the calculation.
Level (%) - If it is smaller than this number, it is assumed to be compressed.
Minimum period - The agreement shall be valid if it has been continued for at least this period.
Cari skrip untuk "Heikin Ashi"
MACD Trend CandlesThe script combines 2 indicators (MACD and Stoch-RSI) and puts them visually directly on the candles - can be used with normal OHLC candles or Heiken Ashi candles. Furthermore, you can derive divergences exremely easy directly visually from the candles as well. Lastly, a SMA 20 high and a SMA 20 low line build a trend channel.
Script is best used in trending markets to trade with the trend.
1) SMA trend channel:
* uptrend: close above
* downtrend: close below
* aggressive entry (uptrend) closing inside channel from below
* conservative entry (uptrend) closing above channel from inside
* hold (uptrend) until close below channel
* can be used accordingly for the downtrend
2) MACD candles
* visualization of the MACD histogram directly on the candles
* dark blue: histogram > 0 and histogram > histogram of previous candle
* light blue: histogram > 0 and histogram < histogram of previous candle
* orange: histogram < 0 and histogram < histogram of previous candle
* light blue: histogram < 0 and histogram > histogram of previous candle
* hold uptrend (dark/light blue candles) - combined with trend channel (above channel)
* hold downtrend (orange /yellow candles) - combined with trend channel (below channel)
* Color divergence: light blue candle > dark blue candle (price and MACD show divergence (bearish)
* Color divergence: yellow candle < orange candle (price and MACD show divergence (bullish)
* Trend change (0 line cross to upside) yellow or orange to dark blue
* Trend change (0 line cross to downside) dark or light blue to orange
3) Stoch RSI diamonds
* visualization of the STOCH-RSI as diamonds above or below the candle
* k, d line > 80: diamond above the candle
* k, d line < 20: diamond below the candle
* divergence caldle without diamond above > candle with diamond above (bearish divergence)
* divergence caldle without diamond below < candle with diamond below (bullish divergence)
Feel free to test each part individually and combine it with other indicators, e.g. BBands and Ichimoku Cloud - you will see it is a powerful visualization script
HAVE FUN
CSRS v2Candlesticked RSI v2 for price action traders!
See the True Momentum.
6 chart type, smooth RSI , add signal lines, find divergences, special alerts
This is 2nd version with major upgrade
Improved and more powerful
fully customizable.
features:
See RSI in 6 type of chart(Candles, Hollow Candles, Siwi Candles, Heikin Ashi, HL Bar, Line)
Monitor Up to 3 RSI , each one at desired resolution, source and length
Smooth each one of chart separately to remove noises
Add up to 3 signal line to primary chart in your desired source and type( SMA , EMA , WMA , HMA )
Find divergences which has special parameters
Gradient color adjustment of line chart
Add alert for reaching to important levels and detected divergences
Colored Klinger Volume Oscillator (CKVO)This is a color enhanced version of Klinger Volume Oscillator. I specially designed this to get maximum profit from highly volatile coins. This indicator is based on volume.
xTrigger (the line) shows if trend is bullish or bearish. It is the average of the area. You can clearly see the trend.
xKVO (the area) shows how buy and sell orders change. It rises while buys are increasing against sells, decreases while sells are increasing against buys.
The color or the area provides buy and sell signals. Green: buy. Red: sell. Gray: Undecided.
Of course there are false signals. You should use other indicators to confirm them.
I like to use RSI and Bollinger Bands along with it to eliminate false signals. Also check for double bottom and top, etc.
Its wise to check the general direction of coin using a bigger time frame using Heikin Aishi. For example 1W Heikin Ashi if you are trading on 1D.
In addition to buy signals the most important indication is divergence with the price. Before a trend change 2 kinds of divergences happen
- Trend line moves reverse to the price line
- Are a tops moves revers to the price tops. For example while there is a higher price top, there is a lower area top. Then its time to escape.
Motivation
It is common to suffer from failures while trading highly profitable but volatile coins like NULLS, REP, DLT, LRC, MFT, HOT, OAX, KEY, etc.
- Traders sell too early to ensure a profit. Sell at 10% and it goes 200%
- Traders buy too early. Traders buy and it drops yet another 50%
- Wrong patience. The trader keeps the faith and waits for days for the glorious days. And nothing happens.
I believe with this indicator I am able to solve those problems most of the time.
mcbw_RSI_candlesAn RSI can have any input, but most commonly used is the closing price. I thought it would be interesting to see if feeding the open high low and close information into the RSI to make RSI candles, if there are candlestick formations that can be recognized or possible patters in wicks.
To make it smoother there also is the option to turn the RSI candles into Heiken Ashi form, just check the box labeled HA. The result is an RSI that is easier on the eyes.
Happy trading!
Remember to not take everything too seriously
[RS]Heiken Ashi Cloud V2V2: switched hardcoded timeframes and place were bulls and bears take controll
Regime [CHE] Regime — Minimal HTF MACD histogram regime marker with a simple rising versus falling state.
Summary
Regime is a lightweight overlay that turns a higher-timeframe-style MACD histogram condition into a simple regime marker on your chart. It queries an imported core module to determine whether the histogram is rising and then paints a consistent marker color based on that boolean state. The output is intentionally minimal: no lines, no panels, no extra smoothing visuals, just a repeated marker that reflects the current regime. This makes it useful as a quick context filter for other signals rather than a standalone system.
Motivation: Why this design?
A common problem in discretionary and systematic workflows is clutter and over-interpretation. Many regime tools draw multiple plots, which can distract from price structure. This script reduces the regime idea to one stable question: is the MACD histogram rising under a given preset and smoothing length. The core logic is delegated to a shared module to keep the indicator thin and consistent across scripts that rely on the same definition.
What’s different vs. standard approaches?
Reference baseline: A standard MACD histogram plotted in a separate pane with manual interpretation.
Architecture differences:
Uses a shared library call for the regime decision, rather than re-implementing MACD logic locally.
Uses a single boolean output to drive marker color, rather than plotting histogram bars.
Uses fixed marker placement at the bottom of the chart for consistent visibility.
Practical effect:
You get a persistent “context layer” on price without dedicating a separate pane or reading histogram amplitude. The chart shows state, not magnitude.
How it works (technical)
1. The script imports `chervolino/CoreMACDHTF/2` and calls `core.is_hist_rising()` on each bar.
2. Inputs provide the source series, a preset string for MACD-style parameters, and a smoothing length used by the library function.
3. The library returns a boolean `rising` that represents whether the histogram is rising according to the library’s internal definition.
4. The script maps that boolean to a color: yellow when rising, blue otherwise.
5. A circle marker is plotted on every bar at the bottom of the chart, colored by the current regime state. Only the most recent five hundred bars are displayed to limit visual load.
Notes:
The exact internal calculation details of `core.is_hist_rising()` are not shown in this code. Any higher timeframe mechanics, security usage, or confirmation behavior are determined by the imported library. (Unknown)
Parameter Guide
Source — Selects the price series used by the library call — Default: close — Tips: Use close for consistency; alternate sources may shift regime changes.
Preset — Chooses parameter preset for the library’s MACD-style configuration — Default: 3,10,16 — Trade-offs: Faster presets tend to flip more often; slower presets tend to react later.
Smoothing Length — Controls smoothing used inside the library regime decision — Default: 21 — Bounds: minimum one — Trade-offs: Higher values typically reduce noise but can delay transitions. (Library behavior: Unknown)
Reading & Interpretation
Yellow markers indicate the library considers the histogram to be rising at that bar.
Blue markers indicate the library considers it not rising, which may include falling or flat conditions depending on the library definition. (Unknown)
Because markers repeat on every bar, focus on transitions from one color to the other as regime changes.
This tool is best read as context: it does not express strength, only direction of change as defined by the library.
Practical Workflows & Combinations
Trend following:
Use yellow as a condition to allow long-side entries and blue as a condition to allow short-side entries, then trigger entries with your primary setup such as structure breaks or pullback patterns. (Optional)
Exits and stops:
Consider tightening management after a color transition against your position direction, but do not treat a single flip as an exit signal without price-based confirmation. (Optional)
Multi-asset and multi-timeframe:
Keep `Source` consistent across assets.
Use the slower preset when instruments are noisy, and the faster preset when you need earlier context shifts. The best transferability depends on the imported library’s behavior. (Unknown)
Behavior, Constraints & Performance
Repaint and confirmation:
This script itself uses no forward-looking indexing and no explicit closed-bar gating. It evaluates on every bar update.
Any repaint or confirmation behavior may come from the imported library. If the library uses higher timeframe data, intrabar updates can change the state until the higher timeframe bar closes. (Unknown)
security and HTF:
Not visible here. The library name suggests HTF behavior, but the implementation is not shown. Treat this as potentially higher-timeframe-driven unless you confirm the library source. (Unknown)
Resources:
No loops, no arrays, no heavy objects. The plotting is one marker series with a five hundred bar display window.
Known limits:
This indicator does not convey histogram magnitude, divergence, or volatility context.
A binary regime can flip in choppy phases depending on preset and smoothing.
Sensible Defaults & Quick Tuning
Starting point:
Source: close
Preset: 3,10,16
Smoothing Length: 21
Tuning recipes:
Too many flips: choose the slower preset and increase smoothing length.
Too sluggish: choose the faster preset and reduce smoothing length.
Regime changes feel misaligned with your entries: keep the preset, switch the source back to close, and tune smoothing length in small steps.
What this indicator is—and isn’t
This is a minimal regime visualization and a context filter. It is not a complete trading system, not a risk model, and not a prediction engine. Use it together with price structure, execution rules, and position management. The regime definition depends on the imported library, so validate it against your market and timeframe before relying on it.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
MACD HTF Hardcoded
CoreMACDHTF [CHE]Library "CoreMACDHTF"
calc_macd_htf(src, preset_str, smooth_len)
Parameters:
src (float)
preset_str (simple string)
smooth_len (int)
is_hist_rising(src, preset_str, smooth_len)
Parameters:
src (float)
preset_str (simple string)
smooth_len (int)
hist_rising_01(src, preset_str, smooth_len)
Parameters:
src (float)
preset_str (simple string)
smooth_len (int)
CoreMACDHTF — Hardcoded HTF MACD Presets with Smoothed Histogram Regime Flags
Summary
CoreMACDHTF provides a reusable MACD engine that approximates higher-timeframe behavior by selecting hardcoded EMA lengths based on the current chart timeframe, then optionally smoothing the resulting histogram with a stateful filter. It is published as a Pine v6 library but intentionally includes a minimal demo plot so you can validate behavior directly on a chart. The primary exported outputs are MACD, signal, a smoothed histogram, and the resolved lengths plus a timeframe tag. In addition, it exposes a histogram rising condition so importing scripts can reuse the same regime logic instead of re-implementing it.
Motivation: Why this design?
Classic MACD settings are often tuned to one timeframe. When you apply the same parameters to very different chart intervals, the histogram can become either too noisy or too sluggish. This script addresses that by using a fixed mapping from the chart timeframe into a precomputed set of EMA lengths, aiming for more consistent “tempo” across intervals. A second problem is histogram micro-chop around turning points; the included smoother reduces short-run flips so regime-style conditions can be more stable for alerts and filters.
What’s different vs. standard approaches?
Reference baseline: a standard MACD using fixed fast, slow, and signal lengths on the current chart timeframe.
Architecture differences:
Automatic timeframe bucketing that selects a hardcoded length set for the chosen preset.
Two preset families: one labeled A with lengths three, ten, sixteen; one labeled B with lengths twelve, twenty-six, nine.
A custom, stateful histogram smoother intended to damp noisy transitions.
Library exports that return both signals and metadata, plus a dedicated “histogram rising” boolean.
Practical effect:
The MACD lengths change when the chart timeframe changes, so the oscillator’s responsiveness is not constant across intervals by design.
The rising-flag logic is based on the smoothed histogram, which typically reduces single-bar flip noise compared to using the raw histogram directly.
How it works (technical)
1. The script reads the chart timeframe and converts it into milliseconds using built-in timeframe helpers.
2. It assigns the timeframe into a bucket label, such as an intraday bucket or a daily-and-above bucket, using fixed thresholds.
3. It resolves a hardcoded fast, slow, and signal length triplet based on:
The selected preset family.
The bucket label.
In some cases, the current minute multiplier for finer mapping.
4. It computes fast and slow EMAs on the selected source and subtracts them to obtain MACD, then computes an EMA of MACD for the signal line.
5. The histogram is derived from the difference between MACD and signal, then passed through a custom smoother.
6. The smoother uses persistent internal state to carry forward its intermediate values from bar to bar. This is intentional and means the smoothing output depends on contiguous bar history.
7. The histogram rising flag compares the current smoothed histogram to its prior value. On the first comparable bar it defaults to “rising” to avoid a missing prior reference.
8. Exports:
A function that returns MACD, signal, smoothed histogram, the resolved lengths, and a text tag.
A function that returns the boolean rising state.
A function that returns a numeric one-or-zero series for direct plotting or downstream numeric logic.
HTF note: this is not a true higher-timeframe request. It does not fetch higher-timeframe candles. It approximates HTF feel by selecting different lengths on the current timeframe.
Parameter Guide
Source — Input price series used for EMA calculations — Default close — Trade-offs/Tips
Preset — Selects the hardcoded mapping family — Default preset A — Preset A is more reactive than preset B in typical use
Table Position — Anchor for an information table — Default top right — Present but not wired in the provided code (Unknown/Optional)
Table Size — Text size for the information table — Default normal — Present but not wired in the provided code (Unknown/Optional)
Dark Mode — Theme toggle for the table — Default enabled — Present but not wired in the provided code (Unknown/Optional)
Show Table — Visibility toggle for the table — Default enabled — Present but not wired in the provided code (Unknown/Optional)
Zero dead-band (epsilon) — Intended neutral band around zero for regime classification — Default zero — Present but not used in the provided code (Unknown/Optional)
Acceptance bars (n) — Intended debounce count for regime confirmation — Default three — Present but not used in the provided code (Unknown/Optional)
Smoothing length — Length controlling the histogram smoother’s responsiveness — Default nine — Smaller values react faster but can reintroduce flip noise
Reading & Interpretation
Smoothed histogram: use it as the momentum core. A positive value implies MACD is above signal, a negative value implies the opposite.
Histogram rising flag:
True means the smoothed histogram increased compared to the prior bar.
False means it did not increase compared to the prior bar.
Demo plot:
The included plot outputs one when rising is true and zero otherwise. It is a diagnostic-style signal line, not a scaled oscillator display.
Practical Workflows & Combinations
Trend following:
Use rising as a momentum confirmation filter after structural direction is established by higher highs and higher lows, or lower highs and lower lows.
Combine with a simple trend filter such as a higher-timeframe moving average from your main script (Unknown/Optional).
Exits and risk management:
If you use rising to stay in trends, consider exiting or reducing exposure when rising turns false for multiple consecutive bars rather than reacting to a single flip.
If you build alerts, evaluate on closed bars to avoid intra-bar flicker in live candles.
Multi-asset and multi-timeframe:
Because the mapping is hardcoded, validate on each asset class you trade. Volatility regimes differ and the perceived “equivalence” across timeframes is not guaranteed.
For consistent behavior, keep the smoothing length aligned across assets and adjust only when flip frequency becomes problematic.
Behavior, Constraints & Performance
Repaint and confirmation:
There is no forward-looking indexing. The logic uses current and prior values only.
Live-bar values can change until the bar closes, so rising can flicker intra-bar if you evaluate it in real time.
security and HTF:
No higher-timeframe candle requests are used. Length mapping is internal and deterministic per chart timeframe.
Resources:
No loops and no arrays in the core calculation path.
The smoother maintains persistent state, which is lightweight but means results depend on uninterrupted history.
Known limits:
Length mappings are fixed. If your chart timeframe is unusual, the bucket choice may not represent what you expect.
Several table and regime-related inputs are declared but not used in the provided code (Unknown/Optional).
The smoother is stateful; resetting chart history or changing symbol can alter early bars until state settles.
Sensible Defaults & Quick Tuning
S tarting point:
Preset A
Smoothing length nine
Source close
Tuning recipes:
Too many flips: increase smoothing length and evaluate rising only on closed bars.
Too sluggish: reduce smoothing length, but expect more short-run reversals.
Different timeframe feel after switching intervals: keep preset fixed and adjust smoothing length first before changing preset.
Want a clean plot signal: use the exported numeric rising series and apply your own display rules in the importing script.
What this indicator is—and isn’t
This is a momentum and regime utility layer built around a MACD-style backbone with hardcoded timeframe-dependent parameters and an optional smoother. It is not a complete trading system, not a risk model, and not predictive. Use it in context with market structure, execution rules, and risk controls.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
Cumulative Volume Delta CandlesCVD Trend Candles
Visualize buying and selling pressure directly on your price candles. This indicator colors your candlesticks based on Cumulative Volume Delta (CVD), helping you see the underlying order flow driving price action.
WHAT IS CVD?
Cumulative Volume Delta estimates the difference between aggressive buying and selling volume on each bar. Positive delta indicates more aggressive buying; negative delta indicates more aggressive selling.
COLOR METHODS
▸ CVD Raw
The simplest view—candles are colored based purely on the raw delta of each bar.
• Cyan = Positive delta (net buying)
• Red = Negative delta (net selling)
▸ Rule-Based (Default)
Uses Heikin Ashi-smoothed CVD candles with intensity based on trend strength:
• Bright colors = Strong conviction (larger body + continuation)
• Medium colors = Moderate conviction (continuation)
• Dark colors = Weak/indecision (inside candles, hesitation)
▸ Size-Based
Colors intensity based on z-score of delta changes:
• Bright colors = Statistically significant delta (above strong threshold)
• Medium colors = Moderate delta (above moderate threshold)
• Dark colors = Normal/quiet delta
KEY FEATURES
◆ Kalman Filter Smoothing
Adaptive filtering reduces noise while staying responsive to genuine shifts in order flow. Adjust sensitivity with the Responsiveness and Kalman Gain settings.
◆ Inside Candle Rule
When enabled, prevents false signals from inside candles that show a direction change but lack conviction. The candle retains the previous trend's color (dimmed) instead of flipping.
◆ Session Anchoring
Optionally reset cumulative delta at a specific time (e.g., market open) for intraday analysis.
◆ Z-Score Thresholds
Fine-tune what constitutes "strong" vs "moderate" delta activity for Size-Based coloring.
HOW TO USE
1. Add the indicator to your chart
2. Set your chart type to "Line" or bring the indicator to front via Visual Order → Bring to Front
3. Select your preferred Color Method
4. Look for:
• Sequences of bright cyan candles → Strong buying pressure / bullish momentum
• Sequences of bright red candles → Strong selling pressure / bearish momentum
• Fading colors → Weakening conviction, potential reversal or consolidation
• Color flips → Shift in order flow dominance
Notes
• This indicator estimates delta from OHLCV data. For true order flow analysis, consider using tick or trade data from your broker/exchange.
• Works on all timeframes and instruments with volume data.
• Best used in conjunction with support/resistance levels, market structure, or other confluence factors.
CoreTFRSIMD CoreTFRSIMD library — Reusable TFRSI core for consistent momentum inputs across scripts
The library provides a reusable exported function such as calcTfrsi(src, len, signalLen) so you can compute TFRSI in your own indicators or strategies, e.g. tfrsi = CoreTFRSIMD.calcTfrsi(close, 6, 2)
Summary
CoreTFRSIMD is a Pine Script v6 library that implements a TFRSI-style oscillator core and exposes it as a reusable exported function. It is designed for authors who want the same TFRSI calculation across multiple indicators or strategies without duplicating logic. The library includes a simple demo plot and band styling so you can visually sanity-check the output. No higher-timeframe sampling is used, and there are no loops or arrays, so runtime cost is minimal for typical chart usage.
Motivation: Why this design?
When you reuse an oscillator across different tools, small implementation differences create inconsistent signals and hard-to-debug results. This library isolates the signal path into one exported function so that every dependent script consumes the exact same oscillator output. The design combines filtering, normalization, and a final smoothing pass to produce a stable, RSI-like readout intended for momentum and regime context.
What’s different vs. standard approaches?
Baseline: Traditional RSI computed directly from gains and losses with standard smoothing.
Architecture differences:
A high-pass stage to attenuate slower components before the main smoothing.
A multi-pole smoothing stage implemented with persistent state to reduce noise.
A running peak-tracker style normalization that adapts to changing signal amplitude.
A final signal smoothing layer using a simple moving average.
Practical effect:
The oscillator output tends to be less dominated by raw volatility spikes and more consistent across changing conditions.
The normalization step helps keep the output in an RSI-like reading space without relying on fixed scaling.
How it works (technical)
1. Input source: The exported function accepts a source series and two integer parameters controlling responsiveness and final smoothing.
2. High-pass stage: A recursive filter is applied to the source to emphasize shorter-term movement. This stage uses persistent storage so it can reference prior internal states across bars.
3. Smoothing stage: The filtered stream is passed through a SuperSmoother-like recursive smoother derived from the chosen length. This again uses persistent state and prior values for continuity.
4. Adaptive normalization: The absolute magnitude of the smoothed stream is compared to a slowly decaying reference level. If the current magnitude exceeds the reference, the reference is updated. This acts like a “peak hold with decay” so the oscillator scales relative to recent conditions.
5. Oscillator mapping: The normalized value is mapped into an RSI-like reading range.
6. Signal smoothing: A simple moving average is applied over the requested signal length to reduce bar-to-bar chatter.
7. Demo rendering: The library script plots the oscillator, draws horizontal guide levels, and applies background plus gradient fills for overbought and oversold regions.
Parameter Guide
Parameter — Effect — Default — Trade-offs/Tips
src — Input series used by the oscillator — close in demo — Use close for general momentum, or a derived series if you want to emphasize a specific behavior.
len — Controls the responsiveness of internal filtering and smoothing — six in demo — Smaller values react faster but can increase short-term noise; larger values smooth more but can lag turns.
signalLen — Controls the final smoothing of the mapped oscillator — two in demo — Smaller values preserve detail but can flicker; larger values reduce flicker but can delay transitions.
Reading & Interpretation
The plot is an oscillator intended to be read similarly to an RSI-style momentum gauge.
The demo includes three reference levels: upper at one hundred, mid at fifty, and lower at zero.
The fills visually emphasize zones above the midline and below the midline. Treat these as context, not as standalone entries.
If the oscillator appears unusually compressed or unusually jumpy, the normalization reference may be adapting to an abrupt change in amplitude. That is expected behavior for adaptive normalization.
Practical Workflows & Combinations
Trend following:
Use structure first, then confirm with oscillator behavior around the midline.
Prefer signals aligned with higher-high higher-low or lower-low lower-high context from price.
Exits/Stops:
Use oscillator loss of momentum as a caution flag rather than an automatic exit trigger.
In strong trends, consider keeping risk rules price-based and use the oscillator mainly to avoid adding into exhaustion.
Multi-asset/Multi-timeframe:
Start with the demo defaults when you want a responsive oscillator.
If an asset is noisier, increase the main length or the signal smoothing length to reduce false flips.
Behavior, Constraints & Performance
Repaint/confirmation: No higher-timeframe sampling is used. Output updates on the live bar like any normal series. There is no explicit closed-bar gating in the library.
security or HTF: Not used, so there is no HTF synchronization risk.
Resources: No loops, no arrays, no large history buffers. Persistent variables are used for filter state.
Known limits: Like any filtered oscillator, sharp gaps and extreme one-bar events can produce transient distortions. The adaptive normalization can also make early bars unstable until enough history has accumulated.
Sensible Defaults & Quick Tuning
Starting values: length six, signal smoothing two.
Too many flips: Increase signal smoothing length, or increase the main length.
Too sluggish: Reduce the main length, or reduce signal smoothing length.
Choppy around midline: Increase signal smoothing length slightly and rely more on price structure filters.
What this indicator is—and isn’t
This library is a reusable signal component and visualization aid. It is not a complete trading system, not predictive, and not a substitute for market structure, execution rules, and risk controls. Use it as a momentum and regime context layer, and validate behavior per asset and timeframe before relying on it.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
Trend TraderMost trend indicators don’t offer continuation signals or accurate bounce points, so I created this indicator that uses one of the most common trading levels (EMAs). This indicator uses the 50, 100, and 200 EMAs along with WaveTrend signals to trade trends. Buy Signals are filtered so that they only show up when the 100 EMA is above the 200. And Inverse for Sell Signals.
This indicator works well with both Stocks and Crypto. Default settings work best on 15 min, 1H, 2H, and 4H.
(Chart examples are using Heikin Ashi Candles, on Log Scale.)
*Buy and Sell Signals do not repaint.
Settings:
- Ability to show all buy and sell signals regardless of trend.
- To change the sensitivity of the buy and sell signals, change the “Average Length”
- (The lower the number the more sensitive, the higher the number the less they pop up)
- Ability to change EMA Lengths
imgur.com
Naveen Prabhu with EMA//@version=6
indicator('Naveen Prabhu with EMA', overlay = true, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
a = input(2, title = 'Key Vaule. \'This changes the sensitivity\'')
c = input(5, title = 'ATR Period')
h = input(false, title = 'Signals from Heikin Ashi Candles')
BULLISH_LEG = 1
BEARISH_LEG = 0
BULLISH = +1
BEARISH = -1
GREEN = #089981
RED = #F23645
BLUE = #2157f3
GRAY = #878b94
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b
HISTORICAL = 'Historical'
PRESENT = 'Present'
COLORED = 'Colored'
MONOCHROME = 'Monochrome'
ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'
TINY = size.tiny
SMALL = size.small
NORMAL = size.normal
ATR = 'Atr'
RANGE = 'Cumulative Mean Range'
CLOSE = 'Close'
HIGHLOW = 'High/Low'
SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'
SMART_GROUP = 'Smart Money Concepts'
INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'
modeTooltip = 'Allows to display historical Structure or only the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart'
modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = )
styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = )
showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip)
showInternalsInput = input( false, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = )
internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = )
internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = )
showStructureInput = input( false, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = )
swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = )
swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = )
showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( false, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)
showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob')
internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( true, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = )
internalBullishOrderBlockColor = input.color(color.new(GREEN, 80), 'Internal Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#f77c80, 80), 'Internal Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(GREEN, 80), 'Bullish OB', group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#b22833, 80), 'Bearish OB', group = BLOCKS_GROUP)
showEqualHighsLowsInput = input( false, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = )
showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = )
dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = )
weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = )
monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly')
showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP)
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox
type trend
int bias
type equalDisplay
line l_ine = na
label l_abel = na
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
type orderBlock
float barHigh
float barLow
int barTime
int bias
// @variable current swing pivot high
var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array fairValueGaps = array.new()
// @variable storage for parsed highs
var array parsedHighs = array.new()
// @variable storage for parsed lows
var array parsedLows = array.new()
// @variable storage for raw highs
var array highs = array.new()
// @variable storage for raw lows
var array lows = array.new()
// @variable storage for bar time values
var array times = array.new()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing order blocks)
var array swingOrderBlocks = array.new()
// @variable storage for orderBlock UDTs (internal order blocks)
var array internalOrderBlocks = array.new()
// @variable storage for swing order blocks boxes
var array swingOrderBlocksBoxes = array.new()
// @variable storage for internal order blocks boxes
var array internalOrderBlocksBoxes = array.new()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time
// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
// @variable source to use in bearish order blocks mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high
// @variable source to use in bullish order blocks mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)
leg(int size) =>
var leg = 0
newLegHigh = high > ta.highest( size)
newLegLow = low < ta.lowest( size)
if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg
startOfNewLeg(int leg) => ta.change(leg) != 0
startOfBearishLeg(int leg) => ta.change(leg) == -1
startOfBullishLeg(int leg) => ta.change(leg) == +1
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) =>
var label l_abel = na
if modeInput == PRESENT
l_abel.delete()
l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small)
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay
string tag = 'EQL'
color equalColor = swingBullishColor
string labelStyle = label.style_label_up
if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down
if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)
e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput)
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)
if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow
if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low , size, false)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh
if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high ,size,true)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)
if modeInput == PRESENT
l_ine.delete()
l_abel.delete()
l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle)
l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize)
deleteOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
for in orderBlocks
bool crossedOderBlock = false
if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput)
array a_rray = na
int parsedIndex = na
if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())
orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias)
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
if orderBlocks.size() >= 100
orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)
drawOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
orderBlocksSize = orderBlocks.size()
if orderBlocksSize > 0
maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize))
array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes
for in parsedOrdeBlocks
orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor)
box b_ox = b_oxes.get(index)
b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow))
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true
if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)
pivot p_ivot = internal ? internalHigh : swingHigh
trend t_rend = internal ? internalTrend : swingTrend
lineStyle = internal ? line.style_dashed : line.style_solid
labelSize = internal ? internalStructureSize : swingStructureSize
extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput
if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS
if internal
currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BULLISH
displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)
p_ivot := internal ? internalLow : swingLow
extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput
if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS
if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BEARISH
displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor)
deleteFairValueGaps() =>
for in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)
// @function draw fair value gaps
// @returns fairValueGap ID
drawFairValueGaps() =>
= request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on)
barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)
newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0
bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe
if bullishFairValueGap
currentAlerts.bullishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor)))
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
= request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on)
float parsedTop = sameTimeframe ? high : topLevel
float parsedBottom = sameTimeframe ? low : bottomLevel
int parsedLeftTime = sameTimeframe ? time : leftTime
int parsedRightTime = sameTimeframe ? time : rightTime
int parsedTopTime = time
int parsedBottomTime = time
if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex = times.binary_search_rightmost(parsedRightTime)
array timeArray = times.slice(leftIndex,rightIndex)
array topArray = highs.slice(leftIndex,rightIndex)
array bottomArray = lows.slice(leftIndex,rightIndex)
parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime
var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny)
rightTimeBar = last_bar_time + 20 * (time - time )
topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High')
bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low')
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)
b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))
l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))
// @function draw premium/discount zones
// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down)
equilibriumLevel = math.avg(trailing.top, trailing.bottom)
drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left)
drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up)
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor)
if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()
if showHighLowSwingsInput
drawHighLowSwings()
if showPremiumDiscountZonesInput
drawPremiumDiscountZones()
if showFairValueGapsInput
deleteFairValueGaps()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showInternalOrderBlocksInput or showTrendInput
displayStructure(true)
if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput
displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)
if showSwingOrderBlocksInput
deleteOrderBlocks()
if showFairValueGapsInput
drawFairValueGaps()
if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)
if showSwingOrderBlocksInput
drawOrderBlocks()
lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex
if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)
if showDailyLevelsInput and not higherTimeframe('D')
drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)
if showWeeklyLevelsInput and not higherTimeframe('W')
drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)
if showMonthlyLevelsInput and not higherTimeframe('M')
drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)
xATR = ta.atr(c)
nLoss = a * xATR
src = h ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close, lookahead = barmerge.lookahead_off) : close
xATRTrailingStop = 0.0
iff_1 = src > nz(xATRTrailingStop , 0) ? src - nLoss : src + nLoss
iff_2 = src < nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? math.min(nz(xATRTrailingStop ), src + nLoss) : iff_1
xATRTrailingStop := src > nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? math.max(nz(xATRTrailingStop ), src - nLoss) : iff_2
pos = 0
iff_3 = src > nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? -1 : nz(pos , 0)
pos := src < nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? 1 : iff_3
xcolor = pos == -1 ? color.red : pos == 1 ? color.green : color.blue
ema = ta.ema(src, 1)
above = ta.crossover(ema, xATRTrailingStop)
below = ta.crossover(xATRTrailingStop, ema)
buy = src > xATRTrailingStop and above
sell = src < xATRTrailingStop and below
barbuy = src > xATRTrailingStop
barsell = src < xATRTrailingStop
//---------------------------------------------------------------------------------------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed')
alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed')
alertcondition(buy, 'UT Long', 'UT Long')
alertcondition(sell, 'UT Short', 'UT Short')
plotshape(buy, title = 'Buy', text = 'Buy', style = shape.labelup, location = location.belowbar, color = color.new(color.green, 0), textcolor = color.new(color.white, 0), size = size.tiny)
plotshape(sell, title = 'Sell', text = 'Sell', style = shape.labeldown, location = location.abovebar, color = color.new(color.red, 0), textcolor = color.new(color.white, 0), size = size.tiny)
//--------------------------------------------------------------------------------------
// EMA ADDITIONS (Editable)
//--------------------------------------------------------------------------------------
ema5Len = input.int(5, "5 EMA Length", minval = 1)
ema9Len = input.int(9, "9 EMA Length", minval = 1)
ema5 = ta.ema(src, ema5Len)
ema9 = ta.ema(src, ema9Len)
plot(ema5, "EMA 5", color = color.red, linewidth = 2)
plot(ema9, "EMA 9", color = color.blue, linewidth = 2)
barcolor(barbuy ? color.green : na)
barcolor(barsell ? color.red : na)
RSI Ensemble Confidence [CHE]RSI Ensemble Confidence — Measures RSI agreement across multiple lengths and price sources
Summary
This indicator does not just show you one RSI — it shows you how strongly dozens of different RSI variants agree with each other right now.
The Confidence line (0–100) is the core idea:
- High Confidence → almost all RSIs see the same thing → clean, reliable situation
- Low Confidence → the RSIs contradict each other → the market is messy, RSI signals are questionable
How it works (exactly as you wanted it described)
1. Multiple RSIs instead of just one
The indicator builds a true ensemble:
- 4 lengths (default 8, 14, 21, 34)
- 6 price sources (Close, Open, High, Low, HL2, OHLC4 – individually switchable)
→ When everything is enabled, up to 24 different RSIs are calculated on every single bar.
These 24 opinions form a real “vote” about the current market state.
2. Mean and dispersion
From all active RSIs it calculates:
- rsiMean → the average opinion of the entire ensemble (orange line)
- rsiStd → how far the individual RSIs deviate from each other
Small rsiStd = they all lie close together → strong agreement
Large rsiStd = they are all over the place → contradiction
3. Confidence (0–100)
The standard deviation is compared to the user parameter “Max expected StdDev” (default 20):
- rsiStd = 0 → Confidence ≈ 100
- rsiStd = maxStd → Confidence ≈ 0
- Everything in between is scaled linearly
If only one RSI is active, Confidence is automatically set to ~80 for practicality.
What you see on the chart
1. Classic reference RSI – blue line (Close, length 14) → your familiar benchmark
2. Ensemble mean – orange line → the true consensus RSI
±1 StdDev band (optional) → shows dispersion directly:
- narrow band = clean, consistent setup
- wide band = the RSIs disagree → caution
3. Confidence line (aqua, 0–100) → your quality meter for any RSI signal
4. StdDev histogram (optional, fuchsia columns) → raw dispersion if you prefer the unscaled value
5. Background coloring
- Greenish ≥ 80 → high agreement
- Orange 60–80 → medium
- Reddish < 40 → strong disagreement
- Transparent below that
6. Two built-in alerts
- High Confidence (crossover 80)
- Low Confidence (crossunder 40)
Why this indicator is practically useful
1. Perfect filter for all RSI strategies
Only trade overbought/oversold, divergences, or failures when Confidence ≥ 70. Skip or reduce size when Confidence < 40.
2. Protection against overinterpretation
You immediately see whether a “beautiful” RSI hook is confirmed by the other 23 variants — or whether it’s just one outlier fooling you.
3. Excellent regime detector
Long periods of high Confidence = clean trends or clear overbought/oversold phases
Constantly low Confidence = choppy, noisy market → RSI becomes almost useless
4. Turns gut feeling into numbers
We all sometimes think “this setup somehow doesn’t feel right”. Now you have the exact number that says why.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
AdjCloseLibLibrary "AdjCloseLib"
Library for producing gap-adjusted price series that removes intraday gaps at market open
get_adj_close(_gapThresholdPct)
Calculates gap-adjusted close price by detecting and removing gaps at market open (09:15)
Parameters:
_gapThresholdPct (float) : Minimum gap size (in percentage) required to trigger adjustment. Example: 0.5 for 0.5%
Returns: Adjusted close price for the current bar (always returns a numeric value, never na)
@details Detects gaps by comparing 09:15 open with previous day's close. If gap exceeds threshold,
subtracts the gap value from all bars between 09:15-15:29 inclusive. State resets after session close.
get_adj_ohlc(_gapThresholdPct)
Calculates gap-adjusted OHLC values by subtracting detected gap from all price components
Parameters:
_gapThresholdPct (float) : Minimum gap size (in percentage) required to trigger adjustment. Example: 0.5 for 0.5%
Returns: Tuple of
@details Useful for calculating indicators (ATR, Heikin-Ashi, etc.) on gap-adjusted data.
Applies the same gap adjustment logic to all OHLC components simultaneously.
Fractional Candlestick Long Only Experimental V10Fractional Candlestick Long-Only Strategy – Technical Description
This document provides a professional English description of the "Fractional Candlestick Long Only Experimental V6" strategy using pure CF/AB fractional kernels and wavelet-based filtering.
1. Fractional Candlesticks (CF / AB)
The strategy computes two fractional representations of price using Caputo–Fabrizio (CF) and Atangana–Baleanu (AB) kernels. These provide long-memory filtering without EMA approximations. Both CF and AB versions are applied to O/H/L/C, producing fractional candlesticks and fractional Heikin-Ashi variants.
2. Trend Stack Logic
Trend confirmation is based on a 4-component stack:
- CF close > AB close
- HA_CF close > HA_AB close
- HA_CF bullish
- HA_AB bullish
The user selects how many components must align (4, 3, or any 2).
3. Wavelet Filtering
A wavelet transform (Haar, Daubechies-4, Mexican Hat) is applied to a chosen source (e.g., HA_CF close). The wavelet response is used as:
- entry filter (4 modes)
- exit filter (4 modes)
Wavelet modes: off, confirm, wavelet-only, block adverse signals.
4. Trailing System
Trailing stop uses fractional AB low × buffer, providing long-memory dynamic trailing behavior. A fractional trend channel (CF/AB lows vs HA highs) is also plotted.
5. Exit Framework
Exit options include: stack flip, CF
Easy [CHE] Easy — Minimalist Pine Script for detecting EMA direction changes to define fixed price zones for simple support and resistance visualization, ideal for manual trading workflows.
Summary
This indicator's programming is kept minimalist and super simple, with core logic in under 20 lines for easy comprehension and modification. It creates fixed price zones based on divergences between a base exponential moving average and its smoother counterpart, helping traders spot potential consolidation or reversal areas without dynamic adjustments. By locking the zone at the high and low of the signal bar, it avoids over-expansion in volatile conditions, offering a stable reference line colored by price position relative to the zone. This approach differs from expanding channels by prioritizing simplicity and persistence until a new qualifying signal, reducing visual clutter while highlighting directional bias through midpoint coloring.
Motivation: Why this design?
Traders often face noisy signals from moving averages that flip frequently in sideways markets or lag during breakouts, leading to premature entries or missed opportunities. This indicator addresses that by focusing on confirmed direction shifts between the base and smoothed averages, then anchoring a non-expanding zone to capture the initial price range of the shift. The result is a cleaner tool for marking equilibrium levels, assuming price respects these bounds in ranging or mildly trending conditions.
What’s different vs. standard approaches?
- Reference baseline: Traditional moving average crossovers or simple channels that update every bar.
- Architecture differences:
- Zones are set only on new divergence signals and remain fixed until reset by a gap from the prior zone.
- No ongoing high-low expansion; relies on persistent variables to hold bounds across bars.
- Midpoint plotting with conditional coloring based on close position, plus a highlight for zone initiations.
- Practical effect: Charts show persistent horizontal references instead of drifting lines, making it easier to gauge if price is rejecting or embracing the zone—useful for avoiding false breaks in low-volatility setups.
How it works (technical)
The indicator first computes a base exponential moving average of closing prices over a user-defined length, then applies a second exponential moving average to smooth that base. It checks if both the base and smoothed values are increasing or decreasing compared to their prior values, indicating aligned direction. A signal triggers when this alignment breaks, marking a potential shift.
On a new signal, if the current bar's high and low fall outside any existing zone (or none exists), the zone bounds update to those extremes and persist via dedicated variables. The midpoint of these bounds becomes the primary plot line, colored green if below the close (bullish lean), red if above (bearish lean), or gray otherwise. A secondary thick line highlights the midpoint briefly when a zone first sets, aiding visual confirmation. No higher timeframe data or external fetches are used, so updates occur on each bar close without lookahead.
Parameter Guide
EMA Length — Sets the period for the base moving average; longer values smooth more, reducing signal frequency but increasing lag. Default: 50. Trade-offs/Tips: Shorter for faster response in intraday charts (risks noise); longer for daily trends (may miss early shifts).
Smoother Length — Defines the period for the secondary smoothing on the base average; higher values dampen minor wiggles for stabler direction checks. Default: 3. Trade-offs/Tips: Keep low (2–5) for sensitivity; increase to 7+ if zones trigger too often in choppy markets, at cost of delayed signals.
Reading & Interpretation
The main circle plot at the zone midpoint serves as a dynamic equilibrium line: green suggests price is above the zone (potential strength), red indicates below (potential weakness), and gray shows containment within bounds (neutral consolidation). A sudden thick foreground line at the midpoint flags a fresh zone start, prompting review of the prior bar's context. Absence of a plot means no active zone, implying reliance on price action alone until the next signal.
Practical Workflows & Combinations
- Trend following: Enter long on green midpoint after a higher low touches the zone lower bound, confirmed by structure like higher highs; filter shorts similarly on red with lower highs.
- Exits/Stops: Use the opposite zone bound as a conservative stop (e.g., below lower for longs); trail aggressively to midpoint on strong moves, tightening near gray neutrality.
- Multi-asset/Multi-TF: Defaults work across forex and stocks on 1H–Daily; for crypto volatility, shorten EMA Length to 20–30. Pair with volume oscillators for confirmation, avoiding isolated use.
Behavior, Constraints & Performance
- Repaint/confirmation: Plots update on bar close using historical closes, so confirmed signals hold; live bars may shift until close but without future references.
- security()/HTF: Not used, eliminating related repaint risks.
- Resources: Minimal overhead—no loops, arrays, or bar limits exceeded; suitable for real-time on any timeframe.
- Known limits: Fixed zones may lag in strong trends (price drifts away without reset); signals skip if no gap from prior zone, potentially missing clustered shifts. Assumes standard OHLC data; untested on non-equity assets.
Sensible Defaults & Quick Tuning
Start with EMA Length at 50 and Smoother Length at 3 for balanced daily charts. If signals fire too frequently (e.g., in ranges), extend EMA Length to 100 for fewer but stabler zones. For sluggish response in trends, drop Smoother Length to 2 and EMA Length to 30, monitoring for added noise. In high-vol setups, widen both to 75/5 to filter extremes, trading speed for reliability.
What this indicator is—and isn’t
This is a lightweight visualization layer for EMA-driven zones, aiding manual chart reading and basic signal spotting. It is not a standalone system, predictive model, or automated alert generator—integrate with broader analysis like market structure and risk rules. (Unknown/Optional: No built-in alerts or multi-timeframe scaling.)
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
VWAP – Pivot Pairs (SECONDS‑BASED RESET)VWAP – Pivot Pairs (SECONDS-BASED RESET) is a Pine Script v6 indicator for TradingView that combines pivot-based breakout detection with resettable VWAP (Volume Weighted Average Price) calculations over user-defined rolling time periods in seconds.It identifies high and low swing pivots via breakout logic, then calculates two VWAP lines per anchor:One using high/low as the price source,
One using close as the price source.
These form "pivot pairs" that reset automatically at the start of each custom-duration period (e.g., every 300 seconds), starting from a user-defined UTC time of day (default: 09:30 UTC).Visuals include:Colored VWAP lines (high pair: red, low pair: green),
Semi-transparent fill zones between each pair,
Optional toggles to show/hide high or low pairs.
Use CasesUse Case
Description
Intraday Scalping (1–15 min charts)
Use 60–300 second resets to capture micro-trends within larger sessions. VWAP pairs act as dynamic support/resistance after breakouts.
High-Frequency / Algo Validation
Backtest strategies on tick/second charts where traditional session resets fail. Align resets with exchange micro-sessions or volatility windows.
Opening Range Breakout (ORB) Enhancement
Set period_seconds = 1800 (30 min) and start time = 09:30 UTC → VWAP builds only on first 30 mins post-open, then floats. Pairs show deviation from ORB mean.
Range-Bound Market Analysis
In choppy markets, VWAP pairs converge near fair value. Divergence signals potential breakout. Fill color intensity shows conviction.
Multi-Timeframe Confluence
Overlay on 1-second chart with 300s reset → matches 5-minute structure. Use close-based VWAP for entries, high/low-based for stops.
Key Features SummaryFeature
Function
period_seconds
Rolling window length in seconds (e.g., 300 = 5 min)
period_start_time
UTC time-of-day anchor (default: 09:30)
new_period logic
Triggers full reset of pivots + VWAP on exact second boundary
breakingHigher / breakingLower
Detects confirmed breakouts (not just close above high)
Dual VWAP per anchor
ta.vwap(high) and ta.vwap(close) for range-aware mean
Fill zones
Visual value area between high/close VWAPs
Toggle visibility
Independently show/hide high or low pivot pairs
How It Works – Step-by-StepTime Engine Converts user inputs → milliseconds
Calculates current period start time using integer division from epoch
Detects exact bar when new period begins (new_period = true)
On New Period Resets both high/low anchors to current bar’s h and l
Forces VWAP recalculation from this bar forward
Breakout Detection Only triggers on strong candles (rising/falling, non-doji)
Requires open/close beyond prior pivot → avoids wicks-only breaks
VWAP Accumulation ta.vwap(source, reset_condition) restarts when anchor resets
Two sources per side → shows where volume clustered (at highs vs closes)
Plotting Four lines + two fills
Clean, customizable, overlay-friendly
Pro TipsUse on Heikin Ashi for smoother breakout signals.
Combine with volume profile to validate VWAP clusters.
For crypto, set period_start_time = 0 (00:00 UTC) for clean 4-hour resets.
Add alerts on new_period or breakingHigher for automation.
In short: This is a precision VWAP tool for time-boxed, pivot-driven mean reversion and breakout trading, ideal for scalpers, day traders, and algo developers needing sub-session granularity.
TopBot [CHE] TopBot — Structure pivots with buffered acceptance and gradient trend visualization
Summary
TopBot detects swing structure from confirmed pivot highs and lows, derives support and resistance levels, and switches trend only after a buffered and accepted break. It renders labels for recent structure points, maintains dynamic support and resistance lines that freeze on contact, and colors candles using a gradient that reflects consecutive trend persistence. The gradient communicates strength without extra panels, while the buffered acceptance reduces fragile flips around key levels. Everything runs in the main chart for immediate context.
Motivation: Why this design?
Classical swing tools often flip on single-bar spikes and produce lines that extend forever without acknowledging when price invalidates them. This script addresses that by requiring a user-controlled buffer and a run of consecutive closes before changing trend, while also freezing lines once price interacts with them. The gradient color layer communicates regime persistence so users can quickly judge whether a move is maturing or just starting.
What’s different vs. standard approaches?
Baseline reference: Simple pivot labeling and unbuffered break-of-structure tools.
Architecture differences:
Buffered level testing using ticks, percent, or ATR.
Acceptance logic that requires multiple consecutive closes.
Synchronized structure labeling with a single Top and Bottom within the active set.
Progressive support and resistance management that freezes lines on first contact.
Gradient candle and wick coloring driven by consecutive trend counts with windowed normalization and gamma control.
Practical effect: Fewer whipsaw flips, clearer status of active levels, and visual feedback about trend persistence without a secondary pane.
How it works (technical)
The script confirms swing points using left and right bar pivots, then forms a current structure window to classify each pivot as higher high, lower high, higher low, or lower low. Recent labels are trimmed to a user cap, and a postprocess step ensures one highest and one lowest label while preserving side information for the others. Support updates on higher low events, resistance on lower high events. Trend flips only after the close has moved beyond the active level by a chosen buffer and this condition holds for a chosen number of consecutive bars. Lines for new levels extend to the right and freeze once price touches them. A running count of consecutive trend bars produces a strength score, which is normalized over a rolling window, shaped by gamma, and mapped to user-defined dark and neon colors for both up and down regimes. Wick coloring uses `plotcandle`; fallback bar coloring uses `barcolor`. No higher-timeframe data is requested. Signals confirm only after the right-bar lookback of the pivot function.
Parameter Guide
Left Bars / Right Bars (default five each): Pivot sensitivity. Larger values confirm later and reduce noise; smaller values respond faster with more noise.
Draw S/R Lines (default true): Enables support and resistance line creation and updates.
Support / Resistance Colors (lime, red): Line colors for each side.
Line Style (Solid, Dashed, Dotted; default Dotted) and Width (default three): Visual style of S/R lines.
Max Labels & Lines (default ten): Cap for objects to control clutter and resource usage.
Change Bar Color (default true), Up/Down colors (blue, black): Fallback bar coloring when gradients or wick coloring are disabled.
Show Neutral Candles (default false): Optional coloring when no trend is active.
Enable Gradient Bar Colors (default true): Turns on gradient body coloring from the strength score.
Enable Wick Coloring (default true): Colors wicks and borders using `plotcandle`.
Collection Period (default one hundred): Rolling window used to scale the strength score. Shorter windows react faster but vary more.
Gamma Bars / Gamma Plots (defaults zero point seven and zero point eight): Shapes perceived contrast of bar and wick gradients. Lower values brighten early; higher values compress until stronger runs appear.
Gradient Transparency / Wick Transparency (default zero): Visual transparency for bodies and wicks.
Up/Down Trend Dark and Neon Colors: Endpoints for gradient mapping in each regime.
Acceptance closes (n) (default two): Number of consecutive closes beyond a level required before trend flips. Larger values reduce false breaks but react later.
Break buffer (None, Ticks, Percent, ATR; default ATR) and Value (default zero point five) and ATR Len (default fourteen): Defines the safety margin beyond the level. ATR mode adapts to volatility; Percent and Ticks are static.
Reading & Interpretation
Labels: “Top” and “Bottom” mark the most extreme points in the active set; “LT” and “HB” indicate side labels for lower top and higher bottom.
Lines: New support or resistance is drawn when structure confirms. A line freezes once price touches it, signaling that the dynamic phase ended.
Trend: Internal state switches to up or down only after buffered acceptance.
Colors: Brighter neon tones indicate stronger and more persistent runs; darker tones suggest early or weakening runs. When gradients are off, fallback bar colors indicate trend sign.
Practical Workflows & Combinations
Trend following: Wait for a buffered and accepted break through the most recent level, then use gradient intensity to stage entries or scale-ins.
Structure-first filtering: Trade only in the direction of the last accepted trend while price remains above support or below resistance.
Exits and stops: Consider exiting on loss of gradient intensity combined with a return through the most recent structure level.
Multi-asset / Multi-timeframe: Works on liquid symbols across common timeframes. Use larger pivot bars and higher acceptance on lower timeframes. No built-in higher-timeframe aggregation is used.
Behavior, Constraints & Performance
Repaint/confirmation: Pivot confirmation waits for the right bar window; trend acceptance is based on closes and can change during a live bar. Final signals stabilize on bar close.
security/HTF: Not used. No cross-timeframe data.
Resources: Arrays and loops are used for labels, lines, and structure search up to a capped historical span. Object counts are clamped by user input and platform limits.
Known limits: Delayed confirmation at sharp turns due to pivot windows; rapid gaps can jump over buffers; gradient scaling depends on the chosen collection period.
Sensible Defaults & Quick Tuning
Start with the defaults: pivot windows at five, ATR buffer with value near one half, acceptance at two, collection period near one hundred, gamma near zero point seven to zero point eight.
Too many flips: increase acceptance, increase buffer value, or increase pivot windows.
Too sluggish: reduce acceptance, reduce buffer value, or reduce pivot windows.
Colors too flat: lower gamma or shorten the collection period.
Visual clutter: reduce the max labels and lines cap or disable wicks.
What this indicator is—and isn’t
This is a visualization and signal layer that encodes swing structure, level state, and regime persistence. It is not a complete trading system, not predictive, and does not manage orders. Use it with broader context such as higher timeframe structure, session behavior, and defined risk controls.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
Acknowledgment
Thanks to LonesomeTheBlue for the fantastic and inspiring "Higher High Lower Low Strategy" .
Original script:
Credit for the original concept and implementation goes to the author; any adaptations or errors here are mine.
Smart VWAP FVG SystemSmart VWAP FVG System - Professional Multi-Filter Trading Indicator
📊 OVERVIEW
The Smart VWAP FVG System is an advanced multi-layered trading indicator that combines institutional volume analysis, multi-timeframe VWAP trend confirmation, and Fair Value Gap detection to identify high-probability trade entries. This indicator uses a sophisticated filtering mechanism where signals appear only when multiple independent confirmation criteria align simultaneously.
Recommended Timeframe: 5-minute (M5) or higher. The indicator works best on M5, M15, and M30 charts for intraday trading.
🎯 ORIGINALITY & PURPOSE
This indicator is original because it combines three distinct analytical methods into a unified decision-making system:
Market Profile Volume Analysis - Identifies institutional accumulation/distribution zones
Dual VWAP Filtering - Confirms trend direction using two independent VWAP calculations
Fair Value Gap Detection - Validates institutional interest through price inefficiency zones
The key innovation is the directional filter system: the primary Market Profile generates BUY-ONLY or SELL-ONLY states based on higher timeframe value area reversals, which then controls which signals from the main system are displayed. This creates a multi-timeframe confluence that significantly reduces false signals.
Unlike simple indicator mashups, each component serves a specific purpose:
Market Profile → Direction bias (trend filter)
Primary VWAP (Session) → Short-term trend confirmation
Secondary VWAP (Week) → Medium-term trend confirmation
FVG Detection → Institutional activity validation
🔧 HOW IT WORKS
1. Primary Market Profile Filter (Higher Timeframe)
The indicator calculates Market Profile on a higher timeframe (default: 1 hour) to determine the overall market structure:
Value Area High (VAH): Top 70% of volume distribution
Value Area Low (VAL): Bottom 70% of volume distribution
Point of Control (POC): Price level with highest volume
When price reaches VAH and reverses down → SELL-ONLY mode activated
When price reaches VAL and reverses up → BUY-ONLY mode activated
This higher timeframe filter ensures you're trading in the direction of institutional flow.
2. Dual VWAP System
Two independent VWAP calculations provide multi-timeframe trend confirmation:
Primary VWAP (Session-based): Resets daily, tracks intraday momentum
Secondary VWAP (Week-based): Resets weekly, confirms longer-term trend
Filter Logic:
BUY signals require: Price > Primary VWAP AND Price > Secondary VWAP
SELL signals require: Price < Primary VWAP AND Price < Secondary VWAP
This dual confirmation prevents counter-trend trades during ranging conditions.
3. Fair Value Gap (FVG) Detection
FVG zones identify price inefficiencies where institutional orders were executed rapidly:
Bullish FVG: Gap between candle .high and candle .low (upward imbalance)
Bearish FVG: Gap between candle .high and candle .low (downward imbalance)
The indicator monitors recent FVG formation (lookback: 50 bars) and requires:
Bullish FVG present for BUY signals
Bearish FVG present for SELL signals
FVG zones are displayed as colored boxes and automatically marked as "mitigated" when price fills the gap.
4. Main Trading Signal Logic
The secondary Market Profile (default: 1 hour) generates the actual trading signals:
BUY Signal Conditions:
Price reaches Value Area Low
Reversal pattern confirmed (minimum 1 bar)
Price > Primary VWAP
Price > Secondary VWAP (if filter enabled)
Recent Bullish FVG detected (if filter enabled)
Primary MP Filter = BUY-ONLY or NEUTRAL
SELL Signal Conditions:
Price reaches Value Area High
Reversal pattern confirmed (minimum 1 bar)
Price < Primary VWAP
Price < Secondary VWAP (if filter enabled)
Recent Bearish FVG detected (if filter enabled)
Primary MP Filter = SELL-ONLY or NEUTRAL
All conditions must be TRUE simultaneously for a signal to appear.
📈 VISUAL ELEMENTS
On Chart:
🟢 Green Triangle (▲) = BUY Signal
🔴 Red Triangle (▼) = SELL Signal
🟦 Blue horizontal lines = Value Area zones
🟡 Yellow line = Point of Control (POC)
🟩 Green boxes = Bullish FVG zones
🟥 Red boxes = Bearish FVG zones
🔵 Blue line = Primary VWAP (Session)
⚪ White line = Secondary VWAP (Week)
Info Panel (Top Right):
Real-time status display showing:
Filter Direction (BUY ONLY / SELL ONLY / NEUTRAL)
Active timeframes for both MP filters
FVG filter status and count
VWAP positions (ABOVE/BELOW)
Signal enablement status
Alert status
⚙️ KEY SETTINGS
MP/TPO Filter Settings (Primary Indicator)
MP Filter Time Frame: 60 minutes (controls directional bias)
Filter Value Area %: 70% (standard Market Profile calculation)
Filter Alert Distance: 1 bar
Filter Min Bars for Reversal: 1 bar
Filter Alert Zone Margin: 0.01 (1%)
FVG Filter Settings
Use FVG Filter: Enabled (toggle on/off)
FVG Timeframe: 60 minutes (1 hour)
FVG Filter Mode: Both (require bullish FVG for BUY, bearish for SELL)
FVG Lookback Period: 50 bars (how far back to search)
Show FVG Formation Signals: Optional visual markers
Max FVG on Chart: 50 zones
Show Mitigated FVG: Display filled gaps
Market Profile Settings
Higher Time Frame: 60 minutes (for main signals)
Percent for Value Area: 70%
Show POC Line: Enabled
Keep Old MPs: Enabled (maintain historical profiles)
Primary VWAP Filter
Use Primary VWAP Filter: Enabled
Primary VWAP Anchor Period: Session (resets daily)
Primary VWAP Source: HLC3 (typical price)
Secondary VWAP Filter
Use Secondary VWAP Filter: Enabled
Secondary VWAP Anchor Period: Week (resets weekly)
Secondary VWAP Filter Mode: Both
Secondary VWAP Line Color: White
Trading Signals
Show Trading Signals on Chart: Enabled
Show SELL Signals: Enabled
Show BUY Signals: Enabled
Alert Distance: 1 bar
Min Bars for Reversal: 1 bar
Alert Zone Margin: 0.01 (1%)
Retest Search Period: 20 bars
Min Bars Between Retests: 5 bars
Show Only Retests: Disabled
Alert Settings
Enable Trading Notifications: Enabled
VAH Reversal Alert: Enabled (SELL signals)
VAL Reversal Alert: Enabled (BUY signals)
Time Filter Settings
Filter Alerts By Time: Optional (exclude specific hours)
⚠️ IMPORTANT WARNINGS & LIMITATIONS
1. Repainting Behavior
CRITICAL: This indicator uses lookahead=barmerge.lookahead_on to access higher timeframe data immediately for FVG detection. This is necessary to provide real-time FVG zone visualization but has the following implications:
FVG zones may shift slightly until the higher timeframe candle closes
FVG detection signals are preliminary until HTF bar confirmation
The main trading signals (triangles) appear on confirmed bars and do not repaint
Best Practice: Always wait for the current timeframe bar to close before acting on signals. The filter status and FVG zones are informational but may adjust as new data arrives.
2. Minimum Timeframe
Do NOT use on timeframes below 5 minutes (M5)
Recommended: M5, M15, M30 for intraday trading
Higher timeframes (H1, H4) can also be used but will generate fewer signals
3. Multiple Filters Can Block Signals
By design, this indicator is conservative. When all filters are enabled:
Signals appear ONLY when all conditions align
You may see extended periods with no signals
This is intentional to reduce false positives
If you see no signals:
Check the Info Panel to see which filters are failing
Consider adjusting FVG lookback period
Temporarily disable FVG filter to test
Verify VWAP filters match current market trend
4. Market Profile Limitations
Market Profile requires sufficient volume data
Low-volume instruments may produce unreliable profiles
Value Areas update only on higher timeframe bar close
Works best on liquid markets (major forex pairs, indices, crypto)
📖 HOW TO USE
Step 1: Add to Chart
Apply indicator to M5 or higher timeframe chart
Ensure chart shows volume data
Use standard candles (NOT Heikin Ashi, Renko, etc.)
Step 2: Configure Settings
Primary MP Filter TF: Set to 60 (1 hour) minimum, or 240 (4 hour) for swing trading
Main MP TF: Set to 60 (1 hour) for intraday signals
FVG Timeframe: Match or exceed main MP timeframe
Leave other settings at default initially
Step 3: Understand the Info Panel
Monitor the top-right panel:
FILTER STATUS: Shows current directional bias
NEUTRAL = Both signals allowed
BUY ONLY = Only green triangles will appear
SELL ONLY = Only red triangles will appear
FVG Filter: Shows if bullish/bearish gaps detected recently
VWAP positions: Confirms trend alignment
Step 4: Take Signals
For BUY Signal (Green Triangle ▲):
Wait for green triangle to appear
Check Info Panel shows ✓ for BUY signals
Confirm current bar has closed
Enter long position
Stop loss: Below recent VAL or swing low
Target: Previous Value Area High or 1.5-2× risk
For SELL Signal (Red Triangle ▼):
Wait for red triangle to appear
Check Info Panel shows ✓ for SELL signals
Confirm current bar has closed
Enter short position
Stop loss: Above recent VAH or swing high
Target: Previous Value Area Low or 1.5-2× risk
Step 5: Risk Management
Risk per trade: Maximum 1-2% of account equity
Position sizing: Adjust based on stop loss distance
Avoid trading: During major news events or time filter periods
Multiple confirmations: Look for confluence with price action (support/resistance, trendlines)
🎓 UNDERLYING CONCEPTS
Market Profile Theory
Developed by J. Peter Steidlmayer in the 1980s, Market Profile organizes price and volume data to identify:
Value Areas: Where 70% of trading activity occurred
POC: Price level with highest acceptance (most volume)
Imbalances: When price moves away from value quickly
This indicator uses TPO (Time Price Opportunity) calculation method to build the volume profile distribution.
VWAP (Volume Weighted Average Price)
VWAP represents the average price weighted by volume, showing where institutional traders are positioned:
Price above VWAP = Bullish (institutions accumulated lower)
Price below VWAP = Bearish (institutions distributed higher)
Using dual VWAP (Session + Week) creates multi-timeframe trend alignment.
Fair Value Gaps (FVG)
Also known as "imbalance" or "inefficiency," FVG occurs when:
Price moves so rapidly that a gap forms in the candlestick structure
Indicates institutional order flow (large market orders)
Price often returns to "fill" these gaps (rebalance)
The 3-candle FVG pattern (gap between candle and candle ) is widely used in ICT (Inner Circle Trader) methodology and Smart Money Concepts.
🔍 CREDITS & CODE ATTRIBUTION
This indicator builds upon established technical analysis concepts and combines multiple methodologies:
1. Market Profile / TPO Calculation
Concept Origin: J. Peter Steidlmayer (Chicago Board of Trade, 1980s)
Code Inspiration: TradingView's public domain Market Profile examples
Modifications: Custom filtering logic for directional bias, dual timeframe implementation
2. VWAP Calculation
Concept Origin: Standard financial instrument (widely used since 1980s)
Code Base: TradingView built-in ta.vwap() function (public domain)
Modifications: Dual VWAP system with independent anchor periods, custom filtering modes
3. Fair Value Gap Detection
Concept Origin: Inner Circle Trader (ICT) / Smart Money Concepts methodology
Code Implementation: Original implementation based on 3-candle gap pattern
Features: Multi-timeframe detection, automatic mitigation tracking, visual zone display
4. Pine Script Framework
Language: Pine Script v6 (TradingView)
Built-in Functions Used:
ta.vwap() - Volume weighted average price
request.security() - Higher timeframe data access
ta.change() - Period detection
ta.cum() - Cumulative volume
time() - Timestamp functions
Note: All code is original implementation. While concepts are based on established trading methodologies, the combination, filtering logic, and execution are unique to this indicator.
📊 RECOMMENDED INSTRUMENTS
Best Performance:
Major Forex Pairs (EURUSD, GBPUSD, USDJPY)
Stock Indices (ES, NQ, SPX, DAX)
Major Cryptocurrencies (BTCUSD, ETHUSD)
Liquid Stocks (high daily volume)
Avoid:
Low-volume altcoins
Illiquid stocks
Exotic forex pairs with wide spreads
⚡ PERFORMANCE TIPS
Start Conservative: Enable all filters initially
Reduce Filters Gradually: If too few signals, disable Secondary VWAP filter first
Match Timeframes: Keep MP Filter TF and FVG TF at same value
Backtest First: Review historical performance on your preferred instrument/timeframe
Combine with Price Action: Look for support/resistance confluence
Use Time Filter: Avoid low-liquidity hours (optional setting)
🚫 WHAT THIS INDICATOR DOES NOT DO
Does not guarantee profits - No trading system is 100% accurate
Does not predict the future - Based on historical patterns
Does not replace risk management - Always use stop losses
Does not work on all instruments - Requires volume data and liquidity
Does not provide exact entry/exit prices - Signals are zones, not precise levels
Does not account for fundamentals - Purely technical analysis
📜 DISCLAIMER
This indicator is provided for educational and informational purposes only. It is not financial advice, and past performance does not guarantee future results.
Trading Risk Warning:
All trading involves risk of loss
You can lose more than your initial investment (leverage products)
Only trade with capital you can afford to lose
Always use appropriate position sizing and risk management
Consider seeking advice from a licensed financial advisor
Technical Limitations:
Indicator may repaint FVG zones until HTF bar closes
Signals are based on historical patterns that may not repeat
Market conditions change and no system works in all environments
Volume data quality varies by exchange/broker
By using this indicator, you acknowledge these risks and agree that the author bears no responsibility for trading losses.
📞 SUPPORT & UPDATES
Questions? Comment on this publication
Issues? Describe the problem with chart screenshot
Feature Requests? Suggest improvements in comments
Updates: Will be published as new versions using TradingView's update feature
📝 VERSION HISTORY
Version 1.0 (Current)
Initial public release
Multi-filter system: MP + Dual VWAP + FVG
Directional bias filter
Real-time info panel
Comprehensive alert system
Time-based filtering
Thank you for using Smart VWAP FVG System!
Happy Trading! 📈
Fractional + Heikin-Ashi Candlestick – CF / ABNew model of Candlestick, Tis model constructed on Fractional Calculus mathematical, use two kernel - Caputo-Fabrizio and Atangana-Baleanu.
Ben's BTC Macro Fair Value OscillatorBen's BTC Macro Fair Value Oscillator
Overview
The **BTC Macro Fair Value Oscillator** is a non-crypto fair value framework that uses macro asset relationships (equities, dollar, gold) to estimate Bitcoin's "macro-driven fair value" and identify mean-reversion opportunities.
"Is BTC cheap or expensive right now?" on the 4 Hour Timeframe ONLY
### Key Features
✅ **Macro-driven**: Uses QQQ, DXY, XAUUSD instead of on-chain or crypto metrics
✅ **Dynamic weighting**: Assets weighted by rolling correlation strength
✅ **Mean-reversion signals**: Identifies when BTC is cheap/expensive vs macro
✅ **Validated parameters**: Optimized through 5-year backtest (Sharpe 6.7-9.9)
✅ **Visual transparency**: Live correlation panel, fair value bands, statistics
✅ **Non-repainting**: All calculations use confirmed historical data only
### What This Indicator Does
- Builds a **synthetic macro composite** from traditional assets
- Runs a **rolling regression** to predict BTC price from macro
- Calculates **deviation z-score** (how far BTC is from macro fair value)
- Generates **entry signals** when BTC is extremely cheap vs macro (dev < -2)
- Generates **exit signals** when BTC returns to fair value (dev > 0)
### What This Indicator Is NOT
❌ Not a high-frequency trading system (sparse signals by design)
❌ Not optimized for absolute returns (optimized for Sharpe ratio)
❌ Not suitable as standalone trading system (best as overlay/confirmation)
❌ Not predictive of short-term price movements (mean-reversion timeframe: days to weeks)
---
## Core Concept
### The Premise
Bitcoin doesn't trade in a vacuum. It's influenced by:
- **Risk appetite** (equities: QQQ, SPX)
- **Dollar strength** (DXY - inverse to risk assets)
- **Safe haven flows** (Gold: XAUUSD)
When macro conditions are "good for BTC" (risk-on, weak dollar, strong equities), BTC should trade higher. When macro conditions turn against it, BTC should trade lower.
### The Innovation
Instead of looking at BTC in isolation, this indicator:
1. **Measures how strongly** BTC currently correlates with each macro asset
2. **Builds a weighted composite** of those macro returns (the "D" driver)
3. **Regresses BTC price on D** to estimate "macro fair value"
4. **Tracks the deviation** between actual price and fair value
5. **Signals mean reversion** when deviation becomes extreme
### The Edge
The validated edge comes from:
- **Extreme deviations predict future returns** (dev < -2 → +1.67% over 12 bars)
- **Monotonic relationship** (more negative dev → higher forward returns)
- **Works out-of-sample** (test Sharpe +83-87% better than training)
- **Low correlation with buy & hold** (provides diversification value)
---
## Methodology
### Step 1: Macro Composite Driver D(t)
The indicator builds a weighted composite of macro asset returns:
**Process:**
1. Calculate **log returns** for BTC and each macro reference (QQQ, DXY, XAUUSD)
2. Compute **rolling correlation** between BTC and each reference over `corrLen` bars
3. **Weight each asset** by `|correlation|` if above `minCorrAbs` threshold, else 0
4. **Sign-adjust** weights (+1 for positive corr, -1 for negative) to handle inverse relationships
5. **Z-score normalize** each reference's returns over `fvWindow`
6. **Composite D(t)** = weighted sum of sign-adjusted z-scores
**Formula:**
```
For each reference i:
corr_i = correlation(BTC_returns, ref_i_returns, corrLen)
weight_i = |corr_i| if |corr_i| >= minCorrAbs else 0
sign_i = +1 if corr_i >= 0 else -1
z_i = (ref_i_returns - mean) / std
contrib_i = sign_i * z_i * weight_i
D(t) = sum(contrib_i) / sum(weight_i)
```
**Key Insight:** D(t) represents "how good macro conditions are for BTC right now" in a normalized, correlation-weighted way.
---
### Step 2: Fair Value Regression
Uses rolling linear regression to predict BTC price from D(t):
**Model:**
```
BTC_price(t) = α + β * D(t)
```
**Calculation (Pine Script approach):**
```
corr_CD = correlation(BTC_price, D, fvWindow)
sd_price = stdev(BTC_price, fvWindow)
sd_D = stdev(D, fvWindow)
cov = corr_CD * sd_price * sd_D
var_D = variance(D, fvWindow)
β = cov / var_D
α = mean(BTC_price) - β * mean(D)
fair_value(t) = α + β * D(t)
```
**Result:** A time-varying "macro fair value" line that adapts as correlations change.
---
### Step 3: Deviation Oscillator
Measures how far BTC price has deviated from fair value:
**Calculation:**
```
residual(t) = BTC_price(t) - fair_value(t)
residual_std = stdev(residual, normWindow)
deviation(t) = residual(t) / residual_std
```
**Interpretation:**
- `dev = 0` → BTC at fair value
- `dev = -2` → BTC is 2 standard deviations **cheap** vs macro
- `dev = +2` → BTC is 2 standard deviations **rich** vs macro
---
### Step 4: Signal Generation
**Long Entry:** `dev` crosses below `-2.0` (BTC extremely cheap vs macro)
**Long Exit:** `dev` crosses above `0.0` (BTC returns to fair value)
**No shorting** in default config (risk management choice - crypto volatility)
---
## How It Works
### Visual Components
#### 1. Price Chart (Main Panel)
**Fair Value Line (Orange):**
- The estimated "macro-driven fair value" for BTC
- Calculated from rolling regression on macro composite
**Fair Value Bands:**
- **±1σ** (light): 68% confidence zone
- **±2σ** (medium): 95% confidence zone
- **±3σ** (dark, dots): 99.7% confidence zone
**Entry/Exit Markers:**
- **Green "LONG" label** below bar: Entry signal (dev < -2)
- **Red "EXIT" label** above bar: Exit signal (dev > 0)
#### 2. Deviation Oscillator (Separate Pane)
**Line plot:**
- Shows current deviation z-score
- **Green** when dev < -2 (cheap)
- **Red** when dev > +2 (rich)
- **Gray** when neutral
**Histogram:**
- Visual representation of deviation magnitude
- Green bars = negative deviation (cheap)
- Red bars = positive deviation (rich)
**Threshold lines:**
- **Green dashed at -2.0**: Entry threshold
- **Red dashed at 0.0**: Exit threshold
- **Gray solid at 0**: Fair value line
#### 3. Correlation Panel (Top-Right)
Shows live correlation and weighting for each macro asset:
| Asset | Corr | Weight |
|-------|------|--------|
| QQQ | +0.45 | 0.45 |
| DXY | -0.32 | 0.32 |
| XAUUSD | +0.15 | 0.00 |
| Avg \|Corr\| | 0.31 | 0.77 |
**Reading:**
- **Corr**: Current rolling correlation with BTC (-1 to +1)
- **Weight**: How much this asset contributes to fair value (0 = excluded)
- **Avg |Corr|**: Average correlation strength (should be > 0.2 for reliable signals)
**Colors:**
- Green/Red corr = positive/negative correlation
- White weight = asset included, Gray = excluded (below minCorrAbs)
#### 4. Statistics Label (Bottom-Right)
```
━━━ BTC Macro FV ━━━
Dev: -2.34
Price: $103,192
FV: $110,500
Status: CHEAP ⬇
β: 103.52
```
**Fields:**
- **Dev**: Current deviation z-score
- **Price**: Current BTC close price
- **FV**: Current macro fair value estimate
- **Status**: CHEAP (< -2), RICH (> +2), or FAIR
- **β**: Current regression beta (sensitivity to macro)
---
## Installation & Setup
### TradingView Setup
1. Open TradingView and navigate to any **BTC chart** (BTCUSD, BTCUSDT, etc.)
2. Open **Pine Editor** (bottom panel)
3. Click **"+ New"** → **"Blank indicator"**
4. **Delete** all default code
5. **Copy** the entire Pine Script from `GHPT_optimized.pine`
6. **Paste** into the editor
7. Click **"Save"** and name it "BTC Macro Fair Value Oscillator"
8. Click **"Add to Chart"**
### Recommended Chart Settings
**Timeframe:** 4h (validated timeframe)
**Chart Type:** Candlestick or Heikin Ashi
**Overlay:** Yes (indicator plots on price chart + separate pane)
**Alternative Timeframes:**
- Daily: Works but slower signals
- 1h-2h: May work but not validated
- < 1h: Not recommended (too noisy)
### Symbol Requirements
**Primary:** BTC/USD or BTC/USDT on any exchange
**Macro References:** Automatically fetched
- QQQ (Nasdaq 100 ETF)
- DXY (US Dollar Index)
- XAUUSD (Gold spot)
**Data Requirements:**
- At least **90 bars** of history (warmup period)
- Premium TradingView recommended for full historical data
---
## Reading the Indicator
### Identifying Signals
#### Strong Long Signal (High Conviction)
- ✅ Deviation < -2.0 (extreme undervaluation)
- ✅ Avg |Corr| > 0.3 (strong macro relationships)
- ✅ Price touching or below -2σ band
- ✅ "LONG" label appears below bar
**Interpretation:** BTC is extremely cheap relative to macro conditions. Historical data shows +1.67% average return over next 12 bars (48 hours at 4h timeframe).
#### Moderate Long Signal (Lower Conviction)
- ⚠️ Deviation between -1.5 and -2.0
- ⚠️ Avg |Corr| between 0.2-0.3
- ⚠️ Price approaching -2σ band
**Interpretation:** BTC is cheap but not extreme. Consider as confirmation for other signals.
#### Exit Signal
- 🔴 Deviation crosses above 0 (returns to fair value)
- 🔴 "EXIT" label appears above bar
**Interpretation:** Mean reversion complete. Close long positions.
#### Strong Short/Avoid Signal
- 🔴 Deviation > +2.0 (extreme overvaluation)
- 🔴 Avg |Corr| > 0.3
- 🔴 Price touching or above +2σ band
**Interpretation:** BTC is expensive vs macro. Historical data shows -1.79% average return over next 12 bars. Consider exiting longs or reducing exposure.
### Regime Detection
**Strong Regime (Reliable Signals):**
- Avg |Corr| > 0.3
- Multiple assets weighted > 0
- Fair value line tracking price reasonably well
**Weak Regime (Unreliable Signals):**
- Avg |Corr| < 0.2
- Most weights = 0 (grayed out)
- Fair value line diverging wildly from price
- **Action:** Ignore signals until correlations strengthen
Victoria Smart Overlay – EMA1/SMA3/SMA1Core Components:
EMA 1 (Micro): fastest trend trigger
SMA 3 (Short): trend confirmation
SMA 1 (Base): structure guide
Conditions and Actions:
EMA1 crosses above SMA3 → Uptrend starting → Consider Calls / Long
EMA1 crosses below SMA3 → Downtrend starting → Consider Puts / Short
Price hugging SMA1 → Neutral zone → Wait for breakout
Background Green → Confirmed Uptrend → Stay long or scalp Calls
Background Red → Confirmed Downtrend → Stay short or scalp Puts
Micro EMA + Heikin Ashi (Refined Swing Map)
Purpose: Filters fake moves and identifies strong momentum runs.
Use on 5m / 15m charts for intraday clarity.
Signals and Actions:
EMA1 > EMA3 > EMA5 → Micro-uptrend forming → Enter / hold Calls
EMA1 < EMA3 < EMA5 → Micro-downtrend forming → Enter / hold Puts
EMA lines tangled → No conviction → Wait
200-Day SMA rising → Macro bullish → Favor long trades
200-Day SMA falling → Macro bearish → Favor shorts
SevenDayHighLowTableWithBoxes [CHE]SevenDayHighLowTableWithBoxes — Seven-day day-range boxes with a weekday-aware “ghost” projection and a compact table that tracks recent extremes and per-weekday hit rates.
Summary
This indicator visualizes each trading day as a colored box and annotates the final high and low with compact markers. It maintains a rolling seven-day view and a five-column table showing day name, high, low, range, and a per-weekday projection hit statistic. A dashed “ghost” box projects a typical range for the current weekday using a running average and an adjustable scaling factor. The script is written in Pine v6, runs on the main chart (overlay true), and emphasizes stable object handling and closed-bar finalization at day boundaries.
Motivation: Why this design?
Intraday traders often need fast context for where today’s price sits relative to recent daily extremes, without switching timeframes. A simple daily high/low overlay is informative but lacks structure, sizing context, and continuity. By grouping bars into local days (configurable UTC offset), drawing explicit boxes, and projecting a weekday-typical range, the chart becomes easier to scan. The compact table gives a quick audit trail of the latest seven days while tracking how often the weekday projection would have covered the realized range.
What’s different vs. standard approaches?
Reference baseline: Plain daily high/low lines or session boxes without context.
Architecture differences:
Weekday-tinted boxes and labels for today plus up to six prior days.
Weekday average range drives a dashed projection (“ghost”) sized by a user-defined percentage.
Per-weekday hit statistics recorded as hits over totals and displayed in the table.
ATR-based vertical offsets keep labels readable.
Live updates intraday; state is finalized at the local day switch.
Practical effect: The chart shows where current price sits inside a known daily envelope, plus how “typical” the day’s movement is for this weekday, aiding expectations and planning.
How it works (technical)
The script computes a local daily timestamp using the user’s UTC offset. A day change finalizes the prior day, writes its high, low, start and end indices, and records the bar indices of the terminal high and low.
For each weekday, it maintains a running average of realized ranges with a cap on the lookback count. The ghost projection length is the weekday average scaled by the user’s percentage setting.
Anchor selection for the ghost uses the most recent extreme and the close relative to the intraday midpoint to choose a low-anchored or high-anchored box.
A five-column table (Day, High, Low, Range, Ghost OK) is refreshed on the last bar. The “Ghost OK” column shows per-weekday cumulative hits over totals with a percentage, calculated before including the just-finished day.
Object counts are bounded to seven days by pruning arrays and deleting old boxes and labels. Visual updates for historical objects occur on the last bar to minimize overhead. No `security()` calls are used.
Parameter Guide
UTC (+/−) — Controls local day boundaries — Default: minus five hours — Set to your venue’s local time.
Session (for Time gate) — Session string — Default: full week — (Optional) computed internally; not applied to gating.
Show 7-Day High/Low Table — Toggles the table — Default: true — Disable to reduce UI load.
Show Day Boxes in Chart — Toggles day boxes — Default: true — Disable for a cleaner chart.
Table Position — Nine-point anchor — Default: Middle Right — Move to avoid overlap.
Table Background / Text Color / Min Cell Width — Styling controls — Defaults: gray background, white text, width twelve characters.
Weekday Colors (Sun…Sat) — Row and box tints — Defaults: semi-transparent hues — Adjust for your theme.
Triangle Transparency — Marker opacity — Default: zero — Increase to fade high/low dots.
Day Label Transparency — Day name opacity — Default: zero — Increase to reduce emphasis.
Box Border Width — Box stroke width — Default: one — Increase for stronger edges.
Extend Boxes Right — Extend current box — Default: false — Useful for forward planning.
Show Average Range Ghost Box — Dashed projection — Default: true — Disable if distracting.
Ghost Border Color / Width — Ghost styling — Defaults: gray, width one.
Ghost Length percent of AvgRange — Projection scale — Default: one hundred; bounds zero to five hundred — Lower to be conservative.
Max History Days for Average — Cap per-weekday averaging — Default: two hundred fifty-two; bounds thirty to five hundred.
ATR Length / Day Label ATR Multiplier / Triangle Up ATR Multiplier / Triangle Down ATR Multiplier — Offsets for label placement — Defaults: length one hundred; multipliers zero — Increase on dense instruments to prevent overlap.
Reading & Interpretation
Day boxes: The filled rectangle marks each day’s full high-low span; color encodes the weekday.
Markers: Small dots near the terminal high and low highlight where the final extremes occurred.
Ghost box: A dashed box sized by the weekday average range, anchored based on recent behavior. It is a typical span, not a target.
Table: Row one shows “Today”. Rows below list up to six prior days. “Ghost OK” shows per-weekday cumulative hits over totals with a percentage, which reflects historical coverage quality for that weekday.
Practical Workflows & Combinations
Trend following: Use the current box plus recent boxes to read expansion or compression days; combine with basic structure such as higher-highs and higher-lows or lower-lows and lower-highs for confirmation.
Exits and risk: When price nears the ghost boundary late in the session, consider managing exposure more conservatively.
Multi-asset and multi-timeframe: Works on minute charts. As a starting point, use five to less than sixty minutes. For cross-checks, pair with a higher timeframe bias filter.
Behavior, Constraints & Performance
Repaint/confirmation: The indicator updates intraday; extremes and ghost position can move while the day is open. Values are finalized on the next local day start.
HTF/security: None used; repaint risk is limited to live-bar movement.
Resources: `max_bars_back` five thousand; arrays are pruned to seven days; the table and color sync run on the last bar; the live ghost updates only in real time.
Known limits: Weekday averages can be unrepresentative during regime shifts, events, or gaps. Day boundaries depend on the UTC offset being set correctly. No alerts are included. The script displays warning labels when the timeframe is below five minutes or at sixty minutes and above.
Sensible Defaults & Quick Tuning
Start with the defaults.
Ghost too aggressive: Lower the percent scale.
Labels overlap: Increase ATR multipliers.
Clutter or performance issues: Hide the table or boxes, or disable the ghost.
Day boundary misaligned: Adjust the UTC offset to your market.
What this indicator is—and isn’t
This is a visualization and context layer for daily extremes and a weekday-based typical span. It does not predict direction, does not manage orders, and is not a complete trading system. Use it alongside market structure, risk controls, and position management.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
