ابدأ الآن

ATR

BullBearXinsights - ATR Projection Levels [Phil Vo]This tool helps you understand how far price has moved during the session based on its average daily range (ATR). Instead of guessing where price might go, it shows you where price currently sits within its expected move for the day. I personally use it to read context: When price is near the lower percentages, the session is still developing and has room to move. Around the middle levels, the move becomes more meaningful and you want to be more selective. As price approaches the higher levels, the move is more stretched and risk starts to increase. This is not a signal indicator. It’s designed to give you a clearer sense of positioning, timing, and expansion during the session. Use it alongside your own strategy to avoid chasing extended moves and to better understand when price still has room to go. So I built this because I didn’t want to guess anymore. Most traders chase moves without knowing how much of the day is already used.
مؤشر Pine Script®
من ‎BullBearInsights‎
2
Exponential Nadaraya Watson kernel regression [Jamallo](2025) Intro Nadaraya-Watson (N-W) kernel regression is a non-parametric smoothing technique that estimates the underlying trend of a price series without assuming any fixed model shape (like a straight line or curve). Unlike a simple moving average which weights bars equally, or an EMA which applies a fixed exponential decay, N-W regression derives its curve by computing a weighted average of all prices within a lookback window — where the weights are determined by a kernel function. The most common kernel used is the Gaussian kernel, which assigns weights in a bell-curve shape — prices closer to the center of the window receive higher weight, prices at the edges receive lower weight. Most N-W implementations use a pure symmetric Gaussian kernel, meaning every bar within the lookback window is weighted purely by its distance from the center, with no preference for recency. This indicator uses a hybrid Exponential Nadaraya-Watson (ENW) kernel that combines two weighting forces simultaneously: Gaussian spatial weight — bell-curve weighting centered on the window, same as standard N-W Exponential time-decay weight — progressively heavier weighting on recent bars, similar to how an EMA behaves Both weights are multiplied together for each bar, meaning a price bar must be both spatially central and recent to receive maximum influence. In practice this shifts the effective weight peak toward the recent end of the window, making the K Line more responsive to current price action than standard N-W. Breakdown K Line — ENW Kernel Regression The central baseline of the indicator. A smooth adaptive curve derived from the hybrid ENW kernel applied to closing prices. Bandwidth is controlled via the Kernel Length and Alpha inputs — higher alpha increases the recency bias, lower alpha brings behavior closer to standard N-W. Volatility Bands (Inner & Outer) Rather than using ATR or standard deviation for band width, this indicator measures the absolute deviation of price from the K Line and smooths that deviation through the same ENW kernel. This means bands are fully adaptive — they expand and contract organically based on how far price has been straying from the regression curve, not a fixed statistical formula. Inner and outer bands are independently scaled via deviation multipliers. A Line — Vervoort ATR Stop A trailing stop built on the HLC4 price source with an ATR-based loss distance. Flips direction on a close beyond the stop level. Serves as the primary trend bias line — when above the K Line the fill turns bullish, when below it turns bearish. Cross signals (triangles) are plotted whenever the A Line crosses the K Line, marking potential trend shifts. Signal Line — Vervoort ATR Stop (Secondary) A second independent Vervoort trailing stop running on its own ATR period and multiplier settings. Typically configured looser than the A Line — wider multiplier, longer or equal period — so it acts as a slower confirmation layer. Useful for filtering noise on the A Line crosses: an A Line cross that also aligns with the Signal Line's bias carries more weight than one that doesn't. ------- Nadaraya-Watson kernel regression concept — E. Nadaraya (1964), G.S. Watson (1964) Vervoort ATR Stop — Sylvain Vervoort
مؤشر Pine Script®
من ‎Jamallo22‎
5
Rolling Segment [LuxAlgo]The Rolling Segment indicator provides a dynamic, trend-following reference line that adapts its slope and direction based on price volatility and distance from the market. 🔶 USAGE The indicator is designed to filter out minor price fluctuations while remaining responsive to significant trend shifts. It appears as a continuous segmented line on the chart, changing color based on the current trend (Green for bullish, Red for bearish). A gradient fill is applied between the price and the segment to visualize the "stretch" or deviation of the current price action from the trend line. This visual aid helps traders identify when price is moving in lockstep with the trend versus when it is overextending. 🔹 Reversal Signals The indicator identifies trend reversals when the distance between the price and the segment exceeds a user-defined ATR-based threshold. These reversals are marked on the chart with triangle labels: A bullish triangle (▲) appears below the segment when a new uptrend begins. A bearish triangle (▼) appears above the segment when a new downtrend begins. 🔹 Speed Modes The segment operates in two speed modes: "Fast" and "Slow." When price moves significantly away from the segment (crossing the Fast Threshold), the indicator switches to a faster slope to catch up with the momentum. When price is closer to the segment, it maintains a slower, more stable slope to avoid premature trend changes during consolidation. 🔶 MARKET INTERPRETATION The Rolling Segment acts as a measure of trend health. Because the slope is derived from the Average True Range (ATR), the "speed" of the line is normalized to the asset's current volatility. Trend Momentum: When the price stays consistently above a green segment (or below a red one) without triggering the "Fast" mode, it indicates a stable, sustainable trend. Price Exhaustion: A sudden jump into "Fast" mode often highlights a surge in momentum. If the price continues to stretch significantly beyond the segment even in fast mode, it may signal an overextended move prone to mean reversion. Consolidation: Horizontal or shallow segments indicate a period where the market is lacking a clear directional driver relative to its recent volatility. 🔶 DETAILS The core of the script relies on a state-machine logic that governs a unique slope-freezing mechanism. Unlike traditional moving averages that recalculate every bar based on shifting data, this indicator calculates a linear slope and "freezes" it until a specific state change occurs. The state is defined by the combination of Trend Direction and Speed Mode . The ATR value used to calculate the slope is only updated when: A trend reversal is detected (Price crosses the Reverse Threshold). The distance between price and the segment crosses the "Fast Threshold," triggering a shift in speed mode. The initial calculation begins at the start of the data series. By freezing the slope, the indicator produces perfectly linear segments. This mathematical intuition ensures that the reference line moves at a constant "volatility-adjusted rate" per bar, providing a cleaner visual representation of trend momentum and making it easier to spot price exhaustion when the market deviates too far from this constant rate. 🔶 SETTINGS 🔹 Slopes Fast Slope Length: The period used to determine the slope speed when the price is trending strongly. Lower values result in a steeper, more aggressive slope. Slow Slope Length: The period used to determine the slope speed during standard market conditions. Higher values create a flatter, more trailing segment. 🔹 ATR Settings ATR Length: The lookback period for the Average True Range calculation, which scales the slope and thresholds to current market volatility. 🔹 Thresholds Fast Slope Threshold (ATR Multiplier): The distance (in ATR units) the price must reach from the segment to trigger the "Fast" slope mode. Reverse Threshold (ATR Multiplier): The distance (in ATR units) the price must cross against the current trend to trigger a reversal and change the segment direction.
مؤشر Pine Script®
من ‎LuxAlgo‎
12
Kalman Regime [Jamallo](2025) Intro Kalman Regime filters price through two stages — a Gaussian kernel weighted average followed by an adaptive Kalman filter — to produce a smooth, noise-resistant baseline. ATR is used throughout to make the system volatility-aware. Breakdown The Gaussian kernel pre-smooths price using a bell-shaped weight profile that blends recency bias (recent bars matter more) with center localization (edge bars contribute less). This pre-smoothed value is then passed into an adaptive Kalman filter, which recursively estimates the "true" price state by balancing how much to trust the new measurement versus the prior state — with that balance dynamically scaled by current ATR. The resulting baseline drives regime detection through a two-tier state machine. A strong signal fires when price breaks the ATR envelope and the baseline slope confirms direction. A weaker signal fires when price crosses the baseline and slope exceeds an ATR-scaled threshold. This dual-gate structure reduces whipsaws without adding lag. END A two-stage price filter combining a Gaussian kernel pre-smoother with an adaptive Kalman filter, using ATR envelopes and slope confirmation for regime detection.
مؤشر Pine Script®
من ‎Jamallo22‎
Trend Lines [UAlgo]Trend Lines is a pivot driven structure indicator that automatically builds, validates, extends, and monitors bullish and bearish trendlines directly on the chart. Instead of relying on manual drawing, the script searches for confirmed pivot highs and pivot lows, connects them into directional line candidates, and keeps only the lines that satisfy a strict set of structural rules. The script is designed to solve a common problem in automated trendline tools. Many indicators can connect two points, but far fewer can judge whether that connection is meaningful. This script does more than draw a line between pivots. It checks bar separation, optional candle body integrity, touch accumulation, break violations, and active state transitions. As a result, it behaves more like a structural trendline engine than a basic line connector. Upper trendlines are built from descending pivot highs and act as bearish pressure lines until price breaks above them. Lower trendlines are built from ascending pivot lows and act as bullish support lines until price breaks below them. Every line begins as a candidate, can become active once it collects enough touches, and is later marked as broken if price closes through it according to the selected break rule. The indicator also supports wick based or body based pivot sourcing, ATR based touch tolerance, optional candidate line display, optional broken line display, and touch count labels on active lines. This makes it flexible enough for both stricter and more permissive trendline workflows while still keeping the core logic rules based. In practical use, Trend Lines can help map directional structure, monitor confirmed support and resistance lines, and highlight meaningful line breaks without requiring manual chart drawing. 🔹 Features 🔸 Pivot Based Trendline Construction The script creates trendlines from confirmed pivot highs and pivot lows. This means every line is anchored to real swing structure rather than arbitrary local movement. 🔸 Wick or Body Source Selection Users can choose whether pivots should come from wick extremes or candle body extremes. This allows the trendline engine to behave either more aggressively or more conservatively depending on chart style. 🔸 ATR Based Touch Tolerance Touch validation uses an ATR scaled tolerance. This helps the script adapt to different volatility conditions instead of relying on a fixed price threshold. 🔸 Minimum Bars Between Pivots Two pivots must be separated by at least a minimum number of chart bars before they can define a candidate line. This helps reduce noisy or overly compressed line creation. 🔸 Multi Touch Validation A line becomes active only after enough pivot touches accumulate on the same projected structure. This prevents weak two point lines from being treated as fully confirmed too early. 🔸 Optional Body Integrity Rule The script can reject lines that cut through candle bodies between the two anchor pivots. This is useful for users who want cleaner structural lines that sit above or below the main body flow of price. 🔸 Candidate, Active, and Broken States Every line can exist in one of several states. It may begin as a candidate, become active after enough touches, and later become broken once price violates it. Each state has its own visual styling. 🔸 Touch Count Labels Active lines can display a compact touch count marker so the user can quickly see how many pivots supported that line. 🔸 Controlled Line Creation The script limits how many new lines each fresh pivot can generate and also limits the total tracked lines per side. This helps reduce visual overload. 🔸 Bullish and Bearish Break Alerts Alerts are included for bullish trendline breaks and bearish trendline breaks once they are confirmed by the selected break rule. 🔹 Calculations 1) Defining Pivot and Trendline Objects type PivotPoint int pivotTime float price type TrendlineState int t1 float y1 int t2 float y2 float slope bool isUpper int touches = 2 int lastTouchTime bool isActive = false bool isBroken = false bool isDisabled = false int breakTime = na float breakPrice = na line basisLine = na label breakLabel = na label touchLabel = na This is the structural base of the whole script. A PivotPoint stores the time and price of one confirmed pivot. A TrendlineState stores everything needed to manage one line: its two anchor points, its slope, whether it is an upper or lower line, how many touches it has, whether it is active, whether it has broken, whether it has been disabled, where the break occurred, and the visual objects used to display it. So the indicator is not simply drawing lines. It is managing full line objects with state and lifecycle logic. 2) Choosing Wick or Body Pivot Source float highSource = sourceMode == "Wick" ? high : math.max(open, close) float lowSource = sourceMode == "Wick" ? low : math.min(open, close) float pivotHighPrice = ta.pivothigh(highSource, pivotLength, pivotLength) float pivotLowPrice = ta.pivotlow(lowSource, pivotLength, pivotLength) This block determines what kind of pivots the script should use. If the user selects Wick mode, pivot highs come from highs and pivot lows come from lows. If the user selects Body mode, pivot highs come from the candle body top and pivot lows come from the candle body bottom. This matters because wick based pivots are more sensitive to extreme price tests, while body based pivots focus more on where the market actually closed and opened. So the user can tune whether the trendline engine should react to extremes or to body structure. 3) ATR Based Touch Tolerance float touchTolerance = math.max(ta.atr(atrLength) * touchAtrMult, syminfo.mintick * 2.0) This defines how close a pivot must be to a projected line in order to count as a valid touch. The script multiplies ATR by the chosen tolerance multiplier. It also enforces a minimum tolerance of two ticks. This makes the detection scale naturally with volatility while still remaining usable on very quiet instruments. So the touch system is adaptive rather than fixed. 4) Calculating the Trendline Value at Any Time method priceAt(TrendlineState this, int targetTime) => this.y1 + this.slope * float(targetTime - this.t1) This is the core projection formula. Once the line anchors and slope are known, the script can compute the expected price of that line at any later time. This is used throughout the indicator for touch detection, break detection, candle body validation, label placement, and live extension. So this method turns a static anchor pair into a dynamic projected structure. 5) Counting Bars Between Two Pivot Times f_countBarsBetween(int startTime, int endTime) => int barsBetween = 0 if endTime > startTime int offset = 0 while offset <= bar_index and time >= startTime int barTime = time if barTime <= endTime and barTime > startTime barsBetween += 1 offset += 1 barsBetween This helper function measures how many chart bars exist between two pivot anchors. It is used to enforce the minimum bars between pivots rule. This prevents the script from connecting pivots that are too close together and likely to generate noisy or trivial lines. So this function helps control line quality through temporal separation. 6) Body Integrity Rule method respectsBodies(TrendlineState this, float tolerance) => bool result = true if this.t2 > this.t1 int offset = 0 while offset <= bar_index and time >= this.t1 int barTime = time if barTime < this.t2 and barTime > this.t1 float linePrice = this.priceAt(barTime) float bodyTop = f_bodyHigh(offset) float bodyBottom = f_bodyLow(offset) if this.isUpper and linePrice < bodyTop - tolerance result := false break if not this.isUpper and linePrice > bodyBottom + tolerance result := false break result This is one of the most important quality filters in the script. For upper lines, the projected line should stay above candle bodies between the anchor pivots. For lower lines, the projected line should stay below candle bodies between the anchor pivots. If the line cuts too deeply through candle bodies, it is rejected. This filter helps eliminate visually awkward or structurally weak lines that may mathematically connect pivots but do not actually respect the shape of price movement between them. 7) Break Violation Check at a Specific Bar method isBreakViolationAt(TrendlineState this, int targetTime, int offset, string methodName, float tolerance) => float linePrice = this.priceAt(targetTime) float priceSource = this.isUpper ? f_bodyHigh(offset) : f_bodyLow(offset) float breakTolerance = f_breakTolerance(methodName, tolerance) this.isUpper ? priceSource > linePrice + breakTolerance : priceSource < linePrice - breakTolerance This method checks whether a line is violated by the current candle body. For upper lines, a violation happens when candle body high moves above the projected line. For lower lines, a violation happens when candle body low moves below the projected line. If the selected break method includes tolerance, the ATR based tolerance is included in the threshold. If the user selects the no tolerance method, the break must occur directly through the line. So this method defines exactly what a valid structural break means. 8) Scanning a Whole Time Interval for Violations method hasBreakViolation(TrendlineState this, int startTime, int endTime, string methodName, float tolerance) => bool violated = false if endTime >= startTime int offset = 0 while offset <= bar_index and time >= startTime int targetTime = time if targetTime <= endTime and targetTime >= startTime and this.isBreakViolationAt(targetTime, offset, methodName, tolerance) violated := true break offset += 1 violated This function applies the break logic across an entire span of bars. The script uses it in two main places: to reject candidate lines that were already violated between their anchor pivots, and to reject future touches if price already broke the line before the new pivot arrived. So a line is not accepted simply because its endpoints look valid. It must also remain unbroken through the relevant interval. 9) Registering a New Touch method registerTouch(TrendlineState this, PivotPoint pivot, string methodName, float tolerance, int requiredTouches) => bool touched = false if not this.isBroken and not this.isDisabled and pivot.pivotTime > this.t2 and pivot.pivotTime > this.lastTouchTime if this.hasBreakViolation(this.lastTouchTime + 1, pivot.pivotTime - 1, methodName, tolerance) this.disable() else float projectedPrice = this.priceAt(pivot.pivotTime) if math.abs(pivot.price - projectedPrice) <= tolerance this.touches += 1 this.lastTouchTime := pivot.pivotTime this.isActive := this.touches >= requiredTouches touched := true touched This method decides whether a fresh pivot should strengthen an existing line. The pivot must arrive after the second anchor and after the last recorded touch. Before the script accepts the touch, it checks whether price already violated the line between the last touch and the new pivot. If a violation happened, the line is disabled. If not, the projected line price at the pivot time is calculated, and the pivot is counted as a touch if it lies within tolerance. If the new touch count reaches the required threshold, the line becomes active. So this is the process that transforms a simple anchor pair into a confirmed multi touch trendline. 10) Building New Candidate Lines method buildCandidates(array this, array pivots, PivotPoint newest, bool isUpper, int minGap, string methodName, float tolerance, int requiredTouches, bool strictBodyFilter, int maxCount, int maxPerPivot) => int pivotCount = pivots.size() int builtCount = 0 if pivotCount > 1 for step = 1 to pivotCount - 1 PivotPoint older = pivots.get(pivotCount - 1 - step) int barsApart = f_countBarsBetween(older.pivotTime, newest.pivotTime) int timeApart = newest.pivotTime - older.pivotTime bool directionalMove = isUpper ? newest.price < older.price : newest.price > older.price This method is the line creation engine. Whenever a new pivot appears, the script looks backward through stored pivots of the same type and tries to form new candidate lines. For upper lines, the newest pivot must be lower than the older one. For lower lines, the newest pivot must be higher than the older one. This directional requirement ensures the script only builds descending resistance lines from highs and ascending support lines from lows. The method also checks bar separation and respects the per pivot creation limit so one pivot does not create too many new candidates. 11) Accepting or Rejecting Candidates TrendlineState candidate = TrendlineState.new(t1=older.pivotTime, y1=older.price, t2=newest.pivotTime, y2=newest.price, slope=(newest.price - older.price) / float(timeApart), isUpper=isUpper, touches=2, lastTouchTime=newest.pivotTime, isActive=requiredTouches <= 2) bool accepted = strictBodyFilter ? candidate.respectsBodies(tolerance) : true accepted := accepted and not candidate.hasBreakViolation(older.pivotTime + 1, newest.pivotTime - 1, methodName, tolerance) if accepted this.enqueueLine(candidate, maxCount) builtCount += 1 Once a candidate is formed, the script tests two major filters. First, if the body rule is enabled, the candidate must respect candle bodies between the anchor pivots. Second, the candidate must not already have been broken between those pivots. Only if both conditions pass is the candidate stored. So the script creates only structurally clean lines, not just any mathematically possible connection. 12) Managing Line Storage Limits method enqueueLine(array this, TrendlineState trendline, int maxCount) => this.push(trendline) if this.size() > maxCount TrendlineState removed = this.shift() removed.deleteVisuals() this This method keeps the number of tracked lines under control. If the array exceeds the allowed maximum, the oldest line is removed and its visuals are deleted. This helps the indicator stay manageable and prevents the chart from filling with stale historical candidates. So the script balances structure memory with chart readability. 13) Break Detection for Active Lines method maybeBreak(TrendlineState this, string methodName, float tolerance, color bullishColor, color bearishColor, string textSize) => bool didBreak = false if this.isActive and not this.isBroken and not this.isDisabled and barstate.isconfirmed and time > this.t2 and not na(time ) bool crossed = this.isBreakViolationAt(time, 0, methodName, tolerance) if crossed this.isBroken := true this.breakTime := time this.breakPrice := this.priceAt(time) string breakText = this.isUpper ? "Bull Break" : "Bear Break" This is the live break engine. Only active, valid lines are checked. The script waits for a confirmed bar after the second anchor, then tests whether the current candle body violates the line. If an upper line breaks, the break is labeled as bullish because price broke upward through resistance. If a lower line breaks, the break is labeled as bearish because price broke downward through support. So the break direction is interpreted from the structural meaning of the line, not from the line type name itself. 14) Processing New Pivots Against Existing Lines if not na(pivotHighPrice) PivotPoint highPivot = PivotPoint.new(pivotTime=time , price=pivotHighPrice) upperLines.processPivotTouch(highPivot, breakMethod, touchTolerance, minTouches) highPivots.rememberPivot(highPivot, pivotMemory) upperLines.buildCandidates(highPivots, highPivot, true, minBarsBetweenPivots, breakMethod, touchTolerance, minTouches, enforceBodyRule, maxTrackedLines, maxNewLinesPerPivot) if not na(pivotLowPrice) PivotPoint lowPivot = PivotPoint.new(pivotTime=time , price=pivotLowPrice) lowerLines.processPivotTouch(lowPivot, breakMethod, touchTolerance, minTouches) lowPivots.rememberPivot(lowPivot, pivotMemory) lowerLines.buildCandidates(lowPivots, lowPivot, false, minBarsBetweenPivots, breakMethod, touchTolerance, minTouches, enforceBodyRule, maxTrackedLines, maxNewLinesPerPivot) This is the main structural update flow. When a new pivot high appears, the script first checks whether that pivot adds touches to existing upper lines. Then it stores the pivot in memory. After that, it tries to build new upper candidates from that fresh pivot. The exact same sequence is used for lower pivots and lower lines. So every new confirmed pivot serves two purposes: it may strengthen existing structure, and it may create new structure. 15) Refreshing Visual States upperLines.refreshAll(bullColor, bearColor, showCandidates, showBrokenLines, lineWidth, candidateOpacity, activeOpacityFloor, brokenOpacity, showTouchMarkers, labelSize) lowerLines.refreshAll(bullColor, bearColor, showCandidates, showBrokenLines, lineWidth, candidateOpacity, activeOpacityFloor, brokenOpacity, showTouchMarkers, labelSize) The script refreshes all stored lines on every bar. Candidate lines, active lines, and broken lines all receive different visual treatment according to the user’s settings. Active lines are stronger and more visible. Candidates are lighter and dotted. Broken lines are dashed and faded. This means the chart always reflects the latest line state rather than treating every stored line the same way. 16) Touch Marker Logic if this.isActive and drawTouchMarkers and not this.isBroken int markerTime = time + f_barTimeMs() string touchText = str.tostring(this.touches) + "T" float markerY = this.priceAt(time) Active lines can display a small touch count label just ahead of the current bar. The script places the label at the projected line value on the latest bar and prints the current number of touches. This gives the user a quick measure of structural strength without needing to inspect the line history manually. So touch markers turn active lines into easy to rank structural objects. 17) Alert Conditions bool bullishBreak = upperLines.breakScan(breakMethod, touchTolerance, bullColor, bearColor, labelSize) bool bearishBreak = lowerLines.breakScan(breakMethod, touchTolerance, bullColor, bearColor, labelSize) alertcondition(bullishBreak, "Bullish Trendline Break", "Bullish trendline break confirmed on close.") alertcondition(bearishBreak, "Bearish Trendline Break", "Bearish trendline break confirmed on close.") This is the final event layer of the script. The indicator scans all upper lines for bullish breaks and all lower lines for bearish breaks. If any valid active line breaks on the confirmed bar, the corresponding alert condition becomes true. So the alert engine is tied to the same structural logic as the chart drawings, not to a simplified separate trigger.
مؤشر Pine Script®
من ‎UAlgo‎
NOA Trading Sessions ProNOA Trading Sessions Pro This indicator plots up to four custom trading sessions on your chart and calculates real-time statistics for volume, range, and volatility. It is built to provide the exact metrics used on institutional trading desks to measure market context. Core Mechanics You can define the start and end times, IANA timezone, and colors for four different sessions (for example: Tokyo, London, Pre-Market, New York). The script plots the open, high, low, and close levels of the active session, along with an optional mid-line or session VWAP. A data box anchors below each session. To prevent the text from overlapping with price bars or volume profiles, the script uses a dynamic ATR offset to push the label into empty chart space. This keeps the chart readable on any timeframe or asset class. Reading the Data Like an Institutional Trader Retail traders often trade patterns; institutional traders trade statistics. The data box provides the context needed to understand if a move is legitimate, exhausted, or a trap. Range vs. Average Range: The indicator tracks the current session range and compares it to the historical average for that specific time of day. If the London session typically moves 80 ticks and currently sits at 30 ticks, the market is compressing and a move is likely pending. Relative Volume (RVol): Volume validates price. The script calculates a volume multiplier comparing the current session to its historical average. If price breaks a session high on 0.5x volume, it is likely a liquidity sweep or a false breakout. If it breaks on 1.5x volume or higher, institutions are actively participating and the breakout is valid. Delta: This measures the net directional push from the session open. Comparing the Delta to the total Range tells you how directional the session is versus how much it is just chopping back and forth. VWAP: The Volume Weighted Average Price is the institutional baseline. Price extending far from VWAP on low relative volume is a prime condition for mean reversion. Price holding above VWAP on high relative volume signals sustained institutional accumulation. The Volatility Heatmap The text color in the data box shifts automatically based on how the current range compares to the historical average range. This helps identify exhaustion and expansion in real time. Gray (Under 70%): The session is in a compression phase. Price is chopping in a tight range. Expect mean reversion and avoid trading breakouts. White (70% to 99%): Normal distribution. The session is developing as statistically expected. Yellow (100% to 119%): Exhaustion. The session has met its historical daily target. Late breakouts at this stage have a high probability of failure, and institutional traders are likely taking profit. Red (120%+): Expansion. This is a statistical outlier or a trend day, usually driven by high-impact news. Mean reversion strategies will fail here; you only trade with the momentum.
مؤشر Pine Script®
من ‎nord-ouestadvisors‎
1
Regime Classifier [JOAT]Regime Classifier Introduction The Regime Classifier is a sophisticated market state detection system designed to identify and classify market conditions into distinct operational regimes. Understanding the current market regime is perhaps the most critical factor in successful trading - a strategy that works beautifully in a trending market will fail miserably in a ranging market, and vice versa. This indicator solves that fundamental problem by providing clear, actionable classification of market states, allowing traders to adapt their approach to current conditions. This tool is built for traders who understand that markets are not random but move through distinct phases, each requiring different strategies and risk management approaches. Whether you're a systematic trader needing regime filters, a discretionary trader seeking market context, or a portfolio manager adjusting exposure, this classifier provides the institutional-grade market intelligence needed to navigate any market environment successfully. Why This Indicator Exists Most traders apply the same strategy regardless of market conditions, then wonder why their performance is inconsistent. This indicator addresses that critical flaw by: Regime Classification: Identifies four distinct market states with clear characteristics Regime Strength: Measures how strongly the market exhibits regime characteristics Regime Persistence: Tracks how long the current regime has been in place Regime Quality: Evaluates the reliability of the current regime classification Session Awareness: Considers session context for regime analysis Regime Transitions: Detects and signals regime changes for strategy adaptation The classifier transforms the complex, often subjective process of market analysis into an objective, systematic framework that can be consistently applied across all instruments and timeframes. Core Components Explained 1. ADX-Based Trend Detection The Average Directional Index (ADX) is the primary tool for trend detection: // ADX calculation float atr_val = ta.rma(ta.tr(true), i_adx_period) float up_move = high - high float down_move = low - low float plus_dm = up_move > down_move and up_move > 0 ? up_move : 0 float minus_dm = down_move > up_move and down_move > 0 ? down_move : 0 float plus_di = 100 * ta.rma(plus_dm, i_adx_period) / atr_val float minus_di = 100 * ta.rma(minus_dm, i_adx_period) / atr_val float adx = 100 * ta.rma(math.abs(plus_di - minus_di) / (plus_di + minus_di), i_adx_period) ADX components: ADX Value: Trend strength (0-100), regardless of direction +DI: Bullish directional movement -DI: Bearish directional movement Trend Threshold: Minimum ADX for trend classification (default 25) Directional Bias: +DI vs -DI for trend direction ADX above 25 indicates a trending market, while below 25 suggests ranging or volatile conditions. 2. ATR-Based Volatility Analysis The Average True Range (ATR) measures volatility and helps distinguish between different non-trending states: // ATR analysis float atr_current = ta.atr(i_atr_period) float atr_average = ta.sma(atr_current, i_atr_period * 3) float atr_ratio = atr_average > 0 ? atr_current / atr_average : 1.0 // Volatility thresholds float expansion_threshold = i_atr_expansion_mult float contraction_threshold = i_atr_contraction_mult ATR components: Current ATR: Recent volatility measurement Average ATR: Long-term volatility baseline ATR Ratio: Current volatility relative to average Expansion Threshold: Ratio indicating high volatility (default 1.4) Contraction Threshold: Ratio indicating low volatility (default 0.6) ATR analysis helps distinguish between ranging (low volatility) and volatile (high volatility) markets when ADX is below the trend threshold. 3. Regime Classification Logic The indicator classifies markets into four distinct regimes: // Regime classification int market_regime = 0 if adx >= i_adx_trend market_regime := 1 // Trending else if atr_ratio >= expansion_threshold and adx < i_adx_trend market_regime := 3 // Volatile else if atr_ratio <= contraction_threshold and adx < i_adx_trend market_regime := 2 // Ranging else market_regime := 0 // Neutral Regime types: Trending (ADX ≥ 25): Strong directional movement with clear trend Ranging (ADX < 25, ATR ratio ≤ 0.6): Low volatility, sideways movement Volatile (ADX < 25, ATR ratio ≥ 1.4): High volatility, erratic movement Neutral (ADX < 25, 0.6 < ATR ratio < 1.4): Transition between defined states Each regime has distinct characteristics that require different trading approaches. 4. Regime Strength Measurement Not all regimes are created equal - some are stronger and more reliable than others: // Regime strength calculation float regime_strength = 0.0 switch market_regime 1 => regime_strength := math.min(adx / 50.0 * 100, 100) // Trending strength 2 => regime_strength := math.min((1 - atr_ratio) / (1 - contraction_threshold) * 100, 100) // Ranging strength 3 => regime_strength := math.min((atr_ratio - 1) / (expansion_threshold - 1) * 100, 100) // Volatile strength 0 => regime_strength := 50.0 // Neutral default Strength interpretation: Trending Strength: Based on ADX value (higher ADX = stronger trend) Ranging Strength: Based on how low volatility is (lower ATR = stronger range) Volatile Strength: Based on how high volatility is (higher ATR = stronger volatility) Neutral Strength: Fixed at 50% as baseline Strength Range: 0-100% indicating regime confidence Higher strength values indicate more reliable regime classification. 5. Regime Persistence Analysis The duration of a regime provides additional context about its reliability: // Regime persistence tracking var int regime_bars = 0 var int regime_start_bar = 0 if market_regime == market_regime regime_bars := regime_bars + 1 else regime_bars := 1 regime_start_bar := bar_index // Persistence score float persistence_score = math.min(float(regime_bars) / i_persistence_lookback * 100, 100) Persistence features: Regime Bars: Number of consecutive bars in current regime Regime Start: When the current regime began Persistence Score: Normalized duration (0-100%) Lookback Period: Reference period for normalization (default 50) Mature Regimes: Higher persistence indicates established conditions Long-lasting regimes are more reliable than newly formed ones. 6. Regime Quality Assessment Quality evaluates how well the current market fits the regime characteristics: // Quality assessment float quality_score = 0.0 float adx_quality = adx / 50.0 * 50 // 50% weight float atr_quality = market_regime == 2 ? (1 - atr_ratio) / (1 - contraction_threshold) * 50 : market_regime == 3 ? (atr_ratio - 1) / (expansion_threshold - 1) * 50 : 25 quality_score := adx_quality + atr_quality Quality components: ADX Quality: How well trend strength matches regime expectations ATR Quality: How well volatility matches regime expectations Quality Score: Combined assessment (0-100%) High Quality: Clear regime characteristics Low Quality: Ambiguous or transitioning conditions High quality scores indicate clear, unambiguous market conditions. 7. Session Context Integration Market behavior varies significantly across trading sessions: // Session analysis bool asian_session = time(timeframe.period, "0000-0800") bool london_session = time(timeframe.period, "0700-1600") bool ny_session = time(timeframe.period, "1200-2100") // Session-specific adjustments float session_multiplier = 1.0 if london_session session_multiplier := 1.2 // Higher volatility expected else if asian_session session_multiplier := 0.8 // Lower volatility expected Session features: Session Detection: Identifies major trading sessions Session Multipliers: Adjusts expectations based on session characteristics Session Persistence: Tracks regime duration within current session Session Quality: Evaluates regime quality within session context Session Transitions: Identifies regime changes at session opens/closes Session context helps interpret regime changes and anticipate behavior. Visual Elements Regime Histogram: Color-coded bars showing current regime Strength Meter: Visual representation of regime strength Persistence Line: Shows regime duration over time Quality Gauge: Quality score visualization Background Colors: Regime-based background shading Session Markers: Visual session boundaries Dashboard: Real-time regime metrics Transition Alerts: Visual regime change notifications The dashboard displays: 1. Current market regime and confidence 2. Regime strength and persistence 3. Quality score and trend direction 4. Session context and behavior 5. Regime history and transitions 6. Recommended strategies for current regime 7. Risk management adjustments 8. Regime forecast based on patterns Input Parameters ADX Settings: ADX Period: Trend strength calculation (default: 14) Trend Threshold: Minimum ADX for trend regime (default: 25) ADX Smoothing: Additional smoothing for ADX (default: 3) ATR Settings: ATR Period: Volatility calculation (default: 14) Expansion Multiplier: High volatility threshold (default: 1.4) Contraction Multiplier: Low volatility threshold (default: 0.6) Analysis Settings: Persistence Lookback: Reference for persistence score (default: 50) Quality Smoothing: Smoothing for quality calculation (default: 5) Session Awareness: Enable session analysis (default: true) Visual Settings: Color Scheme: Customizable regime colors Background Shading: Enable regime backgrounds Dashboard Display: Show metrics panel Alert Settings: Configure regime change alerts How to Use This Indicator Step 1: Identify Current Regime Check the dashboard for the current market regime. Each regime requires a different approach: Trending: Use trend-following strategies, let winners run Ranging: Use mean-reversion strategies, take profits at levels Volatile: Reduce position size, use wider stops, or avoid trading Neutral: Wait for clarity, reduce trading activity Step 2: Assess Regime Strength Higher strength indicates more reliable conditions. In strong regimes (80%+), you can be more aggressive with position sizing. In weak regimes (<50%), reduce exposure and wait for confirmation. Step 3: Monitor Persistence Newly formed regimes (<10 bars) may be false signals. Mature regimes (>20 bars) are more established and reliable. Consider regime persistence in your strategy selection. Step 4: Evaluate Quality High quality scores (>75%) indicate clear market conditions. Low quality scores (<50%) suggest ambiguity - reduce trading or wait for clarity. Step 5: Consider Session Context Regimes that persist across multiple sessions are more significant. Regime changes at session opens often set the tone for the session. Step 6: Watch for Transitions Regime transitions signal strategy changes. A shift from trending to ranging requires switching from trend-following to range-bound strategies. Best Practices Always adapt your strategy to the current regime - don't use a trending strategy in ranging markets High strength + high quality = maximum confidence in regime classification Low persistence regimes (<10 bars) may be false - wait for confirmation Session transitions often trigger regime changes - be alert at session opens Volatile regimes are dangerous for most traders - consider reducing activity Regime persistence is key - the longer a regime persists, the more reliable it is Quality scores below 50% suggest waiting for clarity Combine regime analysis with your existing strategy for better results Keep a regime journal to track how each instrument behaves in different regimes Use regime transitions as signals to adjust your entire trading approach Strategy Applications by Regime Trending Regime: Trend-following strategies (moving averages, ADX, momentum) Let winners run to maximum targets Use trailing stops to capture extended moves Add to positions on pullbacks in trend direction Higher position sizing due to clear direction Ranging Regime: Mean-reversion strategies (RSI, Stochastic, Bollinger Bands) Take profits at support/resistance levels Use fixed targets - don't let winners turn into losers Fade extreme moves toward the range middle Smaller position sizing due to limited moves Volatile Regime: Reduce position size significantly (50% or less) Use wider stops to avoid premature exits Consider sitting out until conditions improve Focus on volatility breakout patterns if trading Quick profit taking - volatile conditions reverse quickly Neutral Regime: Wait for clarity before taking new positions Manage existing positions more actively Reduce trading frequency Look for regime transition signals Focus on longer timeframe analysis for direction Technical Implementation Built with Pine Script v6 featuring: Advanced ADX calculation with directional movement analysis Multi-timeframe ATR analysis for volatility assessment Regime classification with confirmation logic Strength, persistence, and quality scoring systems Session awareness with timezone handling Comprehensive visualization with multiple display modes Real-time dashboard with 10 key metrics Alert conditions for regime changes and thresholds Export functions for strategy integration Historical regime tracking and pattern recognition The code uses confirmed bars for all calculations to prevent repainting and ensure reliable regime classification. Originality Statement This indicator is original in its comprehensive approach to regime classification and market state analysis. While ADX and ATR are established tools, this indicator is justified because: It synthesizes trend and volatility analysis into a unified regime classification system The strength, persistence, and quality scoring provides multi-dimensional regime assessment Session awareness adds critical context often missing from regime analysis Regime transition detection helps traders adapt strategy changes proactively The four-regime classification (Trending, Ranging, Volatile, Neutral) covers all market states Quality assessment helps distinguish between clear and ambiguous market conditions Persistence analysis identifies mature, reliable regimes versus new, potentially false ones Comprehensive visualization makes complex regime analysis accessible and actionable Export functions enable regime-based strategy filtering and adaptation Each component provides unique insights: ADX shows trend, ATR shows volatility, strength shows conviction, persistence shows duration, and quality shows clarity The indicator's value lies in transforming the abstract concept of "market conditions" into concrete, actionable classifications that traders can use to adapt their strategies systematically and consistently. Disclaimer This indicator is provided for educational and informational purposes only. It is not financial advice or a recommendation to buy or sell any financial instrument. Regime classification is a tool for understanding market conditions, not a prediction system. Market regimes can change suddenly due to news events, economic data, or changes in market structure. Past regime behavior does not guarantee future patterns. The indicator's classifications are mathematical calculations based on historical patterns and should be used in conjunction with other forms of analysis. Always use proper risk management, including stop losses and position sizing appropriate for current market conditions. Different regimes require different risk approaches - volatile regimes may require smaller positions and wider stops. The author is not responsible for any losses incurred from using this indicator. Users assume full responsibility for all trading decisions made using this system. -Made with passion by officialjackofalltrades
مؤشر Pine Script®
من ‎officialjackofalltrades‎
Average Volatility ZonesDisplays the average volatility range directly on the chart as horizontal levels projected from the current period's open. The indicator calculates the average candle size (High-Low or True Range) over a configurable period and timeframe (default: Daily, 20 bars), then draws upper and lower lines at that distance from the current timeframe open — showing how far price typically moves within one period. Key features: - Multi-timeframe support — measure volatility from any timeframe (M15 to Monthly) - Scalable levels — optional 2x, 3x, and custom multiplier levels for extended volatility zones - Zone mode — converts lines into shaded bands based on a percentage of the average volatility - Automatic pip detection for forex pairs (supports 5-digit and 3-digit brokers) - Each level is labeled with its timeframe, period, and value in pips - Fully customizable colors, line styles, label positioning, and zone transparency Useful for gauging intraday range potential, setting realistic targets, identifying overextended moves, and filtering entries near volatility extremes.
مؤشر Pine Script®
من ‎zemanjose‎
ATR Stop - w/TP & StatsATR Stop – With Take Profit & Performance Stats This indicator builds on the classic ATR trailing stop concept by adding automated take-profit targets, signal tracking, and real-time performance statistics directly on the chart. It is designed to help traders visualize trend reversals, trade targets, and historical signal performance without needing a separate strategy backtest. Indicator Overview The script calculates a dynamic trailing stop using Average True Range (ATR). When price crosses the stop level, a BUY or SELL signal is generated. Each signal automatically receives a take-profit level based on ATR, and the indicator tracks whether the trade: Hits the TP → Win Gets replaced by a new signal before TP → Loss Is still active → Pending A statistics panel summarizes the results of recent signals. Core Features ATR Trailing Stop System Uses ATR to dynamically calculate a trailing stop. Stop flips direction when price crosses it. Provides clear visual trend direction. Automatic Buy / Sell Signals BUY when price crosses above the ATR stop. SELL when price crosses below the ATR stop. Optional non-repainting confirmation on candle close. ATR-Based Take Profit Targets Each signal creates a take-profit level based on ATR multiple. TP lines extend while the trade is active. When TP is hit, the trade is marked as a win. Signal Outcome Tracking Trades are categorized as: Win → TP reached Loss → Opposite signal appears before TP Pending → TP not yet reached This allows quick evaluation of signal quality. Performance Statistics Panel Displays real-time statistics including: Total signals Pending trades Wins and losses Hit rate % Statistics are calculated from the most recent signals defined by the lookback setting. Chart Visualization ATR stop plotted on chart BUY / SELL labels with TP price Optional TP lines Optional bar coloring based on trend direction Key Inputs ATR Period Length used for ATR calculation. ATR Multiplier Distance of the trailing stop from price. Take Profit ATR Multiplier Distance of TP level relative to ATR. Lookback Closed Trades Number of completed trades included in statistics. Non-Repainting Signals Signals only trigger on confirmed candle closes. Show Take Profit Lines Toggle visibility of TP lines. Bar Coloring Color candles based on ATR stop direction. How Trade Outcomes Are Determined Signal appears TP level is calculated using ATR Trade remains pending One of two events resolves the trade: TP Hit Trade counted as Win Opposite Signal Before TP Previous trade counted as Loss What Makes This Indicator Useful Combines trend detection + trade management Provides visual TP targets Tracks signal performance automatically Maintains clean charts using rolling lookback statistics Designed for manual trading analysis and signal validation Alerts Two alert conditions are included: Buy Signal Sell Signal These can be used to trigger TradingView alerts or automation workflows. Typical Use Cases Trend following strategies ATR-based trade management Signal quality evaluation Visual backtesting Entry/exit reference levels
مؤشر Pine Script®
من ‎tgregg75‎
Viprasol Sniper Confluence Entry/Exit## Overview The Sniper Confluence Entry/Exit indicator builds on Sniper Entry/Exit with SL&TP by , which provided EMA crossover signals with ATR-based stop-loss/take-profit levels, a VWAP overlay, RSI/MACD display, and retest candle highlighting. This version adds a 7-factor confluence scoring engine that gates every signal — crossovers only fire when multiple technical factors align, dramatically reducing false entries. Built for swing and intraday traders who want clean, high-probability setups with automatic risk management. ## How It Works **Signal Generation (from original):** Entries are triggered by a Fast EMA / Slow EMA crossover. When the fast EMA crosses above the slow EMA, a long signal is generated; when it crosses below, a short signal is generated. The original script displayed these crossovers alongside supporting indicators (VWAP, RSI, MACD) but did not require them to agree before firing a signal. **7-Factor Confluence Engine (new):** This version adds a scoring layer that sits between the crossover and the signal output. Each bar, the indicator evaluates 7 independent factors and assigns 1 point for each that confirms the trade direction. A signal only fires when the total score meets your minimum threshold (default: 4/7). Scoring logic (pseudocode): ``` confluenceScore = 0 // Factor 1: Price vs VWAP if (long and close > vwap) or (short and close < vwap) → score += 1 // Factor 2: RSI direction if (long and rsi > 50) or (short and rsi < 50) → score += 1 // Factor 3: MACD trend if (long and macdLine > signalLine) or (short and macdLine < signalLine) → score += 1 // Factor 4: EMA alignment if (long and fastEMA > slowEMA) or (short and fastEMA < slowEMA) → score += 1 // Factor 5: ADX + directional index if adx > 25 and ((long and diPlus > diMinus) or (short and diMinus > diPlus)) → score += 1 // Factor 6: Volume confirmation if volume > volumeSMA and ((long and close > open) or (short and close < open)) → score += 1 // Factor 7: Secondary timeframe RSI if (long and secondaryRSI > 50) or (short and secondaryRSI < 50) → score += 1 signal fires only if confluenceScore >= minimumScore ``` A score of 5/7 or higher typically indicates a strong, well-supported setup. The configurable minimum lets you tune signal frequency vs. quality. **Bar-Close Confirmation (new):** When enabled, signals are delayed until the bar closes, preventing premature entries from intra-bar wicks that reverse before close. **ATR-Based Stop-Loss & Take-Profit (from original, extended):** The original calculated a single stop-loss and take-profit from ATR. This version extends that to: - **Stop-Loss** — ATR multiplied by your chosen risk factor (same core logic as original) - **Take-Profit Levels (1-5)** — Configurable number of TP levels at 1R, 2R, 3R, 4R, 5R distances (new — original had fixed levels) - **Trailing Stop to Breakeven** — Optionally moves SL to entry price once TP1 is hit (new) **Retest Candle Highlighting (from original):** Bars that pull back to the fast EMA after a signal are highlighted in orange, marking potential add-on or re-entry opportunities. **Secondary Timeframe RSI (from original, extended):** The original included a secondary timeframe RSI hardcoded to the 5-minute chart. This version makes the timeframe user-configurable. ## Key Features **From the Original:** - EMA crossover signal generation (fast/slow EMA) - ATR-based stop-loss and take-profit calculation - VWAP overlay with directional coloring - RSI and MACD display - Retest candle highlighting at EMA pullbacks - Secondary timeframe RSI confirmation **Added in This Version:** - 7-factor confluence scoring engine with configurable minimum score threshold - Bar-close confirmation filter to prevent wick-driven false entries - Trailing stop-loss to breakeven after TP1 is hit - Configurable number of take-profit levels (1-5, was fixed) - Configurable secondary timeframe (was hardcoded to 5m) - SL label showing breakeven status when trailing is active - 5 alert conditions with dynamic messages - Full dashboard showing all 7 confluence factors, position status, and targets hit ## How to Use **Setup:** 1. Add to any chart (works on all markets and timeframes) 2. Set your preferred EMA periods (default: 9/21) 3. Adjust the minimum confluence score — higher = fewer signals, better quality 4. Set your ATR multiplier for stop-loss width **Reading Signals:** - **LONG label** appears below bar when bullish crossover fires with sufficient confluence - **SHORT label** appears above bar when bearish crossover fires with sufficient confluence - Blue line = Entry, Red line = Stop-Loss, Green dashed lines = Take-Profit levels - Lines turn turquoise when their target is hit - Orange candles indicate price retesting the fast EMA (potential add-on opportunity) **Dashboard:** The side panel shows real-time scores for all 7 factors plus current position info, targets hit, and SL status. **Recommended Starting Settings:** - Scalping (1m-5m): Fast EMA 5, Slow EMA 13, Min Score 5, ATR Mult 1.0 - Intraday (15m-1H): Fast EMA 9, Slow EMA 21, Min Score 4, ATR Mult 1.5 - Swing (4H-1D): Fast EMA 9, Slow EMA 21, Min Score 4, ATR Mult 2.0 ## Settings **Signal Settings:** Fast/Slow EMA periods and bar-close confirmation toggle. **Confluence Filter:** Enable/disable the score filter and set the minimum threshold. **Risk Management:** ATR period, SL multiplier, number of TP levels, and breakeven trailing toggle. **Secondary Timeframe:** Choose which timeframe provides the secondary RSI confirmation. **Dashboard:** Position, font size, and show/hide toggle. **Visuals:** Toggle EMA ribbon, VWAP, TP/SL lines, retest highlighting, label sizes and offsets. ## Alerts 1. **Long Entry Signal** — Fires when a bullish confluence entry triggers 2. **Short Entry Signal** — Fires when a bearish confluence entry triggers 3. **Any Entry Signal** — Fires on either long or short entry 4. **Strong Bull Bias** — Fires when bull confluence score crosses above 70% 5. **Strong Bear Bias** — Fires when bear confluence score crosses above 70% All alerts include {{ticker}}, {{close}}, and {{interval}} for dynamic notification messages. ## Limitations & Disclaimer - EMA crossover signals are inherently lagging — they work best in trending markets and may produce whipsaws during consolidation - The confluence score uses current-bar values; in fast markets, conditions can change quickly - The secondary timeframe RSI uses `request.security()` which may repaint on the current bar of that timeframe - TP/SL levels are visual guides — they do not execute trades automatically - Past performance of any signal system does not guarantee future results - This indicator is for educational and analytical purposes only — it is not financial advice. Always use proper risk management and do your own analysis before trading. ## Credits & Attribution This indicator is derived from **"Sniper Entry/Exit with SL&TP (open-source, TradingView). The following components originate from that script: - EMA crossover signal generation logic - ATR-based stop-loss and take-profit calculation - VWAP overlay - RSI and MACD display - Retest candle highlighting concept - Secondary timeframe RSI (originally hardcoded to 5m) Viprasol additions: 7-factor confluence scoring engine, bar-close confirmation, trailing stop to breakeven, configurable TP levels (1-5), configurable secondary timeframe, breakeven status labels, alert conditions, and dashboard.
مؤشر Pine Script®
من ‎viprasol‎
6
ATR Trend Strategy with Moving Average | Fixed TP/SL version📈 ## ATR Trend Strategy with Moving Average # Overview This strategy combines a **Moving Average trend filter** with an **ATR-based breakout channel** to identify directional market movements. It is designed for traders who prefer **systematic trend-following strategies with clearly defined risk management**. The script builds an adaptive channel around a selected Moving Average using **Average True Range (ATR)**. When price moves beyond the ATR band and the move is confirmed for a defined number of bars, a trend state is established. Trade entries can then occur either on the initial breakout or on a pullback to the Moving Average. The strategy also includes **fixed percentage Take Profit and Stop Loss levels**, allowing users to evaluate performance under consistent risk parameters. --- ⚙️ # Key Features • **Multiple Moving Average types** Supports EMA, SMA, WMA, Hull MA, VWMA, RMA, and TEMA. • **ATR-based dynamic channel** Uses ATR to create adaptive upper and lower boundaries around the Moving Average. • **Two entry methods** Users can choose between breakout entries or Moving Average pullback entries. • **Trend confirmation filter** Signals are confirmed only after a configurable number of bars remain beyond the ATR boundary. • **Built-in risk management** Includes fixed percentage Take Profit and Stop Loss levels. • **Trade visualization** Displays the TP/SL zone directly on the chart for each trade. • **Performance statistics panel** Shows key strategy metrics such as: * Total trades * Win rate * Profit factor * Net profit * Expectancy * Average R * Maximum drawdown --- 🧠 # Strategy Logic The strategy follows a simple **trend-following structure** : 1️⃣ A Moving Average defines the market's baseline trend. 2️⃣ An ATR multiplier builds a dynamic volatility channel around the Moving Average. 3️⃣ When price breaks above or below this channel and remains there for a specified number of bars, a trend is confirmed. 4️⃣ Entries can occur via: **Breakout Mode** * Long when price breaks above the upper ATR band. * Short when price breaks below the lower ATR band. **MA Cross Mode** * After a confirmed trend, entries occur on pullbacks that cross the Moving Average. 5️⃣ Risk is controlled using **fixed percentage Take Profit and Stop Loss levels**. --- ⚙️ # Inputs Moving Average * MA Type * MA Length * MA Source ATR Signal * ATR Type * ATR Length * ATR Multiplier Trend Confirmation * Number of confirmation bars * Confirmation price source (Close or High/Low) Entry & Risk Management * Entry method (Breakout or MA Cross) * Take Profit (%) * Stop Loss (%) --- 📊 ## Usage Notes This strategy is designed for **trend-following market conditions** and may perform best in environments with sustained directional movement. Users are encouraged to **experiment with different Moving Average types, ATR multipliers, and confirmation settings** to adapt the strategy to different markets and timeframes. --- ⚠️ ## Disclaimer This script is provided for **educational and research purposes only**. Past performance does not guarantee future results. ---
استراتيجية Pine Script®
من ‎lahonglam‎
1
Adaptive Volatility Matrix [JOAT]Adaptive Volatility Matrix Introduction The Adaptive Volatility Matrix (AVM) is an advanced open-source volatility regime classification indicator that combines Bollinger Band Width Percentile (BBWP), ATR percentile analysis, regime transition prediction, volatility clustering detection, and historical regime statistics to classify market conditions into distinct volatility regimes. This indicator helps traders adapt their strategies to current market conditions by systematically identifying when volatility is expanding, contracting, or transitioning between regimes. Unlike basic volatility indicators that simply plot ATR or Bollinger Bands, AVM employs a sophisticated dual-metric system that combines BBWP (measuring price range compression/expansion) with ATR percentile (measuring absolute volatility) to create a combined volatility score (0-100%). The indicator then classifies this score into five distinct regimes and predicts regime transitions through momentum analysis. Why This Indicator Exists This indicator addresses the challenge of adapting trading strategies to volatility conditions. Different market regimes require different approaches - mean reversion works in low volatility, breakout strategies work in expansion, and risk management becomes critical in extreme volatility. AVM systematically reveals: BBWP Analysis: Measures Bollinger Band width percentile to identify compression/expansion cycles ATR Percentile: Tracks normalized ATR percentile to measure absolute volatility levels Combined Volatility Score: Weighted average (60% BBWP, 40% ATR) for robust regime classification Regime Classification: Five distinct regimes (Extreme Expansion, Expansion, Normal, Contraction, Extreme Contraction) Transition Prediction: Momentum-based forecasting of next regime with probability Volatility Clustering: Detects sustained high/low volatility periods Historical Statistics: Tracks regime duration and frequency for context Each component provides unique intelligence. BBWP shows compression cycles, ATR shows absolute volatility, combined score provides robust classification, regime system categorizes conditions, transition prediction anticipates changes, clustering detects persistence, and statistics provide historical context. Core Components Explained 1. BBWP (Bollinger Band Width Percentile) Calculation BBWP measures where current Bollinger Band width ranks relative to historical width: f_calculate_bbwp(int length, int lookback) => float basis = ta.sma(close, length) float dev = ta.stdev(close, length) float bb_width = (dev * 2) / basis * 100 // Calculate percentile rank int count = 0 for i = 1 to lookback if bb_width > nz(bb_width ) count += 1 float bbwp = (count / lookback) * 100 BBWP ranges from 0-100%: - 0-20%: Extreme compression (volatility squeeze) - 20-40%: Contraction (below average volatility) - 40-60%: Normal (average volatility) - 60-80%: Expansion (above average volatility) - 80-100%: Extreme expansion (volatility breakout) 2. ATR Percentile Analysis ATR percentile measures where current normalized ATR ranks historically: f_atr_percentile(int period, int lookback) => float atr_val = ta.atr(period) float natr = close > 0 ? (atr_val / close) * 100 : 0.0 float percentile = ta.percentrank(natr, lookback) Normalized ATR (NATR) accounts for price level differences, making volatility comparable across different price ranges. Percentile ranking shows where current volatility sits in historical distribution. 3. Combined Volatility Score & Regime Classification The combined score weights BBWP more heavily than ATR percentile: float combined_score = (bbwp_value * 0.6) + (atr_percentile * 0.4) f_classify_regime(float bbwp_val, float atr_perc, float exp_th, float con_th, float ext_th) => string regime = "Normal" int regime_code = 0 if bbwp_val >= ext_th or atr_perc >= ext_th regime := "Extreme Expansion" regime_code := 4 else if bbwp_val >= exp_th or atr_perc >= exp_th regime := "Expansion" regime_code := 3 // Additional classifications... Five regime classifications: 1. Extreme Contraction (code 1): Both metrics <30%, volatility squeeze 2. Contraction (code 2): One metric <40%, below average volatility 3. Normal (code 0): Both metrics 40-60%, average conditions 4. Expansion (code 3): One metric >70%, above average volatility 5. Extreme Expansion (code 4): Both metrics >85%, volatility breakout 4. Regime Transition Prediction AVM predicts next regime through momentum analysis: float regime_momentum = combined_score - combined_score string momentum_direction = regime_momentum > 2 ? "Accelerating" : regime_momentum < -2 ? "Decelerating" : "Stable" string predicted_regime = regime_code == 4 and regime_momentum < -5 ? "→ Expansion" : regime_code == 3 and regime_momentum < -3 ? "→ Normal" : // Additional predictions... "Stable" float transition_prob = math.min(math.abs(regime_momentum) * 10, 100) Transition probability (0-100%) based on momentum magnitude. >50% probability triggers warning. 5. Volatility Clustering Detection Clustering identifies sustained high/low volatility periods: int cluster_lookback = 20 float cluster_threshold = 70.0 int high_vol_count = 0 for i = 0 to cluster_lookback - 1 if combined_score >= cluster_threshold high_vol_count += 1 float cluster_ratio = high_vol_count / cluster_lookback * 100 bool in_vol_cluster = cluster_ratio >= 60 // 60% of bars are high vol string cluster_strength = cluster_ratio >= 80 ? "Strong" : cluster_ratio >= 60 ? "Moderate" : cluster_ratio >= 40 ? "Weak" : "None" Clusters indicate persistent volatility conditions that tend to continue. 6. Historical Regime Statistics AVM tracks regime history for context: var array regime_history = array.new_int(0) var array regime_durations = array.new_int(0) if regime_changed array.push(regime_history, regime_code) array.push(regime_durations, bars_in_regime) // Calculate statistics float avg_expansion_duration = exp_sum / exp_cnt float avg_contraction_duration = con_sum / con_cnt float duration_ratio = bars_in_regime / avg_expansion_duration bool regime_extended = duration_ratio > 1.5 Statistics show if current regime is extended (>1.5x average duration), suggesting potential transition. Visual Elements Combined Score Line: Main plot (0-100%) with regime-based coloring ATR Percentile Overlay: Circles showing ATR percentile for comparison Histogram: Gradient-colored bars showing volatility score with regime colors Reference Lines: 70% (expansion), 50% (neutral), 30% (contraction), 85% (extreme) Background Zones: Regime-colored backgrounds (purple for expansion, yellow for contraction) Transition Warnings: ⚠ symbols when transition probability >50% BBWP Percentile Bands: 20th, 50th, 80th percentile circles for context Dashboard: Real-time metrics including regime, score, BBWP, ATR%, trend, duration, momentum, transition prediction, cluster status, duration ratio, historical stats Input Parameters BBWP Parameters: BBWP Length: Bollinger Band period (default: 13) BBWP Lookback: Historical comparison period (default: 252) ATR Analysis: ATR Period: ATR calculation period (default: 14) ATR Percentile Lookback: Historical ranking period (default: 100) Regime Classification: Expansion Threshold: Score for expansion regime (default: 70%) Contraction Threshold: Score for contraction regime (default: 30%) Extreme Threshold: Score for extreme regimes (default: 85%) Visualization: Show Regime Zones: Toggle background coloring Show Histogram: Toggle volatility histogram Show ATR Overlay: Toggle ATR percentile circles How to Use This Indicator Step 1: Identify Current Regime Check dashboard "Regime" row. Adjust strategy based on classification. Step 2: Monitor Combined Score Score >70% = expansion (use breakout strategies) Score <30% = contraction (use mean reversion) Score 40-60% = normal (use balanced approach) Step 3: Check Momentum Direction "Accelerating" = volatility increasing "Decelerating" = volatility decreasing "Stable" = no significant change Step 4: Watch for Transition Warnings ⚠ symbols indicate >50% probability of regime change. Prepare to adjust strategy. Step 5: Assess Cluster Status "Strong" or "Moderate" cluster = persistent conditions likely to continue Step 6: Consider Duration Ratio Ratio >1.5x = extended regime, higher probability of mean reversion Best Practices Use regime classification to select appropriate trading strategies Extreme contraction often precedes volatility breakouts - prepare for expansion Extreme expansion often mean-reverts - reduce position sizes Transition warnings provide early signal to adjust risk management Volatility clusters suggest persistence - don't fight the regime Extended regimes (>1.5x average) have higher reversal probability BBWP and ATR percentile divergence suggests regime uncertainty Historical statistics provide context for current regime duration Combine with directional indicators - AVM shows conditions, not direction Indicator Limitations Regime classification is backward-looking - transitions lag actual changes BBWP calculation is computationally intensive on large lookback periods Transition predictions are probabilistic, not deterministic Extreme regimes can persist longer than expected during major events Historical statistics require sufficient data (50+ regime changes) Clustering detection has fixed lookback - may miss longer-term patterns Combined score weighting (60/40) may not be optimal for all instruments Regime thresholds may need adjustment for different markets Technical Implementation Built with Pine Script v6 using: Custom BBWP calculation with percentile ranking ATR percentile analysis with normalized ATR Weighted combined score (60% BBWP, 40% ATR) Five-tier regime classification system Momentum-based transition prediction with probability Volatility clustering detection (20-bar lookback) Historical regime tracking with arrays (last 50 regimes) Duration ratio calculation vs historical averages BBWP percentile bands (20th, 50th, 80th) Adaptive background coloring based on regime and duration Comprehensive dashboard with 12 metrics The code is fully open-source and can be modified to suit individual trading styles. Originality Statement This indicator is original in its comprehensive volatility regime classification approach. While BBWP and ATR are established concepts, this indicator is justified because: It combines BBWP and ATR percentile into weighted combined score for robust classification The five-tier regime system provides granular volatility categorization Momentum-based transition prediction with probability quantification is unique Volatility clustering detection identifies persistent regime conditions Historical regime statistics provide context for current regime duration Duration ratio calculation identifies extended regimes with mean reversion potential BBWP percentile bands add additional context layers Adaptive background intensity based on regime stability Each component contributes unique information: BBWP shows compression cycles, ATR shows absolute volatility, combined score provides robust classification, regime system categorizes conditions, transition prediction anticipates changes, clustering detects persistence, statistics provide context, and duration ratio identifies extremes. The indicator's value lies in presenting these complementary perspectives simultaneously with unified regime framework. Disclaimer This indicator is provided for educational and informational purposes only. It is not financial advice. Regime classifications do not guarantee future volatility behavior. Trading involves substantial risk of loss. Past performance does not guarantee future results. Always use proper risk management and never risk more than you can afford to lose. -Made with passion by officialjackofalltrades
مؤشر Pine Script®
من ‎officialjackofalltrades‎
ATR Last-Bar Horizontal Stop LinesThis script draws ATR‑based horizontal levels only on the most recent candle, without plotting any historical lines. It uses TradingView’s line.new() engine instead of plot(), ensuring that: Only one horizontal line per direction (Short/Long) is shown The line is drawn only on the latest bar, never across previous bars The line automatically updates on every new candle Older lines are deleted instantly, avoiding chart clutter Lines extend to the right for full visibility, but do not stretch across the entire historical chart The script calculates ATR using the selected length and multiplier, then draws: A Short ATR line above the current candle (High + ATR × Multiplier) A Long ATR line below the current candle (Low − ATR × Multiplier) Both lines can be enabled or disabled individually. This tool is ideal for traders who want a clean chart with a single, dynamic ATR stop‑reference updated only for the current bar.
مؤشر Pine Script®
من ‎Andi303‎
Advanced UT-Trail System Pros [identityKa]Overview The Advanced UT-Trail System Pro is a comprehensive trend-following and trade management indicator. Built upon the foundation of Average True Range (ATR) trailing stops, this script introduces dynamic timeframe adaptation and Heikin-Ashi noise filtering to provide smoother, more reliable structural signals. It is designed to keep traders in prevailing trends longer while mathematically defining risk and automated profit targets. Core Calculations & Engine The indicator relies on a robust trailing stop logic driven by volatility: 1-) ATR Volatility Baseline: It calculates the ATR over a user-defined period (default 10). This value is multiplied by a "Base Key Value" to determine the strict distance the trailing stop will maintain from the price action. 2-) Heikin-Ashi Filtering: Traditional price action can cause premature stop-outs due to market noise. By default, this script pulls Heikin-Ashi close data (ticker.heikinashi) as the source (src) for the trailing calculation. This dramatically smooths the underlying data feed, preventing false wick-outs. 3-) Auto-Adaptive Sensitivity: To combat the lag inherent in macro trailing stops on lower timeframes, the script features an adaptive multiplier engine. If the trader switches to an intraday timeframe (≤ 60 minutes) or a scalp timeframe (≤ 15 minutes), the script mathematically reduces the Base Key Value multiplier (e.g., $a \times 0.6$), tightening the trailing stop dynamically to suit the faster price action. Dynamic Trade Management Upon the confirmation of a directional flip (the source crossing the trailing stop line), the script plots actionable data: Trailing Stop Line: A step-line visualizes the exact, non-repainting invalidation level. Auto Take-Profit Projection: Utilizing the exact ATR value at the moment of the signal, the script automatically projects and draws Target 1 (TP1) and Target 2 (TP2) dashed lines into the future. These targets are based on predefined ATR multipliers (default 1.5x and 3.0x), enforcing a mechanical risk-to-reward ratio. HUD Dashboard & AI State Tracker The integrated on-chart panel aggregates the current system data: Engine Mode: Displays whether the script is operating in SCALP, DAY, or SWING sensitivity mode based on the current chart. AI Suggestion: Evaluates the proximity of the current price to the trailing stop. LONG / SHORT: Triggered when the price is safely trending in the direction of the trailing stop. Dangerous: Triggered strictly when the current closing price enters a 0.2 ATR threshold of the trailing stop line. This mathematical condition acts as a warning that the trend is actively being tested and a reversal may be imminent. How to Use It Traders should utilize the printed BUY/SELL labels as macro directional bias. The trailing step-line serves as an objective, mechanical Stop-Loss level. When entering a position, traders can use the automatically projected TP1 and TP2 lines to scale out of their positions incrementally. If the AI Suggestion shifts to "Dangerous", it is a mechanical cue to protect capital, tighten stops manually, or avoid adding to existing positions.
مؤشر Pine Script®
من ‎IdentityKa‎
Aura Mean Reversion Envelopes [Pineify]Aura Mean Reversion Envelopes The Aura Mean Reversion Envelopes is a volatility-adaptive envelope indicator designed to identify high-probability mean reversion trade setups. It combines a Hull Moving Average (HMA) baseline with ATR-based dynamic envelopes to detect when price has reached statistically extreme levels and is likely to revert back toward its fair value. Unlike static channel indicators, this tool continuously adapts its bands to current market volatility, making it effective across different instruments and timeframes. Key Features Hull Moving Average (HMA) as the central mean — provides a smooth, low-lag baseline that closely tracks the "fair value" of price. ATR-based dynamic envelopes — four bands (inner and outer, upper and lower) that automatically expand and contract with market volatility. Wick rejection reversal signals — BUY and SELL markers triggered only when price pierces the exhaustion zone but closes back inside with a confirming candlestick pattern. Visual cloud zones — color-filled regions between bands clearly delineate overbought, oversold, and neutral mean-reversion corridors. Extreme candle coloring — optional bar coloring highlights candles closing beyond the inner bands for at-a-glance identification of stretched price action. Built-in alert conditions — configurable alerts for both bullish and bearish reversal signals so you never miss a setup. How It Works The indicator is built on the principle of mean reversion — the statistical tendency for price to return to its average after moving to an extreme. The core calculation pipeline is: A Hull Moving Average (HMA) of the closing price over a user-defined period (default: 34) is computed. HMA was chosen over SMA or EMA because it dramatically reduces lag while maintaining smoothness, giving a more accurate representation of the current mean. Market volatility is measured using the Average True Range (ATR) over a separate lookback period (default: 21). ATR captures the true range of each bar — including gaps — providing a robust, adaptive volatility metric. Four envelope bands are constructed symmetrically around the HMA baseline by adding and subtracting ATR multiplied by two configurable multipliers: an inner multiplier (default: 1.618, the golden ratio) and an outer multiplier (default: 3.0). The inner bands define the boundary of normal price oscillation, while the outer bands mark exhaustion zones where price has deviated significantly. Reversal signals are generated using a wick rejection pattern: a bullish signal fires when the bar's low pierces below the lower outer band, but the candle closes bullishly (close > open) and above the outer band. This pattern indicates that sellers pushed price to an extreme but were overwhelmed by buyers. The bearish signal uses the mirror logic on the upper side. Trading Ideas and Insights Mean reversion strategies work best in ranging and oscillating markets. Here are some practical ways to use this indicator: Fade the extremes: When a BUY or SELL signal appears at the outer exhaustion band, consider entering a position targeting the central HMA mean line as your take-profit level. The mean line acts as a natural magnet for price. Use the inner bands as a filter: If price is between the inner bands and the mean, the market is in "normal" territory — avoid counter-trend entries. Wait for price to reach the outer bands before looking for reversal setups. Combine with trend context: On higher timeframes, determine the dominant trend direction. Then on your trading timeframe, only take signals that align with the higher-timeframe trend (e.g., only BUY signals in an uptrend) for higher win rates. Watch for candle coloring clusters: Multiple consecutive colored candles beyond the inner band suggest sustained momentum — a reversal signal after such a cluster can be particularly powerful. How Multiple Indicators Work Together This indicator integrates two distinct technical concepts into a unified framework: Hull Moving Average (trend/mean tracking) — The HMA serves as the anchor point, representing the current equilibrium price. Its low-lag property ensures the mean line stays close to actual price action rather than trailing behind, which is critical for accurate envelope placement. Average True Range (volatility measurement) — ATR dynamically sizes the envelope bands. During high-volatility periods, the bands widen to avoid false signals; during low-volatility periods, they tighten to capture smaller but still meaningful deviations. The synergy between these two components is what makes the indicator adaptive: the HMA tracks where price should be, while the ATR determines how far is too far. Together, they create a self-adjusting framework that does not require manual recalibration across different market conditions. The reversal signal logic adds a third layer — candlestick pattern confirmation — by requiring a wick rejection at the outer band. This prevents signals from firing during strong breakouts where price legitimately moves beyond the envelope. Unique Aspects HMA over EMA/SMA: Most envelope indicators use simple or exponential moving averages, which introduce significant lag. The Hull Moving Average virtually eliminates this lag, resulting in more accurately centered envelopes. Dual-layer envelope design: The inner and outer band structure creates distinct zones (normal, extended, exhaustion) rather than a single binary overbought/oversold threshold, giving traders more nuanced context. Golden ratio default: The inner band multiplier defaults to 1.618 (the Fibonacci golden ratio), a mathematically significant threshold that aligns with natural price clustering behavior observed across many markets. Wick rejection confirmation: Signals require both a pierce beyond the outer band AND a confirming close back inside with a bullish/bearish candle body, filtering out many false signals that plague simpler band-touch systems. How to Use Apply the indicator to your chart. It overlays directly on the price chart with the HMA mean line, four envelope bands, and color-filled zones. Watch for BUY triangles below bars at the lower outer band and SELL triangles above bars at the upper outer band. These are the primary reversal signals. Use the colored candles as an early warning — when candles start coloring, price is in the extended zone and approaching potential reversal territory. Set alerts via the built-in alert conditions ("Bullish Mean Reversion" and "Bearish Mean Reversion") to receive notifications when signals fire. Target the central HMA mean line for take-profit on reversal trades, or use the inner band on the opposite side for more aggressive targets. Customization Mean Tracking Period (default: 34): Controls the HMA lookback. Lower values make the mean more responsive to recent price; higher values produce a smoother, slower-moving baseline. Adjust based on your trading timeframe. Volatility (ATR) Period (default: 21): Controls the ATR lookback for band sizing. Shorter periods make bands more reactive to recent volatility spikes; longer periods smooth out the band width. Inner Band Multiplier (default: 1.618): Defines the boundary between normal and extended price zones. Increase for wider normal zones (fewer colored candles); decrease for tighter zones. Outer Band Multiplier (default: 3.0): Defines the exhaustion zone threshold. Higher values produce fewer but more extreme signals; lower values generate more frequent signals. Color Candles at Extremes: Toggle on/off the candle coloring feature for candles closing beyond the inner bands. All colors (bullish, bearish, mean line) are fully customizable via the Aesthetics & Colors settings group. Conclusion The Aura Mean Reversion Envelopes combines the precision of the Hull Moving Average with ATR-adaptive volatility bands and candlestick-confirmed reversal signals to create a comprehensive mean reversion trading tool. Its dual-layer envelope design provides clear visual zones for identifying when price is normal, extended, or at exhaustion — helping traders time entries at statistically favorable levels where price is most likely to revert toward its mean. Whether you trade forex, crypto, stocks, or futures, this indicator adapts to your market's volatility and provides actionable signals with built-in confirmation logic.
مؤشر Pine Script®
من ‎Pineify‎
Trend Sniper v2.5 [Jamallo](2025) Intro Trend Sniper v2.5 is built around a novel-unique core construction — the Butterworth Stop : a ratcheting trailing stop anchored to a 2-Pole Butterworth Super Smoother and dynamically sized by Parkinson Volatility. While each algorithm used is individually well-documented, this specific combination is rare and not found in standard indicator libraries — most Butterworth implementations are simply plotted as trend lines, not used as the structural anchor of a volatility-adaptive stop mechanism. Break down: 2-Pole Butterworth Super Smoother (Core Trend Line) (smoothed price) The backbone of the indicator is a 2-Pole Butterworth Super Smoother, a concept brought into trading by engineer and author John Ehlers, first published in his 2004 book Cybernetic Analysis for Stocks and Futures In this indicator: The Butterworth filter runs on close with a user-defined period (default 20) and produces bw_trend — a clean, lag-minimized version of price. This smoothed value is not plotted directly. Instead, it acts as the anchor point for the trailing stop. The stop is placed at bw_trend ± stop_dist , meaning the stop hugs the filtered trend rather than raw price, making it far less susceptible to wick noise and erratic bars. Without this pre-filtering step, the trailing stop would oscillate erratically on volatile bars. Parkinson Volatility (Sizes the Stop Distance) "Developed by physicist Michael Parkinson in 1980, it estimates volatility using the natural logarithm of the high-to-low ratio each period, capturing intraday range rather than just close-to-close movement." In this indicator: Parkinson Volatility is calculated over a rolling window (default 50 bars) and multiplied by stop_mult (default 1.2) to produce stop_dist . When markets are volatile, stop_dist expands and the stop gives price more room. When markets are quiet, it contracts and the stop tightens. Butterworth Stop State Machine (The Main Line You Watch) This is the primary plotted line, It's a classic ratcheting trailing stop built on top of outputs from steps 1 and 2. In this indicator: The logic is a simple state machine with two modes — uptrend and downtrend. In an uptrend, the stop only moves up (never down), tracking at bw_trend − stop_dist . In a downtrend, it only moves down, tracking at bw_trend + stop_dist . When price closes on the wrong side of the stop, the state flips and the stop resets on the other side of the trend line. Because both the anchor bw_trend and the buffer stop_dist are noise-filtered and volatility-adjusted, the BW Stop flips far less often than a raw price-based trailing stop would, keeping you in trends longer. Chande Momentum Oscillator + Deadband (Colors the BW Stop Line) "The CMO measures momentum by calculating the difference between the sum of gains and the sum of losses over a specified period, dividing by their total to produce a normalized scale from -100 to +100 that accounts for both up and down days simultaneously." In this indicator: CMO is calculated on bw_stop itself (not raw price), over 14 bars by default. A deadband of ±10 is applied — the line only turns bull-colored when CMO exceeds +10, and bear-colored when it drops below −10. It does not change color in between. KAMA Midpoint (The Dynamic Midline and Fill Zone Anchor) "Introduced by Perry Kaufman in 1995, KAMA dynamically adjusts its smoothing based on the relative efficiency of price movement". In this indicator: Rather than applying KAMA to price directly, it's applied to the midpoint between the BW Stop and the Slow SuperTrend. This midpoint is a computed halfway value between the two lines. KAMA then smooths that midpoint adaptively, producing `kama_mid`. The fill colors you see on the chart are drawn between kama_mid and bw_stop — not between price and anything else. Dual SuperTrend (Signals and Fill State Logic) "Created by Olivier Seban, SuperTrend combines ATR-based volatility with trend detection into a single line that repositions dynamically as price confirms or breaks the current trend direction." In this indicator: Two SuperTrend lines run simultaneously. The Slow ST (9× ATR) is the macro trend reference. The Fast ST (6× ATR) is never plotted at full size — it's compressed halfway toward the BW Stop and shown as orange circles fast_shortened Putting It All Together The flow through the indicator is linear: Butterworth smooths price → Parkinson sizes the stop → the state machine builds the stop line → CMO colors it → KAMA anchors the midline fill → the dual SuperTrend fires signals and shades conviction. END Every component feeds the next, meaning the final signals and visuals are the product of five sequential filters rather than any single calculation — which is what gives the indicator its resistance to false signals in noisy market conditions.
مؤشر Pine Script®
من ‎Jamallo22‎
6
Trend filter [Jamallo](2025) This is a trend qualification and filtering tool. Breakdown: Signal Line — Vervoort ATR Trailing Stop The signal line is an implementation of the ATR Trailing Stop developed by Sylvain Vervoort, first published in Technical Analysis of Stocks & Commodities, Volume 27, Issue 6 (June 2009), in his article "Average True Range Trailing Stops" . The stop uses a modified ATR calculated on the average price (O+H+L+C)/4 rather than the plain close. Baseline — Kalman Filter The baseline is derived from the Kalman Filter, a recursive algorithm developed in 1960 by Rudolf E. Kálmán, a Hungarian-American engineer and mathematician. Originally developed for aerospace applications in the early 1960s — including guidance of the Apollo spacecraft. In this indicator, the Kalman Filter acts as a smooth, low-lag trend estimate. Rather than applying fixed weights to historical data like conventional moving averages, it dynamically adjusts its trust between the predicted trend and observed prices. Bands — Volatility Channels Two pairs of bands (inner and outer) are built around the Kalman baseline using a 200-bar WMA.
مؤشر Pine Script®
من ‎Jamallo22‎
J - Trend Sniper v2(2024) A trend-following indicator that combines an ATR trailing stop with a smoothed price line to detect trend shifts and generate long/short signals. Calculates a slow ATR trailing stop (main trend boundary) and a fast ATR trailing stop, then plots a midpoint "Fast Line" between the two A smoothed signal line (a) tracks price using a volatility-weighted EMA — more reactive during high-volatility candles, smoother during low-volatility ones Long signal fires when the signal line crosses above the ATR trailing stop; Short when it crosses below
مؤشر Pine Script®
من ‎Jamallo22‎
J - ATR Trend Channel(2022) A trend-following overlay that combines an ATR-based trailing stop with a smoothed price average to identify trend direction and generate signals. The trailing stop dynamically trails price using ATR volatility bands, tightening in trending conditions The smoothed line (a) blends open/close/high/low into a volatility-weighted average, acting as a trend filter Best used on trending markets to ride momentum and spot early reversals.
مؤشر Pine Script®
من ‎Jamallo22‎
4
LOWESS Reversal & Continuation [UAlgo]LOWESS Reversal & Continuation is a trend sensitive signal indicator built around a local LOWESS style smoothing engine that adapts to both price structure and volatility. Its core objective is to separate meaningful directional shifts from routine market noise by combining smoothed trend estimation, ATR normalized slope analysis, acceleration filtering, and disciplined signal gating. Instead of relying on a conventional moving average crossover model, the script fits a locally weighted regression over a rolling window of recent bars. This produces a smoother and more context aware estimate of price direction, while still reacting fast enough to identify emerging reversals and pullback continuation opportunities. Because the estimate is local and weighted, recent bars have greater influence than distant bars, which helps the line remain relevant to current market conditions. The indicator classifies signals into two practical categories. Reversal signals aim to identify transitions where directional pressure flips from negative to positive, or from positive to negative. Continuation signals aim to identify pullback resumption behavior inside an already established directional regime. This makes the script suitable for traders who want a single tool that can highlight both early trend change candidates and trend following re entry points. To improve robustness, the script also supports optional robust weighting passes. These passes reduce the influence of outlier bars on the LOWESS fit, which is especially useful during abnormal spikes, illiquid conditions, or isolated volatility shocks. In addition, all slope readings are normalized by ATR, allowing the trend filter to scale more consistently across instruments, timeframes, and volatility regimes. From a workflow perspective, the script is designed for clean chart usage. It colors the LOWESS line according to directional bias, draws an adaptive ATR based band around the curve, supports optional signal labels, limits on chart label clutter through an internal object manager, and provides alert conditions for all signal classes. The result is a visually compact but analytically rich framework for tracking trend reversals and continuation setups in real time. 🔹 Features 🔸 LOWESS Style Local Trend Estimation The heart of the script is a locally weighted linear regression model applied over a rolling lookback window. Each bar inside the window receives a distance based weight, meaning bars closer to the current bar have a larger impact on the estimate. This produces a smooth trend line that is more adaptive than many standard moving average techniques and better suited for identifying subtle turning points. 🔸 Optional Robust Regression Passes The indicator can apply additional robust weighting iterations after the initial fit. Residuals are measured relative to the first regression pass, and bars with unusually large residuals receive progressively lower influence in later passes. This reduces distortion from extreme candles and helps the LOWESS curve remain stable during irregular price events. 🔸 ATR Normalized Slope Filter The script does not use raw slope in isolation. Instead, the LOWESS slope is divided by ATR, creating a volatility adjusted slope metric. This makes the directional threshold more portable across markets and timeframes. A slope that may be meaningful on a slow instrument can be very different on a high volatility asset, so ATR normalization creates a more balanced regime filter. 🔸 Reversal Signal Detection Bullish and bearish reversal signals are triggered when the ATR normalized slope crosses the zero line and is confirmed by directional acceleration and price location relative to the LOWESS line. In other words, the script looks for a meaningful change in smoothed directional pressure, not simply a visual bend in the curve. This makes reversal signals more selective and better aligned with structural momentum shifts. 🔸 Continuation Signal Detection Continuation logic is designed to capture trend resumption after a pullback. The script first requires an established directional regime, then checks whether price recently interacted with the LOWESS line, and finally waits for price to reclaim the trend direction with positive confirming acceleration. This helps distinguish genuine continuation behavior from random sideways oscillation around the curve. 🔸 Pullback Validation Window A dedicated pullback lookback parameter ensures that continuation signals only occur when price has interacted with the LOWESS line within a recent number of bars. This prevents stale continuation triggers and keeps the setup focused on recent retracement behavior rather than distant historical interactions. 🔸 Close Confirmation Option Signals can be gated so they only become valid after bar close. This is useful for traders who want to avoid intrabar flicker and premature triggers on live candles. When disabled, the script can respond more aggressively in real time, which may suit faster execution styles. 🔸 Signal Cooldown Logic To reduce repetitive clustering, the indicator tracks the last occurrence of each signal type and imposes a cooldown period before another signal of the same class can be printed. Separate cooldown tracking is maintained for bullish reversals, bearish reversals, bullish continuations, and bearish continuations. 🔸 Adaptive ATR Band An optional ATR based band can be plotted around the LOWESS line. This band provides a visual sense of dynamic range around the smoothed path and can help contextualize whether price is moving in a relatively stretched or balanced position around the trend estimate. 🔸 Directional Visual Coloring The LOWESS curve changes color according to directional bias derived from the ATR normalized slope. This gives the user an immediate visual read on whether the smoothed trend pressure is currently positive, negative, or unavailable due to insufficient historical data. 🔸 Lightweight Label Management When signal labels are enabled, the script uses an internal label book to store and manage plotted objects. Older labels are automatically deleted once the configured maximum is exceeded, helping keep the chart readable and preventing uncontrolled label buildup. 🔸 Full Alert Support Alert conditions are included for all four event classes: Bullish LOWESS Reversal Bearish LOWESS Reversal Bullish LOWESS Continuation Bearish LOWESS Continuation This allows the script to be used not only as a visual analysis tool, but also as an event driven signal framework for scanning and real time notification workflows. 🔹 Calculations 1) Rolling LOWESS Window Construction For every bar, the script loads the most recent length values of the selected source into an internal rolling window. This window becomes the data sample used for the local regression fit. method loadWindow(LowessEngine this, float seriesValue) => for i = 0 to this.length - 1 array.set(this.y, i, seriesValue ) Interpretation: The regression is always fit on the latest rolling block of data. The rightmost point in the window corresponds to the current estimation point. This makes the smoothing local rather than global. 2) Distance Based LOWESS Weights The script uses a tricube kernel to assign weights based on each point’s distance from the current bar inside the regression window. Bars nearer to the most recent observation receive a larger weight, while distant bars contribute less. method buildDistanceWeights(LowessEngine this, int spanBars) => int x0 = this.length - 1 float bandwidth = math.max(spanBars, 1) for i = 0 to this.length - 1 float u = math.abs(i - x0) / bandwidth float w = u < 1 ? math.pow(1 - math.pow(u, 3), 3) : 0.0 array.set(this.baseW, i, w) Interpretation of the conditions: x0 is the current evaluation point inside the rolling window. u is normalized distance from each historical point to the current point. The tricube weight decays smoothly as distance increases. Bars outside the effective span receive zero weight. This is what gives the LOWESS fit its local character and helps it stay focused on recent structure. 3) Weighted Local Linear Regression After weights are built, the script solves a weighted linear regression over the local window. The output is a local intercept and local slope. The final LOWESS estimate is the fitted value at the most recent point in the sample. method solveWeightedLinear(LowessEngine this, array weights) => float s0 = 0.0 float s1 = 0.0 float s2 = 0.0 float t0 = 0.0 float t1 = 0.0 for i = 0 to this.length - 1 float w = array.get(weights, i) float x = array.get(this.x, i) float y = array.get(this.y, i) s0 += w s1 += w * x s2 += w * x * x t0 += w * y t1 += w * x * y float den = s0 * s2 - s1 * s1 if s0 <= 1e-10 or math.abs(den) <= 1e-10 this.slope := 0.0 this.intercept := array.get(this.y, this.length - 1) else this.slope := (s0 * t1 - s1 * t0) / den this.intercept := (t0 - this.slope * s1) / s0 float x0 = this.length - 1 this.yhat := this.intercept + this.slope * x0 Interpretation: this.slope measures the local directional gradient of the LOWESS fit. this.yhat is the current LOWESS value plotted on the chart. If the weighted regression becomes numerically unstable, the script falls back to a flat slope and uses the latest source value as intercept. 4) Robust Reweighting Passes To reduce the impact of outliers, the script can run additional robust passes after the initial fit. It first calculates the absolute residual of each point relative to the fitted line, then computes a median based scale estimate, and finally applies a bisquare style robust weighting function. method updateRobustWeights(LowessEngine this) => for i = 0 to this.length - 1 float xi = array.get(this.x, i) float yi = array.get(this.y, i) float fit = this.intercept + this.slope * xi array.set(this.residualAbs, i, math.abs(yi - fit)) float med = this.residualAbs.median() float scale = med * 6.0 if na(scale) or scale <= 1e-10 for i = 0 to this.length - 1 array.set(this.robustW, i, 1.0) else for i = 0 to this.length - 1 float u = array.get(this.residualAbs, i) / scale float rw = u < 1 ? math.pow(1 - math.pow(u, 2), 2) : 0.0 array.set(this.robustW, i, rw) Interpretation: Large residual bars are treated as less trustworthy observations. The median residual acts as a robust scale anchor. Higher residuals receive smaller robust weights in subsequent fits. This improves stability during abnormal spikes and irregular candles. 5) ATR Normalized Slope and Acceleration Once the LOWESS fit is complete, the script converts raw slope into a volatility aware slope by dividing it by ATR. It also computes a first-difference style acceleration term to measure whether directional pressure is strengthening or weakening. float slopeAtr = not na(slope) and atr > 0 ? slope / atr : na float accelAtr = slopeAtr - nz(slopeAtr ) Interpretation: slopeAtr expresses trend slope in ATR units. accelAtr measures change in normalized slope from one bar to the next. Positive acceleration supports bullish developments. Negative acceleration supports bearish developments. This combination helps the script distinguish a genuine regime shift from a weak or decaying slope condition. 6) Directional Regime Classification The script uses a user defined ATR normalized threshold to determine whether the current smoothed state qualifies as a bullish or bearish directional regime. bool upRegime = not na(slopeAtr) and slopeAtr > slopeThreshold bool downRegime = not na(slopeAtr) and slopeAtr < -slopeThreshold Interpretation: A positive but very small slope is not automatically treated as a valid uptrend. A negative but very small slope is not automatically treated as a valid downtrend. The threshold acts as a noise filter that requires the trend estimate to have enough magnitude before continuation logic becomes eligible. 7) Pullback Detection Relative to LOWESS Continuation signals depend on recent interaction with the LOWESS line. The script checks how many bars have passed since price moved through the LOWESS curve in the opposite direction of the active regime. int bullPbBars = int(nz(ta.barssince(low < lowess), 100000)) int bearPbBars = int(nz(ta.barssince(high > lowess), 100000)) bool bullPullbackRecent = bullPbBars <= pullbackLookback bool bearPullbackRecent = bearPbBars <= pullbackLookback Interpretation: In a bullish regime, price must have recently dipped below the LOWESS line to qualify as a pullback. In a bearish regime, price must have recently pushed above the LOWESS line to qualify as a pullback. The pullbackLookback parameter controls how recent that interaction must be. 8) Reversal Signal Logic Bullish and bearish reversal signals are built from zero line slope crossings, directional acceleration, and price confirmation relative to the LOWESS curve. bool slopeCrossUp = ta.crossover(slopeAtr, 0) bool slopeCrossDown = ta.crossunder(slopeAtr, 0) bool bullRevRaw = enoughBars and slopeCrossUp and accelAtr > 0 and close > lowess bool bearRevRaw = enoughBars and slopeCrossDown and accelAtr < 0 and close < lowess Interpretation of the bullish reversal conditions: slopeCrossUp means the normalized LOWESS slope has crossed from negative to positive. accelAtr > 0 means the slope is improving, not merely touching zero. close > lowess confirms that price is positioned above the smoothed trend estimate. Interpretation of the bearish reversal conditions: slopeCrossDown means the normalized LOWESS slope has crossed from positive to negative. accelAtr < 0 confirms weakening trend pressure. close < lowess confirms price is positioned below the LOWESS line. This makes reversal signals more selective than a simple moving average crossover style event. 9) Continuation Signal Logic Continuation signals are only allowed when a directional regime already exists, a recent pullback has occurred, price crosses back through the LOWESS line in trend direction, and acceleration confirms that the move is regaining strength. bool priceCrossUp = ta.crossover(close, lowess) bool priceCrossDown = ta.crossunder(close, lowess) bool bullContRaw = enoughBars and upRegime and bullPullbackRecent and priceCrossUp and accelAtr > 0 and not bullRevRaw bool bearContRaw = enoughBars and downRegime and bearPullbackRecent and priceCrossDown and accelAtr < 0 and not bearRevRaw Interpretation of the bullish continuation conditions: The LOWESS slope must already define an uptrend regime. Price must have recently pulled back below the LOWESS line. Price must cross back above the LOWESS line. Acceleration must be positive. A reversal signal takes priority, so continuation does not print if the same bar qualifies as a bullish reversal. Interpretation of the bearish continuation conditions is the exact inverse. 10) Close Confirmation and Cooldown Control The final signal is gated by an optional bar close confirmation and a per-signal cooldown filter. bool gate = confirmClose ? barstate.isconfirmed : true bool bullRev = gate and bullRevRaw and canBullRev(signalState, cooldownBars) bool bearRev = gate and bearRevRaw and canBearRev(signalState, cooldownBars) bool bullCont = gate and bullContRaw and canBullCont(signalState, cooldownBars) bool bearCont = gate and bearContRaw and canBearCont(signalState, cooldownBars) Interpretation: When close confirmation is enabled, signals only become valid after the candle is closed. Cooldown logic prevents repeated printing of the same signal class within a short number of bars. This reduces visual clutter and avoids excessive re-triggering during choppy conditions. 11) Adaptive Band Construction The script can draw an ATR-based envelope around the LOWESS line to provide volatility context. float upperBand = showBand and not na(lowess) ? lowess + atr * bandAtrMult : na float lowerBand = showBand and not na(lowess) ? lowess - atr * bandAtrMult : na Interpretation: The band expands and contracts with ATR. This creates a dynamic visual frame around the LOWESS estimate. It is not a signal by itself, but it helps contextualize the distance between current price and the smoothed trend path. 12) Visual Output and Alerts The LOWESS line changes color according to slope direction, optional labels mark reversal and continuation events, and alert conditions are available for all four signal types. alertcondition(bullRev, "Bullish LOWESS Reversal", "Bullish LOWESS reversal on {{ticker}}") alertcondition(bearRev, "Bearish LOWESS Reversal", "Bearish LOWESS reversal on {{ticker}}") alertcondition(bullCont, "Bullish LOWESS Continuation", "Bullish LOWESS continuation on {{ticker}}") alertcondition(bearCont, "Bearish LOWESS Continuation", "Bearish LOWESS continuation on {{ticker}}") In practical terms, this means the indicator can serve both as a visual discretionary analysis tool and as an alert driven framework for identifying smoothed trend reversals and pullback continuation opportunities with a volatility aware filter structure.
مؤشر Pine Script®
من ‎UAlgo‎
PnL Ruler [NLR]Know your dollar targets at a glance — no mental math. PnL Ruler overlays a dollar-value scale on your chart, anchored to an ATR-based trailing trend line. The trend line marks your ideal entry zone ($0 reference) — to plan high-quality entry. Labeled levels above and below show exactly where each profit and loss target sits in price terms. Having dollar targets defined before the trade removes the guesswork and the emotional pressure of deciding in the moment. Futures-aware: automatically detects tick value per instrument, so dollar levels are accurate out of the box on ES, NQ, MES, MNQ, CL, GC, and others. Also plots the extreme close of the current trend leg — the highest close in an uptrend, lowest in a downtrend — as a visual reference for how far price has extended. Settings ATR Length / Trend Factor / Error Margin — controls the ATR-based trailing trend line Contracts — scales all PnL levels by your position size PnL Step ($) — dollar increment between levels (e.g. $200 → shows ±$200, ±$400…) Levels Each Side — how many levels above and below zero (max 20) Lookback Bars — how far left the lines extend into past price action EMA Length / HMA Length — period for each moving average. EMA follows trend direction color (dashed); HMA uses blue/orange based on its own slope Credits Trend line based on the Follow Line Indicator by Dreadblitz.
مؤشر Pine Script®
من ‎NonLinearRookie‎
52-Week High/Low with Momentum Filter & ATR StopThis indicator for swing traders combines key yearly price levels with a hybrid moving average system and volatility-based risk markers. It identifies the 52-week high and low, providing the exact percentage distance from current prices to highlight potential breakouts or overextended moves. Key Features Yearly Range Labels: Automatically plots the 52-week high and low with labels showing the price distance from these extremes. Hybrid Trend System: Uses a combination of EMA 21 and EMA 50 to capture short-to-medium term momentum, while the SMA 200 provides the standard institutional trend filter. Volatility Stop (1.5x ATR): Features a circle-style trailing line set at 1.5 times the Average True Range. This provides a technical floor designed to filter out market noise for tighter swing trade management. How to Use The 52-week labels pinpoint high-probability breakout or reversal zones. Strong momentum is confirmed when the price holds above the EMA 21/50, while the SMA 200 ensures you are trading in the direction of the long-term trend. The 1.5x ATR circles offer an objective exit point to protect capital during pullbacks.
مؤشر Pine Script®
من ‎kms695‎
Guac's Daily ATR Box (Remaining > Locked w/ Extensions)This script is an intraday visualization tool that uses the Average True Range (ATR) from the Daily timeframe to show, in real time, how much of the day’s typical range has been “used” and when the day’s move has fully consumed that range. Once the daily ATR is “filled,” the script locks that ATR zone for the rest of the day and highlights any additional movement beyond it (ATR extensions). --- What the script does 1) Pulls Daily ATR and anchors it for intraday use 2) Tracks the day’s current high and low intraday * As each intraday bar prints, it updates: - dayHigh = the highest price so far today - dayLow = the lowest price so far today 3) Shows a “Remaining ATR” zone that adapts in real time (pre-fill) * Before the day has used a full ATR of range, the script draws a primary box (Segment 0) that represents the remaining potential movement inside the day’s ATR “budget.” * Conceptually throughout the day the box “shrinks” to visualize how much range is left: - As new highs are made, some of the “budget” is spent upward. - As new lows are made, some of the “budget” is spent downward. 4) Detects when the day’s range has “filled” ATR and locks the zone * The script considers ATR “filled” when: - (dayHigh − dayLow) ≥ Daily ATR * At the first moment this happens: - The script locks Segment 0 into a static ATR zone for the remainder of the day. - It also records whether the zone was locked from the day’s low upward or from the day’s high downward (shown as LOW-ANCHORED / HIGH-ANCHORED). 5) Highlights extensions beyond the locked ATR zone (post-fill) * After the ATR zone is locked: - Any move beyond that locked zone triggers “extension” boxes. - Extensions are shown as additional ATR-sized blocks above or below the locked zone. * Extension colors escalate by distance: - ATR×1+ extension (first block outside) = yellow - ATR×2+ extension (second block) = orange - ATR×3+ extension (third block and beyond) = red This makes it visually obvious when price is no longer moving within a “normal” daily range and is now in volatility expansion / extension territory. 6) HUD status display * A small HUD table shows: - The ticker and Daily ATR value - Whether the ATR range is still LIVE (adapting with remaining dollars) or Range Filled & Locked
مؤشر Pine Script®
من ‎ExtraGuacAM‎