เริ่มกันเลย

Reversal

Viprasol Multi-Timeframe Trend Signal Engine## Overview The Multi-Timeframe Trend Signal Engine is a comprehensive trading system that combines SuperTrend-based signals with a 6-timeframe ADX trend dashboard, EMA trend ribbon, chaos trend line, order blocks, and risk management — all in one overlay. It scans 5m through Daily timeframes using ADX-based trend detection and calculates a confluence score (0-6) showing how many timeframes agree on direction. Built for traders who want multi-timeframe confirmation before entering trades. ## What Is Original (Viprasol Additions) The following features were designed and implemented by Viprasol and do not exist in the original script: 1. **MTF Confluence Score (0-6)** — Counts how many of the 6 monitored timeframes (5m, 15m, 1H, 4H, 12H, Daily) currently show a bullish ADX trend. Displayed in the dashboard as "X/6 Bullish" with color coding: green (5-6), yellow (3-4), red (0-2). A separate bear confluence count is also tracked. This gives traders an instant read on multi-timeframe alignment strength. 2. **Enhanced Dashboard Rows** — The original dashboard only showed 6 timeframe trend readings with volatility and RSI. Viprasol added three additional rows: (a) MTF Confluence Score alongside Ribbon trend status, (b) Last Signal direction (Buy/Sell) alongside Chaos Trend status (Bullish/Bearish), and (c) a branded footer row. The dashboard now shows 10 rows of information instead of 8. 3. **MTF Alignment Alerts** — Two new alert conditions that fire when 5 or more of the 6 timeframes agree on direction (Strong Bullish Alignment and Strong Bearish Alignment). These did not exist in the original and provide automated notification of high-confluence multi-timeframe setups. 4. **Ribbon Trend Change Alerts** — Two alert conditions for when the EMA ribbon crosses from bullish to bearish or vice versa. The original had trend change alerts but they were tied to the ribbon state variable directly — the Viprasol version uses edge detection (`ribbonBullish and not ribbonBullish `) for precise single-bar firing. 5. **Tooltips on All Inputs** — Every input parameter (25+) has a descriptive tooltip explaining its function, recommended values, and behavior. The original had tooltips on only 3 inputs (sensitivity, signal type, and EMA length). 6. **Reorganized Input Groups** — Inputs reorganized from 4 groups (Main, Trend, Advanced, Dashboard) into 5 semantically clearer groups (Main Settings, Trend Settings, Signal Settings, Dashboard Settings, Risk Management) with consistent naming and inline layouts. 7. **Viprasol Dashboard Styling** — Branded header ("Viprasol - MTF Trend Signal Engine"), dark theme color scheme (#111725 background, #18233a header), and branded footer with version number. ## How It Works **SuperTrend Signals:** A custom SuperTrend calculation generates buy/sell signals using ATR-based dynamic bands. All signals require bar-close confirmation to prevent repainting. Two modes are available: "All Signals" shows every crossover, while "Filtered Signals" adds an EMA filter requiring price to be above/below the main EMA for additional confirmation. **Multi-Timeframe ADX Dashboard:** The indicator fetches ADX trend quality from 6 timeframes (5m, 15m, 1H, 4H, 12H, Daily) using an anti-repaint security function (`src ` with `lookahead_on` — confirmed previous bar only). Each timeframe is classified as Bullish (ADX above adaptive threshold), Bearish (below threshold), or Neutral. The confluence score counts how many timeframes are bullish (0-6), providing an at-a-glance alignment reading. **Trend Ribbon:** Five EMAs (20, 25, 35, 45, 55) form a color-coded ribbon that shifts between bullish and bearish states on crossover. The ribbon provides visual trend context independent of the signal system. **EMA Cloud:** The 150/250 EMA cloud identifies longer-term structural trend direction. Green fill indicates bullish structure, red indicates bearish. **Chaos Trend Line:** An adaptive trend line using pivot-based detection with ATR channels. It tracks the trend using highest/lowest pivot levels and changes color on confirmed reversals. **Order Blocks:** Structural order blocks based on pivot break of structure. Bullish OBs form at swing lows when higher highs break structure; bearish OBs form at swing highs when lower lows break structure. Boxes fade when tested and are removed when fully invalidated. **RSI Take Profit System:** A sequential TP system using RSI crossovers at 70/85/100 (bullish) and 30/15/5 (bearish). Each TP level only fires after the previous one has triggered within the current signal, creating a staged exit approach. **Reversal Signals:** A 25-period RSI-based reversal detector that fires when RSI crosses above oversold (25) or below overbought (75) levels, using bar-close confirmation. ## Key Features - Custom SuperTrend signals with bar-close confirmation (no repainting on confirmed bars) - Two signal modes: All Signals and EMA-Filtered Signals - 6-timeframe ADX trend dashboard (5m, 15m, 1H, 4H, 12H, Daily) - MTF Confluence Score (0-6) — count of bullish timeframes - 5-EMA trend ribbon with color-coded direction - EMA 150/250 cloud for structural trend - Adaptive chaos trend line with pivot detection - Structural order blocks with auto-invalidation - RSI-based sequential take profit system (TP1/TP2/TP3) - Visual-only TP/SL risk management lines - RSI reversal signals at extreme levels - Channel breakout levels from pivot highs/lows - 3 candle coloring modes (Scalper RSI, Trend Ribbon, EMA Direction) - RSI background zones for overbought/oversold - Configurable dashboard position (3 locations) and font size (4 sizes) - All visual elements individually toggleable - 10 alert conditions with dynamic messages ## How to Use **Reading the Dashboard:** - Check the MTF Confluence Score first — 5-6/6 Bullish = strong alignment for longs, 0-1/6 = strong alignment for shorts - Individual timeframe trends show where agreement and disagreement exist - Ribbon and Chaos Trend rows provide additional trend context **Signal Interpretation:** - Use "Filtered Signals" mode for higher-quality entries aligned with the main EMA - Use "All Signals" mode for more frequent entries in ranging markets - Reversal signals (purple labels) indicate potential exhaustion at RSI extremes - TP1/TP2/TP3 markers provide staged exit targets based on RSI momentum **Recommended Settings:** - Scalping (1m-5m): Sensitivity 2.0, ATR Factor 8, Filtered mode - Intraday (15m-1H): Sensitivity 2.5, ATR Factor 11, All Signals mode - Swing (4H-1D): Sensitivity 3.0, ATR Factor 14, Filtered mode ## Settings | Group | Description | |---|---| | Main Settings | Sensitivity (signal frequency), Signal Mode (All/Filtered), ATR Factor (band width) | | Trend Settings | Toggle trend ribbon, EMA cloud, chaos trend line, order blocks, main EMA (with custom period) | | Signal Settings | Show/hide signals, candle coloring mode, RSI background zones, channel breakouts | | Dashboard Settings | Show/hide dashboard, position (3 options), font size (4 options) | | Risk Management | Visual-only TP/SL lines with adjustable TP strength, individual TP level toggles | ## Alerts 1. **Buy Signal** — SuperTrend crossover buy confirmed at bar close 2. **Sell Signal** — SuperTrend crossover sell confirmed at bar close 3. **Filtered Buy** — Buy signal with price above main EMA 4. **Filtered Sell** — Sell signal with price below main EMA 5. **Reversal Up** — RSI crosses above oversold level 6. **Reversal Down** — RSI crosses below overbought level 7. **Ribbon Turned Bullish** — EMA ribbon crosses to bullish state 8. **Ribbon Turned Bearish** — EMA ribbon crosses to bearish state 9. **Strong Bullish MTF Alignment** — 5+ of 6 timeframes showing bullish trend 10. **Strong Bearish MTF Alignment** — 5+ of 6 timeframes showing bearish trend All alerts include {{ticker}}, {{close}}, and {{interval}} for dynamic notification messages. ## Limitations & Disclaimer - MTF data uses the anti-repaint pattern (previous bar + lookahead) to avoid repainting on confirmed bars. However, the current bar's data updates in real-time until confirmed. - ADX trend classification uses an adaptive threshold (median ADX x multiplier), which means "Neutral" readings are relative to recent volatility, not fixed levels. - The RSI TP system is sequential — TP2 only fires after TP1, and TP3 after TP2. If TP1 never triggers, later levels will not fire. - Order blocks are based on a simplified break-of-structure method using 3-bar pivots. They are not equivalent to institutional order flow. - The Risk Management TP/SL lines are VISUAL ONLY — they do not execute trades. - Candle coloring modes use different data sources — ensure you understand which mode is active. - This indicator is for educational and analytical purposes only — it is not financial advice. Always use proper risk management and test on a demo account first. ## Credits & Attribution The original script provides the SuperTrend signal engine, EMA trend ribbon, EMA cloud, chaos trend line, MTF ADX dashboard (6 timeframes), order block detection, RSI take profit system, risk management TP/SL lines, reversal signals, channel breakouts, candle coloring modes, volatility measurement, and 8 alert conditions. All enhancements listed in the "What Is Original" section above were designed and implemented by Viprasol. Published open-source per TradingView's open-source reuse guidelines.
อินดิเคเตอร์ Pine Script®
โดย viprasol
Money Flow Divergence Zones [AlgoAlpha]🟠 OVERVIEW This script identifies key price levels where volume and momentum show significant disagreement, visualizing these areas as Money Flow Liquidity Zones. By tracking the Money Flow Index (MFI) and its relationship to price action, the tool detects regular divergences that often precede market reversals. When a divergence is confirmed, the script projects a horizontal zone onto the chart based on the recent price extreme. These zones act as "liquidity pockets" that remain active until price successfully mitigates them through a wick or body cross, providing a clear map of potential support and resistance derived from volume-weighted momentum. 🟠 CONCEPTS The core logic relies on the interaction between a smoothed MFI and pivot-based price extremes. While price might make a lower low, the MFI—calculated from $hlc3$ and volume—might make a higher low, signaling that selling pressure is exhausting despite the price drop. This script uses these divergences to set the initial context for a zone. The zones are then refined using a "Body vs Wick" logic, where the zone's depth is defined by the distance between the absolute high/low and the candle body. The MFI smoothing via a Hull Moving Average (HMA) ensures that the momentum signals are responsive yet filtered for high-frequency noise. 🟠 FEATURES Dynamic Liquidity Zones : Automatically draws and extends support/resistance zones based on MFI divergence. Divergence Engine : Detects regular bullish and bearish divergences with adjustable pivot lookbacks. Visual Momentum Oscillator : Features a color-coded, smoothed MFI with a gradient midline to show volume strength. Touch Signals : Small triangles appear when price interacts with an active zone while momentum aligns. 🟠 USAGE Setup : Add the script to your chart. It is effective on most timeframes, but for intraday trading, the default 14-period MFI works well on 5m to 15m charts. Adjust the "Pivot Lookback" to fine-tune how sensitive the divergence detection is to local peaks. Read the chart : Green zones represent bullish liquidity (potential support), while red zones represent bearish liquidity (potential resistance). Look for "▲" or "▼" symbols on the bars; these indicate price is currently touching a zone and might be ready for a reversal. The oscillator at the bottom confirms the trend: green for rising money flow and red for falling. Settings that matter : The Sweep Type is critical—switching to "wick" will make zones disappear more easily (conservative), while "body" keeps zones active until a candle closes through them (aggressive). The Max Zone Age prevents old, irrelevant levels from cluttering your chart by removing them after a set number of bars.
อินดิเคเตอร์ Pine Script®
โดย AlgoAlpha
LOWESS Reversal & Continuation [UAlgo]LOWESS Reversal & Continuation is a trend sensitive signal indicator built around a local LOWESS style smoothing engine that adapts to both price structure and volatility. Its core objective is to separate meaningful directional shifts from routine market noise by combining smoothed trend estimation, ATR normalized slope analysis, acceleration filtering, and disciplined signal gating. Instead of relying on a conventional moving average crossover model, the script fits a locally weighted regression over a rolling window of recent bars. This produces a smoother and more context aware estimate of price direction, while still reacting fast enough to identify emerging reversals and pullback continuation opportunities. Because the estimate is local and weighted, recent bars have greater influence than distant bars, which helps the line remain relevant to current market conditions. The indicator classifies signals into two practical categories. Reversal signals aim to identify transitions where directional pressure flips from negative to positive, or from positive to negative. Continuation signals aim to identify pullback resumption behavior inside an already established directional regime. This makes the script suitable for traders who want a single tool that can highlight both early trend change candidates and trend following re entry points. To improve robustness, the script also supports optional robust weighting passes. These passes reduce the influence of outlier bars on the LOWESS fit, which is especially useful during abnormal spikes, illiquid conditions, or isolated volatility shocks. In addition, all slope readings are normalized by ATR, allowing the trend filter to scale more consistently across instruments, timeframes, and volatility regimes. From a workflow perspective, the script is designed for clean chart usage. It colors the LOWESS line according to directional bias, draws an adaptive ATR based band around the curve, supports optional signal labels, limits on chart label clutter through an internal object manager, and provides alert conditions for all signal classes. The result is a visually compact but analytically rich framework for tracking trend reversals and continuation setups in real time. 🔹 Features 🔸 LOWESS Style Local Trend Estimation The heart of the script is a locally weighted linear regression model applied over a rolling lookback window. Each bar inside the window receives a distance based weight, meaning bars closer to the current bar have a larger impact on the estimate. This produces a smooth trend line that is more adaptive than many standard moving average techniques and better suited for identifying subtle turning points. 🔸 Optional Robust Regression Passes The indicator can apply additional robust weighting iterations after the initial fit. Residuals are measured relative to the first regression pass, and bars with unusually large residuals receive progressively lower influence in later passes. This reduces distortion from extreme candles and helps the LOWESS curve remain stable during irregular price events. 🔸 ATR Normalized Slope Filter The script does not use raw slope in isolation. Instead, the LOWESS slope is divided by ATR, creating a volatility adjusted slope metric. This makes the directional threshold more portable across markets and timeframes. A slope that may be meaningful on a slow instrument can be very different on a high volatility asset, so ATR normalization creates a more balanced regime filter. 🔸 Reversal Signal Detection Bullish and bearish reversal signals are triggered when the ATR normalized slope crosses the zero line and is confirmed by directional acceleration and price location relative to the LOWESS line. In other words, the script looks for a meaningful change in smoothed directional pressure, not simply a visual bend in the curve. This makes reversal signals more selective and better aligned with structural momentum shifts. 🔸 Continuation Signal Detection Continuation logic is designed to capture trend resumption after a pullback. The script first requires an established directional regime, then checks whether price recently interacted with the LOWESS line, and finally waits for price to reclaim the trend direction with positive confirming acceleration. This helps distinguish genuine continuation behavior from random sideways oscillation around the curve. 🔸 Pullback Validation Window A dedicated pullback lookback parameter ensures that continuation signals only occur when price has interacted with the LOWESS line within a recent number of bars. This prevents stale continuation triggers and keeps the setup focused on recent retracement behavior rather than distant historical interactions. 🔸 Close Confirmation Option Signals can be gated so they only become valid after bar close. This is useful for traders who want to avoid intrabar flicker and premature triggers on live candles. When disabled, the script can respond more aggressively in real time, which may suit faster execution styles. 🔸 Signal Cooldown Logic To reduce repetitive clustering, the indicator tracks the last occurrence of each signal type and imposes a cooldown period before another signal of the same class can be printed. Separate cooldown tracking is maintained for bullish reversals, bearish reversals, bullish continuations, and bearish continuations. 🔸 Adaptive ATR Band An optional ATR based band can be plotted around the LOWESS line. This band provides a visual sense of dynamic range around the smoothed path and can help contextualize whether price is moving in a relatively stretched or balanced position around the trend estimate. 🔸 Directional Visual Coloring The LOWESS curve changes color according to directional bias derived from the ATR normalized slope. This gives the user an immediate visual read on whether the smoothed trend pressure is currently positive, negative, or unavailable due to insufficient historical data. 🔸 Lightweight Label Management When signal labels are enabled, the script uses an internal label book to store and manage plotted objects. Older labels are automatically deleted once the configured maximum is exceeded, helping keep the chart readable and preventing uncontrolled label buildup. 🔸 Full Alert Support Alert conditions are included for all four event classes: Bullish LOWESS Reversal Bearish LOWESS Reversal Bullish LOWESS Continuation Bearish LOWESS Continuation This allows the script to be used not only as a visual analysis tool, but also as an event driven signal framework for scanning and real time notification workflows. 🔹 Calculations 1) Rolling LOWESS Window Construction For every bar, the script loads the most recent length values of the selected source into an internal rolling window. This window becomes the data sample used for the local regression fit. method loadWindow(LowessEngine this, float seriesValue) => for i = 0 to this.length - 1 array.set(this.y, i, seriesValue ) Interpretation: The regression is always fit on the latest rolling block of data. The rightmost point in the window corresponds to the current estimation point. This makes the smoothing local rather than global. 2) Distance Based LOWESS Weights The script uses a tricube kernel to assign weights based on each point’s distance from the current bar inside the regression window. Bars nearer to the most recent observation receive a larger weight, while distant bars contribute less. method buildDistanceWeights(LowessEngine this, int spanBars) => int x0 = this.length - 1 float bandwidth = math.max(spanBars, 1) for i = 0 to this.length - 1 float u = math.abs(i - x0) / bandwidth float w = u < 1 ? math.pow(1 - math.pow(u, 3), 3) : 0.0 array.set(this.baseW, i, w) Interpretation of the conditions: x0 is the current evaluation point inside the rolling window. u is normalized distance from each historical point to the current point. The tricube weight decays smoothly as distance increases. Bars outside the effective span receive zero weight. This is what gives the LOWESS fit its local character and helps it stay focused on recent structure. 3) Weighted Local Linear Regression After weights are built, the script solves a weighted linear regression over the local window. The output is a local intercept and local slope. The final LOWESS estimate is the fitted value at the most recent point in the sample. method solveWeightedLinear(LowessEngine this, array weights) => float s0 = 0.0 float s1 = 0.0 float s2 = 0.0 float t0 = 0.0 float t1 = 0.0 for i = 0 to this.length - 1 float w = array.get(weights, i) float x = array.get(this.x, i) float y = array.get(this.y, i) s0 += w s1 += w * x s2 += w * x * x t0 += w * y t1 += w * x * y float den = s0 * s2 - s1 * s1 if s0 <= 1e-10 or math.abs(den) <= 1e-10 this.slope := 0.0 this.intercept := array.get(this.y, this.length - 1) else this.slope := (s0 * t1 - s1 * t0) / den this.intercept := (t0 - this.slope * s1) / s0 float x0 = this.length - 1 this.yhat := this.intercept + this.slope * x0 Interpretation: this.slope measures the local directional gradient of the LOWESS fit. this.yhat is the current LOWESS value plotted on the chart. If the weighted regression becomes numerically unstable, the script falls back to a flat slope and uses the latest source value as intercept. 4) Robust Reweighting Passes To reduce the impact of outliers, the script can run additional robust passes after the initial fit. It first calculates the absolute residual of each point relative to the fitted line, then computes a median based scale estimate, and finally applies a bisquare style robust weighting function. method updateRobustWeights(LowessEngine this) => for i = 0 to this.length - 1 float xi = array.get(this.x, i) float yi = array.get(this.y, i) float fit = this.intercept + this.slope * xi array.set(this.residualAbs, i, math.abs(yi - fit)) float med = this.residualAbs.median() float scale = med * 6.0 if na(scale) or scale <= 1e-10 for i = 0 to this.length - 1 array.set(this.robustW, i, 1.0) else for i = 0 to this.length - 1 float u = array.get(this.residualAbs, i) / scale float rw = u < 1 ? math.pow(1 - math.pow(u, 2), 2) : 0.0 array.set(this.robustW, i, rw) Interpretation: Large residual bars are treated as less trustworthy observations. The median residual acts as a robust scale anchor. Higher residuals receive smaller robust weights in subsequent fits. This improves stability during abnormal spikes and irregular candles. 5) ATR Normalized Slope and Acceleration Once the LOWESS fit is complete, the script converts raw slope into a volatility aware slope by dividing it by ATR. It also computes a first-difference style acceleration term to measure whether directional pressure is strengthening or weakening. float slopeAtr = not na(slope) and atr > 0 ? slope / atr : na float accelAtr = slopeAtr - nz(slopeAtr ) Interpretation: slopeAtr expresses trend slope in ATR units. accelAtr measures change in normalized slope from one bar to the next. Positive acceleration supports bullish developments. Negative acceleration supports bearish developments. This combination helps the script distinguish a genuine regime shift from a weak or decaying slope condition. 6) Directional Regime Classification The script uses a user defined ATR normalized threshold to determine whether the current smoothed state qualifies as a bullish or bearish directional regime. bool upRegime = not na(slopeAtr) and slopeAtr > slopeThreshold bool downRegime = not na(slopeAtr) and slopeAtr < -slopeThreshold Interpretation: A positive but very small slope is not automatically treated as a valid uptrend. A negative but very small slope is not automatically treated as a valid downtrend. The threshold acts as a noise filter that requires the trend estimate to have enough magnitude before continuation logic becomes eligible. 7) Pullback Detection Relative to LOWESS Continuation signals depend on recent interaction with the LOWESS line. The script checks how many bars have passed since price moved through the LOWESS curve in the opposite direction of the active regime. int bullPbBars = int(nz(ta.barssince(low < lowess), 100000)) int bearPbBars = int(nz(ta.barssince(high > lowess), 100000)) bool bullPullbackRecent = bullPbBars <= pullbackLookback bool bearPullbackRecent = bearPbBars <= pullbackLookback Interpretation: In a bullish regime, price must have recently dipped below the LOWESS line to qualify as a pullback. In a bearish regime, price must have recently pushed above the LOWESS line to qualify as a pullback. The pullbackLookback parameter controls how recent that interaction must be. 8) Reversal Signal Logic Bullish and bearish reversal signals are built from zero line slope crossings, directional acceleration, and price confirmation relative to the LOWESS curve. bool slopeCrossUp = ta.crossover(slopeAtr, 0) bool slopeCrossDown = ta.crossunder(slopeAtr, 0) bool bullRevRaw = enoughBars and slopeCrossUp and accelAtr > 0 and close > lowess bool bearRevRaw = enoughBars and slopeCrossDown and accelAtr < 0 and close < lowess Interpretation of the bullish reversal conditions: slopeCrossUp means the normalized LOWESS slope has crossed from negative to positive. accelAtr > 0 means the slope is improving, not merely touching zero. close > lowess confirms that price is positioned above the smoothed trend estimate. Interpretation of the bearish reversal conditions: slopeCrossDown means the normalized LOWESS slope has crossed from positive to negative. accelAtr < 0 confirms weakening trend pressure. close < lowess confirms price is positioned below the LOWESS line. This makes reversal signals more selective than a simple moving average crossover style event. 9) Continuation Signal Logic Continuation signals are only allowed when a directional regime already exists, a recent pullback has occurred, price crosses back through the LOWESS line in trend direction, and acceleration confirms that the move is regaining strength. bool priceCrossUp = ta.crossover(close, lowess) bool priceCrossDown = ta.crossunder(close, lowess) bool bullContRaw = enoughBars and upRegime and bullPullbackRecent and priceCrossUp and accelAtr > 0 and not bullRevRaw bool bearContRaw = enoughBars and downRegime and bearPullbackRecent and priceCrossDown and accelAtr < 0 and not bearRevRaw Interpretation of the bullish continuation conditions: The LOWESS slope must already define an uptrend regime. Price must have recently pulled back below the LOWESS line. Price must cross back above the LOWESS line. Acceleration must be positive. A reversal signal takes priority, so continuation does not print if the same bar qualifies as a bullish reversal. Interpretation of the bearish continuation conditions is the exact inverse. 10) Close Confirmation and Cooldown Control The final signal is gated by an optional bar close confirmation and a per-signal cooldown filter. bool gate = confirmClose ? barstate.isconfirmed : true bool bullRev = gate and bullRevRaw and canBullRev(signalState, cooldownBars) bool bearRev = gate and bearRevRaw and canBearRev(signalState, cooldownBars) bool bullCont = gate and bullContRaw and canBullCont(signalState, cooldownBars) bool bearCont = gate and bearContRaw and canBearCont(signalState, cooldownBars) Interpretation: When close confirmation is enabled, signals only become valid after the candle is closed. Cooldown logic prevents repeated printing of the same signal class within a short number of bars. This reduces visual clutter and avoids excessive re-triggering during choppy conditions. 11) Adaptive Band Construction The script can draw an ATR-based envelope around the LOWESS line to provide volatility context. float upperBand = showBand and not na(lowess) ? lowess + atr * bandAtrMult : na float lowerBand = showBand and not na(lowess) ? lowess - atr * bandAtrMult : na Interpretation: The band expands and contracts with ATR. This creates a dynamic visual frame around the LOWESS estimate. It is not a signal by itself, but it helps contextualize the distance between current price and the smoothed trend path. 12) Visual Output and Alerts The LOWESS line changes color according to slope direction, optional labels mark reversal and continuation events, and alert conditions are available for all four signal types. alertcondition(bullRev, "Bullish LOWESS Reversal", "Bullish LOWESS reversal on {{ticker}}") alertcondition(bearRev, "Bearish LOWESS Reversal", "Bearish LOWESS reversal on {{ticker}}") alertcondition(bullCont, "Bullish LOWESS Continuation", "Bullish LOWESS continuation on {{ticker}}") alertcondition(bearCont, "Bearish LOWESS Continuation", "Bearish LOWESS continuation on {{ticker}}") In practical terms, this means the indicator can serve both as a visual discretionary analysis tool and as an alert driven framework for identifying smoothed trend reversals and pullback continuation opportunities with a volatility aware filter structure.
อินดิเคเตอร์ Pine Script®
โดย UAlgo
Hidden Markov Reversal Finder [UAlgo]Hidden Markov Reversal Finder is a regime aware reversal detection indicator that uses a compact 3 state Hidden Markov style filter with online adaptation to classify market conditions and highlight potential top and bottom rotations. The script models price behavior as transitions between three regimes: - Bull Expansion - Balance - Bear Stress Instead of running a heavy Baum Welch retraining loop, this version is designed as a lightweight real time filter. It updates regime probabilities using a transition matrix plus a two dimensional Gaussian emission model built from two normalized observations: Return observation as a smoothed log return z score Volatility observation as a realized volatility z score The indicator runs in its own pane ( overlay=false ) but can optionally paint chart bars and place reversal labels on price using force overlay. It also includes a clean dashboard panel showing the current state, confidence, observation values, score, posterior probabilities, stretch, and the current setup classification. The reversal engine is built around a top rotation and bottom rotation concept. It looks for a probability peak in a regime, then a fade from that peak, combined with momentum flip conditions and a stretch filter measured in ATR units relative to a baseline EMA. Signals are gated by a confidence threshold and a cooldown period to reduce repetitive prints. This makes the indicator useful as a regime driven reversal framework that integrates: State probabilities and confidence Regime score and momentum flip ATR based stretch extremes Peak fade rotation logic Clean visual markers and dashboard transparency 🔹 Features 🔸 1) Three Regime Model The script uses three explicit regimes with distinct roles: Bull Expansion, intended to represent positive drift conditions Balance, intended to represent neutral or mixed drift Bear Stress, intended to represent negative drift and higher stress conditions Each regime has its own mean and variance assumptions for return and volatility, which are then adapted online. 🔸 2) Two Dimensional Observation System (Return and Volatility) The model does not rely on only returns. It uses both: A normalized return feature A normalized volatility feature This helps distinguish clean bullish trends from choppy balance periods, and balance periods from bearish stress regimes. 🔸 3) Transition Matrix with Persistence Controls Users can control how sticky each regime is through persistence settings: Bull persistence Balance persistence Bear persistence The transition matrix is constructed so that most probability remains in the same regime, while the remainder flows into other regimes using asymmetric weights that reflect realistic behavior. 🔸 4) Real Time Bayesian Filter Update Each bar, the model performs: Prediction step using the transition matrix Update step using Gaussian emissions Posterior normalization Active state selection by arg max This produces a smooth probability based regime tracker suitable for live use. 🔸 5) Adaptation After filtering, the model adapts its internal means and variances using a learning rate scaled by posterior responsibility. This allows the state distributions to slowly adjust to changing market conditions without full retraining. This keeps the indicator responsive while still stable. 🔸 6) Regime Score Output The main score line is: Bull posterior minus Bear posterior This produces a continuous signal that ranges between negative and positive values and functions as a regime tilt meter. A confidence ribbon is also plotted as an area band derived from the dominant posterior. 🔸 7) Confidence Gating and Visual Strength Confidence is defined as the largest posterior probability among the three regimes. The script uses confidence to: Gate reversal signals Determine bar tint transparency when bar coloring is enabled Decide whether state shift tags should be printed This reduces noise during low clarity periods. 🔸 8) Rotation Style Reversal Engine The reversal finder is built on rotation logic: A top rotation occurs after a Bull probability peak fades while Bear probability begins to rise A bottom rotation occurs after a Bear probability peak fades while Bull probability begins to rise This is a probabilistic rotation concept rather than a simple oscillator crossover. 🔸 9) Momentum Flip Confirmation Signals require momentum confirmation through: Regime score change direction Return observation crossing a flip threshold This is designed to reduce premature top and bottom calls when the regime probabilities shift but price momentum has not actually flipped. 🔸 10) ATR Based Stretch Filter The script computes stretch as distance from an EMA baseline measured in ATR units. Signals require: Top signals only when stretch is above a positive threshold Bottom signals only when stretch is below a negative threshold This ensures reversal signals occur when price is extended, not when it is near equilibrium. 🔸 11) Cooldown Control A cooldown setting prevents consecutive buy or sell reversal signals from printing too frequently. This is especially useful when the market chops around an extreme and repeatedly triggers partial rotation conditions. 🔸 12) Dashboard Panel A table dashboard displays key information on the last bar: Active state name Confidence Return z score and volatility z score Regime score Posterior probabilities Stretch in ATR units Current setup text such as BUY REVERSAL, SELL REVERSAL, TOP WATCH, BOTTOM WATCH, WAIT This makes the indicator transparent and easy to interpret. 🔸 13) State Tags and Reversal Labels on Chart When enabled, the script prints: State tags such as BULL, BASE, BEAR with arrows Reversal markers with a vertical guide line and bold letter B or S Tooltips include confidence, peak probability, stretch, and current posterior probabilities. 🔸 14) Optional Probability Curves and Bar Coloring Users can toggle: State probability plots Signal markers and dots Dashboard visibility State tag visibility Bar coloring by regime with confidence adjusted transparency This makes the indicator adaptable for minimalist or fully informational workflows. 🔹 Calculations 1) Return Observation Construction The script uses log returns: float logReturn = math.log(close / nz(close , close)) It smooths return with an EMA: float smoothedReturn = ta.ema(logReturn, returnSmoothLength) Then normalizes by the return standard deviation: float returnStdev = math.max(nz(ta.stdev(logReturn, returnZLength), EPS), EPS) float returnObs = clampFloat(smoothedReturn / returnStdev, -obsClamp, obsClamp) Interpretation: Return observation is a clamped z score like feature, where positive values represent bullish return pressure and negative values represent bearish return pressure. 2) Volatility Observation Construction Realized volatility is measured as the standard deviation of log returns: float realizedVol = nz(ta.stdev(logReturn, volLength), EPS) Then it is normalized relative to a baseline EMA and baseline standard deviation: float volMean = nz(ta.ema(realizedVol, volBaselineLength), realizedVol) float volStdev = math.max(nz(ta.stdev(realizedVol, volBaselineLength), EPS), EPS) float volObs = clampFloat((realizedVol - volMean) / volStdev, -obsClamp, obsClamp) Interpretation: Volatility observation is a clamped z score like feature, where higher values indicate volatility expansion relative to baseline. 3) Warmup Logic The model waits for enough history to compute stable normalized observations: int warmupBars = math.max(returnZLength, volBaselineLength) + volLength bool ready = bar_index > warmupBars and not na(returnObs) and not na(volObs) Before ready, the script avoids producing live signals and uses the initial posterior distribution. 4) Transition Matrix Configuration The transition matrix uses persistence values and asymmetric drift splits: From Bull, most drift flows to Balance and a smaller portion to Bear From Bear, most drift flows to Balance and a smaller portion to Bull From Balance, drift splits evenly between Bull and Bear Core setup: this.setTransition(STATE_BULL, STATE_BALANCE, bullDrift * 0.78) this.setTransition(STATE_BULL, STATE_BEAR, bullDrift * 0.22) ... this.setTransition(STATE_BEAR, STATE_BALANCE, bearDrift * 0.78) this.setTransition(STATE_BEAR, STATE_BULL, bearDrift * 0.22) This design makes Balance act like a bridge regime and reduces unrealistic direct flip frequency. 5) Emission Model: 2D Gaussian Density Each state computes an emission probability from return and volatility observations using a 2D Gaussian likelihood: float exponent = -0.5 * ((retDeviation * retDeviation) / retVariance + (volDeviation * volDeviation) / volVariance) float normalizer = 1.0 / (2.0 * math.pi * math.sqrt(retVariance * volVariance)) math.max(normalizer * math.exp(math.max(exponent, -24.0)), EPS) Variances are floored at 0.12 to prevent collapse. 6) Prediction Step The model predicts next probabilities using the transition matrix: predictedProbability += posterior * transition(fromState, toState) Then normalizes the predicted vector so it sums to 1. 7) Filter Update Step The posterior is updated by multiplying predicted probabilities by emission likelihoods: nextPosterior = predicted * emission(state, retObs, volObs) Then normalized. The active state is the arg max of the posterior. 8) Online Adaptation The model updates state means and variances using posterior responsibility times learning rate: float responsibility = posterior * learningRate Means update by moving toward the current observation: nextMuRet = oldMuRet + responsibility * retError nextMuVol = oldMuVol + responsibility * volError Variances update toward squared error: nextVarRet = oldVarRet + responsibility * (retError * retError - oldVarRet) nextVarVol = oldVarVol + responsibility * (volError * volError - oldVarVol) All parameters are clamped to stability ranges so the model does not explode. 9) Regime Score and Confidence Score is defined as: posterior - posterior Confidence is the maximum posterior: posterior These values drive visuals and signal gating. 10) Stretch Calculation in ATR Units Stretch uses an EMA basis of price and measures distance in ATR units: float basis = ta.ema(close, stretchLength) float atrValue = math.max(ta.atr(14), syminfo.mintick) float stretch = (close - basis) / atrValue Top stretch requires: stretch >= stretchThreshold Bottom stretch requires: stretch <= -stretchThreshold This ensures reversals occur when price is statistically extended relative to recent volatility. 11) Probability Peak and Fade Logic The script measures recent peaks for bull and bear probabilities: float bullPeak = ta.highest(bullProb , peakLookback) float bearPeak = ta.highest(bearProb , peakLookback) Fade is peak minus current: bullFade = bullPeak - bullProb bearFade = bearPeak - bearProb Top rotation condition requires: Bull peak above threshold Bull fade above minimum Bear probability rising Bottom rotation requires the mirrored conditions. This captures the idea of regime dominance peaking, then fading as the opposite side begins to regain influence. 12) Momentum Flip Confirmation Momentum down requires: Regime score decreasing Return observation strongly negative below a flip threshold Momentum up requires: Regime score increasing Return observation strongly positive above the flip threshold This prevents signals when probabilities fade but momentum remains neutral. 13) Signal Gating and Cooldown Signals require confidence above the threshold and a cooldown to avoid repeated triggers: confidenceValue >= confidenceThreshold bar_index - lastSignalBar > cooldownBars 14) Buy and Sell Reversal Signals Buy reversal: Bottom rotation Momentum up Bottom stretch Confidence filter Cooldown filter Sell reversal: Top rotation Momentum down Top stretch Confidence filter Cooldown filter A Balance signal is also triggered when the state changes to Balance with sufficient confidence. 15) Visual Outputs The indicator plots: Regime score line with area fill around zero Confidence ribbon as an area band Optional posterior curves for Bull, Balance, Bear Normalized stretch line scaled by the stretch threshold Optional dots on the chart for reversal events Optional bar coloring on the main chart It also prints: Reversal labels B and S with stretch, confidence, and peak probability tooltips State tags on regime shifts A dashboard panel summarizing live state and setup context
อินดิเคเตอร์ Pine Script®
โดย UAlgo
1
Momentum Lifecycle Detector [BullByte]Momentum Lifecycle Detector An early trend detection oscillator that tracks momentum through five lifecycle phases - from birth to death - using DI spread acceleration analysis . Designed to identify momentum ignition before traditional ADX signals, and warn of trend exhaustion before it becomes obvious. WHAT THIS INDICATOR DOES The Momentum Lifecycle Detector (MLD) is a momentum oscillator with integrated trend phase classification. It answers the question every trend trader needs answered: "Where in its life is this momentum right now?" Most trend strength indicators tell you a trend exists after the move is already underway. ADX crossing above 25 is a lagging confirmation. MLD solves this by detecting the birth of momentum at the earliest mathematically identifiable point, then tracking that momentum through five distinct lifecycle phases until it dies. The indicator displays: An ATR-normalized momentum oscillator (the main line you follow) A signal line for crossover analysis A histogram showing momentum-signal divergence A colored lifecycle band showing the current phase Consolidation zone boxes marking coiled energy before breakouts A reversal atmosphere glow when momentum curvature suggests reversal A dashboard summarizing momentum conditions at a glance Adaptive dead zone and choppy market warnings THE PROBLEM THIS SOLVES - WHY TRADERS NEED EARLY TREND DETECTION Traditional ADX tells you a trend is strong when it crosses above 25. By that point, the optimal entry window has often closed. Conversely, ADX gives no clear warning when a trend is dying - it just slowly rolls over after the move has already reversed. The core innovation in MLD is measuring the acceleration of the gap between +DI and -DI. Here is the mathematical logic: Spread = |+DI minus -DI| - How far apart are bullish and bearish pressure? Velocity = Spread minus Spread - Is that gap widening or narrowing? Acceleration = Velocity minus Velocity - Is the widening itself speeding up? When acceleration is positive and velocity is positive while ADX is still low, a new trend is actively forming. This is the mathematical fingerprint of momentum at birth - detectable bars before ADX would give any signal. WHY THESE SPECIFIC COMPONENTS - JUSTIFICATION FOR THE INTEGRATION This indicator combines several analytical methods into a unified lifecycle detection framework. Each component serves a specific, non-redundant purpose. Here is why each exists: Zero-Lag EMA Momentum Oscillator Purpose : The primary visual output traders watch and trade. Method : Difference between fast ZLEMA (default 9) and slow ZLEMA (default 21), divided by ATR, multiplied by 100. Why ZLEMA : Standard EMA lags behind price. ZLEMA compensates by adding the difference between the current price and its lagged value before smoothing. This produces earlier momentum readings without adding noise. Why ATR normalization: Raw price differences are not comparable across instruments. A 5-point move means something different on a $10 stock versus Bitcoin. Dividing by ATR makes oscillator readings universal - a reading of +50 represents the same relative momentum strength on any chart, any timeframe. Gaussian-Weighted Directional Indicators Purpose : Feed responsive directional data into the lifecycle detection engine. Method : Instead of standard Wilder smoothing for +DI and -DI, a Gaussian (bell-curve) decay function applies exponentially more weight to recent bars. The formula is exp(-(n/len)^2). Why Gaussian weighting : Standard DI treats all bars in the lookback equally. A directional move from 14 bars ago counts the same as one happening now. Gaussian decay makes DI inherently more responsive to fresh moves without shortening the period (which would increase noise). ZLEMA-Smoothed ADX Purpose : Trend strength measurement for phase classification. Method : DX calculated from Gaussian-weighted DI values, smoothed with ZLEMA instead of traditional Wilder smoothing. Why ZLEMA-smoothed: Standard Wilder-smoothed ADX is deliberately sluggish by design. For lifecycle detection, we need ADX that responds faster to "waking up" and "rolling over" behaviors that define phase transitions. DI Spread Acceleration Engine Purpose : The core innovation - detects momentum birth before ADX confirms. Method : Calculates the absolute spread between +DI and -DI, derives its velocity (first derivative) and acceleration (second derivative), smooths both with 3-period EMA. Why this matters: This is what differentiates MLD from existing ADX-based tools. Acceleration of the DI spread is a leading indicator. By the time ADX crosses a threshold, spread acceleration has already been positive for multiple bars. This enables IGNITION detection before traditional signals fire. Kaufman Efficiency Ratio Purpose : Regime filter that warns when conditions are choppy. Method : ER = net price movement divided by total price movement. Values near 1.0 mean efficient directional movement. Values near 0.0 mean price went back and forth without progress. Why included: Momentum oscillators generate false signals in ranging markets. When ER is low, ADX is weak, and momentum sits inside the dead zone, the background turns gray - warning traders that conditions do not support directional strategies. Momentum Curvature Analysis Purpose : Early warning of potential reversals via oscillator curvature. Method : Second derivative of momentum (how the slope is changing). When momentum is negative but curving upward (positive curvature with positive slope), bullish pressure is building from underneath before the trend visibly reverses. Strength is normalized against 30-bar standard deviation of curvature. Important : This is purely mathematical curvature of the plotted oscillator. It does not use order flow, volume profile, bid/ask data, or any external source. The term "atmosphere" is a visual metaphor for the glow effect. These components form an integrated pipeline - they are not independent indicators placed on the same pane. The oscillator provides visual momentum reading, Gaussian DI and ZLEMA ADX feed the lifecycle engine, spread acceleration detects phase transitions, ER provides regime context, and curvature adds reversal awareness. Each output feeds downstream components. THE FIVE LIFECYCLE PHASES - DETECTION LOGIC EXPLAINED The lifecycle band at the bottom displays one of five phases. Each has specific mathematical conditions that must all be true simultaneously. A state machine with configurable inertia prevents rapid flickering. IGNITION - Cyan Band Conditions : DI crossover within last N bars (default 4), spread acceleration above threshold (default 0.2), spread velocity above threshold (default 0.3), ADX rising for two consecutive bars. Meaning : Momentum is being born. DI lines just crossed, the gap is accelerating open, ADX is waking. This is the earliest actionable signal. ADX may still be below 20. State machine : IGNITION transitions instantly (1-bar inertia) because early detection speed matters. THRUST - Green or Red Band (direction-coded) Conditions : Past ignition window but within 3x that window, spread velocity above threshold (default 0.5), ADX surged more than threshold (default 1.5) over 3 bars. Meaning : Young trend gaining real power. Spread velocity is high, ADX is confirming with a surge. The trend is no longer hypothesis - it is building strength. State machine : THRUST transitions instantly. PRIME - Deeper Green or Red Band (direction-coded) Conditions : ADX above strong threshold (default 20), ADX either rising or above its signal line, DI spread above minimum (default 10). Meaning : Mature, established trend. Maximum directional strength. Most productive phase - but also where exhaustion can begin. Use trailing stops. State machine : Requires configured inertia (default 2 bars) before transition. FADING - Orange Band Conditions : ADX above strong threshold BUT falling AND below its signal line, OR ADX strong but spread velocity sharply negative (below -0.5). Meaning : Trend is dying. ADX rolling over, DI gap closing. Time to tighten stops, take partials, prepare for next cycle. State machine: Requires configured inertia before transition. DEAD - Dark Gray Band Conditions : None of the above active. Meaning : No meaningful directional momentum. Market ranging, consolidating, or in transition. Directional strategies unlikely to perform well. HOW TO READ THE OSCILLATOR PLOT Momentum Line (thick, color-coded) Bright green : Momentum positive and rising (bullish, strengthening) Faded green : Momentum positive but falling (bullish, weakening) Bright red: Momentum negative and falling (bearish, strengthening) Faded red : Momentum negative but rising (bearish, weakening) Gray : Momentum inside dead zone (noise, not signal) Signal Line (thin orange) EMA of momentum. Crossovers between momentum and signal highlight directional shifts, similar to MACD signal line usage. Momentum-Signal Fill (shaded area between the two lines) Teal shading: Momentum above signal (bullish bias) Maroon shading: Momentum below signal (bearish bias) This fill provides instant visual recognition of which line is dominant. Histogram (vertical columns at zero line) Shows the gap between momentum and signal. Bright columns: Gap expanding (momentum pulling away, trend strengthening) Faded columns: Gap contracting (momentum converging, trend weakening) Green: Momentum above signal. Red: Momentum below signal. Dead Zone (gray horizontal band around zero) Dynamically calculated as a multiple (default 0.5x) of momentum's 50-bar standard deviation. When momentum is inside this zone, directional signals are unreliable - the reading is within normal noise range. Zero Line (dotted horizontal) Momentum above zero: Net bullish pressure Momentum below zero: Net bearish pressure Zero line crosses represent directional bias shifts. CONSOLIDATION ZONES - COILED ENERGY BEFORE BREAKOUTS Yellow boxes appear on the oscillator when momentum energy is coiling - a potential precursor to a strong directional move. Detection Logic Two conditions must be simultaneously true: Histogram (momentum-signal gap) is unusually tight relative to its recent 50-bar standard deviation. Momentum slope is unusually flat relative to its recent 50-bar standard deviation. Both thresholds are adaptive - they automatically adjust to each instrument's typical behavior. This means the indicator detects relative consolidation, not absolute levels, making it equally effective on volatile crypto and stable bonds. Zone Lifecycle New zone starts as dotted-border, light yellow box. If it persists for minimum bar count (default 5), it upgrades to solid-border, brighter yellow - a validated zone. If momentum drifts too far from where zone started (exceeds drift tolerance relative to zone height), the zone is invalidated and deleted. This prevents slow trends from being falsely labeled as consolidation. When zone breaks (convergence conditions end), box color changes based on breakout direction: teal for bullish breakout, maroon for bearish breakout. Only one active zone exists at a time to keep the chart clean. How to Trade It Validated consolidation zones (solid border) represent coiled momentum. Breakouts from these zones, especially when accompanied by IGNITION or THRUST phase, often produce strong directional moves. The breakout color immediately tells you the direction. REVERSAL ATMOSPHERE - CURVATURE-BASED REVERSAL WARNING A soft colored glow appears around the momentum line when mathematical curvature suggests a reversal is forming. How It Works The indicator calculates the second derivative of momentum (curvature - how the slope itself is changing). Bullish reversal detection: Momentum is below zero (bearish), but slope has turned positive (rising), and curvature is positive (the rise is accelerating). This is the mathematical signature of a bottom forming - momentum is still negative but fighting back. Bearish reversal detection: Mirror image. Momentum is above zero, but slope is negative and curvature is negative. A top is forming. Visual Output Green glow: Bullish reversal pressure building Red glow: Bearish reversal pressure building Glow intensity increases with curvature strength, normalized against 30-bar standard deviation Glow width is configurable (default 8 units) Important Clarification This is purely mathematical analysis of the oscillator's own curvature. It does not incorporate order flow data, market depth, bid/ask spreads, or any external data source. The term "atmosphere" is a visual metaphor describing the glow effect, not a claim about market microstructure. CHOPPY MARKET BACKGROUND - REGIME WARNING When three conditions are all simultaneously true, the pane background turns gray: Efficiency Ratio below choppy threshold (default 0.30) ADX below choppy threshold (default 18) Momentum inside dead zone This gray background is a visual warning: "Market conditions are choppy. Momentum signals here are statistically less reliable. Consider waiting for cleaner conditions." DASHBOARD - THE MOMENTUM WEATHER REPORT A compact panel (position and size configurable) displaying five key readings: PHASE Current lifecycle phase name in corresponding color. Instantly shows where momentum is in its lifecycle. BIRTH DI spread acceleration status - is new momentum being created? ACCELERATING (cyan) : Strong positive acceleration, momentum actively being born BUILDING (green) : Moderate positive acceleration QUIET (gray): No significant acceleration DECELERATING (red): Negative acceleration, momentum creation slowing or reversing FLOW Directional bias with magnitude. BULL : Bullish DI dominance. Number is DI spread (gap between +DI and -DI) BEAR : Bearish DI dominance FLAT : Momentum in dead zone, no meaningful directional bias WEATHER Overall assessment combining phase and vitality. FAVORABLE (green): Active phase (IGNITION/THRUST/PRIME) with momentum outside dead zone. Conditions support directional trading. CAUTION (orange): FADING phase, or PRIME with negative spread velocity. Trend may be exhausting. UNFAVORABLE (red): DEAD phase or momentum in dead zone. Avoid directional strategies. PRESSURE Reversal pressure from curvature analysis. BULLISH REV (green): Strong bullish reversal curvature BEARISH REV (red): Strong bearish reversal curvature BUILDING (cyan): Moderate reversal curvature forming NONE (gray): No significant reversal pressure COMPLETE SETTINGS REFERENCE Core Momentum Oscillator Fast ZLEMA Length (default 9): Fast moving average responsiveness. Lower = faster, noisier. Slow ZLEMA Length (default 21): Baseline moving average. Gap between fast and slow produces momentum. Signal Line Length (default 5): Smoothing period for signal line. Momentum Smoothing (default 3): Additional noise reduction on raw momentum. ATR Period (default 14): Normalization period for cross-instrument comparability. Consolidation Zones Show Consolidation Zones (default true): Toggle zone detection. Histogram Sensitivity (default 1.0): How tight momentum-signal gap must be. Lower = stricter. Slope Sensitivity (default 1.0): How flat momentum must be. Lower = stricter. Minimum Bars (default 5): Shortest valid consolidation duration. Drift Tolerance (default 0.4): Maximum directional drift before zone invalidation. Regime Detection Efficiency Ratio Period (default 10): Lookback for price efficiency calculation. ER Smoothing (default 5): Smoothing to prevent rapid regime flipping. Trend Threshold (default 0.4): ER above this = trending market. Dead Zone Multiplier (default 0.5): Standard deviations defining the noise band. Choppy ER Threshold (default 0.30): ER below this contributes to choppy warning. Choppy ADX Threshold (default 18): ADX below this contributes to choppy warning. Momentum Lifecycle Show Lifecycle Band (default true): Toggle the colored phase band. DI Calculation Length (default 14): Period for Gaussian-weighted +DI/-DI. ADX Smoothing (default 14): ZLEMA smoothing on DX. ADX Signal Length (default 5): EMA of ADX for crossover detection. Ignition Window (default 4): Bars after DI cross qualifying for IGNITION. State Inertia (default 2): Bars a phase must persist before official transition. Ignition Accel Threshold (default 0.2): Minimum spread acceleration for IGNITION. Ignition Velocity Threshold (default 0.3): Minimum spread velocity for IGNITION. Thrust Velocity Threshold (default 0.5): Minimum spread velocity for THRUST. ADX Surge Threshold (default 1.5): Minimum ADX rise over 3 bars for THRUST. ADX Strong Threshold (default 20): ADX above this = strong trend (PRIME/FADING). DI Spread Minimum (default 10): Minimum DI gap for PRIME confirmation. Reversal Atmosphere Show Reversal Atmosphere (default true): Toggle the curvature glow effect. Glow Width (default 8): Visual width of atmospheric glow. Cosmetic only. Display Show Histogram (default true): Toggle momentum-signal histogram. Show Momentum-Signal Fill (default true): Toggle shaded area between lines. Show Choppy Background (default true): Toggle gray background warning. Dashboard Show Dashboard (default true): Toggle the weather report panel. Dashboard Position (default Top Right): Panel location on chart. Dashboard Size (default Small): Text size in panel. Alerts Alert on Ignition (default true): Notify when entering IGNITION phase. Alert on Fading (default true): Notify when entering FADING phase. Confirm on Bar Close (default true): Wait for bar close before firing alerts. Prevents false signals from intra-bar noise. ALERTS Two alert conditions target the most actionable lifecycle transitions: IGNITION Onset Fires when lifecycle enters IGNITION phase. Alert message includes directional bias (Bullish/Bearish), current ADX value, and how many bars since DI cross. FADING Onset Fires when lifecycle enters FADING phase. Alert message includes ADX value and current spread velocity. Bar Close Confirmation When enabled (default), alerts only fire after the bar closes. This prevents false alerts triggered by intra-bar price spikes that later reverse. Recommended to keep enabled for reliable signals. RECOMMENDED TIMEFRAMES AND INSTRUMENTS MLD works across all timeframes and instruments due to ATR normalization. Default settings optimized for: Daily and 4-hour charts. For lower timeframes (15m, 5m): Consider increasing Momentum Smoothing to 5 and State Inertia to 3 to filter noise. For weekly charts: Default settings work without adjustment. For highly volatile instruments (crypto, small caps): The adaptive thresholds automatically adjust. No manual tuning typically required. For low-volatility instruments (bonds, some forex pairs): Consider reducing Dead Zone Multiplier to 0.3 for more sensitivity. PRACTICAL EXAMPLE - MOMENTUM LIFECYCLE IN ACTION Consider a stock range-bound for weeks. ADX reads 12. Traditional trend tools show nothing actionable. Then +DI crosses above -DI. ADX is still 12. No traditional signal. But MLD detects that the DI spread is accelerating - the gap is not just opening, it is opening faster each bar. ADX has risen for two consecutive bars (waking up). The lifecycle band turns cyan: IGNITION. The dashboard shows BIRTH: ACCELERATING, WEATHER: FAVORABLE. Over the next few bars, spread velocity increases. ADX surges upward. The band turns green: THRUST. The trend is confirmed and building. ADX crosses above 20, continues rising, spread stays wide. Band turns deeper green: PRIME. This is the productive phase. Eventually ADX peaks, starts falling, drops below its signal line. Spread velocity turns negative. Band turns orange: FADING. Dashboard shows WEATHER: CAUTION. Time to trail stops tightly. ADX falls back below 20, momentum enters dead zone. Band turns gray: DEAD. The lifecycle is complete. The value: MLD flagged IGNITION several bars before ADX would have signaled anything. It flagged FADING while ADX was still technically strong but deteriorating. This is the early detection advantage. Chart Example 1: BTC/USDT 5-minute is showing a classic FADING lifecycle : a bullish thrust peaked around 13:00–14:00, entered a validated consolidation zone, and is now visibly breaking down. The momentum line is curving sharply downward inside the yellow box, the band is orange (FADING), and FLOW has flipped to BEAR 17.9 : confirming the consolidation resolved bearishly, not bullishly. The earlier cyan IGNITION flash (~14:30) failed to sustain, overwhelmed by the dominant fading structure. The dashboard reads WEATHER: CAUTION, PRESSURE: NONE : no reversal energy building yet. Chart Example 2: BTC/USDT 15-minute is in DEAD phase with WEATHER: UNFAVORABLE : no tradeable momentum present. The dashboard tells the complete story: FLOW is FLAT meaning neither bulls nor bears have directional control, and PRESSURE is NONE meaning no reversal energy is building beneath the surface either. Despite BIRTH showing ACCELERATING, without flow direction or reversal pressure to back it up, the acceleration has no confirmed destination yet. Stand aside and wait for the lifecycle band to shift out of DEAD before committing. WHAT MAKES THIS INDICATOR ORIGINAL The originality lies in three specific innovations not present in standard ADX/DI implementations or common momentum oscillators: DI Spread Acceleration Analysis Standard tools measure the DI spread itself or track ADX thresholds. MLD applies derivative analysis - velocity and acceleration - to the spread, transforming a traditionally lagging measurement into a leading indicator of trend formation. Gaussian-Weighted DI Calculation Standard DI uses Wilder smoothing with equal weight to all bars. Gaussian decay weighting makes DI inherently more responsive to recent directional moves without the noise penalty of shorter periods. Five-Phase Lifecycle Classification with Inertia-Gated State Machine Rather than binary trend/no-trend output, MLD maps momentum onto a lifecycle model with distinct phases and specific mathematical criteria. The state machine prevents flickering while allowing speed-critical states (IGNITION, THRUST) to transition immediately. These are integrated innovations, not independent indicators on the same pane. Each feeds into the lifecycle engine or provides context for its output. DISCLAIMER This indicator performs mathematical calculations on price data (open, high, low, close) only. It does not use order flow data, volume profile, market depth, bid/ask information, institutional positioning data, or any external data source. Terms like "momentum birth," "reversal atmosphere," "weather," and " lifecycle " are descriptive metaphors for mathematical concepts (derivatives, curvature, efficiency ratios, state classification). They are not claims about market microstructure or participant behavior. No indicator predicts future price movement. MLD identifies mathematical conditions historically associated with specific momentum behaviors. These conditions may or may not produce expected outcomes in any given instance. This tool supplements - it does not replace - a complete trading plan including risk management, position sizing, and multiple forms of analysis. Always use proper risk management. Past indicator behavior does not guarantee future results.
อินดิเคเตอร์ Pine Script®
โดย BullByte
8
VWAP Rejection + CISD AlertVWAP Rejection + CISD Alert — Full Backtest Table + Entry Time Window This powerful intraday ICT-style indicator automatically detects high-probability VWAP Rejection + CISD setups and gives you everything you need to trade them with precise risk management. Strategy Rules (all must align): VWAP Rejection: Candle body fully above VWAP (bullish) or below VWAP (bearish) with a wick touching VWAP. CISD Confirmation: Strong reversal candle after minimum consecutive opposite candles (default 2), breaking the prior high/low, and occurring within max bars after rejection (default 2). Extra Filters: CISD candle must open above VWAP (longs) or below VWAP (shorts). CISD candle must close above/below your chosen Moving Average (SMA/EMA/WMA/VWMA – fully adjustable). Entry: At the open of the very next candle after CISD confirmation. Stop Loss: Choose between: Open of the CISD candle (original) Extreme wick of the VWAP rejection candle (low for longs / high for shorts) Take Profit: User-defined multiplier (default 2R) from entry. Visuals & Tools: Small REJ↑ / REJ↓ labels on rejection candles Large lime/fuchsia CISD↑ / CISD↓ triangles on confirmation Detailed ENTRY LONG/SHORT labels showing exact Open, SL, and TP prices Horizontal lines (Entry dashed blue, SL red, TP green) starting at the CISD candle and automatically stopping when price hits SL or TP Yellow TP and Blue SL hit triangles marking exact exit candles Live Performance Table (top-right) showing: Total Trades Wins / Losses Win Rate % Current TP Multiplier Key Inputs: CISD Settings: Min consecutive candles, Max bars after rejection Risk Management: TP Multiplier, SL Placement (2 options) Moving Average Filter: Length + Type (SMA/EMA/WMA/VWMA) Time Filter: Entry Time Window (default 8:00–11:00 AM EST) Visual toggles for labels, lines, and CISD shapes Alerts: Set alerts on “CISD Confirmed → LONG Setup” or “SHORT Setup”. Alerts fire the moment the CISD candle closes — perfect timing to enter at the next open. Ideal for 1m–15m charts on indices, forex, and futures. Combines classic VWAP rejection with ICT CISD concepts plus strict filters for cleaner, higher-probability trades.
อินดิเคเตอร์ Pine Script®
โดย Resonant_Trader
Gann Fan [UAlgo]Gann Fan is a structure driven Gann angle overlay that automatically builds a multi line fan from the most relevant recent swing anchor on the chart. Instead of requiring manual drawing, the script detects pivot highs and pivot lows, selects an active anchor based on the latest structure, and projects a full set of classic Gann style ratios from that anchor point. The indicator runs directly on price and is designed to provide a clean visual map of potential dynamic support, resistance, and trend geometry. Once an anchor is chosen, the script draws a nine line fan that includes the key 1x1 line along with slower and faster angle ratios such as 1x8, 1x4, 1x3, 1x2, 2x1, 3x1, 4x1, and 8x1. These lines extend forward in time, creating a structured framework that traders can use for directional bias, reaction zones, and acceleration or deceleration analysis. A major strength of this implementation is that it is not just a static angle pack. The script first builds an alternating pivot structure, filters same side pivots so only the more extreme one is retained, then automatically determines whether the active fan should be bullish or bearish when Auto mode is enabled. It also adds optional visual enhancements such as glow effects, filled fan zones between adjacent angles, angle labels, and an anchor label. The result is a polished automatic Gann Fan tool focused on: Recent swing structure Auto or forced bullish / bearish direction Multi angle projection Visual zone segmentation Clean right side angle labeling 🔹 Features 🔸 1) Automatic Gann Fan Projection The script automatically draws a full Gann fan without requiring manual anchor placement. It detects recent pivots, determines the most relevant active anchor, and projects all fan angles from that point. This makes it useful for traders who want a repeatable, rules based Gann framework rather than hand drawn discretionary lines. 🔸 2) Pivot Based Structural Anchoring The fan is built from confirmed pivot highs and pivot lows using a configurable pivot strength setting. These pivots form the structural basis for the fan, so the projection adapts to actual swing development instead of arbitrary recent highs and lows. 🔸 3) Alternating Swing Logic for Cleaner Structure The script does not blindly store every pivot. It enforces an alternating sequence of highs and lows: If a new pivot is the same type as the most recent stored one, only the more extreme pivot is kept If it is the opposite type, it is appended normally This produces a cleaner swing map and avoids clutter from redundant same side pivots. 🔸 4) Auto, Bullish, or Bearish Fan Direction Users can choose: Auto mode Forced Bullish Forced Bearish In Auto mode, the script decides direction based on which pivot type occurred most recently. This makes the fan respond naturally to the latest structural context. 🔸 5) Full Nine Angle Set The indicator plots a broad set of classic Gann style ratios: 1x8 1x4 1x3 1x2 1x1 2x1 3x1 4x1 8x1 This creates a layered angle framework ranging from shallow to steep, with the 1x1 line visually emphasized as the main reference line. 🔸 6) Highlighted 1x1 Line The 1x1 line receives its own dedicated width and stands out from the rest of the fan. This makes it easier to focus on the central balance angle that many traders treat as the most important Gann reference. 🔸 7) Optional Glow Effect The script can render a wider translucent glow line beneath each fan line. This improves visibility, gives the fan a premium visual style, and helps the angle set stand out on busy charts. 🔸 8) Optional Fan Zones Between Angles When enabled, the script fills the space between adjacent fan lines to create alternating fan zones. These colored bands make it easier to visually read the space between angles as active directional sectors. This is especially useful when treating the fan as a dynamic channel structure rather than only a set of lines. 🔸 9) Right Side Angle Labels Each fan angle can be labeled on the right side using the actual ratio name, such as 1x1 or 4x1 . The label position is user adjustable through the label shift setting. This makes the fan immediately readable without needing to memorize line order. 🔸 10) Anchor Label Support The script can place an anchor label at the origin point of the active fan, showing whether the current projection is bullish or bearish. This helps confirm which structural direction is currently active. 🔸 11) Customizable Line and Label Styling Users can control: Base line width 1x1 line width Glow width Label size Label shift Zone visibility Glow visibility Anchor label visibility This makes the tool flexible for both minimalist and presentation focused layouts. 🔸 12) Structure Memory Control The Max Stored Pivots setting controls how many swing points remain in memory. This helps the script stay efficient while still maintaining enough structural context for reliable anchor selection. 🔹 Calculations 1) Pivot Detection The script identifies structural swing highs and lows using: float ph = ta.pivothigh(high, pivotLen, pivotLen) float pl = ta.pivotlow(low, pivotLen, pivotLen) A pivot is only confirmed after pivotLen bars on both sides, so the stored pivot index is aligned to the actual pivot bar: SwingPoint.new(bar_index - pivotLen, ph, true) SwingPoint.new(bar_index - pivotLen, pl, false) This ensures the fan anchor uses the true swing location, not the later confirmation bar. 2) Alternating Swing Storage The script maintains a swing array that enforces alternating highs and lows: if last.isHigh == candidate.isHigh bool moreExtreme = (candidate.isHigh and candidate.price >= last.price) or (not candidate.isHigh and candidate.price <= last.price) if moreExtreme points.set(n - 1, candidate) else points.push(candidate) Interpretation: If two consecutive pivots are both highs, only the higher high is kept. If two consecutive pivots are both lows, only the lower low is kept. This keeps the swing structure cleaner and more meaningful. 3) Auto Direction Logic In Auto mode, the script chooses bullish or bearish orientation based on which pivot type is most recent: bool autoBull = not lastLow.isNa() and (lastHigh.isNa() or lastLow.idx > lastHigh.idx) Interpretation: If the latest valid pivot is a low, the script favors a bullish fan. If the latest valid pivot is a high, the script favors a bearish fan. The final direction can still be overridden by the Fan Direction input. 4) Bullish Anchor Construction For a bullish fan, the script starts from the most recent low pivot: SwingPoint lastLow = swings.lastPivot(false) Then it looks for the most recent high pivot that occurred after that low: SwingPoint ctrlHigh = swings.lastPivotAfter(true, lastLow.idx) If such a high exists, it becomes the control point. If not, the script uses the current bar and current high: int x2 = ctrlHigh.isNa() ? bar_index : ctrlHigh.idx float y2 = ctrlHigh.isNa() ? high : ctrlHigh.price So the bullish fan is anchored from the latest significant low toward the next available structural high, or toward the live chart if that swing is still developing. 5) Bearish Anchor Construction For a bearish fan, the script starts from the most recent high pivot: SwingPoint lastHigh = swings.lastPivot(true) Then it looks for the most recent low pivot that occurred after that high: SwingPoint ctrlLow = swings.lastPivotAfter(false, lastHigh.idx) If none is found yet, the script falls back to the current bar and current low: int x2 = ctrlLow.isNa() ? bar_index : ctrlLow.idx float y2 = ctrlLow.isNa() ? low : ctrlLow.price So the bearish fan projects from the latest significant high toward the next structural low, or toward the live chart while the move is still unfolding. 6) Base Slope Calculation Once the anchor is defined, the script computes the base slope between anchor point 1 and point 2: (anchor.p2 - anchor.p1) / (anchor.idx2 - anchor.idx1) This base slope is the reference slope used for the 1x1 line before applying the fan ratios. 7) Gann Ratio Projection The script stores these ratios: array.from(0.125, 0.25, 0.333333, 0.5, 1.0, 2.0, 3.0, 4.0, 8.0) These correspond to: 1x8 1x4 1x3 1x2 1x1 2x1 3x1 4x1 8x1 For each ratio, the projected line value at any bar x is: anchor.p1 + m * ratio * (x - anchor.idx1) Where m is the base anchor slope. This means: Ratios below 1 create flatter angles than the base line Ratio 1 creates the 1x1 line Ratios above 1 create steeper angles than the base line 8) 1x1 Emphasis The script gives the 1x1 line special treatment: It uses mainLineWidth instead of baseLineWidth Its glow can also be slightly wider than the other lines This makes the central balance angle the visually dominant line in the fan. 9) Line Drawing and Extension Each fan line is drawn from the anchor origin to the control index, then extended to the right: line.new( active.idx1, active.p1, active.idx2, y2, xloc = xloc.bar_index, extend = extend.right, ... ) This means the visible geometry is anchored in actual structure, but the line continues into the future as a projected guide. 10) Glow Layer Logic If glow is enabled, the script first draws a wider translucent line underneath the main line: line.new(... color = glowColor, width = gWidth) Then it draws the normal fan line on top. This creates a soft highlight effect without changing the underlying geometry. 11) Angle Label Placement If labels are enabled, the script places each label at a future bar location: int xLabel = math.min(bar_index + labelShiftBars, bar_index + 500) float yLabel = active.priceAt(ratio, xLabel) This means the label stays attached to the correct projected fan angle while remaining offset from the live candles for readability. 12) Fan Zone Fill Logic When zone fill is enabled, the script creates a fill between each adjacent pair of fan lines: linefill.new(l1, l2, zoneColor) The fill transparency alternates slightly from one band to the next: int zoneAlpha = i % 2 == 0 ? 91 : 95 This creates subtle separation between fan sectors and improves visual depth. 13) Anchor Label Logic If enabled, the script prints a label at the anchor origin: string dirText = active.bullish ? "Bullish Gann Fan" : "Bearish Gann Fan" This provides immediate confirmation of which structural direction is currently driving the fan.
อินดิเคเตอร์ Pine Script®
โดย UAlgo
1
Liquidity Sweep Rider Institutional HFT Grabber Liquidity Sweep Rider Strategy (Swing Pivot + Volume Filter) Publication Description: This is an open-source Pine Script v6 strategy that identifies potential liquidity sweep patterns around confirmed swing highs and lows. It uses: Pivot points (ta.pivothigh / ta.pivotlow) to mark historical swing levels where orders (such as stops or pending entries) often cluster. A volume filter requiring above-average volume (SMA-based with multiplier) on the sweep candle to highlight stronger moves. Classic sweep logic: price wicks beyond the level but closes back inside, suggesting a possible reversal after liquidity is taken. Entry rules: Long: after a downside sweep below a recent swing low (with volume condition). Short: after an upside sweep above a recent swing high (with volume condition). Features include: Optional toggles to enable/disable long/short directions. ATR-based stop-loss and take-profit (configurable multipliers and risk-reward ratio). Visual plots for liquidity levels, entry signals, background highlights, and an info table. Alert conditions for long/short triggers. Important notes: This is an educational/example script for backtesting and learning. Past performance does not indicate future results. Trading involves significant risk of loss — use proper risk management and never risk more than you can afford to lose. No guarantees of profitability are made. Always test thoroughly on demo accounts before live use. Customize parameters (pivot lengths, volume multiplier, ATR settings) based on the instrument and timeframe you trade. Works on various markets/timeframes but performs differently depending on liquidity and volatility. Feel free to fork/modify the code. Feedback and improvements are welcome! (≈ 3–4 paragraphs, clear, educational, includes risk disclaimer, explains logic + usage without hype.)
กลยุทธ์ Pine Script®
โดย uzair2join
Hedge Model Pro Forex Volatility StructureThe Hedge Model is a structured Forex market indicator designed to identify compression, expansion, and controlled volatility shifts. This tool is built around structural behavior — not prediction. It highlights: • Compression zones • Expansion breaks • Structural shift points • Controlled execution areas • Defined visual trade mapping The model is designed for traders who prefer: ✔ Structured decision-making ✔ Risk-defined environments ✔ Clean chart visualization ✔ Repeatable execution logic This is not a signal spam indicator. This is a framework for understanding market structure. Works across major and cross Forex pairs on multiple timeframes. No repainting. No hindsight plotting. No curve fitting. Structured. Controlled. Consistent.
อินดิเคเตอร์ Pine Script®
โดย TruthakaWallStreetakaCookie2
1
AxMan Exhaustion Detection Reversal Rider1. The "Exhaustion" Phase (The Warning) The strategy first looks for a Yellow or Orange Diamond. This isn't a signal to buy yet; it’s a warning that the current trend is dying. The Logic: It looks for a massive spike in volume combined with an "over-extended" RSI. The Visual: Imagine a car slamming on its brakes at high speed. The tires smoke (Volume Spike), and the car skids (RSI Oversold). The Filter: This prevents you from entering a trade when the market is "boring" or slowly drifting. You only care about the moments of peak panic or peak euphoria. 2. The "Locked & Loaded" Window (The 12-Candle Rule) Once that "Exhaustion" diamond appears, the chart background changes color. The strategy is now hunting for a trade. The Logic: It gives the market exactly 12 candles to prove it can reverse. Why 12? If the market doesn't reverse within 12 candles, the "exhaustion" was just a pause, and the old trend is likely to continue. This rule keeps you out of "dead zones" where the price just goes sideways. 3. The "Trigger" (The Fast Entry) This is where the strategy beats traditional indicators. It doesn't wait for a fancy moving average crossover. The Logic: As soon as a candle closes above the high of the previous candle (for a Long) or below the low (for a Short), it enters. The Goal: It gets you in at the absolute "bend" of the trend. By the time most traders see a trend change, this strategy is already in profit. 4. The "Ride" (The Exit) This strategy is not about "scalping" small profits. It is designed to stay in the trade as long as the trend is healthy. The Exit Rule: It only closes the trade if: Opposite Exhaustion: It sees the same "panic" signal happening on the other side (The Target). Trend Break: The price closes on the wrong side of the 50 EMA (The Safety Net). The Result: This allows you to "Ride the Wave" during massive moon-shots or market crashes, often staying in a single trade for days on the 4H chart. Why It’s "Adaptive" Because it uses standard deviations for volume and previous candle breaks for entry, it behaves correctly whether you are looking at a 15-minute chart (fast day trading) or a Daily chart (long-term investing). It scales its "expectations" based on the timeframe you choose. Summary in one sentence: "We wait for the sellers to get exhausted, wait for the buyers to step in and break one high, and then we hold until the buyers get tired too."
กลยุทธ์ Pine Script®
โดย Axj_Stev
Malaysian SnR Levels [UAlgo]Malaysian SnR Levels is a structure based support and resistance overlay that automatically plots three level types on the chart: A-Levels, which act as resistance V-Levels, which act as support Gap Levels, which mark qualifying candle to candle price gaps The script is built for traders who want clean horizontal reference levels that stay active until price decisively crosses through them. Instead of drawing every pivot forever, the indicator manages each level as a stateful object with freshness and activity tracking. A newly created level begins as fresh , becomes unfresh after its first wick interaction, and remains active until price fully crosses through it. Once broken, the level stops extending and is archived on the chart. A major strength of this implementation is its optional multi timeframe workflow. You can leave the timeframe input empty to detect levels on the current chart, or select a higher timeframe to project higher timeframe A, V, and Gap levels onto a lower timeframe execution chart. This makes the script useful for both local chart structure and top down level mapping. The result is a practical support and resistance engine focused on: Pivot based resistance and support Gap based structural levels Fresh versus unfresh state tracking Automatic break detection Optional MTF level projection 🔹 Features 🔸 1) Automatic A-Levels and V-Levels The script detects pivot highs and pivot lows and converts them into horizontal support and resistance levels: A-Levels come from confirmed pivot highs and behave as resistance V-Levels come from confirmed pivot lows and behave as support These are built from pivot calculations on close , not on raw high and low extremes, which gives the levels a close based structural character. 🔸 2) Automatic Gap Levels In addition to pivots, the script detects directional gap style levels when two consecutive candles move in the same direction and the open to prior close gap exceeds a minimum tick distance. Bullish gap logic creates a gap level at the previous close. Bearish gap logic also creates a gap level at the previous close. This gives the indicator a third structural layer beyond classic pivot based support and resistance. 🔸 3) Fresh and Unfresh State Tracking Every new level starts as fresh . A fresh level is considered untouched. Once price interacts with the level by wick, it becomes unfresh : The line style changes to dashed The width becomes thinner The color shifts to the unfresh color theme This helps traders quickly distinguish untouched levels from levels that have already been tested. 🔸 4) Active Until Full Break A level stays active until price crosses through it. Once broken, the level: Stops extending Fixes its endpoint at the break time Keeps the historical line visible Stops updating as an active level This is useful because old levels remain visible for review, while current active levels continue projecting forward. 🔸 5) Multi Timeframe Detection (Optional) The script supports a selectable detection timeframe: Leave it empty to use the current chart timeframe Set it to a higher timeframe to project higher timeframe levels onto the current chart This is especially useful when traders want to execute on a lower timeframe while respecting higher timeframe structure. 🔸 6) Minimum Gap Filter in Ticks Gap levels are filtered by a configurable minimum distance in ticks. This avoids plotting tiny micro gaps and helps keep only more meaningful dislocations. 🔸 7) Duplicate Level Protection Before adding a new level, the script checks whether an active level already exists near the same price. If another active level is within a small tick range, the new one is skipped. This reduces clutter and prevents nearly identical levels from stacking on top of each other. 🔸 8) Separate Visibility Controls Users can independently choose whether to display: A-Levels V-Levels Gap Levels This makes the tool adaptable for different workflows, such as only plotting pivot levels or only monitoring gap structure. 🔸 9) Full Visual Customization The script provides separate color controls for: Fresh A-Levels Unfresh A-Levels Fresh V-Levels Unfresh V-Levels Fresh Gap Levels Unfresh Gap Levels It also allows customization of: Fresh line width Unfresh line width Label size This makes it easy to fit the indicator into different chart styles. 🔸 10) Label Projection to the Right Each active level includes a compact label showing its type: A V Gap The label is automatically pushed several time steps to the right of current price so it stays readable and aligned with the level. 🔸 11) Automatic Level Count Management The script keeps the number of stored levels under control using a maximum active limit. When capacity is exceeded, it tries to remove an older inactive level first. This helps maintain chart cleanliness and stay within TradingView object limits. 🔹 Calculations 1) Pivot Based A-Level and V-Level Detection The script calculates pivots using close, not high or low: float ph = ta.pivothigh(close, pivotLength, pivotLength) float pl = ta.pivotlow(close, pivotLength, pivotLength) Interpretation: A-Level = confirmed close based pivot high V-Level = confirmed close based pivot low Because pivot confirmation requires bars on both sides, the level time is aligned to the true pivot bar using: int ph_t = not na(ph) ? time : na int pl_t = not na(pl) ? time : na 2) Gap Level Detection Logic The script defines bullish and bearish gap conditions using consecutive candles in the same direction plus a minimum gap size measured in ticks. Bullish gap: bool bullishGap = prevBullish and isBullish and (open - close ) >= syminfo.mintick * minGapTicks Bearish gap: bool bearishGap = prevBearish and isBearish and (close - open) >= syminfo.mintick * minGapTicks If either condition is true, the gap level is set at: gap_price := close So the reference price for the gap level is the previous candle’s close. 3) Multi Timeframe Data Selection The script computes levels in a helper function and can either use: Local chart data directly Or higher timeframe data through request.security = request.security(...) If the timeframe input is empty, local values are used. Otherwise, the security values are used: float ph = tf == "" ? loc_ph : sec_ph This gives flexible MTF projection while keeping one consistent logic engine. 4) New Level Event Detection To prevent the same pivot or gap from being added multiple times, the script checks whether the timestamp of the detected event changed: bool new_ph = not na(ph_t) and ph_t != nz(ph_t ) bool new_pl = not na(pl_t) and pl_t != nz(pl_t ) bool new_gap = not na(gap_t) and gap_t != nz(gap_t ) This is an important implementation detail because it avoids a common Pine issue where na != na can propagate as na and block reliable detection. 5) Level Creation and Duplicate Protection Before a new level is added, the script checks existing active levels and rejects duplicates that are too close: if lvl.isActive and math.abs(lvl.price - p) < syminfo.mintick * 10 exists := true This means levels within 10 ticks of an existing active level are treated as duplicates and not added. 6) Level Initialization When a level is created, it starts as: Fresh = true Active = true A line is drawn from the source time and extended to the right: line.new(st, p, st + timeStep, p, xloc=xloc.bar_time, color=c, width=lineWidthFresh, extend=extend.right) A label is also created and placed several time steps to the right: label.new(cur_time + timeStep * 5, p, t, ...) This keeps the label visually separated from the current candle. 7) Fresh to Unfresh Transition Logic A level becomes unfresh when price first touches it by wick while the level is still active. For A-Levels: touchedWick := h >= this.price For V-Levels: touchedWick := l <= this.price For Gap levels: touchedWick := h >= this.price and l <= this.price Once touched: The level remains active isFresh becomes false The line becomes dashed The width changes to the unfresh width The line and label colors switch to the unfresh palette This means a wick touch weakens the level visually, but does not break it. 8) Break / Deactivation Logic A level becomes inactive only when price crosses through it, not merely when it is touched. Cross up condition: bool crossedUp = (o <= this.price and c > this.price) or (c_prev < this.price and c > this.price) Cross down condition: bool crossedDown = (o >= this.price and c < this.price) or (c_prev > this.price and c < this.price) If either is true: this.isActive := false this.lvlLine.set_x2(curTime) this.lvlLine.set_extend(extend.none) this.lvlLabel.set_x(curTime) Interpretation: The level stops projecting and is fixed at the break time. 9) Time Step Handling The script uses the current bar’s time distance to position and extend labels: int timeStep = bar_index > 0 ? time - time : 60000 This is important because the script uses xloc.bar_time , so horizontal positioning is time based rather than bar index based. 10) Maximum Level Management When the array exceeds the user defined maximum, the script tries to remove an inactive level first: if this.size() > maxLevels int removeIdx = 0 for i = 0 to this.size() - 1 SnRLevel lvl = this.get(i) if not lvl.isActive removeIdx := i break Then it deletes that level’s line and label. Important implementation note: If no inactive level is found, removeIdx remains 0, so the oldest level in the array is removed. 11) A-Level, V-Level, and Gap Interpretation In this script: A-Levels are close based pivot highs and function like resistance V-Levels are close based pivot lows and function like support Gap Levels are prior close reference levels from qualifying directional gaps All three share the same lifecycle framework: Fresh Unfresh after wick touch Inactive after a full cross through
อินดิเคเตอร์ Pine Script®
โดย UAlgo
3
KDE Reversals [UAlgo]KDE Reversals is a statistical reversal oscillator that measures where the current price sits inside its recent distribution using a Kernel Density Estimation based cumulative probability model. Instead of relying on fixed momentum formulas or classic overbought and oversold oscillators, the script builds a rolling sample of recent source values, estimates a smoothed empirical distribution, and converts the current value into a percentile style reading from 0 to 100. The result is a non parametric probability oscillator that answers a simple question: how extreme is the current price relative to the recent sample? Very high readings mean the current value is located near the upper tail of the recent distribution. Very low readings mean it is near the lower tail. The script then uses user defined upper and lower reversal zones to detect potential turning points when the percentile reading exits those extreme regions. The indicator runs in a separate pane ( overlay=false ) and combines: A rolling KDE based empirical CDF oscillator Upper and lower statistical reversal zones Gradient coloring based on percentile position Background highlighting in extreme conditions Optional reversal labels when the percentile exits an extreme zone This makes the tool especially useful for traders who want a more distribution aware approach to reversal detection rather than a fixed oscillator threshold based only on momentum formulas. Educational tool only. Not financial advice. 🔹 Features 🔸 1) KDE Based Empirical CDF Oscillator The core output of the script is a percentile style oscillator built from Kernel Density Estimation. It estimates the cumulative distribution position of the current source value relative to a rolling lookback sample and expresses that result as a percentage from 0 to 100. This gives a probabilistic location measure rather than a raw momentum reading. 🔸 2) Rolling Lookback Distribution Model The script stores a rolling window of recent source values in an internal array. As new bars arrive, the oldest values are removed once the array reaches the configured length. This keeps the distribution adaptive to recent market behavior. Because the model is rolling, the oscillator can adjust as the market shifts from one regime to another. 🔸 3) Non Parametric Reversal Logic Unlike indicators that assume a fixed normal distribution of prices, this script uses a kernel smoothed empirical distribution. That means the reversal zones are based on the actual recent sample shape, not a rigid assumption about how price should be distributed. This can make the signal more responsive to skewed, compressed, or uneven recent market structure. 🔸 4) Custom Upper and Lower Reversal Zones Users can define: An upper reversal zone in percentile terms A lower reversal zone in percentile terms These thresholds determine what counts as statistically stretched relative to the recent sample. This allows the indicator to be tuned for more aggressive or more selective reversal detection. 🔸 5) Reversal Triggers on Exit from Extremes The script does not trigger simply because the oscillator enters an extreme zone. Instead, it triggers when the percentile reading exits the extreme zone: A sell trigger occurs when the oscillator crosses back below the upper threshold A buy trigger occurs when the oscillator crosses back above the lower threshold This design aims to catch reversal confirmation after an extreme condition begins to unwind. 🔸 6) Dynamic Gradient Coloring The percentile line is colored with a gradient between bullish and bearish colors based on its position between the lower and upper thresholds. This makes it easy to identify whether the current reading is leaning toward lower tail, neutral, or upper tail conditions. 🔸 7) Upper and Lower Zone Fills The script includes gradient fills above and below the midline so the oscillator visually emphasizes upper tail and lower tail behavior. This improves readability and helps the user quickly identify whether the current reading is operating in a statistically stretched region. 🔸 8) Extreme Zone Background Highlighting When the oscillator is above the upper threshold or below the lower threshold, the pane background is lightly highlighted. This creates an immediate visual cue that the current reading is inside a high probability reversal watch zone. 🔸 9) Optional Reversal Labels When enabled, the script prints: A downward label after a bearish reversal trigger An upward label after a bullish reversal trigger These labels are intentionally simple and keep the pane clean while still marking the event clearly. 🔸 10) Flexible Source Selection The user can choose which source series to analyze, not only close. This allows the KDE engine to be applied to other price derived series if desired. 🔹 Calculations 1) Rolling Data Queue The script stores recent source values in a custom KDEData object: type KDEData array prices int length Each bar, the new value is pushed into the array: this.prices.push(val) if this.prices.size() > this.length this.prices.shift() This creates a fixed length rolling sample used for the KDE calculation. 2) Interquartile Range (IQR) Calculation To make the bandwidth estimate more robust, the script computes the interquartile range from a sorted copy of the rolling sample: int q1_idx = int(math.floor(n * 0.25)) int q3_idx = int(math.floor(n * 0.75)) sorted.get(q3_idx) - sorted.get(q1_idx) The IQR is later used as part of the spread estimate for kernel bandwidth selection. 3) Robust Spread Estimate The script combines sample standard deviation and IQR based scaling: float stdev = this.prices.stdev() float iqr = this.get_iqr() float spread = math.min(stdev, iqr / 1.34) Interpretation: iqr / 1.34 is a robust estimate of standard deviation under near normal assumptions. Taking the minimum of stdev and iqr / 1.34 helps reduce the effect of extreme outliers when setting the kernel width. If the spread collapses to zero, the script falls back to a very small positive value. 4) KDE Bandwidth Selection The kernel bandwidth is computed using a Silverman style rule: float h = 1.06 * spread * math.pow(n, -0.2) This gives the smoothing width used in the Gaussian kernel estimation. Larger sample size reduces the bandwidth, while larger spread increases it. If the calculated bandwidth is zero, the script forces a small fallback: if h == 0 h := 0.0001 5) Gaussian Error Function Approximation The script defines its own approximation of the error function: erf(float x) => ... This function is then used to build the standard normal cumulative distribution function: norm_cdf(float z) => float sqrt2 = math.sqrt(2) 0.5 * (1.0 + erf(z / sqrt2)) This is the mathematical core that converts standardized distances into cumulative probabilities. 6) KDE Based Empirical CDF Calculation For the current price, the script computes a smoothed empirical CDF by averaging the Gaussian CDF centered on every historical sample point: for i = 0 to n - 1 float xi = this.prices.get(i) float z = (current_price - xi) / h sum_prob += norm_cdf(z) Then: (sum_prob / n) * 100.0 Interpretation: Each historical observation contributes a smooth cumulative probability curve. Averaging them creates a KDE smoothed empirical percentile estimate for the current price. This is more stable than a raw rank percentile because it smooths the distribution instead of using hard cutoffs only. 7) Warm Up Condition The indicator only computes the KDE percentile once the rolling sample is fully populated: if kde.prices.size() == lengthInput cdf_percent := kde.get_kde_cdf(srcInput) Before that, the output remains na , which prevents incomplete early calculations. 8) Oscillator Interpretation The resulting cdf_percent is a percentile style value: Near 0 means the current source is near the lower tail of the recent distribution Near 50 means it is near the middle of the recent distribution Near 100 means it is near the upper tail of the recent distribution This is not a momentum ratio. It is a location measure inside the recent smoothed distribution. 9) Threshold Logic The user defines: float upperThreshold = input.float(95.0, ...) float lowerThreshold = input.float(5.0, ...) These thresholds define statistically extreme regions. For example: A 95 reading means the source is near the top tail of the recent sample A 5 reading means the source is near the bottom tail 10) Reversal Trigger Conditions The script does not trigger on entry into the zone. It triggers when the oscillator exits the zone: Bearish reversal trigger: bool sellTrigger = ta.crossunder(cdf_percent, upperThreshold) Bullish reversal trigger: bool buyTrigger = ta.crossover(cdf_percent, lowerThreshold) Interpretation: A sell trigger means the percentile was above the upper threshold and then moved back below it. A buy trigger means the percentile was below the lower threshold and then moved back above it. This acts more like a reversion confirmation than an early warning. 11) Visual Gradient Line The main oscillator line color is derived from its current percentile position: color cdfColor = color.from_gradient(cdf_percent, lowerThreshold, upperThreshold, col_bull, col_bear) This creates a smooth transition from bullish coloring in the lower reversal area toward bearish coloring in the upper reversal area. 12) Gradient Fill Zones The script fills the area between the percentile line and the hidden midline (50) separately for upper and lower halves: fill(p_cdf, p_mid, top_value=100, bottom_value=50, ...) fill(p_cdf, p_mid, top_value=50, bottom_value=0, ...) This gives the oscillator a cleaner and more informative visual structure than a plain line alone. 13) Background Highlighting When the oscillator is inside an extreme zone, the pane background is lightly shaded: bgcolor(cdf_percent >= upperThreshold ? ... : cdf_percent <= lowerThreshold ? ... : na) This does not trigger a signal by itself. It simply highlights that the reading is currently in a statistically extreme region. 14) Reversal Labels If labels are enabled, the script marks reversal exits with simple directional arrows: For bearish reversal: label.new(bar_index, cdf_percent + 3, "▼", ...) For bullish reversal: label.new(bar_index, cdf_percent - 3, "▲", ...) The labels are plotted near the oscillator value, not on price, which keeps the indicator self contained in its own pane.
อินดิเคเตอร์ Pine Script®
โดย UAlgo
Crowd Trap Engine (Exhaustion/Reversal) [Metrify]Crowd Trap Engine is designed to spot crowded / overextended market conditions where price may be running too hard in one direction and is more vulnerable to exhaustion, pause, or reversal. It combines multiple factors (trend, momentum, breakout behavior, volatility, volume pressure, and stretch from equilibrium) to detect when traders are likely piling in late. When a diamond appears, it signals a high probability that the market may “take a breath” (slow down, consolidate, or react) before continuing or changing direction. What this indicator is best used for Spotting possible exhaustion candles Avoiding late entries due to FOMO Adding context for reversal / pullback setups Confirming when price looks too extended Visuals Crowd Mark (diamond) = Exhaustion marker Bias Line = crowd pressure direction / equilibrium bias Cloud = dynamic trap zone / pressure range Note: Best used with market structure, support/resistance, and price action confirmation
อินดิเคเตอร์ Pine Script®
โดย Metrify
Ornstein-Uhlenbeck Mean Reversion Probability Bands [UAlgo]Ornstein-Uhlenbeck Mean Reversion Probability Bands is a statistical mean reversion indicator that models price as a mean reverting process and projects dynamic probability style zones around an estimated equilibrium mean. The script uses a rolling lookback of closing prices, fits an Ornstein-Uhlenbeck inspired parameter set from recent behavior, and then converts that estimate into inner and outer deviation bands around the current mean. The indicator runs directly on price ( overlay=true ) and is built to help traders identify when price is stretched away from its estimated equilibrium. Instead of using a fixed moving average and static standard deviation, the script attempts to infer a mean reverting structure from the data itself. It estimates the long term mean, the speed of reversion, and an equilibrium style dispersion measure, then plots two upside and two downside mean reversion zones. When price pushes into the upper or lower band regions, the script calculates a standardized distance from the estimated mean and displays a probability style label with both the percentage score and the current z score. This gives the user a quick visual read of how statistically extended price is relative to the model. A key strength of this script is that it combines: A rolling Ornstein-Uhlenbeck style parameter estimation Adaptive mean reversion zones Probability style stretch labels at band events A clean overlay presentation with visible upper and lower probability regions Important note: The percentage label in this script is a normal distribution coverage style score derived from the current z score. It is best understood as a probabilistic stretch measure, not a literal exact OU first passage probability. 🔹 Features 🔸 1) Ornstein-Uhlenbeck Inspired Mean Reversion Model The script estimates a mean reverting process from recent closing prices instead of relying only on a moving average. It uses a rolling regression style approach on consecutive price observations, then converts those estimates into Ornstein-Uhlenbeck style parameters. This makes the indicator more model driven than a standard band tool. 🔸 2) Rolling Adaptive Mean Line The central mean line is not a fixed average only. It is the estimated equilibrium level ( mu ) of the fitted process. As the rolling price sample changes, the model updates and the mean shifts with changing market structure. The mean line also changes color depending on whether current price is above or below that estimated equilibrium. 🔸 3) Dual Mean Reversion Zones (Inner and Outer) The script builds two sets of reversion bands around the mean: Inner bands using the inner multiplier Outer bands using the outer multiplier This creates a layered framework where the inner zone marks an early stretch area and the outer zone marks a more extreme statistical extension. 🔸 4) Probability Style Stretch Labels When price crosses into the upper or lower band regions, the script calculates a z score based on current distance from the estimated mean and converts it into a percentage style probability score. The label shows: A directional marker The probability style percentage The current z score This gives the user both a visual event trigger and a numeric measure of extension. 🔸 5) Visual Zone Based Design The indicator uses filled upper and lower zones rather than emphasizing the band lines themselves. This creates a cleaner chart display where the mean line stays visible and the stretch regions are highlighted as colored areas above and below it. This makes the indicator easy to read during fast chart scanning. 🔸 6) Configurable Lookback, Time Step, and Band Width Users can customize: The rolling lookback period used for model estimation The time step parameter ( dt ) used in OU conversion The inner band multiplier The outer band multiplier This makes the script adaptable to different timeframes, instruments, and preferred sensitivity levels. 🔸 7) Built In Estimation Safeguards The parameter estimation logic includes fallback protections. If the inferred model parameters are unstable or unrealistic, the script falls back to simpler sample statistics. This helps prevent unusable outputs during difficult market regimes or low quality fits. 🔸 8) Directional Touch Event Logic The script tracks both upper side and lower side band interaction: Upper side events can signal statistically stretched bullish price movement Lower side events can signal statistically stretched bearish price movement Labels are only created on crossing events, which helps reduce repeated prints while price remains outside the band. 🔹 Calculations 1) Rolling Price Queue Management The script stores recent closing prices in an array with a fixed maximum length: price_array.update_queue(close, length_input) The queue update method behaves differently depending on bar state: On a new bar, it pushes the latest value On an updating live bar, it overwrites the last stored value This keeps the rolling sample aligned with the current chart state without duplicating the active bar. 2) Fallback Mean and Dispersion Estimates Before attempting the OU style fit, the script calculates simple fallback values: float fallback_mu = src_array.avg() float fallback_sigma = src_array.stdev() These act as safety defaults if the regression based OU estimate is not reliable. Important note: In this script, fallback_sigma is a simple sample standard deviation of price levels, not return volatility. 3) AR(1) Style Regression on Consecutive Prices The model estimation is built from consecutive price pairs: x = price y = price The script computes: Mean of x Mean of y Covariance between x and y Variance of x Then it estimates: float b = sum_cov / sum_var_x This creates an AR(1) style coefficient that is later translated into OU style parameters. 4) Conversion from AR(1) Form to OU Style Parameters If the estimated b is within a valid range: if b > 0.05 and b < 0.95 the script computes: float a = mean_y - b * mean_x float mu_exact = a / (1.0 - b) float theta_exact = -math.log(b) / dt Interpretation: mu_exact is the estimated long run mean. theta_exact is the implied mean reversion speed. The conversion assumes the AR(1) relation is a discrete time representation of a mean reverting process. 5) Residual Variance and Equilibrium Dispersion The script next measures residual error from the AR(1) fit: float err = y_i - (a + b * x_i) float var_err = sum_err_sq / (n - 1) Then it converts that residual variance into an equilibrium variance estimate: float var_eq = var_err / (1.0 - b * b) Finally: float calc_sigma = math.sqrt(var_eq) Important implementation note: The variable named sigma in this script is used as an equilibrium style standard deviation around the mean, not as the continuous time OU diffusion coefficient from the SDE form. 6) Stability Filter for the Estimated Sigma Even if the AR(1) fit is mathematically valid, the script only accepts the calculated sigma when it is reasonably close to the fallback sample standard deviation: if calc_sigma < fallback_sigma * 1.5 and calc_sigma > fallback_sigma * 0.5 If this test fails, the script keeps the fallback values instead. This helps avoid unstable band widths caused by bad short term fits. 7) Final Parameter Output The estimation method returns: OU_Params.new(theta, mu, sigma_eq) Where: theta is the estimated reversion speed mu is the estimated equilibrium mean sigma_eq is the accepted equilibrium dispersion measure These parameters are then used to build the bands. 8) Band Construction The script computes four band levels around the estimated mean: float up_out = mean_val + (dev_val * mult_outer) float up_in = mean_val + (dev_val * mult_inner) float dn_in = mean_val - (dev_val * mult_inner) float dn_out = mean_val - (dev_val * mult_outer) Interpretation: Inner bands represent a milder deviation from the mean. Outer bands represent a more extreme deviation from the mean. 9) Mean and Zone Visualization The mean line is explicitly plotted: p_mean = plot(ou_bands.mean, color=color_mean, linewidth=2, title="Mean") The inner and outer band plots are also created, but their colors are fully transparent: color color_inner_up = color.new(#ffb74d, 100) color color_outer_up = color.new(#ef5350, 100) ... This means the visible structure mainly comes from the zone fills: fill(p_ui, p_uo, ...) fill(p_li, p_lo, ...) So the user sees clean upper and lower probability zones rather than several bright boundary lines. 10) Touch and Crossing Logic The script first checks whether price is currently inside a stretch area: bool touch_upper = close >= ou_bands.upper_inner bool touch_lower = close <= ou_bands.lower_inner Then it checks for fresh crossings: bool cross_up_in = ta.crossover(close, ou_bands.upper_inner) bool cross_up_out = ta.crossover(close, ou_bands.upper_outer) bool cross_dn_in = ta.crossunder(close, ou_bands.lower_inner) bool cross_dn_out = ta.crossunder(close, ou_bands.lower_outer) Labels are only created when price is touching the region and a fresh crossing occurs. This avoids creating labels on every bar that remains outside the band. 11) Z Score Calculation When an event occurs, the script calculates the standardized distance from the mean: float current_z_score = dev_val != 0 ? math.abs(close - mean_val) / dev_val : 0.0 Interpretation: A z score of 1 means price is one equilibrium standard deviation away from the estimated mean. Higher values indicate a more statistically stretched condition. 12) Probability Style Score Calculation The script converts the z score into a percentage style score using an approximation of the error function: float x = math.abs(z_score) / math.sqrt(2.0) ... float prob = erf_approx * 100.0 Because erf(|z| / sqrt(2)) corresponds to the probability mass within plus or minus that z distance under a normal distribution, the output behaves like a confidence or coverage score. Important note: This is not a direct OU mean reversion probability in the strict stochastic process sense. It is a normal distribution style stretch score based on the current z distance. 13) Upper Event Label Logic When price crosses into the upper band region: if (touch_upper and cross_up_in) or (touch_upper and cross_up_out) the script prints a bearish styled label above the bar: "▼ %" + str.tostring(probability, "#.##") + " (Z:" + str.tostring(current_z_score, "#.##") + ")" This reflects the idea that price is statistically extended above the mean and may be vulnerable to reversion. 14) Lower Event Label Logic When price crosses into the lower band region: if (touch_lower and cross_dn_in) or (touch_lower and cross_dn_out) the script prints a bullish styled label below the bar: "▲ %" + str.tostring(probability, "#.##") + " (Z:" + str.tostring(current_z_score, "#.##") + ")" This reflects the idea that price is statistically extended below the mean and may be vulnerable to reversion. 15) Role of the Time Step Input The dt_input parameter affects the conversion from the AR(1) coefficient into the OU reversion speed: float theta_exact = -math.log(b) / dt A larger dt lowers the inferred theta for the same b . A smaller dt raises the inferred theta for the same b .
อินดิเคเตอร์ Pine Script®
โดย UAlgo
TX Smooth ReversalOverview: The CDSA Smooth Reversal is a quantitative trading tool designed to identify high-probability price exhaustion and reversal points. By combining Multi-Timeframe (MTF) alignment with a sophisticated Band Engine based on KAMA (Kaufman Adaptive Moving Average), this indicator filters out market noise and focuses on institutional-grade reversal zones. Key Features: KAMA-Adaptive Bands: Unlike standard Bollinger Bands, our bands use an Efficiency Ratio (ER) to adapt to market volatility, expanding during trends and contracting during consolidations. Probabilistic Reversal Scoring: A proprietary logic that calculates the likelihood of a reversal based on price deviation, volume characteristics, and trend exhaustion. MTF Fusion Gate: Ensures that signals only appear when multiple timeframes (Micro, Operational, and Regime) are in alignment, significantly reducing false signals. Heikin Ashi Integration: Optional HA logic processing to smooth out erratic price action for long-term trend analysis. Live Dashboard: Real-time monitoring of Bull/Bear reversal probabilities and MTF status directly on your chart. How to Trade: Bullish Reversal (BUY): Look for the "BUY" label when the Bull Probability is high (>75%) and price touches the lower outer bands. Bearish Reversal (SELL): Look for the "SELL" label when the Bear Probability is high (>75%) and price reaches the upper outer bands. MTF Confirmation: Ensure the "MTF Alignment" on the dashboard matches your trade direction for the highest win-rate setups. Settings: Algorithm Mode: Choose between Conservative (fewer, higher quality signals), Normal, or Aggressive. Alignment Threshold: Adjust how strictly the different timeframes must agree before a signal is triggered.
อินดิเคเตอร์ Pine Script®
โดย Tonzlnxz
SFP Trend & VWAP Liquidity Pro [Zofesu]Technical Logic: This indicator is designed to identify Swing Failure Patterns (SFP) at key liquidity zones, filtered by institutional volume-weighted levels (VWAP) or moving averages. SFP Engine: The script tracks market structure using a Swing Lookback Period (default 150 bars). It identifies "Liquidity Sweeps" where price breaches a prior Swing High or Low but fails to maintain that level, indicating a potential reversal. Dual Trend Filtering (Filter A & B): To ensure high-probability entries, the indicator uses two independent filters. While the default is set to VWAP (Session-based), users can surgically adapt the strategy using the following options: VWAP: Anchored to Session, Week, Month, or Year. Moving Averages: Options to switch to HMA, EMA, or SMA for different trend-following styles. Length (2000/5000): These parameters allow for ultra-smooth trend detection when using MA types instead of VWAP. Off: Filters can be disabled for raw SFP tracking. Visuals: BULL/BEAR SFP Labels: Signal execution points after a liquidity sweep and filter alignment. Upper/Lower Liquidity Lines: Real-time horizontal levels (Red/Green) representing the current swing points being monitored. Filter Lines: Dynamic lines that change color based on whether the price is in a bullish or bearish regime. How to use: Identify the Sweep: Price must move beyond the plotted Red or Green liquidity lines. Wait for Confirmation: An SFP label appears only if the candle closes back within the range and aligns with Filter A or Filter B. Customization: For scalping, use shorter Lookback periods. For swing trading, keep the 150+ lookback and use the Year/Month VWAP anchor.
อินดิเคเตอร์ Pine Script®
โดย Zofesu
7
Natural Visibility Graph [UAlgo]Natural Visibility Graph (NVG) is a structure detection indicator that treats price as a time series network. Each bar is interpreted as a node, and nodes are connected if they can “see” each other without intermediate bars blocking the line of sight. This is based on the Natural Visibility Graph concept introduced in complex network theory, where geometric visibility rules convert a time series into a graph. In practical trading terms, NVG measures how structurally important a bar is by counting how many past bars remain visible from it. Bars with high visibility act like pivots that dominate their local environment because they are not easily obstructed by surrounding price action. The script computes this visibility for highs and lows separately, then flags exceptional nodes as hubs using a dynamic, volatility aware thresholding process. The output is a chart overlay that highlights structural peaks and valleys with neon hub markers, draws a horizon style connection to the furthest visible bar, and optionally provides alerts when new hubs appear. It also colors bars according to hub status so structural events stand out instantly. 🔹 Features 1) Natural Visibility Graph Degree for Highs and Lows The indicator calculates an in degree style connectivity score for each bar. Degree represents how many past bars are visible from the current bar under the NVG rule. Highs and lows are handled independently: High graph measures visibility between swing peaks Low graph measures visibility between swing valleys using an inverted obstruction rule This separation helps detect both resistance like peaks and support like valleys without blending them into a single metric. 2) Lookback Controlled Structural Sensitivity Visibility is computed only within a user selected lookback window. Larger values build stronger structural context and produce more selective hubs, but increase computation. Smaller values react faster but focus on local structure. Visibility Lookback directly controls how far the algorithm searches for visible connections. 3) Dynamic Hub Detection with Adaptive Max Degree Instead of using a fixed degree threshold, the script maintains a rolling maximum degree for highs and lows and applies a percentile style threshold. A slow decay mechanism reduces the max gradually over time so the reference level adapts when market structure changes. This keeps hub detection stable across different regimes and helps avoid permanently locking into an old maximum degree that may no longer be reachable. 4) Hub Threshold Percentile Control Hub Threshold defines how strict hub detection is. It is applied as a fraction of the current rolling maximum degree: High hub when degreeH is greater than or equal to maxDegH times threshold Low hub when degreeL is greater than or equal to maxDegL times threshold Higher threshold values mark only the most dominant nodes. Lower values mark more frequent hubs. 5) Neon Web Visual Design The script uses a neon palette to make structural events highly visible: High hubs are marked with a cyan diamond above price Low hubs are marked with a pink diamond below price A dotted horizon beam connects the hub to its furthest visible past node, helping you interpret how far the hub’s influence extends in the visibility sense. 6) Bar Coloring for Instant Structural Context Bars are colored by hub status: Cyan for high hubs Pink for low hubs Muted gray for non hub bars This provides a fast scan view of where the market is producing dominant structural events. 7) Alerts for Structural Peaks and Valleys Alert conditions are provided for both hub types: High Visibility Structural Peak Detected High Visibility Structural Valley Detected These can be used for structural monitoring, swing validation, or confluence with other tools. 🔹 Calculations 1) Natural Visibility Rule for Highs For each past bar i within the lookback, the script checks if the straight line from the current high to the past high is unobstructed by intermediate highs. If no intermediate high reaches or exceeds the projected height on that line, the past bar is visible and the degree increases. Core idea: Current bar at index 0 Past bar at index i Intermediate bars at index k where 1 is the nearest past bar and i minus 1 is just before the past bar Slope and projection: float slope = (high - high ) / float(i) for k = 1 to i - 1 float y_projected = high - (slope * k) if high >= y_projected isVisible := false break If isVisible remains true, degreeH increments and furthestVisIdxH is updated to i, so the script remembers the furthest visible connection for drawing. 2) Natural Visibility Rule for Lows Lows use the inverted valley logic. A past low is visible from the current low if intermediate lows do not fall at or below the projected line, because deeper lows block visibility in a valley sense. float slope = (low - low ) / float(i) for k = 1 to i - 1 float y_projected = low - (slope * k) if low <= y_projected isVisible := false break If visible, degreeL increments and furthestVisIdxL records the furthest visible low node. 3) Rolling Maximum Degree with Slow Decay The indicator maintains rolling maximum degree values for highs and lows. Periodically it applies a slow decay so that the maximum can adapt downwards over time if structural connectivity decreases: var int maxDegH = 5 var int maxDegL = 5 if bar_index % int(lookback/2) == 0 maxDegH := int(math.max(5, maxDegH * 0.95)) maxDegL := int(math.max(5, maxDegL * 0.95)) maxDegH := math.max(maxDegH, degreeH) maxDegL := math.max(maxDegL, degreeL) Interpretation: The max degree never falls below 5 Decay runs every lookback divided by two bars New degrees update the max immediately if a stronger hub appears 4) Hub Classification A bar becomes a hub if its degree reaches a fraction of the current max degree: bool isHubH = degreeH >= maxDegH * threshold bool isHubL = degreeL >= maxDegL * threshold threshold behaves like a percentile control over the observed maximum connectivity. 5) Hub Markers and Horizon Beam When a hub is detected, the script plots a diamond label and draws a dotted line to the furthest visible bar for that hub type: High hub: label.new(bar_index, high, "◈", textcolor=colNeonCyan, style=label.style_label_down) line.new(bar_index, high, bar_index - furthestVisIdxH, high , style=line.style_dotted) Low hub: label.new(bar_index, low, "◈", textcolor=colNeonPink, style=label.style_label_up) line.new(bar_index, low, bar_index - furthestVisIdxL, low , style=line.style_dotted) Interpretation: The beam represents the furthest confirmed visibility connection and gives a visual sense of the hub’s visibility range. 6) Alert Conditions The script exposes alert conditions tied to the hub booleans: alertcondition(isHubH, "NVG High Hub", "High Visibility Structural Peak Detected") alertcondition(isHubL, "NVG Low Hub", "High Visibility Structural Valley Detected")
อินดิเคเตอร์ Pine Script®
โดย UAlgo
Delta Strike: Order Flow Absorption & Momentum Confirmation**Delta Strike** is a professional-grade quantitative tool designed for traders who prioritize institutional logic over simple price action. It moves beyond traditional "buy/sell" indicators by dissecting the battle between **Passive Absorption** and **Aggressive Initiative** using underlying Order Flow data. ### 🛡️ The Core Philosophy: "Wait for the Trap, Trade the Escape" Markets rarely reverse instantly. **Delta Strike** follows a rigorous two-step verification process to filter out noise and hunt for high-probability institutional footprints: 1. **Phase 1: Institutional Absorption (Left-Side Setup)** The system identifies "Base Bars" where high volume and extreme Delta (passive buying/selling) occur, but price fails to continue. This indicates that a large player is absorbing the current move. 2. **Phase 2: Aggressive Strike (Right-Side Confirmation)** We do not "catch the knife." Instead, the indicator monitors the next **N bars** for a confirmed strike. A signal is only triggered when price engulfs the base bar and is backed by a significant **Active Delta Percentage**, proving that the "absorber" has now become the "aggressor." ### 🚀 Key Technical Features * **Dual-Cycle Volume Matrix**: Unlike standard indicators, Delta Strike analyzes volume across two lookback periods simultaneously (Short-term 20 & Long-term 50). It classifies setups into three categories: * 🔥 **Dual-Cycle Convergence** (Maximum Strength) * ⚡ **Short-term Spike** (Local Volatility) * 🌊 **Macro Volume Surge** (Long-term Accumulation) * **Active Delta Intensity Filter**: Every confirmation bar is evaluated for its "Net Win Ratio." By filtering out low-conviction, low-volume breakouts, it ensures you only follow moves with real institutional backing. * **RSI Environment Guard**: Integrated RSI logic ensures that bottom absorption is only hunted in "Oversold" zones and top absorption in "Overbought" zones, significantly reducing whipsaws in sideways markets. * **Validated SuperTrend (Delta-Sync)**: A modified SuperTrend algorithm that requires a "Delta Handshake." A trend flip is only considered valid if price and Delta move in the same direction, preventing "fake-outs" during low-liquidity periods. ### 📊 Clean & Actionable UI * **Base Bar Highlight**: When a setup is confirmed, the script retroactively draws a **Yellow (Bullish)** or **Fuchsia (Bearish)** box around the original absorption bar. * **Trace Lines**: Dashed lines connect the original institutional entry to your current entry point, providing immediate visual context for the trade's logic. * **Momentum Rating (🐂/🐻)**: * **3 Stars (🐂🐂🐂)**: Extreme Delta Strike (>20% Net Win). * **2 Stars (🐂🐂)**: High Conviction Strike (>10% Net Win). * **1 Star (🐂)**: Standard Confirmation. ### 🔔 Smart Alert System Equipped with a fully customizable alert suite. You can set alerts for: * **Absorption Confirmations** (Long/Short) * **Validated SuperTrend Breakouts** *Note: For the most accurate results, it is recommended to use "Any alert() function call" and set frequency to "Once Per Bar Close" to avoid repainting during intra-bar fluctuations.* --- ### How to use: 1. Look for the ** ** label and highlighted box. 2. Wait for the **Strike icons (🐂/🐻)** to appear within the N-bar window. 3. Combine with your existing Support/Resistance levels for optimal strike rates. ---
อินดิเคเตอร์ Pine Script®
โดย mazmez
2
Liquidity Pools + Sweep Signals [Metrify]If breakouts feel like a scam, it’s because they often function like one. Most charts are taught like they’re a clean story of supply and demand. But real price action is messier: it’s a sequence of tests, traps, and collections. The market doesn’t need to “respect” your line, it needs to find liquidity. And liquidity usually sits in predictable places: swing highs, swing lows, prior reaction points, the levels everyone can see. This Liquidity Sweep Canvas is a market-structure overlay that tracks liquidity pools built from swing highs/lows, then monitors how price interacts with those pools over time (touches → sweeps → breaks/expiry). The goal is not to “predict” — it’s to map where liquidity is parked, highlight when it’s raided with rejection, and keep a clean, visual “canvas” of relevant pools near current market. It builds two sides: SELL liquidity pools (from pivot highs, shown in red) BUY liquidity pools (from pivot lows, shown in teal) Each pool is zoned around the pooled level, merges nearby levels (optional aggressiveness), tracks hits, and can transition through states: Active (building / being respected) Swept (liquidity taken + rejection confirmed) Ended (broken through or expired) Sweep logic in plain terms A sweep is detected when price pierces beyond a pool boundary and then closes back through the pool’s midline in the opposite direction (rejection). Bear sweep (SELL liquidity): price wicks above a SELL pool, then closes back below the pool mid. Bull sweep (BUY liquidity): price wicks below a BUY pool, then closes back above the pool mid. Optionally, you can require a second-step confirmation: Displacement confirm waits for follow-through (within a small window) where price breaks beyond the sweep candle’s reference (with a minimum body size in ATR). This filters some noise, at the cost of being delayed. 🔥 Scoring system (how “quality” is decided) Sweeps are common. Clean sweeps are not. We uses a weighted scoring model (0–100) so you can filter out weak sweeps and keep the ones that show stronger intent. A sweep starts when price penetrates beyond the pool boundary (takes liquidity) and reclaims back inside the zone (closes through the pool mid). From there, a score is built from two layers: ✅ Layer 1 —> Sweep candle “core bundle” (base part) This is computed immediately on the sweep candle (or stored if you require displacement). The base bundle blends: Penetration: how deep the wick pushed beyond the pool in ATR terms (not “deeper is always better”, it’s shaped to reward a realistic sweet spot). Reclaim strength: how much of the candle reclaimed back (close relative to the range). Wick ratio: rejection wick size vs body (controlled by 'Wick Ratio Scale'). Body bias: bullish body for bull sweeps / bearish body for bear sweeps gets rewarded. EMA context: measures whether the sweep is happening with a favorable distance relative to EMA 200. Line age/maturity: longer pools can score differently via a length score, then get penalized by a separate age penalty. 🧠 Layer 2 —> Context add-ons After the base bundle, the final score can include: MSS context: a simple structural reference (recent swing extreme lookback) to rate whether the sweep is happening with useful positioning. Effort score: combines range expansion (ATR) with volume vs volume MA to reward sweeps that show actual participation. Displacement score (optional): if enabled, the sweep is only confirmed after follow-through within a small window. How to use it 1. Build a two-stage decision: location bias, then trigger selection Use pools to decide directional bias before you even consider entries. If price is pressing into SELL pools repeatedly and the dashboard shows dense sell-side activity, your bias shifts toward expecting a sell-side raid (sweep up then rejection) rather than a clean breakout. If price is pressing into BUY pools, same logic for downside raid and bounce. Then decide your trigger style manually: If you trade fast mean reversion, you can use immediate sweeps as the “first alarm” and enter on the reclaim + tight invalidation. If you trade safer confirmation, require displacement confirm, and only act once price has proven it can leave the pool with force. Either way, the script helps you separate where it matters (pools) from where it doesn’t (middle of nowhere). 2. Use hit count to judge liquidity density and trap probability The LP xN hit count is a manual edge if you treat it correctly: more hits generally implies more eyes, more orders, more liquidity, and therefore more potential for a meaningful raid. When you see a pool with high hits near current price, don’t assume it’s “strong support/resistance.” Instead, assume it’s a liquidity magnet. If price repeatedly taps a high-hit pool without breaking cleanly, it often sets up a sweep (stop run + reverse). If price breaks and stays outside with follow-through, that’s not a sweep environment, it’s a continuation environment. So you use hit count to anticipate which levels are likely to be hunted, then use candle behavior + displacement to judge whether the hunt was successful and rejected. 3. Turn sweeps into ‘event markers’ for post-move structure mapping Instead of treating a sweep as “enter now,” treat it as: a structural event happened here. After a sweep prints, manually re-map microstructure: identify the last minor swing before the sweep, then track whether price breaks it (MSS/BOS style) and whether the first pullback respects that break. 4. Use the channel read as a regime filter (premium/discount logic) The nearest pool edges effectively form a liquidity channel. Use it like a regime filter: Inside SELL zone / premium: prioritize short-side narratives Inside BUY zone / discount: prioritize long-side narratives Middle channel: treat as uncertainty, tighten your standards (or step aside). 5. Use scoring as a ‘quality gate’, then you do the narrative check” If you enable scoring, stop thinking of it as “higher score = higher win.” Think of it as a gate that filters out low-effort pokes. Once a high-score sweep prints, manually audit it. 6. Use it as a ‘sweep journal’ to study your market’s behavior A very “pro” use is not trading it at all for a week. Turn on historical traces and sweep markers, and just observe: Which sessions produce the cleanest sweeps? Do high-score sweeps outperform low-score? Do confirmed sweeps reduce chop at the cost of late entries? Does your instrument sweep more on highs or lows? The dashboard counts help you quantify frequency. After you collect observations, you tune inputs (Swing Length, Merge Distance, Minimum Score, Volume thresholds) to match the instrument’s microstructure. This is how you turn a generic sweep concept into a market-specific playbook—and the script becomes your data-driven visual log, not a guessing machine. ⚙️ Tuning tips (fast) Too many pools / too noisy → increase Swing Length / Merge Distance. Sweeps trigger too often → enable Activate Scoring and raise Min Score. Wick quality not valued enough → reduce Wick Ratio Scale. Effort scoring feels too easy/hard → adjust Min Volume / MA and Volume MA Length. A higher score is not a guarantee of a better trade, it simply means the sweep event matched more of the model’s criteria (penetration, reclaim, rejection wick, effort, context components, and optional displacement). Markets are adaptive: what high quality looks like changes by instrument, timeframe, and session. Use scoring to reduce noise, then manually validate.
อินดิเคเตอร์ Pine Script®
โดย Metrify
8
Heiken Ashi Break of Structure with Market Structure [by Hampeh]Description This indicator is designed to identify high-probability trading entries by combining the trend-smoothing capabilities of Heiken Ashi candles with the powerful concept of a Break of Structure (BOS). To enhance signal quality and reduce false signals, it incorporates a mandatory market structure confirmation filter, requiring a Higher Low (HL) to be established before a buy signal and a Lower High (LH) before a sell signal. The indicator automatically provides dynamic Stop Loss levels and generates real-time alerts to streamline the trading process. How It Works The indicator's logic is built upon several key components that work together to filter for high-quality setups. 1. Heiken Ashi Foundation The script uses Heiken Ashi candles as its foundation to reduce market noise and provide a clearer visualization of the underlying trend. This smoothing effect makes it easier to identify sustained directional moves. 2. Break of Structure (BOS) Identification The core entry trigger is a Break of Structure, defined as: Bullish BOS (Buy Signal): The indicator first identifies a downtrend phase (red Heiken Ashi candles). It marks the opening price of this phase (redOpen). A buy signal is triggered when the trend reverses (turns green) and the Heiken Ashi close price breaks above this redOpen level. Bearish BOS (Sell Signal): Conversely, it identifies an uptrend phase (green Heiken Ashi candles) and marks its opening price (greenOpen). A sell signal is triggered when the trend reverses (turns red) and the Heiken Ashi close price breaks below this greenOpen level. 3. Market Structure Confirmation (HL/LH Filter) This is the key filter that validates the strength of a potential new trend: Higher Low (HL) for Buys: A buy signal is only considered valid if the low point of the most recent downtrend phase is higher than the low point of the previous downtrend phase. This confirms a classic "Higher Low" market structure, indicating that buying pressure is increasing. Lower High (LH) for Sells: A sell signal is only considered valid if the high point of the most recent uptrend phase is lower than the high point of the previous uptrend phase. This confirms a "Lower High" structure, suggesting that selling pressure is building. 4. Dynamic Stop Loss Calculation The indicator provides a logical and dynamic Stop Loss for every signal: For Buy Signals: The Stop Loss is automatically placed just below the lowest low (lowestLow) recorded during the entire preceding downtrend (red candle) phase. For Sell Signals: The Stop Loss is placed just above the highest high (highestHigh) recorded during the entire preceding uptrend (green candle) phase. 5. Signal Generation and Visualization A final BUY signal is generated only when all conditions are met: a bullish BOS occurs and it is preceded by a confirmed Higher Low. A final SELL signal is generated only when all conditions are met: a bearish BOS occurs and it is preceded by a confirmed Lower High. When a valid signal is triggered, a label appears on the chart displaying the entry price and the calculated Stop Loss. A corresponding alert is also fired with detailed trade information. Summary of Strategy In essence, this indicator waits for a pullback (a Heiken Ashi color change), confirms that the pullback respects bullish or bearish market structure (HL or LH), and then triggers an entry upon a Break of Structure in the intended direction. Disclaimer : This indicator is a tool for technical analysis and does not guarantee profits. Trading financial markets involves significant risk. Always conduct your own research and practice proper risk management.
อินดิเคเตอร์ Pine Script®
โดย Hampeh
Donchian Ribbon [UAlgo]Donchian Ribbon is a chart-overlay Donchian Channel ribbon that visualizes multiple lookback lengths at the same time. Instead of plotting a single Donchian Channel, the script builds a fixed stack of channels that increase in length and blends them into a clean, layered ribbon above and below price using progressive fills. The goal is to make market structure and regime easier to read without clutter: - When the ribbon expands and stays orderly (fast boundaries leading, slow boundaries following), it often reflects sustained range expansion and more directional flow. - When the ribbon compresses and bands overlap frequently, it typically reflects consolidation, rotational behavior, and reduced clarity. - The slowest channel provides the structural “outer frame” of the market’s recent range, while shorter channels react first and show how quickly the range is shifting. This indicator is designed as a context tool. It does not attempt to “predict” direction by itself, but it gives a high-quality visual map of evolving highs/lows across multiple sensitivities so you can align entries, risk, and expectations with the current regime. 🔹 Features 1) Multi-Length Donchian Stack (Ribbon Engine) The script constructs several Donchian Channels from a Base Length and a Step Length. Each band represents a different sensitivity level: - Fast bands respond quickly to recent highs and lows. - Slow bands respond more conservatively and define broader containment. By stacking these lengths together, you can see short-term responsiveness and higher-level structure simultaneously. 2) Two-Sided Ribbon (Upper and Lower Envelopes) The indicator visualizes both sides of the Donchian framework: - Upper ribbon is built from stacked Donchian highs (highest highs per length). - Lower ribbon is built from stacked Donchian lows (lowest lows per length). This keeps interpretation intuitive: price pressing into the upper ribbon suggests pressure toward recent highs, while leaning into the lower ribbon suggests pressure toward recent lows. 3) Gradient Depth via Layered Fills (Clean Charts) Instead of drawing many lines, the script fills the space between consecutive bands. Transparency is gradually adjusted from the fast band to the slow band, producing a smooth depth effect that stays readable even on busy charts. Intermediate plots are intentionally hidden so the ribbon remains the main visual output. 4) Regime Readability (Expansion vs Compression) Because each band has a different lookback length, the ribbon naturally communicates volatility and state: - Expansion: spacing between fast and slow bands increases, commonly seen in stronger directional phases. - Compression: spacing collapses and bands cluster, commonly seen in ranges, pauses, or choppy rotation. This helps you quickly decide whether to treat price action as breakout-oriented, trend-continuation, or mean-reverting. 5) Trend Baseline Reference (Slow Midpoint) A baseline is plotted using the midpoint of the slowest channel. This provides a stable reference that helps you judge whether price is operating in the upper or lower half of the broader range structure. 🔹 Calculations 1) Donchian High, Low, and Midpoint Per Band Each Donchian band is computed from its own length: - High = highest high over the lookback length - Low = lowest low over the lookback length - Mid = average of High and Low id.high := ta.highest(id.length) id.low := ta.lowest(id.length) id.mid := math.avg(id.high, id.low) 2) Length Sequencing (Base Length + Step Length) The indicator creates a fixed number of bands. Lengths are built as: - Band 1: base_length - Band 2: base_length + step_length - Band 3: base_length + 2 * step_length - ... - Final band: base_length + (ribbon_count - 1) * step_length This yields a consistent progression from fast to slow sensitivity. int len = base_length + (i * step_length) channels.push(DonchianChannel.new(len)) 3) Iterative Updates with Arrays and Methods All bands are stored in an array and updated every bar using a unified method call. This ensures every band follows identical rules and makes the logic scalable and maintainable. for dc in channels dc.update() 4) Upper Ribbon Construction (Layered Fills Between Highs) The upper ribbon is created by filling between consecutive Donchian highs. Each layer uses the same upper tone with progressively stronger visibility toward the slow band. fill(p_fast_high, p_mid1_high, color.new(col_upper, 90), "Ribbon Upper 1") fill(p_mid1_high, p_mid2_high, color.new(col_upper, 80), "Ribbon Upper 2") fill(p_mid2_high, p_mid3_high, color.new(col_upper, 70), "Ribbon Upper 3") fill(p_mid3_high, p_slow_high, color.new(col_upper, 60), "Ribbon Upper 4") 5) Lower Ribbon Construction (Layered Fills Between Lows) The lower ribbon is created by filling between consecutive Donchian lows with the lower tone, again using progressive transparency. fill(p_fast_low, p_mid1_low, color.new(col_lower, 90), "Ribbon Lower 1") fill(p_mid1_low, p_mid2_low, color.new(col_lower, 80), "Ribbon Lower 2") fill(p_mid2_low, p_mid3_low, color.new(col_lower, 70), "Ribbon Lower 3") fill(p_mid3_low, p_slow_low, color.new(col_lower, 60), "Ribbon Lower 4") 6) Trend Baseline (Slow Midpoint) The baseline is the midpoint of the slowest Donchian band, plotted as a stable center reference for the broadest range framework. plot(dc_slow.mid, "Trend Baseline", color = color.from_gradient(0.5, 0, 1, col_lower, col_upper), linewidth = 2) 7) Visualization Choice (Hidden Internals, Visible Structure) To keep charts clean, most intermediate plots are hidden and the ribbon fills do the heavy lifting visually, while the slow boundaries remain visible as the outer frame. p_fast_high = plot(dc_fast.high, "Fast High", color = color.new(col_upper, 80), display = display.none) p_fast_low = plot(dc_fast.low, "Fast Low", color = color.new(col_lower, 80), display = display.none) p_slow_high = plot(dc_slow.high, "Slow High", color = color.new(col_upper, 50)) p_slow_low = plot(dc_slow.low, "Slow Low", color = color.new(col_lower, 50))
อินดิเคเตอร์ Pine Script®
โดย UAlgo
Absorption ReversalAbsorption Reversal detects institutional absorption patterns at the extremes of a trading range. When price reaches a range boundary, large limit orders from institutional players can "absorb" aggressive market orders — this creates a characteristic candle with high volume and a long rejection wick. The indicator identifies these setups and waits for confirmation before signaling a reversal. Free & Open Source — no invite-only access, no paywall. Full source code, fully transparent. ## The Concept: What Is Absorption? In order flow terms, absorption occurs when resting limit orders at a price level absorb incoming market orders without allowing price to break through. This is a core concept in Wyckoff analysis (Effort vs. Result) and institutional trading: - High volume (Effort) + small price movement / long wick (no Result) = absorption - The wick shows that price was pushed to the extreme but immediately rejected - This typically happens at range boundaries where institutional players defend levels The indicator automates this detection process with quantifiable rules. ## How It Works The signal generation follows a strict 6-step process: Step 1 — Range Detection: A Donchian Channel (highest high / lowest low) defines the current trading range boundaries. Step 2 — Range Width Filter: The channel width must be below its own average — confirming the market is sideways/contracting, not expanding into a trend. Step 3 — ADX Trend Filter: Wilder's ADX must be below the threshold (default 25) — no strong trend active. Absorption setups work best in range-bound markets. Step 4 — Proximity Check: Price must be in the upper or lower proximity zone of the range (default: outer 15%). Absorption in the middle of a range is meaningless. Step 5 — Absorption Bar: A candle that shows: - Volume spike (default 1.5x average — significant participation) - Long rejection wick (default 66% of candle range — strong rejection) - Located at the range extreme (within proximity zone) Step 6 — Confirmation: Within the next N bars (default 3), a follow-up candle must close back inside the range in the expected reversal direction. No confirmation = no signal. ## Chart Elements - Range Lines — Donchian Channel upper (red) and lower (green) boundaries - Proximity Zones — Optional shaded areas showing where absorption signals can trigger - Orange Diamonds — Absorption bars detected (before confirmation) - Green/Red Triangles + BUY/SELL Labels — Confirmed reversal signals only ## Dashboard The real-time dashboard displays: - Market Regime — Range or Trending (based on ADX + channel width) - ADX Value — Current trend strength with classification - Range Width — Contracting or Expanding - Position — Where price sits in the range (Near High / Near Low / Middle) - Volume — Current volume relative to average + spike detection - Pending — Active absorption bars awaiting confirmation (with countdown) ## Settings Range Detection: Donchian Channel Length (default 20), Proximity Zone % (default 15%) Trend Filter: ADX Filter ON/OFF (default ON), Range Width Filter ON/OFF (default ON) Absorption Criteria: Min Wick/Range Ratio (default 0.66), Volume SMA Length (default 20), Volume Spike Multiplier (default 1.5x) Confirmation: Max Confirmation Bars (default 3) ## Alerts 4 alert conditions: - Absorption Buy Signal — confirmed bullish reversal at range low - Absorption Sell Signal — confirmed bearish reversal at range high - Bullish Absorption Detected — absorption bar found, awaiting confirmation - Bearish Absorption Detected — absorption bar found, awaiting confirmation ## Best Used For - Identifying high-probability reversal setups at range boundaries - Spotting institutional absorption activity via volume + wick analysis - Range-trading strategies with clear entry signals - Confluence tool alongside other indicators - Works on all instruments: stocks, forex, crypto, futures, indices ## Technical Notes - Pine Script v6 (latest version) - Signals on confirmed bars only — no repainting - State-based confirmation logic - Open source, no external dependencies - All inputs have tooltips ## Disclaimer This indicator is for educational and informational purposes only. It does not constitute financial advice. No signals should be interpreted as buy or sell recommendations. Past performance is not indicative of future results. Always implement proper risk management. Trade at your own risk.
อินดิเคเตอร์ Pine Script®
โดย alphachart_tv
1
Trend Strategy Flip📌 Trend Strategy Flip — Adaptive Trend‑Following System with Smart Flip Logic (Built on the L1 Proximal Filter concept by LuxAlgo) Trend Strategy Flip is an adaptive trend‑following system built on top of the L1 Proximal Filter, a concept originally introduced by LuxAlgo. This strategy expands the idea with multi‑mode entries, smart flip logic, breakeven automation, and a clean visual HUD for real‑time decision support. The result is a lightweight, responsive trend engine suitable for both discretionary and automated trading. 🔍 Core Concept The system uses the L1 Proximal Filter to extract a smooth, noise‑resistant trend line (z) and its velocity (v). This allows the strategy to detect: Confirmed trend reversals (Mode A) Early entries via price cross or velocity shift (Mode B1/B2) Next‑bar confirmation entries (Mode C) When the trend flips, the strategy can automatically reverse the position. ✨ Key Features ✔ Built on the L1 Proximal Filter (LuxAlgo concept) A robust, adaptive trend extraction method. ✔ Multiple Entry Modes Choose between confirmed, early, or next‑bar entries. ✔ Smart Flip Logic Automatically reverses positions on trend change. ✔ Breakeven Protection Dynamic breakeven activation with a semi‑transparent BE line. ✔ Compact HUD (Top‑Right Corner) Displays: Current position Entry price Live PnL (%) Last flip direction Breakeven status Bars since entry ✔ Optional Trend Background Soft diagonal gradient (lightweight imitation) for visual trend context. ✔ Clean Visual Markers Entry arrows, flip markers, trend line, and BE line. ✔ Alerts Included Ready for automation or webhook‑based execution. 🎯 Use Cases Trend‑following systems Reversal/flip strategies Automated execution via alerts Swing and intraday trading Strategy research and optimization ⚠️ Notes This strategy is based on the L1 Proximal Filter concept by LuxAlgo, extended with additional logic and visualization. For educational and research purposes only. Always test before using in live trading.
กลยุทธ์ Pine Script®
โดย olegask68