Rozpocznij

Profil Wolumenu

Market Structure Volume Profiles [Kioseff Trading]Hello traders and friends! Introducing: "Market Structure Volume Profiles". This script combines market structure with volume profiling and CVD to show how volume develops inside each structural changes of the market. Instead of building one continuous profile across a session, this script creates a new volume profile for each completed BoS or CHoCH, allowing you to study the internal auction of each behavioral regime independently. 🔹Features Detects and displays BoS and CHoCH Builds a dedicated volume profile for each new structure Displays profiles in Stacked or Split mode Optional Mini Profile mode for a compact structure profile view Shows buy-side and sell-side volume distribution Displays POC for each profile Optional extended POC and naked POC tracking Displays Value Area (VA) for each completed structure Tracks and plots CVD by structural leg Optional market structure candle coloring Optional structure statistics label Uses lower timeframe data to build more detailed internal volume distribution 🔹How it works This script tracks market structure and recalculates volume profiles for each structural change. Whenever price confirms a Break of Structure (BoS) or Change of Character (CHoCH), the volume accumulated during that completed leg is organized into a profile. This allows you to examine how volume was distributed throughout the move, where the heaviest participation occurred, and whether buying or selling dominated the leg. Rather than asking only where price moved, this script helps answer: where volume concentrated during the move whether the move was supported by participation where value developed inside the structural range how buy and sell volume were distributed across price Each profile is built from lower timeframe data so that the structural leg can be broken into price levels and analyzed internally. 🔹What it shows 🔸Market Structure The script identifies major structural events and labels them as: BoS CHoCH Profiles to be tied directly to meaningful structural transitions. 🔸Volume Profile by Structure Each completed structural leg gets its own profile, showing: buy volume at each level sell volume at each level total participation across the leg the internal shape of the auction This makes it easier to compare continuation legs against reversal legs. You can color BoS and CHoCH generated profiles distinctly. Making it easier to trach where each profile sits inside broader market action. 🔸Point of Control (POC) The script can display the POC of each structural profile, showing the price level with the highest traded volume during that leg. The script can also display the Value Area for each profile, helping identify where the majority of volume was concentrated during the structural move. 🔸CVD The script tracks Cumulative Volume Delta throughout the current structure and plots it in the pane. CVD can be reset by: CHoCH BoS + CHoCH Day Week This makes it possible to study delta behavior in a structural context rather than only in a session-based one. 🔸Structure Stats Optional structure statistics can be displayed, including: Range High Low Buy volume Sell volume Delta Return This gives a summary of the completed structural move. 🔸Why use it This script is designed for traders who want to combine: market structure volume profiling delta/CVD auction logic Because profiles are anchored to structure instead of session time, they can help reveal differences between: strong continuation legs weak continuation legs reversal legs imbalanced breakouts balanced rotations 🔸Mini Profiles The indicator has two separate drawing methods for each VP. The detailed profile is used when the structural move has enough bar data to create a detailed profile. When not enough data exists, a mini profile is used. You can select only to use mini profiles if you prefer the style. The internal logic to calculate each volume profile is similar. However, the detailed profile "scrunches" when not enough bar data exists to calculate it on - that's when mini profile takes over. 🔸Split Profile You can also choose to show split volume profiles. This is more similar to how a delta profile is shown. This is a styling preference only. Rows Limit Detailed profiles can use up to 500 rows. Higher values were giving a "response too large" error, so I restricted the max to 500. 🔹Summary That’s about it! The goal of this script is simply to combine market structure with volume profiles and CVD so you can see how volume develops inside each structural move instead of across arbitrary time windows. By anchoring profiles to BoS and CHoCH, you can study how participation builds during continuations, reversals, and rotations - and get a better feel for how each move was actually formed internally. Hope you find it useful (: Thank you guys and thank you TradingView!
Wskaźnik Pine Script®
od KioseffTrading
5
Sessions & VP with prev session VP & daily/weekly opensThis indicator combines two fully independent volume profile pipelines into a single overlay — one tracking the current session in real time, and one tracking the previous session — along with optional forex session boxes and daily/weekly open levels. Both volume profiles are built from lower-timeframe intraday bar data (request.security_lower_tf), meaning each profile reflects the true distribution of volume across the session's price range rather than a single-bar approximation. The session range is divided into equal price bins, and each bin's volume is split into bullish and bearish components using a proportional wick/body weighting method. The Point of Control (POC), Value Area High (VAH), and Value Area Low (VAL) are calculated using standard Market Profile methodology. The previous session VP is displayed as an overlay across the current session's bar range, making it easy to compare where the prior session's volume clustered against current price action without cluttering historical candles. WHAT IT SHOWS Current session: a live-updating volume profile drawn across the current session as it builds, with POC, VAH, VAL, and an optional session box. Previous session overlay: the most recently completed session's volume profile, drawn across the current session's bar range. Levels are prefixed with "P:" to distinguish them from current session levels (prefixed "C:"). Forex session boxes: optional high/low range boxes for the Tokyo, London, and New York sessions. These show the range only — no volume profile is calculated for forex sessions. Open levels: a 6 PM ET daily open line and a 6 PM Sunday weekly open line, both extending forward from the open price. These mark the start of the futures trading day and trading week respectively, which are commonly used reference levels in US equity index and futures trading. HOW THE VOLUME PROFILE IS CALCULATED Each session's price range (high to low) is divided into a user-defined number of equal bins. For every intraday bar within the session, volume is distributed across the bins it touches. Volume is further split into bullish (up-close) and bearish (down-close) by weighting the body and wick portions of each bar separately. This approach gives a more accurate picture of buyer and seller activity at each price level than simply assigning all of a bar's volume to a single bin. The POC is the bin with the highest total volume. The Value Area expands outward from the POC, adding the next highest adjacent bin on either side, until cumulative volume reaches the user-defined percentage (default 70%). Three display modes control how the histogram bars are rendered: - Mode 1: bullish volume only, extending right from the session left edge - Mode 2: bullish and bearish stacked left-to-right (standard side-by-side view) - Mode 3: bullish extending right and bearish extending left from the session edge (mirrored) SETTINGS --- Current Session --- Session Type — the period the current session covers. Options: Tokyo, London, New York, Daily, Weekly, Monthly, Quarterly, Yearly. Show Volume Profile — toggle the histogram bars on/off. Show POC — toggle the Point of Control line. Show VAH and VAL — toggle the Value Area boundary lines. Show Value Area Box — draws a filled rectangle covering the Value Area range. Show Live Zone — when on, the current session profile updates in real time on every bar. When off, profiles are only drawn for completed sessions. Show Session Box — draws a dashed outline box around the full session range. Show Session Label — displays the session type name at the top of the session. Resolution (default 30, min 5) — number of equal price bins. More bins gives finer detail. Note that each bin uses up to 2 boxes (one green, one red). With 30 bins and both current and previous sessions visible, up to 120 boxes are used, well within TradingView's 500-box limit. Value Area % (default 70) — percentage of total session volume that defines the Value Area. Bar Mode — controls the histogram layout. Mode 1 (bulls only), Mode 2 (side-by-side), Mode 3 (mirrored). Profile Data — Volume uses standard bar volume. Open Interest uses the change in open interest (futures only). Smooth Volume — applies a 5-period EMA to volume before building the profile. --- Current Session Appearance --- Up Volume color — fill color for bullish bins. Down Volume color — fill color for bearish bins. Value Area Box color — fill color for the Value Area Box if enabled. POC, VAH, VAL — line color and thickness for each level. Box — session box outline color and thickness. --- Current Level Labels --- Show Level Labels — toggles the POC/VAH/VAL text labels on/off. POC Label, VAH Label, VAL Label — customise the text shown next to each level. Current session labels are prefixed "C:". Label Size — tiny, small, normal, or large. Label Text color. --- Previous Session --- All settings mirror the Current Session group above, with the following differences: Show Overlay — when on, the previous session's volume profile is drawn across the current session's bar range. When off, no previous session profile is shown. Previous session level labels are prefixed "P:" to distinguish them from current session levels. --- Forex Sessions --- Show Forex Session Boxes — when on, draws high/low range boxes for the Tokyo (midnight-9 UTC), London (7-16 UTC), and New York (13-22 UTC) sessions as each one closes. No volume profile is calculated for these — range only. --- Open Levels --- 6 PM Daily Open — draws a horizontal line at the open price of the 6 PM ET bar, which marks the start of the US futures trading day. Line color, thickness, and style (solid, dotted, dashed) are configurable. Label toggle included. Weekly Open (6 PM Sunday) — same as above but fires only on the Sunday 6 PM ET bar, marking the weekly futures open. Independently configurable color, thickness, style, and label. IMPORTANT NOTES - Best used on intraday timeframes (1m to 4H) so that lower-timeframe data is available to build accurate profiles. On daily or higher timeframes the profile will use only one bar per session and will be approximate. - The previous session overlay requires at least two completed sessions of history before it appears. - The current and previous session types are set independently and can be different (e.g. current = Daily, previous = Weekly). - Open levels use America/New_York timezone regardless of chart timezone settings. - Forex session boxes use UTC-based session detection. Results may vary on symbols with non-standard trading hours. Credits: @LeviathanCapital for the excellent market sessions and volume profiles indicator on which this is based
Wskaźnik Pine Script®
od lucymatos
1
VP History WidgetVP History Widget plots a user-defined number of completed Volume Profiles (VPs) directly to the right of your price chart in real price coordinates. Each profile is calculated from the actual intraday bars that made up that session — giving an accurate picture of where volume was distributed across the price range of each past session. The sessions available are daily, weekly and monthly volume profiles. Unlike volume profiles drawn on top of historical candles, this widget repositions all profiles into future bar space to the right of the current price, keeping your chart clean and uncluttered. Because everything is drawn in real price coordinates there is no distortion — profiles appear at exactly the correct size and price level relative to your chart. HOW IT WORKS Volume profiles are built using lower-timeframe intraday bar data (request.security_lower_tf), so the profile reflects the actual volume distribution across the session rather than a single-bar approximation. The session's price range is divided into a user-defined number of equal bins. For each bin, volume is split into bullish and bearish components using a proportional wick/body weighting method — the same approach used in professional volume profile tools. This data is stored in a rolling buffer and drawn on the last bar as a side-by-side histogram. The Point of Control (POC) is the bin with the highest total volume. The Value Area High (VAH) and Value Area Low (VAL) are calculated by expanding outward from the POC until cumulative volume reaches the user-defined Value Area percentage (default 70%), following standard Market Profile methodology. WHAT IT SHOWS - Green histogram bars: volume from bullish (up-close) bars per price bin - Red histogram bars: volume from bearish (down-close) bars per price bin - POC line: price level with the highest volume for that session - VAH / VAL lines: upper and lower boundaries of the Value Area - Session labels: identify which session each profile belongs to (e.g. Daily -1, Daily -2) TYPICAL USE CASES - Identifying high-volume nodes (HVNs) and low-volume nodes (LVNs) from prior sessions as potential support and resistance - Comparing volume distribution across multiple sessions to gauge market acceptance at price levels - Spotting sessions where price moved quickly through a range — thin profiles indicate low acceptance and potential reversion zones - Keeping your chart clean by comparing N previous session VPs without overlapping historical candles SETTINGS Show Widget — master on/off toggle. Offset from price (default 10, range 1-50) — bars of space between the last candle and the first VP. Increase if profiles overlap your candles when zoomed out. VP Width (default 10, range 3-40) — horizontal width of each volume profile in bars. Wider makes individual bins easier to read. Gap between VPs (default 3, range 1-10) — spacing in bars between adjacent profiles. Number of Sessions (default 5, range 1-10) — how many completed sessions to display. The most recent is on the right (marked with a triangle), oldest on the left. Session Timeframe (Daily / Weekly / Monthly) — the period each volume profile covers. VP Bins (default 50, range 5-50) — number of equal price buckets the session range is divided into. More bins gives finer resolution. With 5 sessions the maximum is 50 bins (5 x 50 x 2 = 500 boxes, TradingView's limit). With 10 sessions keep bins at 20 or below. Value Area % (default 70, range 1-100) — percentage of total session volume that defines the Value Area. 70 is the standard Market Profile convention. Profile Data (Volume / Open Interest) — Volume uses standard bar volume. Open Interest uses the change in OI, which requires a futures symbol with an OI feed. Smooth Volume (default off) — applies a 5-period EMA to volume before building the profile, smoothing out single-bar spikes. Up Volume color — fill color for bullish volume bins. Down Volume color — fill color for bearish volume bins. POC Line color — color of the Point of Control line. VAH / VAL color — color of the Value Area boundary lines. Separator color — color of the thin vertical line on the left edge of each VP slot. Show POC — toggle the POC line and label on/off. Show VAH / VAL — toggle Value Area boundary lines and labels on/off. Show Labels — toggle all text labels on/off for a minimal look. BOX LIMIT REFERENCE TradingView limits indicators to 500 boxes. Each bin draws up to 2 boxes (green + red). Use this as a guide: 5 sessions — max 50 bins (500 boxes, at the limit) 6 sessions — max 40 bins (480 boxes) 7 sessions — max 35 bins (490 boxes) 8 sessions — max 30 bins (480 boxes) 9 sessions — max 27 bins (486 boxes) 10 sessions — max 24 bins (480 boxes) If you see profiles with missing bars, reduce VP Bins or Number of Sessions. IMPORTANT NOTES - Best used on intraday chart timeframes (1m to 4H). When the chart timeframe equals the session timeframe, only a single candle is available and the profile will be approximate. - The widget requires at least N+1 completed sessions of history to populate. On first load it may take a moment to build. - Open Interest mode will silently fall back to volume on symbols without an OI feed.
Wskaźnik Pine Script®
od lucymatos
1
Liquidity Structure & Order Flow [UAlgo]Liquidity Structure & Order Flow is a range based market participation tool that combines a custom volume profile, value area analysis, liquidity void detection, and unusual volume tagging into a single chart overlay. Its goal is to show not only where volume has concentrated across price, but also how that activity was distributed between estimated buying pressure and selling pressure inside the recent market structure. The script begins by scanning a rolling lookback range, then divides that vertical price space into a configurable number of bins. Each bin becomes a price segment that stores estimated buy volume, sell volume, and total volume. From there, the script builds a profile that highlights the Point of Control, the value area, and the internal order flow balance across the studied range. What makes this indicator especially useful is that it does more than draw a standard profile. It also identifies areas where participation is abnormally thin relative to both the Point of Control and local neighboring bins. These low participation areas are marked as liquidity voids, helping the user see where the market moved through price with relatively little acceptance. In addition, the script monitors the current bar for unusually large activity using a volume z score and a directional delta ratio filter. When a bar shows both exceptional size and meaningful directional imbalance, the script prints a bubble style marker above or below price. This gives the user a way to spot unusual participation events as they happen. The result is a tool that can be used for profile analysis, liquidity mapping, imbalance recognition, and structural context. It helps answer several practical questions at once: where the market accepted price, where it rejected or skipped through price, where the strongest concentration of activity formed, and whether recent candles are showing exceptional directional participation. 🔹 Features 🔸 Custom Range Based Volume Profile The script constructs a manual volume profile over the selected lookback period. Instead of relying on a built in profile engine, it divides the recent range into user defined price bins and allocates each bar’s volume into those bins. This gives full control over how the profile is built and how the final distribution is interpreted. 🔸 Buy Volume and Sell Volume Estimation Every candle contributes both buy side and sell side estimates. The script uses the candle’s open, high, low, and close to derive a buy volume ratio, then splits total volume into buy volume and sell volume accordingly. This creates a practical order flow style approximation that is more informative than total volume alone. 🔸 Proportional Price Overlap Allocation When a candle spans multiple bins, the script distributes its buy volume, sell volume, and total volume proportionally according to how much of the candle overlaps each bin. This produces a more realistic internal structure than simply dropping the full bar volume into one price row. 🔸 Point of Control Detection The indicator finds the bin with the highest total volume and marks it as the Point of Control. This gives the user an immediate view of the strongest participation price inside the studied range. 🔸 Value Area Calculation After the Point of Control is found, the script expands upward and downward through neighboring bins until the selected percentage of total profile volume is captured. This defines Value Area High and Value Area Low, allowing the user to distinguish the central acceptance region from the rest of the range. 🔸 Profile Coloring by Participation Side The profile is drawn as stacked horizontal boxes showing estimated buy side participation and sell side participation inside each row. Bins inside the value area use stronger coloring, while bins outside the value area use softer coloring. This makes the internal structure easy to read visually. 🔸 Liquidity Void Detection The script scans for bins with unusually weak participation outside the value area. A bin qualifies as a liquidity void candidate only if it is both small relative to the Point of Control and also weaker than its nearby neighbors. Consecutive weak bins are grouped into a larger void zone and labeled directly on the chart. 🔸 Unusual Volume Bubble Markers Current bar activity is evaluated using a long period volume average and standard deviation. If the bar’s volume is statistically unusual and its estimated delta ratio is large enough, the script prints a directional bubble marker. Positive directional activity is shown below price, and negative directional activity is shown above price. 🔸 Optional Profile and Void Display The user can independently control whether the volume profile, liquidity voids, and unusual volume markers are shown. This makes the script flexible enough for both full structure analysis and lighter chart layouts. 🔸 Extendable Structural Levels The Point of Control, Value Area High, and Value Area Low can be drawn as either compact structure references or extended lines, depending on the chosen setting. This allows the user to decide whether the levels should function as local annotations or ongoing chart references. 🔸 Useful for Acceptance and Imbalance Analysis The combination of profile structure, value area, void zones, and unusual activity markers gives the indicator a broader purpose than a standard profile. It can help identify accepted price, skipped price, directional participation, and possible future reaction areas. 🔹 Calculations 1) Building the Volume Profile Container type PriceBin float price float buyVol = 0.0 float sellVol = 0.0 float totalVol = 0.0 type VolumeProfile float highPrice = na float lowPrice = na float binSize = na array bins float pocPrice = na float pocVol = 0.0 float vah = na float val = na float totalVol = 0.0 This is the foundation of the whole script. Each PriceBin stores one price level area inside the profile. It contains: the row midpoint price, estimated buy volume, estimated sell volume, and total volume. The VolumeProfile structure stores the full profile state: the highest price of the lookback range, the lowest price of the lookback range, the bin size, the array of bins, and the final analytical values such as Point of Control, Value Area High, Value Area Low, and total profile volume. So before any analysis happens, the script defines a complete custom data model for price distribution and order flow style estimation. 2) Initializing the Bins Across the Lookback Range method initBins(VolumeProfile this, float h, float l, int numBins) => this.highPrice := h this.lowPrice := l this.binSize := (h - l) / numBins this.pocPrice := na this.pocVol := 0.0 this.totalVol := 0.0 this.vah := na this.val := na this.bins := array.new() for i = 0 to numBins - 1 this.bins.push(PriceBin.new(price = l + i * this.binSize + (this.binSize / 2))) This method creates the working profile rows. First, it stores the high and low of the selected lookback period. Then it calculates binSize , which is the vertical price height of each row. That is simply the full range height divided by the number of bins. After resetting all major profile outputs, the script creates a fresh bin array. Each new bin is assigned a midpoint price: l + i * this.binSize + (this.binSize / 2) That midpoint becomes the visual and analytical center of the row. In practical terms, this is where the script transforms the raw market range into a structured ladder of price rows that can later receive allocated volume. 3) Locating the Correct Bin for a Price method getBinIndex(VolumeProfile this, float p) => if na(this.lowPrice) or na(this.binSize) or this.binSize == 0 0 else int idx = math.floor((p - this.lowPrice) / this.binSize) math.max(0, math.min(idx, this.bins.size() - 1)) This helper method maps any price to its correct row index inside the profile. It works by measuring how far the price sits above the profile low, then dividing that distance by the bin size. The result is the raw row index. After that, the value is clamped so it always stays inside the valid bin range. This is important because the script repeatedly needs to know which rows are touched by each candle’s low and high. Without this mapping step, the profile could not distribute volume across price space correctly. 4) Estimating Buy Volume and Sell Volume From Candle Structure float hlR = high - low float bVR = hlR == 0 ? 0.5 : (close - low + high - open) / (2 * hlR) float currentBuyVol = volume * bVR float currentSellVol = volume * (1 - bVR) float delta = currentBuyVol - currentSellVol This snippet explains how the script approximates order flow direction on the current bar. First, it measures the candle range from high to low. Then it computes a buy volume ratio using the relative location of the open and close inside that range: (close - low + high - open) / (2 * hlR) This ratio becomes a practical estimate of how much of the bar’s total volume behaved like buying pressure versus selling pressure. If the candle closes stronger and opens higher inside its range, the ratio leans more bullish. If the candle structure is weaker, the ratio leans more bearish. That ratio is then used to split total volume into: currentBuyVol and currentSellVol Finally, the script calculates delta as the difference between estimated buy volume and estimated sell volume. This is not true transaction tagged exchange delta, but it is a useful chart based directional participation model. 5) Distributing Candle Volume Across Touched Price Rows method addBarVolume(VolumeProfile this, float h, float l, float c, float o, float v) => float hlRange = h - l float buyVolRatio = hlRange == 0 ? 0.5 : (c - l + h - o) / (2 * hlRange) float buyV = v * buyVolRatio float sellV = v * (1 - buyVolRatio) int startIdx = this.getBinIndex(l) int endIdx = this.getBinIndex(h) for i = startIdx to endIdx if i >= 0 and i < this.bins.size() PriceBin b = this.bins.get(i) float binTop = b.price + (this.binSize / 2) float binBot = b.price - (this.binSize / 2) float overlapTop = math.min(h, binTop) float overlapBot = math.max(l, binBot) float overlap = math.max(0.0, overlapTop - overlapBot) float weight = hlRange > 0 ? overlap / hlRange : (1.0 / (endIdx - startIdx + 1)) b.buyVol += buyV * weight b.sellVol += sellV * weight b.totalVol += v * weight this.bins.set(i, b) this.totalVol += v * weight This is one of the most important calculations in the entire script. For each candle inside the lookback period, the script first computes estimated buy volume and sell volume. Then it finds which profile rows are touched by the candle’s low and high. For every touched row, it measures how much of the candle overlaps that specific row. That overlap becomes a weighting factor: weight = overlap / hlRange If a candle overlaps a row heavily, that row receives a larger share of the bar’s volume. If the overlap is small, the row receives only a small share. The script then adds weighted buy volume, weighted sell volume, and weighted total volume into that bin. This is much more realistic than assigning all volume to a single row because it respects the actual price space the candle traveled through. 6) Determining the Point of Control method calcValueArea(VolumeProfile this, float pct) => float midPrice = (this.highPrice + this.lowPrice) / 2 float maxVol = -1.0 float bestPrice = na int pocIdx = -1 for i = 0 to this.bins.size() - 1 PriceBin b = this.bins.get(i) if b.totalVol > maxVol maxVol := b.totalVol bestPrice := b.price pocIdx := i else if b.totalVol == maxVol and maxVol > 0 if math.abs(b.price - midPrice) < math.abs(bestPrice - midPrice) bestPrice := b.price pocIdx := i this.pocVol := maxVol this.pocPrice := bestPrice This is the first phase of the value area calculation. The script scans all bins and finds the row with the greatest total volume. That row becomes the Point of Control. If two rows have the same maximum volume, the script breaks the tie by choosing the one closer to the middle of the full lookback range. That tie handling matters because it avoids unstable selection when multiple bins have identical strength. After the winning row is found, the script stores: the Point of Control volume in pocVol and the Point of Control price in pocPrice So the Point of Control is not simply a visual midpoint. It is the actual strongest participation row in the profile. 7) Expanding Upward and Downward to Build the Value Area float targetVol = this.totalVol * pct / 100.0 float currentVol = 0.0 if pocIdx >= 0 and pocIdx < this.bins.size() currentVol := this.bins.get(pocIdx).totalVol int upIdx = pocIdx + 1 int dnIdx = pocIdx - 1 while currentVol < targetVol and (upIdx < this.bins.size() or dnIdx >= 0) float upVol = upIdx < this.bins.size() ? this.bins.get(upIdx).totalVol : -1.0 float dnVol = dnIdx >= 0 ? this.bins.get(dnIdx).totalVol : -1.0 After finding the Point of Control, the script calculates the target volume required for the value area. For example, if the input is 70 percent, the target becomes 70 percent of total profile volume. The expansion begins from the Point of Control row itself. currentVol starts with the Point of Control row’s own total volume. Then the script looks one row up and one row down, repeatedly expanding until the accumulated volume reaches the target. This is the standard logic of building a value area around the strongest participation center. 8) Deciding Whether to Expand Up or Down if upVol > dnVol and upVol != -1.0 currentVol += upVol upIdx += 1 else if dnVol > upVol and dnVol != -1.0 currentVol += dnVol dnIdx -= 1 else if upVol == dnVol and upVol != -1.0 if currentVol + upVol > targetVol if math.abs(this.bins.get(upIdx).price - midPrice) < math.abs(this.bins.get(dnIdx).price - midPrice) currentVol += upVol upIdx += 1 else currentVol += dnVol dnIdx -= 1 else currentVol += upVol + dnVol upIdx += 1 dnIdx -= 1 This block decides which side to include next in the value area. If the row above has more volume than the row below, the script expands upward. If the row below has more volume, it expands downward. If both sides are equal, it uses distance to the overall midpoint as a tie breaker when necessary. This is important because value area growth should follow participation strength, not arbitrary direction. The final result is a value area that naturally wraps around the highest volume concentration. 9) Final VAH and VAL Assignment int finalUpIdx = math.max(pocIdx, upIdx - 1) int finalDnIdx = math.min(pocIdx, dnIdx + 1) this.vah := finalUpIdx < this.bins.size() ? this.bins.get(finalUpIdx).price : this.highPrice this.val := finalDnIdx >= 0 ? this.bins.get(finalDnIdx).price : this.lowPrice Once expansion is complete, the script converts the final included rows into value area boundaries. The highest included row becomes Value Area High. The lowest included row becomes Value Area Low. These values define the central price zone where the chosen percentage of the profile’s total volume was traded. So VAH and VAL are directly derived from the row by row structure of the profile, not from any fixed percentage of price range. 10) Detecting Unusual Volume Activity float volSma = ta.sma(volume, 200) float volStdev = ta.stdev(volume, 200) float zScore = volStdev == 0 ? 0 : (volume - volSma) / volStdev float deltaRatio = volume > 0 ? math.abs(delta) / volume : 0 bool isUnusual = zScore > zScoreThreshold and deltaRatio >= deltaRatioThreshold This block evaluates whether the current bar is unusually active. First, the script computes a 200 period average volume and standard deviation. Then it transforms the current bar’s volume into a z score, which shows how many standard deviations the bar stands above normal background activity. Next, it calculates deltaRatio , which measures how large the directional imbalance is relative to total volume. A bar is marked unusual only if both conditions are true: the volume is statistically large enough, and the directional imbalance is meaningful enough. This double filter helps reduce false signals from large but directionless bars. 11) Printing Unusual Volume Bubbles if showUnusual and isUnusual string lblText = (delta > 0 ? "🟢 " : "🔴 ") + str.tostring(math.round(volume)) color lblColor = delta > 0 ? color.new(color.green, 0) : color.new(color.red, 0) label uLbl = label.new(bar_index, delta > 0 ? low : high, text=lblText, style=label.style_none, textcolor=lblColor, yloc=delta > 0 ? yloc.belowbar : yloc.abovebar, size=size.small) When an unusual bar is detected, the script prints a directional marker. If estimated delta is positive, the bubble is shown below price in green. If estimated delta is negative, the bubble is shown above price in red. The displayed text also includes the rounded volume value. This allows the user to quickly see both direction and size of the unusual participation event. So these markers are not random momentum tags. They specifically highlight bars where both participation size and directional imbalance stand out. 12) Rebuilding the Profile on the Last Bar float highestPrice = ta.highest(high, lookback) float lowestPrice = ta.lowest(low, lookback) if barstate.islast and bar_index >= lookback - 1 profile.initBins(highestPrice, lowestPrice, rows) for i = 0 to lookback - 1 profile.addBarVolume(high , low , close , open , volume ) profile.calcValueArea(vaPct) This is the main execution block for the profile. First, the script finds the highest high and lowest low across the chosen lookback window. That defines the total vertical space of the analysis. Then, on the last visible bar, it: initializes the bins, loops through every candle inside the lookback, adds each candle’s weighted volume into the profile, and finally calculates the value area. Running this only on the last bar is efficient because the full profile is a visual structure based on the current lookback window. It does not need to be redrawn historically on every past bar. 13) Scaling and Drawing the Profile Histogram float maxVol = profile.pocVol float allVols = array.new_float() for i = 0 to profile.bins.size() - 1 allVols.push(profile.bins.get(i).totalVol) float avgVol = allVols.avg() float stdVol = allVols.stdev() float clampedMaxVol = math.max(math.min(maxVol, avgVol + (stdVol * 2)), 0.000001) Before drawing the profile, the script prepares a safer scaling reference. Instead of using raw Point of Control volume alone without adjustment, it clamps the maximum drawable scale using the average row volume plus two standard deviations. This helps prevent a single extreme row from making the rest of the profile look too compressed. In practical terms, this means the visual histogram remains readable even when one row is exceptionally dominant. 14) Drawing Buy Side and Sell Side Inside Each Row int buyLen = math.round((b.buyVol / b.totalVol) * (drawVol / clampedMaxVol) * profileWidth) int sellLen = math.round((b.sellVol / b.totalVol) * (drawVol / clampedMaxVol) * profileWidth) bool inVA = b.price <= profile.vah and b.price >= profile.val bool isPocRow = math.abs(b.price - profile.pocPrice) <= profile.binSize * 0.5 int x1 = profileRight int x2 = x1 - buyLen if buyLen > 0 box bB = box.new(x1, topP, x2, botP, border_color=c_border, bgcolor=c_buy) int x3 = x2 int x4 = x3 - sellLen if sellLen > 0 box bS = box.new(x3, topP, x4, botP, border_color=c_border, bgcolor=c_sell) This is the actual profile drawing logic. For each row, the script determines how much of the row’s total activity came from estimated buy volume and how much came from estimated sell volume. It then converts those fractions into horizontal lengths. The buy portion is drawn first, then the sell portion continues from the end of the buy section. This creates a stacked horizontal bar that reveals both total participation and internal directional composition. The row also receives context coloring: rows inside the value area use stronger color treatment, and the Point of Control row can receive a distinct border. So the histogram communicates three layers at once: how much volume was traded there, whether that row sits inside the value area, and how that row’s activity was split between estimated buying and selling pressure. 15) Drawing POC, VAH, and VAL Lines line pocL = line.new(lineStartX, profile.pocPrice, lineEndX, profile.pocPrice, color=col_poc, width=2, style=line.style_solid) profileLines.push(pocL) line vahL = line.new(lineStartX, profile.vah, lineEndX, profile.vah, color=col_vah, width=1, style=line.style_dashed) profileLines.push(vahL) line valL = line.new(lineStartX, profile.val, lineEndX, profile.val, color=col_val, width=1, style=line.style_dashed) profileLines.push(valL) Once the profile is built, the script draws the three most important structural references: Point of Control, Value Area High, and Value Area Low. These lines can behave as compact annotations near the profile or as broader structure references if extension is enabled. This gives the user a quick way to read acceptance and central balance without needing to inspect every row manually. 16) Detecting Liquidity Voids float voidLimit = profile.pocVol * (voidThreshold / 100.0) bool inVoid = false float voidStartPrice = na for i = 0 to profile.bins.size() - 1 PriceBin b = profile.bins.get(i) bool isOutsideVA = b.price > profile.vah or b.price < profile.val This is the beginning of the liquidity void logic. A row is never treated as a void candidate solely because its volume is small. The script first requires that the row be outside the value area. This matters because low volume inside the main acceptance zone does not carry the same meaning as low volume outside it. The script also calculates voidLimit as a percentage of Point of Control volume. That creates a relative participation threshold tied to the strongest row in the profile. 17) Comparing Each Row to Its Neighbors float sumNeighbors = 0.0 int nC = 0 for j = math.max(0, i - 2) to math.min(profile.bins.size() - 1, i + 2) if j != i sumNeighbors += profile.bins.get(j).totalVol nC += 1 float localAvg = nC > 0 ? sumNeighbors / nC : 0.0 bool isGap = b.totalVol < (localAvg * 0.5) bool isLowVol = b.totalVol < voidLimit bool isVoid = isLowVol and isGap and isOutsideVA This is the real filter that defines a liquidity void. The script looks at nearby bins around the current row and calculates a local neighbor average. Then it applies two separate tests: the row must be low relative to the Point of Control threshold, and it must also be weak relative to its nearby neighbors. Only if both are true, and the row is outside the value area, does the script classify it as a void. This is important because it prevents the indicator from marking every low volume row as a void. A valid void must look weak both globally and locally. 18) Grouping Consecutive Void Rows Into Zones if isVoid if not inVoid inVoid := true voidStartPrice := b.price - (profile.binSize / 2) else if inVoid inVoid := false float voidEndPrice = b.price - (profile.binSize / 2) float topCoord = math.max(voidStartPrice, voidEndPrice) float botCoord = math.min(voidStartPrice, voidEndPrice) box vBox = box.new(bar_index - lookback, topCoord, bar_index, botCoord, border_color=na, bgcolor=col_void) Once a void row is detected, the script begins tracking a continuous void run. If the next row is also a void, the zone continues. When the run ends, the script closes the zone and draws a box covering the full void area. This means the indicator does not plot isolated tiny marks for each row. Instead, it groups neighboring weak rows into a cleaner structure that better represents a meaningful liquidity gap. That box is then labeled as a liquidity void, making the zone easy to identify visually.
Wskaźnik Pine Script®
od UAlgo
1
Range Finder & Profile [UAlgo]Range Finder & Profile is a structured market range detection tool that combines pivot based range discovery with an embedded volume profile. Its purpose is to identify areas where price begins to rotate inside a defined boundary, track whether that balance remains intact, and then summarize how volume was distributed inside the completed range once price finally exits it. The script starts by using pivot highs and pivot lows to define potential horizontal boundaries. When a valid upper and lower reference exist, and price is trading inside those bounds without already breaking them, the script opens a candidate range. From that point onward, it keeps monitoring the structure bar by bar, checking whether the range survives long enough to become confirmed and whether price remains accepted inside it. What makes this indicator especially useful is that it does not stop at simply drawing a box around consolidation. Once a range becomes confirmed, it also builds a row based internal profile of all activity inside that zone. When the range eventually breaks, the script calculates Point of Control, Value Area High, and Value Area Low, then draws a compact profile directly inside the range. This transforms a simple horizontal box into a more informative market acceptance map. The result is a tool that can help traders study balance, distribution, and eventual expansion. It is useful for identifying clean consolidation structures, understanding where the heaviest participation occurred inside a range, and interpreting whether the breakout happened after meaningful internal acceptance or after a less developed structure. 🔹 Features 🔸 Pivot Based Range Discovery The script uses pivot highs and pivot lows to establish potential range boundaries. This creates a structure that reacts to meaningful swing points rather than arbitrary rolling highs and lows. As a result, the detected ranges tend to reflect actual market rotation more naturally. 🔸 Clean Range Validation A new range is only created when price is already trading inside the proposed top and bottom boundaries and when no bar in the candidate history has already closed outside those levels. This helps prevent invalid or already broken ranges from being accepted. 🔸 Overlap Protection The script tracks where the last completed range ended and avoids creating a new one that starts inside an already closed structure. This reduces repeated overlap and keeps the chart cleaner. 🔸 Minimum Range Confirmation Not every detected range is immediately treated as valid. The structure must survive for a minimum number of bars before it becomes confirmed. This helps filter out weak or short lived consolidations. 🔸 Embedded Volume Profile Each confirmed range contains its own internal volume profile. The vertical height of the range is divided into configurable rows, and every bar contributes volume into the relevant price segments. This creates a compact distribution map inside the actual range boundaries. 🔸 Proportional Volume Allocation The script does not simply drop full bar volume into a single row unless the bar has no height. Instead, when a candle spans multiple rows, its volume is distributed proportionally across the overlapped sections. This produces a more realistic representation of participation across the range. 🔸 Point of Control Detection After the range is complete, the script finds the profile row with the highest accumulated volume. This row becomes the Point of Control, giving the user a quick view of the price area with the strongest concentration of activity. 🔸 Value Area Calculation The script expands outward from the Point of Control and accumulates neighboring rows until the selected percentage of total range volume is reached. This produces Value Area High and Value Area Low, which highlight the area where most participation occurred. 🔸 Gradient Range Background The active and completed range is drawn with a multi slice background gradient between the upper and lower colors. This improves readability and gives the zone a more polished visual structure. 🔸 Histogram Inside the Range When a range is confirmed and completed, the script draws horizontal histogram bars inside the zone. Rows inside the value area use a dedicated color, while rows outside the value area use a separate profile color. This makes internal acceptance easy to read visually. 🔸 Live Active Range Updates While the range is still active and not yet broken, the background extends forward in time with every new bar. Once the range becomes confirmed, profile and value area calculations are refreshed continuously until the breakout occurs. 🔸 Practical Market Structure Use This makes the indicator useful for consolidation analysis, acceptance and rejection studies, and breakout context. A trader can see not only where price paused, but also how volume built inside that pause before expansion occurred. 🔹 Calculations 1) Pivot Detection for Range Anchors float ph = ta.pivothigh(high, lengthInput, lengthInput) float pl = ta.pivotlow(low, lengthInput, lengthInput) if not na(ph) recentPH := ph recentPHIndex := bar_index if not na(pl) recentPL := pl recentPLIndex := bar_index This is the starting point of the whole script. The code asks TradingView to detect a pivot high and a pivot low using the selected swing length. A pivot high appears only after enough bars have formed on both sides of the swing, and the same logic applies to a pivot low. Because of that, pivots are confirmed reference points rather than instant highs or lows. When a valid pivot high is found, the script stores two things. The pivot price itself in recentPH The bar index where that pivot actually occurred in recentPHIndex The same is done for pivot lows through recentPL and recentPLIndex . This means the script always keeps track of the latest confirmed upper swing and the latest confirmed lower swing. Those two swing references become the raw ingredients for a possible trading range. 2) Candidate Range Creation Logic bool canCreateRange = na(activeRange) and not na(recentPH) and not na(recentPL) if canCreateRange float top = math.max(recentPH, recentPL) float bot = math.min(recentPH, recentPL) if top > bot and close <= top and close >= bot int sIndex = math.min(recentPHIndex, recentPLIndex) int barsBack = bar_index - sIndex This block decides whether the script is even allowed to start a new range. First, canCreateRange requires three conditions: there must be no currently active range, there must be a recent pivot high, and there must be a recent pivot low. If those conditions are met, the script builds a provisional upper bound and lower bound using the greater and smaller of the two pivot prices. Then it checks whether current price is actually inside that proposed range. This is important because it prevents the script from creating a range that price has already escaped. The code also finds sIndex , which is the earlier of the two pivot bar indices. That earlier point becomes the true starting location of the range. Then barsBack measures how many bars ago the range began. So at this stage, the script has a full candidate structure: an upper price, a lower price, and a starting point in time. 3) Overlap Prevention and Broken History Check bool isOverlapping = false if sIndex <= lastClosedRangeEndIndex isOverlapping := true if not isOverlapping bool broken = false if barsBack > 0 for i = 0 to barsBack if close > top or close < bot broken := true break This section filters out bad candidates before a range is created. First, the script checks whether the proposed start index falls inside or before the end of the last completed range. If it does, the new candidate is marked as overlapping and rejected. This keeps the indicator from repeatedly generating new boxes on top of old structures. Next, even if there is no overlap, the script scans every bar from the proposed start point up to the present. It checks whether any close moved above the top boundary or below the bottom boundary. If that happened, the candidate is marked as broken. This is a very important quality filter. It means the script does not simply connect two pivots and call that a range. It also verifies that price actually stayed accepted inside those boundaries over the full candidate history. 4) Initializing the Range Object activeRange := RangeData.new( startIndex = sIndex, startTime = time , endIndex = bar_index, endTime = time, topPrice = top, bottomPrice = bot, isActive = true, isConfirmed = false, totalVolume = 0.0, pocPrice = na, pocVolume = 0.0, pocIndex = -1, vah = na, val = na, bgBoxes = na, histBoxes = na, pocLine = na, vahLine = na, valLine = na, pocLabel = na, vahLabel = na, valLabel = na ) activeRange.initProfile(profileRows) Once the script is satisfied that the candidate is valid, it creates a new RangeData object. This object stores all important information about the range: where it starts, where it currently ends, its top price, its bottom price, whether it is still active, whether it is confirmed, and all profile related values such as total volume, Point of Control, Value Area High, and Value Area Low. Immediately after creating the object, the script calls initProfile(profileRows) . That method prepares the internal volume profile rows that will later hold the distribution data. So this is the moment where the script moves from pure detection into active tracking. 5) Building the Internal Profile Rows method initProfile(RangeData this, int rowsCount) => float step = (this.topPrice - this.bottomPrice) / rowsCount this.profile := array.new() for i = 0 to rowsCount - 1 float pBottom = this.bottomPrice + (i * step) float pTop = pBottom + step this.profile.push(ProfileRow.new(pTop, pBottom, 0.0)) This method divides the height of the range into a fixed number of rows. First, it calculates step , which is the height of one profile row. That is simply the total range height divided by the selected number of profile rows. Then it creates an empty profile array and fills it row by row. Each row stores: its upper price, its lower price, and the total volume accumulated in that row. At this moment, every row starts with zero volume. The profile is just an empty framework waiting to receive bar by bar contributions. This design is important because the script is not using a prebuilt TradingView volume profile function. It is constructing the profile manually, row by row, inside the exact range boundaries. 6) Adding Volume Into the Profile method addVolume(RangeData this, float bHigh, float bLow, float bVol) => float overlapHigh = math.min(bHigh, this.topPrice) float overlapLow = math.max(bLow, this.bottomPrice) if bHigh == bLow and bHigh <= this.topPrice and bHigh >= this.bottomPrice for i = 0 to this.profile.size() - 1 ProfileRow row = this.profile.get(i) if bHigh >= row.priceBottom and bHigh <= row.priceTop row.volumeTotal += bVol this.totalVolume += bVol break else if overlapHigh > overlapLow float overlapHeight = overlapHigh - overlapLow float totalHeight = bHigh - bLow float effectiveVol = totalHeight > 0 ? bVol * (overlapHeight / totalHeight) : bVol for i = 0 to this.profile.size() - 1 ProfileRow row = this.profile.get(i) float rowOverlapHigh = math.min(overlapHigh, row.priceTop) float rowOverlapLow = math.max(overlapLow, row.priceBottom) if rowOverlapHigh > rowOverlapLow float rowOverlapHeight = rowOverlapHigh - rowOverlapLow float rowRatio = rowOverlapHeight / overlapHeight float addedVol = effectiveVol * rowRatio row.volumeTotal += addedVol this.totalVolume += addedVol This is one of the most important calculations in the whole script. The goal here is to take a candle and distribute its volume into the profile rows that the candle actually overlaps. First, the script limits the candle to the range boundaries using overlapHigh and overlapLow . This ensures that only the part of the candle inside the range contributes to the profile. Then two cases are handled. If the candle has no height, meaning bHigh == bLow , the full volume is assigned to the single row that contains that exact price. If the candle does have height, the script calculates how much of the candle actually overlaps the range. That overlapping height becomes the valid section for profile allocation. Then, for each profile row, the script measures how much of that valid section overlaps the row. Volume is distributed proportionally according to that overlap share. This is much more accurate than placing the full candle volume into a single row. It means tall candles contribute volume across the price levels they truly passed through, which creates a more realistic internal distribution. 7) Filling the New Range With Historical Volume if barsBack >= 0 for i = 0 to barsBack float bVol = na(volume ) ? 1.0 : volume activeRange.addVolume(high , low , bVol) Right after a new range is created, the script goes back through all bars that belong to that range from its start until the current bar. For each of those bars, it reads the volume and sends the bar high, bar low, and volume into addVolume . This step is essential because it backfills the profile immediately. Without it, the range would start with an empty volume profile and would only accumulate data from future bars. Instead, the script reconstructs the whole internal history of the range as soon as the range is created. Also notice the fallback 1.0 when volume data is missing. That ensures the script can still function on symbols where actual volume may not be available. 8) Range Confirmation and Break Detection bool isBroken = close > activeRange.topPrice or close < activeRange.bottomPrice if (bar_index - activeRange.startIndex) >= minRangeLen activeRange.isConfirmed := true Once a range is active, the script keeps evaluating two key questions on every bar. The first question is whether the range is broken. If the current close moves above the top or below the bottom, the range is considered finished. The second question is whether the range has lasted long enough to be trusted. If the number of bars since the range started is at least the user selected minimum, isConfirmed becomes true. This creates a useful distinction between a candidate range and a confirmed range. A short structure can exist visually for a while, but it only becomes analytically meaningful after it survives long enough. 9) Live Updating While the Range Is Active if not justCreated float barVol = na(volume) ? 1.0 : volume activeRange.addVolume(high, low, barVol) if activeRange.isConfirmed activeRange.calcValueArea(valAreaPct) activeRange.drawProfile(colorBgTop, colorBgBot, colorProfile, colorProfileVA, colorPOC, colorVA) else activeRange.updateBgRight(time, colorBgTop, colorBgBot, colorBorder) This block explains how the range evolves in real time. If the current bar is not the same bar where the range was created, the script adds the latest candle volume into the profile. That keeps the internal distribution up to date bar by bar. Then the script behaves differently depending on confirmation state. If the range is already confirmed, it recalculates the value area and redraws the full profile. This means Point of Control, Value Area High, Value Area Low, and the histogram are all updated continuously as long as price remains inside the range. If the range is not yet confirmed, the script only extends the background box to the current time. In other words, the market structure is still being monitored, but the full profile is not drawn until the range has proven itself. 10) Point of Control Discovery float maxVol = -1.0 int pIndex = -1 for i = 0 to this.profile.size() - 1 ProfileRow row = this.profile.get(i) if row.volumeTotal > maxVol maxVol := row.volumeTotal pIndex := i this.pocIndex := pIndex this.pocVolume := maxVol ProfileRow pocRow = this.profile.get(pIndex) this.pocPrice := (pocRow.priceTop + pocRow.priceBottom) / 2.0 This is the first phase inside the value area calculation. The script scans every profile row and looks for the one with the largest accumulated volume. That row becomes the Point of Control row. Once that row is found, the script stores: the row index in pocIndex , the largest row volume in pocVolume , and the row midpoint price in pocPrice . So the Point of Control is not guessed from the center of the range or from price action alone. It is derived directly from the heaviest profile row. 11) Expanding to Build the Value Area float targetVol = this.totalVolume * (pct / 100.0) float currentVol = maxVol int upIndex = pIndex + 1 int downIndex = pIndex - 1 while currentVol < targetVol and (upIndex < this.profile.size() or downIndex >= 0) float upVol = upIndex < this.profile.size() ? this.profile.get(upIndex).volumeTotal : -1.0 float downVol = downIndex >= 0 ? this.profile.get(downIndex).volumeTotal : -1.0 if upVol == -1.0 and downVol == -1.0 break Here the script begins with the Point of Control row and tries to accumulate enough neighboring volume to reach the selected percentage of total range volume. First, it calculates targetVol , which is the amount of total volume required for the value area. For example, if the input is 70 percent, the target is 70 percent of the full profile volume. The process then starts from the Point of Control row. currentVol begins at the Point of Control volume itself. From there, the script looks one row up and one row down and keeps expanding until the target is reached or no more rows remain. This is the classic logic of building a value area around the highest participation zone. 12) Choosing Whether to Expand Up or Down bool addUp = false if upVol > downVol addUp := true else if downVol > upVol addUp := false else int distUp = upIndex - pIndex int distDown = pIndex - downIndex if distUp < distDown addUp := true else if distDown < distUp addUp := false else addUp := true This section decides which side should be added next to the value area. If the row above the current zone has more volume than the row below, the script expands upward. If the row below has more volume, it expands downward. If both sides have the same volume, the script breaks the tie by comparing distance from the Point of Control. If distance is also equal, it defaults upward. This matters because value area construction should not be arbitrary. It should expand toward the heaviest nearby participation first. That keeps the final value area centered around the most meaningful volume concentration. 13) Final VAH and VAL Calculation int finalUp = math.min(upIndex - 1, this.profile.size() - 1) int finalDown = math.max(downIndex + 1, 0) this.vah := this.profile.get(finalUp).priceTop this.val := this.profile.get(finalDown).priceBottom After expansion is complete, the script converts the final upper and lower included rows into actual price boundaries. vah becomes the top of the highest included row. val becomes the bottom of the lowest included row. These two values form the value area envelope, showing the price zone that contains the selected percentage of all volume traded inside the range. So the final value area is not a fixed distance from Point of Control. It adapts to the actual row by row distribution. 14) Drawing the Gradient Range Background method drawBg(RangeData this, color cBgTop, color cBgBot, color cBorder, int rTime) => if not na(this.bgBoxes) for b in this.bgBoxes b.delete() this.bgBoxes := array.new() int bgSlices = 10 float sliceStep = (this.topPrice - this.bottomPrice) / bgSlices for i = 0 to bgSlices - 1 float bBot = this.bottomPrice + (i * sliceStep) float bTop = bBot + sliceStep this.bgBoxes.push(box.new(this.startTime, bTop, rTime, bBot, border_color=na, bgcolor=sliceCol, xloc=xloc.bar_time)) This method handles the visual background of the range. Before drawing anything new, the script deletes previously drawn background boxes. Then it splits the range vertically into ten slices. Each slice receives an interpolated color between the selected bottom background color and top background color. Finally, each slice is drawn as a time based box from the range start to the chosen right edge time. The result is a smooth vertical color transition across the range body, which makes the zone easier to read and visually separates upper and lower sections. 15) Drawing the Histogram, POC, VAH, and VAL if this.isConfirmed float maxVol = this.pocVolume if maxVol > 0 int rangeTimeWidth = math.max(rightTime - this.startTime, 1000) int maxTimeWidth = math.round(rangeTimeWidth * 0.35) for i = 0 to this.profile.size() - 1 ProfileRow row = this.profile.get(i) if row.volumeTotal > 0 float widthRatio = row.volumeTotal / maxVol int boxTimeWidth = math.round(maxTimeWidth * widthRatio) int boxLeftTime = rightTime - boxTimeWidth bool inVA = (row.priceTop <= this.vah and row.priceBottom >= this.val) color finalHistCol = inVA ? histVaCol : histCol this.histBoxes.push(box.new(boxLeftTime, t, rightTime, b, border_color=na, bgcolor=finalHistCol, xloc=xloc.bar_time)) this.pocLine := line.new(this.startTime, this.pocPrice, rightTime, this.pocPrice, color=pocCol, style=line.style_solid, width=2, xloc=xloc.bar_time) this.vahLine := line.new(this.startTime, this.vah, rightTime, this.vah, color=vaCol, style=line.style_dashed, width=1, xloc=xloc.bar_time) this.valLine := line.new(this.startTime, this.val, rightTime, this.val, color=vaCol, style=line.style_dashed, width=1, xloc=xloc.bar_time) This is the drawing engine for the completed profile. For each row with volume, the script calculates a width ratio relative to the Point of Control volume. Rows with more volume receive wider histogram boxes. Rows with less volume receive narrower boxes. That width is converted into time space, so the histogram grows leftward from the right edge of the range. This creates a compact in range horizontal profile. The script also checks whether each row lies inside the value area. If it does, the row uses the value area histogram color. If it does not, it uses the normal profile color. This makes the high participation area visually distinct. Finally, the script draws three key lines across the full width of the range: Point of Control, Value Area High, and Value Area Low. These lines convert the internal profile data into easy to read structure references on the chart. 16) What Happens When the Range Breaks if isBroken activeRange.isActive := false activeRange.endIndex := bar_index activeRange.endTime := time if not activeRange.isConfirmed if not na(activeRange.bgBoxes) for b in activeRange.bgBoxes b.delete() else activeRange.calcValueArea(valAreaPct) activeRange.drawProfile(colorBgTop, colorBgBot, colorProfile, colorProfileVA, colorPOC, colorVA) lastClosedRangeEndIndex := bar_index activeRange := na This block defines the final lifecycle of a range. When price closes outside the range boundaries, the active structure is terminated. The script records the ending bar and ending time, then checks whether the range had ever become confirmed. If the range was never confirmed, its background is deleted and the structure is discarded. This prevents weak or short lived ranges from leaving unnecessary clutter. If the range was confirmed, the script performs a final value area calculation and profile draw on the completed structure. It also stores the ending index so future ranges do not overlap with this one. Then the active range is cleared from memory, which allows the script to start searching for the next valid structure.
Wskaźnik Pine Script®
od UAlgo
Liquidity Depth [UAlgo]Liquidity Depth is a price distribution and participation map designed to show where market activity has concentrated across a recent trading range. Instead of focusing only on candle by candle direction, the script builds a structured profile of how volume has been allocated across price levels inside a rolling lookback window. The result is a visual depth curve that helps identify areas where buyers or sellers may have shown stronger relative presence. The indicator works by taking the highest and lowest prices inside the selected lookback, dividing that range into evenly spaced bins, and then assigning bar volume into those bins using one of two distribution models. This transforms raw volume into a spatial map of activity, allowing traders to see where liquidity has accumulated rather than simply when it appeared. A central strength of the script is that it separates participation into buy side and sell side estimates using candle direction as a practical heuristic. Bullish candles contribute to the buy side profile and bearish candles contribute to the sell side profile. While this is not exchange level bid ask data, it creates a highly usable approximation of directional participation that is often more intuitive for chart based analysis. The profile is drawn directly on the chart as a right side structure with smoothed depth curves, shaded fills, a Point of Control line, contextual range framing, and automatically detected strong liquidity pockets. This makes the tool especially useful for traders who want to study where activity is clustering, where resistance or support may be forming, and which parts of the recent range are attracting stronger participation. Because the output is overlay based and visually compact, Liquidity Depth can be used in a wide variety of workflows. It can complement trend analysis, help frame pullback entries, identify acceptance and rejection zones, or simply provide a clearer understanding of where recent market interest has been strongest. 🔹 Features 🔸 Price Range Liquidity Mapping The script scans a rolling lookback window, identifies the active price range, and divides that space into a configurable number of bins. Each bin becomes a small price segment where participation is accumulated. This produces a clear distribution style view of liquidity across the full recent range. 🔸 Two Distribution Modes The indicator supports two ways of assigning volume into the profile. Close Bin places the full bar volume into the single bin that contains the closing price. This creates a sharper and more concentrated structure that emphasizes where bars finished. Wick Spread distributes the bar volume evenly across all bins touched by the candle from low to high. This produces a broader and more spatially balanced profile that better represents the full path of the bar through price. These two modes give the user control over whether the profile should be more precise and concentrated or more inclusive and range aware. 🔸 Buy Side and Sell Side Separation The script maintains separate depth values for buying and selling participation. Bullish candles add volume to the buy side and bearish candles add volume to the sell side. This creates two distinct distribution curves that help reveal whether the lower part of the range is showing stronger buying interest or whether the upper part is attracting stronger selling interest. 🔸 Smoothed Liquidity Curves Instead of plotting raw bin values only, the script applies curve smoothing to the side distributions. This creates a cleaner, more readable shape that reduces visual noise and highlights the underlying structure of participation. The result is a profile that feels fluid and analytical rather than fragmented. 🔸 Glow Enhanced Curve Rendering The current build uses a glow style rendering around the main liquidity curves. This improves visual separation on the chart and makes strong participation bulges easier to recognize at a glance, especially when the profile is viewed on darker chart themes. 🔸 Automatic Strong Pocket Detection One of the most practical parts of the script is its ability to detect strong liquidity pockets. These are clusters of consecutive bins where smoothed participation exceeds a chosen strength threshold. When found, the script highlights the zone and labels it as a strong buy pocket or strong sell pocket. These pockets can be useful for identifying areas of acceptance, defense, or possible future reaction. 🔸 Point of Control Highlighting The indicator finds the price bin with the highest total participation and marks it as the Point of Control. This is the most active price area inside the profile and often serves as an important reference for equilibrium, attraction, or repeated interaction. 🔸 Range Frame and Midpoint Context A visual frame is drawn around the active profile range, including the highest level, the lowest level, and the midpoint. This gives the distribution a clear structure and helps the user understand where participation is concentrated relative to the center of the recent range. 🔸 Side Summary Readout The script prints a compact summary that shows estimated buy side and sell side percentages, along with total side volumes. This provides a quick interpretation layer so the user can understand the current balance of participation without needing to inspect each curve manually. 🔸 Theme Adaptive Colors Colors are selected dynamically according to the chart background tone. This helps the profile remain readable across both light and dark themes while preserving clear differentiation between buy side, sell side, frame lines, and Point of Control. 🔸 Efficient Object Management All boxes, lines, fills, and labels are refreshed on the last visible bar so the profile stays clean and up to date. Internal object arrays are actively cleared and rebuilt, which keeps the display organized and avoids uncontrolled accumulation of chart objects. 🔹 Calculations 1) Active Range Construction The script begins by defining the working range from the highest high and lowest low across the selected lookback window. This creates the vertical space where the full profile will be built. The total span is then divided into the configured number of bins, which creates evenly spaced price segments from the bottom of the range to the top. Each bin stores its lower boundary, upper boundary, midpoint, buy volume, sell volume, and total volume. In practical terms, this means the indicator converts the recent market range into a structured ladder of price levels so activity can be measured spatially. 2) Bin Initialization Once the range is known, every bin is reset and rebuilt. Each bin receives: its lower boundary, its upper boundary, its midpoint, and empty participation values for buy, sell, and total activity. This reset process ensures that the profile always reflects only the current rolling window rather than carrying stale values from older bars. 3) Volume Assignment Logic For every bar inside the lookback, the script reads the volume and determines whether the candle is bullish or bearish. From there, distribution depends on the selected mode. With Close Bin , the full bar volume is assigned to the bin that contains the close. If the candle is bullish, that volume is counted on the buy side. If the candle is bearish, it is counted on the sell side. With Wick Spread , the script finds every bin touched between the candle low and candle high. The bar volume is divided evenly across those crossed bins. That distributed share is then assigned entirely to the buy side for bullish candles or entirely to the sell side for bearish candles. This approach creates a practical estimate of where participation occurred across price, while also preserving directional context. 4) Total Participation and Point of Control After all bars are processed, each bin contains a buy volume, a sell volume, and a total volume equal to the sum of the two. The script then scans the full array of bins to find the highest total value. The bin with that maximum total becomes the Point of Control. The Point of Control represents the most concentrated participation zone inside the profile and is drawn as a dedicated horizontal reference line. 5) Midpoint Split and Side Totals The active range midpoint is calculated as the average of the range high and range low. This midpoint is used as the divider between the lower half and upper half of the profile. For summary purposes, buy side totals are accumulated from bins at or below the midpoint, while sell side totals are accumulated from bins above the midpoint. The script also records the highest buy side bin value and the highest sell side bin value. This design gives the profile a simple structural interpretation: lower range strength is associated with buying participation, upper range strength is associated with selling participation. That makes the summary especially useful for understanding whether the range is showing stronger support style accumulation below or stronger supply style pressure above. 6) Smoothing Engine To reduce jaggedness, the script smooths each side of the profile with a local weighted kernel built from five neighboring bins. The center bin carries the highest influence, adjacent bins carry moderate influence, and outer bins carry smaller influence. The smoothed result is then blended with the raw bin value according to the user selected smoothing factor. A low smoothing value preserves more of the original structure, while a high smoothing value creates a softer and more continuous curve. This process helps reveal the true shape of participation without overreacting to isolated bin spikes. 7) Curve Projection and Shape Refinement Once a side is smoothed, its value is normalized against the maximum strength of that side. The normalized result is converted into horizontal width inside the selected profile width. This is what determines how far the curve extends to the right from its anchor point. The script also applies an additional running refinement to the horizontal curve position from one bin to the next. This makes the drawn path more fluid and helps eliminate abrupt lateral jumps between neighboring levels. The final effect is a polished depth curve that communicates intensity clearly while remaining visually smooth. 8) Strong Pocket Detection Strong liquidity pockets are found by scanning for consecutive bins where normalized smoothed participation exceeds the pocket threshold. For the upper half of the profile, the script searches for strong sell side runs. For the lower half of the profile, the script searches for strong buy side runs. When a qualifying run lasts for at least the minimum required number of bins, a zone is drawn across that price region and labeled accordingly. The horizontal size of the zone is linked to the peak strength found inside that run. This means the pocket logic is not simply marking a single peak. It is identifying sustained participation clusters, which often carry more analytical value than isolated extremes. 9) Visual Frame and Range Guides The script adds a top guide at the range high, a bottom guide at the range low, and a midpoint guide through the center of the profile. These references help the user interpret the shape of liquidity in relation to the broader active range. A curve concentrated near the midpoint suggests balance or repeated acceptance. A strong bulge in the upper section can imply stronger supply style participation. A strong bulge in the lower section can imply stronger demand style participation. 10) Summary Metrics The summary label presents estimated buy side and sell side percentages along with total side volumes. These percentages are derived from the midpoint based side totals described above. This gives the user a fast read on the internal balance of the profile without needing to inspect the full shape manually. It is especially useful when comparing one instrument or one session structure to another.
Wskaźnik Pine Script®
od UAlgo
Delta Flow Volume Profile [UAlgo]Delta Flow Volume Profile is a price based profile indicator that builds a rolling volume distribution and separates that distribution into bullish and bearish participation at each price zone. Instead of showing only how much total volume traded in an area, the script splits each profile row into buyer dominated and seller dominated segments, then renders those segments side by side on the chart. This creates a more informative profile that helps reveal not only where activity concentrated, but also which side was dominant inside each level. The indicator runs directly on price ( overlay=true ) and analyzes a user defined lookback window. It divides the recent price range into fixed bins, distributes each candle’s volume across the bins it overlaps, and classifies that allocated volume as bullish or bearish based on candle direction. The final result is drawn to the right of the chart as a horizontal stacked profile where: The left segment of each row represents bullish volume The right segment represents bearish volume The widest total row identifies the Point of Control (POC) Each significant row can display buyer and seller percentage labels This makes the script useful for traders who want a profile style map of participation with directional context, especially when identifying areas where buyers were dominant, sellers were dominant, or both sides were highly active. Important note: The bullish and bearish split in this script is an approximation based on candle direction ( close >= open versus close < open ). It is not true bid ask or tick level order flow delta. 🔹 Features 🔸 1) Delta Style Volume Profile by Price Level The core idea of the script is to turn a standard horizontal volume profile into a directional participation profile. Each row tracks both bullish and bearish volume, so the user can see whether a price zone was primarily buyer controlled, seller controlled, or relatively balanced. 🔸 2) Rolling Lookback Profile The profile is built from the most recent user selected number of bars. This means the profile continuously adapts to current market structure instead of being locked to a session boundary. This makes it useful for intraday structure analysis, local range mapping, and recent participation studies. 🔸 3) Fixed Bin Price Segmentation The script divides the recent highest to lowest range into a configurable number of bins. Lower bin counts create thicker and smoother rows. Higher bin counts create more detailed and granular distribution. This lets the user control the balance between clarity and resolution. 🔸 4) Proportional Volume Allocation Across Overlapping Bins When a candle spans multiple bins, the script does not place the full candle volume into a single row. Instead, it allocates volume proportionally according to the overlap between the candle range and each bin. This produces a more realistic distribution than a single point assignment, especially for larger candles. 🔸 5) Bullish and Bearish Segment Rendering Each row is drawn as a stacked two part structure: The bullish segment starts from the left base of the profile The bearish segment continues immediately after the bullish segment This gives an intuitive visual read of which side dominated and how much each side contributed inside the same price zone. 🔸 6) Point of Control Highlighting The script automatically finds the row with the highest total volume and marks it as the Point of Control. The POC row is highlighted with a full width background band, which makes the most active zone immediately obvious. This is useful for identifying the strongest recent area of price acceptance. 🔸 7) Percentage Labels for Strong Rows For profile rows with meaningful participation, the script prints a right side label showing: Bullish percentage Bearish percentage For the POC row, the label is prefixed with POC . This gives a quick summary of directional balance at the most important nodes. 🔸 8) Dynamic Label Coloring by Dominance The percentage labels change color based on row context: POC labels use the dedicated POC color Rows dominated by bullish volume use the bullish color Rows dominated by bearish volume use the bearish color This improves readability and speeds up visual interpretation. 🔸 9) Adjustable Profile Width and Offset The profile is drawn to the right of the current bar with configurable: Profile width as a percentage of lookback Horizontal offset in bars This makes it easy to place the profile in a clean position without obstructing live price action. 🔸 10) Smooth Clean Presentation The script uses borderless boxes and compact right side labels, which gives the profile a clean and uncluttered look. This makes it suitable for traders who want visual structure without excessive chart noise. 🔸 11) Built for Practical Delta Style Context While it does not use true order flow data, the indicator still provides a highly usable approximation of directional participation. This can help identify: Buyer heavy zones Seller heavy zones Balanced zones High activity acceptance areas 🔹 Calculations 1) Price Range Detection The script first determines the highest high and lowest low over the selected lookback: float hh_global = ta.highest(high, lookback) float ll_global = ta.lowest(low, lookback) This defines the full vertical range of the profile. 2) Bin Construction That range is divided into the selected number of bins: float binSize = (hh - ll) / numBins Each bin stores: Top price Bottom price Bullish allocated volume Bearish allocated volume The bins are built from top to bottom so the profile rows map naturally across the recent range. 3) Candle by Candle Volume Processing For every bar in the lookback window, the script reads: High Low Open Close Volume Then it checks each bin to see whether the candle overlaps that bin. 4) Proportional Overlap Allocation For each overlapping bin, the script calculates: float overlapTop = math.min(bHigh, b.top) float overlapBottom = math.max(bLow, b.bottom) If there is overlap, it allocates volume proportionally: allocatedVol := bVol * ((overlapTop - overlapBottom) / rangeSize) Interpretation: If a candle covers multiple price rows, each row receives only the fraction of volume corresponding to its share of the candle’s total range. This is a more realistic approximation than assigning all volume to one bin. 5) Zero Range Candle Handling If a candle has zero range, the script assigns the full volume to the bin that contains the candle price: if rangeSize > 0 ... else if bHigh <= b.top and (bHigh > b.bottom or (j == numBins - 1 and bHigh >= b.bottom)) allocatedVol := bVol This prevents divide by zero issues and still keeps the data usable. 6) Bullish vs Bearish Classification Once the script calculates allocated volume for a bin, it classifies that volume by candle direction: if bClose >= bOpen b.bullVol += allocatedVol else b.bearVol += allocatedVol Interpretation: Bullish volume means the candle closed at or above its open. Bearish volume means the candle closed below its open. Important note: This is a directional approximation. It is not true tape based aggressive buy or aggressive sell volume. 7) Total Volume, Delta, and Percent Methods Each bin includes helper methods: totalVol() returns bullVol + bearVol deltaVol() returns bullVol - bearVol bullPct() returns bullish percentage of total bearPct() returns bearish percentage of total The script actively uses total volume and percentages in rendering. The deltaVol() method is defined for convenience, but this version does not directly plot or label the raw delta value. 8) Point of Control Detection After all bins are populated, the script finds the row with the largest total volume: if bTotVol > maxVol maxVol := bTotVol pocIdx := i This row becomes the Point of Control and acts as the strongest recent participation zone. 9) Width Normalization The total maximum row volume is used as the width normalization anchor. For each row: float bullRatio = b.bullVol / maxVol float bearRatio = b.bearVol / maxVol Then the segment widths are scaled into bars: int bullWidthBars = math.round(bullRatio * maxBoxWidthBars) int bearWidthBars = math.round(bearRatio * maxBoxWidthBars) Because both bullish and bearish widths are normalized against the same maxVol , their combined width reflects the row’s total participation relative to the profile maximum. 10) Minimum Visible Width Safeguard If a row has non zero bullish or bearish volume but the calculated width rounds to zero, the script forces a minimum width of one bar: if b.bullVol > 0 and bullWidthBars == 0 bullWidthBars := 1 This ensures small but meaningful contributions remain visible. 11) Right Side Time Based Layout The profile is rendered using xloc.bar_time , so all horizontal distances are based on time, not bar index. The script calculates: A base left time for the profile A maximum right time A per bar time width Key logic: int leftBaseTime = lastBarTime + (profileOffset * barTimeDiff) int maxRightTime = leftBaseTime + (maxBoxWidthBars * barTimeDiff) This makes the profile appear a fixed number of bar widths to the right of the latest candle. 12) POC Background Highlight Before drawing the bullish and bearish segments for the POC row, the script paints a full width background band: box.new(left=leftBaseTime, top=drawTop, right=maxRightTime, bottom=drawBottom, ...) This gives the POC a distinct highlighted backdrop behind the actual stacked volume bars. 13) Visual Gap Inside Each Bin The script trims the top and bottom of each drawn row slightly: float boxGap = (b.top - b.bottom) * 0.1 float drawTop = b.top - boxGap float drawBottom = b.bottom + boxGap This creates small vertical spacing between rows, which improves readability and avoids a fully merged block appearance. 14) Percentage Label Threshold Labels are not printed for every row. They appear only when the row’s total volume is greater than 15 percent of the maximum row volume: if bTotVol > (maxVol * 0.15) This reduces clutter and focuses attention on more relevant nodes. 15) Label Text Construction For significant rows, the script computes: Bullish percentage Bearish percentage Then formats them as: string labelText = bullStr + " | " + bearStr For the POC row: labelText := "POC: " + labelText
Wskaźnik Pine Script®
od UAlgo
Swing Profile [BigBeluga]🔵 OVERVIEW Swing Profile is a dynamic swing-based volume profiling tool that builds a complete volume profile for each completed market swing. Instead of using fixed sessions or time ranges, the indicator anchors its profile strictly between confirmed swing highs and swing lows, allowing traders to analyze where volume accumulated inside each directional leg. The profile updates in real time while a swing is still forming and finalizes once the swing direction flips, giving both historical and live insight into volume behavior. 🔵 CONCEPTS Swing-Anchored Profiling — Volume is calculated only between confirmed swing highs and lows detected by the Swing Length input. Directional Legs — Each bullish or bearish swing leg gets its own independent volume profile. ATR-Adaptive Bins — Profile bin size is automatically scaled using ATR, keeping resolution consistent across volatility regimes. Real-Time Rebuild — While a swing is still active, the profile continuously recalculates and redraws. Finalized Profiles — Once direction flips, the profile is locked and marked as a completed swing. 🔵 FEATURES Swing Volume Profile — Displays horizontal volume distribution for each swing leg. Point of Control (PoC) — Highlights the price level with the highest traded volume inside the swing. Buy / Sell Volume Separation — Tracks bullish (buy) and bearish (sell) volume inside each profile. Delta Volume Calculation — Shows net buying vs selling pressure as a percentage. Profile Outline — A polyline traces the outer shape of the volume distribution. HeatMap Mode — Optional heatmap visualization showing volume intensity by color gradient. ZigZag Swing Connector — Visual connection between swing highs and lows for structure clarity. Custom Label Sizing — Adjust label size (Tiny → Huge) for clean chart scaling. 🔵 HOW TO USE Identify High-Interest Zones — Use the PoC to locate price levels where the market spent the most time during a swing. Trend Strength Analysis — Strong directional swings often show volume skewed toward one side of the profile. Pullback Zones — Profiles help identify areas where price may react during retracements. Continuation vs Reversal — Delta volume reveals whether buying or selling dominated the swing. Live Monitoring — While a swing is forming, watch the real-time profile to anticipate where structure may complete. 🔵 DATA LABELS T — Total traded volume inside the swing. B — Buy volume (bullish candles). S — Sell volume (bearish candles). D — Delta volume (% difference between buy and sell volume). 🔵 CONCLUSION Swing Profile delivers a precise, structure-aware view of volume by anchoring profiles directly to market swings. By combining real-time profiling, PoC detection, delta analysis, and adaptive resolution, it provides deep insight into where participation truly occurred — making it a powerful tool for swing traders, structure traders, and volume-focused strategies.
Wskaźnik Pine Script®
od BigBeluga
13
3D Volume Profile [UAlgo]3D Volume Profile is a chart based volume profile indicator that takes a classic horizontal profile concept and presents it as a pseudo 3D structure directly on price. Instead of drawing flat histogram bars only, the script renders each profile row as a shaded 3D block with a front face, a side face, and a top face, which creates a stronger visual sense of depth and distribution. The indicator runs on price ( overlay=true ) and builds a rolling volume profile over a user defined lookback window. It divides the recent price range into fixed bins, distributes candle volume across those bins, identifies the Point of Control and the Value Area, and then draws the result on the right side of the chart. Each row is color coded by dominant flow direction, which means the profile can show whether a bin was more buy dominated or sell dominated in addition to showing how much total volume accumulated there. This makes the tool useful for traders who want more than a basic profile display. It combines: A rolling horizontal volume profile Buy versus sell dominance shading Point of Control and Value Area detection A forward projected 3D style histogram Clear POC, VAH, and VAL reference lines on the chart The final result is a visually rich profile tool designed for fast structural reading, especially when identifying acceptance zones, thin areas, and dominant participation regions. 🔹 Features 🔸 1) Rolling Volume Profile Over a Recent Window The script builds a rolling profile from the most recent user selected number of bars. This means the profile continuously adapts as new bars come in, making it more useful for current market structure analysis than a fixed session only approach. 🔸 2) 3D Style Histogram Rendering Each volume row is drawn as a pseudo 3D block rather than a flat rectangle. The script creates: A front face A side face A top face The side and top faces are shaded versions of the main color, which gives the profile a depth effect and makes the structure easier to read visually. 🔸 3) Customizable 3D Depth in X and Y The 3D effect is controlled with two settings: 3D Depth X , which controls how far the rear face is shifted horizontally in bars 3D Depth Y , which controls how far the rear face is shifted vertically as a percentage of row height This allows the user to make the profile look flatter or more pronounced depending on preference. 🔸 4) Buy and Sell Volume Dominance Coloring Each bin tracks both buy volume and sell volume. If buy volume is greater than or equal to sell volume, the row uses the bullish color. If sell volume dominates, the row uses the bearish color. This means the profile is not only a measure of total activity. It also adds directional context to each price zone. 🔸 5) Point of Control Detection The script identifies the row with the highest total volume and marks it as the Point of Control. The POC is highlighted with its own dedicated color and is visually distinct from the rest of the profile. This gives traders an immediate reference for the most active price zone in the rolling range. 🔸 6) Value Area Calculation The indicator calculates a Value Area around the Point of Control based on the user selected percentage. Bins inside the Value Area are marked and recolored with the Value Area color, which makes the high participation region easy to identify. 🔸 7) Forward Projected Profile Layout The profile is drawn to the right of current price using a configurable offset. This keeps the active candle area readable while still placing the profile in a clear and accessible location. 🔸 8) Adjustable Resolution and Width Users can control: The lookback length The number of profile rows The maximum width of the histogram The right side offset This makes the indicator suitable for both coarse structural analysis and more detailed profile inspection. 🔸 9) POC, VAH, and VAL Reference Lines After the profile is built, the script calculates the POC, Value Area High, and Value Area Low, then projects horizontal reference lines across the chart. Labels are placed to the right so the key levels are clearly marked. 🔸 10) Row by Row Dominance and Acceptance Reading Because each row stores total volume, buy volume, sell volume, Value Area membership, and POC status, the indicator gives a layered view of the market: Where the most activity occurred Which zones were accepted Which zones were dominated by buyers Which zones were dominated by sellers 🔸 11) Premium Visual Presentation The script uses shaded faces, dedicated POC highlighting, Value Area recoloring, and clean right side labels. This makes it more presentation focused than a basic flat profile and improves chart readability for manual analysis. 🔹 Calculations 1) Profile Range Detection The script first finds the highest high and lowest low inside the active lookback window. This defines the full vertical range of the volume profile. Only the most recent bars inside that window are used for profile construction. 2) Bin Initialization Once the recent range is known, the script divides that price range into the chosen number of bins. Each bin stores: Top boundary Bottom boundary Total volume Buy volume Sell volume Flags for Value Area and POC The bin size is calculated by dividing the total price range by the number of rows. 3) Volume Distribution Across Price Bins For each candle, the script determines which bins the candle spans. It then spreads that candle’s volume evenly across all touched bins. This is important because the script does not place the full candle volume into a single price level. Instead, it allocates the candle volume across the portion of the profile that candle covers. Important implementation note: This script uses equal distribution across the spanned bins, not proportional overlap weighting. That means each touched row receives the same share of the candle’s volume. 4) Buy Versus Sell Volume Classification The script classifies each candle as buy dominated or sell dominated using candle direction: If close is greater than or equal to open, the candle is treated as buy volume If close is below open, the candle is treated as sell volume That candle’s allocated volume is then added to either volBuy or volSell inside each touched bin. This is a practical directional approximation, not true bid ask tape volume. 5) Total Volume and POC Detection After all candles are processed, the script scans every bin and calculates: The total volume across the profile The maximum single bin volume The POC index The POC is the bin with the highest total volume. That bin is marked as both isPOC and isVA before Value Area expansion begins. 6) Value Area Expansion Logic The Value Area is built around the POC by expanding upward and downward until the selected percentage of total profile volume is included. The script compares the next bin above and the next bin below the current Value Area. It adds whichever side has greater volume first. This continues until cumulative included volume reaches the target Value Area percentage. This creates a standard profile style Value Area centered on the highest participation region. 7) Histogram Width Normalization Each row’s width is scaled relative to the maximum volume row: The row with the most volume becomes the widest Smaller rows are scaled proportionally This means width directly communicates relative participation at each price zone. 8) Color Selection Logic For each bin, the script first determines whether buy volume or sell volume dominates: If buy volume is greater than or equal to sell volume, it uses the bullish color Otherwise it uses the bearish color Then the script overrides that base direction color if needed: If the row is the POC, it uses the POC color If the row is inside the Value Area, it uses the Value Area color This gives the profile a clear visual hierarchy: POC first Value Area second Directional dominance otherwise 9) 3D Face Construction Each row is rendered as a pseudo 3D object using: A front rectangle A shifted back edge using the X and Y depth settings A side face when horizontal depth is visible A top or bottom face depending on vertical depth direction The script shades the side face darker and the top face brighter than the base color to create a depth illusion. This is a visual projection technique, not a true 3D engine, but it produces a convincing 3D profile effect on the chart. 10) Rendering Order Logic The script changes draw order depending on the sign of the Y depth: If vertical depth is positive, rows are drawn from bottom to top If vertical depth is negative, rows are drawn from top to bottom This helps the 3D faces stack more cleanly and reduces visual overlap issues. 11) POC, VAH, and VAL Price Calculation After the profile is complete: The POC price is the midpoint of the POC bin VAH is the highest top boundary among all Value Area bins VAL is the lowest bottom boundary among all Value Area bins These levels are then drawn as horizontal lines extending from the left side of the lookback window toward the right side label area. 12) Label Placement The labels for POC, VAH, and VAL are placed slightly to the right of the profile. This keeps them readable and avoids overlap with the 3D bars themselves.
Wskaźnik Pine Script®
od UAlgo
Value Area Levels [crlmx]Calculated from native volume-at-price data vaLevels shows Value Area levels (VAH, POC, VAL) across three independently configurable timeframes. Requires TradingView Premium or above plan for Footprint data access, Short of that refere to Lite version (coming soon). Key Features - Three independent VA slots with on/off toggles - Timeframe selection: D, W, M, 30min, 1H, 4H, 8H, 12H - Session-based VA on slot 3: NYC, London, Asia, Custom - Custom session with user-defined time window and label prefix - Auto-calculated row resolution per instrument type - Manual ticks-per-row override for fine-tuning - Configurable Value Area percentage (default 68%) - Individual VAH, POC, VAL toggles per slot - Optional price display in labels - Requires TradingView Premium or Ultimate plan - Streamlined input / UI brought to you by crlmx Trading Applications - Map previous day area against weekly and session VAs to identify confluence zones - Track VAH/VAL as breakout triggers when price moves outside the prior value area - Compare session VA (NYC/LDN) against daily VA to for reactions - When daily and weekly VAs overlap, expect stronger reactions at the shared boundary - Combine with prLevels for a complete prior-level picture (price levels + volume levels) - Recommended Settings Intraday S/R: D + W + NYC | Chart: 1-15 min Session Trading: D + 4H + LDN | Chart: 1-5 min Swing Reference: D + W + M | Chart: 30 min - 4H Version History - v0.10: Initial release
Wskaźnik Pine Script®
od crlmx
Price Normalized RSI Profile [UAlgo]Price Normalized RSI Profile is a hybrid visualization tool that combines a rolling RSI distribution study with a profile style overlay drawn directly on the price chart. Instead of plotting a classic RSI line in a separate oscillator pane, this script collects historical RSI readings, groups them into fixed 0 to 100 bins, weights each bin by traded volume, and then renders the resulting distribution as a horizontal profile on the right side of the main chart. The goal of the script is not to show where price traded the most, but to show where RSI states accumulated the most volume over the selected lookback period. In other words, it answers a different question than a traditional volume profile. Rather than asking which prices were most active, it asks which RSI regimes were most active, then maps those oscillator regimes visually into the chart’s price space for easier on-chart interpretation. The indicator highlights: A volume weighted RSI Point of Control (POC) A Value Area around that POC A right side histogram of RSI regime distribution A color gradient that reflects bullish versus bearish RSI zones Reference labels for POC, VAH, and VAL Lookback boundary markers for profile context This makes the script useful for traders who want to blend oscillator distribution analysis with chart based execution, especially when comparing current price position against historically dominant RSI states. Important note: The POC, VAH, and VAL in this script are derived from an RSI distribution profile , not from a standard price based volume profile. They are visually mapped onto the current chart range for presentation. 🔹 Features 🔸 1) Volume Weighted RSI Distribution Profile The script collects RSI values over a rolling lookback window and assigns each reading into one of several fixed RSI bins. Each bin accumulates volume , not just frequency, so the profile reflects how much traded participation occurred while RSI was in that zone. This makes the output more meaningful than a simple occurrence count because highly active bars contribute more weight. 🔸 2) Fixed 0 to 100 RSI Bin Framework The profile is built over the natural RSI range from 0 to 100, divided into a user defined number of bins. This creates a stable oscillator distribution model that is consistent across symbols and timeframes. Lower bin counts create thicker, smoother profile bars. Higher bin counts create finer resolution and more detailed structure. 🔸 3) Overlay on the Main Price Chart Unlike most RSI tools, this script runs with overlay=true and renders the profile directly on the price chart. It maps RSI bins onto the vertical span of the recent chart range, allowing traders to see the distribution without leaving the main chart. This is a visual convenience feature and creates a unique fusion of oscillator logic and price space presentation. 🔸 4) Point of Control (POC) Detection The indicator identifies the RSI bin with the highest accumulated volume and treats it as the RSI Profile POC. This is the most active RSI zone by volume over the lookback window. The POC is highlighted with: A wider profile bar A unique color A label showing the POC volume 🔸 5) Value Area (VAH / VAL) Calculation The script builds a Value Area around the POC using the selected percentage of total profile volume. This identifies the core RSI regime zone where the majority of the volume weighted RSI activity occurred. The Value Area is visually emphasized with more visible bars and separate VAH / VAL guide lines. 🔸 6) Gradient Color Mapping by RSI Regime Each bin is colored using a gradient based on its RSI location: Lower RSI zones lean bullish color Higher RSI zones lean bearish color This reflects the script’s chosen visual logic, where low RSI bins appear in the bullish color family and high RSI bins appear in the bearish color family. 🔸 7) Distinct Styling for POC, Value Area, and Outside Value The script visually separates three categories: POC bin Bins inside the Value Area Bins outside the Value Area This helps traders quickly distinguish the dominant RSI regime from the broader accepted RSI zone and from lower importance outer regions. 🔸 8) Forward Projected Histogram Layout The profile is drawn to the right of current price using configurable: Maximum width in bars Horizontal offset This keeps the histogram out of the way of current candles while preserving clear visibility on the active chart. 🔸 9) Lookback Context Markers The script draws a vertical line marking the start of the profile lookback window, plus horizontal guide lines across the chart high and low range used for the profile mapping. This makes it easy to understand which portion of the chart is being analyzed. 🔸 10) Compact On Chart Labels The indicator adds right side labels for: POC VAH VAL This makes the distribution easier to read without manually inspecting each bar. 🔸 11) Rolling History Buffer for RSI and Volume The script stores both RSI and volume into arrays, allowing the profile to be rebuilt from recent history on the last bar. This keeps the logic fully rolling and independent from session boundaries. 🔸 12) Structured Object Based Design The script uses custom types: RsiBin for each RSI interval RsiProfile for the full profile state, including POC and Value Area indexes This makes the internal logic cleaner and easier to maintain. 🔹 Calculations 1) RSI Calculation The script calculates RSI from the chosen source and length: float rsi_val = ta.rsi(rsi_src, rsi_len) This value is the basis for all binning and profile accumulation. 2) Rolling RSI and Volume History Storage Every bar, the script pushes the latest RSI value and volume into rolling arrays: rsi_history.push(rsi_val) vol_history.push(volume) To prevent unlimited growth, the arrays are trimmed when they exceed: lookback + 100 This keeps enough buffer for profile stability while controlling memory size. 3) Fixed RSI Bin Initialization The profile divides the 0 to 100 RSI range into equal bins: float step = 100.0 / bins_count for i = 0 to bins_count - 1 float min_v = i * step float max_v = (i + 1) * step this.bins.push(RsiBin.new(min_v, max_v, 0.0, 0)) Each bin stores: RSI minimum value RSI maximum value Accumulated volume Observation count 4) Volume Weighted Population of the RSI Profile When populating the profile, each historical RSI value is mapped into the correct bin: int bin_idx = math.floor(r_val / 100.0 * this.bins.size()) The index is clamped to remain inside valid bounds: bin_idx := math.min(bin_idx, this.bins.size() - 1) bin_idx := math.max(bin_idx, 0) Then the script adds the corresponding bar volume to that bin: b.volume += v_val b.count += 1 this.total_vol += v_val This means the profile is volume weighted RSI distribution , not a simple count histogram. 5) POC Detection As bins are populated, the script tracks the bin with the highest accumulated volume: if b.volume > this.max_vol this.max_vol := b.volume this.poc_idx := bin_idx This bin becomes the profile POC and acts as the center for Value Area expansion. 6) Value Area Calculation The Value Area target is calculated from total profile volume: float target_vol = this.total_vol * (va_percent / 100.0) The script starts from the POC and expands outward, comparing the next upper and lower bin volumes: float vol_up = (top < max_idx) ? this.bins.get(top + 1).volume : 0.0 float vol_dn = (bot > 0) ? this.bins.get(bot - 1).volume : 0.0 Whichever side has more volume is added first. This continues until the accumulated volume reaches the target percentage. The final indexes are stored as: this.va_top_idx := top this.va_bot_idx := bot 7) Mapping RSI Bins into Price Space A key part of this script is that RSI bins are not drawn in an oscillator pane. Instead, each RSI interval is mapped onto the chart’s recent price range: float price_range = chart_high - chart_low float y_bottom = chart_low + (b.min_val / 100.0) * price_range float y_top = chart_low + (b.max_val / 100.0) * price_range Interpretation: RSI 0 maps to the recent chart low. RSI 100 maps to the recent chart high. All intermediate RSI bins are proportionally placed between them. This is a visual mapping device, not a statement that those price levels correspond to actual RSI threshold prices. 8) Histogram Width Normalization Each bin’s horizontal width is scaled by its volume relative to the maximum profile volume: int bar_w = math.round((b.volume / this.max_vol) * max_width) If the bin is the POC, it gets extra width: if is_poc bar_w := int(max_width * 1.15) This makes the POC stand out clearly inside the profile. 9) POC, VA, and Outside VA Styling Logic Each bin is categorized as: POC Inside the Value Area Outside the Value Area Then the script applies different opacity and border logic: POC gets the dedicated POC color VA bins are more visible Outside VA bins are more faded This creates clear visual hierarchy in the profile. 10) Color Gradient by RSI Position Base color is determined from bin position in the RSI scale: color base_col = color.from_gradient(b.min_val, 0, 100, c_bull, c_bear) This means lower RSI bins transition toward the bullish color and higher RSI bins transition toward the bearish color. This is a stylistic mapping choice built into the script. 11) POC Label and Volume Display When the POC is drawn, the script also adds a label showing: The text POC The accumulated volume of that bin text="POC " + str.tostring(b.volume, format.volume) This provides quick information about the dominant RSI regime’s participation size. 12) VAH and VAL Price Level Rendering The script converts the Value Area top and bottom RSI bin indexes into mapped chart levels: For VAH: float vah_level = chart_low + (b_vah.max_val / 100.0) * price_range_val For VAL: float val_level = chart_low + (b_val.min_val / 100.0) * price_range_val It then draws dashed horizontal lines and small labels for both. Important note: These are RSI profile Value Area boundaries mapped into price space , not true price based VAH and VAL from a market profile. 13) Lookback Boundary Drawing The start of the lookback window is marked with a vertical dotted line: int start_bar_idx = bar_index - lookback line.new(start_bar_idx, chart_low, start_bar_idx, chart_high, ...) This makes it easier to visually understand which section of chart history contributed to the current profile. 14) Chart Range Anchoring The vertical display range used for the RSI to price mapping is derived from: float chart_high = ta.highest(high, lookback) float chart_low = ta.lowest(low, lookback) This means the profile always stretches across the full recent visible price range used in the calculation window. 15) Last Bar Rendering Behavior The profile is built and rendered only on the last bar: if barstate.islast vp.init(bin_count) vp.populate(rsi_history, vol_history, lookback) vp.calc_va(va_pct) vp.render(...)
Wskaźnik Pine Script®
od UAlgo
Volume Delta Profile BubblesVolume Delta Profile Bubbles 🔵 What is this indicator? Volume Delta Profile Bubbles is a unique indicator that combines two powerful concepts — Volume Profile and Volume Delta — to identify price levels where the market has reacted with significant volume AND strong directional pressure. Instead of showing a traditional vertical histogram on the price axis, this indicator stamps a bubble directly on the candle at the exact price level where the reaction occurred. The bigger the bubble, the more times that level has been confirmed over time. 🔵 How does it work? For each candle, the indicator analyzes two independent events: 🟢 Green bubble on the LOW — The lower wick is significant, buy volume is concentrated on the low, and that price level has been visited multiple times with the same bullish pressure. This identifies zones where the market found strong buyers. 🔴 Red bubble on the HIGH — The upper wick is significant, sell volume is concentrated on the high, and that price level has been visited multiple times with the same bearish pressure. This identifies zones where the market found strong sellers. A doji with long wicks on both sides can generate both a green bubble on the low and a red bubble on the high simultaneously — indicating a zone of strong contention from both sides. Volume is normalized using standard deviation (volume / stdev(volume, period)), which automatically adjusts for session differences. This means the indicator works correctly across Regular Trading Hours (RTH) and Extended Trading Hours (ETH) — a high volume candle in ETH is compared against typical ETH volumes, not RTH volumes. Bubble size reflects how many times that level has been confirmed: 🔵 Tiny → minimum confirmations 🔵 Small → 2x minimum confirmations 🔵 Normal → 3x minimum confirmations 🔵 Large → 4x minimum confirmations 🔵 Huge → 5x+ minimum confirmations 🔵 Parameters Price Tolerance (points) — The radius around a price level within which candles are considered "at the same level". Adjust based on your instrument's tick size. For XAUUSD use 0.3–0.8, for indices use 1–2. Volume Threshold (x std dev) — Minimum volume significance. At 1.0 many bubbles appear, at 2.0 only exceptional volume spikes trigger. Start at 1.5 and increase until bubbles visually align with clear market reactions. Delta Min % of candle volume — Minimum percentage of volume that must be concentrated on the wick to qualify as directional pressure. Lower to 15% for more signals, raise to 30%+ for high selectivity. Min Wick % of range — Minimum wick size relative to the total candle range. At 0.20 the wick must be at least 20% of the range. Raise to 0.30–0.40 to filter only candles with clear rejections. Min Confirmations — How many times the level must have been visited with the same characteristics before drawing a bubble. At 2 it is already selective. Raise to 3–4 to see only the most robust support/resistance levels. Lookback bars — How many bars back to calculate the Volume Profile. On low timeframes (1–5 min) use 200–300 to cover the current session. On higher timeframes (1H–4H) you can go up to 500. Normalization Period — The period for standard deviation calculation of volume. Default 200 is solid for most use cases. Transparency — Alpha of the bubbles. Since bubbles can overlap on the same level, lower transparency creates a natural gradient effect — overlapping bubbles become more visible. Alert Size — Minimum bubble size that triggers an alert. Set via dropdown: tiny / small / normal / large / huge. 🔵 Suggested Setups Breakout Setup (Bullish) When a medium-to-large green bubble forms and price subsequently closes above the bubble level, the market has absorbed all the selling pressure and buyers are in control. This often leads to an impulsive extension to the upside. Enter on the breakout candle or on a retest of the level. Liquidation Cascade Setup (Bearish) When price closes below a green bubble level with bearish bias, the long positions that accumulated at that level are being stopped out. Their stop losses become sell orders, adding further downward pressure. This often triggers a sharp bearish extension. The same logic applies in reverse for red bubbles — closes above a red bubble can trigger short squeeze extensions, closes below often lead to continuation. Confluence Setup A level with both a green and red bubble (visible on doji candles) is a zone of strong contention. When price returns to these levels, expect explosive moves in either direction. Wait for a clear directional close before committing. Size Matters Always prioritize large and huge bubbles — these represent levels tested and confirmed multiple times with significant volume. A huge green bubble on the low is a much stronger potential support than a tiny one. 🔵 Important Notes on Volume Data ⚠️ This indicator requires real volume data to function correctly. It will not work properly on instruments that do not provide actual traded volume. ✅ Works well on: Futures (ES, NQ, GC, CL), Crypto (BTC, ETH), Forex pairs on brokers that provide tick volume. ⚠️ Use with caution on: CFDs and some Forex pairs where volume data may represent tick count rather than actual traded volume. Results may be less reliable. ❌ Not suitable for: Instruments with no volume data at all. The Volume Delta calculation in this indicator is an approximation — without real tick-by-tick data, buy and sell volume are estimated based on wick proportions. On instruments with real volume data (futures, crypto), the approximation is reasonably accurate. On tick-volume instruments, treat the signals as directional bias indicators rather than precise measurements. 🔵 Call to Action If you find this indicator useful, please leave a comment sharing how you are using it and on which instruments. Your feedback helps improve future versions. 🚀 Boost the script if you want to support the development of more tools like this one. 📬 For questions, suggestions or bug reports, use the comment section below. ⚠️ Disclaimer This indicator is for educational and informational purposes only. It does not constitute financial advice, investment advice, or a recommendation to buy or sell any financial instrument. Past performance of any level identified by this indicator does not guarantee future results. Always use proper risk management and consult a qualified financial advisor before making any trading decisions. Trading involves substantial risk of loss.
Wskaźnik Pine Script®
od Burdiga84
HTF Floating Candles w/ Vol FP for Peasants [theUltimator5]This indicator is designed to pull higher-timeframe candles outside of the chart, and add the footprint volume data to give a complete snapshot of the Higher Timeframe (HTF) trading range and volume data without cluttering your view. This indicator is unique from my HTF Floating Candles w/ Volume Footprint script because it doesn't use the footprint call, opening it up to everybody and not just premium users. The tradeoff is that it doesn't calculate the net volume the same way and uses the total volume from each bar to approximate the buy and sell volume. Instead of forcing you to mentally reconstruct the most recent daily (or weekly/monthly) candle(s) while watching lower-timeframe price action, this script draws floating HTF candles to the right side of the chart and updates it live as the higher-timeframe bar develops. The default number of HTF candles is 1, but you can add up to 10 HTF candles. It also builds a row-by-row volume distribution across the active HTF candle price range and separates it into buy-side vs sell-side volume, displayed on opposite sides of the candle. This gives you a quick visual read on where volume has been concentrated inside the higher-timeframe structure — not just where price traveled. If you don't like seeing buy and sell volume on separate sides of the candles, you can stack them all on the left side like traditional volume footprint indicators. If you want more than 1 HTF candle, you can plot multiple. The volume footprint shows the volume profile of the entire plotted HTF candle range. You can configure the following display options: Position and size of HTF candles Number of HTF candles HTF timeframe Volume profile layout style Number of volume profile bars POC toggle Transparency toggle to highlight high volume rows Width of volume profile bars Colors & transparency Horizontal high/low toggle This indicator isn't a standalone trading indicator, but it is a visualization enhancement tool to give you a clean picture of the higher timeframe's price and volume data without the clutter.
Wskaźnik Pine Script®
od TheUltimator5
1
MFI Distribution [UAlgo]MFI Distribution is a statistics focused Money Flow Index indicator that combines a live MFI oscillator with a forward projected distribution histogram and normality diagnostics. Instead of only showing the current MFI line, the script collects a rolling history of MFI values, studies their distribution over a configurable lookback period, and visualizes the result as a histogram in the oscillator pane. The indicator is designed for traders who want to understand how MFI behaves as a distribution , not only where it is on the current bar. It provides a compact statistical framework that helps answer questions such as: Is MFI clustering around a narrow regime or spread across the full range Is the recent MFI behavior skewed toward strong buying or selling pressure Does the MFI sample look approximately normal, or is it fat tailed / asymmetric How extreme is the current reading relative to the recent distribution To support this, the script includes: A live MFI line with dynamic gradient coloring Overbought and oversold visual zones with gradient fills A histogram of MFI frequency distribution over the selected lookback An optional Gaussian curve overlay for visual comparison A statistical dashboard with mean, standard deviation, skewness, kurtosis, and Jarque Bera normality test results The histogram is drawn into the future area of the pane, so it does not interfere with the live MFI trace while still remaining visually aligned to the 0 to 100 oscillator scale. Educational tool only. Not financial advice. 🔹 Features 🔸 1) Live MFI Oscillator with Regime Aware Coloring The script plots a standard MFI line and colors it dynamically based on level behavior: High MFI values transition toward red tones Low MFI values transition toward green tones Mid range values remain purple This makes the oscillator easier to read at a glance, especially during sustained overbought or oversold conditions. 🔸 2) Overbought and Oversold Zone Visualization The indicator includes standard MFI reference levels at 80 and 20, then adds gradient fills that become visible when the MFI pushes into extreme zones. This provides better visual emphasis for momentum extremes without cluttering the chart. 🔸 3) Rolling MFI History Collection for Statistical Analysis The script maintains an internal array of the latest MFI values up to the user defined lookback length. This rolling sample is used to compute all distribution statistics and histogram frequencies on the last bar. This design keeps the indicator responsive while ensuring the displayed distribution reflects the most recent market behavior. 🔸 4) Forward Projected MFI Distribution Histogram A histogram is drawn in the oscillator pane using bins over the fixed MFI range from 0 to 100. Each bin counts how many MFI observations fall inside that interval during the lookback window. The histogram is projected to the right of current price action in the pane, giving users a clean distribution panel without covering the live MFI line. 🔸 5) Configurable Histogram Resolution and Width Users can control: Lookback period used for distribution analysis Number of histogram bins Visual width of the histogram in future bars This makes the tool flexible for both high level regime reading and finer distribution inspection. 🔸 6) Optional Gaussian Curve Overlay When enabled, the script overlays a theoretical normal distribution curve using the sample mean and sample standard deviation. The curve is normalized to the histogram height so users can visually compare the empirical MFI distribution against a bell curve shape. This is useful for quickly spotting asymmetry, multimodal clustering, or fat tail behavior. 🔸 7) Full Statistical Summary Dashboard A built in dashboard table displays: Mean Standard Deviation Skewness Kurtosis (excess kurtosis) Jarque Bera statistic Pass / Fail normality status (95% threshold logic) This turns the indicator into a compact quantitative diagnostic panel, not only a visual oscillator. 🔸 8) Jarque Bera Normality Test Classification The script evaluates whether the MFI sample is approximately normal using a Jarque Bera style test and a fixed chi square threshold (95% confidence, 2 degrees of freedom). It then marks the result as PASS (Normal) or FAIL (Non Normal). This helps traders distinguish between more stable oscillator regimes and structurally distorted ones. 🔸 9) Histogram Color Theme Based on Normality Result The histogram automatically changes style depending on the test result: Teal themed histogram when normality test passes Red themed histogram when normality test fails This creates an immediate visual signal of distribution quality without needing to read the dashboard first. 🔸 10) Last Bar Only Heavy Processing for Efficiency Statistical calculations, histogram drawing, and dashboard refresh are performed only on the last bar. This reduces object churn and improves performance while preserving real time utility. 🔸 11) Object Based Drawing Management The script uses custom types to organize logic: DistributionStats for statistical values and normality output HistoDrawer for histogram bars, curve lines, and labels This makes the code structured and easier to extend with future features such as percentiles, z scores, or alternate tests. 🔹 Calculations 1) MFI Calculation The script computes Money Flow Index from a user selected source and length: mfi_val = ta.mfi(mfi_src, mfi_len) This value is plotted in the oscillator pane and colored dynamically according to level. 2) Rolling History Buffer for Distribution Sampling Each valid MFI value is pushed into a rolling array used for statistical analysis: if not na(mfi_val) mfi_history.push(mfi_val) if mfi_history.size() > lookback mfi_history.shift() This ensures the sample size is capped at the selected lookback and continuously refreshed with recent values. 3) Sample Variance and Standard Deviation The script computes sample variance using the classic n minus 1 denominator: sum_sq_diff / (n - 1) Standard deviation is then calculated as: stats.stdev := math.sqrt(variance_val) Using sample variance is appropriate here because the lookback window is treated as a sample of recent market behavior. 4) Sample Skewness Calculation Skewness is computed from standardized deviations and corrected for sample size: (n * sum_cube_diff) / ((n - 1) * (n - 2)) Interpretation: Positive skew suggests more mass on lower values with a right tail toward high MFI prints Negative skew suggests more mass on higher values with a left tail toward low MFI prints 5) Excess Kurtosis Calculation The script calculates excess kurtosis , where a normal distribution is centered around 0: float term1 = (n * (n + 1) * sum_quad_diff) / ((n - 1) * (n - 2) * (n - 3)) float term2 = (3 * math.pow(n - 1, 2)) / ((n - 2) * (n - 3)) term1 - term2 Interpretation: Positive excess kurtosis suggests heavier tails or more peaked behavior Negative excess kurtosis suggests flatter distribution behavior 6) Jarque Bera Normality Test The script uses skewness and excess kurtosis to compute the Jarque Bera statistic: stats.jb_stat := (n / 6.0) * (math.pow(stats.skew, 2) + 0.25 * math.pow(stats.kurt, 2)) Then it compares the result against a 95 percent chi square critical value (2 degrees of freedom): stats.is_normal := stats.jb_stat < 5.991 Important note: The code defines a jb_p_value field in the stats type, but this version does not explicitly calculate or display a p value. The pass / fail logic is threshold based. 7) Fixed MFI Range Histogram Binning (0 to 100) The histogram always bins data over the full MFI range: float min_val = 0.0 float max_val = 100.0 float bin_size = (max_val - min_val) / bins Each MFI value is mapped to a bin index: int bin_idx = math.floor(val / bin_size) The index is clamped so values at boundaries stay valid: if bin_idx >= bins bin_idx := bins - 1 if bin_idx < 0 bin_idx := 0 This makes the histogram consistent across symbols and timeframes. 8) Frequency Counting and Peak Detection For each binned MFI observation, the script increments a frequency counter and tracks the highest bin count: int new_count = frequencies.get(bin_idx) + 1 frequencies.set(bin_idx, new_count) if new_count > max_freq max_freq := new_count The maximum frequency is later used to normalize histogram bar heights. 9) Histogram Rendering Geometry The histogram is drawn as boxes in the oscillator pane, projected to the right of the last bar: int start_bar = bar_index + 5 float base_y = 10.0 float available_height = 80.0 This effectively uses the MFI pane vertical range from about 10 to 90 for histogram height visualization, keeping it aligned with the oscillator scale. Each bin is mapped to x coordinates using its MFI interval and the user selected histogram width: int x_left = start_bar + math.round((bin_val_start / 100.0) * chart_width_bars) int x_right = start_bar + math.round((bin_val_end / 100.0) * chart_width_bars) Each frequency is mapped to a vertical height using: float bar_height_val = (freq / max_freq) * available_height 10) Histogram Color Logic from Normality Result The histogram color theme is selected from the Jarque Bera pass / fail result: Teal palette when stats.is_normal is true Red palette when stats.is_normal is false This creates a direct link between statistical classification and visual presentation. 11) Gaussian Curve Overlay Calculation The script defines a normal probability density function: (1.0 / (sigma * math.sqrt(2.0 * math.pi))) * math.exp(-0.5 * math.pow((x - mu) / sigma, 2)) For curve plotting: It samples points across the histogram width Maps each x position back to an MFI value from 0 to 100 Computes the PDF at that MFI value using the sample mean and standard deviation Scales the PDF by the theoretical peak so the curve fits the histogram height Key normalization idea: float pdf_peak = normal_pdf(stats.mean, stats.mean, stats.stdev) float current_y = base_y + (pdf_val / pdf_peak) * available_height This makes the Gaussian curve visually comparable to the empirical histogram, even though one is a density and the other is raw frequency. 12) Dashboard Table Metrics On the last bar, the script updates a table with the computed statistics: Mean StdDev Skewness Kurtosis Jarque Bera statistic and normality classification The result cell color changes based on normality: Green for PASS (Normal) Red for FAIL (Non Normal) This gives traders a compact quantitative summary next to the visual distribution. 13) Overbought and Oversold Gradient Fills The script adds gradient fills that appear when MFI moves beyond standard thresholds: fill(plot_mfi, p_ob, 100, 80, ...) fill(plot_mfi, p_os, 20, 0, ...) This helps contextualize whether the current MFI reading is extreme while the histogram and dashboard describe the broader behavior of the recent MFI sample.
Wskaźnik Pine Script®
od UAlgo
HTF Floating Candles w/ Volume Footprint [theUltimator5]This indicator is designed to pull higher-timeframe candles outside of the chart, and add the footprint volume data to give a complete snapshot of the Higher Timeframe (HTF) trading range and volume data without cluttering your view. IMPORTANT! This uses the new request.footprint() call, which may make this indicator only available to premium TradingView users. The request.footprint() doesn't assume all buy volume or all sell volume based on the direction of a candle, but instead uses actual footprint information to construct the volume footprints. Instead of forcing you to mentally reconstruct the most recent daily (or weekly/monthly) candle(s) while watching lower-timeframe price action, this script draws floating HTF candles to the right side of the chart and updates it live as the higher-timeframe bar develops. The default number of HTF candles is 1, but you can add up to 10 HTF candles. It also builds a row-by-row volume distribution across the active HTF candle price range and separates it into buy-side vs sell-side volume, displayed on opposite sides of the candle. This gives you a quick visual read on where volume has been concentrated inside the higher-timeframe structure — not just where price traveled. If you don't like seeing buy and sell volume on separate sides of the candles, you can stack them all on the left side like traditional volume footprint indicators. You can also plot the horizontal lines backwards on the chart to show where the high and low points for the candle occurred. If you want more than 1 HTF candle, you can plot multiple. The volume footprint shows the volume profile of the entire plotted HTF candle range. You can configure the following display options: Position and size of HTF candles Number of HTF candles HTF timeframe Volume profile layout style Number of volume profile bars Width of volume profile bars Colors & transparency Horizontal high/low toggle This indicator isn't a standalone trading indicator, but it is a visualization enhancement tool to give you a clean picture of the higher timeframe's price and volume data without the clutter.
Wskaźnik Pine Script®
od TheUltimator5
8
Volume Flow Analysis [UAlgo]Volume Flow Analysis is a market profile style volume study that builds a session anchored volume distribution, extracts key reference levels from the previous profile, and generates institutional style context signals based on Auction Market Theory concepts. The script combines several workflows in one tool: previous session volume profile levels (POC, VAH, VAL), liquidity void detection through LVN valleys, acceptance versus rejection logic around value, and Initial Balance with open type classification. The indicator runs on price ( overlay=true ) and is designed for intraday or swing traders who want a structured read of where value formed in the prior profile and how the current session is interacting with it. Instead of only plotting static lines, the script actively interprets behavior when price moves outside the previous value area. It checks whether the move is rejected quickly (failed auction) or sustained with time and volume (acceptance), which helps distinguish responsive activity from initiative activity. Another major component is the profile shape and liquidity void framework. The script identifies previous profile shape as P, b, or D based on POC location within the profile range, and it scans for LVN valleys that can act as low participation zones where price may travel quickly. This gives the user both structural context and event based signals from the same indicator. The result is a comprehensive volume flow dashboard that merges profile levels, session behavior, and AMT inspired signal logic into a single chart layer. 🔹 Features 🔸 1) Anchored Session Volume Profile (Daily, Weekly, Monthly or Custom Anchor) The script builds a volume profile for each anchor period selected by the user through the Profile Period (Anchor) input. Common choices include Daily, Weekly, and Monthly anchors. When a new anchor session begins, the current session profile is finalized and promoted to the previous profile, then a new profile begins. This allows the indicator to continuously reference the fully calculated previous profile while the current session is developing. 🔸 2) Price Range Binning with User Defined Resolution Each session profile is divided into a configurable number of rows (bins). The script maps price activity into these bins and distributes volume proportionally based on the overlap between each candle range and each volume bin. This creates a more realistic histogram than assigning all candle volume to a single price level, especially for wide range candles. 🔸 3) Previous Profile Core Levels (POC, VAH, VAL) Once a session completes, the script calculates and stores the key profile levels: POC (Point of Control), the price bin with the highest volume VAH (Value Area High) VAL (Value Area Low) Value Area is computed by expanding outward from the POC until the chosen percentage of total profile volume is covered. These levels are then plotted on the chart as dynamic reference lines for the next session. 🔸 4) Acceptance vs Rejection Logic Around Previous Value Area The indicator monitors current session behavior relative to the previous VAH and VAL and classifies behavior as either rejection (failed auction) or acceptance (initiative drive). Failed Auction (Rejection): Price trades outside the previous value area but returns back inside before meeting acceptance criteria. This is treated as a failed attempt to establish new value. Acceptance (Initiative Drive): Price stays outside the previous value area for a user defined number of bars and accumulates enough volume relative to average volume. This suggests successful acceptance of higher or lower value. This framework is useful for separating temporary probes from meaningful value migration. 🔸 5) Institutional Style Signal Labels The script can display signal labels for: Failed Auction Bullish and Bearish Acceptance Bullish and Bearish LVN Traversal Bullish and Bearish These labels appear directly on price and use user defined bullish and bearish colors for quick interpretation. 🔸 6) LVN Traversal (Liquidity Void / Vacuum) Detection The script detects low volume nodes as true local valleys in the previous profile histogram. A bin qualifies as an LVN when surrounding bins on both sides have higher volume for a chosen valley depth. If current price enters one of these prior LVN zones from above or below, the script marks a potential traversal event. This can help identify zones where price may move faster due to lower prior participation. 🔸 7) Previous Profile Shape Classification (P, b, D) The script classifies the previous profile shape based on where the POC sits within the full profile range: P shape if POC is near the upper portion of the profile b shape if POC is near the lower portion D shape if POC is near the middle This gives quick context about the prior session structure, which can support directional bias interpretation and session planning. 🔸 8) Initial Balance (IB) Tracking The indicator tracks the Initial Balance range using a user defined duration in minutes. During the IB window, it records session high and low. After the IB period ends, it can draw an IB box on the chart for visual reference. This is useful for intraday frameworks where the IB range is used as a key reference for breakout, reversal, and auction development. 🔸 9) Open Type Classification and Daily Bias At the start of each new anchor session, the script compares the new open to the previous value area and assigns a basic daily bias such as initiative bullish, initiative bearish, or responsive inside. After the IB period completes, it classifies the open type using rule based conditions, including: Open Drive Bullish / Bearish Open Rejection Reverse Bullish / Bearish Open Test Drive Bullish / Bearish This adds a session narrative layer on top of the profile levels. 🔸 10) Previous Profile Histogram Visualization on Last Bar On the last bar, the script can render the previous profile histogram as a horizontal bar style distribution using boxes. Bins inside the previous value area can be colored differently from bins outside value. This provides an at a glance visual summary of where prior volume concentrated, without needing a separate profile tool. 🔸 11) Extensive Visual Customization Users can configure colors for: Previous POC Previous VA levels Histogram bins Value area histogram bins Bullish signals Bearish signals This makes it easy to integrate the indicator into existing chart themes and workflows. 🔸 12) Structured Object Based Design The script uses custom types ( VolumeBin and SessionProfile ) to store profile state, bins, levels, shape, and LVN zones. This object based approach keeps the logic modular and easier to maintain as features are added. 🔹 Calculations 1) Session Detection and Profile Lifecycle A new profile session is detected with: bool isNewSession = timeframe.change(i_anchor) When a new session begins: The current profile is finalized (end bar, profile calculations) The current profile becomes the previous profile A fresh session profile starts from the current bar This design ensures that current session logic can reference a fully completed previous profile with stable POC, VAH, VAL, shape, and LVN data. 2) Volume Profile Bin Initialization Each session profile is divided into i_rows equal price bins between session low and session high: float step = (this.highestPrice - this.lowestPrice) / rows for i = 0 to rows - 1 float bottom = this.lowestPrice + (i * step) float top = bottom + step this.bins.push(VolumeBin.new(top, bottom, 0.0)) As the current session high or low changes, the script rebuilds the current profile bins and repopulates volume from session start to the current bar. This keeps the current profile geometry aligned with the latest session range. 3) Proportional Volume Distribution Across Bins For each candle, the script distributes volume across all bins according to candle range overlap: float overlapTop = math.min(h, bin.priceTop) float overlapBottom = math.max(l, bin.priceBottom) if overlapTop > overlapBottom float overlapRatio = (overlapTop - overlapBottom) / barRange float volToAdd = v * overlapRatio bin.volumeTotal += volToAdd this.totalVolume += volToAdd Interpretation: Volume is allocated proportionally to the fraction of the candle range overlapping each price bin. This is a practical approximation of intrabar volume distribution across price. Special handling exists for zero range candles, where volume is assigned to the bin containing the candle price. 4) POC Detection and Profile Max Volume After session completion, the script scans all bins to find the highest volume bin: for i = 0 to this.bins.size() - 1 VolumeBin bin = this.bins.get(i) if bin.volumeTotal > maxVol maxVol := bin.volumeTotal pocIndex := i The POC price is set to the midpoint of that bin: this.pocPrice := (pocBin.priceTop + pocBin.priceBottom) / 2 The script also stores maxVolume , which is later used to scale histogram width display on the chart. 5) Value Area Calculation (VAH / VAL) The Value Area is built by expanding outward from the POC until the target percentage of session volume is reached: float targetVol = this.totalVolume * (vaPct / 100.0) float currentVol = pocBin.volumeTotal int upperIndex = pocIndex int lowerIndex = pocIndex At each step, the script compares the next upper and lower bin volumes and expands toward the larger volume side first. This continues until the cumulative value area volume reaches the target percentage. Final levels: this.vahPrice := this.bins.get(upperIndex).priceTop this.valPrice := this.bins.get(lowerIndex).priceBottom This is a standard volume profile style value area expansion method centered on POC. 6) Previous Profile Shape Classification (P, b, D) The profile shape is inferred from the POC position inside the profile range: float profileRange = this.highestPrice - this.lowestPrice float pocPosPct = (this.pocPrice - this.lowestPrice) / profileRange Classification logic: P shape if POC is at or above 70 percent of the range b shape if POC is at or below 30 percent D shape otherwise This is a simplified but practical shape proxy based on volume concentration location. 7) LVN (Liquidity Void) Valley Detection The script identifies LVNs as local volume minima among profile bins, using a user defined valley depth i_lvnDepth . A bin is treated as an LVN if the bins on both sides for the specified depth all have greater volume: for j = 1 to lvnDepth if this.bins.get(i - j).volumeTotal <= currentBin.volumeTotal or this.bins.get(i + j).volumeTotal <= currentBin.volumeTotal isValley := false break Only non zero volume bins are considered. Detected LVNs are stored in this.lvnZones for use in later traversal signals. 8) Initial Balance (IB) Calculation At the start of a new session, the script resets IB state and starts tracking the session open, session start time, and current IB high and low. While the market is still inside the IB duration: ibHigh := math.max(ibHigh, high) ibLow := math.min(ibLow, low) IB tracking ends once the elapsed time exceeds the configured duration in minutes: if (time - sessionStartTime) >= i_ibMins * 60000 inIb := false This produces the opening range used for later visualization and open type classification. 9) Daily Bias and Open Type Classification At each new session open, the script sets a basic bias by comparing the session open to the previous value area: Open above previous VAH suggests initiative bullish Open below previous VAL suggests initiative bearish Open inside previous value suggests responsive / inside After the IB period ends, the script classifies the open type using rule based comparisons among: Open location relative to previous VAH / VAL Close relative to IB highs and lows Intraday test and rejection behavior around prior value Examples from the code include: "Open-Drive Bullish" "Open-Rejection-Reverse Bearish" "Open-Test-Drive Bullish" This gives a structured session narrative that aligns with many profile and AMT workflows. 10) Acceptance vs Failed Auction Logic (Above VAH) The script tracks consecutive bars and cumulative volume when price closes above the previous VAH: if close > prevVah barsAboveVah += 1 volAboveVah += volume If price returns inside value before acceptance is confirmed, it prints a failed auction bearish signal (fade breakout logic): if barsAboveVah > 0 and not acceptedAbove and i_sigFailedAuc isFailedAucBear := true Acceptance bullish is confirmed only if both time and volume thresholds are satisfied: if barsAboveVah >= i_accBars and volAboveVah >= (avgVol * i_accVolMult) and not acceptedAbove and i_sigAccept acceptedAbove := true isAcceptBull := true This is a practical combination of time and participation filters, which reduces false acceptance signals from brief low volume excursions. 11) Acceptance vs Failed Auction Logic (Below VAL) The same framework is applied below the previous VAL: Tracking closes below VAL: if close < prevVal barsBelowVal += 1 volBelowVal += volume Failed auction bullish if price returns inside before acceptance: if barsBelowVal > 0 and not acceptedBelow and i_sigFailedAuc isFailedAucBull := true Acceptance bearish if time and volume thresholds are met: if barsBelowVal >= i_accBars and volBelowVal >= (avgVol * i_accVolMult) and not acceptedBelow and i_sigAccept acceptedBelow := true isAcceptBear := true This creates a symmetric AMT style signal model for both sides of value. 12) LVN Traversal Signal Logic If LVN traversal signaling is enabled, the script checks whether price enters a previous LVN zone from outside: Bullish traversal candidate when price enters the LVN from below Bearish traversal candidate when price enters the LVN from above Code logic example: if close > lvn.priceBottom and close < lvn.priceTop and close < lvn.priceBottom isLvnTravBull := true This flags the moment price enters a potential liquidity void zone where faster movement may occur. 13) Previous Profile Histogram Rendering on Last Bar On the last chart bar, the script draws the previous session histogram using boxes. Width is normalized by each bin volume relative to the profile max volume: float widthRatio = bin.volumeTotal / previousProfile.maxVolume int boxRight = bar_index + math.round((rightBar - bar_index) * widthRatio) Bins inside VAH and VAL are colored using the value area histogram color, while other bins use the general histogram color. This gives a compact visual profile snapshot without external tools. 14) Dynamic Plots for Previous POC, VAH, and VAL The previous profile reference levels are continuously plotted as line break style plots: plot(plotPoc, "Prev POC", color=i_colPoc, linewidth=2, style=plot.style_linebr) plot(plotVah, "Prev VAH", color=i_colVa, linewidth=1, style=plot.style_linebr) plot(plotVal, "Prev VAL", color=i_colVa, linewidth=1, style=plot.style_linebr) These lines provide stable reference levels throughout the current session and form the basis for the acceptance, rejection, and open type logic.
Wskaźnik Pine Script®
od UAlgo
Quantum Adaptive Session Profile v4Quantum Adaptive Session Profile (SVP) - The Dynamic Roadmap Overview Traditional Volume Profiles and anchored VWAPs are incredibly useful, but they suffer from rigidity. When a market abruptly accelerates—like the New York session open on Gold or the Nasdaq—standard VWAP levels lag behind the true mean, leaving traders looking for pullbacks that never arrive. The Quantum Adaptive Session Profile (SVP) solves this by calculating a "Dynamic VWAP" using an Efficiency Ratio engine. The Point of Control (POC) and Value Areas automatically speed up to track explosive momentum, giving you real-time structural levels that actually respect the current market velocity. Key Highlights • The Adaptive Point of Control (POC): This acts as the session's dynamic fair value. During chop, it remains steady. When a breakout occurs, the alpha logic catches the volatility shift and aggressively pulls the POC to trail the new trend. • Dynamic Value Areas (VAH / VAL): The Value Area High and Value Area Low expand and contract around the POC based on real-time standard deviations, mapping out the true "value" zone of the active session. • Session Automation: Set your custom session hours in the inputs (e.g., London Open to NY Close). The indicator will automatically draw, track, and cleanly reset itself at the start of each new session to prevent historical data from polluting your current intraday levels. • Fully Customizable Visuals: Take complete control over the colors and thickness of the POC, VAH, VAL, and background fill to match your personal chart aesthetic perfectly. How to Trade It 1. The Range Market (Mean Reversion): When the Value Area bands are relatively flat, treat the VAH as resistance and the VAL as support. Fade the edges back toward the POC. 2. The Trend Market (Break & Retest): When price breaks strongly outside the VAH or VAL and the bands begin to aggressively angle upward/downward, the market is in price discovery mode. Do not fade this. Instead, wait for a pullback to the VAH (in an uptrend) or the VAL (in a downtrend) for continuation entries. 3. The Session Shift: Pay close attention to how price reacts to the POC during the first hour of your defined session. Staying above it implies buyer control for the day; staying below implies seller dominance. The Quantum Ecosystem Integration The Adaptive SVP is your structural roadmap on the main chart. It is designed to be paired with the Quantum sub-chart indicators for absolute precision: 1. Quantum Confluence : When price retraces to your Adaptive POC, look at Trendilo. If Trendilo flashes a Regular Divergence or glows Neon in the direction of the macro trend, you have a high-probability entry right off the structural level. 2. Quantum Z-Score : Combine VAH/VAL touches with extreme Z-Score readings (+2.0 / -2.0) to validate true exhaustion and snipe the reversal. 3. Quantum Main Chart Divergence: Use this to spot immediate structural momentum shifts exactly as price taps your SVP levels. ⚠️ DISCLAIMER: STRICTLY FOR EDUCATIONAL PURPOSES The information, scripts, and concepts provided in this publication are for educational and informational purposes only and do not constitute financial, investment, or trading advice. Trading in financial markets (including Forex, Crypto, Stocks, and Commodities) carries a high level of risk and may not be suitable for all investors. You could lose some or all of your initial investment. Past performance is not indicative of future results. Always conduct your own due diligence, backtest any strategy thoroughly, and consult with a certified financial advisor before making any trading decisions. By using this script, you acknowledge that you are solely responsible for your own trading actions and outcomes.
Wskaźnik Pine Script®
od kimlombard
1
BK AK-Ghost Ladder👻 BK AK–Ghost Ladder — FVG Zones, Volume Profile, Confluence, Lifecycle 👻 🙏 All glory to G-d. Built with standards and discipline passed down by my mentor — thank you for the relentless insistence on structure over noise, and for sharing real knowledge with generosity — no gatekeeping, no cheapness, no games. Update / Record A previous version of this publication was hidden due to insufficient description. This republish is a complete explanation of what the script does, how it works, how to use it, and what its limits are. What this script does Ghost Ladder is an overlay indicator that detects Fair Value Gaps (FVGs) and manages them as “living” support/resistance zones. It doesn’t just draw rectangles — it tracks each zone’s behavior (touches, breaks, role flips), grades strength (0–100), optionally builds an in-zone volume profile with POC, and adds confluence layers like pivots, MTF alignment, Fibonacci proximity, delta imbalance, sessions, and divergence warnings. The goal is not prediction — it’s structured context: which zones matter, why they matter, and how price is interacting with them now. Core features (what you’ll see on chart) 1) FVG detection (bull + bear) Uses classic 3-bar gap logic: Bullish FVG: low > high and gap size > ATR threshold Bearish FVG: high < low and gap size > ATR threshold Includes timeframe-adaptive distance filters (different settings under 1H vs ≥1H). 2) Zone lifecycle management Each zone is stored and managed over time: Expiration by max age (bars) Optional “reset age on touch” Optional overlap prevention / “keep strongest” Optional proximity rules (minimum bars between zones) “Clean mode” display (shifts/extends boxes for cleaner viewing) 3) Strength score (0–100) + ★ rating Each zone gets a composite Strength Score that can include: Volume vs average (optionally using lower timeframe volume aggregation) Gap size vs ATR Pivot confluence count MTF confluence (additional timeframes) Session weighting (Asia / London / NY / overlap) Order block + imbalance checks VWAP proximity/extreme bonus Fib confluence Delta divergence Clustering / consolidation bonus Role reversal bonus (support flips to resistance and confirms) The star label displays score tiers (configurable thresholds): ★★, ★★★, ★★★★, ★★★★★ 4) In-zone Volume Profile + POC (optional) For each zone, Ghost Ladder can compute a lower-TF volume profile proxy inside the zone: Configurable bins (resolution) POC line (most volume concentration in-zone) Optional total zone volume label Optional delta coloring on POC (buy vs sell pressure) Note: this is a practical proxy using lower-TF bar volumes/close locations — it is not exchange-level true volume-at-price. 5) Smart positioning / role logic (S/R behavior) Optional “Smart Positioning” modes: Show All Hide Wrong Side Auto Role Flip (support ↔ resistance based on price location + buffer) Role reversal tracking: Break detection (body break optional) Break confirmation bars Broken-zone persistence for N bars Reactivation badge when zone becomes relevant again 6) Real-time divergence warnings (optional) When price is interacting with a zone, it can flag divergence/weakness conditions using: RSI divergence thresholding OBV divergence (optional) ADX weak-momentum check (optional) You can choose how it displays: Border only / icon only / both / color change 7) Fibonacci confluence (optional) Computes fib levels from a lookback swing (highest/lowest over period), then counts if fib levels fall inside/near a zone (tolerance %). Optional fib lines + labels (with “only current fib” cleanup). 8) Adaptive learning + backtesting (optional) Zones can be evaluated after touches: “Success” if price moves away by a threshold “Failure” if price violates beyond a threshold Tracks wins/losses per zone Updates an adaptive weight periodically Optional ML-style confidence badge when sample size is meaningful This is not a machine-learning model in the academic sense — it’s a performance-based weighting and confidence heuristic. 9) Info Table (optional) A compact “war room” table on the last bar summarizing: Active zone counts (bull vs bear) Current market posture (near support/resistance, above/below, neutral) Nearest S/R levels Bias estimate Active session Risk assessment 10) Alerts Built-in alert conditions include: Magnetic pull active (price entering magnetic range of a strong zone) Strong bullish FVG / strong bearish FVG (high strength score) Divergence detected while price touches a zone How to use (simple workflow) Start with the stars: focus on ★★★★–★★★★★ zones first. Trade the edges, not the middle: entries are usually better at zone boundaries with defined invalidation. Respect role flips: a broken zone that flips and confirms can become a higher-quality level than a fresh gap. Use divergence as a brake: divergence-at-zone = reduce size, wait for confirmation, or stand down. Let filters remove excuses: tune distance filters, minimum stars, institutional-only mode, session weighting to match your market + timeframe. Badge / icon legend (labels) Depending on enabled features, labels may include: 🔥 = cluster / stacked zones 🎯 = pivot confluence ⚡ = MTF confluence 📐 = fib confluence ⚠ = delta divergence / warning 🔗 = merged / consolidated 📈 = upgraded to “institutional” classification 🤖 = confidence badge (sample-size based) 🔄 = reactivated zone Repaint / reliability notes (important) FVG zones: detected from past bars ( reference) → does not require future bars. Pivot markers: use ta.pivothigh/ta.pivotlow → pivots confirm after pivotPeriod bars. That’s normal and means pivot signals are delayed/confirmed, not “future-looking.” Lower-TF volume profile: depends on available lower timeframe data; can be heavier and may vary slightly by broker/feed. Scores/labels: update as new touches, breaks, and confirmations occur (expected “living” behavior). Performance / chart limits This script uses many drawing objects (boxes/lines/labels) and can be resource-heavy: Reduce profile bins, disable volume profile, or increase filters if you hit object limits or slowdowns. “Clean Mode” can simplify the on-chart clutter. Disclaimer This indicator is for educational and analytical purposes only. It does not provide financial advice and does not guarantee outcomes. All “institutional / smart money / confidence” terminology is heuristic scoring, not a claim of certainty. 🙏 All glory to G-d — may He bless your vision, patience, and discipline at the boundary.
Wskaźnik Pine Script®
od Ki11a_B
HTF Candle Profile [UAlgo]HTF Candle Profile is a higher timeframe candle visualization tool that rebuilds each selected HTF candle from the lower timeframe bars that form it, then projects a horizontal volume profile inside that HTF candle range. The goal is to make intrabar participation visible directly on the price chart, so you can see where volume concentrated within the candle, where it was thin, and where the dominant traded price level emerged. Instead of treating a daily or four hour candle as a single block, the script aggregates the lower timeframe bars as they arrive and distributes their volume across price bins covering the HTF candle’s high to low range. The result is a compact profile drawn from the start time of the HTF candle toward the right, with width proportional to relative volume per bin and color intensity driven by a gradient. This provides a fast read of internal structure: balanced candles, directional candles, rejection wicks, and consolidation pockets become easier to interpret because you can see the volume distribution inside the candle. The indicator draws on the main chart and keeps a small rolling history of recent HTF candles to stay responsive and to respect object limits. 🔹 Features 1) Multi Timeframe HTF Candle Reconstruction The script listens for a new HTF candle event using the selected timeframe input. When a new HTF candle begins, the previous one is finalized and drawn. During the active HTF candle, each incoming lower timeframe bar updates the running OHLC and stores its high, low, and volume for profiling. This approach enables a live building profile for the current HTF candle while preserving completed profiles for recent candles. 2) Intrabar Volume Profile Built from LTF Data For each HTF candle, the price range from low to high is divided into a user defined number of bins. Each lower timeframe bar contributes volume into all bins it spans. Volume is distributed evenly across the spanned bins to approximate participation within that bar’s range. This produces a per bin volume distribution that is stable and visually interpretable even when lower timeframe candles have large ranges. 3) Gradient Based Profile Intensity Each bin is drawn as a horizontal box. Its color comes from a gradient that maps low volume to a softer profile color and high volume to a stronger profile color. This makes it easy to spot high participation nodes and low participation voids within the HTF candle. Inputs allow independent control for bullish and bearish candle coloring and for the low volume and high volume profile colors. 4) POC Line Option The script can optionally plot a POC line representing the price level of maximum volume within the HTF candle. This is drawn as a dashed horizontal line that spans the candle’s start time to end time. POC is often used as a reference for acceptance, fair value, or a magnet level during retracements. 5) Candle Body, Wick, and Time Boundaries To keep the profile anchored and readable, the script also draws: A translucent body box from HTF open to HTF close A vertical wick line from HTF high to HTF low A dotted start boundary and a dotted end boundary for the HTF candle window These elements provide context so the profile is always interpreted within the candle structure that produced it. 6) Object Management and Rolling History To keep charts clean and avoid exceeding platform limits, the script maintains a small history of HTF candles and deletes drawings for older ones. Each candle owns its objects and can fully clear them when removed from the rolling window. 🔹 Calculations 1) New HTF Candle Detection A new candle event is detected using timeframe change on the selected timeframe: isNew = timeframe.change(tf) When isNew is true: The previous HTF candle is finalized by setting its end time and drawing it A new HTF candle object is created and added to the array Old candles beyond the history limit are removed and their drawings deleted 2) HTF Candle Aggregation from LTF Bars Each incoming lower timeframe bar updates the active HTF candle: method addLtf(HtfCandle this, float h, float l, float c, float v) => this.ltfData.push(LtfBar.new(h, l, v)) this.h := math.max(this.h, h) this.l := math.min(this.l, l) this.c := c Interpretation: High is updated to the maximum seen so far within the HTF candle window Low is updated to the minimum seen so far Close is updated to the most recent close Each LTF bar is stored with its high, low, and volume for later bin distribution 3) Bin Construction Across the HTF Candle Range When drawing a candle, the script divides the HTF range into binCount segments: float step = (this.h - this.l) / bCount for i = 0 to bCount - 1 this.bins.push(ProfileData.new(this.l + i * step, this.l + (i + 1) * step, 0.0, na)) Each bin stores: minP and maxP boundaries accumulated volume for that price segment a box handle for drawing 4) Volume Distribution from Each LTF Bar into Bins For each stored LTF bar, the script determines which bins the bar spans and distributes volume evenly across them: int startIdx = int((ltf.l - this.l) / step) int endIdx = int((ltf.h - this.l) / step) startIdx := math.max(0, math.min(startIdx, bCount - 1)) endIdx := math.max(0, math.min(endIdx, bCount - 1)) int spanned = endIdx - startIdx + 1 float vPerBin = ltf.v / spanned for j = startIdx to endIdx ProfileData b = this.bins.get(j) b.vol += vPerBin Interpretation: The bar range is mapped to bin indexes Indexes are clamped so they remain inside the array Volume is divided by the number of spanned bins Each spanned bin receives an equal share of that bar’s volume This is a robust approach for intrabar profiling without tick data. 5) POC Computation The script finds the bin with the maximum accumulated volume and sets the POC price at the midpoint of that bin: float maxVol = 0.0 float pocP = na for b in this.bins if b.vol > maxVol maxVol := b.vol pocP := math.avg(b.minP, b.maxP) If enabled, a dashed POC line is drawn across the HTF candle window: if sPoc and not na(pocP) this.lPoc := line.new(x1=this.st, y1=pocP, x2=this.et, y2=pocP, xloc=xloc.bar_time, color=cPoc, style=line.style_dashed, width=2) 6) Profile Box Width Scaling Each bin’s box width scales by its volume relative to the maximum volume bin. Width is capped as a fraction of the candle’s time duration: int duration = math.max(this.et - this.st, 1) int volWidth = int((duration * 0.40) * (b.vol / maxVol)) int boxRight = this.st + volWidth Interpretation: duration represents the HTF candle time width 0.40 is the maximum profile width fraction of the candle duration b.vol / maxVol converts volume to a normalized ratio boxRight is calculated so all profile boxes start at the candle start time and extend rightward based on volume 7) Gradient Coloring of the Profile Each bin color is mapped from low volume to high volume using a gradient: color gradColor = color.from_gradient(b.vol, 0, maxVol, cLow, cHigh) This keeps low participation zones visually lighter and high participation zones more prominent. 8) Candle Body and Wick Drawing The script draws an HTF candle body box and a wick line for context: float topP = math.max(this.o, this.c) float botP = math.min(this.o, this.c) this.bBody := box.new(left=this.st, top=topP, right=this.et, bottom=botP, xloc=xloc.bar_time, bgcolor=color.new(c, 85)) this.lWick := line.new(x1=midTime, y1=this.h, x2=midTime, y2=this.l, xloc=xloc.bar_time, color=color.new(c, 30), width=2) It also draws start and end boundary lines so the candle window is clearly defined in time.
Wskaźnik Pine Script®
od UAlgo
2
Delta Ladder Order Flow [UAlgo]Delta Ladder Order Flow is an overlay order flow visualizer that builds a per bar delta ladder using lower timeframe candles as an intrabar proxy. For each recent bar, the script pulls the underlying lower timeframe open, high, low, close, and volume arrays, then distributes volume into discrete price buckets. Each bucket accumulates estimated buy volume and sell volume, producing a ladder that resembles a footprint style view. The display focuses on three core outputs: A delta heatmap ladder where each price level is colored by net delta dominance A Point of Control highlight that marks the highest total volume level inside the bar A stacked imbalance detector that scans diagonally across levels to identify aggressive one sided participation and optionally projects that stack forward The system is designed with stability controls for real world chart conditions. It includes dynamic scaling to prevent excessive level counts on high range bars, object budgeting through bars to draw limits, and text filtering to reduce clutter. 🔹 Features 1) Intrabar Resolution via Lower Timeframe Data The ladder is constructed using request.security_lower_tf. You select an Intrabar Resolution timeframe that must be lower than the chart timeframe. The script then receives arrays of LTF candles for each chart bar and uses them as a proxy for footprint style aggregation. This approach provides a practical order flow approximation on TradingView charts without requiring native tick level data. 2) Ladder Aggregation with Tick Size Multiplier Price levels are aggregated using the symbol mintick multiplied by a user multiplier. Increasing the multiplier produces thicker ladder steps and fewer levels. Decreasing it produces finer granularity but increases the number of boxes drawn. This control is critical for balancing detail versus performance across different symbols and volatility regimes. 3) Dynamic Scaling to Prevent High Range Bar Overload A single volatile bar can contain too many price steps if the granularity is too fine. To prevent crashes, the script estimates how many steps would be required for the bar and increases the effective step size when the raw step count exceeds Max Levels per Bar. This keeps rendering stable even during high volatility events while still maintaining a consistent ladder representation. 4) Buy, Sell, and Neutral Volume Attribution Each LTF candle’s direction is inferred from its open and close: Close above open is treated as buy side volume Close below open is treated as sell side volume Close equal open is treated as neutral and split evenly between buy and sell Volume is then distributed across the price buckets covered by the LTF candle range so that wide candles spread their influence across multiple levels. 5) Delta Heatmap Ladder with Intensity Scaling Each price bucket computes delta as buy volume minus sell volume and total volume as the sum of both. Ladder cells are colored positive or negative based on delta sign, and transparency is scaled by how dominant the delta is relative to the maximum total volume level inside that bar. This yields a compact heatmap where strong imbalances visually stand out. A square root curve is applied to intensity to improve mid tone visibility without making everything fully opaque. 6) Point of Control Highlight The ladder tracks the price level with the highest total volume and marks it as the Point of Control. When enabled, the POC row uses a dedicated border color and a stronger border width so the acceptance anchor is immediately visible. 7) Stacked Imbalance Detection and Projection The script can detect stacked diagonal imbalances. It compares volume across adjacent price levels using a diagonal logic similar to footprint tools: Bullish diagonal checks buy volume at a level versus sell volume at the level below Bearish diagonal checks sell volume at a level versus buy volume at the level above An imbalance requires the winning side to exceed the losing side by the configured Imbalance Ratio and also exceed a minimum volume threshold to filter low volume noise. When consecutive imbalanced levels reach the Stacked Levels count, the stack is marked and optionally extended forward as a zone. Stack members also override normal heatmap coloring and are rendered more solid for emphasis. 8) Clean Visual Controls Several options support readability: Bars to Draw limits workload and object count Show Delta Values can be toggled on or off Min Delta to Show Text filters small prints Ladder Width percent controls how wide the ladder is relative to the bar space Text size can be adjusted for different chart zoom levels Box outline can be hidden by default for a cleaner footprint aesthetic 🔹 Calculations 1) Intrabar data acquisition (lower timeframe arrays) The script requests arrays of LTF OHLCV values for each chart bar using request.security_lower_tf. ltf_open = request.security_lower_tf(syminfo.tickerid, tf_input, open) ltf_close = request.security_lower_tf(syminfo.tickerid, tf_input, close) ltf_high = request.security_lower_tf(syminfo.tickerid, tf_input, high) ltf_low = request.security_lower_tf(syminfo.tickerid, tf_input, low) ltf_vol = request.security_lower_tf(syminfo.tickerid, tf_input, volume) These arrays contain the lower timeframe candles that make up each chart bar. Each chart bar index has its own embedded array. 2) Base tick step (bucket size control) Bucket size starts from mintick multiplied by Tick Size Multiplier. var float base_tick_step = syminfo.mintick * tick_size_mult This is the baseline price increment used to build the ladder levels. 3) Last bar execution model (performance design) The script only builds and draws ladders when barstate.islast is true. It then reconstructs the last N bars using an index offset. if barstate.islast int start_idx = math.max(0, bar_index - bars_to_draw + 1) for i = start_idx to bar_index int offset = bar_index - i float arr_o = ltf_open float arr_c = ltf_close float arr_h = ltf_high float arr_l = ltf_low float arr_v = ltf_vol This design dramatically reduces CPU and memory load compared to updating every bar. 4) Dynamic scaling per bar (anti crash protection) For each bar, the script estimates how many price steps would be needed using the current bucket size. If that count exceeds Max Levels per Bar, it increases the step size only for that bar. float bar_h = high float bar_l = low float bar_range = bar_h - bar_l float raw_steps = bar_range / base_tick_step int scaler = 1 if raw_steps > max_levels_per_bar scaler := int(math.ceil(raw_steps / max_levels_per_bar)) float current_tick_step = base_tick_step * scaler Result: Calm bars use fine granularity High range bars are automatically compressed into fewer buckets 5) LTF candle direction classification (buy, sell, neutral) Each LTF candle is classified using its open and close. Neutral candles split volume evenly. bool is_buy = c > o bool is_sell = c < o bool is_neutral = c == o This is a heuristic proxy for aggressor side. It is not true bid ask data. 6) Align LTF candle range to bucket grid The candle low and high are rounded to the current tick step so bucket prices align cleanly. float low_aligned = math.round(l / current_tick_step) * current_tick_step float high_aligned = math.round(h / current_tick_step) * current_tick_step 7) Step counting and volume per step The script computes how many bucket levels the candle touches and divides volume equally across them. int steps = int(math.round((high_aligned - low_aligned) / current_tick_step)) + 1 if steps > 500 steps := 500 float vol_per_step = v / steps This means wide candles distribute volume across more ladder cells, while tight candles concentrate volume into fewer cells. 8) Writing volume into the ladder map (PriceLevel storage) Each chart bar owns a DeltaLadder with a map of price to PriceLevel. Each PriceLevel stores buy and sell volume. Volume is added step by step. type PriceLevel float price float buy_vol = 0.0 float sell_vol = 0.0 type DeltaLadder int bar_idx map levels float min_price = 10000000.0 float max_price = 0.0 float max_vol_level = 0.0 float poc_price = na float poc_vol = 0.0 The add method updates volumes and also tracks max volume and POC: method add_volume(DeltaLadder this, float price, float vol, bool is_buy, bool is_neutral) => if not this.levels.contains(price) this.levels.put(price, PriceLevel.new(price)) PriceLevel lvl = this.levels.get(price) if is_neutral lvl.buy_vol += vol * 0.5 lvl.sell_vol += vol * 0.5 else if is_buy lvl.buy_vol += vol else lvl.sell_vol += vol float t = lvl.total() if t > this.max_vol_level this.max_vol_level := t if t > this.poc_vol this.poc_vol := t this.poc_price := price The main loop calls this method for each bucket level touched by each LTF candle: for p = 0 to steps - 1 float level_price = low_aligned + (p * current_tick_step) ladder.add_volume(level_price, vol_per_step, is_buy, is_neutral) 9) Delta and total volume formulas Delta and total are defined as methods on PriceLevel. method delta(PriceLevel this) => this.buy_vol - this.sell_vol method total(PriceLevel this) => this.buy_vol + this.sell_vol These values drive both coloring and POC selection. 10) Stacked imbalance detection (diagonal footprint logic) Prices are sorted so neighbor comparisons are correct. A stack_map stores whether each price belongs to a bullish or bearish stacked run. float prices = ladder.levels.keys() array.sort(prices) map stack_map = map.new() Diagonal comparisons: Bullish diagonal compares BuyVol at level i with SellVol at level below i minus 1 Bearish diagonal compares SellVol at level i with BuyVol at level above i plus 1 Bullish check includes a zero handling rule: if i > 0 float p_below = array.get(prices, i-1) PriceLevel lvl_below = ladder.levels.get(p_below) if lvl_below.sell_vol == 0 if lvl.buy_vol > imb_min_vol direction := 1 else if lvl.buy_vol > lvl_below.sell_vol * imb_ratio and lvl.buy_vol > imb_min_vol direction := 1 Bearish check includes symmetric logic: if i < array.size(prices) - 1 float p_above = array.get(prices, i+1) PriceLevel lvl_above = ladder.levels.get(p_above) if lvl_above.buy_vol == 0 if lvl.sell_vol > imb_min_vol direction := -1 else if lvl.sell_vol > lvl_above.buy_vol * imb_ratio and lvl.sell_vol > imb_min_vol direction := -1 Runs are tracked and only accepted if the number of consecutive levels meets the stacked requirement: if math.abs(i - run_start_idx) >= stack_count for k = run_start_idx to i - 1 stack_map.put(array.get(prices, k), run_dir) The script also draws a projected zone for the detected stack band: box.new(right_time, p_top + current_tick_step/2, right_time + 1000 * 60 * 60 * 24, p_bot - current_tick_step/2, xloc=xloc.bar_time, border_width=0, bgcolor=color.new(c_stack, 85), extend=extend.right) 11) Heatmap intensity and transparency mapping For each price level, intensity is computed as abs(delta) relative to the maximum total volume level in the bar, then curved and mapped into transparency. float intensity = ladder.max_vol_level > 0 ? math.abs(delta) / ladder.max_vol_level : 0 intensity := math.min(intensity, 1.0) float curved_intensity = math.sqrt(intensity) float transp = 97 - (curved_intensity * 57) Stacked members force stronger visibility: if stack_map.contains(p) intensity := 1.0 transp := 30 12) POC marking in the drawing pass POC is detected during volume accumulation, then used in rendering to upgrade the border style for that cell. bool is_poc = show_poc and (p == ladder.poc_price) color border_c = is_poc ? col_poc : col_outline int border_w = is_poc ? 2 : 1 13) Delta text rendering filter Text labels are optional and can be filtered by a minimum absolute delta threshold. if show_text and math.abs(delta) >= text_threshold string txt = str.tostring(delta, format.volume) label.new(int((left_time + right_time)/2), p, txt, xloc=xloc.bar_time, style=label.style_none, textcolor=txt_col, size=text_size)
Wskaźnik Pine Script®
od UAlgo
Accumulation Zone Profiles [UAlgo]Accumulation Zone Profiles is an overlay indicator that detects low volatility accumulation phases and automatically builds a fixed range volume profile for each confirmed zone. The script uses a statistical volatility model based on log returns, identifies periods where volatility compresses into an unusually quiet regime, then verifies that price action remains sufficiently sideways before confirming the zone. When a zone is confirmed, the indicator draws two complementary views: A highlighted accumulation range on the chart A fixed range volume profile drawn to the right of the zone, including Point of Control and Value Area levels The intent is to turn consolidation into a structured map. Instead of treating ranges as vague rectangles, the script assigns a volume distribution to the range so you can see where the market accepted price, where it rejected price, and which levels are most likely to matter during expansion. 🔹 Features 1) Statistical Accumulation Detection Using Log Volatility The detection engine starts from log returns r = ln(C / C ) and builds an EWMA based volatility estimate. Volatility is converted into log space and evaluated with a rolling distribution model. A z score determines whether the current volatility is unusually low relative to its own history. Zones begin when the z score falls below a configurable entry threshold and they end after volatility recovers above an exit threshold for a configurable number of confirmation bars. 2) Sideways Quality Filter With Trend Score Not every low volatility period is true accumulation. The script measures drift using a trend score defined as: absolute sum of returns divided by sum of absolute returns Lower values indicate more rotation and less directional drift. A maximum trend score filter ensures zones remain meaningfully sideways before a profile is created. 3) Non Repainting Option Using Confirmed Bars When enabled, the system only updates on confirmed bars. This reduces repainting behavior and makes zone start and zone end decisions more stable for live trading workflows. 4) Fixed Range Volume Profile Per Zone For each confirmed accumulation zone, the script builds a histogram of volume across a user selected number of price rows. Each bar’s volume is distributed into bins according to how much of that candle range overlaps each bin. This produces a true fixed range profile for the zone. The profile is drawn to the right of the zone so it does not cover price action. 5) Point of Control and Value Area Levels The highest volume row is treated as the Point of Control. Value Area High and Value Area Low are computed by expanding outward from POC until a target percent of total volume is captured. This creates a practical acceptance framework inside the zone. Optional plotting allows: Highlighting the POC row Drawing VAH and VAL lines Drawing zone boundary guides Showing an information label that summarizes zone statistics 6) Tick Alignment For Clean Levels If enabled, the zone range, bin step size, and derived levels are aligned to the instrument tick size. This produces cleaner price levels and reduces floating point noise in labels and lines. 7) Object Budget Management Volume profiles use many boxes. The script computes an effective rows value based on the number of profiles you choose to keep, then limits total box usage so you are less likely to hit platform object limits. Older profiles are deleted automatically when new ones are created. 8) Alerts Two alerts are available: Accumulation Zone Started Accumulation Zone Confirmed and Profile Created This supports automation such as watchlist monitoring and breakout preparation. 🔹 Calculations 1) Log Return and EWMA Variance The script defines log return as ln(C / C ) and uses an EWMA of squared returns as a variance proxy. Alpha for EWMA: f_alpha(int len) => 2.0 / (len + 1.0) Log return: lr = math.log(close / close ) lr := na(close ) or close == 0.0 ? 0.0 : lr EWMA variance and volatility: alphaFast = f_alpha(fastLen) var float ewmaVarR = na ewmaVarR := na(ewmaVarR ) ? lr * lr : alphaFast * (lr * lr) + (1.0 - alphaFast) * ewmaVarR vol = math.sqrt(math.max(ewmaVarR, 0.0)) 2) Log Volatility Distribution and z Score Volatility is transformed into log space to stabilize distribution behavior. The script maintains EWMA estimates of mean and second moment, then computes standard deviation and z score. eps = 1e-10 logVol = math.log(vol + eps) alphaDist = f_alpha(distLen) var float m1 = na var float m2 = na m1 := na(m1 ) ? logVol : alphaDist * logVol + (1.0 - alphaDist) * m1 m2 := na(m2 ) ? logVol * logVol : alphaDist * (logVol * logVol) + (1.0 - alphaDist) * m2 sigma = math.sqrt(math.max(m2 - m1 * m1, eps)) z = (logVol - m1) / sigma Interpretation: Negative z means volatility is below its typical level More negative z means stronger compression 3) Zone Start and Zone End Conditions Entry and exit logic uses the z score relative to thresholds: Start when z is less than or equal to minus Enter Threshold End when z is greater than or equal to minus Exit Threshold for Exit Confirm Bars lowNow = not na(z) and z <= -enterZ highNow = not na(z) and z >= -exitZ Exit confirmation counter: zb.exitCount := highNow ? zb.exitCount + 1 : 0 bool exitByConfirm = zb.exitCount >= exitBars A maximum zone duration also forces closure: bool exitByMax = zb.barCount() >= maxZoneBars If exit is triggered via confirmation bars, the script removes those last bars from the zone before profiling to avoid contaminating the accumulation range with the volatility recovery phase. 4) Sideways Drift Score Filter During zone building, returns are accumulated: sumR is the signed drift sumAbsR is total movement magnitude Trend score: method driftScore(ZoneBuilder this) => math.abs(this.sumR) / math.max(this.sumAbsR, 1e-10) A zone is accepted only if: Bar count is at least Min Zone Bars Drift score is less than or equal to Max Trend Score 5) Profile Range and Row Step Once accepted, the profile range is built from the min low and max high of the zone. The range is optionally aligned to tick. Step size equals range divided by rows, with optional tick alignment: float stepRaw = (hi - lo) / rows float step = stepRaw if alignTick step := math.max(syminfo.mintick, f_roundToTick(stepRaw)) 6) Volume Histogram Construction For each bar in the zone, volume is assigned into bins. If the candle range is very small, volume goes to a single nearest bin. Otherwise, volume is distributed proportionally by overlap between candle range and each bin range. Core proportional distribution logic: float overlap = math.max(0.0, math.min(bh, binHi) - math.max(bl, binLo)) if overlap > 0 float frac = overlap / br array.set(binVol, b, array.get(binVol, b) + bv * frac) This produces binVol, a per row volume distribution. 7) POC Calculation POC is the index of the maximum bin volume. POC price is the center of that row. if v > maxV maxV := v pocIdx := b float poc = lo + (pocIdx + 0.5) * step 8) Value Area Computation Value Area is derived by expanding outward from POC until the cumulative volume reaches Value Area percent of total volume. Target volume: float target = totV * (valueAreaPct / 100.0) Expand left and right by choosing the side with higher next volume until the target is met. This creates a contiguous value area band. VAL and VAH mapping to prices: float valP = lo + left * step float vahP = lo + (right + 1) * step 9) Rendering Logic Zone highlight is drawn directly over the accumulation period using a box with configurable fill and border transparency. The volume profile is drawn as a stack of boxes to the right of the zone. Each row width is proportional to row volume relative to max row volume. Transparency is mapped so high volume rows appear more prominent. POC row can be highlighted using a dedicated color and transparency configuration. VAH and VAL can be drawn as horizontal lines across the profile region, and optional boundary lines can mark the start and end of the detected zone. 10) Profile Retention and Cleanup Profiles are stored in an array. When the number of stored profiles exceeds Keep Last Profiles, the oldest profile is deleted and all of its objects are removed. This keeps the chart responsive and prevents reaching the platform maximum object counts.
Wskaźnik Pine Script®
od UAlgo
1