PROTECTED SOURCE SCRIPT
ที่อัปเดต: Institutional Confluence Suite [SurgeGuru]
Executive Summary
This is not an indicator; it is a Predictive Confluence Engine. It represents a quantum leap in technical analysis by synthesizing four distinct analytical dimensions—Fibonacci mathematics, temporal market energy, volume dynamics, and harmonic resonance—into a single, predictive framework. Its specialty lies in identifying High-Probability Confluence Zones where multiple independent factors align to signal potent market turning points.
Core Differentiators
Adaptive Fibonacci-Volume Synthesis:
Dynamic Support/Resistance: Transforms static Fibonacci levels into dynamic, volume-weighted zones. The script calculates a Volume Strength Score (0-100) for each key Fib level (0.236, 0.382, 0.618, 0.786).
Intelligent Visualization: Line thickness and style adapt in real-time: Thick/Solid for high-volume, high-confidence levels, and Thin/Dotted for low-volume, weak levels.
Real-Time Confirmation: Provides immediate ✓/✗ signals when price touches a Fib level, filtered by live volume momentum, distinguishing between high-conviction rejections and weak bounces.
Temporal Power Zone Analysis (Power Hour):
Institutional-Grade Confluence Detection: The system's masterstroke is identifying when a Power Hour Fibonacci level aligns with the Primary Trend Fibonacci level. These rare convergences are marked with a lightning bolt (⚡) and represent a consensus across timeframes and participant groups.
Structural Context: Power Hour zones provide the macro-structure, framing the market's most recent high-volatility battle. The subsequent price action within and around this zone reveals the dominant force's next intended direction.
Solfeggio Harmonic Resonance (Proprietary Beta):
Predictive Convergence: Identifies the rarest and most powerful market condition: a Harmonic Convergence Zone. This occurs when a Fibonacci level, a high-volume node, and a Solfeggio frequency ratio all align within a precise tolerance.
Market "Tuning Fork": The system acts as a resonance detector. A cyan pulse marker (●) signals when price touches a harmonic zone with expanding volume—like striking a tuning fork—indicating a high-probability bounce or reversal.
Unified Trend Framework:
Granular Trend Control: Offers 12 levels of trend sensitivity, from "Extreme" (0.5) for scalpers to "Maximum" (7.0) for position traders, ensuring the analysis is tailored to any trading style or timeframe.
Volume-Fueled Trends: The Angled Volume Profile visually demonstrates whether a trend is pushing (volume dominant on upper bars), breaking (volume dominant on lower bars), or healthy and sustained (balanced volume distribution).
Synthesis: The Confluence Engine
The true genius of this system is how these dimensions interact:
The Power Hour sets the tactical battlefield.
The Fibonacci-Volume analysis identifies the key defensive and offensive lines within that battlefield.
The Solfeggio Harmonics act as a sonar, pinging at the most potent points of alignment.
The Unified Trend Framework provides the strategic context and confirms the overall campaign's direction.
Conclusion
This script moves beyond analysis into the realm of market forecasting. It doesn't just show you what is happening; it predicts where the market is most likely to respect structure by identifying zones where mathematics, market energy, time, and resonance converge. This is institutional-grade intelligence, delivering a definitive and actionable edge by answering the critical question: "Where is the highest probability for the next significant move?"
Overall Architecture
The script operates as a multi-layered event detector. Instead of calculating continuous oscillators, it identifies specific market events (like a new swing high) and then performs complex logic to draw the appropriate structures (like an Order Block). It maintains internal arrays (lists) of these events and their corresponding drawings, constantly updating and cleaning them as new price data arrives.
1. Market Structure & Swing Detection
This is the foundational layer that identifies the market's basic rhythm.
How it Works:
Swing Point Identification: The core function queryPatterns(lastPrice, midPrice, prevPrice, isSwingHigh) looks for a three-bar pattern. For a swing high, it checks if the middle bar is higher than both its immediate neighbor bars. For a swing low, it checks if the middle bar is lower.
Multi-Timeframe Stack: The script creates three independent analyzers for Short-Term (stHigh, stLow), Intermediate-Term (itHigh, itLow), and Long-Term (ltHigh, ltLow) structures.
Short-Term: Reacts directly to the 3-bar pattern on the raw price series.
Intermediate-Term: Its input is the output of the Short-Term detector. It only records a new swing point when the Short-Term system identifies one. This creates a higher-quality, filtered set of swings.
Long-Term: Likewise, it builds upon the Intermediate-Term swings. This hierarchical filtering ensures each timeframe captures genuinely significant structural points.
Structure Breaks (MSS/BOS): The renderStructures() method is the key. It waits for price to "cross" a previously identified swing point.
If price crosses above a prior swing high, it draws a bullish line and labels it a Break of Structure (BOS), indicating renewed bullish momentum.
If price crosses below a prior swing low, it draws a bearish line and labels it a Change of Character (CHoCH) or Market Structure Shift (MSS), indicating a potential trend reversal.
2. Order Block & Breaker Block Detection (LuxAlgo Logic)
This layer identifies areas where "smart money" likely placed significant orders.
How it Works:
Fractal Detection: It uses a fractalHigh and fractalLow system (arrays of recent swing points) to identify the most significant pivot highs and lows, filtered by the user-selected term.
Block Creation - The "Cause": When price closes beyond a fractal high/low, it triggers a lookback period.
For a Bullish Order Block (after breaking a high): It looks back from the break point to the fractal and finds the bar with the lowest low within that range. The high and low (or open/close if body is selected) of that bar define the Order Block. The logic is that this was the last consolidation area before the bullish breakout.
Breaker Block - The "Effect": The script then monitors these Order Blocks.
If price re-enters a Bullish Order Block and breaks below its low, that block is "breached." It is then re-classified as a Breaker Block and visually changes (e.g., color, extended lines). This indicates the failure of that buy-side level, which now becomes resistance.
3. Liquidity Analysis (Buyside/Sellside & Voids)
This layer maps out the market's "why" - the liquidity pools that price is drawn to.
Buyside/Sellside Liquidity:
Pivot-Based Aggregation: It uses the multi-timeframe swing points (topLQ, btmLQ) as potential liquidity targets.
Zone Confirmation: It doesn't just use a single swing point. It checks a historical array of all prior pivots (aZZ). If it finds several pivots clustered within a narrow band (defined by atr / liqMar), it marks the entire zone as a Liquidity Pool.
Visualization: It draws a semi-transparent box around this zone. A "Buyside Liquidity" zone is below price (where sell-stops are hunted), and a "Sellside Liquidity" zone is above price (where buy-stops are hunted).
Liquidity Voids:
Gap Detection: This is a simpler, more geometric concept. It looks for large gaps between candles that exceed a threshold (based on atr200).
Visual Representation: When such a gap is found (e.g., the current low is significantly above the high of two bars ago), it fills the space with a series of small, colored boxes. This creates a clear visual "void" area, indicating a price range with little trading activity that will likely be traversed quickly.
4. Enhanced Liquidity Detection (BigBeluga Logic)
This is a separate, volume-informed system for spotting immediate liquidity.
How it Works:
Volume Spike Context: It calculates a normalized volume value (norm_vol) by comparing current volume to a high percentile of recent volume. This identifies unusually high volume activity.
Price Rejection: It looks for simple price patterns: a bar that makes a new high (or low) and is immediately rejected (the next bar does not continue in that direction).
Dynamic Box Creation: When these two conditions align (high volume + price rejection), it draws a box extending from that high/low. The opacity and size of the box are directly tied to the strength of the volume spike. A massive volume spike creates a very prominent box, signaling a critical liquidity level where a significant battle between buyers and sellers occurred.
Synthesis: The "Behind the Scenes" Workflow
On every new bar, the script performs this orchestrated sequence:
Update & Detect: It updates all its internal swing point arrays and checks for new Market Structure events.
Check Conditions: It runs the Order Block logic to see if any fractal levels have been breached, creating new blocks.
Monitor & Modify: It checks all existing Order Blocks to see if any have been "breached," converting them to Breaker Blocks.
Map Liquidity: It updates the liquidity pools based on the latest swings and checks for new liquidity voids based on recent price gaps.
Volume Analysis: The enhanced system checks for volume-based liquidity zones.
Garbage Collection: It constantly cleans up old drawings (lines, boxes, labels) that are no longer relevant to keep the chart performant and uncluttered.
In essence, the code acts as a state machine that tracks the market's evolution through its structural breaks, order placements, and liquidity interactions, translating this complex state into a clear, visual narrative for the trader.
Credits: LuxAlgo, PrimeChart, Trendoscope
This is not an indicator; it is a Predictive Confluence Engine. It represents a quantum leap in technical analysis by synthesizing four distinct analytical dimensions—Fibonacci mathematics, temporal market energy, volume dynamics, and harmonic resonance—into a single, predictive framework. Its specialty lies in identifying High-Probability Confluence Zones where multiple independent factors align to signal potent market turning points.
Core Differentiators
Adaptive Fibonacci-Volume Synthesis:
Dynamic Support/Resistance: Transforms static Fibonacci levels into dynamic, volume-weighted zones. The script calculates a Volume Strength Score (0-100) for each key Fib level (0.236, 0.382, 0.618, 0.786).
Intelligent Visualization: Line thickness and style adapt in real-time: Thick/Solid for high-volume, high-confidence levels, and Thin/Dotted for low-volume, weak levels.
Real-Time Confirmation: Provides immediate ✓/✗ signals when price touches a Fib level, filtered by live volume momentum, distinguishing between high-conviction rejections and weak bounces.
Temporal Power Zone Analysis (Power Hour):
Institutional-Grade Confluence Detection: The system's masterstroke is identifying when a Power Hour Fibonacci level aligns with the Primary Trend Fibonacci level. These rare convergences are marked with a lightning bolt (⚡) and represent a consensus across timeframes and participant groups.
Structural Context: Power Hour zones provide the macro-structure, framing the market's most recent high-volatility battle. The subsequent price action within and around this zone reveals the dominant force's next intended direction.
Solfeggio Harmonic Resonance (Proprietary Beta):
Predictive Convergence: Identifies the rarest and most powerful market condition: a Harmonic Convergence Zone. This occurs when a Fibonacci level, a high-volume node, and a Solfeggio frequency ratio all align within a precise tolerance.
Market "Tuning Fork": The system acts as a resonance detector. A cyan pulse marker (●) signals when price touches a harmonic zone with expanding volume—like striking a tuning fork—indicating a high-probability bounce or reversal.
Unified Trend Framework:
Granular Trend Control: Offers 12 levels of trend sensitivity, from "Extreme" (0.5) for scalpers to "Maximum" (7.0) for position traders, ensuring the analysis is tailored to any trading style or timeframe.
Volume-Fueled Trends: The Angled Volume Profile visually demonstrates whether a trend is pushing (volume dominant on upper bars), breaking (volume dominant on lower bars), or healthy and sustained (balanced volume distribution).
Synthesis: The Confluence Engine
The true genius of this system is how these dimensions interact:
The Power Hour sets the tactical battlefield.
The Fibonacci-Volume analysis identifies the key defensive and offensive lines within that battlefield.
The Solfeggio Harmonics act as a sonar, pinging at the most potent points of alignment.
The Unified Trend Framework provides the strategic context and confirms the overall campaign's direction.
Conclusion
This script moves beyond analysis into the realm of market forecasting. It doesn't just show you what is happening; it predicts where the market is most likely to respect structure by identifying zones where mathematics, market energy, time, and resonance converge. This is institutional-grade intelligence, delivering a definitive and actionable edge by answering the critical question: "Where is the highest probability for the next significant move?"
Overall Architecture
The script operates as a multi-layered event detector. Instead of calculating continuous oscillators, it identifies specific market events (like a new swing high) and then performs complex logic to draw the appropriate structures (like an Order Block). It maintains internal arrays (lists) of these events and their corresponding drawings, constantly updating and cleaning them as new price data arrives.
1. Market Structure & Swing Detection
This is the foundational layer that identifies the market's basic rhythm.
How it Works:
Swing Point Identification: The core function queryPatterns(lastPrice, midPrice, prevPrice, isSwingHigh) looks for a three-bar pattern. For a swing high, it checks if the middle bar is higher than both its immediate neighbor bars. For a swing low, it checks if the middle bar is lower.
Multi-Timeframe Stack: The script creates three independent analyzers for Short-Term (stHigh, stLow), Intermediate-Term (itHigh, itLow), and Long-Term (ltHigh, ltLow) structures.
Short-Term: Reacts directly to the 3-bar pattern on the raw price series.
Intermediate-Term: Its input is the output of the Short-Term detector. It only records a new swing point when the Short-Term system identifies one. This creates a higher-quality, filtered set of swings.
Long-Term: Likewise, it builds upon the Intermediate-Term swings. This hierarchical filtering ensures each timeframe captures genuinely significant structural points.
Structure Breaks (MSS/BOS): The renderStructures() method is the key. It waits for price to "cross" a previously identified swing point.
If price crosses above a prior swing high, it draws a bullish line and labels it a Break of Structure (BOS), indicating renewed bullish momentum.
If price crosses below a prior swing low, it draws a bearish line and labels it a Change of Character (CHoCH) or Market Structure Shift (MSS), indicating a potential trend reversal.
2. Order Block & Breaker Block Detection (LuxAlgo Logic)
This layer identifies areas where "smart money" likely placed significant orders.
How it Works:
Fractal Detection: It uses a fractalHigh and fractalLow system (arrays of recent swing points) to identify the most significant pivot highs and lows, filtered by the user-selected term.
Block Creation - The "Cause": When price closes beyond a fractal high/low, it triggers a lookback period.
For a Bullish Order Block (after breaking a high): It looks back from the break point to the fractal and finds the bar with the lowest low within that range. The high and low (or open/close if body is selected) of that bar define the Order Block. The logic is that this was the last consolidation area before the bullish breakout.
Breaker Block - The "Effect": The script then monitors these Order Blocks.
If price re-enters a Bullish Order Block and breaks below its low, that block is "breached." It is then re-classified as a Breaker Block and visually changes (e.g., color, extended lines). This indicates the failure of that buy-side level, which now becomes resistance.
3. Liquidity Analysis (Buyside/Sellside & Voids)
This layer maps out the market's "why" - the liquidity pools that price is drawn to.
Buyside/Sellside Liquidity:
Pivot-Based Aggregation: It uses the multi-timeframe swing points (topLQ, btmLQ) as potential liquidity targets.
Zone Confirmation: It doesn't just use a single swing point. It checks a historical array of all prior pivots (aZZ). If it finds several pivots clustered within a narrow band (defined by atr / liqMar), it marks the entire zone as a Liquidity Pool.
Visualization: It draws a semi-transparent box around this zone. A "Buyside Liquidity" zone is below price (where sell-stops are hunted), and a "Sellside Liquidity" zone is above price (where buy-stops are hunted).
Liquidity Voids:
Gap Detection: This is a simpler, more geometric concept. It looks for large gaps between candles that exceed a threshold (based on atr200).
Visual Representation: When such a gap is found (e.g., the current low is significantly above the high of two bars ago), it fills the space with a series of small, colored boxes. This creates a clear visual "void" area, indicating a price range with little trading activity that will likely be traversed quickly.
4. Enhanced Liquidity Detection (BigBeluga Logic)
This is a separate, volume-informed system for spotting immediate liquidity.
How it Works:
Volume Spike Context: It calculates a normalized volume value (norm_vol) by comparing current volume to a high percentile of recent volume. This identifies unusually high volume activity.
Price Rejection: It looks for simple price patterns: a bar that makes a new high (or low) and is immediately rejected (the next bar does not continue in that direction).
Dynamic Box Creation: When these two conditions align (high volume + price rejection), it draws a box extending from that high/low. The opacity and size of the box are directly tied to the strength of the volume spike. A massive volume spike creates a very prominent box, signaling a critical liquidity level where a significant battle between buyers and sellers occurred.
Synthesis: The "Behind the Scenes" Workflow
On every new bar, the script performs this orchestrated sequence:
Update & Detect: It updates all its internal swing point arrays and checks for new Market Structure events.
Check Conditions: It runs the Order Block logic to see if any fractal levels have been breached, creating new blocks.
Monitor & Modify: It checks all existing Order Blocks to see if any have been "breached," converting them to Breaker Blocks.
Map Liquidity: It updates the liquidity pools based on the latest swings and checks for new liquidity voids based on recent price gaps.
Volume Analysis: The enhanced system checks for volume-based liquidity zones.
Garbage Collection: It constantly cleans up old drawings (lines, boxes, labels) that are no longer relevant to keep the chart performant and uncluttered.
In essence, the code acts as a state machine that tracks the market's evolution through its structural breaks, order placements, and liquidity interactions, translating this complex state into a clear, visual narrative for the trader.
Credits: LuxAlgo, PrimeChart, Trendoscope
เอกสารเผยแพร่
Institutional Confluence Suite + Trade Wars - Professional Overview - Huge UpdateNote - This is a completely new
Why This Combination Is Powerful
This indicator reveals "Trade War Zones" - critical price areas where institutional orders clash with retail flow, creating high-probability trading opportunities through multi-layered confluence.
Key Confluence Scenarios:
Order Blocks + Strong Delta Spikes
When delta shows heavy buying pressure at a bullish OB, it confirms institutions are actively defending that zone
Opposite scenario: selling pressure at bearish OB validates distribution
Fair Value Gaps (FVGs) + Opposite Delta
FVGs with negative delta suggest unfinished institutional business
Price typically returns to these zones as smart money balances positions
Creates "magnetic" levels for entries
Liquidity Zones + POC (Point of Control) Alignment
Buyside/Sellside liquidity marks retail stop-loss clusters
When POC (maximum volume) aligns with these levels = reversal fuel
Institutions hunt stops where volume is concentrated
Market Structure Breaks + Delta Divergence
Structure breaks (BOS/MSS) with weakening delta warn of exhaustion
Strong moves need volume confirmation - weak delta = potential false breakout
Helps filter high-quality vs low-quality structure shifts
Architecture in Simple Terms
The indicator uses a modular, layered design:
Layer 1: Swing Detection Engine
Identifies pivot highs/lows across 3 timeframes (short/intermediate/long term)
Uses pattern recognition on 3-candle sequences
Feeds data to all other components
Layer 2: Institutional Structure Analysis
Order Blocks: Tracks last bearish candle before bullish break (and vice versa)
Market Structure: Detects when price breaks previous pivots (BOS/MSS)
Liquidity Mapping: Clusters swing points within ATR-based margins
FVG Detection: Finds gaps where current low > 2-candle-ago high (bullish) or opposite (bearish)
Layer 3: Volume Profile Engine
Bins price range into adjustable segments (default 30)
Distributes volume to bins using proximity matching (if price within step distance)
Separates bull/bear volume based on candle close vs open
Calculates delta as percentage difference between bull and bear dominance
Layer 4: Visual Rendering
Institutional layers = boxes/lines/labels on chart
Volume profile = right-side histogram with gradient coloring
Delta heatmap = color intensity based on buyer/seller imbalance
All elements auto-clean expired/broken levels
Data Flow:
Price Data → Swing Detection → Structure Analysis → Volume Binning → Delta Calculation → Visual Output
↓ ↓ ↓
Pivot Points → Order Blocks → Confluence Zones
COMPLIENCE:
✅ Educational Tool: Analyzes market structure and volume distribution for learning purposes
✅ No Signal Generation: Does not provide buy/sell signals or trade recommendations
✅ User Responsibility: Traders must apply independent analysis and risk management
✅ Transparent Logic: All calculations based on historical price/volume data, no predictive algorithms
✅ Technical Analysis: Combines established concepts (order blocks, volume profile, delta) in novel way
✅ Open Methodology: Architecture clearly explained, no "black box" systems
Disclaimer: This indicator identifies potential areas of interest based on price structure and volume analysis. It does not guarantee trading success and should be used alongside proper risk management and personal trading strategies.
All credits goes to the developers:
LuxAlgo BigBeluga SurgeGuru
เอกสารเผยแพร่
Trade Wars Cloud v2 - Advanced Delta EngineSmart Delta Calculation System
The upgraded Smart Delta mode represents a sophisticated multi-factor volume analysis engine that transcends traditional bullish vs bearish volume comparison. This system implements six independent analytical layers that work in concert to produce institutional-grade directional bias measurements.
Multi-Factor Architecture
1. Temporal Decay Framework (0.85 Exponential)
Recent price action receives exponentially higher influence through a decay-weighted system. The most recent bar maintains 100% weight, while historical data diminishes at 85% per bar backward. This creates a 20% influence at 10 bars back, ensuring the calculation remains responsive to current market dynamics while incorporating relevant historical context.
2. Intra-Candle Volume Distribution
Rather than binary candle classification, the engine analyzes bullish and bearish portions within each individual candle based on close position relative to the full range. Volume is proportionally distributed between directional components, capturing nuanced buying and selling pressure that traditional methods overlook.
3. Conviction Aggression Multiplier
Candles closing in extreme positions (top or bottom 25% of range) receive a 1.15x boost, identifying moves with strong directional intent. This filter distinguishes decisive institutional activity from indecisive retail price action.
4. Volume Efficiency Scoring
Measures price displacement achieved per unit of volume traded (price_movement / volume × 10000). Separate efficiency calculations for bullish and bearish moves create an efficiency factor that weights the delta by how effectively volume moved price. Higher efficiency indicates stronger conviction and institutional participation.
5. Structural Proximity Adjustment
Evaluates distance to key price structures using EMA-based reference levels:
Near structure (<0.5 ATR): 1.4x multiplier - amplifies delta when price approaches significant zones
Far from structure (>2.0 ATR): 0.75x multiplier - reduces delta in structurally insignificant areas
Provides context-aware weighting based on institutional level proximity
6. Delta Acceleration Capture
Tracks rate of change in delta between calculations: (current_delta - previous_delta) × 0.4. This momentum component captures building pressure and directional shifts, applied at 50% weight to the final output to avoid over-sensitivity while maintaining responsiveness to momentum changes.
Confluence Scoring System
The projection only displays when multiple factors align, calculated through a weighted scoring model:
Component Weights:
Fair Value Gap Proximity: 45% (primary institutional signal)
Volume Delta Strength: 30% (directional pressure measure)
Order Block Distance: 25% (secondary structural confirmation)
Scoring Ranges:
75-100%: Strong institutional confluence - multiple factors aligned
50-74%: Valid setup - adequate factor agreement
30-49%: Weak signal - limited factor alignment
0-29%: Insufficient confluence - projection hidden
Each component uses distance-normalized scoring with maximum influence at contact and linear decay to zero at 3 ATRs away, ensuring only relevant structural levels contribute to the final confidence measurement.
Institutional Anchor Selection
The secondary projection line (Span B) intelligently selects anchor points through hierarchical scoring:
Priority Ranking:
Fair Value Gaps (1.5x multiplier)
Active Order Blocks (1.0x multiplier)
Breaker Blocks (0.8x penalty for broken structure)
EMA(26) fallback when no institutional levels qualify
Scoring Formula: (100 + distance_score + size_score + age_score) × type_multiplier
Distance: 100 points at contact, decaying to 0 at 5 ATRs
Size: Normalized by ATR, capped at 50 points
Age: 100 points fresh, decaying to 0 after 50 bars
Type: Multiplier based on level classification
This creates a dynamic anchor that automatically latches onto the most relevant institutional level within a 5 ATR search radius, with preference for recent, large, and proximate structures.
Output Integration
The final projection combines the smart delta calculation with the institutional anchor, creating two projected lines that form a directional cloud. The cloud's opacity dynamically adjusts based on confluence strength, providing visual feedback on signal quality. Only projections meeting the minimum confluence threshold display, filtering out low-probability setups automatically.
This architecture transforms raw volume data into actionable institutional bias measurements, capturing the multi-dimensional nature of prof
เอกสารเผยแพร่
📊 Volume Profile Calculation Engine - User GuideHow Your Volume Bars Calculate (Backend Explanation)
🔍 The Old Problem
Traditional volume profiles show you cumulative history - if a price level had strong buying 6 months ago, it stays green forever, even if yesterday's action was completely bearish.
Example:
Price at $50.00 six months ago: 10,000 shares bought (bulls won)
Price at $50.00 yesterday: 500 shares sold aggressively (bears rejected)
Old Display: Shows GREEN (because 10,000 > 500 historically)
Reality: Bears are currently controlling that level
✅ The New Solution: Last-Touch Memory System
Your volume profile now has memory for each price level - it remembers the most recent candle that touched that price and gives it special importance.
🎯 How It Works (2-Pass Calculation)
PASS 1: Historical Accumulation
The system first collects ALL volume data across your lookback period (default 200 bars):
For Each Candle:
Body Distribution - Volume is split based on where the candle closed
Close near high = more bull volume
Close near low = more bear volume
Aggression Detection - Candles closing in top/bottom 20% get boosted
Institutional footprint recognition
Multiplier: 1.15x (configurable)
Time Weighting - Recent bars matter more than old bars
Recent 50 bars: Moderate decay (0.97 per bar)
Historical bars: Minimal decay (preserves context)
Efficiency Filter - Big price moves on volume = institutional
Efficient volume (smart money): +10% boost
Inefficient volume (retail churn): -10% reduction
PASS 2: Last-Touch Weighting 🔥
After accumulating history, the system applies recency bias to each price bin:
For Each Price Level:
Identify Last Touch
Find the most recent candle that traded at this price
Extract its bull/bear volume components
Calculate Strength
Measure: What % of total volume does this last touch represent?
Example: Last touch = 400 vol, Total = 1000 vol → 40%
Apply Weighting Logic
Mode A: Weighted Enhancement (when threshold NOT met)
Multiplier: 3.5x (your setting)
Before:
- Historical Bull: 1000
- Historical Bear: 800
- Last Touch: 50 bear volume
After:
- Bull: 1000
- Bear: 800 - 50 + (50 × 3.5) = 925
Result: Nearly balanced (was bullish, now realistic)
```
**Mode B: Complete Override** (when threshold IS met)
```
Threshold: 40% (your setting)
If last touch = 450 vol and total = 1000 vol
→ 450/1000 = 45% > 40% threshold
Action: IGNORE ALL HISTORY
Display: Show ONLY the last touch (×3.5 boost)
Result: 100% reflects recent decision
```
---
## **🎮 Your Control Settings**
### **Last Touch Multiplier: 3.5x**
- **Lower (1.5x - 2.5x):** Respectful of history, subtle recency bias
- **Medium (3.0x - 4.5x):** Balanced - recent matters but history counts
- **Higher (5.0x - 10.0x):** Aggressive - only recent decisions matter
### **Override Threshold: 40%**
- **Lower (10-30%):** Easy to override history (very responsive)
- **Medium (35-50%):** Balanced - strong touches override
- **Higher (55-90%):** Hard to override (preserves more history)
---
## **💡 Real-World Scenarios**
### **Scenario 1: Old Support Broken**
```
Price: $100 (former support)
Historical: 5000 bull vol (strong buying 3 months ago)
Yesterday: 2500 bear vol (aggressive breakdown)
Calculation:
- Last touch % = 2500/(5000+2500) = 33%
- Below 40% threshold → Weighted mode
- Bear vol becomes: 2500 × 3.5 = 8750
- Result: Shows BEARISH (accurate current sentiment)
```
### **Scenario 2: Fresh Resistance Test**
```
Price: $75 (recent resistance)
Historical: 3000 vol (mixed)
Today: 1500 bear vol (hard rejection - 50% of total)
Calculation:
- Last touch % = 50% > 40% threshold
- Override mode ACTIVATED
- Result: Shows 100% BEARISH (ignores old data)
```
### **Scenario 3: Low Volume Noise**
```
Price: $82 (random level)
Historical: 8000 vol (established data)
Recent: 200 bear vol (weak test)
Calculation:
- Last touch % = 200/8200 = 2.4%
- Far below threshold → Weighted mode
- Bear boost: 200 × 3.5 = 700
- Result: History still dominates (correct - noise filtered)
🎯 Why This Matters
Traditional Volume Profile:
❌ Shows you what WAS happening (historical bias)
❌ Old levels stay same color forever
❌ Doesn't reflect current market structure
Last-Touch System:
✅ Shows you what IS happening (current sentiment)
✅ Adapts when market shifts at a level
✅ Filters noise but catches real changes
✅ Institutional-sized moves get priority
🔧 Quick Tuning Guide
If volume profile changes TOO MUCH (too sensitive):
Lower multiplier: 3.5x → 2.0x
Raise threshold: 40% → 60%
Keep override ON
If volume profile changes TOO LITTLE (too stale):
Raise multiplier: 3.5x → 6.0x
Lower threshold: 40% → 25%
Keep override ON
For maximum historical context:
Multiplier: 2.0x
Override: OFF
Uses weighting only, never overrides
🎓 Technical Summary
The indicator now operates like institutional order flow analysis:
Tracks volume accumulation (what happened)
Remembers recent decisions (what's happening now)
Prioritizes strong touches (what institutions are doing)
Filters retail noise (what doesn't matter)
เอกสารเผยแพร่
reverted to BigBeluga logics of detection from v1สคริปต์ที่ได้รับการป้องกัน
สคริปต์นี้ถูกเผยแพร่เป็นแบบ closed-source อย่างไรก็ตาม คุณสามารถใช้ได้อย่างอิสระและไม่มีข้อจำกัดใดๆ – เรียนรู้เพิ่มเติมได้ที่นี่
คำจำกัดสิทธิ์ความรับผิดชอบ
ข้อมูลและบทความไม่ได้มีวัตถุประสงค์เพื่อก่อให้เกิดกิจกรรมทางการเงิน, การลงทุน, การซื้อขาย, ข้อเสนอแนะ หรือคำแนะนำประเภทอื่น ๆ ที่ให้หรือรับรองโดย TradingView อ่านเพิ่มเติมที่ ข้อกำหนดการใช้งาน
สคริปต์ที่ได้รับการป้องกัน
สคริปต์นี้ถูกเผยแพร่เป็นแบบ closed-source อย่างไรก็ตาม คุณสามารถใช้ได้อย่างอิสระและไม่มีข้อจำกัดใดๆ – เรียนรู้เพิ่มเติมได้ที่นี่
คำจำกัดสิทธิ์ความรับผิดชอบ
ข้อมูลและบทความไม่ได้มีวัตถุประสงค์เพื่อก่อให้เกิดกิจกรรมทางการเงิน, การลงทุน, การซื้อขาย, ข้อเสนอแนะ หรือคำแนะนำประเภทอื่น ๆ ที่ให้หรือรับรองโดย TradingView อ่านเพิ่มเติมที่ ข้อกำหนดการใช้งาน