Equilibrium Momentum Shift + Divegence [BigBeluga]🔵 OVERVIEW
Equilibrium Momentum Shift is a range-based momentum oscillator designed to measure how far price has deviated from its current equilibrium.
Instead of focusing purely on trend direction or overbought/oversold conditions, this indicator evaluates price relative to the midpoint of its recent range and quantifies the strength of the shift away from that balance.
By combining normalized range deviation, smoothing techniques, and nonlinear compression, the indicator provides a clear view of when markets transition from equilibrium into directional momentum, now featuring Normal Divergence detection to spot potential trend reversals.
🔵 CONCEPT
Equilibrium Midpoint — The midpoint between the highest high and lowest low over the selected range length represents the equilibrium price.
Deviation Measurement — The indicator measures how far the current price has moved away from this midpoint.
Range Normalization — Deviations are normalized relative to the size of the current range, allowing the oscillator to remain consistent across different volatility conditions.
Momentum Compression — A hyperbolic tangent function compresses extreme values, stabilizing the oscillator and preventing runaway signals during large trends.
Divergence Identification — Automatically identifies discrepancies between price action and the oscillator to highlight weakening momentum in established trends.
🔵 HOW IT WORKS
1️⃣ Equilibrium Range Calculation
The indicator calculates the highest high and lowest low over the user-defined range length.
The midpoint between these two levels forms the equilibrium line.
This midline represents the center of balance for recent price activity.
2️⃣ Price Deviation Measurement
The distance between the current close and the equilibrium midpoint is calculated.
This deviation is then smoothed using a double EMA structure to reduce noise.
The smoothed value is normalized relative to half of the current range size.
3️⃣ Nonlinear Oscillator Transformation
A hyperbolic tangent function compresses normalized deviations into a stable range between -1 and +1.
This transformation prevents extreme outliers and creates a more interpretable oscillator.
4️⃣ Momentum Histogram
A signal line is generated using EMA smoothing.
The difference between the oscillator and the signal line forms a histogram.
The histogram behaves similarly to a MACD-style momentum indicator:
Expanding bars indicate strengthening momentum.
Contracting bars indicate weakening momentum.
5️⃣ Normal Divergence Logic
Bullish Divergence: Occurs when price makes a Lower Low , but the Equilibrium Oscillator makes a Higher Low . This suggests that despite the price drop, the selling pressure relative to equilibrium is fading.
Bearish Divergence: Occurs when price makes a Higher High , but the Equilibrium Oscillator makes a Lower High . This indicates that the buyers' ability to push price away from the midpoint is losing strength.
🔵 KEY FEATURES
Equilibrium midpoint plotted directly on the chart.
Range-normalized momentum oscillator.
Hyperbolic tangent compression to stabilize signals.
MACD-style histogram for momentum acceleration detection.
Automatic Normal Divergence labels to spot exhaustion.
Gradient-colored oscillator line reflecting directional bias.
Dashboard displaying real-time momentum metrics.
🔵 DASHBOARD METRICS
Shift — Current oscillator value showing how far price has moved from equilibrium.
State — Market regime derived from oscillator thresholds:
Bullish
Bearish
Neutral
Range Position — Location of price inside the current range expressed as a percentage.
Pressure — Magnitude of momentum deviation from equilibrium.
🔵 HOW TO USE
Use the equilibrium midline as a dynamic balance reference.
When the oscillator moves above zero, bullish momentum dominates.
When the oscillator moves below zero, bearish momentum dominates.
Trading Divergences: Watch for divergence labels when price is at historical range extremes. A bullish divergence near the "Lowest Low" of the range suggests a high-probability mean-reversion trade back toward equilibrium.
Histogram expansions highlight momentum acceleration.
Histogram contraction can signal potential momentum exhaustion.
🔵 INTERPRETING MOMENTUM SHIFTS
Oscillator near zero → Market is balanced around equilibrium.
Oscillator above 0.2 → Bullish momentum phase.
Oscillator below -0.2 → Bearish momentum phase.
Divergence Label + Oscillator Flatline → High probability of a trend reversal or deep pullback.
Rapid oscillator expansion → Strong directional pressure.
Oscillator flattening → Momentum compression or consolidation.
🔵 CONCLUSION
Equilibrium Momentum Shift offers a structured way to analyze how price behaves relative to its recent balance point.
By measuring normalized deviations from equilibrium and visualizing momentum shifts with a smoothed oscillator, histogram, and integrated divergence analysis , the indicator helps traders identify when markets transition from balance into directional movement.
This makes it especially useful for spotting early momentum expansions, trend continuation signals, and potential exhaustion points where price is likely to snap back to its equilibrium midpoint. مؤشر
Liquidity Contour Engine [JOAT]
Liquidity Contour Engine
Introduction
Liquidity Contour Engine is an overlay indicator that identifies two distinct institutional price phenomena: liquidity sweeps at swing highs and lows, and order blocks formed before impulsive structural moves. Liquidity sweep zones mark levels where price reached beyond a prior swing, triggering stop orders, then reversed — the classic footprint of a sweep-and-reversal sequence. Order block zones mark the last opposing candle before a significant directional impulse, representing the area where a large position was initiated.
The underlying premise is that institutions build and exit positions through order flow that leaves identifiable marks on the chart. A liquidity sweep is one such mark: price extending beyond a well-established swing level, clearing stops, then reversing. This behavior is not random — it reflects deliberate order accumulation at levels where retail stops cluster. Similarly, order blocks at the origin of impulsive moves may act as re-entry areas when price later returns to them.
Core Concepts
1. Confirmed Swing Pivot Detection
Swings are identified using ta.pivothigh and ta.pivotlow with a configurable lookback. All pivot detections are confirmed — offset by the lookback bars — meaning no repainting occurs. Only when sufficient bars have closed on both sides of a potential pivot is it registered.
2. Liquidity Sweep Detection
A bullish sweep is confirmed when: price wicks below the most recent swing low by at least a configurable ATR multiple, and the bar closes back above that swing low. This captures the wick-past-and-close-back pattern that characterizes institutional accumulation at liquidity levels. A bearish sweep is the mirror condition at swing highs.
Upon detection, a zone is created at the swept level, rendered as a dual-width line (thin solid + thick transparent shadow). Zones remain active until price sustains a close beyond the swept level by 0.5 ATR, at which point they convert to dotted lines (mitigated state).
3. Order Block Detection
An order block is identified as the prior N candle(s) before a structural impulse. A bullish impulse is defined as a bar that closes above the most recent swing high. The order block is the last candle body before that impulse, rendered as a filled box from body open to the wick high. Mitigation occurs when price closes beyond the 50% level of the order block body, fading the box to indicate the zone has been traded through.
4. Zone Lifecycle Management
The indicator uses arrays to track active zones and enforces a maximum count. When the maximum is exceeded, the oldest zone is removed from the chart. This prevents chart clutter while keeping the most recent and relevant zones visible.
Features
Liquidity Sweep Zones: Dual-width line rendering at swept swing levels, self-managing lifecycle
Order Block Boxes: Filled zones at order block origin, with mitigation fading
Swing Level Dotted Lines: Current swing high and low extensions as dotted reference lines
9-Row Dashboard: Sweep state, active zone counts, order block counts, last swing levels
Configurable ATR Threshold: Adjusts how far price must reach beyond a swing to qualify as a sweep
Max Zone Limit: Prevents chart clutter with configurable maximum active zone count
Input Parameters
Swing Lookback: Bars required each side for pivot confirmation (default: 8)
Sweep ATR Threshold: Minimum sweep distance in ATR units (default: 0.3)
Max Active Zones: Maximum concurrently displayed liquidity zones (default: 8)
ATR Period: Period for ATR calculation (default: 14)
Show Order Blocks: Toggle order block rendering
OB Lookback: How many bars back to identify the order block candle (default: 3)
How to Use This Indicator
Sweep-and-Reverse Setups
When a bullish sweep fires (price wicked below a swing low and closed back above), the zone represents the level where stops were taken. If price subsequently builds structure above that zone and delta pressure is positive, the setup is a potential long entry with the swept level as reference for the stop.
Order Block Re-Tests
When price returns to a bullish order block zone (shown in teal), it is revisiting the area where an institutional position was likely initiated. If the zone has not been mitigated (box remains filled), a reaction from that zone is plausible. A mitigated order block (faded) is a less reliable reference.
Zone Confluence
When a liquidity sweep zone and an order block coincide at the same price level, the confluence represents a stronger structural reference than either zone alone.
Limitations
Swing pivot confirmation introduces a bar lag equal to the lookback period. Sweeps and order blocks are identified after the fact, not in the moment they form
Not every liquidity sweep produces a reversal. Price can continue through a swept level without reversing
Order block identification is mechanical and cannot account for all institutional order placement strategies
On higher timeframes, zones cover wider price ranges and may require adjustment of the ATR threshold
Originality Statement
The unified framework for tracking liquidity sweeps and order blocks within a single indicator with a shared zone lifecycle management system is the original design contribution. Zone mitigation logic that converts active zones to passive reference lines (rather than deleting them) preserves structural context while visually indicating that a zone's primary relevance has passed. The dual-width shadow line rendering for sweep zones provides depth that distinguishes them clearly from standard horizontal lines.
Disclaimer
This indicator is for educational and informational purposes only. Liquidity sweep detection describes a pattern in historical price data. Past occurrences of this pattern do not guarantee future reactions. Order blocks are hypothetical areas of interest, not confirmed institutional levels. Always use proper risk management.
-Made with passion by officialjackofalltrades
مؤشر
Swing Fibonacci [BigBeluga]Swing Fibonacci is a high-precision geometric framework that merges traditional swing structure with parametric spiral projections. Unlike standard Fibonacci retracements that use static horizontal lines, this tool projects expanding harmonic spirals from major structural turning points to map out the "natural geometry" of the market.
By calculating the mathematical relationship between price volatility and time, the indicator identifies expansion shells where price is naturally inclined to react, stall, or reverse.
🔵 CONCEPTS
Macro Swing Detection: The engine utilizes a high-threshold lookback window (50–100 bars) to filter out market noise. It only identifies the most significant structural pivots, ensuring the spirals are anchored to "institutional" levels rather than minor retail fluctuations.
Anchor Points & Structural Mapping: At every confirmed trend reversal, the script anchors a ⦾ symbol. It then draws a solid "Swing Leg" connecting the current anchor to the previous one, providing a clear visual map of the market's structural transitions.
Parametric Fibonacci Spirals: The spirals are generated using a high-resolution 300-step parametric calculation. This ensures the curve remains perfectly smooth and mathematically accurate regardless of how many bars are on the screen.
Adaptive Price Normalization: To prevent the "squashed" look common in geometric tools, the spiral dynamically rescales itself based on the price range of the last 500 bars. This ensures the geometry stays proportional to current market volatility.
🔵 FEATURES
Institutional Data Dashboard: Located in the top-right corner, the dashboard provides real-time stats including the exact Anchor Price , the current Trend Status (BULLISH ▲ or BEARISH ▼), and the Swing % move from the low/high.
Real-Time Swing Tracking: A dynamic dashed line follows the current price, connecting it back to the active anchor point. This allows you to visualize the current "swing in progress" before it is finalized.
Parametric Control Suite:
• Radius: Adjusts the vertical "stretch" and overall size.
• Spiral Qty: Controls the number of rotations (up to 10) to project further into the future.
Color Flow Visualization: The spirals utilize a professional gradient transition from the bearish color (inner) to the bullish color (outer), visually representing the expansion of price energy.
🔵 HOW TO USE
Identify Reaction Zones: Price often treats the edges of the spiral curves as dynamic support and resistance. Look for "confluence" where a spiral curve intersects with a horizontal level or a previous swing point.
Forecasting Expansion:
• Bullish Spiral: Projects outward from a swing low, highlighting potential take-profit zones or areas where the trend might exhaust.
• Bearish Spiral: Projects from a swing high, identifying "expansion floors" for short positions.
Trend Confirmation: Use the Trend Squares at the bottom of the chart for a quick pulse on the current directional bias without cluttering the main price action.
Harmonic Timing: The spiral's horizontal reach provides a "time" component. If price reaches a specific spiral arc at a specific time, it often marks a high-probability turning point in the cycle.
🔵 CONCLUSION
Swing Fibonacci transforms abstract price action into a tangible geometric forecast. By anchoring dynamic, price-normalized spirals to the market’s strongest turning points, it provides a unique lens through which to view volatility, extension, and mean reversion.
Ideal for harmonic traders, swing analysts, and anyone looking for a deeper mathematical edge in their structural analysis. مؤشر
KernelLens🟦 KernelLens is a professional kernel regression library for Pine Script v6, providing eight mathematically rigorous Nadaraya–Watson estimators, a three-mode filter layer, a unified string dispatcher, and a suite of trading utilities — all built from the ground up on correct non-parametric statistics. Unlike existing Pine smoothing libraries — which inherit a decade-old loop-bound bug that silently reduces every kernel window to a handful of bars, regardless of the bandwidth parameter — KernelLens is built with auditable math, NA-safe iteration, input validation at every entry point, and academic references cited inline next to the formulas they describe.
The library integrates eight independent kernel families — Rational Quadratic, Gaussian, Periodic, Locally Periodic, Epanechnikov, Tricube, Triangular, and Cosine — behind a consistent API, with every raw estimator wrapped in a filter layer (None / Smooth / Zero Lag), a unified dispatcher for dropdown-driven kernel selection, and five utility exports covering slope detection, trend state, crossover signaling, residual confidence bands, and Silverman's rule-of-thumb bandwidth recommendation. Every public function validates its inputs, raises descriptive runtime errors on misuse, and returns `na` only when there is genuinely no data — never as a silent fallback.
🟦 MATHEMATICAL FOUNDATION
**The Nadaraya–Watson Estimator**
Given a source series `y_t` and a symmetric kernel `K` with scale parameter `ℓ` (the "bandwidth"), the Nadaraya–Watson estimator of the regression function `m(x) = E ` evaluated at the current bar is:
```
Σᵢ K(dᵢ / ℓ) · y_{t−i}
ŷ(t) = ───────────────────────
Σᵢ K(dᵢ / ℓ)
```
where `dᵢ` is the bar-distance from the kernel center and the sum runs over a finite window determined by the effective support of `K`.
The estimator is a locally weighted average: bars close to the kernel center contribute heavily, distant bars contribute proportionally less, and bars outside the support contribute nothing. It is asymptotically unbiased up to `O(ℓ²)` for twice-differentiable `m`, with variance of order `(n·ℓ)⁻¹` — the classical bias–variance trade-off that defines all non-parametric smoothers.
**Why Kernel Regression Beats Rolling Means**
A simple moving average gives every bar in the window the same weight. Kernel regression gives each bar a weight that decays smoothly with distance, producing:
- **Smoother output** — no step artifacts when bars enter / leave the window
- **Better bias control** — the peak of the kernel sits exactly on the point being estimated
- **Kernel-specific behavior** — compact-support kernels eliminate tail contamination entirely; Rational Quadratic's `α` parameter exposes multi-scale mixing; Periodic kernels resonate with known cycle lengths
The math has been the academic standard for non-parametric regression since Nadaraya (1964) and Watson (1964). KernelLens brings it to Pine Script v6 in its correct, bug-free form.
🟦 THE EIGHT KERNELS
All eight kernels implement the Nadaraya–Watson weighting scheme. They differ in support (compact versus infinite), smoothness (how many times differentiable), and how weight decays with distance.
| # | Kernel | Formula | Support | Smoothness | Character |
|---|---|---|---|---|---|
| 1 | **Rational Quadratic** | `(1 + d² / (2·α·ℓ²))^(−α)` | ℝ | C∞ | Multi-scale mixer — `α` controls stretch versus wiggle |
| 2 | **Gaussian (RBF)** | `exp(−d² / (2·ℓ²))` | ℝ | C∞ | The canonical smoother — smoothest possible with L² optimality |
| 3 | **Periodic** | `exp(−2·sin²(π·d/p) / ℓ²)` | ℝ | C∞ | Resonates with repetition distance `p` — ideal for cycles |
| 4 | **Locally Periodic** | Periodic · Gaussian | ℝ | C∞ | Seasonal patterns that slowly drift with trend |
| 5 | **Epanechnikov** | `(3/4)(1 − u²) · 𝟙{|u|≤1}` | | C⁰ | Asymptotically MSE-optimal (Watson 1964) — no tail contamination |
| 6 | **Tricube** | `(70/81)(1 − \|u\|³)³ · 𝟙{|u|≤1}` | | C² | The LOWESS standard — near-Gaussian with compact support |
| 7 | **Triangular** | `(1 − \|u\|) · 𝟙{|u|≤1}` | | C⁰ | Simplest non-uniform kernel — fastest to compute |
| 8 | **Cosine** | `(π/4)·cos(π·u/2) · 𝟙{|u|≤1}` | | C¹ | Raised-cosine taper — smoother boundary than Epanechnikov |
where `u = d/ℓ` and `𝟙` is the indicator function.
**Infinite-Support vs Compact-Support — Why Both Matter**
| | Infinite Support (RQ, Gauss, Periodic, LocPeriodic) | Compact Support (Epa, Tricube, Triangular, Cosine) |
|---|---|---|
| **Tail weight** | Never exactly zero | Exactly zero beyond ±ℓ |
| **Loop depth** | `3·ℓ` (3-σ cutoff, ≈99.7% mass) | Exactly `ℓ` |
| **Bar contamination** | Distant bars still pull the estimate a tiny amount | Distant bars cannot affect the estimate at all |
| **Best for** | Smooth trends, Gaussian-process intuition | Robust regression, outlier resistance |
KernelLens picks the correct loop depth automatically based on kernel family: `_depthInfinite` for Gaussian-family kernels, `_depthCompact` for bounded kernels, `_depthPeriodic` for Periodic (which must span enough cycles to reach stable weights).
**Why Eight, Not Four**
Most Pine kernel libraries ship only the four kernels from MacKay's Gaussian process tutorial. KernelLens adds the four compact-support classical kernels because:
- **Epanechnikov** minimises asymptotic mean squared error among all non-negative kernels of bounded support (Watson 1964) — it is the MSE-optimal baseline against which all other kernels are measured
- **Tricube** is the kernel used by LOWESS (Cleveland 1979), the de-facto standard for robust locally weighted scatterplot smoothing
- **Triangular** is the cheapest non-uniform compact kernel — useful when loop-budget matters on intraday charts with huge dataset size
- **Cosine** is C¹-continuous at the support boundary, unlike Epanechnikov's C⁰ discontinuity, producing visibly smoother transitions at kernel edges
Adding them makes the library an academically complete toolkit, not just a Pine port of one tutorial.
🟦 FILTER LAYER — NONE / SMOOTH / ZERO LAG
Every kernel export accepts a `_filter` parameter with three valid values. The filter layer is implemented identically across all eight kernels, so switching kernel families does not change filter behavior.
**"No Filter" — Single-Pass Raw Estimate**
```
ŷ = K(y)
```
One Nadaraya–Watson pass over the source. Cheapest mode, most reactive, fully represents the underlying kernel. Use this when you want the kernel's raw behavior with no additional smoothing or lag correction.
**"Smooth" — Double-Pass Estimate**
```
ŷ = K(K(y))
```
The kernel is applied once to the source, then applied again to its own output using the same bandwidth and the same parameters. The result is a more strongly smoothed curve at the cost of one extra loop pass per bar.
This is mathematically equivalent to convolving the kernel with itself — the effective kernel is wider and flatter, pulling longer-range context into each estimate without requiring the user to double the bandwidth.
**"Zero Lag" — Ehlers De-Lagged Estimate**
```
ŷ = 2·K(y) − K(K(y))
```
The ZLEMA identity from Ehlers (*Rocket Science for Traders*, 2000): subtract the smoothing lag from the raw estimate, effectively shifting the output back in time to match the source more closely.
The intuition: `K(y)` lags `y` by some amount; `K(K(y))` lags `K(y)` by the same amount; so `K(y) − K(K(y))` is an estimate of the lag itself, and adding it back to `K(y)` cancels out. The result tracks the source more tightly than either pass alone, at the cost of slightly noisier turning points.
**Lazy Evaluation — No Wasted Cycles**
In `"No Filter"` mode, the second pass is skipped entirely — it never runs. The filter branch uses an `if` block (not a ternary), so Pine's short-circuit semantics prevent the unused computation. A single kernel call costs one pass; `"Smooth"` or `"Zero Lag"` costs two. You only pay for what you use.
🟦 KERNEL CENTER OFFSET — THE `_phase` PARAMETER
Every KernelLens kernel takes a `_phase` parameter that shifts the kernel center into the past by `_phase` bars. It is the library's non-repainting knob.
**_phase = 0 — Live Estimate**
The kernel is centered on the current bar. The most recent price has maximum weight, and the estimate is as fresh as possible. Suitable for live signal generation, but the most recent bar can re-evaluate as it develops within its interval — standard Pine real-time behavior.
**_phase > 0 — Non-Repainting Historical Estimate**
The kernel center is moved `_phase` bars into the past. The estimate becomes the smoothed value *at that historical bar*, not the current bar. Once the bar at `bar_index − _phase` is fully confirmed (`barstate.isconfirmed`), its estimate cannot change again.
This is the standard trick for publishing kernel indicators that do not repaint: you get a stable, historically accurate curve at the cost of shifting the entire output `_phase` bars to the right on the chart. A `_phase = 25` call gives a curve that lags live price by 25 bars but is guaranteed stable for every past bar.
**Why It Belongs in the Library, Not the Caller**
Pushing `_phase` into the kernel's own loop is not the same as evaluating the kernel at a shifted source (`K(src )`). Shifting the source just uses a stale input with a current-bar-centered kernel, which still produces a fresh estimate of a stale series. KernelLens's `_phase` genuinely moves the kernel center, producing a historical-bar estimate that computes over the correct surrounding window.
🟦 NON-REPAINTING BEHAVIOR
Repainting is the single most-asked question about any Pine indicator, and the single most common source of silent failure when a retail trader moves from backtest to live. A strategy that looks flawless on historical bars and then bleeds money the moment it is deployed is almost always suffering from some form of repainting. KernelLens is engineered from first principles to eliminate every class of repainting by construction — not by patching symptoms, but by removing the dependencies that cause repainting in the first place.
**The Two Forms of Repainting**
| Form | Symptom | Typical Cause |
|---|---|---|
| **Historical repainting** | A bar that was closed days or weeks ago silently changes its plotted value when the chart is refreshed or scrolled | `request.security()` with `lookahead = barmerge.lookahead_on`, un-gated higher-timeframe data, or incorrect array rotation that reads into future bars |
| **Real-time repainting** | The plotted value on the live (current developing) bar flickers tick-by-tick as new price ticks arrive, then freezes at a final value when the bar closes | The indicator reads `close ` (or any current-bar value) inside a weighted sum — the current-bar weight changes every tick |
KernelLens avoids the first kind **entirely and unconditionally**: the library contains no `request.security` calls, no higher-timeframe lookups, no `lookahead_on` usage, and no array rotation that could leak future bars into the window. Every historical bar plotted by any KernelLens kernel is computed exclusively from bars that existed at the time that bar was closed. The plotted history is immutable.
Real-time repainting is controlled explicitly by the `_phase` parameter — it is the user's choice whether to accept tick-by-tick flicker on the live bar in exchange for zero lag (`_phase = 0`) or to eliminate the flicker entirely at the cost of a small fixed lag (`_phase ≥ 1`).
**Why Kernel Regression Normally Repaints (And How KernelLens Stops It)**
A traditional Nadaraya–Watson call centered on the current bar evaluates:
```
ŷ(t) = Σᵢ K(dᵢ/ℓ) · y_{t−i} for i = 0 … depth
```
On the live bar, the term `y_{t−0} = close ` is the current real-time price — which changes on every tick. Every tick moves the weighted sum, every tick moves the estimate, and the trader watching the chart sees the kernel plot flicker as the bar develops. The historical bars (where `close ` for that past bar is now fixed) are stable, but the live plot is unstable.
KernelLens's `_phase` parameter shifts the loop so the kernel runs over `i = _phase … _phase + depth`. With `_phase = 2`:
```
ŷ(t) = Σᵢ K((i−2)/ℓ) · y_{t−i} for i = 2 … 2 + depth
```
The sum no longer touches `close ` or `close ` — every bar it reads is already confirmed and cannot change. The live-bar kernel output is therefore identical from the first tick of the bar to the last tick of the bar, and identical again when the bar finally closes. There is no flicker and nothing to repaint.
**The Lag / Stability Trade-Off**
| `_phase` | Lag on Live Bar | Live-Bar Flicker | Historical Repainting | Best For |
|---|---|---|---|---|
| **0** | 0 bars | Yes (real-time only; history is stable) | None | Scalping, academic research, calibration |
| **1** | 1 bar | None | None | Fast day-trading; minimum acceptable lag for a live trading desk |
| **2** | 2 bars | None | None | Default for most users — the sweet spot between freshness and stability |
| **3** | 3 bars | None | None | Swing trading — extra margin against false flickers from erratic ticks |
| **5+** | 5+ bars | None | None | Position trading, long-term chart analysis, published signal marks |
Even at `_phase = 0`, **historical repainting never occurs** — only the live bar flickers during its own development. Once a bar closes, its plotted value is final; scrolling away and back, refreshing the chart, or re-opening TradingView will never change that historical plot. The flicker is exclusively a live-bar tick-by-tick phenomenon.
**KernelLens as a Non-Repainting Primitive**
KernelLens exposes real-time flicker as an explicit, user-controlled trade-off rather than a hidden behavior. The caller picks any point on the spectrum from "fully live" (`_phase = 0`, maximum reactivity with tick-by-tick flicker) to "fully confirmed" (`_phase ≥ 1`, one or more bars of lag in exchange for a curve that never redraws) with a single integer parameter. Historical repainting — the dangerous form that silently rewrites past plots — is eliminated unconditionally regardless of `_phase`.
**How to Verify Non-Repainting Yourself**
Do not trust the word "non-repainting" from any library — always verify. KernelLens can be verified in about thirty seconds:
1. Load a chart with KernelLens on it using `_phase = 2` (or any value > 0).
2. Take a screenshot at any specific historical bar.
3. Scroll far to the left, refresh the chart, or reload the indicator.
4. Return to the same bar. The plotted value at that bar must be pixel-identical to the screenshot — because the computation on that bar used only the bars before it, which have not changed.
5. Repeat with `_phase = 0`. The historical bars must still be pixel-identical — only the live bar's plot can differ between observations, and only because the live bar's `close` is now a different number than it was when you took the screenshot.
For a stricter test, use TradingView's **Bar Replay** mode. Enable Bar Replay, step forward one bar at a time, and watch the kernel plot on each newly-closed bar. With `_phase ≥ 1`, the value plotted on each newly-closed bar will exactly match what the indicator shows after you exit replay mode and view the same bar normally. This is the gold-standard test — Bar Replay reproduces live-bar tick arrival in a controlled way.
**Common Misconceptions**
> *"Any Pine indicator that uses `close` repaints."*
False. Using `close` on a confirmed bar does not repaint — the confirmed bar's close is locked. What can repaint is using `close` on the live bar, and only within that live bar's interval. KernelLens with `_phase > 0` never reads the live-bar close at all.
> *"`lookahead = barmerge.lookahead_on` is always wrong."*
Context-dependent. `lookahead_on` is used correctly in some multi-timeframe indicators to request a higher-TF value that is already settled on the lower TF. KernelLens does not use `request.security` at all, so this question does not apply — but for libraries that do, `lookahead_on` is only problematic when it leaks values from bars that were not yet closed at the lower-TF time of evaluation.
> *"Non-repainting means zero lag."*
False. Zero lag and non-repainting are orthogonal properties. KernelLens `_phase = 0` is zero lag with real-time flicker; `_phase = 2` is two-bar lag with no flicker. You can have any combination of the two, and the right choice depends on the trading style.
> *"The `FILTER_ZEROLAG` mode makes the indicator non-repainting."*
False. `FILTER_ZEROLAG` is an Ehlers-style de-lagging filter applied to the kernel output; it reduces the perceived lag of the estimate, but it does not affect whether the live bar flickers. Non-repainting is controlled exclusively by `_phase`. Choose `_phase` for repainting behavior, and `_filter` for smoothness / lag shape — they are independent knobs.
**When to Accept Real-Time Flicker (`_phase = 0`)**
Despite everything above, there are legitimate reasons to deliberately use `_phase = 0`:
- **Academic research and backtesting** — you want the kernel mathematics in its classical form, centered on the point being estimated, with no phase adjustment
- **Scalping on very short timeframes** — a 2-bar lag on a 1-minute chart is a 2-minute delay, which can matter when you are exiting within a 4-minute window
- **Visual calibration** — when you are choosing a bandwidth by eye, the live-bar flicker actually helps: you see how sensitive the curve is to each incoming tick, which is diagnostic information
- **Indicators that read the kernel output only on `barstate.isconfirmed`** — if your signal logic is gated by `if barstate.isconfirmed`, then live-bar flicker is invisible to your signal (it sees only the frozen close-of-bar value), and you can safely use `_phase = 0` with no practical consequence
For every other case — and especially for any live alert or automated trading system — use `_phase ≥ 1`. Two bars of lag on a clean, stable curve is almost always worth more than zero lag on a curve that redraws itself several times per bar.
🟦 UNIFIED DISPATCHER — `estimate()`
For indicators where the user picks a kernel from a dropdown, writing eight separate ternary branches is tedious and error-prone. KernelLens ships with a unified dispatcher that routes to the correct kernel based on a string argument:
```pine
import a_jabbaroff/KernelLens/1 as kl
line = kl.estimate(
kernelType = kl.KERNEL_GAUSS,
src = close,
bandwidth = 32,
shapeAlpha = 1.0,
period = 1,
phase = 2,
filter = kl.FILTER_SMOOTH)
```
The dispatcher forwards to the matching typed export, so there is no performance penalty versus calling the kernel directly — it is a compile-time routing pass. Unknown kernel names raise a descriptive `runtime.error` naming every valid alternative, so typos fail loudly instead of silently returning `na`.
**Public Constants**
KernelLens exposes its string constants so callers never type the magic values by hand:
| Constant | Value |
|---|---|
| `FILTER_NONE` | `"No Filter"` |
| `FILTER_SMOOTH` | `"Smooth"` |
| `FILTER_ZEROLAG` | `"Zero Lag"` |
| `KERNEL_RQ` | `"Rational Quadratic"` |
| `KERNEL_GAUSS` | `"Gaussian"` |
| `KERNEL_PERIODIC` | `"Periodic"` |
| `KERNEL_LOCPER` | `"Locally Periodic"` |
| `KERNEL_EPA` | `"Epanechnikov"` |
| `KERNEL_TRICUBE` | `"Tricube"` |
| `KERNEL_TRIANG` | `"Triangular"` |
| `KERNEL_COSINE` | `"Cosine"` |
Using the constants in your caller code means the Pine compiler — not a runtime string compare — catches typos at edit time.
🟦 UTILITY LAYER — FIVE PROFESSIONAL HELPERS
KernelLens ships with five utility exports that complement the core estimators. They are the functions you almost always write immediately after getting a smoothed line, factored out so you don't rewrite them in every indicator.
**`slope(estimate, step)` — Discrete First Derivative**
Returns `(y_t − y_{t−step}) / step`, the normalized rate of change over `step` bars. Use it to detect whether a kernel output is trending up, flat, or down — the foundation for any trend-following signal built on top of KernelLens.
```pine
rising = kl.slope(line, 3) > 0.0
```
**`trendState(estimate, step)` — Ternary Trend Indicator**
Returns `+1` if the estimate is rising, `−1` if falling, `0` if exactly flat over the window. A single-call replacement for hand-rolled `line > line ? 1 : line < line ? -1 : 0` ladders.
**`crossSignal(fast, slow)` — Bi-directional Crossover**
Returns `+1` on the bar where `fast` crosses above `slow` (bullish), `−1` on a bearish cross, and `0` otherwise. Built on `ta.crossover` / `ta.crossunder`, so the signal is non-repainting once the bar is confirmed.
**`confidenceBand(src, estimate, window)` — Residual Standard Deviation**
Computes the rolling standard deviation of `(src − estimate)` over a user-defined window. Use the return value as the half-width of a confidence band around the estimate:
```pine
est = kl.gaussian(close, 32, 2, kl.FILTER_SMOOTH)
sigma = kl.confidenceBand(close, est, 50)
upper = est + 1.96 * sigma
lower = est - 1.96 * sigma
```
This is a computationally cheap proxy for the full kernel-weighted local variance — ideal when you need visual bands without paying for a second weighted pass.
**`silvermanBandwidth(src, window)` — Optimal ℓ Suggestion**
Returns the Silverman rule-of-thumb bandwidth:
```
h ≈ 1.06 · σ · n^(−1/5)
```
where `σ` is the rolling standard deviation of the source and `n` is the window size. This is the classical starting point for Gaussian-family bandwidths in academic texts (Silverman 1986). Because Pine requires `simple int` for kernel bandwidth, the returned value is intended for diagnostic display — plot it, read it off the chart, then hard-code the rounded integer into the kernel call.
🟦 INPUT VALIDATION — FAIL LOUDLY, FAIL EARLY
Every public function in KernelLens validates its inputs through a set of internal `_assert*` helpers. Invalid arguments never produce silent `na` fallbacks or buried zero-divisions — they raise `runtime.error` with a descriptive message identifying the function, the parameter, and the expected range.
| Helper | Checks | Raises On |
|---|---|---|
| `_assertFilter` | Filter string is `FILTER_NONE`, `FILTER_SMOOTH`, or `FILTER_ZEROLAG` | Typos like `"No FIlter"` (capital I) — a bug that exists in at least one published kernel indicator |
| `_assertBandwidth` | Bandwidth is a strictly positive integer | Negative or zero bandwidth, which would cause division by zero or infinite loops |
| `_assertPeriod` | Period is a strictly positive integer | Zero period, which would cause `sin(π·d/0)` in Periodic kernels |
| `_assertAlpha` | Rational Quadratic shape parameter is strictly positive | Zero or negative `α`, which would invert the RQ formula |
Error messages are prefixed `KernelLens:` (or `KernelLens.:`) so they are easy to spot in the TradingView runtime log. Every message names the parameter that failed, the value that was passed, and the set of valid alternatives — so a misconfigured chart tells you exactly what to fix.
🟦 LOOP DEPTH — THE BUG FIX THAT MOTIVATED KERNELLENS
The two most popular Pine kernel libraries on TradingView share the same fatal bug: both compute their loop depth as
```pine
_size = array.size(array.from(_src))
```
where `array.from(_src)` creates a **one-element array containing the current value of `_src`**, so `_size` is always `1`. The loop then runs `for i = 0 to 1 + startAtBar`, effectively using only `startAtBar + 2` bars — completely ignoring the user's bandwidth. Every published kernel indicator built on those libraries inherits this silent miscalculation.
KernelLens replaces the broken helper with three explicit depth selectors:
| Helper | Depth | Used By |
|---|---|---|
| `_depthInfinite(bw)` | `max(bw · 3, 4)` | Gaussian, Rational Quadratic, Locally Periodic |
| `_depthCompact(bw)` | `max(bw, 4)` | Epanechnikov, Tricube, Triangular, Cosine |
| `_depthPeriodic(bw, p)` | `max(bw · 3, p · 10, 4)` | Periodic |
For Gaussian-family kernels, the `3·ℓ` cutoff captures approximately 99.7% of the kernel mass (the three-sigma rule). For compact-support kernels, the depth equals the bandwidth exactly — the loop terminates at the kernel's natural zero point. For Periodic kernels, the depth is the larger of the scale-based and cycle-based minima, so the loop always spans enough periods to produce a stable weighted average.
The loop counter `i` runs over bar offsets starting at `_phase`, every bar lookup is NA-checked before being incorporated into the sum, and the final `num / den` division is guarded against zero denominators. On a fresh chart, the kernel gracefully returns `na` for bars where the window extends past available history, rather than producing poisoned sums from implicit NA arithmetic.
🟦 API REFERENCE
**Core Kernel Estimators — Eight Exports**
| Export | Signature |
|---|---|
| `rationalQuadratic` | `(src, bandwidth, shapeAlpha, phase, filter) → float` |
| `gaussian` | `(src, bandwidth, phase, filter) → float` |
| `periodic` | `(src, bandwidth, period, phase, filter) → float` |
| `locallyPeriodic` | `(src, bandwidth, period, phase, filter) → float` |
| `epanechnikov` | `(src, bandwidth, phase, filter) → float` |
| `tricube` | `(src, bandwidth, phase, filter) → float` |
| `triangular` | `(src, bandwidth, phase, filter) → float` |
| `cosineKernel` | `(src, bandwidth, phase, filter) → float` |
**Unified Dispatcher**
| Export | Signature |
|---|---|
| `estimate` | `(kernelType, src, bandwidth, shapeAlpha, period, phase, filter) → float` |
**Utility Layer — Five Exports**
| Export | Signature |
|---|---|
| `slope` | `(estimate, step) → float` |
| `trendState` | `(estimate, step) → int` |
| `crossSignal` | `(fast, slow) → int` |
| `confidenceBand` | `(src, estimate, window) → float` |
| `silvermanBandwidth` | `(src, window) → float` |
**Parameter Types**
| Name | Pine Type | Description |
|---|---|---|
| `src` | `series float` | Source series (close, hl2, ohlc4, or any other price-derived series) |
| `bandwidth` | `simple int` | Kernel scale `ℓ`, must be `> 0` |
| `shapeAlpha` | `simple float` | Rational Quadratic shape parameter, must be `> 0` |
| `period` | `simple int` | Periodic repetition distance, must be `> 0` |
| `phase` | `simple int` | Kernel center offset in bars, must be `≥ 0` |
| `filter` | `simple string` | One of `FILTER_NONE`, `FILTER_SMOOTH`, `FILTER_ZEROLAG` |
| `kernelType` | `simple string` | One of the eight `KERNEL_*` constants |
| `step` | `simple int` | Finite-difference step for `slope` / `trendState`, must be `≥ 1` |
| `window` | `simple int` | Rolling window for `confidenceBand` / `silvermanBandwidth`, must be `≥ 2` |
🟦 USAGE EXAMPLES
**Minimal — One Gaussian Curve**
```pine
//@version=6
indicator("KernelLens — Gaussian Demo", overlay = true)
import a_jabbaroff/KernelLens/1 as kl
line = kl.gaussian(close, 32, 2, kl.FILTER_SMOOTH)
plot(line, "Gaussian", color = color.orange, linewidth = 2)
```
**Fast / Slow Crossover System**
```pine
//@version=6
indicator("KernelLens — RQ Crossover", overlay = true)
import a_jabbaroff/KernelLens/1 as kl
fast = kl.rationalQuadratic(close, 8, 1.0, 2, kl.FILTER_NONE)
slow = kl.rationalQuadratic(close, 32, 1.0, 2, kl.FILTER_SMOOTH)
cross = kl.crossSignal(fast, slow)
plot(fast, "Fast", color = color.aqua, linewidth = 2)
plot(slow, "Slow", color = color.orange, linewidth = 2)
plotshape(cross == 1, "Bull", location = location.belowbar,
color = color.lime, style = shape.triangleup, size = size.tiny)
plotshape(cross == -1, "Bear", location = location.abovebar,
color = color.red, style = shape.triangledown, size = size.tiny)
```
**Confidence Band Envelope**
```pine
//@version=6
indicator("KernelLens — Confidence Band", overlay = true)
import a_jabbaroff/KernelLens/1 as kl
est = kl.tricube(close, 48, 2, kl.FILTER_SMOOTH)
sigma = kl.confidenceBand(close, est, 50)
k = 1.96
upper = est + k * sigma
lower = est - k * sigma
plot(est, "Estimate", color = color.orange, linewidth = 2)
p1 = plot(upper, "+1.96σ", color = color.new(color.aqua, 70))
p2 = plot(lower, "−1.96σ", color = color.new(color.aqua, 70))
fill(p1, p2, color = color.new(color.aqua, 92))
```
**Dropdown-Driven Kernel Selection**
```pine
//@version=6
indicator("KernelLens — Dropdown", overlay = true)
import a_jabbaroff/KernelLens/1 as kl
kernelType = input.string(kl.KERNEL_GAUSS, "Kernel",
options = )
bandwidth = input.int(32, "Bandwidth", minval = 2)
alphaRQ = input.float(1.0,"RQ Alpha", minval = 0.01, step = 0.25)
period = input.int(20, "Period", minval = 1)
phase = input.int(2, "Phase", minval = 0)
filter = input.string(kl.FILTER_SMOOTH, "Filter",
options = )
line = kl.estimate(kernelType, close, bandwidth, alphaRQ, period, phase, filter)
plot(line, "KernelLens", color = color.orange, linewidth = 2)
```
🟦 TIMEFRAME PRESETS — BANDWIDTH BY STYLE
Kernel bandwidth is the single most important parameter. It controls the trade-off between reactivity (small `ℓ`, tight fit, noisier) and stability (large `ℓ`, smooth curve, slower to react). The presets below are tested starting points — adjust by ±25 % to taste.
---
**SCALPER — 1m / 3m / 5m**
| Parameter | Value |
|---|---|
| Bandwidth (ℓ) | 8 |
| Phase | 1 |
| Filter | `FILTER_NONE` |
| Best Kernel | Rational Quadratic or Gaussian |
| RQ shapeAlpha | 1.0 |
**Why:** Short bandwidth means the kernel reacts within a handful of bars. `FILTER_NONE` removes the double-pass lag, so the estimate tracks price as tightly as possible. Phase 1 keeps the estimate nearly live while still avoiding the current-bar tick noise.
---
**DAY TRADER — 15m / 30m / 1H**
| Parameter | Value |
|---|---|
| Bandwidth (ℓ) | 16 |
| Phase | 2 |
| Filter | `FILTER_SMOOTH` |
| Best Kernel | Gaussian or Tricube |
| RQ shapeAlpha | 1.0 |
**Why:** Balanced reactivity — the 16-bar Gaussian is the default Silverman range for intraday price data, and `FILTER_SMOOTH` removes most of the bar-to-bar chop without significantly increasing lag. Tricube provides near-identical behaviour with strict compact support and is preferred on noisy assets where outlier bars should not influence the curve.
---
**SWING TRADER — 4H / 1D**
| Parameter | Value |
|---|---|
| Bandwidth (ℓ) | 32 |
| Phase | 3 |
| Filter | `FILTER_SMOOTH` |
| Best Kernel | Rational Quadratic |
| RQ shapeAlpha | 2.0 |
**Why:** Swing trades need structural signals, not intraday noise. Rational Quadratic with `α = 2.0` mixes medium and long length scales, producing a curve that ignores transient spikes but catches genuine regime shifts. Phase 3 shifts the estimate three bars back so each swing decision is made against a fully confirmed kernel output.
---
**POSITION / LONG-TERM — 1D / 1W / 1M**
| Parameter | Value |
|---|---|
| Bandwidth (ℓ) | 64 |
| Phase | 5 |
| Filter | `FILTER_SMOOTH` or `FILTER_ZEROLAG` |
| Best Kernel | Gaussian or Locally Periodic |
| Period (if LP) | 52 (weekly cycle) |
**Why:** Position traders care about the macro trajectory. A Gaussian with ℓ = 64 produces a curve that only turns on genuine multi-month inflections. Locally Periodic with `period = 52` is the ideal choice when a clear seasonal cycle is present — it uses both the long-range Gaussian envelope and the 52-bar periodicity to highlight cycle turns that align with trend.
---
**RESEARCH — Academic / Backtest**
| Parameter | Value |
|---|---|
| Bandwidth (ℓ) | Compute via `silvermanBandwidth(src, 200)` |
| Phase | 0 |
| Filter | `FILTER_NONE` |
| Best Kernel | Epanechnikov |
**Why:** Epanechnikov is the MSE-optimal kernel; `FILTER_NONE` keeps the estimator in its classical single-pass form; `phase = 0` centers the kernel on the bar being evaluated. This is the configuration that matches the statistical literature exactly — use it when publishing research, running Monte-Carlo studies, or calibrating against reference implementations.
🟦 BANDWIDTH SELECTION
Bandwidth `ℓ` is the single most consequential choice in kernel regression. Too small and the estimate overfits local noise; too large and it flattens real structure. KernelLens exposes two helpers to support both manual and semi-automated bandwidth selection.
**Manual — Start with ℓ ≈ √n**
A practical starting point for financial time series: set `ℓ ≈ √window_of_interest`. If you care about 100-bar structure, try `ℓ = 10`. If you care about 400-bar structure, try `ℓ = 20`. Adjust by ±25 % based on how noisy the result looks.
**Silverman's Rule of Thumb**
The closed-form optimal bandwidth for Gaussian-family kernels under Gaussian source assumptions:
```
h ≈ 1.06 · σ · n^(−1/5)
```
Call `silvermanBandwidth(src, window)` to compute this value live. Because Pine requires `simple int` bandwidth at compile time, the returned value is for diagnostic use — plot it, read the stable value off the chart, then hard-code the rounded integer into your kernel calls.
**Leave-One-Out Cross-Validation (Manual)**
For academic rigor, compute the leave-one-out mean squared error for a range of bandwidths and pick the minimum. KernelLens does not automate this (it would require `series int` bandwidth, which Pine does not support inside kernel loops), but the formula is straightforward:
```
LOOCV(ℓ) = (1/n) · Σᵢ (yᵢ − ŷᵢ⁻ⁱ(ℓ))²
```
where `ŷᵢ⁻ⁱ` is the kernel estimate at bar `i` computed without including bar `i` in the sum. Evaluate offline, pick the minimum, hard-code the result.
🟦 FILTER SELECTION — WHEN TO USE EACH
| Filter | Best For | Avoid When |
|---|---|---|
| `FILTER_NONE` | Live signal generation, research / calibration, compact-support kernels on noisy data | Choppy markets where you need extra smoothing |
| `FILTER_SMOOTH` | Swing and position trades, confidence band midlines, most day-trading setups | Scalping — the double pass adds measurable lag |
| `FILTER_ZEROLAG` | Regime detection, crossover systems that need the curve to track price tightly | Low-volume assets — Zero Lag amplifies high-frequency noise |
The three filters use the same underlying kernel with the same bandwidth, so switching between them does not require re-tuning. Default to `FILTER_SMOOTH` when in doubt — it is the best-behaved option across the widest range of assets and timeframes.
🟦 COMPATIBILITY
KernelLens targets Pine Script v6 and runs on every TradingView chart — no exchange, asset class, or timeframe restriction.
- **Crypto** — Spot, futures, perpetual contracts
- **Forex** — All majors, minors, and exotics
- **Equities** — Stocks, ETFs, indices
- **Commodities** — Metals, energy, agriculture
- **Timeframes** — 1 minute through Monthly
The library is deterministic — given the same source and parameters, every bar of every symbol produces the same estimate. No calibration is needed across assets; the bandwidth parameter alone controls smoothness, and the kernel formulas are scale-free in the source dimension. Silverman's bandwidth helper automatically adapts to each asset's volatility.
🟦 TECHNICAL NOTES
- **Pine Script v6** — uses the modern type system, strict type checking, and the `switch` expression in the unified dispatcher
- **Non-repainting** — kernel outputs for any confirmed bar depend only on that bar's history; there is no look-ahead, no `request.security` with lookahead, and no dependency on the unconfirmed current bar unless `_phase = 0` is deliberately chosen
- **NA-safe iteration** — every bar lookup inside a kernel loop is guarded by `if not na(y)`, so chart history gaps and warm-up bars cannot poison the weighted sum
- **Division-by-zero protection** — every kernel's final division checks `den > 0.0` and returns `na` if the denominator collapses (which can only happen on truly empty windows)
- **Input validation** — every public function asserts its preconditions up front via `_assertFilter`, `_assertBandwidth`, `_assertPeriod`, `_assertAlpha`, and raises `runtime.error` with a descriptive message on misuse — no silent `na` fallbacks
- **Lazy filter evaluation** — the `"No Filter"` path never executes the second kernel pass; the `if`-branch check short-circuits, so single-pass mode is as cheap as a raw kernel call
- **Correct loop bounds** — `_depthInfinite`, `_depthCompact`, and `_depthPeriodic` compute the correct window size per kernel family, fixing the silent `_size = 1` bug that plagues every other published Pine kernel library
- **No persistent state** — the library is purely functional: no `var`, no arrays, no history buffers that grow over time; every export is a pure expression of `(inputs) → output`, so Pine's `max_*_count` limits cannot be exceeded and the library cannot leak memory
- **O(bandwidth) per bar per kernel call** — the loop depth is bounded by the constants in Section 0; there is no hidden quadratic behavior and the cost scales linearly with the user-chosen bandwidth
- **Unicode-safe comments** — the source uses academic notation (`σ`, `ℓ`, `α`, `ŷ`, `ℝ`) where it improves readability; all strings are plain ASCII for runtime compatibility
🟦 ACADEMIC REFERENCES
Every kernel and every formula in KernelLens is cited inline in the source. The combined bibliography:
- **Nadaraya, E. A. (1964).** On estimating regression. *Theory of Probability & Its Applications*, 9(1), 141–142.
- **Watson, G. S. (1964).** Smooth regression analysis. *Sankhyā: The Indian Journal of Statistics, Series A*, 26(4), 359–372.
- **Cleveland, W. S. (1979).** Robust locally weighted regression and smoothing scatterplots. *Journal of the American Statistical Association*, 74(368), 829–836. *(Tricube kernel, LOWESS.)*
- **Silverman, B. W. (1986).** *Density Estimation for Statistics and Data Analysis*. Chapman & Hall, London. *(Bandwidth rule of thumb.)*
- **Wand, M. P. & Jones, M. C. (1995).** *Kernel Smoothing*. Chapman & Hall. *(Unified treatment of all eight kernels.)*
- **MacKay, D. J. C. (1998).** Introduction to Gaussian Processes. *NIPS Tutorial*. *(Periodic and Rational Quadratic kernels.)*
- **Ehlers, J. F. (2000).** *Rocket Science for Traders*. John Wiley & Sons. *(Zero-lag smoothing trick.)*
- **Rasmussen, C. E. & Williams, C. K. I. (2006).** *Gaussian Processes for Machine Learning*. MIT Press. *(Locally Periodic and Rational Quadratic kernels.)*
🟦 VERSIONING & LICENSE
- **Version** — 1.0.0
- **Pine Script** — v6
- **License** — Mozilla Public License 2.0
- **Status** — Production-ready
KernelLens follows semantic versioning. Minor versions add new exports without breaking existing ones; patch versions fix bugs; major versions may change function signatures and will be announced in the changelog.
🟦 DISCLAIMER
KernelLens is a mathematical library for non-parametric regression on financial time series using the Nadaraya–Watson method. The library is provided solely for educational and research purposes and does not constitute financial, investment, or trading advice.
Kernel regression is a local smoothing technique. It estimates the mean of a source series in the neighborhood of the current bar based on historical data, but it does not predict future prices, does not generate trading signals on its own, and does not guarantee the profitability of any strategy built on top of its output.
Past performance of any model does not guarantee future results. Markets contain systemic risks that cannot be eliminated by any amount of mathematical rigor in the kernel itself. Responsibility for any trading decisions made using this library rests entirely with the user. Always apply sound capital management, conduct your own independent analysis, and never risk capital you are not prepared to lose.
The author assumes no liability for direct or indirect losses incurred through the use of KernelLens or any indicator built on top of it. مكتبة
Dynamic FibTrend Signals [MarkitTick]💡 This indicator represents an advanced multi-layered analytical framework designed to synchronize trend identification with structural market geometry. By integrating adaptive trend-following logic with automated price action mapping, the tool serves as a comprehensive dashboard for traders seeking to identify high-probability entry zones. It solves the common problem of "indicator clutter" by condensing volatility-adjusted trend direction, swing structure recognition, and Fibonacci retracement depth into a single, cohesive visual interface that provides real-time trade execution levels based on current market volatility.
● ✨ Originality and Utility
The primary utility of this script lies in its ability to bridge the gap between momentum-based trend following and static price levels. While many scripts focus on a single aspect of technical analysis, this indicator utilizes a synergistic approach:
It combines the volatility-sensitive nature of SuperTrend with the objective structural points of Pivot Highs and Lows.
It automates the projection of Fibonacci retracement levels based on a dynamic lookback period, ensuring that support and defense zones are always relevant to recent price action.
Unlike standard tools that leave the user to determine their own risk, this system automatically calculates a suggested entry, stop loss, and multiple target levels using Average True Range (ATR) to adjust for current market volatility.
● 🔬 Methodology and Concepts
The core engine operates on a tripartite logic system:
Trend Quantification: The system employs an Average True Range (ATR) calculation multiplied by a specific factor to create a dynamic band around the price. This determines the prevailing bias (Bullish or Bearish) and filters out market noise.
Structural Mapping: Through a pivot-point algorithm, the script identifies "Swing" levels. These are points where the market has shown significant rejection, helping to define the current trading range.
Risk Geometry: Upon a trend shift (signal), the script calculates trade levels. The Entry is based on the previous bar's close, while the Stop Loss and Profit Targets are mathematically derived from the ATR. This ensures that the risk-to-reward ratio remains consistent regardless of whether the market is in a high or low-volatility state.
● 🎨 Visual Guide
The chart interface is designed for high legibility, using distinct color coding and shapes to signify different market states:
SuperTrend Line: A continuous line that turns Green during bullish momentum and Red during bearish momentum. The area between this line and the price is filled with a subtle transparency to highlight the "trend cloud."
Signal Arrows: Bright green "BUY" arrows appear below the bars for bullish transitions, and red "SELL" arrows appear above the bars for bearish transitions.
Swing Markers: Small orange downward triangles mark Swing Highs, while blue upward triangles mark Swing Lows. These are accompanied by dashed horizontal lines projecting the price level forward.
Fibonacci Grid: A series of purple dotted horizontal lines representing key retracement levels (0%, 23.6%, 38.2%, 50%, 61.8%, 78.6%, 100%). These levels provide context for potential pullbacks within the main trend.
Trade Execution Box: When a signal is generated, a yellow entry box appears along with three distinct lines:
Yellow Line: The specific Entry price.
Green Dashed Line: The Target (Take Profit) level.
Red Dashed Line: The Stop Loss level.
Info Table: A professional-grade data table in the top-right corner summarizes the current trend status, the most recent swing levels, and the active trade coordinates for quick reference.
● 📖 How to Use
Trend Identification: Observe the color of the SuperTrend line. If the line is green and the price is above it, focus on long opportunities. If red, focus on shorts.
Confirmation: Look for signals where the SuperTrend flip aligns with a bounce off a Fibonacci level (specifically the 50% or 61.8% "Golden Pocket").
Execution: When a "BUY" or "SELL" arrow appears, refer to the yellow entry zone. The script projects these levels 40 bars into the future to allow for trade planning.
Exit Strategy: Use the target line for profit-taking and the red stop-loss line for capital protection. The 2:1 risk-to-reward ratio is the default, but this can be adjusted in the settings.
● ⚙️ Inputs and Settings
⚡ SuperTrend: Adjust the ATR Length and Factor. A higher factor makes the trend slower and more resilient to whipsaws, while a lower factor makes it more sensitive.
🔄 Swing High / Low: Define the lookback period for pivot detection. Increasing this value will only identify major market turns.
📐 Fibonacci Retracement: Change the lookback bars for the Fibonacci grid. This determines the "height" of the range being measured.
🎯 Trade Levels: Set your desired Risk-to-Reward ratio (default is 2.0). You can also toggle the visibility of the entry, target, and stop lines.
● 🔍 Deconstruction of the Underlying Scientific and Academic Framework
The indicator is built upon the "Volatility Clustering" theory, which suggests that market volatility is not constant but occurs in bursts. By using ATR-based thresholds, the indicator applies a statistical filter that expands and contracts based on realized variance. The swing detection logic utilizes a "Windowed Extrema" approach, which is a fundamental concept in time-series analysis for identifying local maxima and minima within a defined temporal window. Furthermore, the integration of Fibonacci ratios (specifically the 0.618 Golden Mean) incorporates elements of fractal geometry and Elliott Wave theory, positing that market corrections often move in proportions derived from the Fibonacci sequence. The final trade execution component utilizes a fixed-fractional risk management model, ensuring that trade parameters are mathematically optimized for the current market environment rather than being based on arbitrary price distances.
⚠️ Disclaimer
All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion. مؤشر
Statistical Zone Engine [JOAT]Statistical Zone Engine
Introduction
Statistical Zone Engine is an open-source overlay indicator that builds pivot-cluster support and resistance zones with walk-forward statistical scoring. Each zone is backed by a full expected value computation: the indicator counts historical touches and bounces from the zone's price range over a configurable lookback, computes a win rate, and derives an EV score in units of R. Zones are tiered into four strength categories — Weak, Moderate, Strong, and Institutional — based on their live touch count, with border thickness and fill opacity scaling proportionally to the EV and tier. Labels display R:R, win rate, EV, and touch count, all updated live each bar.
The core problem this indicator solves is that conventional support and resistance drawing tools are entirely qualitative — the trader decides what is significant by eye. The SZE replaces that subjective judgment with a quantitative framework: zone strength is computed from actual price behavior over the lookback window, not from the visual prominence of the swing. A zone that has been tested eight times with seven bounces carries an objectively different statistical weight from one that was tested twice with one bounce, and the SZE communicates that difference through its tier system, border rendering, and live EV label. Cluster merging prevents adjacent pivots at nearly the same price from spawning overlapping zones that would misrepresent true strength.
Core Concepts
1. Pivot Cluster Zones
The indicator uses ta.pivothigh and ta.pivotlow with a configurable swing length. When a new pivot high is confirmed and no existing resistance zone is within ATR * clusterTol of the pivot price, a new zone is created. The cluster merge check prevents nearby pivots from generating duplicate zones at the same structural level — if a zone already exists within the tolerance radius, no new zone is spawned. This means zones represent genuinely distinct price levels, not just the most recent pivot above an existing zone.
2. Walk-Forward Expected Value Computation
For each new zone, the indicator scans the prior lookback bars and counts every bar where the high-low range overlapped with the zone. For each touch, it checks whether the close exited the far side of the zone — if so, it counts as a bounce. Win rate = bounces / touches. EV = winRate * tpRR - (1 - winRate) * slRR. A positive EV means the zone has historically resolved in the bounce direction more often than not, weighted by the configured R:R ratio.
3. Four-Tier Strength System
Zone tier is determined by live touch count:
Weak: 1-2 touches — thin border (width 1), low opacity fill
Moderate: 3 touches — medium border (width 1), moderate opacity fill
Strong: 4-5 touches — thicker border (width 2), more opaque fill
Institutional: 6+ touches — widest border (width 3), most opaque fill
Both the border width and the border transparency scale with tier, producing a visual system where the most historically significant zones dominate the chart. The fill opacity also scales with EV — zones with positive EV are more opaque, zones with negative EV are more transparent.
4. Live Label Updates
Each zone carries a label at its right edge displaying: type (RES/SUP), tier name, touch count, win rate percentage, and EV in R units. The label is recalculated and updated every bar when price is inside the zone, ensuring the statistics reflect current behavior. The label text color also scales with tier — more significant zones use brighter text.
5. Sweep Detection
When price closes fully through a zone boundary — above the top for resistance, below the bottom for support — the zone is marked as mitigated. If volume exceeds 1.4x the SMA(20) at the mitigation bar, a BREAK label fires above or below the zone. The total sweep count accumulates in the dashboard. After a break, zone fill fades to near-transparent, clearly communicating that the level has been closed through.
Features
Pivot-Cluster Zone Detection: Swing-pivot based zone creation with ATR-cluster merge deduplication — nearby pivots do not spawn overlapping zones
Walk-Forward EV Computation: Historical touch/bounce counting over configurable lookback produces win rate and R-unit EV scores for each zone
Four-Tier Strength System: Weak / Moderate / Strong / Institutional tiers based on touch count — border width and opacity scale with tier
EV-Scaled Fill Opacity: Positive EV zones are more opaque, negative EV zones are more transparent — fill intensity communicates statistical quality
Live Label Updates: Type, tier, touch count, win rate %, and EV in R units update every bar when price is inside the zone
Sweep Detection with Volume Filter: BREAK label fires on zone close-through when volume exceeds 1.4x SMA(20)
Post-Break Zone Fade: Broken zones fade visually, clearly delineating active versus mitigated levels
Proximity Markers: Diamond plotchar fires when price first enters a zone neighborhood
Min Touches Filter: Only zones with at least the configured minimum historical touches are displayed, eliminating freshly-formed single-touch zones
Zone Trim Management: Oldest zones are removed when arrays exceed the maximum zone count, keeping memory bounded
9-Row Dashboard: Active resistance and support zone counts, near-zone states, total sweep count, TP and SL R:R ratios, ATR
4 Alertconditions: Zone entry for resistance and support, new zone creation for both sides
Input Parameters
Zone Detection:
Swing Length: Pivot confirmation lookback period — higher values detect fewer, more significant pivots (default 10)
Cluster ATR Tolerance: Pivots within ATR * this of an existing zone are merged rather than spawning a new zone (default 0.4)
Zone ATR Width: Half the zone height as an ATR multiple — controls vertical thickness (default 0.35)
Max Active Zones: Maximum concurrent zones per direction before oldest are trimmed (default 12)
Min Touches To Show: Minimum historical touches required to display a zone (default 2)
Statistics:
EV Lookback (bars): Historical bar window for touch/bounce counting (default 200)
TP R:R Ratio: Take-profit distance in R units used for EV calculation (default 2.0)
SL R:R Ratio: Stop-loss distance in R units used for EV calculation (default 1.0)
Visuals:
Toggles for zone labels, sweep labels, and dashboard
Resistance Color (default orange #f97316), Support Color (default sky blue #38bdf8)
How to Use This Indicator
Primary Setup — Statistical Zone Entry:
Look for Institutional or Strong zones with positive EV — these are the levels with the longest bounce history weighted by your R:R parameters. When price enters a zone, the live label shows the current win rate. Enter at the zone edge with a stop beyond the far edge and a target at your TP R:R ratio from entry.
EV as a Selection Filter:
Multiple zones may be on the chart simultaneously. Prioritize zones with positive EV labels (e.g., EV: 1.25R) over zones with negative EV. A zone with 4 touches and 75% win rate at 2R:1R produces an EV of +1.25R per trade — objectively worth trading. A zone with 3 touches and 33% win rate at the same R:R produces EV of -0.33R — not worth trading regardless of how prominent it looks.
Using the Sweep Count:
The total sweep count on the dashboard accumulates every time a zone break is detected with high-volume momentum. Rising sweep counts in one direction indicate the market is consistently breaking through levels on that side — a sign of trending pressure rather than range behavior. Adjust bias accordingly.
Cluster Merge and Fresh Zones:
When a new pivot forms near an existing zone and is merged rather than spawning a new zone, the existing zone's historical statistics remain unchanged. A fresh zone with no historical data will show EV close to 0 — treat these as unproven until more touches accumulate.
Indicator Limitations
EV computation scans up to the full lookback on every qualifying pivot — on very long lookback settings and active pivot instruments, this can increase calculation time
The walk-forward EV uses the same zone size (ATR * width at creation time) for historical counting. If ATR changes significantly between creation time and the historical scan, the touch count may include bars where the equivalent zone boundaries would have been different
Cluster merging uses the current ATR at detection time. In periods of sharply rising or falling ATR, two zones that appear to merge at one ATR level may have been distinct at a different level, potentially underrepresenting zone density
The touch count displayed on the label is the live count updated each bar. The historical bounce count used for EV is computed at creation time and is not re-scanned dynamically — the label win rate reflects creation-time statistics
The minimum touches filter removes zones with fewer historical touches than the threshold. On fresh instruments or small lookbacks, most zones may be filtered out, especially on less-traded timeframes
Originality Statement
This indicator is original in its walk-forward EV scoring framework, four-tier visual strength system driven by live touch counts, and the cluster merging deduplication approach. The publication is justified because:
Walk-forward EV computation in R units provides a quantitative quality signal not found in standard support/resistance tools — each zone is backed by a historically derived expected value, enabling objective zone selection
The four-tier visual system (border width and opacity scaling with tier and EV) embeds the statistical quality directly into the zone appearance, eliminating the need to read labels to gauge significance
ATR-cluster merge deduplication prevents pivot-dense markets from generating overlapping zones at the same structural level, producing a cleaner, more meaningful map than raw pivot-based zone tools
Live label updates during zone interaction show the evolving win rate and EV as each new touch is counted, providing real-time statistical feedback not present in static zone indicators
The post-break fade combined with the total sweep count dashboard provides a structural memory of how many levels have been invalidated, enabling a directional bias gauge derived from zone lifecycle data
Disclaimer
This indicator is provided for educational and informational purposes only and does not constitute financial advice or a recommendation to buy or sell any financial instrument. Past performance of any pattern or signal does not guarantee future results. All trading involves substantial risk. Always use proper risk management and conduct your own independent analysis.
— Made with passion by officialjackofalltrades
مؤشر
Trend Pulse [BigBeluga]🔵 OVERVIEW
Trend Pulse is a structure-driven trend detection indicator that identifies bullish and bearish regime shifts using confirmed pivot breaks and an adaptive volatility-aware trend band.
Instead of relying on momentum oscillators or fixed moving averages, Trend Pulse focuses on market structure, price expansion, and trend aging to determine when a trend starts, matures, and potentially exhausts.
The indicator is designed to visually communicate trend state directly on price using adaptive bands and progressive color transitions.
🔵 CONCEPT
Structure First — Trend direction is defined by confirmed pivot lows and their breaks, not by indicators crossing indicators.
Adaptive Trend Band — A volatility-adjusted SMA band expands over time during bearish phases, making late trend reversals harder to trigger.
Break-Based Trend Shifts — Bullish trends are confirmed only when price breaks above the adaptive band; bearish trends are confirmed by breaking below structural pivots.
Trend Aging — Trend strength is visualized by time-based color gradients that reflect how long a trend has been active, not momentum.
🔵 KEY FEATURES
Pivot-Based Bearish Detection
A bearish trend is triggered only after a confirmed pivot low is broken. This avoids reacting to temporary pullbacks or intrabar noise.
Real-time pivot low level tracking
During a bullish trend, the indicator displays the most recent pivot low level and extends it to the latest bar. This helps identify a potential level where the bullish trend may reverse into a downtrend.
Adaptive Volatility Band
The trend band is built from:
A dynamically expanding SMA length
ATR-based offset for volatility normalization
As the bearish trend matures, the band widens, requiring stronger price expansion to flip the trend back bullish.
Bullish Trend Confirmation via Band Break
A bullish trend is confirmed only when price breaks above the adaptive band, signaling genuine upside expansion rather than a weak bounce.
Automatic Band Reset
On bullish trend shifts, the adaptive band resets to a shorter length, allowing faster reaction to early trend stages.
Time-Based Trend Coloring
Trend color transitions from:
Fresh → Mature
Bullish → Bearish
based purely on how long the trend has persisted since the last flip.
Clear Structural Markers
The indicator plots:
- Confirmed pivot lows
- Bearish breakdown points
- Bullish breakout points
directly on the chart for structural clarity.
Full Candle Coloring
Candles inherit the current trend color, allowing instant visual recognition of market regime without additional indicators.
🔵 HOW TO USE
Use bearish trend shifts to identify structural breakdowns, not just momentum pullbacks.
Treat bullish breaks as confirmation of real trend reversals, not early counter-trend signals.
Use trend color aging to gauge whether a move is early-stage or potentially mature.
Avoid fading trends solely based on color maturity — use it as context, not a reversal signal.
Combine Trend Pulse with structure tools (order blocks, liquidity zones, volume) for higher-confidence entries.
🔵 CONCLUSION
Trend Pulse is a structure-aware trend engine built around confirmed pivots, adaptive volatility logic, and time-based trend visualization.
By separating trend direction from trend age , it avoids common indicator pitfalls such as over-sensitivity and late momentum signals.
This makes Trend Pulse especially effective for traders who want clear regime definition, disciplined trend confirmation, and visual clarity directly on price — without relying on lagging oscillators or fixed moving average systems. مؤشر
Artemis Oscillator PROArtemis Oscillator PRO is a momentum oscillator built on a custom Directional Range Momentum (DRM) engine — an original algorithm that measures signed range impulse, not price distance. Unlike RSI or Stochastic, DRM scores the direction and force of range expansion relative to its own history, normalized to 0–100. The result is an oscillator that reacts cleanly to structural momentum shifts without the lag inherent in traditional smoothed-ratio oscillators.
The indicator integrates five analytical layers — oscillator core, volume pressure, momentum state scoring, divergence detection, and KNN machine learning bias — each operating independently and rendered on a single, clean oscillator panel.
🟦 HOW THE CORE ENGINE WORKS
**Directional Range Momentum (DRM)**
Each bar, the engine measures the current highest high and lowest low over the lookback period. It then assigns a signed range force:
- If the range is expanding to the upside → positive force (full range span)
- If the range is expanding to the downside → negative force (negative full span)
- If range is stable → raw tick delta (neutral)
This signed force is split into two smoothed components:
- `sUp` — smoothed directed force (can be positive or negative)
- `sAbs` — smoothed absolute force (always positive, represents total activity)
The oscillator value is: `(sUp / sAbs) * 50 + 50`
This produces a 0–100 scale where 50 is neutral, above 50 means upward range pressure dominates, and below 50 means downward range pressure dominates. Division by the absolute component normalizes the output regardless of asset volatility.
**Signal Line**
A second independently configurable smoothing pass over the oscillator value. Crossovers between the oscillator and signal line mark momentum regime changes.
**Smoothing Methods**
Four algorithms available for both oscillator and signal line:
- RMA — Wilder's Moving Average (default, most stable, minimal overreaction)
- EMA — Exponential, faster response
- SMA — Simple, equal weight across all bars
- TMA — Double-smoothed SMA, maximum smoothness
🟦 VOLUME PRESSURE
**Dual MFI Architecture**
Volume Pressure uses two Money Flow Index calculations simultaneously:
- Fast MFI: `Period / 1.33` (shorter window, more reactive)
- Slow MFI: `Period * 1.33` (longer window, structural bias)
These are blended 50/50, then passed through a power-curve compression function (`x^0.75`) that reduces extreme readings while preserving directional accuracy. The result is mapped to 0–100 and rendered as fill areas anchored at the midline:
- Above 50: Inflow fill (buying pressure dominates)
- Below 50: Outflow fill (selling pressure dominates)
The MFI price source is configurable: HLC3 (default), Close, HL2, or OHLC4.
🟦 MOMENTUM STATE SCORING
A composite score from 0 to 3 is calculated each bar using three independent binary conditions:
| Condition | +1 Point |
|---|---|
| Oscillator > Signal Line | Momentum direction |
| Oscillator > 50 | Oscillator position |
| Volume Pressure > 50 | Volume confirmation |
**Score interpretation:**
- Score 3 → Full overbought state fill (all three conditions bull-aligned)
- Score 2 → Partial overbought fill (two conditions)
- Score 1 → Partial oversold fill (one condition)
- Score 0 → Full oversold state fill (all three conditions bear-aligned)
Fills render inside the oscillator panel at adjustable opacity. The scoring is continuous — it updates every bar without look-ahead.
🟦 MOMENTUM EXHAUSTION
Exhaustion labels (`✦ OB` / `✦ OS`) fire when the oscillator is inside a zone but weakening consecutively. Specifically:
✦ OB — oscillator is at or above the OB threshold AND has closed lower for N consecutive bars
✦ OS — oscillator is at or below the OS threshold AND has closed higher for N consecutive bars
N (Confirmation Bars) is configurable from 1 to 4. Higher values produce fewer but more structurally confirmed signals. This is not a predictive signal — it marks the process of momentum fading, not the reversal itself.
🟦 DIVERGENCE DETECTION
Pivots are calculated using `ta.pivothigh` and `ta.pivotlow` with an arm of `Period / 2`. All divergence results appear `Period / 2` bars late — this is standard Pine Script pivot behavior, not a bug.
**Four divergence types:**
| Type | Price | Oscillator | Signal |
|---|---|---|---|
| Regular Bull (D▲) | Lower Low | Higher Low | Potential reversal up |
| Regular Bear (D▼) | Higher High | Lower High | Potential reversal down |
| Hidden Bull (H▲) | Higher Low | Lower Low | Uptrend continuation |
| Hidden Bear (H▼) | Lower High | Higher High | Downtrend continuation |
Regular divergence uses solid lines. Hidden divergence uses dashed lines. Labels use clean symbol-only style with no background box.
**Smart Divergence Filter (AI)**
An optional pre-filter that rejects low-quality divergence signals before they render. Three conditions must pass (each configurable independently):
1. Minimum oscillator swing between the two pivot points (default: 5 units)
2. Minimum price swing as a percentage of recent range (default: 0.3%)
3. Volume Pressure confirmation — VP must agree with divergence direction
When the filter is OFF, all detected divergences render. When ON, only structurally significant divergences pass. The filter applies identically to both chart rendering and alert conditions — no mismatch between visual and alert signals.
🟦 KNN BIAS PANEL
**What KNN Does**
K-Nearest Neighbors (KNN) is a non-parametric machine learning algorithm. Each bar, the indicator stores the current market state as a point in 3-dimensional feature space. When making a prediction, it finds the K historically most similar states and votes on the likely outcome.
**The Three Features**
| Feature | Calculation | Signal |
|---|---|---|
| O (Oscillator) | `oscVal / 100` | O+ = above 50 (bull zone) |
| V (Volume) | `vpMid / 100` | V+ = above 50 (inflow) |
| S (Signal gap) | `(oscVal - sigVal + 100) / 200` | S+ = oscillator above trigger |
**ATR-Normalized Output Label**
The classification target uses ATR-adjusted thresholds rather than a raw `close > close ` comparison. A bar is labeled bullish only if close moved more than `0.1 × ATR(14)` upward, bearish if it moved more than `0.1 × ATR(14)` downward, otherwise the previous label is carried forward. This eliminates noise-driven label flips caused by micro price movements.
**Distance Calculation**
Euclidean distance in 3D feature space:
```
d = sqrt((kf1_now - kf1_hist)^2 + (kf2_now - kf2_hist)^2 + (kf3_now - kf3_hist)^2)
```
The K nearest historical points vote. If majority voted bullish → BULL bias. Result thresholds: ≥60% bull vote = BULL, ≤40% = BEAR, between = NEUTRAL.
**Panel Display**
| Row | Left | Right |
|---|---|---|
| Header | KNN AI | Direction (▲ BULL / ▼ BEAR / ◈ NEUTRAL) |
| Row 1 | Confidence | Percentage (0–100%) |
| Row 2 | Progress bar (█░) | Bars in training memory |
| Row 3 | O± V± S± feature states | K= neighbor count |
Panel renders with monospace font, theme-aware backgrounds, and a single accent color derived from the active theme.
🟦 COLOR THEMES
Eight complete palettes, each defining five independently tuned colors (bull, bear, signal, VP buy, VP sell):
| Theme | Character | Bull Color | Bear Color |
|---|---|---|---|
| Aurora | Dark mode, high contrast | Cyan | Violet |
| Ember | Dark mode, warm | Amber | Steel Blue |
| Cyber | Dark mode, neon | Lime Green | Crimson |
| Arctic | Dark mode, cool | Sky Blue | Soft Purple |
| Solar | Dark mode, warm gold | Yellow Gold | Salmon |
| Obsidian | Dark mode, pro trader | Emerald | Scarlet |
| Classic | Light mode | Navy Blue | Crimson |
| Mono | Light mode, minimal | Near Black | Gray |
All five color roles (bull/bear/signal/VP buy/VP sell) change simultaneously when the theme changes. No per-color manual adjustment required.
🟦 ALERT SYSTEM
Twelve alert conditions, all using `alert.freq_once_per_bar`:
| Alert | Condition |
|---|---|
| Bullish Cross | Oscillator crosses above signal while below midline |
| Bearish Cross | Oscillator crosses below signal while above midline |
| Exit Oversold | Oscillator crosses above OS level |
| Exit Overbought | Oscillator crosses below OB level |
| Regular Bull Divergence | Price LL + oscillator HL (+ Smart Filter if enabled) |
| Regular Bear Divergence | Price HH + oscillator LH (+ Smart Filter if enabled) |
| Hidden Bull Divergence | Price HL + oscillator LL (+ Smart Filter if enabled) |
| Hidden Bear Divergence | Price LH + oscillator HH (+ Smart Filter if enabled) |
| VP Inflow | Volume Pressure crosses above 50 |
| VP Outflow | Volume Pressure crosses below 50 |
| Exhaustion OB | Oscillator weakening N bars while above OB level |
| Exhaustion OS | Oscillator strengthening N bars while below OS level |
Divergence alerts respect the Smart Divergence Filter — if the filter is ON and a divergence is rejected visually, the alert will also not fire.
🟦 SETTINGS REFERENCE
**Oscillator**
- Period — DRM lookback window. Also controls divergence pivot arm (Period / 2). Default: 14
- Smoothing — EMA / SMA / RMA / TMA. Default: RMA
- Source — Price input for the range engine. Default: Close
- Adaptive Color — Oscillator line shifts between bull/bear colors based on position. Default: ON
**Signal Line**
- Period — Signal smoothing window. Default: 7
- Smoothing — EMA / SMA / RMA / TMA. Default: EMA
- Show Cross Dots — Dot on signal line at each crossover. Default: ON
**Zones & Fills**
- Overbought level — Default: 80
- Oversold level — Default: 20
- Zone fill opacity — Configurable per zone. Default: 20
**Volume Pressure**
- Show Volume Pressure — Toggle. Default: ON
- MFI Source — HLC3 / Close / HL2 / OHLC4. Default: HLC3
- Opacity — Default: 18
**Momentum State**
- Show Momentum State — Toggle. Default: ON
- OB Opacity / OS Opacity — Default: 35 each
**Divergence**
- Regular / Hidden — Independent toggles and opacity controls
- Label Size — Tiny / Small / Normal / Large. Default: Tiny
- Smart Divergence Filter — ON/OFF. Default: OFF
- Min Oscillator Swing — Default: 5.0
- Min Price Swing % — Default: 0.3%
- Require VP Confirmation — Default: ON
**Momentum Exhaustion**
- Show Labels — Toggle. Default: ON
- Confirmation Bars — 1 to 4. Default: 4
**KNN Bias**
- Show KNN Panel — Toggle. Default: ON
- Neighbors (K) — 3 to 10. Default: 5
- Training Window — 50 to 300 bars. Default: 100
- Panel Position — Four corners. Default: Bottom Right
- Panel Text Size — Tiny / Small / Normal / Large. Default: Small
🟦 COMPATIBILITY
Works on all asset classes and all timeframes in TradingView Pine Script v6.
- Crypto: Spot, futures, perpetual contracts
- Forex: All pairs
- Equities: Stocks, ETFs, indices
- Commodities: Metals, energy, agriculture
- Timeframes: 1m through Monthly
The DRM engine normalizes by its own absolute smoothed component, making it volatility-agnostic across assets and timeframes without manual recalibration.
🟦 TECHNICAL NOTES
- Pine Script v6
- max_lines_count = 500`, `max_labels_count = 500` (divergence drawings)
- No repainting — all values calculated on bar close. Pivot-based divergence results appear `Period / 2` bars late by design
- KNN training updates only after `bar_index > 1` to avoid cold-start artifacts
- Volume Pressure fill anchors use `color = na` (not `display.none`) to maintain Pine v6 `fill()` compatibility
- OB/OS state fills render outside the 0–100 oscillator range (104–110 and −10 to −4) to avoid visual overlap
🟦 DISCLAIMER
This indicator is provided for educational and informational purposes only. It does not constitute financial advice. Past performance does not guarantee future results. Always conduct your own analysis and apply proper risk management.
مؤشر
Volume Acceptance Zones [BigBeluga]Volume Acceptance Zones is a market structure tool designed to identify areas of price acceptance and statistically stretched extremes. By modeling market activity as a continuous distribution, the indicator highlights where price is actively accepted versus where it behaves as a statistical outlier.
The goal is not prediction, but context — separating balanced price behavior from structurally stretched conditions.
🔵 CONCEPTS
The indicator calculates a Volume-Weighted Balance Price , representing the center of gravity for participation over a selected range.
Price dispersion around this balance point is measured using volume-weighted standard deviation .
The area within ±1 standard deviation forms the Acceptance Zone , where the majority of activity is concentrated.
Prices beyond this zone are treated as outliers , where participation thins and market reactions become more likely.
These zones do NOT represent guaranteed probabilities — they describe participation density and behavioral extremes.
🔵 STANDARD DEVIATION, BELL CURVE & OUTLIERS
At the core of this indicator lies the concept of standard deviation , which describes how price activity clusters around a central value.
When activity is observed over time, it tends to form a distribution where:
Most activity concentrates near a central balance level.
Fewer observations occur as price moves further away from that balance.
This behavior can be visualized conceptually as a bell-shaped distribution — a practical way to describe market participation density.
Prices that move beyond the Acceptance Zone deviate meaningfully from the balance of participation.
These areas are treated as outliers , where price is statistically stretched relative to recent market behavior.
Outliers do not imply immediate reversals — they signal that price is operating in a low-acceptance environment.
Market responses in these zones often include rejection, consolidation, or strong continuation if acceptance builds.
🔵 NEW: INTEGRATED FREQUENCY PROFILE
While the zones are calculated using volume-weighted math, the visual profile has been updated to a Frequency-Based Distribution . This transition allows you to see "Time at Price" rather than just raw volume.
Frequency Distribution: The profile counts the number of bars (occurrences) spent at each price bin. This highlights levels of high interest where the market finds it easy to trade, effectively acting as a Time-Price Opportunity (TPO) proxy.
Time-Based Sentiment: Each bin is split into Bull/Bear frequency. This shows which side was in control during the time spent at that specific level, identifying where buyers or sellers were more persistent.
Filtering Noise: By using frequency instead of raw volume, the profile avoids being skewed by single high-volume spikes, focusing instead on where the market established a sustained presence.
🔵 FEATURES
Acceptance Zone (±1σ)
Highlights the primary balance area where price is most actively accepted and rotational behavior is common.
Extreme Zones (±2σ)
Marks statistically stretched prices where acceptance weakens and reactions or trend continuation may occur.
Volume-Weighted Balance Line
Acts as a structural fair-value reference similar to an anchored VWAP.
Outlier Detection
Price closing beyond the acceptance zone is flagged as an outlier, helping identify exhaustion or breakout conditions.
Distribution Labels
Displays how price activity is distributed between acceptance and extreme zones, reinforcing the concept visually.
Flexible Anchoring
Calculations can be based on a fixed lookback or the visible chart range.
🔵 HOW TO USE
Treat the Acceptance Zone as a balance area where price is fairly valued and mean-reversion is common.
Observe how price behaves in Extreme Zones — rejection may signal reversion, while sustained acceptance may indicate trend continuation.
Frequency Nodes: Use the Frequency Profile to identify where the market is "stalling." High frequency nodes often act as magnets for price, while low frequency gaps (low time spent) often lead to fast price movement.
Use outlier signals in combination with trend bias, liquidity levels, or momentum tools.
🔵 CONCLUSION
Volume Acceptance Zones reframes market analysis around participation density. By distinguishing accepted price behavior from statistical outliers and providing a frequency-based view of time-at-price, the indicator helps traders understand when the market is balanced—and when it is structurally stretched. مؤشر
Alpha Signal Engine [MarkitTick]💡 The Alpha Signal Engine is an advanced, multi-dimensional trend-following system designed to provide traders with highly filtered, high-probability market signals. At its core, it dynamically calculates a volatility-adjusted trailing band to determine the primary market direction. However, unlike traditional trend indicators that rely on a single data point, this engine passes every potential trend reversal through a rigorous, six-layer filtering mechanism. By requiring confluence across higher timeframe trends, momentum, volume, volatility regimes, and price action strength, it drastically reduces the noise and false signals inherent in choppy markets. It also features a built-in heads-up dashboard and fully formatted JSON webhook capabilities for automated trading integration.
✨ Originality and Utility
● A Dynamic, Adaptive Baseline
Standard trailing stop or trend indicators, such as the classic Supertrend, typically use a static multiplier against the Average True Range (ATR). The Alpha Signal Engine innovates by introducing a "Dynamic Factor." This factor continuously adapts the band's distance from price by factoring in the current baseline multiplier, the relative volatility (ATR normalized by price), and the immediate price change momentum. This allows the bands to tighten during periods of strong, directional momentum and widen during erratic volatility, providing a more responsive and intelligent trailing mechanism.
● The Six-Pillar Filtering Gateway
The true utility of this indicator lies in its modular filtering engine. Traders often have to clutter their charts with half a dozen indicators to confirm a setup. This script centralizes that logic. Users can selectively enable or disable filters based on their specific asset and trading style, turning the indicator into a customizable algorithmic engine. Whether you need volume confirmation, ADX trend strength, or simple RSI momentum, the script handles the complex boolean logic internally and only outputs a signal when your precise market conditions are met.
🔬 Methodology and Concepts
● Dynamic Factor Calculation
The indicator establishes its baseline trend using an upper and lower band. The distance of these bands from the median price is dictated by a dynamically calculated factor. This factor is the sum of a base value, a volatility component (ATR divided by Close, scaled by a user weight), and a price movement component (percentage change of the close, scaled by a user weight). This raw factor is then smoothed using a Simple Moving Average (SMA) to prevent erratic band shifts.
● Trend Determination
The trend direction flips when the closing price crosses the active dynamic band. If the price closes above the upper band, the trend shifts bullish, and the lower band becomes the active support. Conversely, closing below the lower band shifts the trend bearish, making the upper band the active resistance.
● The Filter Matrix
A signal is only generated when a trend flip aligns with all activated filters:
HTF Alignment: Uses the request context to pull the trend direction from a higher timeframe, ensuring you are not trading against the macro trend.
ADX Trending: Measures the Average Directional Index to ensure the market is in an active trending phase (above a defined threshold) rather than a sideways chop.
Volume Surge: Compares current volume against a Volume SMA. The current bar must exhibit a volume spike greater than the defined multiplier to confirm institutional participation.
RSI Momentum: A simple but effective gatekeeper requiring the Relative Strength Index to be above 50 for longs and below 50 for shorts.
ATR Volatility Regime: Compares the current ATR against a 50-period SMA of the ATR. It ensures the market is operating within a "normal" volatility ratio, preventing entries during extreme, unpredictable volatility spikes or dead, illiquid periods.
Candle Body Strength: Calculates the absolute size of the candle body (Open to Close) and mandates it must be larger than a specific fraction of the ATR, ensuring the signal candle has true directional conviction.
🎨 Visual Guide
● Chart Elements
Up Trend Line: Displayed as a solid, teal-colored line trailing below the price action during a bullish phase. It acts as dynamic support.
Down Trend Line: Displayed as a solid, bright pink/red line trailing above the price action during a bearish phase. It acts as dynamic resistance.
Trend Cloud (Fill): A colored gradient fill exists between the median price and the active trend line. A teal cloud visually represents bullish dominance, while a pink/red cloud represents bearish dominance.
Buy Signals: Indicated by small, teal "B" labels positioned below the signal candle.
Sell Signals: Indicated by small, pink/red "S" labels positioned above the signal candle.
● Filter Dashboard
Located in the top right corner of the chart, this HUD (Heads-Up Display) provides a real-time status check of your system.
The left column lists the available filters (HTF Align, ADX Trend, Vol Surge, RSI Gate, ATR Regime, Body Str).
The right column displays the current status of each filter.
A gray "OFF" indicator means the user has disabled the filter in the settings.
A green "ON" or "Aligned" text indicates the condition is currently met.
A red "Opposed" or unlit indicator means the condition is active but currently failing to meet the required criteria.
The bottom rows clearly state the current overarching trend direction and whether a signal is pending or waiting.
📖 How to Use
• Interpreting the System
To effectively use the Alpha Signal Engine, begin by observing the main trend lines and the color of the cloud. This provides your baseline bias. Do not take trades purely on the band flipping. Instead, rely on the explicit "B" and "S" labels.
• Signal Execution
When a "B" (Buy) or "S" (Sell) label appears, it means the price has successfully flipped the trend AND all user-activated filters in the dashboard are glowing green. This is your entry trigger. The active trend line (the teal line for longs, the pink line for shorts) serves as an ideal, dynamic stop-loss placement.
• Customizing the Engine
The system is designed to be tuned. If you are trading a highly liquid asset like major forex pairs, you may want to enable the ADX and HTF filters to catch long, sustained moves. If you are trading volatile crypto assets, enabling the Volume Surge and Candle Body filters can help you avoid fake-outs and trap wicks. Monitor the on-chart dashboard to see which filters are keeping you out of bad trades and adjust your settings accordingly.
⚙️ Inputs and Settings
• Supertrend Settings
ATR Length: The lookback period for calculating the Average True Range.
Base Factor: The starting multiplier for the dynamic bands.
Volatility & Price Change Weights: Determines how aggressively the bands react to sudden spikes in relative volatility and price momentum.
Factor Smoothing: Applies an SMA to the final dynamic multiplier to keep the bands stable.
• Filter Settings
Enable HTF Alignment: Toggle and define the higher timeframe (e.g., Daily) to align with.
ADX Settings: Toggle the filter, define the lookback length, and set the minimum trend strength threshold (default is 20).
Volume Settings: Toggle the filter, define the Volume MA length, and set the multiplier required to classify as a "surge."
RSI Settings: Toggle the filter and set the RSI lookback length.
ATR Regime Settings: Define the minimum and maximum acceptable ratios of current ATR versus historical ATR.
Candle Body Settings: Define the minimum required size of the candle body as a fraction of the current ATR.
• Webhook Action Names
These text inputs allow you to define specific payload strings (e.g., "long", "closeshort") that the indicator will output via JSON alerts, perfectly formatting the data for third-party automation services like 3Commas or PineConnector.
🔍 Deconstruction of the Underlying Scientific and Academic Framework
The Alpha Signal Engine is grounded in several well-documented tenets of quantitative financial analysis and statistical market theory.
● Volatility-Adjusted Trailing Stops
The foundation of the indicator relies on the Average True Range (ATR), introduced by J. Welles Wilder Jr. The ATR is a measure of the degree of price volatility. By tying the trailing stop (the dynamic band) to the ATR, the system acknowledges the statistical reality of market variance. The innovation here is the dynamic multiplier. By adjusting the distance based on the normalized rate of change (momentum), the script attempts to solve the lagging nature of fixed-multiplier trailing stops, utilizing principles found in adaptive moving averages (like Kaufman's AMA), where sensitivity increases alongside directional conviction.
● Multi-Dimensional Confluence Theory
The filtering engine operates on the academic principle of conditional probability and confluence. In market microstructure, no single indicator holds a permanent statistical edge.
The HTF filter is rooted in Dow Theory, prioritizing the primary trend over secondary reactions.
The ADX filter utilizes Wilder's Directional Movement Index to mathematically separate trending environments from mean-reverting environments, applying a statistical threshold to directional strength.
The Volume Surge filter relies on the Volume Price Trend concepts, positing that significant price movements must be sponsored by outsized volume to validate institutional participation and avoid anomalous low-liquidity spikes.
The ATR Regime filter applies mean-reverting principles to volatility itself (volatility clustering), ensuring that entries are only taken when the variance of the asset is within historically "normal" parameters, avoiding the fat tails of extreme market shocks.
By chaining these disparate mathematical models (trend, momentum, volume, volatility) via Boolean logic, the system mathematically reduces the frequency of trades while theoretically increasing the probability of the remaining sample size.
⚠️ Disclaimer
All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion. مؤشر
مؤشر
Adaptive Channel Breakout [MarkitTick]💡 This script is a trend-following system designed to identify high-probability breakout opportunities while rigorously filtering out market noise. By synthesizing volatility (ATR), trend strength (ADX), and price extremes (Donchian logic), this indicator attempts to solve the classic problem of false breakouts in ranging markets. It features a regime-detection engine that dynamically adjusts the visual feedback and signal generation based on whether the market is trending or consolidating.
✨ Originality and Utility
Most breakout indicators rely solely on price crossing a fixed threshold (like a 20-day High). However, these systems often fail in "choppy" markets where price seeks liquidity above highs before reversing. This script innovates by:
Volatility-Adjusted Bounds: It does not simply track the Highest High or Lowest Low. Instead, it retracts the channel bounds by a multiple of the Average True Range (ATR). This creates a "tightened" breakout requirement—price must not only make a new high but do so with enough momentum to overcome the volatility threshold. Regime Filtering: Integrated ADX/DMI logic categorizes the market into Bull, Bear, or Range. Signals are filtered to align with the dominant regime (e.g., no Longs are permitted if the internal structure is Bearish). Logarithmic Scaling: A unique feature allowing calculations to be performed on Logarithmic price data, making it highly suitable for parabolic assets like Crypto or small-cap stocks where linear percentage moves vary drastically. Time-Based Exits: Recognizes that "stale" trades—those that do not perform immediately—often turn into losses, and provides visual cues to exit if momentum stalls.
🔬 Methodology and Concepts
The core logic operates on a three-stage pipeline:
1. Market Regime Classification The script utilizes the Directional Movement Index (DMI) and Average Directional Index (ADX) to determine the state of the market. Trending: Defined as ADX > Threshold (default 25). Range: Defined as ADX < Threshold. Direction: Determined by the relationship between DI+ and DI-.
2. Adaptive Channel Construction The channels are calculated using a modified Donchian/ATR hybrid approach: Upper Band: Highest High (N) minus (ATR × Multiplier) . Lower Band: Lowest Low (N) plus (ATR × Multiplier) . Note: By subtracting ATR from the High, the Upper Band acts as a trailing resistance level that gets closer to price as volatility decreases, allowing for earlier entries during volatility squeezes.
3. Signal Generation & Filtering Long Signal: Price crosses over the Upper Band, provided the market is in a Bull or Range regime. Short Signal: Price crosses under the Lower Band, provided the market is in a Bear or Range regime. Stale Exit: If a signal is generated but price fails to reverse or progress significantly within a user-defined bar limit (default 10), a "Time Exit" warning is triggered.
🎨 Visual Guide
The indicator is designed for immediate visual interpretation through color-coding and dashboard analytics.
● Channel Bands Upper Line: Represents the dynamic resistance/breakout level. Lower Line: Represents the dynamic support/breakout level. Color Logic: Gray: Indicates the opposing side of the trend (e.g., Upper band is gray during a downtrend). Green: Active Upper Band during a Bullish phase. Red: Active Lower Band during a Bearish phase.
● Background Fills (Market Regime) The space between the channels is filled to indicate the current market state: Green Fill: Bullish Trend (ADX High, DI+ > DI-). Red Fill: Bearish Trend (ADX High, DI- > DI+). Yellow Fill: Range/Accumulation (ADX Low). Breakouts from Yellow zones are often the most explosive.
● Signal Shapes Green Triangle (Below Bar): Valid Long Breakout Signal. Red Triangle (Above Bar): Valid Short Breakout Signal. Orange "X" (Below Bar): Time Exit/Stale Trade. Indicates the trade has not progressed after N bars.
● Dashboard (Top Right) A table displaying real-time metrics: Market Regime: Explicitly states TREND (Bull/Bear) or RANGE. Volatility: Displays the current ATR value. ADX Strength: Shows the ADX value, highlighting it in white if it is above the trending threshold.
📖 How to Use
For Trend Following Wait for the background color to transition from Yellow (Range) to Green (Bull) or Red (Bear). This signifies a volatility expansion from a consolidation period. Enter on the corresponding Triangle signal.
For Risk Management Stop Loss: The script calculates suggested Stop Losses (SL) based on the opposite channel band. Stale Exits: If you see an Orange "X" appear after entering a trade, consider closing the position or tightening stops, as the momentum impulse has faded.
For Crypto/Parabolic Assets Enable the "Use Logarithmic Scale" setting in the inputs. This normalizes the volatility calculations, preventing the bands from becoming too wide during exponential price increases.
⚙️ Inputs and Settings
Adaptive Parameters Lookback Length (20): The period for High/Low and ATR calculations. ATR Multiplier (3.2): Determines the width of the channel. Higher values reduce false signals but delay entry. (3.2 is tuned for outlier detection). Use Logarithmic Scale: Toggles math.log() calculations for High, Low, and Close.
Filters & Exits ADX Threshold (25): The level at which the market is considered "Trending." Time Exit (Bars) (10): The number of bars allowed for a trade to "work" before being flagged as stale.
UI / Dashboard Show Analytics Dashboard: Toggles the on-screen information table. Size: Adjusts the text size of the dashboard (Tiny, Small, Normal).
🔍 Deconstruction of the Underlying Scientific and Academic Framework
1. Outlier Detection Theory The script uses an ATR Multiplier of 3.2. In normal statistical distributions, 3 standard deviations cover 99.7% of data points. While financial markets are leptokurtic (fat-tailed), a multiplier of 3.2 on the ATR effectively acts as an outlier filter. A breach of this band signifies a price movement that is statistically significant relative to recent noise, suggesting a structural shift in supply/demand rather than random variance.
2. Heteroscedasticity Handling By including a Logarithmic option, the script addresses heteroscedasticity—the phenomenon where the variability of a variable is unequal across the range of values. In simpler terms, a $100 move in Bitcoin at $1,000 is different from a $100 move at $60,000. Using log-returns (math.log) ensures the channel width remains proportionally relevant regardless of the asset's absolute price level.
3. Trend Efficiency (ADX) The integration of J. Welles Wilder’s ADX serves as a filter for "Trend Efficiency." Breakout systems suffer drawdown in mean-reverting markets. By mathematically requiring ADX > 25, the model attempts to trade only when the autocorrelation of price changes is positive (trending behavior), thereby increasing the expectancy of the breakout signal.
⚠️ Disclaimer
All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion. مؤشر
Future Swing [BigBeluga]🔵 OVERVIEW
Future Swing is a swing-based projection tool that estimates the potential size and price target of the next swing move using historical swing behavior.
Instead of predicting direction randomly, it analyzes completed swing legs, measures their percentage moves, and projects a statistically derived swing target into the future.
The indicator combines swing structure, high/low zones, volume context, and a real-time dashboard to help traders anticipate where price may travel next.
🔵 CONCEPTS
Swing Detection — Swing highs and lows are identified using a configurable lookback length.
Swing Percentage Tracking — Each completed swing leg is converted into a percentage move and stored.
Statistical Projection — Future swing size is estimated using Average, Median, or Mode of past swing percentages.
Directional Awareness — Projections adapt automatically based on current swing direction.
🔵 FEATURES
Historical Swing Sampling —
• Uses a user-defined number of completed swings.
• More samples = smoother projection, fewer samples = faster adaptation.
Future Swing Projection —
• Dashed line projects the estimated swing target forward in time.
• Projection distance is visual-only and does not affect calculations.
High/Low Swing Zones —
• Upper and lower swing zones expand using ATR distance.
• Zones visualize potential reaction and rejection areas.
Volume Context per Swing —
• Buy and sell volume are accumulated during each swing leg.
• Delta and total volume are displayed in the dashboard.
Smart Dashboard —
• Displays each stored swing percentage.
• Shows calculated swing projection value.
Flexible Projection Method —
• Average: smooth and balanced.
• Median: filters out extreme outliers.
• Mode: focuses on the most common swing size.
Extendable Zones —
• Swing zones can optionally extend forward indefinitely.
🔵 HOW TO USE
Anticipate Swing Targets — Use the projected swing line as a probabilistic price objective.
Combine with Structure — Align projections with support, resistance, or liquidity zones.
Filter by Volume — Confirm swing quality using delta and total volume metrics.
Adjust Sensitivity — Tune swing length and historical sample size to match timeframe and volatility.
Context, Not Certainty — Use projections as guidance, not fixed take-profit levels.
🔵 CONCLUSION
Future Swing transforms past swing behavior into a forward-looking projection model.
By combining swing structure, statistical aggregation, ATR zones, and volume analysis, it offers traders a structured way to estimate where the next meaningful price move may reach — without relying on fixed targets or subjective assumptions. مؤشر
Smart Trader, Episode 03, by Ata Sabanci, Candles and TradelinesA volume-based multi-block analysis system designed for educational purposes. This indicator helps traders understand their current market situation through aggregated block analysis, volumetric calculations, trend detection, and an AI-style narrative engine.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
DESIGN PHILOSOPHY: CLEAN CHART, RICH DASHBOARD
Traditional indicators often clutter charts with dozens of support/resistance lines, making it difficult to see price action clearly. This indicator takes a different approach:
The Chart:
Displays only the most meaningful, nearest levels (1 up, 1 down) that have not been consumed by price. This keeps your chart clean and focused on what matters right now.
The Dashboard:
Contains all detailed metrics, calculations, and analysis. Instead of drawing 20 lines on your chart, you get comprehensive data in an organized table format.
Why this approach?
• A clean chart allows you to see price action without visual noise
• Fewer but more meaningful levels help focus attention on immediate reference points
• The dashboard provides depth without sacrificing chart clarity
• Beginners can learn chart reading with an uncluttered view while accessing detailed analysis when needed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. BLOCK SEGMENTATION
What it does:
Divides the analysis window into fixed-size blocks. Each block contains multiple bars that are analyzed as a single unit.
Why:
Individual bars contain noise. A single red candle in an uptrend might cause unnecessary concern, but when you view 5-10 bars as one block, the overall direction becomes clear. Block segmentation filters out bar-to-bar noise and reveals the underlying structure.
Benefit:
• Clearer view of market structure at a higher aggregation level
• Enables comparison between time periods (Block 1 vs Block 2 vs Block 3)
• Creates the foundation for composite candles and trend detection
• Reduces emotional reaction to single-bar movements
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
2. COMPOSITE CANDLES (FRACTAL CONCEPT)
What it does:
Each block generates a "ghost candle" representing aggregated OHLC:
• Open: First bar's open in the block
• High: Highest high across all bars in the block
• Low: Lowest low across all bars in the block
• Close: Last bar's close in the block
Why:
This is essentially a FRACTAL view of the market. The same candlestick patterns that appear on a daily chart also appear on hourly charts, and on 5-minute charts. By aggregating bars into composite candles, you create a synthetic higher timeframe view without changing your actual timeframe.
Benefit:
• See higher timeframe patterns while staying on your preferred timeframe
• Identify block-level candlestick patterns (Doji, Hammer, Marubozu, Engulfing, etc.)
• Compare composite candle relationships: Does Block 1 engulf Block 2? Is Block 1 an inside bar relative to Block 2?
• Recognize patterns that individual bars obscure due to noise
Fractal Nature:
A hammer pattern means the same thing whether it appears on a 1-minute chart or a weekly chart: price tested lower levels and was rejected. Composite candles let you see these patterns at your chosen aggregation level, providing a multi-scale view of market behavior.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
3. VOLUME ENGINE
What it does:
This indicator is 100% VOLUME-BASED. It separates total volume into buying volume and selling volume using two methods:
Method 1 - Geometric (Approximation):
• Buy Volume = Total Volume × ((Close - Low) / Range)
• Sell Volume = Total Volume × ((High - Close) / Range)
Method 2 - Intrabar LTF (Precise):
Uses actual tick-level or lower timeframe data to determine real buy/sell distribution.
Why:
Raw volume tells you HOW MUCH was traded, but not WHO was aggressive. A large volume bar could mean heavy buying, heavy selling, or both. By separating buy and sell volume, you can identify which side is driving the market.
Benefit:
• Identify whether buyers or sellers are more aggressive
• Detect when volume contradicts price direction (divergence)
• Measure accumulation (buying into weakness) vs distribution (selling into strength)
• Quantify the delta (buy minus sell) to see net pressure
Why Delta Matters:
If price is rising but delta is negative, sellers are actually more aggressive despite the price increase. This divergence often precedes reversals because the price movement lacks volume confirmation.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
4. PIN ANALYSIS (WICK MEASUREMENT)
What it does:
Calculates average upper pin (wick) and lower pin sizes for each block, then tracks how these change across consecutive blocks.
Why:
Upper pins represent price levels that were tested but rejected by sellers. Lower pins represent price levels that were tested but rejected by buyers. The size and direction of pins reveal rejection strength at specific price zones.
Benefit:
• Large upper pins = strong selling pressure at higher levels
• Large lower pins = strong buying support at lower levels
• Increasing upper pins across blocks = intensifying selling pressure
• Decreasing lower pins across blocks = weakening buying support
Why Track Pin Changes:
Pin behavior often changes before price direction changes. If lower pins are shrinking while price is still rising, the buying support that was defending dips is weakening. This is observable data, not prediction.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
5. TREND CHANNEL DETECTION
What it does:
Identifies trend direction using block-level price structure:
• UPTREND: Block highs are higher than previous block highs, AND block lows are higher than previous block lows (HH/HL pattern)
• DOWNTREND: Block highs are lower than previous block highs, AND block lows are lower than previous block lows (LH/LL pattern)
• RANGE: No consistent directional pattern
Once detected, the system draws upper and lower channel boundaries by connecting extreme points within each trend segment.
Why:
HH/HL and LH/LL are the classical definitions of trend. By applying this logic to composite candles (blocks) rather than individual bars, the trend detection becomes more stable and less prone to whipsaws from single-bar noise.
Benefit:
• Clear visual boundaries showing the current trend channel
• Upper channel line = dynamic resistance based on actual price structure
• Lower channel line = dynamic support based on actual price structure
• Channel angle indicates trend strength (steeper = stronger)
• Channel width indicates volatility
Why Lock Trend States:
Once a block's trend classification is determined, it locks and does not change on subsequent recalculations. Without locking, the same block could flip between UP and DOWN repeatedly, creating inconsistent analysis. Locking ensures stability.
Why Project Lines Forward:
Channel lines can be projected into the future to show where support/resistance would be if the current trend continues at the same angle. This is not a prediction; it is a visual reference showing the trend's trajectory.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
6. CORE LEVELS: POC, MAX BUY, MAX SELL
What it does:
Identifies key price levels within each block based on volume data:
POC (Point of Control):
The price level where the highest total volume occurred within the block.
MAX BUY Level:
The bar with the highest buying volume. The HIGH of this bar marks the level.
MAX SELL Level:
The bar with the highest selling volume. The LOW of this bar marks the level.
MIN BUY/SELL Levels:
Optional levels showing where minimum buy/sell volume occurred.
Why:
High volume at a specific price means many participants entered positions there. These participants have a vested interest in that price level. If price returns to that area, those same participants may act to defend their positions.
Benefit:
• POC acts as a volume-based magnet; price tends to revisit high-volume areas
• MAX BUY level shows where buyers committed most aggressively
• MAX SELL level shows where sellers committed most aggressively
• These levels are based on actual transaction data, not arbitrary calculations
Why Consumed Levels Disappear:
When price crosses through a level, that level has been "tested." Keeping consumed levels on the chart creates visual clutter and suggests they are still relevant when they may no longer be. Removing them keeps focus on levels that have not yet been tested.
Why Show Only Nearest Levels:
If you have 20 blocks, you could have 60+ potential levels (POC, MAX BUY, MAX SELL for each). Displaying all of them makes the chart unreadable. Showing only the nearest untested level above and below current price keeps the chart clean while providing immediate reference points.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
7. QUALITY SCORE AND TREND INTELLIGENCE
What it does:
Calculates a quality score (0-100) for the current trend based on multiple factors:
• Angle steepness (stronger trends have steeper angles)
• Delta consistency (does volume support the trend direction?)
• Volume momentum (is participation increasing or decreasing?)
• Body expansion (are candle bodies growing or shrinking?)
• Pin alignment (do pins support the trend direction?)
• Contradiction count (how many factors disagree?)
Why:
Not all trends are equal. A trend with consistent volume support, expanding bodies, and aligned pins is healthier than a trend with contradicting signals. The quality score quantifies this.
Benefit:
• HIGH quality (80+): Multiple factors confirm the trend
• MEDIUM quality (60-79): Some factors confirm, some neutral
• LOW quality (below 60): Multiple contradictions exist
• Strength rating based on channel angle: VERY STRONG, STRONG, MODERATE, WEAK
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
8. NARRATIVE ENGINE
What it does:
Generates a text-based market analysis by synthesizing all calculated data into readable sentences.
How it works:
1. Analyzes current candle: pattern type (Doji, Hammer, Marubozu, etc.), body/wick ratios, range vs ATR
2. Analyzes composite candle: Block 1 pattern and relationship to Block 2 (Engulfing, Inside, Outside)
3. Evaluates trend context: direction, duration, quality, transitions
4. Examines volume data: delta, dominance, momentum direction
5. Checks proximity to key levels: channel boundaries, POC, core levels
6. Identifies divergences: when price and volume directions contradict
7. Produces a coherent narrative describing the current situation
Why:
Numbers and charts require interpretation. The narrative engine translates calculated data into plain language, helping traders understand what the data means in context. This is especially valuable for beginners learning to read charts.
Benefit:
• Synthesizes multiple data points into a coherent story
• Explicitly flags divergences and contradictions
• Describes the current situation without making predictions
• Educational: shows how different factors relate to each other
What the Narrative Does NOT Do:
The narrative describes what IS, not what WILL BE. It does not predict future price movement. It reports the current candle pattern, the current trend state, the current volume situation, and the current proximity to levels.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
9. SMART DASHBOARD
What it does:
Displays all metrics in an organized table with multiple sections.
Sections:
• Volume Engine: Calculation method, data availability, current candle buy/sell/delta
• Trend Volumetrics: Aggregated buy/sell/delta across the current trend, trend type
• Pressure and Momentum: Average pins, pin change percentages, body expansion status
• Trend Channel Boundaries: Upper/lower levels with exact prices, distances, percentages
• Trend Intelligence: Quality score, confidence level, strength rating, volume momentum
Why:
All the detailed calculations need to live somewhere without cluttering the chart. The dashboard provides comprehensive data in a structured format.
Benefit:
• All metrics in one place
• Organized by category for easy reference
• Hover over any label to see a tooltip explaining that metric
• No need to draw dozens of lines on the chart
TIP: Hover over dashboard headers and labels to see tooltips explaining each metric.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
10. LANGUAGE SUPPORT
The indicator supports three languages:
• English
• Türkçe (Turkish)
• हिन्दी (Hindi)
Why only three languages?
Each additional language requires duplicate strings throughout the code, increasing memory usage and compilation time. To keep the script optimized and responsive, language options are limited to these three.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
11. DATA ACCURACY AND LIMITATIONS
This indicator is 100% VOLUME-BASED and requires Lower Timeframe (LTF) intrabar data for accurate calculations.
DATA ACCURACY LEVELS:
• 1T (Tick): Most accurate, real volume distribution per tick
• 1S (1 Second): Reasonably accurate approximation
• 15S (15 Seconds): Good approximation, longer historical data available
• 1M (1 Minute): Rough approximation, maximum historical data range
BACKTEST AND REPLAY LIMITATIONS:
• Replay mode results may differ from live trading due to data availability
• For longer backtest periods, use higher LTF settings (15S or 1M)
• Not all symbols/exchanges support tick-level data
• Crypto and Forex typically have better LTF data availability than stocks
A NOTE ON DATA ACCESS:
Higher TradingView plans provide access to more historical intrabar data, which directly impacts the accuracy of volume-based calculations. More precise volume data leads to more reliable calculations.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
12. SETTINGS OVERVIEW
Main Settings:
• Window Bars: Total bars to analyze
• Group Count: Number of blocks to create
• Calculation Basis: Current bar (live updates) or Closed bar (stable, no repaint)
Block Analytics:
• Show Composite Candle: Toggle ghost candles on/off
• Composite Candle Transparency: Adjust visibility
• Dim Original Candles: Fade original candles when composites are shown
Volume Engine:
• Calculation Method: Geometric (approx) or Intrabar (precise)
• Lower Timeframe: Select LTF for intrabar calculations
Multi-Segment Trend:
• Enable Trend Detection: Toggle trend channels on/off
• Range Angle Threshold: Angle below which trend is classified as RANGE
• Line colors, width, and style
• Project to Future: Extend trend lines forward
Core Calculation:
• Enable Core Calculation: Toggle POC and core levels
• Show POC Nearest Up/Down: Display nearest untested POC levels
• Include MAX/MIN Buy/Sell Levels: Toggle extremes display
• Nearest Only: Show only the closest level above and below price
Market Narrative:
• Enable Market Narrative: Toggle narrative text
• Language selection
• Show Educational Disclaimer: Toggle disclaimer in dashboard
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
EDUCATIONAL PURPOSE
This indicator is designed to help traders:
1. Understand their current market situation at a glance
2. Learn chart reading through block analysis and composite candles
3. See how volume relates to price movement
4. Recognize when technical factors align or contradict
5. Focus on meaningful levels without chart clutter
Whether you are a beginner learning to read charts or an experienced trader seeking a cleaner analytical view, this tool provides structured data to support your analysis.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPORTANT DISCLAIMER
This indicator is for EDUCATIONAL PURPOSES ONLY and does not constitute investment advice. Always conduct your own research and consult with a qualified financial advisor before making investment decisions.
This disclaimer is also displayed within the indicator itself. If you prefer a cleaner chart, you can disable it in Settings under Market Narrative by unchecking Show Educational Disclaimer. مؤشر
Regression Slope Oscillator [BigBeluga]🔵 OVERVIEW
The Regression Slope Oscillator is a trend–momentum tool that applies multiple linear regression slope calculations over different lookback ranges, then averages them into a single oscillator line. This design helps traders visualize when price is extending beyond typical regression behavior, as well as when momentum is shifting up or down.
🔵 CONCEPTS
Regression Slope – Measures the steepness and direction of price trends over a selected length.
f_log_regression(src, length) =>
float sumX = 0.0
float sumY = 0.0
float sumXSqr = 0.0
float sumXY = 0.0
for i = 0 to length - 1
val = math.log(src )
per = i + 1.0
sumX += per
sumY += val
sumXSqr += per * per
sumXY += val * per
slope = (length * sumXY - sumX * sumY) / (length * sumXSqr - sumX * sumX)
slope*-1
Multi–Sample Averaging – Instead of relying on one regression slope, the indicator loops through many lengths (from Min Range to Max Range with Step increments) and averages their slopes.
multiSlope(length)=>
// Get regression slope
slope = f_log_regression(close, length)
slopAvg.push(slope)
for i = minRange to maxRange by step
multiSlope(i)
Color Gradient – The oscillator and candles are colored dynamically from oversold (orange) to overbought (aqua), based on slope extremes observed within the user–defined Color Range.
Trend Oscillation – When the oscillator rises, price trend is strengthening; when it falls, momentum weakens.
🔵 FEATURES
Calculates regression slopes across a user–defined range (e.g., 10–100 with steps of 5).
Averages all sampled slopes into a single oscillator line.
Dynamic coloring of oscillator and chart candles based on slope values.
User–controlled Color Range :
High values (e.g., 50–100) → interpret as overbought vs oversold zones.
Low values (e.g., 2–5) → interpret as slope rising vs falling momentum shifts.
Dashboard table (top–right) displaying number of slope samples and current averaged slope value.
Candle coloring mode (optional) – candles take on the oscillator gradient color for at–a–glance reading of trend bias.
Signal Line (SMA) – A moving average of the slope oscillator used to identify momentum reversals.
Bullish Reversal Signal – Triggered when the oscillator crosses above the signal line while below zero, indicating downside momentum exhaustion and potential trend recovery.
Bearish Reversal Signal – Triggered when the oscillator crosses below the signal line while above zero, indicating upside momentum exhaustion and potential trend rollover.
Dual Placement Signals – Reversal signals are plotted both:
On the oscillator pane (for momentum context)
On the price chart (for execution alignment)
Confirmation Logic – Signals are only printed on confirmed bars to reduce repainting and false triggers.
🔵 HOW TO USE
Watch the oscillator cross above/below zero: signals shifts in regression slope direction.
Use the signal line crossovers near zero to identify early trend reversals.
Use high Color Range settings to identify potential overbought/oversold extremes in trend slope.
Use low Color Range settings for a faster, momentum–driven color change that tracks slope rising/falling.
Candle coloring highlights short–term trend pressure in sync with the oscillator.
Combine reversal signals with structure, support/resistance, or volume for higher–probability entries.
🔵 CONCLUSION
The Regression Slope Oscillator transforms raw regression slope data into a smooth, color–coded oscillator. By averaging across multiple regression lengths, it avoids the noise of single–range analysis while still capturing trend extensions and momentum shifts.
With the addition of signal line crossovers and confirmed reversal markers, the indicator now provides both trend context and actionable momentum signals within a single regression-based framework. مؤشر
Point of Control [BigBeluga]🔵 OVERVIEW
Point of Control identifies the exact price level with the highest traded volume over a selected lookback period.
This level—called the Point of Control (PoC) —marks where the greatest market participation occurred, representing a zone of highest volume.
The indicator helps traders visualize dominant volume concentrations, fair-value levels, and structural balance within recent price action.
🔵 CONCEPTS
Point of Control (PoC) — The single price level within the defined lookback range that has accumulated the most traded volume.
Volume Distribution Bins — The price range is divided into 25 equal bins, and volume is aggregated per bin to locate the maximum concentration.
Range Boundaries — The highest and lowest price within the lookback window are used to form the upper and lower reference limits.
PoC Channel — Optional upper and lower bands plotted around the main PoC to visualize a fair-value corridor.
Volume Intensity Mapping — Candle color dynamically shifts based on the candle’s position relative to the PoC channel, showing whether price is balanced or trending away from high-volume levels.
🔵 FEATURES
Configurable Lookback Range — Adjust how many bars (10–400) are used for calculating the PoC.
Precise PoC Calculation — Volume aggregation across 25 bins to identify the exact volume peak.
Dynamic Channel Visualization — PoC bands above and below the central level to indicate equilibrium tolerance.
Adaptive Candle Coloring —
- Neutral → price inside PoC channel. Gray
- Bullish → price above PoC channel. Blue 🔵
- Bearish → price below PoC channel. Orange 🟠
Automatic Volume Labeling — Displays total volume at the active PoC level for quick reference.
Directional Indicators — 🔵 or 🟠 markers appear when price shifts above or below the PoC channel.
Range Visualization — Plots the highest and lowest points of the active lookback window for contextual awareness.
Live Updating Logic — PoC recalculates automatically every 15 bars for efficient chart performance and accuracy.
🔵 HOW TO USE
Volume Anchoring — Use PoC as a reference for where the majority of volume occurred; price often reacts to or consolidates around this level.
Trend Confirmation — Sustained price movement away from PoC channel may signal developing directional imbalance.
Value Tracking — Watch the shifting of PoC across time to identify where fair value migrates during market evolution.
Equilibrium Mapping — When price hovers around PoC, the market is balanced; when it departs, a new value zone may form.
Combine With Volume Profiles — Use alongside profile tools for higher-resolution analysis of institutional activity.
🔵 CONCLUSION
Point of Control provides a pure, volume-centric view of market balance by pinpointing where most transactions occurred within any chosen range.
It delivers a clean and efficient visualization of fair value zones—helping traders track the heartbeat of market participation, recognize dominant liquidity areas, and stay aligned with where true market interest resides. مؤشر
مؤشر
مؤشر
Smart Gap Concepts [MarkitTick]💡 This indicator automates the identification and classification of price gaps, commonly known as Fair Value Gaps (FVG) or Imbalances, by integrating market structure and volume analysis. Unlike standard gap detectors that simply highlight empty space on a chart, this script applies algorithmic filters to categorize gaps into three distinct phases of market movement: Breakaway, Runaway, and Exhaustion. This helps traders understand the potential context of a move rather than just seeing a support or resistance zone.
● Originality and Utility
The primary innovation of this tool is its dynamic classification system. It moves beyond visual detection by checking the "why" behind the gap. By referencing Swing Highs and Swing Lows (Market Structure) alongside Volume efficiency, it determines if a gap represents a breakout, a trend continuation, or a climatic end to a move. Additionally, the script features an automated mitigation tracking system that removes gaps from the chart once price has re-tested the midpoint, ensuring the visual workspace remains clean and relevant to current price action.
● Methodology
The script operates on a multi-stage logic engine:
• Gap Detection
It first identifies the core imbalance where the Low of the current bar does not overlap with the High of the bar two periods prior (for bullish gaps), ensuring the intervening candle represents a strong displacement.
• Structural Analysis (Breakaway Gaps)
The script monitors Pivot Highs and Lows. If a gap occurs simultaneously with a close beyond a key structural Pivot, it is classified as a "Breakaway Gap." This signals the potential start of a new trend.
• Volume and Time Analysis (Exhaustion Gaps)
To identify potential reversals, the script looks for "Trend Maturity." If a gap forms after a long duration since the last pivot and is accompanied by a volume spike (defined by the Volume Spike Multiplier), it is labeled as an "Exhaustion Gap."
• Continuation (Runaway Gaps)
If a gap is valid but meets neither the Breakaway nor Exhaustion criteria, it is considered a "Runaway Gap," typically found in the middle of an established trend.
• Dynamic Cleanup
The script tracks the midpoint of every active gap. If price creates a lower low (for bullish gaps) or higher high (for bearish gaps) beyond this midpoint, the gap is considered mitigated and is removed from the screen.
📖 How to Use
Traders can utilize the color-coded classifications to gauge market intent:
Breakaway (Default Blue): Watch these zones for potential trend initiations. These are often high-probability areas for a retest entry after a structure break.
Runaway (Default Orange): These indicate strong momentum. They can be used to trail stop-losses or add to winning positions, as price should ideally not close below these gaps in a healthy trend.
Exhaustion (Default Red): Be cautious when these appear. They suggest the current move is overextended and a reversal or complex pullback may be imminent.
• Exhaustion Gap : A Practical Case Study
• Breakaway Gap: A Practical Case Study
• Runaway Gap : A Practical Case Study
⚙️ Inputs and Settings
Min Gap Size (Points): Filters out insignificant gaps smaller than this threshold.
Structure Lookback: Defines the sensitivity of the Pivot detection (Swing High/Low).
Volume Avg Length & Multiplier: Determines what qualifies as a "Volume Spike" for exhaustion logic.
Trend Maturity: The minimum number of bars required to consider a trend "old" enough for an exhaustion signal.
Visual Settings: Custom colors for each gap type and box extension length.
● Disclaimer
All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion.
مؤشر
MA Strength Indicator EnhancedThe "MA Strength" is an indicator that measures market trend strength or (in the case of forex pairs) the relative strength of individual currencies based on up to five different moving averages (MA). It offers multiple calculation methods, such as simple summation, normalized value, or measuring ATR/percentage distance from the price. The results are summarized in a clear table, and it provides customizable alerts for trend changes or shifts in currency strength. The high level of configurability (e.g., MA weighting, "all MA alignment" requirement) allows for fine-tuning the strategy.
💬 Interpreting the Table (Top Rows)
The top row of the table shows the final output of the indicator. This changes according to the set "Table Mode".
Trend Mode: The top row shows the final, aggregated trend status (e.g., "BULLISH", "NEUTRAL") and the corresponding "Trend Value". This is the value the indicator compares to its thresholds.
Forex Mode: (Only on 6-character pairs): The top two rows show the strength of the Base currency and the Quote currency separately.
Calculation of the top rows:
The indicator calculates the individual score of all active MAs (according to the chosen method).
Trend Value: This is the final value calculated from the scores.
If "Enable Averaging" is ON, this will be the average of the scores (e.g., MA1 score is 5.0, MA2 score is 7.0 -> Trend Value is 6.0).
If averaging is OFF, this will be the sum of the scores (e.g., 5.0 + 7.0 = 12.0).
Forex Calculation: "Forex Mode" uses this "Trend Value". If the Trend Value is +6.0 (on an EURUSD pair):
The Base currency (EUR) value will be +6.0.
The Quote currency (USD) value will be -6.0.
The indicator compares these values to the thresholds to determine the "STRONG" status for EUR and "WEAK" status for USD.
📊 Calculation Methods
The indicator can calculate trend strength using 5 methods. The final "Trend Value" is derived from the results of these calculations.
Sum:
Description: Simply adds up the individual scores of all enabled moving averages (MA).
Formula: If the price is above an MA, it gets the "Score Above" value (e.g., +2.0); if below, it gets the "Score Below" value (e.g., -2.0).
Example: Result = (MA1 score) + (MA2 score) + ...
Normalized:
Description: Takes the sum obtained by the "Sum" method and converts it to a scale between -100% (maximally bearish) and +100% (maximally bullish). It takes into account the maximum possible positive and negative scores.
Formula: Result = (Total Score / Max Possible Score) * 100
Percentage Distance:
Description: This method also considers distance. The further the price is from the MA in percentage terms, the higher the score.
Formula: MA Score = (|Close Price - MA| / MA * 100) * Weight (The "Weight" is the "Score Above/Below" value set in settings).
ATR Distance:
Description: Similar to percentage distance, but normalizes the distance using volatility via ATR (Average True Range).
Formula: MA Score = (|Close Price - MA| / ATR) * Weight
Candle Count:
Description: Counts how many consecutive candles have been above or below the MA. It multiplies this number by the set weight.
Formula: MA Score = (Number of consecutive candles) * Weight
⚙️ Settings Options
Moving Averages (MA 1-5)
For each moving average, you can set:
Enable MA: Turn the specific MA on or off.
Type: The type of moving average (SMA, EMA, WMA, etc.).
Period: The period of the MA (e.g., 50, 200).
Score Above / Below: The most important setting. This defines the "weight" of the MA in the calculation. In "Sum" mode, this is a fixed score; in distance-based modes, this is a multiplier (weight). It is advisable to write a positive number for "Score Above" and a negative number for "Score Below".
Calculation Settings
Enable Averaging: If this is on, the indicator shows the average of the active MA scores, not the total score.
Exception: This function is not available in "Normalized" mode.
Require All MA Alignment: This is a strict filter. If enabled, the indicator only gives a "BULLISH" (or "STRONG") signal if the price is above all enabled moving averages. Similarly, a "BEARISH" signal only occurs if the price is below all moving averages. If the price is on the opposite side of even just one MA (e.g., above 4, below 1), the status becomes "NEUTRAL", regardless of the scores.
Strength / Trend Thresholds
Enable Extra Levels: If active, statuses are expanded: "EXT. BULLISH" / "EXT. BEARISH" (Trend mode) or "EXT. STRONG" / "EXT. WEAK" (Forex mode). This indicates stronger, overbought/oversold conditions.
Threshold setting: The thresholds (e.g., "Strong Above - ATR") determine when the calculated value counts as a "STRONG" or "WEAK" status.
🔢 Setting Thresholds via Calculation
If "Enable Averaging" is OFF, the "Trend Value" shown in the table will be the sum of the individual MA scores. Therefore, we must define the threshold by adding up the minimum expected performance from each moving average. This allows us to set different expectations for short, medium, and long-term averages.
Step 1: Determine MA weights
In our example, we use 3 active MAs with the following weights (Score Above values):
MA1 (Short): Weight = +2
MA2 (Medium): Weight = +3
MA3 (Long): Weight = +4
Step 2: Determine the minimum expected distance
Define a minimum distance expected from each MA to trigger a "Strong" signal.
Step 3: Calculate target scores and the final threshold
Note: If "Enable Averaging" is ON, the resulting value (sum of target scores) must be
averaged to get the final threshold.
Example 1: ATR Distance
-Goal: I want a "Strong" signal if the price is...
...at least 1.0 ATR above MA1 (Short),
...at least 1.5 ATR above MA2 (Medium),
...and at least 2.0 ATR above MA3 (Long).
-Calculation (Expected Distance * Weight):
MA1 Target Score: 1.0 * 2 = 2.0
MA2 Target Score: 1.5 * 3 = 4.5
MA3 Target Score: 2.0 * 4 = 8.0
-Final Threshold (Sum of Target Scores): 2.0 + 4.5 + 8.0 = 14.5
-Setting: Set "Strong Above - ATR" threshold to 14.5.
If "Enable Averaging" is ON, the obtained value must be averaged, and the result will be the
threshold: 4.8 (14.5 / 3 = 4.83).
Example 2: Percentage Distance
-Goal: I want a "Strong" signal if the price is...
...at least 0.5% above MA1,
...at least 1.0% above MA2,
...and at least 1.5% above MA3.
-Calculation (Expected Distance * Weight):
MA1 Target Score: 0.5 * 2.0 = 1.0
MA2 Target Score: 1.0 * 3.0 = 3.0
MA3 Target Score: 1.5 * 4.0 = 6.0
-Final Threshold (Sum): 1.0 + 3.0 + 6.0 = 10.0
-Setting: Set "Strong Above - Percentage" threshold to 10.0.
If "Enable Averaging" is ON, the obtained value must be averaged, and the result will be the
threshold.
Example 3: Candle Count
-Goal: I want a "Strong" signal if...
...at least 3 consecutive candles are above MA1,
...at least 5 consecutive candles are above MA2,
...and at least 10 consecutive candles are above MA3.
-Calculation (Expected Candle Count * Weight):
MA1 Target Score: 3 * 2.0 = 6.0
MA2 Target Score: 5 * 3.0 = 15.0
MA3 Target Score: 10 * 4.0 = 40.0
-Final Threshold (Sum): 6.0 + 15.0 + 40.0 = 61.0
-Setting: Set "Strong Above - Candle" threshold to 61.0.
If "Enable Averaging" is ON, the obtained value must be averaged, and the result will be the
threshold.
Example 4: Sum
In this mode, distance does not matter, only whether the price is above or below the MA.
-Goal: "Strong" signal if the price is above the long-term averages, but can be below the short-term (MA1).
MA1 (Short): Can be below (Weight: -2.0)
MA2 (Medium): Must be above (Weight: +3.0)
MA3 (Long): Must be above (Weight: +4.0)
-Calculation: -2.0 + 3.0 + 4.0 = 5.0
-Setting: Set "Strong Above - Sum" threshold to 5.0.
If it must be above all three moving averages, the threshold would be 2.0 + 3.0 + 4.0 = 9.0.
If "Enable Averaging" is ON, the obtained value must be averaged, and the result will be the
threshold.
Example 5: Normalized
The basic logic is similar to the "Sum" method.
-Goal: "Strong" signal if price is above MA2 and MA3, but potentially below MA1.
-Calculation: Target Sum: 5.0. Max Possible Score (above all): 9.0.
-Threshold: (5.0 / 9.0) * 100 = 55.5
In this calculation method, averaging cannot be set.
The Usage of the "ATR %" Row
The "ATR %" row shows the percentage movement of an average candle.
How to use this with "Percentage Distance" mode:
This number gives a baseline. It helps decide if the "Percentage Distance" threshold is realistic.
Example: You see the "ATR %" value is hovering around 1.2%. This means a "normal" candle moves about 1.2%.
If you set the Percentage threshold to 0.5%, it is too low. The indicator will constantly give a "Strong" signal because even average movement (noise) exceeds the threshold.
Correct Usage: If "normal" movement is 1.2%, then a "strong" movement (trend) needs to be significantly larger. For example, set the threshold to double the ATR %: 2.4 (2 * 1.2). Thus, you only get a "Strong" signal if the movement is twice the average volatility.
Supplementary Information
Rounding Differences:
The numbers displayed in the table and the precision of calculations in the background differ.
Table Display: The indicator rounds numbers to two decimal places in the table. So, if the value is 0.996, the table shows 1.00 (rounded up).
Internal Calculation: The background calculation uses much higher precision. When determining status (STRONG vs NEUTRAL), the program compares the precise, unrounded value to the threshold.
Result: Due to rounding, it may happen that if the threshold is 1.00 and the table shows 1.00, the status flickers between Strong and Neutral. If this is bothersome, it is advisable to set a slightly lower threshold (e.g., 0.98).
🔔 Alert Settings
The indicator can send alerts when the status changes.
Alert Method:
Trend: Alerts when the main trend status changes (e.g., from "NEUTRAL" to "BULLISH"). You can specify which direction to alert for (e.g., only "BULLISH").
Forex: Works only on 6-character forex pairs. You can set separate alerts for the Base or Quote currency.
Forex Strength Level: You can specify at which status level to alert (e.g., "WEAK" or "EXT. STRONG").
📈 Trading Tips
Trend Confirmation: Use the "BULLISH" / "BEARISH" status to confirm your existing strategy (e.g., breakouts, bounces off support).
Forex Pairing: In Forex mode, look for pairs where the Base currency is "STRONG" and the Quote currency is "WEAK" (or "EXT. STRONG" / "EXT. WEAK") for a long position.
Short Position: Reverse the above (Base: WEAK, Quote: STRONG). مؤشر
Regime Filter [BigBeluga]🔵 OVERVIEW
Regime Filter is a dual-factor trend condition tool combining price trend momentum and volume expansion into a single, easy-to-read visual framework. It quantifies recent trend direction and volume shifts, then shows them as:
Two oscillator plots for Trend and Volume regimes
Dynamic candle coloring for trend clarity
A quadrant scatter map in your chart corner for immediate regime recognition.
This filter helps traders quickly detect when a trend is healthy & confirmed by strong volume, or weakening & vulnerable due to low volume.
🔵 CONCEPTS
Trend Oscillator: A loop-based trend value calculated by comparing the current smoothed price (HMA of HLC3) against its own trailing history. Positive values indicate trend-up regimes, negative values signal trend-down phases.
Volume Oscillator: Similar loop logic but on smoothed volume (HMA of Volume) — highlighting whether trading activity is expanding or contracting relative to past bars.
hma = ta.hma(hlc3, 15)
vol = ta.hma(volume, 15)
for i = 0 to len
if hma > hma
trend += 1
else
trend -= 1
for i = 0 to len
if vol > vol
voltrend += 1
else
voltrend -= 1
Regime Map Scatter Plot: A unique 2D quadrant displayed in the bottom-right corner. This shows where the market is sitting:
> Top Right (green): Trend ↑ and Volume ↑ → strong confirmed up trend.
> Top Left (red): Trend ↓ but Volume ↑ → strong sell momentum.
> Bottom Right (blue): Trend ↑ but Volume ↓ → uptrend losing steam.
> Bottom Left (yellow): Trend ↓ and Volume ↓ → weak bearish drift.
Dynamic Candle Coloring: Candles are colored by trend only: green for uptrends, red for downtrends, and orange near reversals.
Threshold Fills: The oscillator region is shaded green above +10 (healthy uptrend) and red below -10 (strong downtrend) for instant confidence.
🔵 FEATURES
Normalized trend and volume values adapt automatically to your lookback length.
Candlestick color overrides highlight current trend state in real-time.
Clear zero-line and fill bands help you gauge strength vs. noise.
Scatter regime dashboard updates live to track when trend and volume align or decouple.
Color gradients show intensification or cooling in both oscillators and the regime map.
🔵 HOW TO USE
Look for sustained positive trend and volume values to confirm strong directional moves.
Watch for the scatter dot in the green square (top right) for high-confidence breakouts.
If the dot drops to bottom right, uptrend may be tiring — possible exit zone.
If the dot jumps top left, bearish drive is reinforced by heavy volume — caution on longs.
Use the orange trend coloring as an early warning that trend pressure may be shifting.
Combine with breakout levels or moving averages for a robust regime filter system.
🔵 CONCLUSION
The Regime Filter distills price trend and volume dynamics into an actionable multi-mode display: oscillators, color-coded candles, and an intuitive scatter map. This all-in-one layout helps traders visually read market regime strength and spot fading trends before they turn — perfect for swing traders, intraday scalpers, and macro trend followers alike. مؤشر
MFM – Light Context HUD (Minimal)Overview
MFM Light Context HUD is the free version of the Market Framework Model. It gives you a fast and clean view of the current market regime and phase without signals or chart noise. The HUD shows whether the asset is in a bullish or bearish environment and whether it is in a volatile, compression, drift, or neutral phase. This helps you read structure at a glance.
Asset availability
The free version works only on a selected list of five assets.
Supported symbols are
SP:SPX
TVC:GOLD
BINANCE:BTCUSD
BINANCE:ETHUSDT
OANDA:EURUSD
All other assets show a context banner only.
How it works
The free version uses fixed settings based on the original MFM model. It calculates the regime using a higher timeframe RSI ratio and identifies the current phase using simplified momentum conditions. The chart stays clean. Only a small HUD appears in the top corner. Full visual phases, ratio logic, signals, and auto tune are part of the paid version.
The free version shows the phase name only. It does not display colored phase zones on the chart.
Phase meaning
The Market Framework Model uses four structural phases to describe how the market
behaves. These are not signals but context layers that show the underlying environment.
Volatile (Phase 1)
The market is in a fast, unstable or directional environment. Price can move aggressively with
stronger momentum swings.
Compression (Phase 2)
The market is in a contracting state. Momentum slows and volatility decreases. This phase
often appears before expansion, but it does not predict direction.
Drift (Phase 3)
The market moves in a more controlled, persistent manner. Trends are cleaner and volatility
is lower compared to volatile phases.
No phase
No clear structural condition is active.
These phases describe market structure, not trade entries. They help you understand the conditions you are trading in.
Cross asset context
The Market Framework Model reads markets as a multi layer system. The full version includes cross asset analysis to show whether the asset is acting as a leader or lagger relative to its benchmark. The free version uses the same internal benchmark logic for regime detection but does not display the cross asset layer on the chart.
Cross asset structure is a core part of the MFM model and is fully available in the paid version.
Included in this free version
Higher timeframe regime
Current phase name
Clean chart output
Context only
Works on a selected set of assets
Not included
No forecast signals
No ratio leader or lagger logic
No MRM zones
No MPF timing
No auto tune
The full version contains all features of the complete MFM model.
Full version
You can find the full indicator here:
payhip.com
More information
Model details and documentation:
mfm.inratios.com
Momentum Framework Model free HUD indicator User Guide: mfm.inratios.com
Disclaimer
The Market Framework Model (MFM) and all related materials are provided for educational and informational purposes only. Nothing in this publication, the indicator, or any associated charts should be interpreted as financial advice, investment recommendations, or trading signals. All examples, visualizations, and backtests are illustrative and based on historical data. They do not guarantee or imply any future performance. Financial markets involve risk, including the potential loss of capital, and users remain fully responsible for their own decisions. The author and Inratios© make no representations or warranties regarding the accuracy, completeness, or reliability of the information provided. MFM describes structural market context only and should not be used as the sole basis for trading or investment actions.
By using the MFM indicator or any related insights, you agree to these terms.
© 2025 Inratios. Market Framework Model (MFM) is protected via i-Depot (BOIP) – Ref. 155670. No financial advice. مؤشر
مؤشر
