Quantum Fib & Liquidity EngineQuantum Fib & Liquidity Engine
A dynamic Fibonacci retracement indicator that anchors to swing highs and lows using ZigZag pivot detection. Automatically identifies support/resistance levels and key retracement zones.
Core Functionality:
Dynamic Fibonacci Retracement System — Uses ZigZag pivot detection (ta.pivothigh/ta.pivotlow) to anchor retracement levels to the most recent swing high (resistance) and swing low (support). Updates when new pivots form, keeping levels aligned with market structure.
Golden Zone Identification — Highlights the 50%-61.8% retracement zone, a common reversal area.
Support & Resistance Detection — Displays current S/R levels as horizontal dashed lines, updated from ZigZag pivots.
Liquidity Pool Analysis — Identifies significant liquidity zones and detects sweeps when price crosses these levels.
Pattern Recognition — Detects Double Top and Double Bottom patterns with configurable tolerance.
Multi-Timeframe Compatibility — Functions across 1m, 5m, 15m, 1h, 4h, daily, and higher timeframes using a consistent pivot detection algorithm.
Technical Implementation:
The indicator uses ZigZag pivot analysis to identify swing points. Fibonacci levels are calculated from the most recent swing high and swing low, ensuring alignment with market structure rather than arbitrary price ranges. Drawing objects are updated dynamically to maintain accuracy without excessive object creation.
Configuration Options:
Structure Lookback — Controls swing detection sensitivity (default: 20 bars)
Feature Toggles — Enable/disable Golden Zone, Liquidity Pools, and Pattern Detection
Visual Customization — Adjust glow intensity and line transparency
Use Cases:
Identifying potential reversal zones within retracements
Locating support and resistance levels
Detecting liquidity sweeps and pattern formations
Multi-timeframe analysis
Designed for traders who require dynamic Fibonacci levels that adapt to market structure.
Analisis Trend
Harmonic Oscillator - Multi-Component Momentum ConsensusHarmonic Oscillator - Multi-Component Momentum Consensus
Harmonic Oscillator is a seven-component momentum analysis system that transforms standard oscillators into a unified consensus framework. The indicator combines RSI, Stochastic RSI, MACD, EMA Trend, Momentum, Volume, and Divergence Zone detection into a single composite oscillator with automatic regime classification and qualified voting.
Rather than monitoring multiple separate indicators, traders can observe how these momentum calculations align or diverge through a single panel displaying vote count (X/7), regime state (TRENDING/BIAS/RANGING), and a normalized composite line.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗢𝗩𝗘𝗥𝗩𝗜𝗘𝗪
Traditional momentum analysis often requires monitoring multiple oscillators simultaneously: RSI for momentum strength, Stochastic for extreme zones, MACD for trend-following momentum, and so on. Each indicator has its own scale, its own interpretation rules, and its own blind spots.
Harmonic Oscillator addresses this by implementing a voting system where seven independent components each cast a vote based on their specific criteria. The indicator then:
• Counts votes to show consensus level (displayed as X/7)
• Blends three oscillators into a single normalized composite line (0-100 scale)
• Classifies market regime based on composite position and baseline confirmation
• Detects divergences between price structure and oscillator structure
• Filters signals through optional higher timeframe trend alignment
The result is a unified view of momentum conditions that may help traders identify when multiple factors are agreeing versus conflicting.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗛𝗢𝗪 𝗜𝗧 𝗪𝗢𝗥𝗞𝗦
The indicator is built around one core principle: momentum readings are more meaningful when multiple independent calculations agree.
𝗧𝗵𝗲 𝗦𝗲𝘃𝗲𝗻 𝗩𝗼𝘁𝗶𝗻𝗴 𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀
Each component analyzes a different aspect of momentum and casts a bullish, bearish, or neutral vote:
𝟭. 𝗥𝗦𝗜 (𝗠𝗼𝗺𝗲𝗻𝘁𝘂𝗺-𝗔𝘄𝗮𝗿𝗲)
What it does: RSI is calculated with additional RMA smoothing to reduce noise. The voting logic requires both threshold position AND slope confirmation. RSI must be above 50 with rising slope to vote bullish, or below 50 with falling slope to vote bearish. Special conditions detect potential reversals (RSI below 30 but rising).
How to interpret it: A green RSI arrow in the panel indicates bullish momentum with directional confirmation. A red arrow indicates bearish. Gray dash means RSI is not showing clear directional conviction.
𝟮. 𝗦𝘁𝗼𝗰𝗵𝗮𝘀𝘁𝗶𝗰 𝗥𝗦𝗜 (𝗦𝗹𝗼𝗽𝗲 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀)
What it does: Stochastic RSI uses EMA smoothing on K and D lines for stability. The vote requires K-line momentum alignment: K above D with positive slope for bullish, K below D with negative slope for bearish.
How to interpret it: This component captures turning points in momentum. When SRSI votes while RSI doesn't (or vice versa), it may indicate the oscillators are at different phases of a move.
𝟯. 𝗠𝗔𝗖𝗗 (𝗛𝗶𝘀𝘁𝗼𝗴𝗿𝗮𝗺 𝗔𝗰𝗰𝗲𝗹𝗲𝗿𝗮𝘁𝗶𝗼𝗻)
What it does: Rather than voting on histogram direction alone, MACD votes on histogram acceleration, which is the rate of change of the histogram. This approach aims to identify momentum shifts before the histogram crosses zero.
How to interpret it: MACD acceleration can signal momentum changes early. A bullish vote means histogram is positive and accelerating, OR negative but accelerating upward.
𝟰. 𝗘𝗠𝗔 𝗧𝗿𝗲𝗻𝗱 (𝗣𝗼𝘀𝗶𝘁𝗶𝗼𝗻 + 𝗦𝗹𝗼𝗽𝗲)
What it does: Requires both price position relative to EMA AND slope confirmation. Price above EMA with positive EMA slope = bullish vote. Price below EMA with negative slope = bearish vote.
How to interpret it: This prevents votes in ambiguous situations where price is above a falling EMA or below a rising EMA. The EMA vote indicates clear trend alignment.
𝟱. 𝗠𝗼𝗺𝗲𝗻𝘁𝘂𝗺 (𝗥𝗮𝘁𝗲 𝗼𝗳 𝗖𝗵𝗮𝗻𝗴𝗲)
What it does: Uses smoothed Rate of Change (ROC) with the same qualification requirement: ROC positive AND increasing for bullish, ROC negative AND decreasing for bearish.
How to interpret it: Pure momentum measurement. When MOM agrees with trend components, directional conviction may be higher.
𝟲. 𝗩𝗼𝗹𝘂𝗺𝗲 (𝗖𝗼𝗻𝗳𝗶𝗿𝗺𝗮𝘁𝗶𝗼𝗻)
What it does: Compares current volume to recent average. Votes bullish when volume is elevated (1.2x+ average) on an up candle. Votes bearish when elevated volume accompanies a down candle.
How to interpret it: Volume confirmation adds weight to directional moves. Low volume readings during directional moves may indicate less conviction.
𝟳. 𝗗𝗶𝘃𝗲𝗿𝗴𝗲𝗻𝗰𝗲 𝗭𝗼𝗻𝗲
What it does: Detects when price and oscillator are in extreme zones with structural disagreement. Votes bullish when oscillator is oversold but price is making higher lows. Votes bearish when oscillator is overbought but price is making lower highs.
How to interpret it: This component specifically looks for potential reversal setups where momentum and price structure are disagreeing.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗪𝗛𝗬 𝗧𝗛𝗘𝗦𝗘 𝗖𝗢𝗠𝗣𝗢𝗡𝗘𝗡𝗧𝗦 𝗪𝗢𝗥𝗞 𝗧𝗢𝗚𝗘𝗧𝗛𝗘𝗥
The seven components are designed to capture different aspects of momentum:
1. 𝗥𝗦𝗜 + 𝗦𝘁𝗼𝗰𝗵𝗮𝘀𝘁𝗶𝗰 𝗥𝗦𝗜: Two approaches to measuring momentum strength and turning points
2. 𝗠𝗔𝗖𝗗 + 𝗠𝗼𝗺𝗲𝗻𝘁𝘂𝗺: Trend-following momentum and pure rate of change
3. 𝗘𝗠𝗔 𝗧𝗿𝗲𝗻𝗱: Price position relative to moving average with slope confirmation
4. 𝗩𝗼𝗹𝘂𝗺𝗲: Participation confirmation on directional moves
5. 𝗗𝗶𝘃𝗲𝗿𝗴𝗲𝗻𝗰𝗲 𝗭𝗼𝗻𝗲: Structural disagreement detection in extreme zones
When multiple factors align (RSI slope confirms, MACD accelerates, EMA trend agrees, volume confirms), this represents broad momentum agreement. Such conditions may warrant attention, though they do not guarantee any particular outcome.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗛𝗢𝗪 𝗧𝗢 𝗨𝗦𝗘
This section provides step-by-step guidance for interpreting the indicator's visual elements.
𝗦𝘁𝗲𝗽 𝟭: 𝗖𝗵𝗲𝗰𝗸 𝘁𝗵𝗲 𝗥𝗲𝗴𝗶𝗺𝗲 𝗖𝗹𝗮𝘀𝘀𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻
The regime label at the top of the status panel provides immediate market context:
• TRENDING ▲ or TRENDING ▼: Composite oscillator at extremes (above 65 or below 35) with 200 EMA baseline confirming direction. This may indicate sustained directional momentum.
• BIAS ▲ or BIAS ▼: Composite showing moderate lean (above 55 or below 45) without extreme readings. Directional tendency without full momentum extension.
• RANGING: Composite near midpoint (45-55 zone). This may indicate consolidation, indecision, or transition between directional moves.
The regime classification helps contextualize other readings. A high vote count during TRENDING may indicate trend continuation. The same vote count during RANGING may indicate an emerging directional move.
𝗦𝘁𝗲𝗽 𝟮: 𝗢𝗯𝘀𝗲𝗿𝘃𝗲 𝘁𝗵𝗲 𝗩𝗼𝘁𝗲 𝗖𝗼𝘂𝗻𝘁
The vote count (displayed as X/7) shows how many components currently agree:
• 6/7 or 7/7: High consensus. Most or all components showing directional agreement through their different calculation methods.
• 4/7 or 5/7: Moderate consensus. Majority agreement with some components neutral or conflicting.
• 1/7 to 3/7: Low consensus. Components are in disagreement or showing mixed readings.
The consensus meter bar at the bottom of the oscillator panel also visualizes this. Brighter colors indicate higher consensus.
𝗦𝘁𝗲𝗽 𝟯: 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗖𝗼𝗺𝗽𝗼𝘀𝗶𝘁𝗲 𝗢𝘀𝗰𝗶𝗹𝗹𝗮𝘁𝗼𝗿
The main oscillator line blends RSI, Stochastic RSI, and MACD using winsorized normalization:
• Above 75 zone: Extended bullish momentum (overbought region)
• Above 85 zone: Extreme overbought
• Below 25 zone: Extended bearish momentum (oversold region)
• Below 15 zone: Extreme oversold
• 45-55 zone: Neutral/consolidation area
The signal line (thinner line) provides crossover reference. When composite crosses above signal = bullish momentum shift. Below = bearish shift.
Important: Like all oscillators, the composite can remain at extremes during strong directional moves. Overbought does not mean "sell"; it means momentum is extended.
𝗦𝘁𝗲𝗽 𝟰: 𝗖𝗵𝗲𝗰𝗸 𝗜𝗻𝗱𝗶𝘃𝗶𝗱𝘂𝗮𝗹 𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀
The status panel shows each component's current vote with arrows:
• ▲ (green): Component voting bullish
• ▼ (red): Component voting bearish
• — (gray): Component neutral/no vote
This breakdown helps identify which factors are agreeing and which are diverging. For example, if RSI and SRSI show bullish but MACD shows bearish, momentum may be mixed.
𝗦𝘁𝗲𝗽 𝟱: 𝗪𝗮𝘁𝗰𝗵 𝗳𝗼𝗿 𝗗𝗶𝘃𝗲𝗿𝗴𝗲𝗻𝗰𝗲𝘀
Divergence labels appear when price and oscillator structure disagree:
• ▲ DIV (bullish): Price makes lower low, oscillator makes higher low. Appears only in oversold zone (below 25).
• ▼ DIV (bearish): Price makes higher high, oscillator makes lower high. Appears only in overbought zone (above 75).
Divergences indicate structural disagreement that may precede reversals. However, divergences can persist or resolve without reversal. They are one input for analysis, not standalone signals.
𝗦𝘁𝗲𝗽 𝟲: 𝗖𝗼𝗺𝗯𝗶𝗻𝗲 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗙𝗮𝗰𝘁𝗼𝗿𝘀
The indicator provides the most context when multiple elements align:
Example Scenario A (Trend Continuation):
Composite holding above 65 for eight bars. Regime reads TRENDING▲, votes at 6/7, no divergence labels. The oscillator hasn't touched the 85 extreme zone yet. Components are aligned with room to extend before reaching overbought conditions.
Example Scenario B (Momentum Fading):
Regime shows BIAS▼ during a two-day selloff. But votes just dropped from 5/7 to 3/7, and the composite crossed above the signal line. The regime label says bearish while components are losing agreement. This type of disconnect often appears before moves stall or reverse.
Example Scenario C (Exhaustion Warning):
After a rally, composite hits 87 in the extreme zone. A ▼ DIV label appears. Votes drop from 7/7 to 4/7 over three bars. None of this guarantees reversal, but multiple warning signs appearing together (extreme reading, divergence, falling consensus) suggest caution.
Example Scenario D (Breakout From Consolidation):
Regime has shown RANGING for two days, composite hovering 48-52, votes stuck at 2/7 to 3/7. Then regime flips to BIAS▲, votes jump to 5/7, composite breaks above 55. When all three shift together after a quiet period, consolidation may be resolving into a directional move.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗡𝗔𝗩𝗜𝗚𝗔𝗧𝗜𝗡𝗚 𝗗𝗜𝗙𝗙𝗘𝗥𝗘𝗡𝗧 𝗠𝗔𝗥𝗞𝗘𝗧 𝗖𝗢𝗡𝗗𝗜𝗧𝗜𝗢𝗡𝗦
𝗧𝗿𝗲𝗻𝗱𝗶𝗻𝗴 𝗠𝗮𝗿𝗸𝗲𝘁𝘀
In trending conditions, traders may observe the regime classification showing "TRENDING" with baseline confirmation, composite remaining in the upper or lower half of the range, and high consensus readings (5-7 votes) persisting across multiple bars. The qualification requirements help maintain agreement during trends. A sustained move where RSI stays above 50 with positive slope, MACD histogram accelerates, and EMA slope confirms will show consistent directional votes. Divergences may appear in extreme zones but may not resolve immediately during strong trends.
𝗥𝗮𝗻𝗴𝗶𝗻𝗴 𝗠𝗮𝗿𝗸𝗲𝘁𝘀
In ranging or consolidating conditions, the regime classification will often show "RANGING" or alternate between brief directional readings. The composite typically oscillates around the 50 line without reaching sustained extremes, and vote counts fluctuate without reaching high consensus for extended periods. Divergences appearing at range extremes may be more significant in these conditions, potentially indicating range boundaries.
𝗛𝗶𝗴𝗵 𝗩𝗼𝗹𝗮𝘁𝗶𝗹𝗶𝘁𝘆 𝗘𝘃𝗲𝗻𝘁𝘀
During high volatility events, components may respond rapidly to price changes. Vote counts can swing from high bullish to high bearish consensus quickly. The regime classification helps contextualize whether these swings are occurring within a larger trending structure or representing genuine momentum reversals. The composite may reach extreme zones (85+ or 15-) during volatility spikes.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗧𝗘𝗖𝗛𝗡𝗜𝗖𝗔𝗟 𝗗𝗘𝗧𝗔𝗜𝗟𝗦
• Normalization uses winsorized statistics: extreme values are clipped before scaling to prevent outliers from dominating the composite blend
• Qualification logic requires directional confirmation (slope, acceleration) beyond simple threshold positions
• Divergence detection uses pivot comparison with left/right bar lookback, filtered to extreme zones only
• Regime classification combines composite position thresholds with 200 EMA slope direction
• HTF data uses confirmed bars only with request.security() lookahead disabled
• All signals fire on bar close only (non-repainting): historical display matches live behavior
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗨𝗡𝗜𝗤𝗨𝗘 𝗙𝗘𝗔𝗧𝗨𝗥𝗘𝗦
• 𝗦𝗲𝘃𝗲𝗻-𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁 𝗩𝗼𝘁𝗶𝗻𝗴: Each component uses qualification criteria beyond simple thresholds, reducing noise from single-indicator false signals
• 𝗤𝘂𝗮𝗹𝗶𝗳𝗶𝗲𝗱 𝗩𝗼𝘁𝗲𝘀: Components only vote when showing directional conviction (slope confirmation, acceleration, etc.), not just static positions
• 𝗖𝗼𝗺𝗽𝗼𝘀𝗶𝘁𝗲 𝗡𝗼𝗿𝗺𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Three oscillators blended using winsorized statistics for a smoother, more stable reading than any single oscillator
• 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗰 𝗥𝗲𝗴𝗶𝗺𝗲 𝗗𝗲𝘁𝗲𝗰𝘁𝗶𝗼𝗻: TRENDING/BIAS/RANGING classification provides immediate market context
• 𝗛𝗧𝗙 𝗗𝗶𝘃𝗲𝗿𝗴𝗲𝗻𝗰𝗲 𝗙𝗶𝗹𝘁𝗲𝗿: When enabled, divergence signals are filtered by higher timeframe trend direction to reduce counter-trend noise
• 𝗡𝗼𝗻-𝗥𝗲𝗽𝗮𝗶𝗻𝘁𝗶𝗻𝗴: All calculations use confirmed bar data only. Historical display matches what was shown in real-time.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗦𝗘𝗧𝗧𝗜𝗡𝗚𝗦 𝗢𝗩𝗘𝗥𝗩𝗜𝗘𝗪
𝗖𝗼𝗿𝗲 𝗦𝗲𝘁𝘁𝗶𝗻𝗴𝘀
• 𝗦𝗶𝗴𝗻𝗮𝗹 𝗠𝗼𝗱𝗲: Alert threshold only (no visual change). Controls when High Consensus alerts fire:
- Conservative = 6+ votes to trigger alert
- Balanced = 5+ votes (default)
- Aggressive = 4+ votes
• 𝗛𝗧𝗙 𝗙𝗶𝗹𝘁𝗲𝗿: When enabled, divergence signals are filtered by higher timeframe trend. Bullish divergences only appear when HTF is bullish (price above HTF EMA). Bearish divergences only appear when HTF is bearish. Helps avoid counter-trend signals.
• 𝗛𝗧𝗙 𝗧𝗶𝗺𝗲𝗳𝗿𝗮𝗺𝗲: Timeframe used for HTF filter (default 4H). The indicator checks if price is above/below the 50 EMA on this timeframe.
𝗗𝗶𝘀𝗽𝗹𝗮𝘆 𝗦𝗲𝘁𝘁𝗶𝗻𝗴𝘀
• Show Divergences: Toggle divergence labels on/off
• Show Consensus Meter: Toggle vote count bar at bottom of oscillator
• Show Status Panel: Toggle the info table
• Show OB/OS Zone Fills: Toggle colored fill zones for extreme areas
𝗧𝗮𝗯𝗹𝗲 𝗦𝗲𝘁𝘁𝗶𝗻𝗴𝘀
• Table Position: 9 position options (corners, centers, edges)
• Table Font Size: Tiny/Small/Normal
• Table Layout: Horizontal (wide, desktop) or Vertical (compact, mobile-friendly)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗔𝗟𝗘𝗥𝗧𝗦
14 alert conditions available:
𝗗𝗶𝘃𝗲𝗿𝗴𝗲𝗻𝗰𝗲 𝗔𝗹𝗲𝗿𝘁𝘀
• Bullish Divergence / Bearish Divergence: Divergence detected in extreme zone
• Any Divergence: Either type detected
𝗖𝗿𝗼𝘀𝘀𝗼𝘃𝗲𝗿 𝗔𝗹𝗲𝗿𝘁𝘀
• Bullish Crossover / Bearish Crossover: Composite crosses signal line
• Any Crossover: Either type detected
𝗘𝘅𝘁𝗿𝗲𝗺𝗲 𝗭𝗼𝗻𝗲 𝗔𝗹𝗲𝗿𝘁𝘀
• Extreme Overbought / Extreme Oversold: Composite enters 85/15 zones
• Exit Overbought / Exit Oversold: Composite exits 85/15 zones
𝗥𝗲𝗴𝗶𝗺𝗲 𝗔𝗹𝗲𝗿𝘁𝘀
• Regime to Bullish / Regime to Bearish: Regime classification changes direction
𝗖𝗼𝗻𝘀𝗲𝗻𝘀𝘂𝘀 𝗔𝗹𝗲𝗿𝘁𝘀
• High Bull Consensus / High Bear Consensus: Vote count reaches Signal Mode threshold (6+/5+/4+ depending on mode). Alert only, no visual change.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗟𝗜𝗠𝗜𝗧𝗔𝗧𝗜𝗢𝗡𝗦
• 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 𝘁𝗼𝗼𝗹, 𝗻𝗼𝘁 𝗮 𝘀𝗶𝗴𝗻𝗮𝗹 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗼𝗿: This indicator displays consensus, regime state, and divergences for the trader to interpret. It does not tell you when to buy or sell.
• 𝗖𝗼𝗻𝘀𝗲𝗻𝘀𝘂𝘀 𝗰𝗮𝗻 𝗹𝗮𝗴: By the time all components agree, price movement may have already begun. High consensus readings indicate current agreement, not future direction.
• 𝗘𝘅𝘁𝗿𝗲𝗺𝗲𝘀 𝗰𝗮𝗻 𝗽𝗲𝗿𝘀𝗶𝘀𝘁: Like all oscillators, the composite can remain at extremes during strong directional moves. Overbought does not mean "must reverse."
• 𝗗𝗶𝘃𝗲𝗿𝗴𝗲𝗻𝗰𝗲𝘀 𝗮𝗿𝗲 𝗻𝗼𝘁 𝗴𝘂𝗮𝗿𝗮𝗻𝘁𝗲𝗲𝗱: Divergences indicate structural disagreement. They may precede reversals but can also persist or resolve without reversal.
• 𝗟𝗮𝗴𝗴𝗶𝗻𝗴 𝗶𝗻𝗱𝗶𝗰𝗮𝘁𝗼𝗿: All signals are derived from historical price data and confirm on bar close.
• 𝗣𝗮𝘀𝘁 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀 𝗱𝗼 𝗻𝗼𝘁 𝗴𝘂𝗮𝗿𝗮𝗻𝘁𝗲𝗲 𝗳𝘂𝘁𝘂𝗿𝗲 𝗿𝗲𝘀𝘂𝗹𝘁𝘀.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗖𝗢𝗡𝗖𝗟𝗨𝗦𝗜𝗢𝗡
Harmonic Oscillator provides a structured framework for analyzing momentum through seven independent components, a normalized composite oscillator, and automatic regime classification. The indicator is designed to help traders identify when multiple momentum factors are agreeing versus conflicting, which may provide useful context for analysis.
The voting system, qualification requirements, and regime detection work together to present a unified view of momentum conditions that would otherwise require monitoring multiple separate indicators.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔶 𝗗𝗜𝗦𝗖𝗟𝗔𝗜𝗠𝗘𝗥
Trading is risky and most traders lose money. This indicator is provided for informational and educational purposes only. It does not constitute financial advice, and past performance does not guarantee future results. All content, tools, and analysis should not be considered as recommendations to buy or sell any asset. Users are solely responsible for their own trading decisions. Always use proper risk management and consider consulting a qualified financial advisor before making trading decisions.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Built with PineScript v6. Non-repainting. All signals confirmed on bar close.
Professional Bar Market + Footprint OrderFlowBar Market + Order Flow Footprint – See Balance, Rotation, and Real Aggression Inside Each Bar
The Bar Market + Order Flow Footprint Indicator is built for traders who want to see where the auction is balanced, when it’s about to break, and who is actually in control at each step. It combines professional Bar Market detection with real‑time, footprint‑style order flow analysis directly on your TradingView chart.
Core edge: balance + order flow
Bar Market detection and visualization
Automatically identifies balanced, rotational “bar market” environments using overlap, volatility contraction, and structure neutrality.
Visually marks balance zones with boxes, shaded regions, or range boundaries so compression stands out instantly on any chart.
Clearly shows when price enters balance, rotates inside it, and when it finally breaks out or fails and returns to balance.
Embedded footprint‑style data on every candle
Estimates buy vs sell pressure per bar to approximate a professional order flow footprint within Pine Script limits.
Displays bar‑level delta, volume intensity, and imbalance conditions to reveal whether aggressive buyers or sellers are dominating.
Highlights absorption and exhaustion so you can spot trapped traders and fading momentum at key levels.
Focused order flow inside balance
Emphasizes order flow behavior inside Bar Markets, where rotation, absorption, and stop runs set up the next expansion.
Calls out absorption at range extremes, delta divergence before breakouts, and failed breaks that snap back into balance.
Optionally reduce noise outside balance zones, so you only see detailed footprint data where it matters most.
Flexible customization for different traders
Tune Bar Market logic with sensitivity, lookback, and minimum balance duration controls.
Adjust volume smoothing and delta calculation method to match your order flow style.
Toggle footprint visibility, select light vs detailed performance modes, and customize all colors and label sizes for maximum clarity.
Designed for futures, forex, crypto, and indices, this tool helps you read balance, transitions, and aggression in one unified view — ideal for intraday traders who combine auction market theory with modern order flow.
⚠️ Disclaimer: For educational and analytical purposes only and does not constitute financial advice. Always apply proper risk management and confirm signals using additional analysis.
Enigma DaytradingThis indicator contains integrated databases for 3 instruments (GC, 6B, and CL) to be used only in the New York session. These integrated databases enable the visualization of key price levels associated with either the continuation of the current trend or with the mitigation of Internal Range Liquidity within the session (displayed as colored boxes), along with their corresponding liquidity draws (displayed as colored lines).
The basic logic is to consider the colored boxes as potential entry areas and the colored lines as potential exit levels. Which colored line to use as a potential exit level will be determined by which colored box was used in the first place. The colors of both the entry box and the exit line should be the same.
This visualization system and the methodology to structure the integrated databases are the result of proprietary analysis of historical price data and recurring patterns.
Every trade setup presented by the usage of this indicator doesn't constitute investment advice. Past results will never guarantee future performance.
Modular OmniTrendOverview
Modular OmniTrend Pro 2026 is a sophisticated, trend-following trading indicator designed for traders who value precision and multi-layer confirmation. Unlike standard indicators, this system utilizes a "modular confluence" engine, requiring multiple technical conditions—momentum, trend direction, and market participation—to align before issuing a signal.
The core philosophy of this script is to eliminate market noise and capture high-probability swings by filtering out low-liquidity movements.
Key Features
Modular Architecture: Toggle between various trend-detection methods (EMA, WMA, HMA, DEMA) and confirmation layers (MACD, Parabolic SAR, ADX).
Volume-Validated Entries: Built-in volume analysis ensures that every signal is backed by real market interest, protecting you from "fake-outs" during low-volume periods.
Visualization: A clean UI that colors candles based on overall trend health and provides a dynamic "magnetic field" fill for immediate trend identification.
How to Use & Set Up Alerts
Setting Alerts: :
- Long Entry Signal: Triggers when bullish conditions align.
- Short Entry Signal: Triggers when bearish conditions align (if "Both" directions are enabled).
State Logic: The indicator remembers its state. It won't give a new Long signal until the bearish conditions have reset the cycle, ensuring cleaner entries.
Best Performance
Optimized for ETHUSD INDEX, 4H Timeframe to filter out intraday noise.
Volume Required: As this system uses Volume Confirmation, it is strictly intended for pairs with reliable volume data (Exchanges like Binance, Kraken, Coinbase).
Disclaimer: Trading involves significant risk. This indicator is a technical tool and does not constitute financial advice. Past performance is not indicative of future results.
BOS 5m Session (NY Time)BOS (Break of Structure) indicator designed for strict 5-minute intraday trading.
The script identifies valid swing structures using a strict two-candle pattern (bullish → bearish for highs, bearish → bullish for lows) and tracks breaks only by candle close.
Key features:
• Works exclusively on the 5-minute timeframe
• Fixed New York time zone
• Session modes: Asia, London, New York, and ALL
• ALL mode resets at the end of New York main session (17:00 NY)
• Trend-only logic — only one BOS line is displayed at a time
• No repainting, no doji logic, no extra signals
• Visual customization (colors, width, line length)
Custom versions:
If you are interested in a custom version (additional filters, alerts, different logic, or private access), feel free to contact me directly.
Wyckoff Cycle Detection ProWyckoff Market Structure Indicator | Full Cycle Detection
Overview
The Wyckoff Market Structure Indicator automatically detects and visualizes the complete Wyckoff market cycle in real time. It identifies Accumulation, Markup, Distribution, and Markdown, including Re-Accumulation and Re-Distribution, and displays each phase directly on the chart using colored phase boxes, support/resistance lines, and Wyckoff event labels.
Built to reflect how markets actually behave, this indicator uses adaptive, non-rigid logic to capture Wyckoff structures even when price action does not look textbook-perfect.
Key Features
✔ Automatic Wyckoff cycle detection
✔ Accumulation, Markup, Distribution, Markdown
✔ Re-Accumulation & Re-Distribution support
✔ Colored boxes labeling each Wyckoff phase
✔ Dynamic support & resistance lines
✔ Dotted Automatic Rally (AR) extension line
✔ Real-time, non-repainting logic
✔ Optional toggle to show/hide past Wyckoff cycles
✔ Clean chart layout with minimal configuration
Wyckoff Events Detected
Accumulation
PS – Preliminary Support
SC – Selling Climax
AR – Automatic Rally
ST – Secondary Test
Spring / Shakeout (when present)
Test
SOS – Sign of Strength
LPS – Last Point of Support
BU – Back-Up to the Creek
Distribution
PSY – Preliminary Supply
BC – Buying Climax
AR – Automatic Reaction
ST – Secondary Test
UT / UTAD – Upthrust
SOW – Sign of Weakness
LPSY – Last Point of Supply
Labels appear only when market conditions reasonably support the Wyckoff logic, keeping signals contextual and practical.
How It Works
The indicator analyzes:
Price structure (swings and range behavior)
Volume expansion and contraction
Volatility (ATR-based behavior)
Trend context (prior markup or markdown)
This multi-factor approach allows the system to identify true institutional accumulation and distribution, not random consolidation.
Designed for Real Markets
Wyckoff structures are not identical every time. This indicator loosens rigid textbook rules and instead focuses on probability, context, and confirmation, making it effective across:
Forex
Stocks
Crypto
Futures
Any timeframe
How to Use
Add the indicator to your chart
Identify the current Wyckoff phase box
Use event labels for confirmation and context
Align trade decisions with the active phase
Enable past cycles for learning or backtesting (optional)
Who It’s For
Wyckoff Method traders
Market structure & price action traders
Swing & position traders
Traders seeking institutional context
Investors looking for accumulation/distribution zones
Important Notes
No repainting
No future-looking logic
Works out of the box
Designed to keep charts clean and readable
Disclaimer
This indicator is for educational and analytical purposes only and does not constitute financial advice. Always use proper risk management.
[Saga Trading] Order Flow Imbalance# Order Flow Imbalance Finder - Advanced Edition
## Overview
Professional order flow imbalance detector with intelligent auto-adaptation to any asset and timeframe. Identifies supply/demand imbalances (FVG) with precision filtering and real-time retest alerts.
## Key Features
### 🎯 Smart Asset Adaptation
- **Auto ATR Normalization**: Automatically adjusts to asset volatility
- **Dynamic Timeframe Detection**: Adapts analysis period based on chart timeframe
- **Universal Compatibility**: Works on forex, crypto, stocks, indices
### 📊 Volume Analysis
- **Auto Volume Detection**: Intelligent volume threshold based on volatility ratio
- **High Volume Highlights**: Visual markers (🔊) for significant volume imbalances
- **Manual Override**: Optional manual volume multiplier control
### 💪 Imbalance Strength Classification
- **Strong**: Solid border - Major gaps (>50-60% of candle range)
- **Medium**: Dashed border - Moderate gaps (25-35% of candle range)
- **Weak**: Dotted border - Minor gaps (<25% of candle range)
- **Strength Filter**: Display only desired strength levels
### 🚨 Smart Alerts
- Real-time alerts when price retests imbalance zones
- Distinguishes bullish vs bearish retest events
- Once-per-bar alert frequency to avoid spam
### 🎨 Visual Customization
- Bullish imbalances: Green zones
- Bearish imbalances: Red zones
- High volume zones: Enhanced transparency
- Adjustable maximum boxes displayed (default: 50)
## How It Works
Detects 3-candle imbalances where price gaps between candles, leaving unfilled zones. These zones often act as magnets for price action and represent institutional order flow inefficiencies.
## Settings
- **Chart Customization**: Max boxes, bull/bear colors
- **Volume Analysis**: Auto/manual volume detection
- **Alerts**: Enable/disable retest notifications
- **Imbalance Strength**: Filter by All/Weak/Medium/Strong
Perfect for scalpers, day traders, and swing traders seeking high-probability support/resistance zones.
Key Levels - Prop Trader JourneyKey Levels (Compact) is a clean, execution-focused key levels indicator built for intraday futures and price-action traders.
It plots the most important session-based levels in a compact right-side layout so your chart stays clear and decision-ready: RTH High/Low, Premarket High/Low, Opening Range, 1H levels, Session Open, Weekly levels, and averages.
Key Features:
Smart label collision handling: Merge / Stack / Merge+Stack
Compact and Pivot display modes
Fully customizable colors, line styles, widths, and label text
Session-aware logic (RTH vs Premarket vs Session Open)
Built for confluence and reaction-based trading (not prediction)
How to Use:
Treat levels as reaction zones: wait for rejection, hold, or break + retest.
When multiple labels merge/stack tightly, that’s often a stronger support/resistance zone (confluence).
Use Compact mode to stay clean, Pivot mode to see where each level was formed.
ES Gamma LevelsES Gamma Levels - Dynamic Options Flow Visualization
This indicator displays gamma exposure levels from SPY options data, automatically scaled to ES/MES futures prices. Simply copy gamma data from your dashboard and paste it into the indicator to see key support and resistance levels based on dealer positioning.
Features:
- Automatic SPY to ES price conversion using live 1-minute ratios
- Visual strength indicators - thicker/longer lines show stronger gamma concentrations
- Customizable colors for positive and negative gamma levels
- Dotted reference lines extending across the chart for easy price tracking
- Updates every minute to prevent chart clutter and jumping levels
- Filters to show only significant levels above your threshold
- Strongest positive and negative levels are automatically highlighted
The solid colored lines represent gamma strength - longer lines indicate higher concentration at that price level. Dotted lines provide continuous reference points across your chart. Green levels typically act as support (dealers long gamma), while red levels often act as resistance (dealers short gamma).
Best used on 1-5 minute timeframes for intraday trading. Paste fresh data from your options flow dashboard whenever you want updated levels.
Dealing Range Auto-Zone v2.1Dealing Range Auto-Zone v2.1 - Summary
Purpose: Automatically creates zone-based support/resistance levels within a dealing range using percentage-based spacing with ATR-driven recommendations.
How It Works:
Click two points to define dealing range (high and low)
Set step % (e.g., 0.25% = one zone every 0.25% move)
Indicator calculates exact zone count and draws upper/lower zone boundaries
Optional center lines show midpoint of each zone
Key Features:
Zone-based S/R - Upper and lower boundaries instead of single lines (creates "price zones" rather than precise levels)
Auto-calculated spacing - Uses exact % steps with math.round() for optimal coverage (minimizes gaps near boundaries)
Adjustable zone width - Default 50% of step (e.g., 0.25% step = 0.125% zone width on each side)
Ghost zones - Extends zones above/below range for anticipating breakouts
ATR-based recommendations - Calculates Daily ATR and suggests Tight/Balanced/Wide step % based on current volatility
Smart validation - Compares your step % to ATR recommendations and shows if it's appropriate for current market conditions
Use Case:
Converts dealing ranges into tradeable S/R zones for 15s-5m intraday scalping. Makes it clear when price is "in a zone" vs "at a precise line." Ideal for MNQ, MGC, and other liquid futures/crypto.
Version 2.1 Changes:
New Features:
Daily ATR calculation with automatic Tight/Balanced/Wide step % recommendations
Volatility-based auto-recommendations (compares ATR(14) vs ATR(50))
Smart validation system that evaluates your step % choice and provides feedback
Info table shows all three ATR recommendations (Tight/Balanced/Wide)
Improvements:
Changed from math.floor() to math.round() for zone count calculation (eliminates gaps near boundaries)
Streamlined info table (removed redundant rows: Range points, Step %, Total Lines)
Added color-coded validation (green checkmark for appropriate settings, orange warning for extreme values)
Bug Fixes:
Fixed tooltip compilation error (moved dynamic ATR data to info table only)
Corrected validation logic to properly categorize step % ranges
Info Table Now Shows:
Range % (dealing range size as %)
Exact Zones (calculated, including fractional)
Zones Drawn (rounded to nearest whole number)
Zone Width (in price points and % of step)
Daily ATR (value and %)
Auto Rec (all three recommendations: T/B/W)
Your Step (with validation: ✓ Tight/Balanced/Wide or ⚠️ Very Tight/Wide)
Float RotationThis is an indicator that plots the float rotation. Best used on the 5min chart. It is best if settings are set to 1 time period and on the columns graph. I use it with a 20 MA bounce strategy.
Ticker DataTicker Data is a high-efficiency dashboard designed for traders and analysts who need immediate context on a ticker without cluttering their chart.
This script aggregates fundamental data, price performance, and key institutional support levels into a single, customizable table. It allows you to assess the "character" of a stock in seconds by overlaying essential metrics directly onto your chart.
Key Features
1. Institutional Anchors (Auto-VWAPs)
Instead of manually drawing Anchored VWAPs for every ticker, this script automatically calculates and displays the three most important levels for trend management:
VWAP IPO: The volume-weighted average price since the stock's inception.
VWAP YTD: The volume-weighted average price starting from Jan 1st of the current year.
VWAP Earnings: The volume-weighted average price since the most recent earnings report.
Visual Logic: Text turns Green if price is above the VWAP, and Red if below.
2. Trend & Momentum
5-Day MA: Displays the 5-day Simple Moving Average based on Daily data. This serves as a "momentum guardrail"—if the price is above the 5DMA, short-term momentum is bullish.
Timeframe Independence: The 5DMA and performance stats are forced to the Daily timeframe, ensuring consistent data even if you view the chart on 15m or 1H intervals.
3. Fundamental Context
Market Cap: Current market capitalization.
Float & Float %: Displays the number of floating shares and the percentage of total shares they represent. Vital for gauging volatility potential (low float = higher volatility).
4. Price Performance & Range
Performance: % change over the last Week (1W), Month (1M), and Quarter (3M).
52-Week High/Low:
Off 52W High: The % drawdown from the 52-week high.
Above 52W Low: The % extension from the 52-week low.
5. Event & History Awareness
Earnings Countdown: Displays the number of days until the next earnings report. Text turns Red inside the "Danger Zone" (less than 7 days).
IPO Timer: Calculates exactly how many years have passed since the stock's public listing, allowing you to quickly filter for fresh merchandise vs. mature assets.
Settings & Customization
This script is built for "Chart Real Estate" management. You have full control over the visual layout via the inputs tab:
Display Toggles: Every metric (Float %, Dist from High/Low, IPO Timer, VWAPs, etc.) has its own checkbox. Uncheck what you don't need to keep the table compact.
Table Positioning:
Location: Pin the table to any corner (Top/Bottom, Left/Right).
Size: Scale the table from Tiny to Large to fit your resolution.
Push Down: A unique feature that adds empty transparent rows to the top of the table. This pushes the data down so it does not obscure the most recent price candles or the ticker header.
Visual Styling:
Alignment: Independently control the text alignment (Left, Center, Right) for both the Labels and the Data columns.
Colors: Fully customizable Background and Text colors.
Note: The default text color is Black (optimized for Light Mode charts). If you use Dark Mode, simply switch the "Text Color" input to White.
Technical Notes
Data Source: Moving averages and VWAP anchors are calculated using Daily ('D') data to ensure institutional relevance.
ELMEHDI VIP (v4.0)ABO SALTAN //@version=5
indicator(title = 'ELMEHDI VIP (v4.0)', shorttitle = 'EL MEHDI KHEYI(v4.0)', overlay = true, max_boxes_count = 500, max_labels_count = 500, max_lines_count = 500, max_bars_back = 500, max_polylines_count = 100)
bullcolor = #339b44
bearcolor = #af3232
ema150 = ta.ema(close, 150)
ema250 = ta.ema(close, 250)
gr_customalert = "Custom Alerts"
gr_signal = "General Configurations"
gr_PullBacksignal = "Trading Assistants"
gr_RiskManage = "Risk Management"
gr_dash = "Dashboard Configurations"
//symbol info
symInfoCheck = false
symInfo = syminfo.ticker + ' | ' + timeframe.period + (timeframe.isminutes ? 'M' : na)
date = str.tostring(dayofmonth(time_close)) + '/' + str.tostring(month(time_close)) + '/' + str.tostring(year(time_close))
//text positioning
textVPosition = 'middle'
textHPosition = 'center'
//symbol info positioning
symVPosition = 'top'
symHPosition = 'left'
//cell size
width = 0
height1 = 0
//title settings
c_title = #b2b5be80
s_title = 'large'
a_title = 'center'
//subtitle settings
c_subtitle = #b2b5be80
s_subtitle = 'normal'
a_subtitle = 'center'
c_bg = color.new(color.blue, 100)
// Get user input
showSignals = input(true, "Show Signal's", group=gr_signal)
//showSignals = true
sensitivity = input.float(2.4, "Sensitivity", 0.1, step=0.1, group=gr_signal)
STuner = input.int(10, "Signal Tuner(1-25)", minval = 1, maxval = 25, group=gr_signal)
Presets = "All Signals"
//Presets = input.string("All Signals", "Presets", , group=gr_signal)
filterstyle = input.string("Trending Signals ", "Signal Mode / Filters", ["Trending Signals ", "Contrarian Signals ", "High Volume ", "Strong ", "Swing ", "Smooth ", "Scalping ", "Scalping+ "], group=gr_signal)
//TextStyle = input.string("Minimal", "Signal Style", , group=gr_signal)
//periodTrendCloud = input.string("Smooth", "Trend Cloud Style", , group=gr_Other_Settings)
TextStyle = "Minimal"
consSignalsFilter = filterstyle == "Trending Signals " ? true : false
StrongSignalsOnly = filterstyle == "Strong " ? true : false
highVolSignals = filterstyle == "High Volume " ? true : false
signalsTrendCloud = (filterstyle == "Smooth ") ? true : (filterstyle == "Scalping ") ? true : (filterstyle == "Scalping+ ") ? true : (filterstyle == "Swing ") ? true : false
ContrarianOnly = filterstyle == "Contrarian Signals " ? true : false
TrendMap = 'Trend Gradient'
momentumCandles = false
assistantenable = input(true,'', group=gr_PullBacksignal, inline = 'sexyshit')
assistantmode = input.string('Trend Assistant', 'Assistant | Mode', , group = gr_PullBacksignal, inline = 'sexyshit')
Show_PR = input.bool(true, title="", group = gr_PullBacksignal , inline = "Features1")
MSTuner = input.int(8, "Reversal Dot | Tuner(2-30)", minval = 2, maxval = 30, group=gr_PullBacksignal, inline = "Features1")
LongTrendAverage = assistantmode == 'Trend Tracker' and assistantenable == true ? true : false
analyscloud = assistantmode == 'Trend Assistant' and assistantenable == true ? true : false
showTrendCloud = (filterstyle == "Smooth ") ? true : (filterstyle == "Scalping ") ? true : (filterstyle == "Scalping+ ") ? true : (filterstyle == "Swing ") ? true : false
periodTrendCloud = (filterstyle == "Smooth ") ? "Smooth" : (filterstyle == "Scalping ") ? "Scalping" : (filterstyle == "Scalping+ ") ? "Scalping+" : (filterstyle == "Swing ") ? "Swing" : na
//ScalpingPlus = input(false, "Fast trend cloud", group=gr_Other_Settings)
//fastTrendCloudLen = input.int(55, "Fast trend cloud", 2, group=gr_Other_Settings)
fill(plot(showTrendCloud and periodTrendCloud == "Smooth" ? na : assistantenable == true and assistantmode == 'Trend Tracker' ? ema150 : na, "", na, editable=false), plot(showTrendCloud and periodTrendCloud == "Smooth" ? na : assistantenable == true and assistantmode == 'Trend Tracker' ? ema250 : na, "", na, editable=false), ema150 > ema250 ? color.new(bullcolor, 70) : ema150 < ema250 ? color.new(bearcolor, 70) : na)
showDashboard = input(true, "Smart Panel", group = gr_dash , inline = "Features1")
locationDashboard = input.string("Bottom Right", "Dashboard Location", , group = gr_dash , tooltip="Smart Panel")
sizeDashboard = input.string("Small", "Dashboard Size", , group = gr_dash , tooltip="Smart Panel")
tpLabels = input(true, "Dynamic Take Profit Lables", group=gr_RiskManage)
ShowTpSlAreas = input(true, "Show take Profit/Stop-loss Area", group=gr_RiskManage)
ShowTrailingSL = input(false, "Show trailing Stop-loss", group=gr_RiskManage)
usePercSL = input(false, "SL/TRAILING", inline="1", group=gr_RiskManage)
percTrailingSL = input.float(1, "", 0, step=0.1, inline="1", group=gr_RiskManage)
useTP1 = input(true, "", inline="1", group=gr_RiskManage)
multTP1 = input.float(1, "TP 1", 0, inline="1", group=gr_RiskManage)
useTP2 = input(true, "", inline="4", group=gr_RiskManage)
multTP2 = input.float(2, "TP 2", 0, inline="4", group=gr_RiskManage)
useTP3 = input(true, "", inline="4", group=gr_RiskManage)
multTP3 = input.float(3, "TP 3", 0, inline="4", group=gr_RiskManage)
ShowSwings = input(false, "Show Market Structure", inline="3", group=gr_RiskManage)
periodSwings = input.int(10, "", 2, inline="3", group=gr_RiskManage)
//showTS = input(title='Show Trend Shifter', defval=false, group='Contrarian SIGNALS')
// showsignals = input(title='Show Signals', defval=false, group='Contrarian SIGNALS')
// Alerts Managemnt
Normalbuy_alert = input.bool(title='Buy Signal', defval=false, inline = "NB", group=gr_customalert)
Strongbuy_alert = input.bool(title='Strong Buy', defval=true, inline = "NB", group=gr_customalert)
Normalsell_alert = input.bool(title='Sell Signal', defval=false , inline = "NS", group=gr_customalert)
Strongsell_alert = input.bool(title='Strong Sell', defval=true , inline = "NS", group=gr_customalert)
slalert = input.bool(title='Stop-Loss', defval=true , inline = "SLTP1", group=gr_customalert)
tp1alert = input.bool(title='Target 1', defval=true , inline = "SLTP1", group=gr_customalert)
tp2alert = input.bool(title='Target 2', defval=true , inline = "TP2TP3", group=gr_customalert)
tp3alert = input.bool(title='Target 3', defval=true , inline = "TP2TP3", group=gr_customalert)
bullcrosscloud_alert = input.bool(title='Bullish Cloud', defval=false, inline = "CD", group=gr_customalert)
bearcrosscloud_alert = input.bool(title='Bearish Cloud', defval=false, inline = "CD", group=gr_customalert)
showCons = false
paintCons = false
// Signal Text
SimpleBuy = "Buy"
StrongB = "Strong Buy"
SimpleSell = "Sell"
StrongS = "Strong Sell"
if TextStyle == "Normal"
SimpleBuy := "Buy"
StrongB := "BUY"
SimpleSell:= "Sell"
StrongS := "Strong Sell"
if TextStyle == "Minimal"
SimpleBuy := "⬆"
StrongB := "⬆⬆"
SimpleSell:= "⬇"
StrongS := "⬇⬇"
// Signal Text Color
// bullsignalcolor = #ffffff
// bearsignalcolor = color.rgb(255, 255, 255)
// if TextStyle == "Normal"
// bullsignalcolor := color.rgb(255, 255, 255)
// bearsignalcolor := color.rgb(255, 255, 255)
// if TextStyle == "Minimal"
// bullsignalcolor := color.rgb(255, 255, 255)
// bearsignalcolor := color.rgb(255, 255, 255)
src = close
RSII = ta.ema(ta.rsi(src, 50), 30)
TR = math.abs(RSII - RSII )
wwalpha = 1 / 50
WWMA = 0.0
WWMA := wwalpha * TR + (1 - wwalpha) * nz(WWMA )
ATRRSI = 0.0
ATRRSI := wwalpha * WWMA + (1 - wwalpha) * nz(ATRRSI )
TsFast = ta.ema(ta.rsi(src, 50), 30)
TsUP = TsFast + ATRRSI * 4.236
TsDN = TsFast - ATRRSI * 4.236
textWatermark = table.new(textVPosition + '_' + textHPosition, 1, 3)
TsSlow = 0.0
TsSlow := TsUP < nz(TsSlow ) ? TsUP : TsFast > nz(TsSlow ) and TsFast < nz(TsSlow ) ? TsDN : TsDN > nz(TsSlow ) ? TsDN : TsDN < nz(TsSlow ) and TsFast > nz(TsSlow ) ? TsUP : nz(TsSlow )
Colorh = TsFast > 55 ? color.rgb(255, 0, 0) : TsFast < 45 ? color.rgb(0, 255, 8) : #ffffff
//QQF = plot(TsFast, 'TS FAST', color=color.new(color.maroon, 100), linewidth=2, display=display.none, editable = false)
//QQS = plot(TsSlow, 'TS SLOW', color=color.new(color.white, 100), linewidth=2, display=display.none , editable = false)
//plot(TsFast, color=Colorh, linewidth=2, style=plot.style_area, histbase=50)
//BearLimit = hline(60, color=color.gray, linestyle=hline.style_dashed)
//BullLimt = hline(40, color=color.gray, linestyle=hline.style_dashed)
bulllim = 45
bearlim = 55
BullSignalr = ta.crossover(TsFast, TsSlow) and TsFast < bulllim
BearSignallr = ta.crossunder(TsFast, TsSlow) and TsFast > bearlim
/////////////////////////////////////////////////////////
// Trap Detector
////////////////////////////////////////////////////////
// Functions
wavetrend(src, chlLen, avgLen) =>
esa = ta.ema(src, chlLen)
d = ta.ema(math.abs(src - esa), chlLen)
ci = (src - esa) / (0.015 * d)
wt1 = ta.ema(ci, avgLen)
wt2 = ta.sma(wt1, 3)
f_top_fractal(src) => src < src and src < src and src > src and src > src
f_bot_fractal(src) => src > src and src > src and src < src and src < src
f_fractalize (src) => f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0
f_findDivs(src, topLimit, botLimit) =>
fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na
fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na
highPrev = ta.valuewhen(fractalTop, src , 0)
highPrice = ta.valuewhen(fractalTop, high , 0)
lowPrev = ta.valuewhen(fractalBot, src , 0)
lowPrice = ta.valuewhen(fractalBot, low , 0)
bearSignal = fractalTop and high > highPrice and src < highPrev
bullSignal = fractalBot and low < lowPrice and src > lowPrev
// Get components
= wavetrend(close, 5*MSTuner, 10*MSTuner)
= f_findDivs(wt2, 10, -35)
= f_findDivs(wt2, 40, -70)
wtDivBull = wtDivBull1 or wtDivBull2
wtDivBear = wtDivBear1 or wtDivBear2
plotshape(ta.crossover(wt1, wt2) and Show_PR and wt2 <= -60)
plotshape(ta.crossunder(wt1, wt2) and Show_PR and wt2 >= 60)
rsi = ta.rsi(close ,14)
// Functions
f_chartTfInMinutes() =>
float _resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1. / 60 :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 60. * 24 :
timeframe.isweekly ? 60. * 24 * 7 :
timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
atr(len) =>
tr = ta.tr
atr = 0.0
atr := nz(atr + (tr - atr ) / len, tr)
supertrend(src, factor, len) =>
atr = ta.atr(len)
upperBand = src + factor * atr
lowerBand = src - factor * atr
prevLowerBand = nz(lowerBand )
prevUpperBand = nz(upperBand )
lowerBand := lowerBand > prevLowerBand or close < prevLowerBand ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or close > prevUpperBand ? upperBand : prevUpperBand
int direction = na
float superTrend = na
prevSuperTrend = superTrend
if prevSuperTrend == prevUpperBand
direction := close > upperBand ? 1 : -1
else
direction := close < lowerBand ? -1 : 1
superTrend := direction == 1 ? lowerBand : direction == -1 ? upperBand : na
dchannel(len)=>
hh = ta.highest(len)
ll = ta.lowest (len)
trend = 0
trend := close > hh ? 1 : close < ll ? -1 : nz(trend )
trendScalper(show, len1, len2, len3, colorBull, colorBear, colorBarBull, colorBarBear) =>
avgOC = math.avg(open, close)
ha_o = 0.0, ha_o := na(ha_o ) ? avgOC : (ha_o + ohlc4 ) / 2
ema1 = ta.ema(ha_o, len1), ema2 = ta.ema(ha_o, len2), ema3 = ta.ema(ha_o, len3)
ris1 = ema1 > ema1 , ris2 = ema2 > ema2 , ris3 = ema3 > ema3
fal1 = ema1 < ema1 , fal2 = ema2 < ema2 , fal3 = ema3 < ema3
colorEma1 = ris1 ? colorBull : fal1 ? colorBear : na, colorEma2 = ris2 ? colorBull : fal2 ? colorBear : na, colorEma3 = ris3 ? colorBull : fal3 ? colorBear : na
fillEma1 = avgOC > ema1 ? colorBull : avgOC < ema1 ? colorBear : na, fillEma2 = ema1 > ema2 ? colorBull : ema1 < ema2 ? colorBear : na, fillEma3 = ema2 > ema3 ? colorBull : ema2 < ema3 ? colorBear : na
colorBar = close < ema1 and close < ema2 ? colorBarBear : colorBarBull
candlesMom() =>
= ta.macd(close, 2, 4, 3)
(macd > 10 and macd > macd ) or (macd < 10 and macd < macd )
trailingSL(buy, sell, factor, len, usePerc, perc) =>
atr = atr(len)
upperBand = high + (usePerc ? high * (perc / 100) : factor * atr)
lowerBand = low - (usePerc ? low * (perc / 100) : factor * atr)
prevLowerBand = nz(lowerBand )
prevUpperBand = nz(upperBand )
lowerBand := lowerBand > prevLowerBand or buy ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or sell ? upperBand : prevUpperBand
int direction = na
float stop = na
prevSuperTrend = stop
if prevSuperTrend == prevUpperBand
direction := buy ? 1 : -1
else
direction := sell ? -1 : 1
stop := direction == 1 ? lowerBand : direction == -1 ? upperBand : na
add_to_zz(zz, val, bi) =>
array.unshift(zz, bi)
array.unshift(zz, val)
if array.size(zz) > 12
array.pop(zz)
update_zz(zz, val, bi, dir) =>
if array.size(zz) == 0
add_to_zz(zz, val, bi)
else
if dir == 1 and val > array.get(zz, 0) or dir == -1 and val < array.get(zz, 0)
array.set(zz, 0, val)
array.set(zz, 1, bi)
0
// Get components
vosc = ta.obv - ta.ema(ta.obv, 20)
bs = ta.ema(nz(math.abs((open - close) / (high - low) * 100)), 3)
ema = ta.ema(close, 200)
emaBull = close > ema
equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes()
higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes()
too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10)
securityNoRep(sym, res, src) =>
bool bull = na
bull := equal_tf(res) ? src : bull
bull := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_off) : bull
bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)
if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)
bull := array.pop(bull_array)
array.clear(bull_array)
bull
//TF1Bull = securityNoRep(syminfo.tickerid, "1" , emaBull)
//TF3Bull = securityNoRep(syminfo.tickerid, "3" , emaBull)
TF5Bull = securityNoRep(syminfo.tickerid, "5" , emaBull)
//TF10Bull = securityNoRep(syminfo.tickerid, "10" , emaBull)
TF15Bull = securityNoRep(syminfo.tickerid, "15" , emaBull)
TF30Bull = securityNoRep(syminfo.tickerid, "30" , emaBull)
TF60Bull = securityNoRep(syminfo.tickerid, "60" , emaBull)
//TF120Bull = securityNoRep(syminfo.tickerid, "120" , emaBull)
TF240Bull = securityNoRep(syminfo.tickerid, "240" , emaBull)
//TF720Bull = securityNoRep(syminfo.tickerid, "720" , emaBull)
//TFDBull = securityNoRep(syminfo.tickerid, "1440", emaBull)
hma55 = ta.hma(close, 55 )
= ta.macd(close, 12, 26, 9)
supertrend = supertrend(close, sensitivity, STuner)
maintrend = dchannel(30)
confBull = (ta.crossover (close, supertrend) or (ta.crossover (close, supertrend) and maintrend < 0)) and macd > 0 and macd > macd and ema150 > ema250 and hma55 > hma55 and maintrend > 0
confBear = (ta.crossunder(close, supertrend) or (ta.crossunder(close, supertrend) and maintrend > 0)) and macd < 0 and macd < macd and ema150 < ema250 and hma55 < hma55 and maintrend < 0
trendcloud = supertrend(ohlc4, periodTrendCloud == "Swing" ? 7 : 4, 10)
hma = periodTrendCloud == "Scalping+" ? ta.hma(close, 55) : na
none = close > 0
= ta.dmi(14, 14)
consFilter = adx > 20
ContBear = TsFast > 65
ContBull = TsFast < 35
StrongFilter = ta.ema(close, 200)
//volFilter = (ta.ema(volume, 25) - ta.ema(volume, 26)) / ta.ema(volume, 26) > 0
volFilter = (ta.ema(volume, 15) - ta.ema(volume, 20)) / ta.ema(volume, 25) > 0
trendFilter = trendcloud
bull = (Presets == "All Signals" ? ta.crossover (close, supertrend) : confBull and not confBull ) and Presets != "Trend Scalper" and (StrongSignalsOnly ? close > StrongFilter : none) and (ContrarianOnly ? ContBull : none) and (consSignalsFilter ? consFilter : none) and (highVolSignals ? volFilter : none) and (signalsTrendCloud ? (periodTrendCloud == "Smooth" ? ema150 > ema250 : close > trendFilter) : none)
bear = (Presets == "All Signals" ? ta.crossunder(close, supertrend) : confBear and not confBear ) and Presets != "Trend Scalper" and (StrongSignalsOnly ? close < StrongFilter : none) and (ContrarianOnly ? ContBear : none) and (consSignalsFilter ? consFilter : none) and (highVolSignals ? volFilter : none) and (signalsTrendCloud ? (periodTrendCloud == "Smooth" ? ema150 < ema250 : close < trendFilter) : none)
countBull = ta.barssince(bull)
countBear = ta.barssince(bear)
trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0
= trendScalper(Presets == "Trend Scalper" ? true : false, 5, 9, 21, bullcolor, bearcolor, bullcolor, bearcolor)
trailingStop = trailingSL(bull, bear, 2.2, 14, usePercSL, percTrailingSL)
float _ph = ta.highestbars(high, periodSwings) == 0 ? high : na
float _pl = ta.lowestbars (low, periodSwings) == 0 ? low : na
var _dir = 0, dir_ = _pl and na(_ph) ? -1 : _dir, _dir := _ph and na(_pl) ? 1 : dir_, dirChg = ta.change(_dir)
var zz = array.new_float(0), zzOld = array.copy(zz)
float zzLive = _ph or _pl ? (dirChg ? add_to_zz(zz, _dir == 1 ? _ph : _pl, bar_index) : update_zz(zz, _dir == 1 ? _ph : _pl, bar_index, _dir)) : na
float hb_ = ta.highestbars(10) == 0 ? high : na
float lb_ = ta.lowestbars (10) == 0 ? low : na
var int dir = 0
float zz_ = na
float pp = na
var int consCnt = 0
var float condHi = na
var float condLo = na
float H_ = ta.highest(5)
float L_ = ta.lowest (5)
var line lineUp = na
var line lineDn = na
bool breakUp = false
bool breakDn = false
var float pvh1_price = array.new_float(1000, na)
var int pvh1_time = array.new_int (1000, na)
var float pvl1_price = array.new_float(1000, na)
var int pvl1_time = array.new_int (1000, na)
var float pvh2_price = array.new_float(1000, na)
var int pvh2_time = array.new_int (1000, na)
var float pvl2_price = array.new_float(1000, na)
var int pvl2_time = array.new_int (1000, na)
var float htcmrll_price = na
var int htcmrll_time = na
var float ltcmrhh_price = na
var int ltcmrhh_time = na
var box long_boxes = array.new_box()
var box short_boxes = array.new_box()
var float temp_pv_0 = na
var float temp_pv_1 = na
var float temp_pv_2 = na
bool pvh = high < high and high > high
bool pvl = low > low and low < low
int pv1_time = bar_index
float pv1_high = high
float pv1_low = low
var buyBars = array.new_box(365, na)
for i = 0 to 364
box.delete(array.get(buyBars, i))
var sellBars = array.new_box(365, na)
for i = 0 to 364
box.delete(array.get(sellBars, i))
// Colors
green = bullcolor, green50 = color.new(green, 50), green20 = color.new(green, 80)
red = bearcolor, red50 = color.new(red, 50), red20 = color.new(red, 80)
silver = #B2B5BE, silver50 = color.new(silver, 50), silver20 = color.new(silver, 80)
// Plots
atrBand = usePercSL ? (trigger ? low : high) * (percTrailingSL / 100) : ta.atr(14) * 2.2
atrStop = trigger ? low - atrBand : high + atrBand
lastTrade(src) => ta.valuewhen(bull or bear, src, 0)
entry_y = lastTrade(close)
stop_y = lastTrade(atrStop)
tp1_y = (entry_y-lastTrade(atrStop))*multTP1 + entry_y
tp2_y = (entry_y-lastTrade(atrStop))*multTP2 + entry_y
tp3_y = (entry_y-lastTrade(atrStop))*multTP3 + entry_y
labelTpSl(cond, y, txt, color) =>
label labelTpSl = ShowTpSlAreas and cond ? label.new(bar_index + 1, y, txt, xloc.bar_index, yloc.price, color, label.style_label_left, color.white, size.normal) : na
label.delete(labelTpSl )
labelTpSl(none, entry_y, "Entry : " + str.tostring(math.round_to_mintick(entry_y)), #089981)
labelTpSl(none, stop_y , "Stop loss : " + str.tostring(math.round_to_mintick(atrStop)), bearcolor)
labelTpSl(useTP1 and multTP1 != 0, tp1_y, "TP 1 : " + str.tostring(math.round_to_mintick(tp1_y)), #089981)
labelTpSl(useTP2 and multTP2 != 0, tp2_y, "TP 2 : " + str.tostring(math.round_to_mintick(tp2_y)), #089981)
labelTpSl(useTP3 and multTP3 != 0, tp3_y, "TP 3 : " + str.tostring(math.round_to_mintick(tp3_y)), #089981)
lineTpSl(cond, y, color, style) =>
line lineTpSl = ShowTpSlAreas and cond ? line.new(bar_index - (trigger ? countBull : countBear), y, bar_index + 1, y, xloc.bar_index, extend.none, color, style) : na
line.delete(lineTpSl )
lineTpSl(none, entry_y, #089981, line.style_dashed)
lineTpSl(none, stop_y , bearcolor , line.style_solid )
lineTpSl(useTP1 and multTP1 != 0, tp1_y, bullcolor, line.style_dotted)
lineTpSl(useTP2 and multTP2 != 0, tp2_y, bullcolor, line.style_dotted)
lineTpSl(useTP3 and multTP3 != 0, tp3_y, bullcolor, line.style_dotted)
//buy = showSignals and bull ? label.new(bar_index, low , close > StrongFilter ? StrongB : SimpleBuy , xloc.bar_index, yloc.belowbar, bullcolor, label.style_label_up , color.rgb(255, 255, 255), size.normal) : na
//sell = showSignals and bear ? label.new(bar_index, high, close < StrongFilter ? StrongS : SimpleSell , xloc.bar_index, yloc.abovebar, bearcolor , label.style_label_down, color.rgb(255, 255, 255), size.normal) : na
buy = (showSignals and bull ? label.new(bar_index, low , close > StrongFilter ? StrongB : SimpleBuy , xloc.bar_index, yloc.belowbar, bullcolor, label.style_label_up , color.rgb(255, 255, 255), size.normal) : na)
sell = showSignals and bear ? label.new(bar_index, high, close < StrongFilter ? StrongS : SimpleSell , xloc.bar_index, yloc.abovebar, bearcolor , label.style_label_down, color.rgb(255, 255, 255), size.normal) : na
tpLabels(tp) =>
tp1Bull = ta.crossover (rsi, 70), tp2Bull = ta.crossover (rsi, 75), tp3Bull = ta.crossover (rsi, 80)
tp1Bull := tp1Bull and (nz(ta.barssince(tp1Bull) , 9999) > countBull), tp2Bull := tp2Bull and (ta.barssince(tp1Bull) <= countBull), tp2Bull := tp2Bull and (nz(ta.barssince(tp2Bull) , 9999) > countBull), tp3Bull := tp3Bull and (ta.barssince(tp2Bull) <= countBull), tp3Bull := tp3Bull and (nz(ta.barssince(tp3Bull) , 9999) > countBull)
tp1Bear = ta.crossunder(rsi, 30), tp2Bear = ta.crossunder(rsi, 25), tp3Bear = ta.crossunder(rsi, 20)
tp1Bear := tp1Bear and (nz(ta.barssince(tp1Bear) , 9999) > countBear), tp2Bear := tp2Bear and (ta.barssince(tp1Bear) <= countBear), tp2Bear := tp2Bear and (nz(ta.barssince(tp2Bear) , 9999) > countBear), tp3Bear := tp3Bear and (ta.barssince(tp2Bear) <= countBear), tp3Bear := tp3Bear and (nz(ta.barssince(tp3Bear) , 9999) > countBear)
if Presets != "Trend Scalper" and tpLabels
trigger ? (tp == 1 ? tp1Bull : tp == 2 ? tp2Bull : tp3Bull) : (tp == 1 ? tp1Bear : tp == 2 ? tp2Bear : tp3Bear)
plotshape(tpLabels(1), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 1", trigger ? green : na , true)
plotshape(tpLabels(2), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 2", trigger ? green : na , false)
plotshape(tpLabels(3), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 3", trigger ? green : na , false)
plotshape(tpLabels(1), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 1", trigger ? na : red, true)
plotshape(tpLabels(2), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 2", trigger ? na : red, false)
plotshape(tpLabels(3), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 3", trigger ? na : red, false)
var label zzLabel = na
if array.size(zz) > 12 and ShowSwings
if array.get(zz, 0) != array.get(zzOld, 0) or array.get(zz, 1) != array.get(zzOld, 1)
if array.get(zz, 2) == array.get(zzOld, 2) and array.get(zz, 3) == array.get(zzOld, 3)
label.delete(zzLabel)
zzLabel := label.new(math.round(array.get(zz, 1)), array.get(zz, 0), _dir == 1 ? array.get(zz, 0) > array.get(zz, 4) ? ((array.get(zz, 4) < array.get(zz, 8)) ? "High" : "HH") : "LH" : array.get(zz, 0) < array.get(zz, 4) ? ((array.get(zz, 4) > array.get(zz, 8)) ? "Low" : "LL") : "HL", xloc.bar_index, yloc.price, color.new(color.white, 100), _dir == 1 ? label.style_label_down : label.style_label_up, _dir == 1 ? bullcolor : bearcolor)
if showCons and barstate.isconfirmed
dir := hb_ and na(lb_) ? 1 : lb_ and na(hb_) ? -1 : dir
if hb_ and lb_
if dir == 1
zz_ := hb_
else
zz_ := lb_
else
zz_ := hb_ ? hb_ : lb_ ? lb_ : na
for x = 0 to 1000
if na(close) or dir != dir
break
if zz_
if na(pp)
pp := zz_
else
if dir == 1 and zz_ > pp
pp := zz_
if dir == -1 and zz_ < pp
pp := zz_
if pp != pp
if consCnt > 5
if pp > condHi
breakUp := true
if pp < condLo
breakDn := true
if consCnt > 0 and pp <= condHi and pp >= condLo
consCnt += 1
else
consCnt := 0
else
consCnt += 1
if consCnt >= 5
if consCnt == 5
condHi := H_
condLo := L_
else
line.delete(lineUp)
line.delete(lineDn)
condHi := math.max(condHi, high)
condLo := math.min(condLo, low )
lineUp := line.new(bar_index, condHi , bar_index - consCnt, condHi , color=bearcolor , style=line.style_dashed)
lineDn := line.new(bar_index, condLo , bar_index - consCnt, condLo , color=color.lime, style=line.style_dashed)
fill(plot(condHi, "", na, 1, plot.style_stepline, editable=false), plot(condLo, "", na, 1, plot.style_stepline, editable=false), paintCons and consCnt > 5 ? color.white : na, "", false)
//buy_col = color.new(#0ac20a,0)
//sell_col = color.new(#fd1605,0)
//text_col = color.new(#FFFFFF,0)
// -------- Bearish trend (blue) color selection --------
// getSellColor(count) =>
// if count == 1
// color.new(#11e7f2,0)
// else
// if count == 2
// color.new(#11d9f2,0)
// else
// if count == 3
// color.new(#11cbf2,0)
// else
// if count == 4
// color.new(#11aff2,0)
// else
// if count == 5
// color.new(#1193f2,0)
// else
// if count == 6
// color.new(#1176f2,0)
// else
// if count == 7
// color.new(#105df4,0)
// else
// if count == 8
// color.new(#1051f5,0)
// else
// if count == 9
// color.new(#0f44f5,0)
// else
// if count == 10
// color.new(#0c3de0,0)
// else
// if count == 11
// color.new(#0935ca,0)
// else
// if count == 12
// color.new(#062eb4,0)
// else
// if count == 13
// color.new(#02269e,0)
// -------- Bullish trend (blue) color selection --------
// getBuyColor(count) =>
// if count == 1
// color.new(#eef211,0)
// else
// if count == 2
// color.new(#efdc11,0)
// else
// if count == 3
// color.new(#f0c511,0)
// else
// if count == 4
// color.new(#f1af11,0)
// else
// if count == 5
// color.new(#f29811,0)
// else
// if count == 6
// color.new(#f28811,0)
// else
// if count == 7
// color.new(#f27811,0)
// else
// if count == 8
// color.new(#f26811,0)
// else
// if count == 9
// color.new(#f25811,0)
// else
// if count == 10
// color.new(#ea420d,0)
// else
// if count == 11
// color.new(#e12c09,0)
// else
// if count == 12
// color.new(#d81605,0)
// else
// if count == 13
// color.new(#cf0000,0)
// -------- Calculate bearish trend sequence --------
buySetup = 0
buySetup := close < close ? buySetup == 13 ? 1 : buySetup + 1 : 0
// -------- Calculate bullish trend sequence --------
sellSetup = 0
sellSetup := close > close ? sellSetup == 13 ? 1 : sellSetup + 1 : 0
// -------- Paint bars --------
//barColour = buySetup >= 1 ? getBuyColor(buySetup) : sellSetup >= 1 ? getSellColor(sellSetup) : na
// Candle Coloring
// Input
FastteyLength = 12
SjlowLeyLength = 26
srrrc = close
signalXLength = 9
// Data reference
= ta.macd(srrrc, FastteyLength, SjlowLeyLength, signalXLength)
// 4 level of green
greenHigh = #7bff00
greenMidHigh = #7bff00
greenMidLow = #7bff00
greenLow = #7bff00
// Yellow
yellowLow = #693d8e
// 4 level of red
redHigh = #ff0000
redMidHigh = #ff0000
redMidLow = #ff0000
redLow = #ff0000
// Default color
candleBody = yellowLow
// Ranging trend
if histX > 0
if histX > histX and histX > 0
candleBody := greenLow
if histX < 0
if histX < histX and histX < 0
candleBody := redLow
// Bullish trend
if MacdX > 0 and histX > 0
candleBody := greenMidLow
if histX > histX and MacdX > 0 and histX > 0
candleBody := greenMidHigh
if histX > histX and MacdX > 0 and histX > 0
candleBody := greenHigh
// Bearish trend
if MacdX < 0 and histX < 0
candleBody := redMidLow
if histX < histX and MacdX < 0 and histX < 0
candleBody := redMidHigh
if histX < histX and MacdX < 0 and histX < 0
candleBody := redHigh
barcolor(candleBody)
//barcolor(TrendMap == 'RSI Gradient' ? barColour : na, title='Bar colors (heatmap)',editable=false)
//barcolor(momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false)
//plotcandle(open, high, low, close , color = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , wickcolor = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , bordercolor = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , editable = false)
fill(plot(showTrendCloud and periodTrendCloud == "Smooth" ? ema150 : na, "", na, editable=false), plot(showTrendCloud and periodTrendCloud == "Smooth" ? ema250 : na, "", na, editable=false), ema150 > ema250 ? color.new(bullcolor, 70) : ema150 < ema250 ? color.new(bearcolor, 70) : na)
plot(ShowTrailingSL and trigger and nz(ta.barssince(low < trailingStop), bar_index) > countBull ? trailingStop : na, "", green, 1, plot.style_linebr, editable=false)
plot(ShowTrailingSL and not trigger and nz(ta.barssince(high > trailingStop), bar_index) > countBear ? trailingStop : na, "", red , 1, plot.style_linebr, editable=false)
p0 = plot(avgOC, "", na , editable=false)
p1 = plot(ema5 , "", colorEma5 , editable=false)
p2 = plot(ema9 , "", colorEma9 , editable=false)
p3 = plot(ema21, "", colorEma21, editable=false)
plot(LongTrendAverage ? ta.ema(close, 250) : na, 'Trend Tracer', linewidth=2, color=close > ta.ema(close, 250) ? color.new(bullcolor, 45) : color.new(bearcolor, 45))
fill(p0, p1, fillEma5 )
fill(p1, p2, fillEma9 )
fill(p2, p3, fillEma21)
fill(plot(showTrendCloud and periodTrendCloud != "Smooth" and periodTrendCloud != "Scalping+" and trendcloud != 0 and close > trendcloud ? trendcloud : na, "", bullcolor, 1, plot.style_linebr, editable=false), p0, color.new(bullcolor, 90))
fill(plot(showTrendCloud and periodTrendCloud != "Smooth" and periodTrendCloud != "Scalping+" and trendcloud != 0 and close < trendcloud ? trendcloud : na, "", bearcolor , 1, plot.style_linebr, editable=false), p0, color.new(bearcolor , 90))
//fill(plot(hma, "", hma > hma ? green : hma < hma ? red : na, editable=false), plot(hma , "", hma > hma ? green : hma < hma ? red : na, editable=false), hma > hma ? green : hma < hma ? red : na)
////////////////////////////////////////////////////////////////////////////////////////////////
// Get user input
indicatorTF = "Chart"
// Functions
sqz(bbLen, bbMult, kcLen, kcMult, source) =>
upperBB = ta.sma(source, bbLen) + ta.stdev(source, bbLen) * bbMult
lowerBB = ta.sma(source, bbLen) - ta.stdev(source, bbLen) * bbMult
upperKC = ta.sma(source, kcLen) + ta.sma(ta.tr, kcLen) * kcMult
lowerKC = ta.sma(source, kcLen) - ta.sma(ta.tr, kcLen) * kcMult
sqzOn = lowerBB > lowerKC and upperBB < upperKC
sqzOff = lowerBB < lowerKC and upperBB > upperKC
qqe(rsiLen, rsiSmooth, factor, source, bbLen, bbMult) =>
rsiMa = ta.ema(ta.rsi(source, rsiLen), rsiSmooth)
delta = ta.ema(ta.ema(math.abs(ta.mom(rsiMa, 1)), rsiLen * 2 - 1), rsiLen * 2 - 1) * factor
longBand = 0.0, longBand := rsiMa > longBand and rsiMa > longBand ? math.max(longBand , rsiMa - delta) : rsiMa - delta
shortBand = 0.0, shortBand := rsiMa < shortBand and rsiMa < shortBand ? math.min(shortBand , rsiMa + delta) : rsiMa + delta
cross1 = ta.cross(rsiMa, shortBand )
cross2 = ta.cross(rsiMa, longBand )
trend = 0.0, trend := cross1 ? 1 : cross2 ? -1 : nz(trend , 1)
fastDelta = trend == 1 ? longBand : shortBand
_hist = rsiMa - 50
_line = fastDelta - 50
= ta.bb(_line, bbLen, bbMult)
// Get components
cond(_offset) =>
top = ta.highest(high, 10)
bot = ta.lowest(low, 10)
osc = ta.ema(hlc3, 5) - ta.ema(ohlc4, 20)
oscRis = osc > osc
oscFal = osc < osc
oscA0 = osc > 0
oscB0 = osc < 0
oscTop = oscFal and oscRis
oscBot = oscRis and oscFal
bullR = oscB0 and oscBot and ((osc > ta.valuewhen(oscB0 and oscBot, osc, 1) and bot < ta.valuewhen(oscB0 and oscBot, bot, 1)))
bearR = oscA0 and oscTop and ((osc < ta.valuewhen(oscA0 and oscTop, osc, 1) and top > ta.valuewhen(oscA0 and oscTop, top, 1)))
bullH = oscB0 and oscBot and ((osc < ta.valuewhen(oscB0 and oscBot, osc, 1) and bot > ta.valuewhen(oscB0 and oscBot, bot, 1)))
bearH = oscA0 and oscTop and ((osc > ta.valuewhen(oscA0 and oscTop, osc, 1) and top < ta.valuewhen(oscA0 and oscTop, top, 1)))
= sqz(20, 2, 20, 2, close)
= qqe(6, 6, 3, close, 50, 0.001)
= qqe(6, 5, 1.618, close, 50, 1)
= ta.dmi(14, 14)
[osc , oscRis , oscFal , oscA0 , oscB0 , oscTop , oscBot , bullR , bearR , bullH , bearH , sqzOn , sqzOff , _hist1 , upper1 , lower1 , _hist2 , _line2 , tvr ]
tf = indicatorTF == "Chart" ? timeframe.period : indicatorTF == "1 minute" ? "1" : indicatorTF == "3 minutes" ? "3" : indicatorTF == "5 minutes" ? "5" : indicatorTF == "10 minutes" ? "10" : indicatorTF == "15 minutes" ? "15" : indicatorTF == "30 minutes" ? "30" : indicatorTF == "45 minutes" ? "45" : indicatorTF == "1 hour" ? "60" : indicatorTF == "2 hours" ? "120" : indicatorTF == "3 hours" ? "180" : indicatorTF == "4 hours" ? "240" : indicatorTF == "12 hours" ? "720" : indicatorTF == "1 day" ? "1D" : indicatorTF == "1 week" ? "1W" : indicatorTF == "1 month" ? "1M" : na
= request.security(syminfo.tickerid, tf, cond(indicatorTF != "Chart" and barstate.isrealtime ? 1 : 0))
//colorTVR = tvr < 15 ? #F6525F : tvr > 15 and tvr < 25 ? #B2B5BE : #66BB6A
// Plots
//plot(Presets == "Money Moves TrendVR" ? tvr : na, "", colorTVR, editable=false)
TrendText = "Trending"
if tvr < 15 and tvr < 25
TrendText := "No trend"
if tvr > 15 and tvr < 25
TrendText := "Ranging"
//------------------------------------------------------------------------------------------------------- Volatitiry
//Calculates Volatility for Dashboard
atrr = 3 * ta.atr(10)
stdAtr = 2 * ta.stdev(atrr, 20)
smaAtr = ta.sma(atrr, 20)
topAtrDev = smaAtr + stdAtr
bottomAtrDev = smaAtr - stdAtr
calcDev = (atrr - bottomAtrDev) / (topAtrDev - bottomAtrDev)
percentVol = 40 * calcDev + 30
AvrLength = 21
PercentFilter = 144
xAavrVolume = ta.rma(volume, AvrLength)
nResLess = volume * 100 / xAavrVolume < PercentFilter ? 0 : volume
nRes = nResLess
clr = close < open ? #b2b5be : #00dbff
//plot(nRes, color=clr, style=plot.style_columns, title='Volume Filter', transp=20)
VolitiText = "Inactive"
if nRes
VolitiText := "Active"
//////////////////////////////////////////
ema69 = ta.ema(close, 9)
totalSentTxt = ema69 > ema69 ? 'Bullish' : ema69 < ema69 ? 'Bearish' : 'Flat'
// INputs
//Timezones
tz_incr = 0
use_exchange = false
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
//Session A
NYSes = true
NYTxt = 'New York'
NYTime = '1300-2200'
//Session B
LDSes = true
sesb_txt = 'London'
sesb_ses = '0700-1600'
//Session C
show_sesc = true
sesc_txt = 'Tokyo'
sesc_ses = '0000-0900'
//Session D
show_sesd = true
sesd_txt = 'Sydney'
sesd_ses = '2100-0600'
//-----------------------------------------------------------------------------}
//Sessions
//-----------------------------------------------------------------------------{
tff = timeframe.period
var tz = use_exchange ? syminfo.timezone :
str.format('UTC{0}{1}', tz_incr >= 0 ? '+' : '-', math.abs(tz_incr))
is_sesa = math.sign(nz(time(tff, NYTime, tz)))
is_sesb = math.sign(nz(time(tff, sesb_ses, tz)))
is_sesc = math.sign(nz(time(tff, sesc_ses, tz)))
is_sesd = math.sign(nz(time(tff, sesd_ses, tz)))
////////////////////////////////////////////
SessionText = "Default"
if is_sesd
SessionText := sesd_txt
if is_sesc
SessionText := sesc_txt
if is_sesb
SessionText := sesb_txt
if is_sesa
SessionText := NYTxt
if is_sesd and is_sesc
SessionText := "Sydney/Tokyo"
if is_sesb and is_sesc
SessionText := "Tokyo/London"
if is_sesb and is_sesa
SessionText := "London/Newyork"
if is_sesa and is_sesd
SessionText := "Newyork/Sydney"
//-----------------------------------------------------------------------------}
//Overlays color.green : color.red
//
var dashboard_loc = locationDashboard == "Top Right" ? position.top_right : locationDashboard == "Middle Right" ? position.middle_right : locationDashboard == "Bottom Right" ? position.bottom_right : locationDashboard == "Top Center" ? position.top_center : locationDashboard == "Middle Center" ? position.middle_center : locationDashboard == "Bottom Center" ? position.bottom_center : locationDashboard == "Top Left" ? position.top_left : locationDashboard == "Middle Left" ? position.middle_left : position.bottom_left
var dashboard_size = sizeDashboard == "Large" ? size.large : sizeDashboard == "Normal" ? size.normal : sizeDashboard == "Small" ? size.small : size.tiny
var dashboard = showDashboard ? table.new(dashboard_loc, 3, 7, color.rgb(0, 0, 0, 60), #3d384300, 2, color.rgb(30, 34, 45 , 60), 1) : na
dashboard_cell(column, row, txt, signal=false) => table.cell(dashboard, column, row, txt, 0, 0, signal ? #000000 : color.white, text_size=dashboard_size)
dashboard_cell_bg(column, row, col) => table.cell_set_bgcolor(dashboard, column, row, col)
if barstate.islast and showDashboard
// MTF Trend
dashboard_cell(0, 0 , "MTF")
dashboard_cell(0, 2 , "M5") , dashboard_cell_bg(0, 2 , TF5Bull ? color.rgb(70, 153, 67) : #880000)
dashboard_cell(0, 3 , "M15") , dashboard_cell_bg(0, 3 , TF15Bull ? color.rgb(70, 153, 67) : #880000)
dashboard_cell(0, 4 , "M30") , dashboard_cell_bg(0, 4 , TF30Bull ? color.rgb(70, 153, 67) : #880000)
dashboard_cell(0, 5 , "1H") , dashboard_cell_bg(0, 5 , TF60Bull ? color.rgb(70, 153, 67) : #880000)
dashboard_cell(0, 6 , "4H") , dashboard_cell_bg(0, 6 , TF240Bull ? color.rgb(70, 153, 67) : #880000)
// Middel part
dashboard_cell(1, 0 , "PoseidonPips")
dashboard_cell(1, 2 , "Market State")
dashboard_cell(1, 3 , "Volatility")
dashboard_cell(1, 4 , "Institutional Activity")
dashboard_cell(1, 5 , "Current Session (UTC)")
dashboard_cell(1, 6 , "Trend Pressure")
// End part
dashboard_cell(2, 0 , "")
dashboard_cell(2, 2 , TrendText)
dashboard_cell(2, 3 , str.tostring(percentVol, '##.##') + '%')
dashboard_cell(2, 4 , VolitiText)
dashboard_cell(2, 5 , SessionText)
dashboard_cell(2, 6 , totalSentTxt)
// Alerts
// Cross Functions for SL and TP
f_sl_crossed() =>
ret = false
crossBull = low >= ta.lowest(low, 5) and low < ta.lowest(low, 5)
crossBear = high <= ta.highest(high, 5) and high > ta.highest(high, 5)
ret := trigger ? crossBull : crossBear
ret
f_tp_crossed(tp) =>
ret = false
crossBull = high <= tp and high > tp
crossBear = low >= tp and low < tp
ret := trigger ? crossBull : crossBear
ret
// Alert Conditions
alert04 = bull and close <= StrongFilter
alert07 = bull and close > StrongFilter
alert09 = f_sl_crossed()
alert11 = f_tp_crossed(60.0)
alert12 = f_tp_crossed(80.0)
alert13 = f_tp_crossed(100.0)
alert14 = periodTrendCloud == "Smooth" ? ta.crossunder(ema150, ema250) : (close < trendcloud) and (close > trendcloud )
alert15 = periodTrendCloud == "Smooth" ? ta.crossover(ema150, ema250) : (close > trendcloud) and (close < trendcloud )
// Signal Alerts
if alert04 and Normalbuy_alert
alert('Buy Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert07 and Strongbuy_alert
alert('Strong Buy Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if (bear and close >= StrongFilter) and Normalsell_alert
alert('Sell Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if (bear and close < StrongFilter) and Strongsell_alert
alert('Strong Sell Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
// Risk Management Alerts
if alert09 and slalert
alert('SL Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert11 and tp1alert
alert('Target 1 Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert12 and tp2alert
alert('Target 2 Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert13 and tp3alert
alert('Target 3 Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
// Cloud Alerts
if alert15 and bullcrosscloud_alert
alert('Cloud Turned Bullish !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert14 and bearcrosscloud_alert
alert('Cloud Turned Bearish !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
// Alert Conditions for TradingView
alertcondition(alert04, "Normal Buy Alert", "Normal Buy Signal")
alertcondition(alert07, "Strong Buy Alert", "Strong Buy Signal")
alertcondition((bear and close >= StrongFilter), "Normal Sell Alert", "Normal Sell Signal")
alertcondition((bear and close < StrongFilter), "Strong Sell Alert", "Strong Sell Signal")
alertcondition(alert09, "SL Crossed Alert", "Stop Loss Crossed")
alertcondition(alert11, "TP1 Crossed Alert", "Target 1 Crossed")
alertcondition(alert12, "TP2 Crossed Alert", "Target 2 Crossed")
alertcondition(alert13, "TP3 Crossed Alert", "Target 3 Crossed")
// Input
fastLength = 12
slowLength = 26
srcceed = close
signalLength = 9
// Data reference
= ta.macd(srcceed, fastLength, slowLength, signalLength)
// 4 level of green
greenHighh = #7bff00
greenMidHighh = #7bff00
greenMidLowh = #7bff00
greenLowh = #7bff00
// Yellow
yellowLowh = #693d8e
// 4 level of red
redHighh = #ff0000
redMidHighh = #ff0000
redMidLowh = #ff0000
redLowh = #ff0000
// Default color
candleBodyd = yellowLowh
// Ranging trend
if hist > 0
if hist > hist and hist > 0
candleBodyd := greenLowh
if hist < 0
if hist < hist and hist < 0
candleBodyd := redLowh
// Bullish trend
if macdda > 0 and hist > 0
candleBodyd := greenMidLowh
if hist > hist and macd > 0 and hist > 0
candleBodyd := greenMidHighh
if hist > hist and macd > 0 and hist > 0
candleBodyd := greenHighh
// Bearish trend
if macdda < 0 and hist < 0
candleBodyd := redMidLowh
if hist < hist and macd < 0 and hist < 0
candleBodyd := redMidHighh
if hist < hist and macd < 0 and hist < 0
candleBodyd := redHighh
barcolor(candleBodyd) // Include suggestion by Shaheen204
//
tenkan_len = 365
tenkan_mult = 3
kijun_len = 365
kijun_mult = 7
spanB_len = 365
spanB_mult = 10
offset = 1
//------------------------------------------------------------------------------
avg(src,length,mult)=>
atr = ta.atr(50)*mult
up = hl2 + atr
dn = hl2 - atr
upper = 0.,lower = 0.
upper := src < upper ? math.min(up,upper ) : up
lower := src > lower ? math.max(dn,lower ) : dn
os = 0,max = 0.,min = 0.
os := src > upper ? 1 : src < lower ? 0 : os
spt = os == 1 ? lower : upper
max := ta.cross(src,spt) ? math.max(src,max ) : os == 1 ? math.max(src,max ) : spt
min := ta.cross(src,spt) ? math.min(src,min ) : os == 0 ? math.min(src,min ) : spt
math.avg(max,min)
//------------------------------------------------------------------------------
tenkan = avg(close,tenkan_len,tenkan_mult)
kijun = avg(close,kijun_len,kijun_mult)
senkouA = math.avg(kijun,tenkan)
senkouB = avg(close,spanB_len,spanB_mult)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Smart Money Concept
settings = "Settings"
zigzag_len = input.int(9, "ZigZag Length", group=settings)
show_zigzag = input.bool(false, "Show Zigzag", group=settings)
fib_factor = input.float(0.33, "Fib Factor for breakout confirmation", 0, 1, 0.01, group=settings)
text_size = input.string(size.tiny, "Text Size", , group=settings)
delete_boxes = input.bool(true, "Delete Old/Broken Boxes", group=settings)
bu_ob_inline_color = "Bu-OB Colors"
be_ob_inline_color = "Be-OB Colors"
bu_bb_inline_color = "Bu-BB Colors"
be_bb_inline_color = "Be-BB Colors"
bu_ob_display_settings = "Bu-OB Display Settings"
bu_ob_color = input.color(color.new(color.green, 70), "Color", group=bu_ob_display_settings, inline=bu_ob_inline_color)
bu_ob_border_color = input.color(color.green, "Border Color", group=bu_ob_display_settings, inline=bu_ob_inline_color)
bu_ob_text_color = input.color(color.green, "Text Color", group=bu_ob_display_settings, inline=bu_ob_inline_color)
be_ob_display_settings = "Be-OB Display Settings"
be_ob_color = input.color(color.new(color.red, 70), "Color", group=be_ob_display_settings, inline=be_ob_inline_color)
be_ob_border_color = input.color(color.red, "Border Color", group=be_ob_display_settings, inline=be_ob_inline_color)
be_ob_text_color = input.color(color.red, "Text Color", group=be_ob_display_settings, inline=be_ob_inline_color)
bu_bb_display_settings = "Bu-BB & Bu-MB Display Settings"
bu_bb_color = input.color(color.new(color.green, 70), "Color", group=bu_bb_display_settings, inline=bu_bb_inline_color)
bu_bb_border_color = input.color(color.green, "Border Color", group=bu_bb_display_settings, inline=bu_bb_inline_color)
bu_bb_text_color = input.color(color.green, "Text Color", group=bu_bb_display_settings, inline=bu_bb_inline_color)
be_bb_display_settings = "Be-BB & Be-MB Display Settings"
be_bb_color = input.color(color.new(color.red, 70), "Color", group=be_bb_display_settings, inline=be_bb_inline_color)
be_bb_border_color = input.color(color.red, "Border Color", group=be_bb_display_settings, inline=be_bb_inline_color)
be_bb_text_color = input.color(color.red, "Text Color", group=be_bb_display_settings, inline=be_bb_inline_color)
var float high_points_arr = array.new_float(5)
var int high_index_arr = array.new_int(5)
var float low_points_arr = array.new_float(5)
var int low_index_arr = array.new_int(5)
var box bu_ob_boxes = array.new_box(5)
var box be_ob_boxes = array.new_box(5)
var box bu_bb_boxes = array.new_box(5)
var box be_bb_boxes = array.new_box(5)
to_up = high >= ta.highest(zigzag_len)
to_down = low <= ta.lowest(zigzag_len)
trend = 1
trend := nz(trend , 1)
trend := trend == 1 and to_down ? -1 : trend == -1 and to_up ? 1 : trend
last_trend_up_since = ta.barssince(to_up )
low_val = ta.lowest(nz(last_trend_up_since > 0 ? last_trend_up_since : 1, 1))
low_index = bar_index - ta.barssince(low_val == low)
last_trend_down_since = ta.barssince(to_down )
high_val = ta.highest(nz(last_trend_down_since > 0 ? last_trend_down_since : 1, 1))
high_index = bar_index - ta.barssince(high_val == high)
if ta.change(trend) != 0
if trend == 1
array.push(low_points_arr, low_val)
array.push(low_index_arr, low_index)
if trend == -1
array.push(high_points_arr, high_val)
array.push(high_index_arr, high_index)
f_get_high(ind) =>
f_get_low(ind) =>
f_delete_box(box_arr) =>
if delete_boxes
box.delete(array.shift(box_arr))
else
array.shift(box_arr)
0
= f_get_high(0)
= f_get_high(1)
= f_get_low(0)
= f_get_low(1)
if ta.change(trend) != 0 and show_zigzag
if trend == 1
line.new(h0i, h0, l0i, l0)
if trend == -1
line.new(l0i, l0, h0i, h0)
market = 1
market := nz(market , 1)
// market := market == 1 and close < l0 and low < l0 - math.abs(h0 - l0) * fib_factor ? -1 : market == -1 and close > h0 and high > h0 + math.abs(h0 - l0) * fib_factor ? 1 : market
last_l0 = ta.valuewhen(ta.change(market) != 0, l0, 0)
last_h0 = ta.valuewhen(ta.change(market) != 0, h0, 0)
market := last_l0 == l0 or last_h0 == h0 ? market : market == 1 and l0 < l1 and l0 < l1 - math.abs(h0 - l1) * fib_factor ? -1 : market == -1 and h0 > h1 and h0 > h1 + math.abs(h1 - l0) * fib_factor ? 1 : market
bu_ob_index = bar_index
bu_ob_index := nz(bu_ob_index , bar_index)
for i=h1i to l0i
index = bar_index - i
if open > close
bu_ob_index := bar_index
bu_ob_since = bar_index - bu_ob_index
be_ob_index = bar_index
be_ob_index := nz(be_ob_index , bar_index)
for i=l1i to h0i
index = bar_index - i
if open < close
be_ob_index := bar_index
be_ob_since = bar_index - be_ob_index
be_bb_index = bar_index
be_bb_index := nz(be_bb_index , bar_index)
for i=h1i - zigzag_len to l1i
index = bar_index - i
if open > close
be_bb_index := bar_index
be_bb_since = bar_index - be_bb_index
bu_bb_index = bar_index
bu_bb_index := nz(bu_bb_index , bar_index)
for i=l1i - zigzag_len to h1i
index = bar_index - i
if open < close
bu_bb_index := bar_index
bu_bb_since = bar_index - bu_bb_index
if ta.change(market) != 0
if market == 1
line.new(h1i, h1, h0i, h1, color=color.green, width=1)
label.new(int(math.avg(h1i, l0i)), h1, "BoS", color=color.new(color.black, 100), style=label.style_label_down, textcolor=color.green, size=size.small)
bu_ob = box.new(bu_ob_index, high , bar_index + 10, low , bgcolor=bu_ob_color, border_color=bu_ob_border_color, text="Bu-OB", text_color=bu_ob_text_color, text_halign=text.align_right, text_size=text_size)
bu_bb = box.new(bu_bb_index, high , bar_index + 10, low , bgcolor=bu_bb_color, border_color=bu_bb_border_color, text=l0 < l1 ? "Bu-BB" : "Bu-MB", text_color=bu_bb_text_color, text_halign=text.align_right, text_size=text_size)
array.push(bu_ob_boxes, bu_ob)
array.push(bu_bb_boxes, bu_bb)
if market == -1
line.new(l1i, l1, l0i, l1, color=color.red, width=1)
label.new(int(math.avg(l1i, h0i)), l1, "BoS", color=color.new(color.black, 100), style=label.style_label_up, textcolor=color.red, size=size.small)
be_ob = box.new(be_ob_index, high , bar_index + 10, low , bgcolor=be_ob_color, border_color=be_ob_border_color, text="Be-OB", text_color=be_ob_text_color, text_halign=text.align_right, text_size=text_size)
be_bb = box.new(be_bb_index, high , bar_index + 10, low , bgcolor=be_bb_color, border_color=be_bb_border_color, text=h0 > h1 ? "Be-BB" : "Be-MB", text_color=be_bb_text_color, text_halign=text.align_right, text_size=text_size)
array.push(be_ob_boxes, be_ob)
array.push(be_bb_boxes, be_bb)
for bull_ob in bu_ob_boxes
bottom = box.get_bottom(bull_ob)
top = box.get_top(bull_ob)
if close < bottom
f_delete_box(bu_ob_boxes)
else if close < top
alert("Price in the BU-OB zone")
else
box.set_right(bull_ob, bar_index + 10)
for bear_ob in be_ob_boxes
top = box.get_top(bear_ob)
bottom = box.get_bottom((bear_ob))
if close > top
f_delete_box(be_ob_boxes)
if close > bottom
alert("Price in the BE-OB zone")
else
box.set_right(bear_ob, bar_index + 10)
for bear_bb in be_bb_boxes
top = box.get_top(bear_bb)
bottom = box.get_bottom(bear_bb)
if close > top
f_delete_box(be_bb_boxes)
else if close > bottom
alert("Price in the BE-BB zone")
else
box.set_right(bear_bb, bar_index + 10)
for bull_bb in bu_bb_boxes
bottom = box.get_bottom(bull_bb)
top = box.get_top(bull_bb)
if close < bottom
f_delete_box(bu_bb_boxes)
else if close < top
alert("Price in the BU-BB zone")
else
box.set_right(bull_bb, bar_index + 10)
alertcondition(ta.change(market) != 0, "MSB", "MSB")
enableAutoTrend = input(true, "Enable Auto Trendlines", group="AUTO TRENDLINES SETTINGS")
srcTrendChannel = input(close, "Trend channel source", group="AUTO TRENDLINES SETTINGS")
lenTrendChannel = input.int(50, "Trend channel loopback", 2, group="AUTO TRENDLINES SETTINGS")
a = ta.wma(srcTrendChannel, lenTrendChannel), b = ta.sma(srcTrendChannel, lenTrendChannel)
A = 4 * b - 3 * a, B = 3 * a - 2 * b
m = (A - B) / (lenTrendChannel - 1)
d = 0., for i = 0 to lenTrendChannel - 1 by 1
l = B + m * i
d += math.pow(srcTrendChannel - l, 2)
rmse = math.sqrt(d / (lenTrendChannel - 1)) * 2
l(css, k) =>
line lr = enableAutoTrend ? line.new(bar_index - lenTrendChannel + 1, A + k, bar_index, B + k, extend=extend.right, color=css) : na
line.delete(lr )
l(#808080, rmse), l(#808080, 0), l(#808080,-rmse)
// ==========================================================================================
// === Dashboard with Telegram Link ===
var table myTable = table.new(position.top_center, 1, 1, border_width=1, frame_color=color.black, bgcolor=color.white)
table.cell(myTable, 0, 0, "", bgcolor=color.blue, text_color=color.white, text_size=size.normal)
INDIBOT ABO SALTAN
//@version=5
indicator("INDIBOT", shorttitle = "INDIBOT", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500, max_bars_back = 500, max_polylines_count = 100)
//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BOS = 0
s_CHoCH = 1
i_BOS = 2
i_CHoCH = 3
i_pp_CHoCH = 4
green_candle = 5
red_candle = 6
s_CHoCHP = 7
i_CHoCHP = 8
boolean =
array.from(
false
, false
, false
, false
, false
, false
, false
, false
, false
)
//-----------------------------------------------------------------------------{
// User inputs
//-----------------------------------------------------------------------------{
show_swing_ms = input.string ("All" , "Swing " , inline = "1", group = "MARKET STRUCTURE" , options = )
show_internal_ms = input.string ("All" , "Internal " , inline = "2", group = "MARKET STRUCTURE" , options = )
internal_r_lookback = input.int (5 , "" , inline = "2", group = "MARKET STRUCTURE" , minval = 2)
swing_r_lookback = input.int (50 , "" , inline = "1", group = "MARKET STRUCTURE" , minval = 2)
ms_mode = input.string ("Manual" , "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE" , tooltip = " Use selected lenght Use automatic lenght" ,options = )
show_mtf_str = input.bool (true , "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE" , tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green = Bullish. Red = Bearish")
show_eql = input.bool (false , "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE")
plotcandle_bool = input.bool (false , "Plotcandle" , inline = "3", group = "MARKET STRUCTURE" , tooltip = "Displays a cleaner colored candlestick chart in place of the default candles. (requires hiding the current ticker candles)")
barcolor_bool = input.bool (false , "Bar Color" , inline = "4", group = "MARKET STRUCTURE" , tooltip = "Color the candle bodies according to market strucutre trend")
i_ms_up_BOS = input.color (#089981 , "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BOS = input.color (#f23645 , "" , inline = "2", group = "MARKET STRUCTURE")
s_ms_up_BOS = input.color (#089981 , "" , inline = "1", group = "MARKET STRUCTURE")
s_ms_dn_BOS = input.color (#f23645 , "" , inline = "1", group = "MARKET STRUCTURE")
lvl_daily = input.bool (false , "Day " , inline = "1", group = "HIGHS & LOWS MTF")
lvl_weekly = input.bool (false , "Week " , inline = "2", group = "HIGHS & LOWS MTF")
lvl_monthly = input.bool (false , "Month" , inline = "3", group = "HIGHS & LOWS MTF")
lvl_yearly = input.bool (false , "Year " , inline = "4", group = "HIGHS & LOWS MTF")
css_d = input.color (color.blue , "" , inline = "1", group = "HIGHS & LOWS MTF")
css_w = input.color (color.blue , "" , inline = "2", group = "HIGHS & LOWS MTF")
css_m = input.color (color.blue , "" , inline = "3", group = "HIGHS & LOWS MTF")
css_y = input.color (color.blue , "" , inline = "4", group = "HIGHS & LOWS MTF")
s_d = input.string ('⎯⎯⎯' , '' , inline = '1', group = 'HIGHS & LOWS MTF' , options = )
s_w = input.string ('⎯⎯⎯' , '' , inline = '2', group = 'HIGHS & LOWS MTF' , options = )
s_m = input.string ('⎯⎯⎯' , '' , inline = '3', group = 'HIGHS & LOWS MTF' , options = )
s_y = input.string ('⎯⎯⎯' , '' , inline = '4', group = 'HIGHS & LOWS MTF' , options = )
ob_show = input.bool (true , "Show Last " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volumetric order blocks on the chart Ammount of volumetric order blocks to show")
ob_num = input.int (5 , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Orderblocks number", minval = 1, maxval = 10)
ob_metrics_show = input.bool (true , "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volume metrics that have formed the orderblock")
css_metric_up = input.color (color.new(#089981, 50) , " " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 50) , "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
ob_swings = input.bool (false , "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display swing volumetric order blocks")
css_swing_up = input.color (color.new(color.gray , 90) , " " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
css_swing_dn = input.color (color.new(color.silver, 90) , "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
ob_filter = input.string ("None" , "Filtering " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options = )
ob_mitigation = input.string ("Absolute" , "Mitigation " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Trigger to remove volumetric order blocks", options = )
ob_pos = input.string ("Precise" , "Positioning " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Position of the Order Block Cover the whole candle Cover half candle Adjust to volatility Same as Accurate but more precise", options = )
use_grayscale = input.bool (false , "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Use gray as basic order blocks color")
use_show_metric = input.bool (true , "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show volume associated with the orderblock and his relevance")
use_middle_line = input.bool (true , "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true , "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Hide overlapping order blocks")
use_overlap_method = input.string ("Previous" , "Overlap Method " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = " Preserve the most recent volumetric order blocks Preserve the previous volumetric order blocks", options = )
ob_bull_css = input.color (color.new(#089981 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
ob_bear_css = input.color (color.new(#f23645 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
show_acc_dist_zone = input.bool (false , "" , inline = "1", group = "Accumulation And Distribution")
zone_mode = input.string ("Fast" , "" , inline = "1", group = "Accumulation And Distribution" , tooltip = " Find small zone pattern formation Find bigger zone pattern formation" ,options = )
acc_css = input.color (color.new(#089981 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
dist_css = input.color (color.new(#f23645 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
show_lbl = input.bool (true , "Show swing point" , inline = "1", group = "High and Low" , tooltip = "Display swing point")
show_mtb = input.bool (true , "Show High/Low/Equilibrium" , inline = "2", group = "High and Low" , tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.red , "Premium Zone " , inline = "3", group = "High and Low")
midlvl = input.color (color.gray , "Equilibrium Zone" , inline = "4", group = "High and Low")
btmlvl = input.color (#089981 , "Discount Zone " , inline = "5", group = "High and Low")
fvg_enable = input.bool (false , " " , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap")
what_fvg = input.string ("FVG" , "" , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap", options = )
fvg_num = input.int (5 , "Show Last " , inline = "1a", group = "FAIR VALUE GAP" , tooltip = "Number of fvg to show")
fvg_upcss = input.color (color.new(#089981, 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_dncss = input.color (color.new(color.red , 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_extend = input.int (10 , "Extend FVG" , inline = "2", group = "FAIR VALUE GAP" , tooltip = "Extend the display of the FVG.")
fvg_src = input.string ("Close" , "Mitigation " , inline = "3", group = "FAIR VALUE GAP" , tooltip = " Use the close of the body as trigger Use the extreme point of the body as trigger", options = )
fvg_tf = input.timeframe ("" , "Timeframe " , inline = "4", group = "FAIR VALUE GAP" , tooltip = "Timeframe of the fair value gap")
t = color.t (ob_bull_css)
invcol = color.new (color.white , 100)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - UDT }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
type bar
float o = open
float c = close
float h = high
float l = low
float v = volume
int n = bar_index
int t = time
type Zphl
line top
line bottom
label top_label
label bottom_label
bool stopcross
bool sbottomcross
bool itopcross
bool ibottomcross
string txtup
string txtdn
float topy
float bottomy
float topx
float bottomx
float tup
float tdn
int tupx
int tdnx
float itopy
float itopx
float ibottomy
float ibottomx
float uV
float dV
type FVG
box box
line ln
bool bull
float top
float btm
int left
int right
type ms
float p
int n
float l
type msDraw
int n
float p
color css
string txt
bool bull
type obC
float top
float btm
int left
float avg
float dV
float cV
int wM
int blVP
int brVP
int dir
float h
float l
int n
type obD
box ob
box eOB
box blB
box brB
line mL
type zone
chart.point points
float p
int c
int t
type hqlzone
box pbx
box ebx
box lbx
label plb
label elb
label lbl
type ehl
float pt
int t
float pb
int b
type pattern
string found = "None"
bool isfound = false
int period = 0
bool bull = false
type alerts
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool equal = false
bool ob = false
bool swingob = false
bool zone = false
bool fvg = false
bool obtouch = false
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - General Setup }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
bar b = bar.new()
var pattern p = pattern.new()
alerts blalert = alerts.new()
alerts bralert = alerts.new()
if p.isfound
p.period += 1
if p.period == 50
p.period := 0
p.found := "None"
p.isfound := false
p.bull := na
switch
b.c > b.o => boolean.set(green_candle, true)
b.c < b.o => boolean.set(red_candle , true)
f_zscore(src, lookback) =>
(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)
var int iLen = internal_r_lookback
var int sLen = swing_r_lookback
vv = f_zscore(((close - close ) / close ) * 100,iLen)
if ms_mode == "Dynamic"
switch
vv >= 1.5 or vv <= -1.5 => iLen := 10
vv >= 1.6 or vv <= -1.6 => iLen := 9
vv >= 1.7 or vv <= -1.7 => iLen := 8
vv >= 1.8 or vv <= -1.8 => iLen := 7
vv >= 1.9 or vv <= -1.9 => iLen := 6
vv >= 2.0 or vv <= -2.0 => iLen := 5
=> iLen
var msline = array.new(0)
iH = ta.pivothigh(high, iLen, iLen)
sH = ta.pivothigh(high, sLen, sLen)
iL = ta.pivotlow (low , iLen, iLen)
sL = ta.pivotlow (low , sLen, sLen)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - ARRAYS }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
hl () =>
= request.security(syminfo.tickerid , 'D' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'W' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'M' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , '12M', hl() , lookahead = barmerge.lookahead_on)
lstyle(style) =>
out = switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
'····' => line.style_dotted
mtfphl(h, l ,tf ,css, pdhl_style) =>
var line hl = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var line ll = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var label lbl = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}L', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
var label hlb = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}H', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
hy = ta.valuewhen(h != h , h , 1)
hx = ta.valuewhen(h == high , time , 1)
ly = ta.valuewhen(l != l , l , 1)
lx = ta.valuewhen(l == low , time , 1)
if barstate.islast
extension = time + (time - time ) * 50
line.set_xy1(hl , hx , hy)
line.set_xy2(hl , extension , hy)
label.set_xy(hlb, extension , hy)
line.set_xy1(ll , lx , ly)
line.set_xy2(ll , extension , ly)
label.set_xy(lbl, extension , ly)
if lvl_daily
mtfphl(pdh , pdl , 'D' , css_d, s_d)
if lvl_weekly
mtfphl(pwh , pwl , 'W' , css_w, s_w)
if lvl_monthly
mtfphl(pmh , pml, 'M' , css_m, s_m)
if lvl_yearly
mtfphl(pyh , pyl , '12M', css_y, s_y)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Market Structure }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method darkcss(color css, float factor, bool bull) =>
blue = color.b(css) * (1 - factor)
red = color.r(css) * (1 - factor)
green = color.g(css) * (1 - factor)
color.rgb(red, green, blue, 0)
method f_line(msDraw d, size, style) =>
var line id = na
var label lbl = na
id := line.new(
d.n
, d.p
, b.n
, d.p
, color = d.css
, width = 1
, style = style
)
if msline.size() >= 250
line.delete(msline.shift())
msline.push(id)
lbl := label.new(
int(math.avg(d.n, b.n))
, d.p
, d.txt
, color = invcol
, textcolor = d.css
, style = d.bull ? label.style_label_down : label.style_label_up
, size = size
, text_font_family = font.family_monospace
)
structure(bool mtf) =>
msDraw drw = na
bool isdrw = false
bool isdrwS = false
var color css = na
var color icss = na
var int itrend = 0
var int trend = 0
bool bull_ob = false
bool bear_ob = false
bool s_bull_ob = false
bool s_bear_ob = false
n = bar_index
var ms up = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms dn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sup = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sdn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
switch show_swing_ms
"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, true )
"CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, false )
"CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, true )
"BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
=> na
switch show_internal_ms
"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, true )
"CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, false)
"CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, true )
"BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
=> na
switch
iH =>
up.p.unshift(b.h )
up.l.unshift(b.h )
up.n.unshift(n )
iL =>
dn.p.unshift(b.l )
dn.l.unshift(b.l )
dn.n.unshift(n )
sL =>
sdn.p.unshift(b.l )
sdn.l.unshift(b.l )
sdn.n.unshift(n )
sH =>
sup.p.unshift(b.h )
sup.l.unshift(b.h )
sup.n.unshift(n )
// INTERNAL BULLISH STRUCTURE
if up.p.size() > 0 and dn.l.size() > 1
if ta.crossover(b.c, up.p.first())
bool CHoCH = na
string txt = na
if itrend < 0
CHoCH := true
switch
not CHoCH =>
txt := "BOS"
css := i_ms_up_BOS
blalert.bos := true
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS
, txt
, true
)
CHoCH =>
dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch
txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_up_BOS.darkcss(0.25, true)
if (dn.l.first() > dn.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => bull_ob := true
ob_filter == "BOS" and txt == "BOS" => bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bull_ob := true
itrend := 1
up.n.clear()
up.p.clear()
// INTERNAL BEARISH STRUCTURE
if dn.p.size() > 0 and up.l.size() > 1
if ta.crossunder(b.c, dn.p.first())
bool CHoCH = na
string txt = na
if itrend > 0
CHoCH := true
switch
not CHoCH =>
bralert.bos := true
txt := "BOS"
css := i_ms_dn_BOS
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS
, txt
, false
)
CHoCH =>
if up.l.first() < up.l.get(1)
bralert.chochplus := true
else
bralert.choch := true
txt := up.l.first() < up.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_dn_BOS.darkcss(0.25, false)
if (up.l.first() < up.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => bear_ob := true
ob_filter == "BOS" and txt == "BOS" => bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bear_ob := true
itrend := -1
dn.n.clear()
dn.p.clear()
// SWING BULLISH STRUCTURE
if sup.p.size() > 0 and sdn.l.size() > 1
if ta.crossover(b.c, sup.p.first())
bool CHoCH = na
string txt = na
if trend < 0
CHoCH := true
switch
not CHoCH =>
blalert.swingbos := true
txt := "BOS"
icss := s_ms_up_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS
, txt
, true
)
CHoCH =>
if sdn.l.first() > sdn.l.get(1)
blalert.chochplusswing := true
else
blalert.chochswing := true
txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_up_BOS.darkcss(0.25, true)
if (sdn.l.first() > sdn.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => s_bull_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bull_ob := true
trend := 1
sup.n.clear()
sup.p.clear()
// SWING BEARISH STRUCTURE
if sdn.p.size() > 0 and sup.l.size() > 1
if ta.crossunder(b.c, sdn.p.first())
bool CHoCH = na
string txt = na
if trend > 0
CHoCH := true
switch
not CHoCH =>
bralert.swingbos := true
txt := "BOS"
icss := s_ms_dn_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS
, txt
, false
)
CHoCH =>
if sup.l.first() < sup.l.get(1)
bralert.chochplusswing := true
else
bralert.chochswing := true
txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_dn_BOS.darkcss(0.25, false)
if (sup.l.first() < sup.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => s_bear_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bear_ob := true
trend := -1
sdn.n.clear()
sdn.p.clear()
= structure(false)
if isdrw
f_line(drw, size.small, line.style_dashed)
if isdrwS
f_line(drw, size.small, line.style_solid)
= request.security("", "15" , structure(true))
= request.security("", "60" , structure(true))
= request.security("", "240" , structure(true))
= request.security("", "1440" , structure(true))
if show_mtf_str
var tab = table.new(position = position.top_right, columns = 10, rows = 10, bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color = color.rgb(54, 58, 69, 100), border_width = 1)
table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 5, text = "Detected Pattern", text_halign = text.align_center, text_size = size.normal, text_color = color.silver, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center, text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ? i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25, false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.merge_cells(tab, 0, 5, 1, 5)
table.merge_cells(tab, 0, 6, 1, 6)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Strong/Weak High/Low And Equilibrium }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
var phl = Zphl.new(
na
, na
, label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style = label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style = label.style_label_up , size = size.tiny , text = "")
, true
, true
, true
, true
, ""
, ""
, 0
, 0
, 0
, 0
, high
, low
, 0
, 0
, 0
, 0
, 0
, 0
, na
, na
)
zhl(len)=>
upper = ta.highest(len)
lower = ta.lowest(len)
var float out = 0
out := b.h > upper ? 0 : b.l < lower ? 1 : out
top = out == 0 and out != 0 ? b.h : 0
btm = out == 1 and out != 1 ? b.l : 0
= zhl(sLen)
= zhl(iLen)
upphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
if top
phl.stopcross := true
phl.txtup := top > phl.topy ? "HH" : "HL"
if show_lbl
topl = label.new(
b.n - swing_r_lookback
, top
, phl.txtup
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
line.delete(phl.top )
phl.top := line.new(
b.n - sLen
, top
, b.n
, top
, color = toplvl)
phl.topy := top
phl.topx := b.n - sLen
phl.tup := top
phl.tupx := b.n - sLen
if itop
phl.itopcross := true
phl.itopy := itop
phl.itopx := b.n - iLen
phl.tup := math.max(high, phl.tup)
phl.tupx := phl.tup == high ? b.n : phl.tupx
phl.uV := phl.tup != phl.tup ? b.v : phl.uV
if barstate.islast
line.set_xy1(
phl.top
, phl.tupx
, phl.tup
)
line.set_xy2(
phl.top
, b.n + 50
, phl.tup
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tup
)
dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend < 0
? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
dnphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
if btm
phl.sbottomcross := true
phl.txtdn := btm > phl.bottomy ? "LH" : "LL"
if show_lbl
btml = label.new(
b.n - swing_r_lookback
, btm, phl.txtdn
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
line.delete(phl.bottom )
phl.bottom := line.new(
b.n - sLen
, btm
, b.n
, btm
, color = btmlvl
)
phl.bottomy := btm
phl.bottomx := b.n - sLen
phl.tdn := btm
phl.tdnx := b.n - sLen
if ibtm
phl.ibottomcross := true
phl.ibottomy := ibtm
phl.ibottomx := b.n - iLen
phl.tdn := math.min(low, phl.tdn)
phl.tdnx := phl.tdn == low ? b.n : phl.tdnx
phl.dV := phl.tdn != phl.tdn ? b.v : phl.dV
if barstate.islast
line.set_xy1(
phl.bottom
, phl.tdnx
, phl.tdn
)
line.set_xy2(
phl.bottom
, b.n + 50
, phl.tdn
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tdn
)
dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend > 0
? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
midphl() =>
avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2())
var line l = line.new(
y1 = avg
, y2 = avg
, x1 = b.n - sLen
, x2 = b.n + 50
, color = midlvl
, style = line.style_solid
)
var label lbl = label.new(
x = b.n + 50
, y = avg
, text = "Equilibrium"
, style = label.style_label_left
, color = invcol
, textcolor = midlvl
, size = size.small
)
if barstate.islast
more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() + phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1()
line.set_xy1(l , more , avg)
line.set_xy2(l , b.n + 50, avg)
label.set_x (lbl , b.n + 50 )
label.set_y (lbl , avg )
dist = math.abs((l.get_y2() - close) / close) * 100
label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) + "%)")
hqlzone() =>
if barstate.islast
var hqlzone dZone = hqlzone.new(
box.new(
na
, na
, na
, na
, bgcolor = color.new(toplvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(midlvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(btmlvl, 70)
, border_color = na
)
, label.new(na, na, text = "Premium" , color = invcol, textcolor = toplvl, style = label.style_label_down, size = size.small)
, label.new(na, na, text = "Equilibrium", color = invcol, textcolor = midlvl, style = label.style_label_left, size = size.small)
, label.new(na, na, text = "Discount" , color = invcol, textcolor = btmlvl, style = label.style_label_up , size = size.small)
)
dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)) , phl.tup)
dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup + 0.05 * phl.tdn)
dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup + 0.475 * phl.tdn)
dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn + 0.475 * phl.tup)
dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn + 0.05 * phl.tup)
dZone.lbx.set_rightbottom(b.n + 50 , phl.tdn)
dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tup)
dZone.elb.set_xy( int(b.n + 50) , math.avg(phl.tup, phl.tdn))
dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tdn)
if show_mtb
upphl (trend)
dnphl (trend)
hqlzone()
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Volumetric Order Block }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method eB(box b, bool ext, color css, bool swing) =>
b.unshift(
box.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, text_font_family = font.family_monospace
, extend = ext ? extend.right : extend.none
, border_color = swing ? color.new(css, 0) : color.new(color.white,100)
, bgcolor = css
, border_width = 1
)
)
method eL(line l, bool ext, bool solid, color css) =>
l.unshift(
line.new(
na
, na
, na
, na
, width = 1
, color = css
, xloc = xloc.bar_time
, extend = ext ? extend.right : extend.none
, style = solid ? line.style_solid : line.style_dashed
)
)
method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) =>
= request.security(
syminfo.tickerid
, ""
,
, lookahead = barmerge.lookahead_off
)
var obC obj = obC.new(
array.new()
, array.new()
, array.new< int >()
, array.new()
, array.new()
, array.new()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new()
, array.new()
, array.new< int >()
)
var obD draw = obD.new(
array.new()
, array.new()
, array.new()
, array.new()
, array.new()
)
if barstate.isfirst
for i = 0 to ob_num - 1
draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) : color.new(css,0))
draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css, swing)
draw.blB.eB(false, css_metric_up , swing)
draw.brB.eB(false, css_metric_dn , swing)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css, swing)
float pos = ob_pos == "Full"
? (bull ? high : low)
: ob_pos == "Middle"
? ohlc4
: ob_pos == "Accurate"
? hl2
: hl2
if cdn
obj.h.clear()
obj.l.clear()
obj.n.clear()
for i = 0 to math.abs((loc - b.n)) - 1
obj.h.push(hH )
obj.l.push(lL )
obj.n.push(b.t )
// obj.h.reverse()
// obj.l.reverse()
int iU = obj.l.indexof(obj.l.min()) + 1
int iD = obj.h.indexof(obj.h.max()) + 1
obj.dir.unshift(
bull
? (b.c > b.o ? 1 : -1)
: (b.c > b.o ? 1 : -1)
)
obj.top.unshift(
bull
? pos
: obj.h.max()
)
obj.btm.unshift(
bull
? obj.l.min()
: pos
)
obj.left.unshift(
bull
? obj.n.get(obj.l.indexof(obj.l.min()))
: obj.n.get(obj.h.indexof(obj.h.max()))
)
obj.avg.unshift(
math.avg(obj.top.first(), obj.btm.first())
)
obj.cV.unshift(
bull
? b.v
: b.v
)
if ob_pos == "Precise"
switch bull
true =>
if obj.avg.get(0) < (b.c < b.o ? b.c : b.o ) and obj.top.get(0) > hlcc4
obj.top.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
false =>
if obj.avg.get(0) > (b.c < b.o ? b.o : b.c ) and obj.btm.get(0) < hlcc4
obj.btm.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
obj.blVP.unshift ( 0 )
obj.brVP.unshift ( 0 )
obj.wM .unshift ( 1 )
if use_overlap
int rmP = use_overlap_method == "Recent" ? 1 : 0
if obj.avg.size() > 1
if bull
? obj.btm.first() < obj.top.get(1)
: obj.top.first() > obj.btm.get(1)
obj.wM .remove(rmP)
obj.cV .remove(rmP)
obj.dir .remove(rmP)
obj.top .remove(rmP)
obj.avg .remove(rmP)
obj.btm .remove(rmP)
obj.left .remove(rmP)
obj.blVP .remove(rmP)
obj.brVP .remove(rmP)
if barstate.isconfirmed
for x = 0 to ob_num - 1
tg = switch ob_mitigation
"Middle" => obj.avg
"Absolute" => bull ? obj.btm : obj.top
for in tg
if (bull ? cC < pt : cC > pt)
obj.wM .remove(idx)
obj.cV .remove(idx)
obj.dir .remove(idx)
obj.top .remove(idx)
obj.avg .remove(idx)
obj.btm .remove(idx)
obj.left .remove(idx)
obj.blVP .remove(idx)
obj.brVP .remove(idx)
if barstate.islast
if obj.avg.size() > 0
// Alert
if bull
? ta.crossunder(low , obj.top.get(0))
: ta.crossover (high, obj.btm.get(0))
switch bull
true => blalert.obtouch := true
false => bralert.obtouch := true
float tV = 0
obj.dV.clear()
seq = math.min(ob_num - 1, obj.avg.size() - 1)
for j = 0 to seq
tV += obj.cV.get(j)
if j == seq
for y = 0 to seq
obj.dV.unshift(
math.floor(
(obj.cV.get(y) / tV) * 100)
)
obj.dV.reverse()
for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1)
dmL = draw.mL .get(i)
dOB = draw.ob .get(i)
dblB = draw.blB.get(i)
dbrB = draw.brB.get(i)
deOB = draw.eOB.get(i)
dOB.set_lefttop (obj.left .get(i) , obj.top.get(i))
deOB.set_lefttop (b.t , obj.top.get(i))
dOB.set_rightbottom (b.t , obj.btm.get(i))
deOB.set_rightbottom(b.t + (b.t - b.t ) * 100 , obj.btm.get(i))
if use_middle_line
dmL.set_xy1(obj.left.get(i), obj.avg.get(i))
dmL.set_xy2(b.t , obj.avg.get(i))
if ob_metrics_show
dblB.set_lefttop (obj.left.get(i), obj.top.get(i))
dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i))
dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i))
dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i))
rpBL = dblB.get_right()
rpBR = dbrB.get_right()
dbrB.set_right(rpBR + (b.t - b.t ) * obj.brVP.get(i))
dblB.set_right(rpBL + (b.t - b.t ) * obj.blVP.get(i))
if use_show_metric
txt = switch
obj.cV.get(i) >= 1000000000 => str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B"
obj.cV.get(i) >= 1000000 => str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M"
obj.cV.get(i) >= 1000 => str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K"
obj.cV.get(i) < 1000 => str.tostring(math.round(obj.cV.get(i)))
deOB.set_text(
str.tostring(
txt + " (" + str.tostring(obj.dV.get(i)) + "%)")
)
deOB.set_text_size (size.auto)
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.silver : color.new(css, 0))
if ob_metrics_show and barstate.isconfirmed
if obj.wM.size() > 0
for i = 0 to obj.avg.size() - 1
switch obj.dir.get(i)
1 =>
switch obj.wM.get(i)
1 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 1)
-1 =>
switch obj.wM.get(i)
1 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 1)
var hN = array.new(1, b.n)
var lN = array.new(1, b.n)
var hS = array.new(1, b.n)
var lS = array.new(1, b.n)
if iH
hN.pop()
hN.unshift(int(b.n ))
if iL
lN.pop()
lN.unshift(int(b.n ))
if sH
hS.pop()
hS.unshift(int(b.n ))
if sL
lS.pop()
lS.unshift(int(b.n ))
if ob_show
bull_ob.drawVOB(true , ob_bull_css, hN.first(), false)
bear_ob.drawVOB(false, ob_bear_css, lN.first(), false)
if ob_swings
s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true)
s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true)
if bull_ob
blalert.ob := true
if bear_ob
bralert.ob := true
if s_bull_ob
blalert.swingob := true
if s_bear_ob
blalert.swingob := true
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - FVG | VI | OG }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
ghl() => request.security(syminfo.tickerid, fvg_tf, [high , low , close , open ])
tfG() => request.security(syminfo.tickerid, fvg_tf, )
cG(bool bull) =>
= ghl()
= tfG()
var FVG draw = FVG.new(
array.new()
, array.new()
)
var FVG cords = array.new()
float pup = na
float pdn = na
bool cdn = na
int pos = 2
cc = timeframe.change(fvg_tf)
if barstate.isfirst
for i = 0 to fvg_num - 1
draw.box.unshift(box.new (na, na, na, na, border_color = color.new(color.white, 100), xloc = xloc.bar_time))
draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width = 1, style = line.style_solid))
switch what_fvg
"FVG" =>
pup := bull ? gl : l
pdn := bull ? h : gh
cdn := bull ? gl > h and cc : gh < l and cc
pos := 2
"VI" =>
pup := bull
? (gc > go
? go
: gc)
: (gc > go
? go
: gc )
pdn := bull
? (gc > go
? gc
: go )
: (gc > go
? gc
: go)
cdn := bull
? go > gc and gh > gl and gc > gc and go > go and gh < math.min(gc, go) and cc
: go < gc and gl < gh and gc < gc and go < go and gl > math.max(gc, go) and cc
pos := 1
"OG" =>
pup := bull ? b.l : gl
pdn := bull ? gh : gh
cdn := bull ? gl > gh and cc : gh < gl and cc
pos := 1
if not na(cdn ) and cdn
cords.unshift(
FVG.new(
na
, na
, bull
? true
OSTDV SeppeMILLIONAIRE CHEAT CODE, time based stdv levels works best on gold. Pre determined pivots.
Fixed Zone Flow ABO SALTAN (Non-Repaint)//@version=5
indicator("Fixed Zone Flow (Non-Repaint)", overlay=false)
// ===== INPUTS =====
lenFast = input.int(10, "Fast Length")
lenSlow = input.int(21, "Slow Length")
signal = input.int(4, "Signal Smooth")
buyLevel = input.int(-60, "BUY Level (Fixed)")
sellLevel = input.int(60, "SELL Level (Fixed)")
// ===== CORE =====
price = hlc3
basis = ta.ema(price, lenFast)
dev = ta.ema(math.abs(price - basis), lenFast)
ci = (price - basis) / (0.015 * dev)
fzf = ta.ema(ci, lenSlow)
sig = ta.sma(fzf, signal)
// ===== FIXED BUY / SELL =====
fixedBuy = ta.crossover(fzf, buyLevel)
fixedSell = ta.crossunder(fzf, sellLevel)
// ===== PLOTS =====
plot(fzf, title="FZF", color=color.aqua, linewidth=2)
plot(sig, title="Signal", color=color.orange)
hline(buyLevel, "FIXED BUY", color=color.green, linestyle=hline.style_dashed)
hline(sellLevel, "FIXED SELL", color=color.red, linestyle=hline.style_dashed)
hline(0, "Zero", color=color.gray)
// ===== SIGNAL MARKERS =====
plotshape(fixedBuy, title="BUY",
style=shape.labelup,
location=location.bottom,
color=color.lime,
text="BUY",
textcolor=color.black)
plotshape(fixedSell, title="SELL",
style=shape.labeldown,
location=location.top,
color=color.red,
text="SELL",
textcolor=color.white)
Ryan-Trend PulseOverview
Ryan-Trend Pulse is a volatility-adjusted trend-following indicator designed to identify institutional-grade shifts in market momentum. Unlike static moving averages that lag significantly, This indicator utilizes a modified ATR-based trailing logic to create dynamic ranges. This allows the indicator to remain stable during consolidation but react decisively when a genuine trend breakout occurs.
The core philosophy of this tool is to provide traders with clear, visual "Zones of Interest" (Target and Stoploss) that adapt in real-time to current market volatility.
How It Works: The Logic
The indicator is built around a proprietary Adaptive Average function. Here is the technical breakdown:
1. Volatility Anchoring : The script calculates a base ATR (Average True Range) multiplied by a user-defined factor. This creates a "volatility buffer" around the price.
2. Range Displacement : The center line (Trend Average) only moves when the price closes outside of the volatility buffer. This filtering mechanism eliminates market noise and "whipsaws" often found in standard trend-following tools.
3. Dynamic Band Scaling : Once a new range is established, the upper and lower bands are calculated based on 50% of the current volatility. This provides a mathematically consistent frame for potential price action.
Indicator Specifications & Features
- Zero-Lag Range Shifts: The range updates instantly upon a confirmed break, providing the trader with immediate feedback on trend direction.
- Multi-Timeframe Compatible: Users can pull data from higher timeframes (HTF) to filter lower timeframe noise via the built-in Timeframe input.
How to Trade with Ryan-Trend Pulse
The indicator features a Dual-State Dynamic Coloring System:
1. 🔵 The Blue Center channel: This is your Trend Pivot. As long as price remains within the current range, the trend is considered stable.
2. 🟢 Bullish Breakout (Long): When price breaks the upper channel and shifts the range upward:
- The Upper channel turns Green, representing your primary Target Zone.
- The Lower channel turns Red, representing your Logical Stop Loss.
3. 🔴 Bearish Breakout (Short) : When price breaks the lower channel and shifts the range downward:
- The Lower channel turns Green, representing your primary Target Zone.
- The Upper channel turns Red, representing your Logical Stop Loss.
Settings Guidance
- Length (Default 200): Optimized for long-term trend health. Lowering this to 50-100 will make the indicator more aggressive for scalping.
- Factor (Default 5.0): This controls the "tightness" of the range. A higher factor requires a more significant move to trigger a trend change, suitable for volatile assets like Crypto or Indices.
Disclaimer: Past performance does not guarantee future results. This indicator is a tool for technical analysis and should be used in conjunction with a complete trading plan and proper risk management.
MACD Extreme [CoinTadpole]█ MACD Extreme - TradingView Script Description
═══════════════════════════════════════════════════════════════════════════════
MACD Extreme is an advanced MACD-based indicator that detects potential trend reversal points by measuring the divergence gap between MACD line (K) and Signal line (D). Instead of relying on traditional crossover signals, this indicator identifies when the gap expands to extreme levels - a more reliable precursor to actual trend reversals.
█ THE PROBLEM WITH TRADITIONAL MACD
Many traders believe that trend reversals occur the moment:
• MACD line crosses ABOVE Signal line (Golden Cross = Buy)
• MACD line crosses BELOW Signal line (Dead Cross = Sell)
This is a dangerous misconception.
In real trading, crossovers are LAGGING signals. By the time a Golden Cross appears, the upward move has often already happened. Entering at that exact moment frequently results in buying at local tops or selling at local bottoms - leading to significant losses.
As shown above, entering long positions at Golden Cross points often results in immediate drawdowns and extended periods of being underwater.
█ HOW THIS INDICATOR WORKS
This indicator takes a completely different approach. Instead of waiting for crossovers, it monitors the GAP between K line and D line (the histogram).
The core principle:
**Trend reversals tend to occur when the K-D divergence expands significantly beyond normal levels.**
The algorithm measures:
• Current histogram value (K line - D line)
• Historical standard deviation of the histogram over N periods
• Identifies when current divergence exceeds the threshold
When the divergence reaches extreme levels AND shows signs of reversal, the indicator generates a signal - often BEFORE the traditional crossover occurs.
█ THE SIGNALS
🟢 Green Signal (Bullish)
Appears when:
• Histogram is in negative territory (K below D)
• Divergence has reached extreme levels
• Histogram begins turning upward
This signals potential bullish reversal - the selling pressure may be exhausting.
🔴 Red Signal (Bearish)
Appears when:
• Histogram is in positive territory (K above D)
• Divergence has reached extreme levels
• Histogram begins turning downward
This signals potential bearish reversal - the buying pressure may be exhausting.
█ BACKGROUND ZONES
The colored background bars provide additional context:
🟩 Green Background Zone
Indicates oversold divergence territory. When you see green background, the K-D gap has expanded significantly in the bearish direction. This zone often precedes bullish reversals.
🟥 Red Background Zone
Indicates overbought divergence territory. When you see red background, the K-D gap has expanded significantly in the bullish direction. This zone often precedes bearish reversals.
These zones help you visually identify WHEN the market is in extreme conditions - preparing you for potential reversals before they happen.
█ WHY THIS APPROACH IS MORE RELIABLE
Traditional MACD analysis requires you to:
1. Constantly monitor the K and D lines
2. Mentally estimate whether the gap is "large" or "small"
3. Make subjective judgments in real-time
This is practically impossible during live trading.
MACD Extreme solves this by:
• Automatically calculating historical divergence patterns
• Objectively identifying when divergence is truly "extreme"
• Alerting you at precisely the right moments
Just like how UCTRPB Rsi Price Band pre-calculates where RSI oversold/overbought levels will be, this indicator pre-identifies where MACD divergence reaches extreme levels.
█ SETTINGS EXPLAINED
📊 MACD Settings
• Fast EMA (Default: 7): Short-term EMA period
• Slow EMA (Default: 25): Long-term EMA period
• Signal EMA (Default: 9): Signal line smoothing period
🔥 Signal Detection
• Lookback Period (Default: 50): Number of bars to calculate divergence baseline. Higher values = compare against longer-term averages. Recommended: 30-80
• Sensitivity (Default: 2.0): Standard deviation multiplier for signal threshold
- Lower (1.5): More signals, earlier detection, but more false positives
- Default (2.0): Balanced - recommended for most users
- Higher (2.5+): Fewer signals, only extreme cases, fewer false positives
• Use Percentile Detection: Alternative detection method
- OFF (Default): Uses standard deviation-based detection
- ON: Uses percentile-based detection (signals when divergence is in top X%)
• Percentile Threshold (Default: 95%): When percentile detection is enabled, signals trigger when divergence is in the top X% of historical values
█ RECOMMENDED SETTINGS BY STYLE
Conservative Trading:
• Lookback: 50-80
• Sensitivity: 2.0-2.5
• Fewer signals, higher reliability
Aggressive Trading:
• Lookback: 30-50
• Sensitivity: 1.5-2.0
• More signals, requires additional confirmation
█ ALERT SETTINGS
Three alert options are available:
📢 Bullish Reversal
Triggers when green signal appears. Use this if you only trade long positions.
📢 Bearish Reversal
Triggers when red signal appears. Use this if you only trade short positions.
📢 Reversal Signal
Triggers on BOTH green and red signals. Use this if you trade both directions - you only need to set up this one alert to catch all signals.
To set up alerts:
1. Right-click on the indicator
2. Select "Add Alert"
3. Choose your preferred condition
4. Configure notification method (popup, email, webhook, etc.)
█ HOW TO USE THIS INDICATOR
⚠️ IMPORTANT: This is NOT a buy/sell signal generator.
This indicator is a REFERENCE TOOL for identifying potential trend reversal zones using K-D divergence analysis.
For best results, combine with:
• RSI Oversold/Overbought levels (RSI < 30 or RSI > 70)
• Support/Resistance levels
• Volume analysis
• Higher timeframe trend direction
Recommended workflow:
1. Wait for signal to appear
2. Check RSI for confirmation (oversold for bullish, overbought for bearish)
3. Identify nearby support/resistance levels
4. Enter with proper risk management
█ TIMEFRAME RECOMMENDATIONS
• Best: 4H and above
• Good: 1H
• Not recommended: 15m and below
Lower timeframes produce more noise and less reliable signals.
█ IMPORTANT NOTES
• Signals indicate potential reversal zones, not guaranteed reversals
• Always use stop-losses and proper position sizing
• Past performance does not guarantee future results
• This indicator works best in ranging and mean-reverting market conditions
• Trending markets may produce early signals - use trend filters for additional confirmation
═══════════════════════════════════════════════════════════════════════════════
═══════════════════════════════════════════════════════════════════════════════
Tags: MACD, divergence, reversal, trend, momentum, oscillator, crossover, signal, alert
Fractal - VA (Dynamic Wicks)This indicator, which we’ve developed as the Frectal - VA (Multi-Timeframe Visual Analytics), is designed for traders who utilize multi-timeframe analysis but want to keep their main chart clean of overlapping candles.
It functions as a Projected Dashboard, pulling price action from a higher timeframe (HTF) and rendering it as a set of dynamic, solid objects in the right-hand margin of your chart.
Core Philosophy
The "Frectal - VA" is built on the principle of Nested Structure. In professional trading, the "Value Area" or the "Fractal" of a higher timeframe often dictates the trend of the lower timeframe. By projecting these candles into the future (the right side of the chart), you can monitor HTF trend shifts, volatility, and candle closes without the HTF candles obscuring your current "live" price action.
Key Components
Decoupled Visualization: Unlike standard MTF indicators that overlay large boxes behind your current bars, this indicator creates a side-by-side comparison in the chart's whitespace.
Real-Time Data Streaming: It doesn't just show historical candles; the "lead" candle in the dashboard updates with every tick of the current price, showing you exactly how the higher timeframe candle is forming.
Dynamic Color Sync: The body, border, and wick of each projected candle are linked. If a 1-hour candle flips from bullish to bearish on a 5-minute chart, the entire dashboard object changes color instantly.
Customizable Offset: You control the "Drop" (Vertical Offset) and the "Margin" (Horizontal Offset). This allows you to tuck the indicator into a corner of your screen as a heads-up display (HUD).
Strategic Use Cases
Trend Confirmation: If you are trading a 1-minute "scalp" but the 15-minute dashboard shows a solid, large-bodied bearish candle, you are alerted to trade with the HTF momentum.
Volatility Monitoring: By observing the size of the wicks in the dashboard, you can see if the higher timeframe is experiencing "rejection" at certain levels, even if your local timeframe looks like a steady trend.
Visual Backtesting: Because it maintains a queue of the last
X
candles, you can see the immediate history of the HTF structure (e.g., a "Morning Star" pattern or "Engulfing" candles) at a glance.
Technical Specifications
Pine Script Version: v6 (latest standard).
Drawing Engine: Uses box and line arrays for high-performance rendering that doesn't lag the UI.
Memory Management: Automatically deletes old objects to stay within TradingView’s script limits, ensuring stability during long trading sessions.
Ed's Swing Ready Ripper (STABLE v3) Ed’s Swing Ready Ripper
Ed’s Swing Ready Ripper is a swing-trading indicator built to identify stocks that are consolidating in a strong daily uptrend and preparing for an upside breakout.
It combines higher-timeframe trend confirmation with precise 4H / 2H entry signals, helping traders enter early while managing risk clearly.
🎯 Best For
Swing trades (days to weeks)
Growth stocks & strong sector leaders
Works best on 4H charts (2H for aggressive traders)
⚙️ How It Works
Daily trend filter confirms bullish structure & consolidation
4H / 2H entry logic looks for EMA20 pullbacks with momentum
BUY signals are labeled:
🟢 FULL – higher confidence setup
🟠 PARTIAL – lower confidence setup
TP1 & TP2 are plotted automatically
TP3 uses EMA20 trailing exit to let winners run
🚨 Built-In Alerts
BUY signal
TP1 hit
TP2 hit
TP3 exit (close below EMA20)
⚠️ Disclaimer
This indicator is for educational purposes only and does not constitute financial advice. Always manage risk and confirm signals with price action.
⭐ Tip
Use the Daily chart for trend direction, then switch to 4H (or 2H) for entries.
COT Index TT Tools Questo indicatore nasce come ispirazione diretta dallo script TradingView “COT Index” di Dixon_Chai 👉
La logica di base rimane quella del COT Index in stile Larry Williams (calcolo dell’indice su più finestre temporali), ma questa versione TT Tools introduce funzionalità operative aggiuntive pensate per una lettura immediata del posizionamento dei Commercials e per individuare con precisione i cambi di regime delle Net Position.
🔹 Cosa aggiunge questa versione (TT Tools)
✅ Riquadro “Net State” nella tabella di verifica
LONG quando le Net Position dei Commercials sono positive
SHORT quando sono negative
colorazione verde / rossa coerente con lo stato
✅ Segnalazione visiva dello switch
“⚠️ ALERT CHANGE LONG” quando le Net Position passano da negative a positive
“⚠️ ALERT CHANGE SHORT” quando passano da positive a negative
la segnalazione appare solo nella settimana del cambio
✅ Alert TradingView integrati
Possibilità di creare alert automatici per essere notificati esattamente nel momento in cui avviene lo switch LONG/SHORT, senza dover monitorare manualmente il grafico.
🔹 Utilizzo consigliato
Questo indicatore è pensato per essere utilizzato in combinazione con
“Contango/Backwardation Futures Box Desk – TT Tools”.
La lettura congiunta permette di:
contestualizzare il posizionamento dei Commercials
verificare la struttura della curva (contango / backwardation)
individuare fasi di rotazione, accumulo o distribuzione con maggiore probabilità
Note
Dati COT forniti tramite libreria ufficiale TradingView (COT Library)
Mapping manuale dei codici CFTC per gli strumenti supportati
Focus principale sulle Net Position dei Commercials
_____________________________________________________________
Description
This indicator is directly inspired by the TradingView script “COT Index” by Dixon_Chai
👉
It preserves the original Larry Williams–style COT Index logic (index calculation over multiple lookback periods), while this TT Tools version introduces additional operational features designed for a faster and more actionable reading of Commercials’ positioning, with a specific focus on regime changes in Net Positions.
🔹 What this TT Tools version adds
✅ “Net State” box inside the verification table
LONG when Commercials’ Net Positions are positive
SHORT when they are negative
green / red coloring consistent with the current state
✅ Visual regime-change signal
“⚠️ ALERT CHANGE LONG” when Net Positions switch from negative to positive
“⚠️ ALERT CHANGE SHORT” when they switch from positive to negative
the alert appears only on the exact week of the switch
✅ Built-in TradingView alerts
You can link TradingView alerts to be notified precisely when a LONG/SHORT regime change occurs, without manual chart monitoring.
🔹 Recommended usage
This indicator is designed to be used in combination with
“Contango/Backwardation Futures Box Desk – TT Tools”.
Using both tools together allows you to:
contextualize Commercials’ positioning
evaluate the futures curve structure (contango / backwardation)
identify potential rotation, accumulation, or distribution phases with higher confidence
Notes
COT data provided via the official TradingView COT Library
Manual mapping of CFTC codes for supported instruments
Primary focus on Commercials’ Net Positions
AKKTABLEIt contains table of 10 stocks/Indices i.e. NIFTY, BANKNIFTY, SENSEX, TMPV, RELIANCE, ITC, TATASTEEL, HDFC BANK, INFY AND SBIN.
