התחל

ניתוח נרות

Reversal Candlestick Patterns reinforced with Slow StochasticStandalone candlestick patterns are often subjective noise. This script transforms visual price action into strict mathematical algorithms, filtering reversals through momentum exhaustion to provide objective, data-backed execution triggers. Core Mechanics Algorithmic Price Action: Hardcoded geometric proportions for Engulfing lines, Partial Penetrations (Piercing/Dark Cloud), Umbrellas (Hammers/Shooting Stars), and Dojis. No approximations. Momentum Exhaustion: Signals strictly fire only when the smoothed 10-6-3 Slow Stochastic is in extreme zones: < 25% (BULL) or > 75% (BEAR). Macro-Trend Filter: Optional Multi-Timeframe EMA to ensure signals align with the dominant structural flow. Strategic Execution ⚠️ WARNING: USE ONLY AT KEY LEVELS. This tool is designed as a micro-sentiment execution trigger, not a standalone system. For high-probability asymmetry, wait for price to test a verified structural defence area. When price interacts with that precise geometry and this indicator simultaneously prints a confirmed signal, you have an objective, mathematically validated setup.
אינדיקטור Pine Script®
מאת ‎Lorjan500‎
6
Volumetric Inverse Fair Value Gap (VIFVG) [UAlgo]Volumetric Inverse Fair Value Gap is an imbalance analysis tool that tracks the full lifecycle of a Fair Value Gap and then focuses on what happens after that gap fails. Instead of stopping at the initial gap detection, the script stores qualifying bullish and bearish FVGs, waits for price to invalidate them from the opposite side, and then converts those failed imbalances into active Inverse Fair Value Gaps. The main idea is rooted in role reversal. A bullish Fair Value Gap may initially represent an area of inefficiency below price, but if price later trades through that gap in the opposite direction, the same zone can flip into a bearish inverse area. The same logic applies in reverse for bearish gaps that later fail to the upside. This script automates that transition and keeps the resulting IFVG visible on the chart as long as it remains active. What makes this version more distinctive is the volumetric overlay inside the inverse zone. Once an IFVG is created, the script attaches three internal metrics to it. The first estimates bullish participation, the second estimates bearish participation, and the third measures relative volume strength using percentile rank. These values are then displayed inside the box as horizontal progress bars, turning the IFVG into both a structural level and a compact participation summary. The indicator also supports a ghost box that preserves the original FVG location from the moment it was created until the moment it became inverse. This gives the user a clearer narrative of how the imbalance formed and where the role reversal occurred. Combined with the active box, the result is a visually informative workflow for traders who want to study failed imbalances, structure flips, and how strong the inversion candle was when the role change happened. In practical use, the script can help identify zones where a former inefficiency has turned into a reaction area, while also showing whether the inversion event carried more bullish pressure, more bearish pressure, or unusually strong participation relative to recent volume history. 🔹 Features 🔸 Fair Value Gap Detection With ATR Filtering The script first detects classic three candle FVG structures, then filters them using a minimum gap size expressed in ATR units. This helps reduce noise and removes smaller gaps that may be less meaningful. 🔸 Strict and Non Strict Detection Modes Strict mode requires actual wick separation between the first and third candle. Non strict mode allows close based confirmation instead. This gives the user control over how precise the gap definition should be. 🔸 Pending FVG Lifecycle Tracking Detected FVGs are not immediately turned into inverse zones. They are first stored as pending gaps and monitored until price later crosses them in the opposite direction. 🔸 Automatic FVG to IFVG Conversion When price invalidates a pending gap from the opposite side, the script creates a new Inverse Fair Value Gap object and begins tracking it as an active zone. 🔸 Ghost Box Support The original FVG can be preserved visually as a dashed ghost box from the creation time of the imbalance to the inversion time. This makes it easier to see the original gap and the later role reversal event together. 🔸 Volumetric Breakdown Inside the IFVG Each active inverse gap includes three stacked internal bars: estimated bullish participation, estimated bearish participation, and relative strength. This gives the zone more context than a normal box alone. 🔸 Participation Estimation From Candle Anatomy Bullish and bearish participation are estimated from the inversion candle’s structure and volume. This creates a practical volume split model that helps describe how the inversion occurred. 🔸 Strength Metric From Volume Percentile Rank The script measures how strong the inversion candle’s volume is relative to the last one hundred bars. This is displayed as a separate strength bar inside the IFVG. 🔸 Live Box Expansion As long as an IFVG remains active, its container extends forward in time. The internal volumetric bars and text labels are updated continuously so the zone remains clear and readable. 🔸 Automatic Invalidation A bullish IFVG is removed if price closes below its bottom. A bearish IFVG is removed if price closes above its top. This keeps the display focused on still valid inverse zones. 🔸 Controlled History Size The script limits how many active IFVGs remain on the chart. Older ones are removed once the display exceeds the selected history count. 🔹 Calculations 1) Defining the Pending Gap and Active IFVG Objects type PendingFVG float top float btm bool is_bull_gap bool processed int created_time type IFVG int start_time int origin_time float top float btm bool is_bull_ifvg float pct_bull float pct_bear float pct_strength box container box ghost_box box bg_bull box bar_bull box bg_bear box bar_bear box bg_str box bar_str label lbl_bull label lbl_bear label lbl_str bool active This is the structural foundation of the script. A PendingFVG stores an imbalance that has been detected but has not yet inverted. It contains the gap boundaries, whether the original gap was bullish or bearish, whether it has already been processed into an inverse gap, and the time when it was created. An IFVG stores the full active inverse gap state. In addition to the price boundaries and direction, it also stores the three internal metrics, the container box, the optional ghost box, the internal background and progress bars, the labels, and the active state. So the script is not just drawing boxes. It is managing two linked object lifecycles: pending FVGs, and active inverse FVGs. 2) ATR Filter for Gap Significance float atr_val = ta.atr(14) The ATR value is used as the script’s minimum significance filter. Instead of accepting every visible gap, the script compares gap size against a fraction of ATR. This is useful because a fixed price threshold would behave very differently across markets and timeframes, while ATR gives a volatility aware reference. So ATR acts as the noise filter that decides whether a newly found gap deserves to be tracked. 3) Estimating Bullish and Bearish Participation calc_metrics(float o, float h, float l, float c, float v) => float rng = h - l float buy_v = 0.0 if rng == 0 buy_v := v * 0.5 else if c >= o buy_v := v * ((math.abs(c - o) + (math.min(o, c) - l)) / rng) else buy_v := v * ((h - math.max(o, c)) / rng) float sell_v = v - buy_v float total = buy_v + sell_v float p_bull = total > 0 ? buy_v / total : 0 float p_bear = total > 0 ? sell_v / total : 0 float p_str = ta.percentrank(v, 100) / 100.0 This function is one of the most important parts of the whole script. Its goal is to turn one candle into three interpretable metrics: bullish share, bearish share, and strength. First, the script measures the candle range. If the candle has zero range, volume is split evenly. If the candle has a real range, the script estimates buying pressure differently depending on candle direction. For bullish candles, buy volume is influenced by the candle body plus the lower section of the candle. For bearish candles, buy volume is approximated from the remaining upper section. The result is not true exchange level aggressor volume, but it is a practical candle anatomy based estimate of how much of the inversion bar behaved more like buying versus selling. Then the script converts those raw buy and sell estimates into proportions: p_bull and p_bear Finally, it calculates p_str using the percentile rank of current volume over the last one hundred bars. That means the strength value is not just raw volume. It describes how relatively strong the inversion candle was compared with recent history. 4) Reading the Current Candle Metrics = calc_metrics(open, high, low, close, volume) This line applies the volumetric function to the current bar. These three values are later attached to a new IFVG at the moment of inversion. So each active inverse gap inherits the participation and strength profile of the candle that caused the role reversal. That is important conceptually. The internal bars inside the IFVG are not random decorations. They represent the inversion event itself. 5) Detecting Bullish and Bearish FVGs bool bull_cond = strict_mode ? (low > high ) : (close > high ) bool bear_cond = strict_mode ? (high < low ) : (close < low ) This block defines the actual Fair Value Gap logic. In strict mode: a bullish gap exists only when the current low is above the high from two bars ago, and a bearish gap exists only when the current high is below the low from two bars ago. That means actual wick separation is required. In non strict mode: the script relaxes this and allows close based confirmation instead. So the user can choose whether the script should only accept clean wick gaps or allow a softer close based definition. 6) Measuring the Gap Size float gap_size = 0.0 if bull_cond and close > open gap_size := low - high if bear_cond and close < open gap_size := low - high bool is_significant = gap_size >= (atr_val * fvg_threshold_atr) Once a candidate FVG is found, the script measures how large the gap actually is. For bullish gaps, the size is the distance between the current low and the high from two bars ago. For bearish gaps, the size is the distance between the low from two bars ago and the current high. The script also adds a candle direction filter on the middle bar: bullish gaps require the middle candle to be bullish, and bearish gaps require the middle candle to be bearish. Finally, the measured gap must be at least as large as: ATR × threshold This removes smaller gaps that may simply be noise. 7) Storing a Pending FVG if is_significant PendingFVG p = PendingFVG.new() p.created_time := time p.processed := false if bull_cond p.is_bull_gap := true p.top := low p.btm := high else p.is_bull_gap := false p.top := low p.btm := high array.push(pending_fvgs, p) If the gap is significant, the script stores it as a pending FVG. The gap is not drawn yet as an inverse zone. Instead, it is placed into the pending list with: its direction, its boundaries, its creation time, and a flag showing it has not yet been processed. This is important because an FVG only becomes an IFVG after it fails. The pending list is the waiting room for that future role reversal. 8) Detecting the Inversion Event if array.size(pending_fvgs) > 0 for i = array.size(pending_fvgs) - 1 to 0 PendingFVG p = array.get(pending_fvgs, i) if not p.processed bool inverted = false bool to_bull = false if not p.is_bull_gap and close > p.top inverted := true to_bull := true if p.is_bull_gap and close < p.btm inverted := true to_bull := false This is the core IFVG transition logic. A pending bearish FVG becomes a bullish IFVG if price closes above its top. A pending bullish FVG becomes a bearish IFVG if price closes below its bottom. That is the actual role reversal event. Price has invalidated the original imbalance from the opposite side, so the gap flips into an inverse form. The to_bull flag determines the direction of the new inverse zone. 9) Creating the IFVG Object if inverted IFVG obj = IFVG.new() obj.start_time := time obj.origin_time := p.created_time obj.top := p.top obj.btm := p.btm obj.is_bull_ifvg := to_bull obj.pct_bull := curr_p_bull obj.pct_bear := curr_p_bear obj.pct_strength := curr_p_str obj.active := true obj.create_drawings() array.push(active_ifvgs, obj) p.processed := true Once inversion is confirmed, the script creates the active IFVG. The new object inherits: the original FVG boundaries, the original creation time, the inversion start time, and the new inverse direction. It also stores: the bullish participation percentage, the bearish participation percentage, and the strength percentage from the inversion candle. So the IFVG is a structural object with a built in event profile. It tells the user not only where the failed gap is located, but also what the inversion bar looked like in participation terms. 10) Creating the Ghost Box and Main Container if show_ghost this.ghost_box := box.new( left=this.origin_time, top=this.top, right=this.start_time, bottom=this.btm, border_color=color.new(c_border, 20), border_width=1, border_style=line.style_dashed, bgcolor=c_ghost, xloc=xloc.bar_time ) this.container := box.new( left=this.start_time, top=this.top, right=time, bottom=this.btm, border_color=c_border, border_width=1, bgcolor=color(na), xloc=xloc.bar_time ) This is the first part of the IFVG drawing engine. If ghost mode is enabled, the script draws a dashed box from the original FVG creation time to the inversion time. This visually represents the original gap before it failed. Then it creates the main IFVG container box starting from the inversion time and extending to the current bar. So the chart can show both: where the original gap existed, and where the inverse zone now lives. 11) Building the Internal Volumetric Bar Areas this.bg_bull := box.new(this.start_time, this.top, time, this.top, border_width=0, bgcolor=c_bg_dark, xloc=xloc.bar_time) this.bar_bull := box.new(this.start_time, this.top, this.start_time, this.top, border_width=0, bgcolor=c_bull_bar, xloc=xloc.bar_time) this.bg_bear := box.new(this.start_time, this.top, time, this.top, border_width=0, bgcolor=c_bg_dark, xloc=xloc.bar_time) this.bar_bear := box.new(this.start_time, this.top, this.start_time, this.top, border_width=0, bgcolor=c_bear_bar, xloc=xloc.bar_time) this.bg_str := box.new(this.start_time, this.top, time, this.top, border_width=0, bgcolor=c_bg_dark, xloc=xloc.bar_time) this.bar_str := box.new(this.start_time, this.top, this.start_time, this.top, border_width=0, bgcolor=c_str_bar, xloc=xloc.bar_time) Inside every IFVG, the script creates three horizontal rows. Each row has: a dark background box, and a colored progress bar box. The three rows represent: bullish participation, bearish participation, and strength. Initially these boxes are created with minimal size. Their real geometry is set later during updates. So the IFVG is designed as a mini information panel embedded directly inside the zone. 12) Slicing the IFVG Into Three Metric Rows float total_h = this.top - this.btm float h_slice = total_h / 3 float y1 = this.top float y2 = this.top - h_slice float y3 = this.top - 2 * h_slice float y4 = this.btm This block divides the IFVG vertically into three equal sections. The full height of the box is measured, then split into thirds: the first slice for bullish participation, the second slice for bearish participation, the third slice for strength. This makes the internal visualization clean and consistent regardless of zone height. 13) Converting Percentages Into Horizontal Width int now = time int dur = now - this.start_time if dur <= 0 dur := timeframe.in_seconds() * 1000 int w_bull = math.round(dur * this.pct_bull) int w_bear = math.round(dur * this.pct_bear) int w_str = math.round(dur * this.pct_strength) This is how the script turns percentages into visible progress bars. The available horizontal width is the elapsed time from the IFVG start to the current bar. That duration becomes the maximum usable width. Then each stored metric is multiplied by that duration: bullish percentage controls the bullish bar width, bearish percentage controls the bearish bar width, strength percentage controls the strength bar width. So the internal bars behave like proportion meters stretched across the live duration of the zone. 14) Updating the Bull, Bear, and Strength Bars this.bg_bull.set_left(this.start_time) this.bg_bull.set_right(now) this.bg_bull.set_top(y1) this.bg_bull.set_bottom(y2) this.bar_bull.set_left(this.start_time) this.bar_bull.set_right(this.start_time + w_bull) this.bar_bull.set_top(y1) this.bar_bull.set_bottom(y2) this.bg_bear.set_left(this.start_time) this.bg_bear.set_right(now) this.bg_bear.set_top(y2) this.bg_bear.set_bottom(y3) this.bar_bear.set_left(this.start_time) this.bar_bear.set_right(this.start_time + w_bear) this.bar_bear.set_top(y2) this.bar_bear.set_bottom(y3) this.bg_str.set_left(this.start_time) this.bg_str.set_right(now) this.bg_str.set_top(y3) this.bg_str.set_bottom(y4) this.bar_str.set_left(this.start_time) this.bar_str.set_right(this.start_time + w_str) this.bar_str.set_top(y3) this.bar_str.set_bottom(y4) These blocks physically place the three metric layers inside the IFVG. Each background row spans the full current width of the active zone. Each colored bar spans only the proportional amount determined by the stored metric. So if bullish participation is high, the bullish bar stretches farther across its row. If strength is low, the strength bar remains shorter. This gives the zone an at a glance internal profile. 15) Updating the Text Labels this.lbl_bull.set_xy(center_x, mid_bull) this.lbl_bull.set_text(str.format("Bull: {0}%", math.round(this.pct_bull * 100))) this.lbl_bear.set_xy(center_x, mid_bear) this.lbl_bear.set_text(str.format("Bear: {0}%", math.round(this.pct_bear * 100))) this.lbl_str.set_xy(center_x, mid_str) this.lbl_str.set_text(str.format("Str: {0}%", math.round(this.pct_strength * 100))) The script also prints the numerical values inside the three rows. Each label is placed at the center of its row and updated with the rounded percentage value. So the user sees both: the visual bar length, and the exact stored percentage. This makes the IFVG readable even when box width is large or when color alone is not enough. 16) IFVG Invalidation Logic bool broken = false if this.is_bull_ifvg and close < this.btm broken := true if not this.is_bull_ifvg and close > this.top broken := true if broken this.active := false this.remove() An active IFVG only remains valid while price stays on the correct side of its structure. For bullish IFVG: if close falls below the bottom, the zone is broken. For bearish IFVG: if close rises above the top, the zone is broken. When that happens, the IFVG is marked inactive and all associated objects are deleted. So the indicator is not just drawing inverse gaps indefinitely. It actively monitors whether they continue to behave as valid reaction zones. 17) Display Limit Management while array.size(active_ifvgs) > show_last_n IFVG d = array.shift(active_ifvgs) d.remove() This final block controls how many IFVGs remain visible. If the number of active inverse gaps exceeds the selected display limit, the oldest one is removed from the front of the array and all of its drawings are deleted. This keeps the chart focused on the most recent inverse gaps and prevents excessive visual clutter.
אינדיקטור Pine Script®
מאת ‎UAlgo‎
1
Outside Bar & 2-Bar Reversal Alerts + SystemOutside Bar & 2-Bar Reversal — Price Action Reversal Detection with Integrated Trade Management Hello friends and traders! 🔹 Introduction This indicator — Outside Bar & 2-Bar Reversal — automatically identifies two of the most structurally sound price action reversal patterns and overlays a complete trade management system directly on your chart. The patterns this indicator detects are rooted in a simple but powerful idea: momentum exhaustion followed by full absorption. When price makes an aggressive directional push and is then completely engulfed by the opposing side, it often signals that the prevailing move has run out of willing participants. The indicator also includes an optional suite of confluence filters — VWAP, swing sweeps, and time-of-day — so you can isolate the highest-quality setups rather than trading every signal blindly. I'll cover the pattern logic, the trade management system, and all filters in detail throughout this description. 🔹 The Premise 🔸 Why Reversal Candles Work Price moves because of imbalance. When more aggressive buyers than sellers are active, price rises. When more aggressive sellers than buyers are active, price falls. Reversal candle patterns are useful because they attempt to identify the moment that imbalance flips — where one side that was previously dominant is fully overcome by the other. The key word is fully. A simple bearish candle after a bullish candle tells you very little. What's meaningful is when the opposing candle completely engulfs the prior move — taking out its low, closing above its open, and reaching above its high. That's not just a pause. That's a statement. This is the foundation of both patterns this indicator detects. 🔸 What Is an Outside Bar? An outside bar is a candle that completely engulfs the prior candle — its range exceeds the prior candle's range on both sides. But not all outside bars are created equal. A random outside bar on a quiet consolidation bar means very little. The patterns this indicator targets require context and directionality before the signal fires. Bullish Outside Bar — Full Conditions: Candle 1 must be bearish — it closes below its open Candle 1 must close below the prior candle's close — a genuine continuation of selling Candle 1's low must be below the prior candle's low — it must make a lower low, showing directional commitment Candle 2 (signal candle) must have a lower low than Candle 1 — extending the flush Candle 2 must close above Candle 1's open — full absorption of the bearish candle Candle 2 must have a higher high than Candle 1 — completing the engulf The result: a setup where price made a committed bearish push, and then a single candle came in, swept below it, and closed above the entire prior move. Buyers didn't just show up — they overwhelmed every seller from the prior candle. Bearish Outside Bar — Full Conditions: The exact mirror. A committed bullish candle that makes a higher high, followed by a signal candle that sweeps above it and closes below its entire range. Sellers overwhelmed every buyer. 🔸 What Is a 2-Bar Reversal? The 2-Bar Reversal is a related but distinct pattern. Rather than requiring full range engulfment, it focuses on close-to-close extremity. Bullish 2-Bar Reversal: Candle 1 closes entirely below the low of the candle before it — an aggressive, committed flush Candle 2 closes above the open of Candle 1 — a full reclaim of the prior candle's starting point The logic: if price closes below a prior candle's entire range, sellers were aggressive. If the very next candle reclaims all of that, buyers responded even more aggressively. The speed of the reversal is what makes this significant. Bearish 2-Bar Reversal: Candle 1 closes above the prior candle's high. Candle 2 closes below Candle 1's open. Immediate and full rejection of the breakout. 🔹 Integrated Trade Management Every signal automatically places three levels on your chart so you never have to manually calculate a trade again. 🔸 Entry The open of the candle immediately following the signal candle. You're not chasing — you're entering at the next structured open after confirmation is complete. 🔸 Stop Loss The open of the signal candle itself. The reasoning: if price returns to where the signal candle opened, the reversal thesis is structurally compromised. 🔸 Take Profit Fully user-adjustable R multiple. Default is 2R — meaning for every dollar risked, you're targeting two dollars of reward. Adjustable from 0.1R to any value via the settings panel. 🔸 Line Behavior All three lines extend to the right in real time and automatically terminate the moment price hits either the TP or SL level. No manual cleanup. No cluttered leftover lines. Every historical trade remains visible on the chart so you can review setups at a glance. 🔹 Live Performance Table A built-in stats table tracks every closed trade automatically: Total Trades — all resolved trades Wins — trades that reached the TP level Losses — trades that hit the SL level Win Rate — displayed as a percentage, color coded green above 50% and red below Load any chart, any timeframe, any market — the table populates in real time and gives you an instant read on how the patterns have performed under your current filter settings. 🔹 Confluence Filters Each filter is independently toggleable. Use one, all, or none — the indicator works standalone without any filters active. 🔸 VWAP Filter VWAP (Volume Weighted Average Price) is widely used by institutional participants as an intraday benchmark. Price trading above VWAP is generally considered a bullish market structure for the session; below VWAP is bearish. When enabled, this filter requires: Bullish signals: the signal candle must close above VWAP Bearish signals: the signal candle must close below VWAP This keeps you aligned with the intraday institutional bias rather than trading reversals against the dominant order flow of the session. 🔸 Swing Sweep Filter One of the most reliable contexts for a reversal pattern is when it occurs after a liquidity sweep — price briefly trading through a prior swing point before reversing. This is often where stop orders from trapped traders trigger, adding fuel to the reversal. When enabled: Bullish signals only show if the signal candle's low swept below a recent pivot low Bearish signals only show if the signal candle's high swept above a recent pivot high Both the lookback window and the pivot strength (number of bars required on each side to qualify as a swing) are fully adjustable. 🔸 Time Window Filter Not all hours of the trading day are equal. The highest-quality price action signals tend to occur during periods of genuine institutional participation — typically the first few hours of the New York session when volume, spread, and volatility are all at their daily peak. When enabled, signals are restricted to a user-defined time window. Default is 8:00 AM – 11:00 AM EST, covering the New York open. The start and end times are individually adjustable by hour and minute. Uses the America/New_York timezone, so EST/EDT daylight saving transitions are handled automatically. 🔹 Settings Overview SettingDescriptionShow Bullish / Bearish SignalsToggle each direction independentlyShow Outside BarsToggle OB pattern on/offShow 2-Bar ReversalsToggle 2BR pattern on/offTake Profit R MultipleAdjustable TP target (default 2R)Show Trade LinesToggle entry/SL/TP linesLine ColorsIndependently customizableTime Window FilterOn/off + start/end timeVWAP FilterOn/offSwing Sweep FilterOn/off + lookback + pivot strength 🔹 Works On Any Market & Timeframe The patterns are purely price-action based — no volume dependency, no indicator inputs. They apply equally to equities, futures, forex, and crypto. Most effective on intraday timeframes (1m–15m) during high-liquidity sessions, but the logic holds on higher timeframes for swing traders as well. 🔹 Closing Remarks The Outside Bar and 2-Bar Reversal are not new concepts. Traders have been observing these patterns for decades. What this indicator adds is precision in definition — ensuring every signal meets a strict structural checklist rather than firing on any loosely engulfing candle — combined with a fully automated trade management overlay and a real-time performance table. The filters exist because context matters. The same pattern in the middle of a choppy afternoon session, below VWAP, with no liquidity sweep, is a different proposition to the same pattern at the New York open, above VWAP, after a clean sweep of a prior swing low. Use the filters to build a ruleset that matches your edge, and use the performance table to validate it. Drop a comment below with the market and timeframe you're testing this on — always interested to see how different traders apply price action tools.
אינדיקטור Pine Script®
מאת ‎Resonant_Trader‎
Squeeze Impulse OscillatorSqueeze Impulse Oscillator (SIO) Indicator Description The Squeeze Impulse Oscillator is designed to detect moments when the market exits a consolidation phase (squeeze) and forms a strong impulsive move. The indicator analyzes candlestick patterns, the ratio of the body to the range, wick lengths, and price dynamics to assess the strength of the current trend and potential breakout from consolidation. The core idea is to compare two components: Impulse – shows how strong the price movement is, based on the body size relative to the range and the persistence of direction (consecutive bars in the same direction). Squeeze – reflects the degree of market tightness, evaluated by wick length and range contraction. Longer wicks and narrower ranges indicate higher energy accumulation for a subsequent impulse. The resulting SIO value = impulse − squeeze. Positive values indicate a dominance of the impulse component, negative values point to a squeeze phase. Additional threshold levels help identify confident impulse zones and extreme squeeze zones. How It Works Candle Evaluation Relative body size (bodyEff) – ratio of the candle body to its full range. Larger body means stronger impulse. Wick ratio (wickRatio) – total wick length relative to the range. Long wicks indicate indecision or accumulation. Current range compared to its average (rangeRatio) – helps incorporate volatility. Price Dynamics Persistence factor (persist) equals 1 if the last two price changes are in the same direction, otherwise 0. Component Calculation impulseScore = bodyEff × rangeRatio × (0.5 + 0.5 × persist) squeezeScore = wickRatio × (2.0 − rangeRatio) × (1.0 − persist × 0.5) Oscillator rawSIO = impulseScore − squeezeScore Final sio value is smoothed with an exponential moving average (EMA) using the specified smoothing period. Squeeze Counter When sio drops below the squeeze threshold (i_sqzTh), a consecutive bar count begins. The counter resets when sio rises above zero. Additional Line Averaged wick bias (avgWickBias) is displayed, showing which side has longer wicks (positive → bullish bias, negative → bearish bias). Used for signal filtering. Signals The indicator generates three types of signals (enabled via Show Signals parameter): Bull Impulse – green triangle at the bottom. Conditions: sio crosses above the impulse threshold (i_impTh); preceded by at least the minimum number of squeeze bars (Min Squeeze Bars); wick bias positive (avgWickBias > 0). Interpretation: after a prolonged squeeze phase, price starts moving up, confirmed by bullish candle structure. Bear Impulse – red triangle at the bottom. Same conditions but wick bias ≤ 0. Interpretation: expected downward move after a squeeze. Squeeze Start – purple diamond at the top. Occurs when sio crosses below the squeeze threshold. Warns of possible energy accumulation and an upcoming impulse. Visual Elements SIO Histogram – colored according to the state: bright green/red (depending on candle direction) – above impulse threshold; purple – below squeeze threshold; gray – neutral zone. Wick Bias Line (yellow) – scaled for better visibility. Squeeze Counter – purple step line showing consecutive bars in squeeze. Background Highlight – squeeze zones are marked with a semi‑transparent purple background. Horizontal Levels: impulse threshold, zero line, squeeze threshold. Input Parameters Core Period – period for average range calculation and wick bias moving average. Smoothing – EMA smoothing of the final SIO value. Impulse Threshold – level above which the value is considered impulsive. Squeeze Threshold – level below which the value is considered a squeeze. Signals Show Signals – enable/disable signal plotting. Min Squeeze Bars – minimum number of consecutive squeeze bars required for an impulse signal. Highlight Squeeze Zones – enable/disable background highlighting. Colors – custom colors for all visual elements. Usage The indicator helps identify entry points after consolidation phases. Buy/sell signals should be considered only with confirming factors: higher‑timeframe trend, volume, support/resistance levels. False signals may occur in low‑volatility markets or during news events. It is recommended to backtest and adapt thresholds for the specific instrument. Disclaimer This indicator is not financial advice. All calculations are based on historical data and do not guarantee future results. Use it as one of many analytical tools in combination with other methods.
אינדיקטור Pine Script®
מאת ‎Smart-Day-Trader‎
ZenAlgo - DojiOverview This indicator identifies Doji candles and adds two contextual filters before creating an alert: a relative volume expansion filter and a normalized directional-shift filter. Most Doji indicators simply detect candle shape. This script instead adds contextual conditions so that alerts appear only when the Doji occurs together with increased participation and a change in short-term directional pressure. Doji candles appear frequently on their own, so the script focuses on situations where candle balance, elevated activity, and a directional shift occur at the same time. How the indicator works The script begins by evaluating candle structure. It measures the full candle range, the size of the body, and the size of the upper and lower wicks relative to the entire candle. A candle is considered a Doji when the body occupies only a small portion of the range. After identifying the base Doji structure, the candle is classified into one of several common Doji types depending on the relative size of the wicks: Dragonfly Doji – very small upper wick and long lower wick. Gravestone Doji – very small lower wick and long upper wick. Long-legged Doji – both wicks are relatively long. Standard Doji – small body without the extreme wick proportions of the other types. A Doji indicates that price moved during the bar but finished close to the opening level, suggesting temporary balance between buyers and sellers. Volume context (PVSRA-style comparison) After the candle structure is detected, the script evaluates trading activity. Current volume is compared with the average volume over a recent lookback window. If current volume exceeds that average by a configurable multiple, the candle is considered to occur during elevated participation. This step is important because a Doji formed during low activity may simply reflect quiet trading, while a Doji formed during higher participation means more trading occurred but the candle still closed near equilibrium. Normalized price-change proxy The script then evaluates short-term directional behavior. It measures the percentage change between consecutive closing prices. This series is smoothed to reduce noise and then normalized relative to recent behavior. The normalization allows the script to determine whether the current directional movement is unusually positive or negative compared with recent activity. The script compares this normalized value with the previous bar. An alert requires the value to change sign between the two bars, which indicates that the short-term directional pressure has flipped. Why the components are combined Each component describes a different aspect of market behavior: The Doji describes temporary balance inside a candle. The volume comparison measures whether that balance occurred during elevated participation. The directional flip indicates a shift in short-term pressure. Basic Doji markers highlight every small-body candle. This indicator is more selective because it only highlights cases where equilibrium, participation, and directional change appear together. Final alert logic An alert is created when the following conditions occur simultaneously: A Doji is present on the current candle or the previous candle. Volume exceeds the recent average by the configured multiple when the volume filter is enabled. The normalized directional reading flips sign between two consecutive bars. Alerts are separated into bullish and bearish categories according to the direction of the normalized reading after the flip. How to interpret the alerts A bullish alert means the script detected a Doji context with elevated volume and a positive directional flip. A bearish alert means the same conditions occurred with a negative directional flip. The alert marks a moment where price equilibrium, increased participation, and directional change appeared together. These conditions may appear near short-term transitions, pauses, or local turning points. How to use the indicator This indicator is intended as a contextual chart tool rather than a standalone trading system. Use alerts to locate Doji candles confirmed by participation and directional change. Interpret bullish alerts as possible upward transitions and bearish alerts as possible downward transitions. Evaluate the alert location relative to support, resistance, or recent trend structure. Combine the alerts with other analysis tools or higher timeframe context. Why Heikin Ashi often works well The script can be used on any chart type, but Doji detection often becomes clearer on Heikin Ashi candles. Heikin Ashi candles smooth short-term price fluctuations by averaging values from multiple bars. Because the indicator relies on candle body and wick proportions, this smoothing reduces small random Doji created by short-term noise and produces clearer candle structures. Limitations Doji candles occur frequently and do not inherently indicate reversals. Volume filters depend on the quality and meaning of the exchange’s volume data. The directional proxy is based on price changes rather than direct order flow. Different markets, timeframes, and preset settings can change how often alerts appear. The indicator highlights situations where candle equilibrium, elevated participation, and directional change appear together, but it does not determine future price direction.
אינדיקטור Pine Script®
מאת ‎ZenAlgo_Official‎
Asia Liquidity + PDH/PDL (BornaTrading)Asia + Frankfurt Liquidity + PDH/PDL (GER40 / DAX) This indicator highlights key intraday liquidity levels commonly used by traders of GER40 / DAX and other indices. It automatically plots the most important session highs and lows that institutional traders often monitor for liquidity sweeps and market manipulation. The script focuses on three main liquidity zones: Asia Session High / Low Frankfurt Session High / Low Previous Day High / Low (PDH / PDL) based on the main European trading session. Features • Customizable Asia Session You can freely set the Asia session time, for example: 00:00 – 07:00 02:00 – 08:00 • Customizable Frankfurt Session Frankfurt session time can also be adjusted based on your strategy. • Previous Day High / Low (PDH / PDL) Calculated from the main European trading session (09:00 – 17:30 CET). • Clean Chart Design The indicator only displays levels for the current trading day, preventing charts from being cluttered with historical lines. • Toggle Visibility Each level can be turned on or off individually: Asia High Asia Low Frankfurt High Frankfurt Low PDH PDL • Right-Side Labels All levels remain clearly labeled on the right side of the chart for easier reading. Why These Levels Matter Institutional traders often target areas where liquidity accumulates. These typically include: Previous Day High / Low Asia Session High / Low Frankfurt Session High / Low Price frequently sweeps these levels before moving in the opposite direction, especially around the London open. This tool helps traders quickly identify these zones and incorporate them into their intraday liquidity-based trading strategies.
אינדיקטור Pine Script®
מאת ‎Borna_trading‎
Supply and Demand [odnac]Overview An indicator that visualizes directional candles and consolidation zones by analyzing candle flow. Displayed in a separate panel (overlay = false). Candle Flow Candles are categorized into 4 colors. Green : Bullish candle that breaks above the previous reference high Red : Bearish candle that breaks below the previous reference low White : Both high and low broken simultaneously (two-way sweep) Gray : Inside candle that stays within the reference range How it works Initial reference values (refHigh, refLow) are set from the first candle's high and low Reference values update every time a candle breaks outside the current range Tracks the last confirmed directional trend (lastDirectionalTrend), with trueReversal flag triggered on trend changes Settings Show Consolidation : Toggle consolidation box visibility Overlay on Main Chart : Display box on the main chart pane Minimum Inside Candles : Minimum candles required to form a valid zone Box Color : Box background color How it works A box is created when price enters an inside candle sequence The box right edge, high, and low are continuously updated while inside candles continue Box color is applied once the minimum candle count (min_candles) is reached When a directional candle breaks out, the box is finalized — deleted if below minimum threshold
אינדיקטור Pine Script®
מאת ‎odnac‎
Inducement [UAlgo]Inducement is a market structure tool designed to detect pullback liquidity levels that form during directional expansion and remain relevant until price comes back to sweep them. The script tracks directional legs, monitors the deepest retracement points that appear against the active move, and promotes those retracement extremes into active IDM levels once the trend resumes in the original direction. The core idea is simple. During a bullish move, price often creates a temporary downside pullback before continuing upward. That pullback low can later act as an inducement point where liquidity rests below the market. In a bearish move, the opposite process happens, where an upside pullback forms before price continues lower. That pullback high can later become a bearish inducement point. This script automates that process and keeps those levels visible on the chart until they are eventually swept. What makes the script useful is that it does not plot every fluctuation. It first filters out inside bars, tracks the active directional leg, records the most meaningful retracement extreme inside that leg, and only creates a new IDM when price resumes the main move by printing a fresh expansion. That makes the final levels cleaner and more structurally relevant. Once an IDM is created, it is drawn as a horizontal reference with a label. If price later trades through that level, the script marks it as swept, updates the label, and changes the line style to reflect that the liquidity has been taken. This creates a very practical chart view for traders who want to monitor inducement behavior, liquidity sweeps, and the relationship between pullbacks and later price delivery. 🔹 Features 🔸 Directional Leg Tracking The script maintains an internal bullish or bearish trend state and updates the active structural leg as price continues to expand. This gives the indicator a directional framework instead of treating each new bar independently. 🔸 Inside Bar Filtering Inside bars are ignored for structural progression. This helps the script focus on meaningful range expansion rather than reacting to small compressive candles that do not add new directional information. 🔸 Pullback Extreme Detection During a bullish leg, the script tracks the lowest downside pullback that forms before the next bullish expansion. During a bearish leg, it tracks the highest upside pullback before the next bearish expansion. These stored extremes are the raw candidates for inducement levels. 🔸 Automatic IDM Creation A stored pullback extreme becomes an active IDM only when the market resumes the active leg and creates a fresh structural push. This means the indicator does not mark every retracement immediately. It waits for continuation confirmation. 🔸 Bullish and Bearish IDM Mapping Bullish IDM levels are created from pullback lows inside bullish continuation. Bearish IDM levels are created from pullback highs inside bearish continuation. This gives the user a clean map of likely liquidity resting points below or above price. 🔸 Sweep Recognition Once an IDM is active, the script checks every new bar to see whether price has swept it. Bullish IDM is considered swept when current low trades at or below the level. Bearish IDM is considered swept when current high trades at or above the level. 🔸 Live Visual State Changes Active IDM levels are drawn with dashed lines and labeled as unswept. Once swept, the line style changes, the color becomes softer, and the label updates to show that the liquidity event has already occurred. 🔸 Lightweight Structure Display The script keeps an internal array of active IDM levels and limits the array size to avoid uncontrolled growth. This keeps the display practical and suitable for live chart use. 🔹 Calculations 1) Defining the IDM Object type InducementLevel float price int bIndex int dir line idmLine label idmLabel bool isSwept This is the core data container used by the script. Each inducement level stores: its price, the bar index where it originated, its direction, its line object, its label object, and whether it has already been swept. The dir field controls the level type: 1 means bullish IDM -1 means bearish IDM So before any logic runs, the script already has a dedicated structure for tracking the full lifecycle of each inducement level from creation to sweep. 2) Drawing Active and Swept Levels method draw(InducementLevel this, color c_bull, color c_bear) => color c = this.dir == 1 ? c_bull : c_bear string txt = this.isSwept ? "IDM ✓" : "IDM ✗" if na(this.idmLine) this.idmLine := line.new(this.bIndex, this.price, bar_index, this.price, color=c, style=line.style_dashed) else if not this.isSwept this.idmLine.set_x2(bar_index) if na(this.idmLabel) this.idmLabel := label.new(bar_index, this.price, txt, style=label.style_none, textcolor=c, size=size.small, textalign=text.align_left) else if not this.isSwept this.idmLabel.set_x(bar_index) this This method is responsible for visualizing each inducement level. First, it selects the correct color according to direction. Bullish levels use the bullish color input, and bearish levels use the bearish color input. Then it builds a text state: "IDM ✗" means the level is still active and not yet swept. "IDM ✓" means the level has already been swept. If the line does not exist yet, the script creates a dashed horizontal line starting from the level’s origin bar to the current bar. If the line already exists and the level is still unswept, the line is extended to the latest bar. The label follows the same logic. If no label exists, it is created. If the label already exists and the level is still active, its position is moved to the latest bar. So visually, each active IDM behaves like a live horizontal liquidity reference that extends forward until price takes it. 3) Detecting Liquidity Sweeps method checkSweep(InducementLevel this, float currLow, float currHigh, color c_bull, color c_bear) => if not this.isSwept swept = false if this.dir == 1 and currLow <= this.price swept := true else if this.dir == -1 and currHigh >= this.price swept := true This method determines whether an existing inducement level has been taken. The logic is direction specific. For bullish IDM: if the current low trades at or below the level price, the level is considered swept. For bearish IDM: if the current high trades at or above the level price, the level is considered swept. This matches the structural idea behind inducement. A bullish pullback low represents liquidity resting below price, and that liquidity is considered taken once price trades through it. A bearish pullback high represents liquidity resting above price, and that liquidity is considered taken once price pushes through it. So this method is the event detector that turns an active liquidity level into a completed liquidity event. 4) Updating the Visual State After a Sweep if swept this.isSwept := true color c = this.dir == 1 ? color.new(c_bull, 50) : color.new(c_bear, 50) this.idmLine.set_color(c) this.idmLine.set_style(line.style_dotted) this.idmLine.set_x2(bar_index) this.idmLabel.set_text("IDM ✓") this.idmLabel.set_textcolor(c) this.idmLabel.set_x(bar_index) Once a sweep happens, the script changes both the internal state and the visual appearance. The level is marked as swept with this.isSwept := true . Then the line color becomes softer by applying transparency. The line style changes from dashed to dotted. The label text changes from IDM ✗ to IDM ✓ . This is useful because it preserves the historical location of the inducement while also showing that the level is no longer pending. In other words, the chart keeps the context but changes the state. 5) Filtering Out Inside Bars var float mHigh = high var float mLow = low bool isInside = high <= mHigh and low >= mLow This small block is more important than it looks. The script stores a reference range using mHigh and mLow . A bar is considered inside if its high is less than or equal to the stored high and its low is greater than or equal to the stored low. In simple terms, an inside bar is a bar that remains contained within the prior meaningful structure range. The script ignores those bars for the purpose of leg progression. This helps reduce noise because inside bars usually reflect compression rather than new structural information. By ignoring them, the indicator focuses on actual range expansion and meaningful pullback development. 6) Tracking Trend State and Leg Extremes var int trend = 1 var float legHigh = high var float legLow = low var float pullbackLow = na var int pullbackLowBar = na var float pullbackHigh = na var int pullbackHighBar = na This block defines the internal market structure memory. trend stores whether the script currently sees the market as bullish or bearish. legHigh and legLow track the active structural extreme of the current leg. pullbackLow and pullbackHigh store the most important retracement extreme that forms against the current trend. So the script is always tracking two things at once: the direction of the main move, and the deepest retracement against that move. That retracement extreme later becomes the candidate IDM if price resumes the original direction. 7) Bullish Leg Logic and Bullish IDM Creation if trend == 1 if high > legHigh if not na(pullbackLow) activeIDMs.push(InducementLevel.new(pullbackLow, pullbackLowBar, 1, na, na, false)) pullbackLow := na legHigh := high else if brokeLow if na(pullbackLow) or low < pullbackLow pullbackLow := low pullbackLowBar := bar_index This is the heart of bullish inducement detection. When the script is in bullish mode, it watches for two types of events. First, if price makes a new leg high: high > legHigh That means bullish continuation has occurred. If a downside pullback low had been stored before this continuation, the script converts that pullback low into a new bullish IDM by pushing it into the active array. That is the crucial idea: the pullback low becomes inducement only after price proves continuation by printing a fresh high. Second, if the current bar breaks below the stored micro range low: brokeLow Then the script updates pullbackLow if this new low is deeper than the previously stored pullback. This allows the script to keep tracking the deepest retracement inside the bullish leg until continuation happens. So bullish IDM is created from the most meaningful downside retracement that occurs before the next bullish expansion. 8) Bearish Leg Logic and Bearish IDM Creation else if trend == -1 if low < legLow if not na(pullbackHigh) activeIDMs.push(InducementLevel.new(pullbackHigh, pullbackHighBar, -1, na, na, false)) pullbackHigh := na legLow := low else if brokeHigh if na(pullbackHigh) or high > pullbackHigh pullbackHigh := high pullbackHighBar := bar_index This is the mirror image of the bullish logic. When the script is in bearish mode, it waits for a new leg low: low < legLow If that happens and a prior upside pullback high was stored, the script converts that pullback high into a bearish IDM. This marks the retracement high as a future liquidity point above price. If price does not yet continue lower but instead breaks upward inside the local structure: brokeHigh Then the script updates pullbackHigh if the new high is greater than the previously stored retracement high. So bearish IDM is created from the strongest upside retracement that forms before the next bearish continuation. 9) Detecting Trend Reversal and Resetting the Pullback Memory if low < legLow trend := -1 legLow := low pullbackLow := na pullbackHigh := na if high > legHigh trend := 1 legHigh := high pullbackHigh := na pullbackLow := na These blocks handle directional flips. Inside bullish mode, if price breaks below the active leg low, the script changes its internal state to bearish. Inside bearish mode, if price breaks above the active leg high, the script changes its internal state to bullish. Whenever the trend flips, the stored pullback variables are cleared. That is important because retracement data from the old trend should not be reused after the market has structurally changed direction. So the script always keeps its inducement logic aligned with the current structural leg rather than mixing information from opposite phases. 10) Updating the Reference Range After a Non Inside Bar if not isInside bool brokeLow = low < mLow bool brokeHigh = high > mHigh mHigh := high mLow := low This block updates the structure reference only when the current bar is not an inside bar. Before resetting the reference range, the script checks whether the current bar expanded below the stored low or above the stored high. Those two booleans are then used in the bullish and bearish logic to decide whether the move represents pullback development or continuation. After those checks are done, the reference high and low are updated to the current bar’s high and low. So mHigh and mLow act like a rolling structural filter that helps the script ignore internal compression and focus on meaningful range expansion. 11) Managing All Active IDM Levels on Every Bar if activeIDMs.size() > 0 for i = 0 to activeIDMs.size() - 1 idm = activeIDMs.get(i) idm.checkSweep(low, high, colorBullIDM, colorBearIDM) idm.draw(colorBullIDM, colorBearIDM) This is the execution loop for all stored inducement levels. On every bar, the script goes through each active IDM and does two things: it checks whether the level has now been swept, and it redraws or updates the level on the chart. This means every stored level remains live and state aware. Unswept levels keep extending forward, while swept levels lock their appearance into a completed state. So the script is always balancing two layers: new IDM creation from ongoing structure, and lifecycle management of previously created levels. 12) Limiting the Number of Stored Levels if activeIDMs.size() > 50 activeIDMs.shift() This last block keeps the internal IDM array from growing indefinitely. If more than fifty inducement levels are stored, the oldest one is removed from the array. This helps keep memory usage under control and makes the indicator more practical for ongoing chart use. The purpose here is not analytical. It is purely operational. The script limits historical storage so the active structure set remains manageable.
אינדיקטור Pine Script®
מאת ‎UAlgo‎
1
Strategic MA Deviation TargetsOverview This indicator is a comprehensive mean-reversion tool designed to quantify how far the current price has strayed from its Moving Average (SMA or EMA). Built for traders who look for overextended market conditions, it provides clear, actionable target levels for potential reversals. Key Features Flexible MA Engine: Switch between SMA and EMA with customizable periods. Dual Deviation Targets: Set independent percentages for Buy (downside) and Sell (upside) targets. Sentiment Ranking System: Automatically categorizes the market state into five ranks: Extreme Buy, Buy Stretch, Neutral, Sell Stretch, and Extreme Sell. Target Progress Monitoring: The dashboard calculates exactly how close the price is to your target as a percentage. Visual Clarity: Dotted target lines and optional shaded zones provide a professional look. Calculation Logic Deviation: ((Close - MA) / MA) * 100 Progress: Ratio of the current deviation relative to the user-defined target threshold. Alerts: Triggers on "Cross" and "Hit" conditions. 概要 本インジケーターは、現在の価格が移動平均線（SMA/EMA）からどの程度離れているかを定量化し、相場の過熱感を分析するための平均回帰ツールです。「売られすぎ」「買われすぎ」の局面を的確に捉え、反発を狙うトレーダー向けに設計されています。 主な機能 柔軟なMA設定: SMAとEMAを切り替え可能。 独立した売買ターゲット: 買い（下方）と売り（上方）のターゲットを個別に設定可能。 センチメント・ランク機能: 相場の状態を5段階（Extreme Buy等）で自動判別。 ターゲット進捗率の可視化: 設定したターゲットに対して現在どれくらい接近しているかを数値化します。 洗練された視覚効果: ターゲットラインは点線で表示され、視認性を損ないません。 計算ロジック 乖離率: ((終値 - 移動平均線) / 移動平均線) * 100 進捗率: 設定した目標乖離率に対し、現在の乖離率が何％まで達しているかを計算します。
אינדיקטור Pine Script®
מאת ‎Harurow‎
Strategic Peak Drawdown MonitorOverview This indicator is a professional-grade tool designed to track price drawdowns from a specific peak. It is particularly effective for identifying "dip-buying" opportunities or "pullbacks" in a trending market by calculating the percentage drop from the highest price reached within a defined period or the current year. Key Features Dual Peak Modes: Choose between a rolling Lookback window or the Year-to-Date (YTD) high to define your reference peak. Visual Target Tracking: A dotted target line clearly marks your entry or monitoring zone (e.g., -10% from peak). Dynamic Alerting: Integrated background shading and status labels provide instant visual feedback when the target is reached. Clean Dashboard: A toggleable UI table displays real-time metrics, including current drawdown percentage and progress toward the target. Calculation Logic Lookback Mode: Uses the ta.highest function over a user-defined number of bars. Year-to-Date Mode: Automatically identifies the highest price since the first trading day of the current year. Target Calculation: Target = Peak Price * (1 - Drop % / 100) How to Use Trend Pullbacks: Set a target (e.g., 5-10%) to catch retracements in a strong uptrend. Market Corrections: Use the YTD mode to monitor how far the market has corrected from its yearly highs. Risk Management: Use the progress percentage in the dashboard to gauge how close the price is to a significant support level based on drawdown. 概要 本インジケーターは、特定の高値（ピーク）からの下落率を追跡するために設計されたプロフェッショナル向けツールです。一定期間の最高値、または年初来高値からの下落率を計算することで、トレンド相場における「押し目買い」のタイミングや「プルバック」の深さを正確に把握することができます。 主な機能 2つのピーク判定モード: 任意の期間（ Lookback ）または、年初からの最高値（ Year-to-Date ）を基準値として選択可能です。 視覚的なターゲット表示: ターゲットライン（例：高値から-10%）を点線で表示し、監視レベルを明確にします。 ダイナミックな通知設定: ターゲット到達時には背景のハイライトとステータスラベルが表示され、即座に状況を判断できます。 クリーンなダッシュボード: 現在の下落率やターゲットへの到達進捗率（%）をリアルタイムで表示するテーブル機能を搭載（表示/非表示の切り替え可能）。 計算ロジック ルックバックモード: 指定された期間内の最高値を ta.highest 関数を使用して算出します。 年初来モード: 当該年の最初の取引日以降の最高値を自動的に追跡します。 ターゲット計算式: ターゲット価格 = 高値 * (1 - 設定下落率 / 100) 活用方法 押し目買いの判断: 強い上昇トレンドにおいて、5〜10%程度の調整を狙う際のエントリー根拠として活用できます。 相場調整の監視: 年初来高値モードを使用することで、市場が年間の最高値からどの程度調整しているかを定量的に分析できます。 リスク管理: ダッシュボードの進捗率を確認することで、心理的な節目やサポートラインへの接近を事前に察知できます。
אינדיקטור Pine Script®
מאת ‎Harurow‎
8Bit BTC Long and Short IndicatorHow It Works The script identifies three distinct entry types, each color coded so you always know what triggered the signal: 🟢 Lime = Structure Signal (BOS) The highest conviction entry. Price sweeps a key high or low (triggering stop losses), reverses with a strong candle (CHoCH), then breaks structure in the new direction (BOS). Requires Supertrend alignment, ADX trend strength, and above-average volume to confirm. 🔵 Aqua = Divergence Signal Catches tops and bottoms that the structure method misses. Fires when RSI diverges from price action near a key swing level AND a reversal candle pattern (engulfing or hammer/shooting star) confirms the turn. 🟡 Yellow = Supertrend Flip Early trend change signal. Fires the moment the Supertrend indicator flips direction with above-average volume and trend strength confirmed by ADX. Built-In Filters Supertrend direction must agree with trade direction ADX minimum threshold filters out choppy, low-momentum markets Ranging market detection blocks signals when price is stuck sideways Stale setup cancellation — setups auto-expire after 15 bars if not confirmed Stop losses anchored to the liquidity sweep level for precise placement What You See On The Chart Colored triangle arrows with LONG/SHORT labels at every signal Supertrend line (green below price = uptrend, red above = downtrend) EMA 200 as macro trend reference Yellow background = ranging market, no trades recommended Recommended Settings Timeframe: 1H or 4H for best results on Bitcoin and major crypto pairs Works on any liquid market (forex, indices, crypto) All parameters fully adjustable in the settings panel Risk Disclaimer This indicator is a technical analysis tool only. It does not constitute financial advice. All signals should be used alongside proper risk management. Past performance does not guarantee future results. Never risk more than you can afford to lose.
אסטרטגיית Pine Script®
מאת ‎joshuavegahawkins‎
Hammer Reversal StructureThe script combines: Hammer / inverse hammer geometry Recent support or resistance zone interaction Sweep-and-reclaim behavior Optional cluster shelf and prior range context Volume confirmation Optional EMA 9 / EMA 20 / VWAP confluence notes This version is designed to reduce weak textbook-only signals by requiring the candle to form in a more meaningful location on the chart. It supports both Trend and Consolidation modes, includes configurable strictness, and offers debug tools such as candidate labels, gate tables, and plotted structure levels for review and tuning. Signals shown: H = Bull Hammer IH = Bearish Inverse Hammer Best used as a reversal-context tool, not as a standalone entry system.
אינדיקטור Pine Script®
מאת ‎Term401‎
Marubozu CandlesMarubozu Candles Indicator Highlights Marubozu candlesticks on your chart. A Marubozu is a strong single-candle pattern with little or no wicks: price moves in one direction and the body dominates the range. • Bullish Marubozu — Green candle: open near the low, close near the high (buying pressure). • Bearish Marubozu — Red candle: open near the high, close near the low (selling pressure). Detection (inputs): • Max wick % of range — How much wick is allowed (0 = strict, no wicks; e.g. 5 = small wicks allowed). • Min body % of range — Body must be at least this share of the candle’s high–low range (default 85%). • Min body (absolute) — Optional minimum body size in price units to filter out tiny candles. Display: • Colors for bull/bear Marubozu, fill, border, and optional "M" label. • Works on any timeframe and instrument. Use strict settings (e.g. 0% wick, 90%+ body) for textbook Marubozu only, or relax them to catch more strong-bodied candles.
אינדיקטור Pine Script®
מאת ‎Lean_Trading‎
LOWESS Reversal & Continuation [UAlgo]LOWESS Reversal & Continuation is a trend sensitive signal indicator built around a local LOWESS style smoothing engine that adapts to both price structure and volatility. Its core objective is to separate meaningful directional shifts from routine market noise by combining smoothed trend estimation, ATR normalized slope analysis, acceleration filtering, and disciplined signal gating. Instead of relying on a conventional moving average crossover model, the script fits a locally weighted regression over a rolling window of recent bars. This produces a smoother and more context aware estimate of price direction, while still reacting fast enough to identify emerging reversals and pullback continuation opportunities. Because the estimate is local and weighted, recent bars have greater influence than distant bars, which helps the line remain relevant to current market conditions. The indicator classifies signals into two practical categories. Reversal signals aim to identify transitions where directional pressure flips from negative to positive, or from positive to negative. Continuation signals aim to identify pullback resumption behavior inside an already established directional regime. This makes the script suitable for traders who want a single tool that can highlight both early trend change candidates and trend following re entry points. To improve robustness, the script also supports optional robust weighting passes. These passes reduce the influence of outlier bars on the LOWESS fit, which is especially useful during abnormal spikes, illiquid conditions, or isolated volatility shocks. In addition, all slope readings are normalized by ATR, allowing the trend filter to scale more consistently across instruments, timeframes, and volatility regimes. From a workflow perspective, the script is designed for clean chart usage. It colors the LOWESS line according to directional bias, draws an adaptive ATR based band around the curve, supports optional signal labels, limits on chart label clutter through an internal object manager, and provides alert conditions for all signal classes. The result is a visually compact but analytically rich framework for tracking trend reversals and continuation setups in real time. 🔹 Features 🔸 LOWESS Style Local Trend Estimation The heart of the script is a locally weighted linear regression model applied over a rolling lookback window. Each bar inside the window receives a distance based weight, meaning bars closer to the current bar have a larger impact on the estimate. This produces a smooth trend line that is more adaptive than many standard moving average techniques and better suited for identifying subtle turning points. 🔸 Optional Robust Regression Passes The indicator can apply additional robust weighting iterations after the initial fit. Residuals are measured relative to the first regression pass, and bars with unusually large residuals receive progressively lower influence in later passes. This reduces distortion from extreme candles and helps the LOWESS curve remain stable during irregular price events. 🔸 ATR Normalized Slope Filter The script does not use raw slope in isolation. Instead, the LOWESS slope is divided by ATR, creating a volatility adjusted slope metric. This makes the directional threshold more portable across markets and timeframes. A slope that may be meaningful on a slow instrument can be very different on a high volatility asset, so ATR normalization creates a more balanced regime filter. 🔸 Reversal Signal Detection Bullish and bearish reversal signals are triggered when the ATR normalized slope crosses the zero line and is confirmed by directional acceleration and price location relative to the LOWESS line. In other words, the script looks for a meaningful change in smoothed directional pressure, not simply a visual bend in the curve. This makes reversal signals more selective and better aligned with structural momentum shifts. 🔸 Continuation Signal Detection Continuation logic is designed to capture trend resumption after a pullback. The script first requires an established directional regime, then checks whether price recently interacted with the LOWESS line, and finally waits for price to reclaim the trend direction with positive confirming acceleration. This helps distinguish genuine continuation behavior from random sideways oscillation around the curve. 🔸 Pullback Validation Window A dedicated pullback lookback parameter ensures that continuation signals only occur when price has interacted with the LOWESS line within a recent number of bars. This prevents stale continuation triggers and keeps the setup focused on recent retracement behavior rather than distant historical interactions. 🔸 Close Confirmation Option Signals can be gated so they only become valid after bar close. This is useful for traders who want to avoid intrabar flicker and premature triggers on live candles. When disabled, the script can respond more aggressively in real time, which may suit faster execution styles. 🔸 Signal Cooldown Logic To reduce repetitive clustering, the indicator tracks the last occurrence of each signal type and imposes a cooldown period before another signal of the same class can be printed. Separate cooldown tracking is maintained for bullish reversals, bearish reversals, bullish continuations, and bearish continuations. 🔸 Adaptive ATR Band An optional ATR based band can be plotted around the LOWESS line. This band provides a visual sense of dynamic range around the smoothed path and can help contextualize whether price is moving in a relatively stretched or balanced position around the trend estimate. 🔸 Directional Visual Coloring The LOWESS curve changes color according to directional bias derived from the ATR normalized slope. This gives the user an immediate visual read on whether the smoothed trend pressure is currently positive, negative, or unavailable due to insufficient historical data. 🔸 Lightweight Label Management When signal labels are enabled, the script uses an internal label book to store and manage plotted objects. Older labels are automatically deleted once the configured maximum is exceeded, helping keep the chart readable and preventing uncontrolled label buildup. 🔸 Full Alert Support Alert conditions are included for all four event classes: Bullish LOWESS Reversal Bearish LOWESS Reversal Bullish LOWESS Continuation Bearish LOWESS Continuation This allows the script to be used not only as a visual analysis tool, but also as an event driven signal framework for scanning and real time notification workflows. 🔹 Calculations 1) Rolling LOWESS Window Construction For every bar, the script loads the most recent length values of the selected source into an internal rolling window. This window becomes the data sample used for the local regression fit. method loadWindow(LowessEngine this, float seriesValue) => for i = 0 to this.length - 1 array.set(this.y, i, seriesValue ) Interpretation: The regression is always fit on the latest rolling block of data. The rightmost point in the window corresponds to the current estimation point. This makes the smoothing local rather than global. 2) Distance Based LOWESS Weights The script uses a tricube kernel to assign weights based on each point’s distance from the current bar inside the regression window. Bars nearer to the most recent observation receive a larger weight, while distant bars contribute less. method buildDistanceWeights(LowessEngine this, int spanBars) => int x0 = this.length - 1 float bandwidth = math.max(spanBars, 1) for i = 0 to this.length - 1 float u = math.abs(i - x0) / bandwidth float w = u < 1 ? math.pow(1 - math.pow(u, 3), 3) : 0.0 array.set(this.baseW, i, w) Interpretation of the conditions: x0 is the current evaluation point inside the rolling window. u is normalized distance from each historical point to the current point. The tricube weight decays smoothly as distance increases. Bars outside the effective span receive zero weight. This is what gives the LOWESS fit its local character and helps it stay focused on recent structure. 3) Weighted Local Linear Regression After weights are built, the script solves a weighted linear regression over the local window. The output is a local intercept and local slope. The final LOWESS estimate is the fitted value at the most recent point in the sample. method solveWeightedLinear(LowessEngine this, array weights) => float s0 = 0.0 float s1 = 0.0 float s2 = 0.0 float t0 = 0.0 float t1 = 0.0 for i = 0 to this.length - 1 float w = array.get(weights, i) float x = array.get(this.x, i) float y = array.get(this.y, i) s0 += w s1 += w * x s2 += w * x * x t0 += w * y t1 += w * x * y float den = s0 * s2 - s1 * s1 if s0 <= 1e-10 or math.abs(den) <= 1e-10 this.slope := 0.0 this.intercept := array.get(this.y, this.length - 1) else this.slope := (s0 * t1 - s1 * t0) / den this.intercept := (t0 - this.slope * s1) / s0 float x0 = this.length - 1 this.yhat := this.intercept + this.slope * x0 Interpretation: this.slope measures the local directional gradient of the LOWESS fit. this.yhat is the current LOWESS value plotted on the chart. If the weighted regression becomes numerically unstable, the script falls back to a flat slope and uses the latest source value as intercept. 4) Robust Reweighting Passes To reduce the impact of outliers, the script can run additional robust passes after the initial fit. It first calculates the absolute residual of each point relative to the fitted line, then computes a median based scale estimate, and finally applies a bisquare style robust weighting function. method updateRobustWeights(LowessEngine this) => for i = 0 to this.length - 1 float xi = array.get(this.x, i) float yi = array.get(this.y, i) float fit = this.intercept + this.slope * xi array.set(this.residualAbs, i, math.abs(yi - fit)) float med = this.residualAbs.median() float scale = med * 6.0 if na(scale) or scale <= 1e-10 for i = 0 to this.length - 1 array.set(this.robustW, i, 1.0) else for i = 0 to this.length - 1 float u = array.get(this.residualAbs, i) / scale float rw = u < 1 ? math.pow(1 - math.pow(u, 2), 2) : 0.0 array.set(this.robustW, i, rw) Interpretation: Large residual bars are treated as less trustworthy observations. The median residual acts as a robust scale anchor. Higher residuals receive smaller robust weights in subsequent fits. This improves stability during abnormal spikes and irregular candles. 5) ATR Normalized Slope and Acceleration Once the LOWESS fit is complete, the script converts raw slope into a volatility aware slope by dividing it by ATR. It also computes a first-difference style acceleration term to measure whether directional pressure is strengthening or weakening. float slopeAtr = not na(slope) and atr > 0 ? slope / atr : na float accelAtr = slopeAtr - nz(slopeAtr ) Interpretation: slopeAtr expresses trend slope in ATR units. accelAtr measures change in normalized slope from one bar to the next. Positive acceleration supports bullish developments. Negative acceleration supports bearish developments. This combination helps the script distinguish a genuine regime shift from a weak or decaying slope condition. 6) Directional Regime Classification The script uses a user defined ATR normalized threshold to determine whether the current smoothed state qualifies as a bullish or bearish directional regime. bool upRegime = not na(slopeAtr) and slopeAtr > slopeThreshold bool downRegime = not na(slopeAtr) and slopeAtr < -slopeThreshold Interpretation: A positive but very small slope is not automatically treated as a valid uptrend. A negative but very small slope is not automatically treated as a valid downtrend. The threshold acts as a noise filter that requires the trend estimate to have enough magnitude before continuation logic becomes eligible. 7) Pullback Detection Relative to LOWESS Continuation signals depend on recent interaction with the LOWESS line. The script checks how many bars have passed since price moved through the LOWESS curve in the opposite direction of the active regime. int bullPbBars = int(nz(ta.barssince(low < lowess), 100000)) int bearPbBars = int(nz(ta.barssince(high > lowess), 100000)) bool bullPullbackRecent = bullPbBars <= pullbackLookback bool bearPullbackRecent = bearPbBars <= pullbackLookback Interpretation: In a bullish regime, price must have recently dipped below the LOWESS line to qualify as a pullback. In a bearish regime, price must have recently pushed above the LOWESS line to qualify as a pullback. The pullbackLookback parameter controls how recent that interaction must be. 8) Reversal Signal Logic Bullish and bearish reversal signals are built from zero line slope crossings, directional acceleration, and price confirmation relative to the LOWESS curve. bool slopeCrossUp = ta.crossover(slopeAtr, 0) bool slopeCrossDown = ta.crossunder(slopeAtr, 0) bool bullRevRaw = enoughBars and slopeCrossUp and accelAtr > 0 and close > lowess bool bearRevRaw = enoughBars and slopeCrossDown and accelAtr < 0 and close < lowess Interpretation of the bullish reversal conditions: slopeCrossUp means the normalized LOWESS slope has crossed from negative to positive. accelAtr > 0 means the slope is improving, not merely touching zero. close > lowess confirms that price is positioned above the smoothed trend estimate. Interpretation of the bearish reversal conditions: slopeCrossDown means the normalized LOWESS slope has crossed from positive to negative. accelAtr < 0 confirms weakening trend pressure. close < lowess confirms price is positioned below the LOWESS line. This makes reversal signals more selective than a simple moving average crossover style event. 9) Continuation Signal Logic Continuation signals are only allowed when a directional regime already exists, a recent pullback has occurred, price crosses back through the LOWESS line in trend direction, and acceleration confirms that the move is regaining strength. bool priceCrossUp = ta.crossover(close, lowess) bool priceCrossDown = ta.crossunder(close, lowess) bool bullContRaw = enoughBars and upRegime and bullPullbackRecent and priceCrossUp and accelAtr > 0 and not bullRevRaw bool bearContRaw = enoughBars and downRegime and bearPullbackRecent and priceCrossDown and accelAtr < 0 and not bearRevRaw Interpretation of the bullish continuation conditions: The LOWESS slope must already define an uptrend regime. Price must have recently pulled back below the LOWESS line. Price must cross back above the LOWESS line. Acceleration must be positive. A reversal signal takes priority, so continuation does not print if the same bar qualifies as a bullish reversal. Interpretation of the bearish continuation conditions is the exact inverse. 10) Close Confirmation and Cooldown Control The final signal is gated by an optional bar close confirmation and a per-signal cooldown filter. bool gate = confirmClose ? barstate.isconfirmed : true bool bullRev = gate and bullRevRaw and canBullRev(signalState, cooldownBars) bool bearRev = gate and bearRevRaw and canBearRev(signalState, cooldownBars) bool bullCont = gate and bullContRaw and canBullCont(signalState, cooldownBars) bool bearCont = gate and bearContRaw and canBearCont(signalState, cooldownBars) Interpretation: When close confirmation is enabled, signals only become valid after the candle is closed. Cooldown logic prevents repeated printing of the same signal class within a short number of bars. This reduces visual clutter and avoids excessive re-triggering during choppy conditions. 11) Adaptive Band Construction The script can draw an ATR-based envelope around the LOWESS line to provide volatility context. float upperBand = showBand and not na(lowess) ? lowess + atr * bandAtrMult : na float lowerBand = showBand and not na(lowess) ? lowess - atr * bandAtrMult : na Interpretation: The band expands and contracts with ATR. This creates a dynamic visual frame around the LOWESS estimate. It is not a signal by itself, but it helps contextualize the distance between current price and the smoothed trend path. 12) Visual Output and Alerts The LOWESS line changes color according to slope direction, optional labels mark reversal and continuation events, and alert conditions are available for all four signal types. alertcondition(bullRev, "Bullish LOWESS Reversal", "Bullish LOWESS reversal on {{ticker}}") alertcondition(bearRev, "Bearish LOWESS Reversal", "Bearish LOWESS reversal on {{ticker}}") alertcondition(bullCont, "Bullish LOWESS Continuation", "Bullish LOWESS continuation on {{ticker}}") alertcondition(bearCont, "Bearish LOWESS Continuation", "Bearish LOWESS continuation on {{ticker}}") In practical terms, this means the indicator can serve both as a visual discretionary analysis tool and as an alert driven framework for identifying smoothed trend reversals and pullback continuation opportunities with a volatility aware filter structure.
אינדיקטור Pine Script®
מאת ‎UAlgo‎
Hidden Markov Reversal Finder [UAlgo]Hidden Markov Reversal Finder is a regime aware reversal detection indicator that uses a compact 3 state Hidden Markov style filter with online adaptation to classify market conditions and highlight potential top and bottom rotations. The script models price behavior as transitions between three regimes: - Bull Expansion - Balance - Bear Stress Instead of running a heavy Baum Welch retraining loop, this version is designed as a lightweight real time filter. It updates regime probabilities using a transition matrix plus a two dimensional Gaussian emission model built from two normalized observations: Return observation as a smoothed log return z score Volatility observation as a realized volatility z score The indicator runs in its own pane ( overlay=false ) but can optionally paint chart bars and place reversal labels on price using force overlay. It also includes a clean dashboard panel showing the current state, confidence, observation values, score, posterior probabilities, stretch, and the current setup classification. The reversal engine is built around a top rotation and bottom rotation concept. It looks for a probability peak in a regime, then a fade from that peak, combined with momentum flip conditions and a stretch filter measured in ATR units relative to a baseline EMA. Signals are gated by a confidence threshold and a cooldown period to reduce repetitive prints. This makes the indicator useful as a regime driven reversal framework that integrates: State probabilities and confidence Regime score and momentum flip ATR based stretch extremes Peak fade rotation logic Clean visual markers and dashboard transparency 🔹 Features 🔸 1) Three Regime Model The script uses three explicit regimes with distinct roles: Bull Expansion, intended to represent positive drift conditions Balance, intended to represent neutral or mixed drift Bear Stress, intended to represent negative drift and higher stress conditions Each regime has its own mean and variance assumptions for return and volatility, which are then adapted online. 🔸 2) Two Dimensional Observation System (Return and Volatility) The model does not rely on only returns. It uses both: A normalized return feature A normalized volatility feature This helps distinguish clean bullish trends from choppy balance periods, and balance periods from bearish stress regimes. 🔸 3) Transition Matrix with Persistence Controls Users can control how sticky each regime is through persistence settings: Bull persistence Balance persistence Bear persistence The transition matrix is constructed so that most probability remains in the same regime, while the remainder flows into other regimes using asymmetric weights that reflect realistic behavior. 🔸 4) Real Time Bayesian Filter Update Each bar, the model performs: Prediction step using the transition matrix Update step using Gaussian emissions Posterior normalization Active state selection by arg max This produces a smooth probability based regime tracker suitable for live use. 🔸 5) Adaptation After filtering, the model adapts its internal means and variances using a learning rate scaled by posterior responsibility. This allows the state distributions to slowly adjust to changing market conditions without full retraining. This keeps the indicator responsive while still stable. 🔸 6) Regime Score Output The main score line is: Bull posterior minus Bear posterior This produces a continuous signal that ranges between negative and positive values and functions as a regime tilt meter. A confidence ribbon is also plotted as an area band derived from the dominant posterior. 🔸 7) Confidence Gating and Visual Strength Confidence is defined as the largest posterior probability among the three regimes. The script uses confidence to: Gate reversal signals Determine bar tint transparency when bar coloring is enabled Decide whether state shift tags should be printed This reduces noise during low clarity periods. 🔸 8) Rotation Style Reversal Engine The reversal finder is built on rotation logic: A top rotation occurs after a Bull probability peak fades while Bear probability begins to rise A bottom rotation occurs after a Bear probability peak fades while Bull probability begins to rise This is a probabilistic rotation concept rather than a simple oscillator crossover. 🔸 9) Momentum Flip Confirmation Signals require momentum confirmation through: Regime score change direction Return observation crossing a flip threshold This is designed to reduce premature top and bottom calls when the regime probabilities shift but price momentum has not actually flipped. 🔸 10) ATR Based Stretch Filter The script computes stretch as distance from an EMA baseline measured in ATR units. Signals require: Top signals only when stretch is above a positive threshold Bottom signals only when stretch is below a negative threshold This ensures reversal signals occur when price is extended, not when it is near equilibrium. 🔸 11) Cooldown Control A cooldown setting prevents consecutive buy or sell reversal signals from printing too frequently. This is especially useful when the market chops around an extreme and repeatedly triggers partial rotation conditions. 🔸 12) Dashboard Panel A table dashboard displays key information on the last bar: Active state name Confidence Return z score and volatility z score Regime score Posterior probabilities Stretch in ATR units Current setup text such as BUY REVERSAL, SELL REVERSAL, TOP WATCH, BOTTOM WATCH, WAIT This makes the indicator transparent and easy to interpret. 🔸 13) State Tags and Reversal Labels on Chart When enabled, the script prints: State tags such as BULL, BASE, BEAR with arrows Reversal markers with a vertical guide line and bold letter B or S Tooltips include confidence, peak probability, stretch, and current posterior probabilities. 🔸 14) Optional Probability Curves and Bar Coloring Users can toggle: State probability plots Signal markers and dots Dashboard visibility State tag visibility Bar coloring by regime with confidence adjusted transparency This makes the indicator adaptable for minimalist or fully informational workflows. 🔹 Calculations 1) Return Observation Construction The script uses log returns: float logReturn = math.log(close / nz(close , close)) It smooths return with an EMA: float smoothedReturn = ta.ema(logReturn, returnSmoothLength) Then normalizes by the return standard deviation: float returnStdev = math.max(nz(ta.stdev(logReturn, returnZLength), EPS), EPS) float returnObs = clampFloat(smoothedReturn / returnStdev, -obsClamp, obsClamp) Interpretation: Return observation is a clamped z score like feature, where positive values represent bullish return pressure and negative values represent bearish return pressure. 2) Volatility Observation Construction Realized volatility is measured as the standard deviation of log returns: float realizedVol = nz(ta.stdev(logReturn, volLength), EPS) Then it is normalized relative to a baseline EMA and baseline standard deviation: float volMean = nz(ta.ema(realizedVol, volBaselineLength), realizedVol) float volStdev = math.max(nz(ta.stdev(realizedVol, volBaselineLength), EPS), EPS) float volObs = clampFloat((realizedVol - volMean) / volStdev, -obsClamp, obsClamp) Interpretation: Volatility observation is a clamped z score like feature, where higher values indicate volatility expansion relative to baseline. 3) Warmup Logic The model waits for enough history to compute stable normalized observations: int warmupBars = math.max(returnZLength, volBaselineLength) + volLength bool ready = bar_index > warmupBars and not na(returnObs) and not na(volObs) Before ready, the script avoids producing live signals and uses the initial posterior distribution. 4) Transition Matrix Configuration The transition matrix uses persistence values and asymmetric drift splits: From Bull, most drift flows to Balance and a smaller portion to Bear From Bear, most drift flows to Balance and a smaller portion to Bull From Balance, drift splits evenly between Bull and Bear Core setup: this.setTransition(STATE_BULL, STATE_BALANCE, bullDrift * 0.78) this.setTransition(STATE_BULL, STATE_BEAR, bullDrift * 0.22) ... this.setTransition(STATE_BEAR, STATE_BALANCE, bearDrift * 0.78) this.setTransition(STATE_BEAR, STATE_BULL, bearDrift * 0.22) This design makes Balance act like a bridge regime and reduces unrealistic direct flip frequency. 5) Emission Model: 2D Gaussian Density Each state computes an emission probability from return and volatility observations using a 2D Gaussian likelihood: float exponent = -0.5 * ((retDeviation * retDeviation) / retVariance + (volDeviation * volDeviation) / volVariance) float normalizer = 1.0 / (2.0 * math.pi * math.sqrt(retVariance * volVariance)) math.max(normalizer * math.exp(math.max(exponent, -24.0)), EPS) Variances are floored at 0.12 to prevent collapse. 6) Prediction Step The model predicts next probabilities using the transition matrix: predictedProbability += posterior * transition(fromState, toState) Then normalizes the predicted vector so it sums to 1. 7) Filter Update Step The posterior is updated by multiplying predicted probabilities by emission likelihoods: nextPosterior = predicted * emission(state, retObs, volObs) Then normalized. The active state is the arg max of the posterior. 8) Online Adaptation The model updates state means and variances using posterior responsibility times learning rate: float responsibility = posterior * learningRate Means update by moving toward the current observation: nextMuRet = oldMuRet + responsibility * retError nextMuVol = oldMuVol + responsibility * volError Variances update toward squared error: nextVarRet = oldVarRet + responsibility * (retError * retError - oldVarRet) nextVarVol = oldVarVol + responsibility * (volError * volError - oldVarVol) All parameters are clamped to stability ranges so the model does not explode. 9) Regime Score and Confidence Score is defined as: posterior - posterior Confidence is the maximum posterior: posterior These values drive visuals and signal gating. 10) Stretch Calculation in ATR Units Stretch uses an EMA basis of price and measures distance in ATR units: float basis = ta.ema(close, stretchLength) float atrValue = math.max(ta.atr(14), syminfo.mintick) float stretch = (close - basis) / atrValue Top stretch requires: stretch >= stretchThreshold Bottom stretch requires: stretch <= -stretchThreshold This ensures reversals occur when price is statistically extended relative to recent volatility. 11) Probability Peak and Fade Logic The script measures recent peaks for bull and bear probabilities: float bullPeak = ta.highest(bullProb , peakLookback) float bearPeak = ta.highest(bearProb , peakLookback) Fade is peak minus current: bullFade = bullPeak - bullProb bearFade = bearPeak - bearProb Top rotation condition requires: Bull peak above threshold Bull fade above minimum Bear probability rising Bottom rotation requires the mirrored conditions. This captures the idea of regime dominance peaking, then fading as the opposite side begins to regain influence. 12) Momentum Flip Confirmation Momentum down requires: Regime score decreasing Return observation strongly negative below a flip threshold Momentum up requires: Regime score increasing Return observation strongly positive above the flip threshold This prevents signals when probabilities fade but momentum remains neutral. 13) Signal Gating and Cooldown Signals require confidence above the threshold and a cooldown to avoid repeated triggers: confidenceValue >= confidenceThreshold bar_index - lastSignalBar > cooldownBars 14) Buy and Sell Reversal Signals Buy reversal: Bottom rotation Momentum up Bottom stretch Confidence filter Cooldown filter Sell reversal: Top rotation Momentum down Top stretch Confidence filter Cooldown filter A Balance signal is also triggered when the state changes to Balance with sufficient confidence. 15) Visual Outputs The indicator plots: Regime score line with area fill around zero Confidence ribbon as an area band Optional posterior curves for Bull, Balance, Bear Normalized stretch line scaled by the stretch threshold Optional dots on the chart for reversal events Optional bar coloring on the main chart It also prints: Reversal labels B and S with stretch, confidence, and peak probability tooltips State tags on regime shifts A dashboard panel summarizing live state and setup context
אינדיקטור Pine Script®
מאת ‎UAlgo‎
2
Gann Fan [UAlgo]Gann Fan is a structure driven Gann angle overlay that automatically builds a multi line fan from the most relevant recent swing anchor on the chart. Instead of requiring manual drawing, the script detects pivot highs and pivot lows, selects an active anchor based on the latest structure, and projects a full set of classic Gann style ratios from that anchor point. The indicator runs directly on price and is designed to provide a clean visual map of potential dynamic support, resistance, and trend geometry. Once an anchor is chosen, the script draws a nine line fan that includes the key 1x1 line along with slower and faster angle ratios such as 1x8, 1x4, 1x3, 1x2, 2x1, 3x1, 4x1, and 8x1. These lines extend forward in time, creating a structured framework that traders can use for directional bias, reaction zones, and acceleration or deceleration analysis. A major strength of this implementation is that it is not just a static angle pack. The script first builds an alternating pivot structure, filters same side pivots so only the more extreme one is retained, then automatically determines whether the active fan should be bullish or bearish when Auto mode is enabled. It also adds optional visual enhancements such as glow effects, filled fan zones between adjacent angles, angle labels, and an anchor label. The result is a polished automatic Gann Fan tool focused on: Recent swing structure Auto or forced bullish / bearish direction Multi angle projection Visual zone segmentation Clean right side angle labeling 🔹 Features 🔸 1) Automatic Gann Fan Projection The script automatically draws a full Gann fan without requiring manual anchor placement. It detects recent pivots, determines the most relevant active anchor, and projects all fan angles from that point. This makes it useful for traders who want a repeatable, rules based Gann framework rather than hand drawn discretionary lines. 🔸 2) Pivot Based Structural Anchoring The fan is built from confirmed pivot highs and pivot lows using a configurable pivot strength setting. These pivots form the structural basis for the fan, so the projection adapts to actual swing development instead of arbitrary recent highs and lows. 🔸 3) Alternating Swing Logic for Cleaner Structure The script does not blindly store every pivot. It enforces an alternating sequence of highs and lows: If a new pivot is the same type as the most recent stored one, only the more extreme pivot is kept If it is the opposite type, it is appended normally This produces a cleaner swing map and avoids clutter from redundant same side pivots. 🔸 4) Auto, Bullish, or Bearish Fan Direction Users can choose: Auto mode Forced Bullish Forced Bearish In Auto mode, the script decides direction based on which pivot type occurred most recently. This makes the fan respond naturally to the latest structural context. 🔸 5) Full Nine Angle Set The indicator plots a broad set of classic Gann style ratios: 1x8 1x4 1x3 1x2 1x1 2x1 3x1 4x1 8x1 This creates a layered angle framework ranging from shallow to steep, with the 1x1 line visually emphasized as the main reference line. 🔸 6) Highlighted 1x1 Line The 1x1 line receives its own dedicated width and stands out from the rest of the fan. This makes it easier to focus on the central balance angle that many traders treat as the most important Gann reference. 🔸 7) Optional Glow Effect The script can render a wider translucent glow line beneath each fan line. This improves visibility, gives the fan a premium visual style, and helps the angle set stand out on busy charts. 🔸 8) Optional Fan Zones Between Angles When enabled, the script fills the space between adjacent fan lines to create alternating fan zones. These colored bands make it easier to visually read the space between angles as active directional sectors. This is especially useful when treating the fan as a dynamic channel structure rather than only a set of lines. 🔸 9) Right Side Angle Labels Each fan angle can be labeled on the right side using the actual ratio name, such as 1x1 or 4x1 . The label position is user adjustable through the label shift setting. This makes the fan immediately readable without needing to memorize line order. 🔸 10) Anchor Label Support The script can place an anchor label at the origin point of the active fan, showing whether the current projection is bullish or bearish. This helps confirm which structural direction is currently active. 🔸 11) Customizable Line and Label Styling Users can control: Base line width 1x1 line width Glow width Label size Label shift Zone visibility Glow visibility Anchor label visibility This makes the tool flexible for both minimalist and presentation focused layouts. 🔸 12) Structure Memory Control The Max Stored Pivots setting controls how many swing points remain in memory. This helps the script stay efficient while still maintaining enough structural context for reliable anchor selection. 🔹 Calculations 1) Pivot Detection The script identifies structural swing highs and lows using: float ph = ta.pivothigh(high, pivotLen, pivotLen) float pl = ta.pivotlow(low, pivotLen, pivotLen) A pivot is only confirmed after pivotLen bars on both sides, so the stored pivot index is aligned to the actual pivot bar: SwingPoint.new(bar_index - pivotLen, ph, true) SwingPoint.new(bar_index - pivotLen, pl, false) This ensures the fan anchor uses the true swing location, not the later confirmation bar. 2) Alternating Swing Storage The script maintains a swing array that enforces alternating highs and lows: if last.isHigh == candidate.isHigh bool moreExtreme = (candidate.isHigh and candidate.price >= last.price) or (not candidate.isHigh and candidate.price <= last.price) if moreExtreme points.set(n - 1, candidate) else points.push(candidate) Interpretation: If two consecutive pivots are both highs, only the higher high is kept. If two consecutive pivots are both lows, only the lower low is kept. This keeps the swing structure cleaner and more meaningful. 3) Auto Direction Logic In Auto mode, the script chooses bullish or bearish orientation based on which pivot type is most recent: bool autoBull = not lastLow.isNa() and (lastHigh.isNa() or lastLow.idx > lastHigh.idx) Interpretation: If the latest valid pivot is a low, the script favors a bullish fan. If the latest valid pivot is a high, the script favors a bearish fan. The final direction can still be overridden by the Fan Direction input. 4) Bullish Anchor Construction For a bullish fan, the script starts from the most recent low pivot: SwingPoint lastLow = swings.lastPivot(false) Then it looks for the most recent high pivot that occurred after that low: SwingPoint ctrlHigh = swings.lastPivotAfter(true, lastLow.idx) If such a high exists, it becomes the control point. If not, the script uses the current bar and current high: int x2 = ctrlHigh.isNa() ? bar_index : ctrlHigh.idx float y2 = ctrlHigh.isNa() ? high : ctrlHigh.price So the bullish fan is anchored from the latest significant low toward the next available structural high, or toward the live chart if that swing is still developing. 5) Bearish Anchor Construction For a bearish fan, the script starts from the most recent high pivot: SwingPoint lastHigh = swings.lastPivot(true) Then it looks for the most recent low pivot that occurred after that high: SwingPoint ctrlLow = swings.lastPivotAfter(false, lastHigh.idx) If none is found yet, the script falls back to the current bar and current low: int x2 = ctrlLow.isNa() ? bar_index : ctrlLow.idx float y2 = ctrlLow.isNa() ? low : ctrlLow.price So the bearish fan projects from the latest significant high toward the next structural low, or toward the live chart while the move is still unfolding. 6) Base Slope Calculation Once the anchor is defined, the script computes the base slope between anchor point 1 and point 2: (anchor.p2 - anchor.p1) / (anchor.idx2 - anchor.idx1) This base slope is the reference slope used for the 1x1 line before applying the fan ratios. 7) Gann Ratio Projection The script stores these ratios: array.from(0.125, 0.25, 0.333333, 0.5, 1.0, 2.0, 3.0, 4.0, 8.0) These correspond to: 1x8 1x4 1x3 1x2 1x1 2x1 3x1 4x1 8x1 For each ratio, the projected line value at any bar x is: anchor.p1 + m * ratio * (x - anchor.idx1) Where m is the base anchor slope. This means: Ratios below 1 create flatter angles than the base line Ratio 1 creates the 1x1 line Ratios above 1 create steeper angles than the base line 8) 1x1 Emphasis The script gives the 1x1 line special treatment: It uses mainLineWidth instead of baseLineWidth Its glow can also be slightly wider than the other lines This makes the central balance angle the visually dominant line in the fan. 9) Line Drawing and Extension Each fan line is drawn from the anchor origin to the control index, then extended to the right: line.new( active.idx1, active.p1, active.idx2, y2, xloc = xloc.bar_index, extend = extend.right, ... ) This means the visible geometry is anchored in actual structure, but the line continues into the future as a projected guide. 10) Glow Layer Logic If glow is enabled, the script first draws a wider translucent line underneath the main line: line.new(... color = glowColor, width = gWidth) Then it draws the normal fan line on top. This creates a soft highlight effect without changing the underlying geometry. 11) Angle Label Placement If labels are enabled, the script places each label at a future bar location: int xLabel = math.min(bar_index + labelShiftBars, bar_index + 500) float yLabel = active.priceAt(ratio, xLabel) This means the label stays attached to the correct projected fan angle while remaining offset from the live candles for readability. 12) Fan Zone Fill Logic When zone fill is enabled, the script creates a fill between each adjacent pair of fan lines: linefill.new(l1, l2, zoneColor) The fill transparency alternates slightly from one band to the next: int zoneAlpha = i % 2 == 0 ? 91 : 95 This creates subtle separation between fan sectors and improves visual depth. 13) Anchor Label Logic If enabled, the script prints a label at the anchor origin: string dirText = active.bullish ? "Bullish Gann Fan" : "Bearish Gann Fan" This provides immediate confirmation of which structural direction is currently driving the fan.
אינדיקטור Pine Script®
מאת ‎UAlgo‎
1
BK AK-HA Window🖥️ BK AK–HA PnF Window 🖥️ 🙏 All glory to G-d Respect to AK — discipline, patience, clean execution. HA Window is a compact “analysis panel” that lives on your chart. It lets you toggle between two different ways of reading structure: Heikin Ashi Window (normalized, consistent OB/OS framework) Point & Figure Window (clean X/O structure with targets + pattern logic) This is not financial advice and it’s not a promise of results. It’s a visual decision tool designed to help you track trend, structure, and reaction quality with fewer distractions. 1) Quick Start (60 seconds) Content → Heikin Ashi if you want trend + turning-point context inside a fixed OB/OS framework. Content → Point & Figure if you want clean structure (X/O columns), break/rotate behavior, and objective counting tools. Keep Lock to Last Bar = ON and adjust: Width (candles) Height (ATR multiple or % range) Future Offset to park the panel neatly to the right. 2) Mode A — Heikin Ashi Window (Normalized Oscillator Candles) This mode takes Heikin Ashi OHLC and maps it into a stable window range with: 0 / Overbought / Oversold levels Optional zone fills for quick “where are we?” context HA candle rendering with spacing options (1-bar or centered 2-bar mode) Built-in confirmations (optional) EMA overlay on the HA close (bias + pullback structure) Pivot highs/lows (structure markers) Buy/Sell markers (HA color flip events) Divergence detection (RSI or MFI) with swing filters (so it doesn’t spam) Volume spike highlighting (Volume ROC) to flag “activity candles” Session shading (Asia / London / RTH) for time-context Pattern recognition (optional) The window can tag common HA behaviors like: Flat tops/bottoms (level sensitivity) Acceleration vs deceleration Compression/inside bars Absorption / exhaustion signatures These are presented as context labels, not “guaranteed signals.” 3) Mode B — Point & Figure Window (X/O Structure Map) PnF is about structure without time noise. This mode builds X/O columns and renders them inside a clean grid. Auto box sizing (important) Instead of forcing one ATR length, the script can evaluate several ATR candidates and select the one that best matches price behavior over the chosen lookback. That means: less arbitrary box size guessing more consistent columns across symbols/timeframes What’s included (optional) PnF reversal detection (X→O / O→X) + alert conditions Pattern recognition (double/triple breaks, ascending/descending triples, catapults) Gann/PnF counting tools Horizontal count (congestion width → projected objectives) Vertical count (column height → objective projection) 45° trend lines (classic PnF rails) Congestion zone box (where acceptance is forming) Price level labels (turns the panel into a quick S/R ladder) Volume weighting (opacity or glyph size) Column “box count” + time-in-column quick read on thrust vs rotation/absorption behavior MTF + LTF direction badges alignment = higher confidence context disagreement = “slow down and verify” 4) How to Use It (simple workflow) Step 1 — Bias: HA mode: EMA + candle color + zone location PnF mode: column direction + HTF badge Step 2 — Location: HA mode: OB/OS + pivots PnF mode: congestion zones + price level ladder Step 3 — Confirmation: HA flip + divergence/pattern context PnF reversal/pattern + timeframe alignment Step 4 — Management: Use structure (pivots / PnF rails / count objectives) to manage expectations Don’t treat the panel as a “prediction machine” — treat it as a clarity tool 5) Settings Suggestions For fast intraday: Smaller window width, keep PnF rows capped for readability, let auto-box sizing do the work. For higher timeframe: Increase correlation lookback + window width Use MTF badge to stay aligned with the bigger structure 🖥️ BK AK–HA Window 🖥️
אינדיקטור Pine Script®
מאת ‎Ki11a_B‎
Daily MGI - OnlyFlowMGI (Market Generated Information) plots key daily reference levels used by auction market and order flow traders. It draws Prior Day High, Low, Mid, and Close, Overnight High/Low, Opening Range, Initial Balance, RTH VWAP, and Value Area levels — all with price labels extending to the current bar. Each line originates from the bar where the level was actually printed, giving you immediate visual context on where the market established its boundaries. Features: - Full Day (ETH) or RTH Only mode for prior day levels - Configurable Opening Range and Initial Balance durations with ±50/100/150/200% extensions - RTH VWAP and session midline - Approximate prior day Value Area (VAH/VAL/POC) - All levels togglable with customizable colors and label sizes - Lines draw from their origin point to the current bar Built as a lightweight alternative to paid order flow packages. Designed for futures (ES, NQ, etc.) but works on any instrument with defined RTH/ETH sessions. Adjust the RTH and ETH session times in settings to match your market.
אינדיקטור Pine Script®
מאת ‎ofderk‎
1