Volume footprint by MH RaajThis is for the pro traders who work with volume footprint chart. it includes a complete package of -
1. Footprint chart.
2. Volume profile.
3. Total volume of every single candle.
4. Delta volume.
which can help a traders exactly what is happening in a specific price level on higher time frame and lower time frame. using this multi purpose indicator, you can take a perfect entry where the market makers or big players are interest to buy or sell. to know the strategy or how to use this fantastic combo indicator, follow me on YT or in telegram
Youtube : www.youtube.com
Telegram : t.me/ dJyewRuz6lQ5ZmNl
インジケーターとストラテジー
PK Scalper Pro Neon Cloud Killzone Dashboard 📌 Overview
PK Scalper Pro — Neon Cloud + Killzone Dashboard (JST) combines a Wilders ATR trail,
Fibonacci entry zones, session/killzone context, and a 7-factor environment score
to form a dynamic trend-following scalping strategy.
It adapts in real time to volatility, aiming for higher entry precision and optimized risk.
⚠️ For educational and research purposes only. Past performance does not guarantee future results.
🎯 Strategy Objectives
React quickly to sharp moves and reversals while using hysteresis (bar confirmation)
to suppress noise and deliver stable scalping signals.
✨ Key Features
Neon Cloud visualization (Full / Entry / Premium-Discount / Fib Bands / Upper / Middle / Lower modes)
7-factor scalping score (ATR compression / ADX / Volume / Candle range / Range compression / RSI / BB width)
— quantified 0–10 to measure environment suitability
Stable state machine combining Sensitivity × Stability (confirmation bars)
to determine start/end states reliably
📊 Trading Rules
Long Entry:
Trend = +1 and price <= f2 (78.6%), with is_scalping_time = true
Optimal zone: between f3 (88.6%) and l100 (trail); automatic “Fib Entry (Long)” label
Short Entry:
Trend = −1 and price >= f2 (78.6%), with is_scalping_time = true
Optimal zone: between f3 and l100; automatic “Fib Entry (Short)” label
Exit / Reversal:
Reverse or close on Trend crossover/crossunder
When is_scalping_time = false is confirmed, prioritize taking profit
💰 Risk Management Parameters
Recommended timeframes: 1–15m (FX / Indices / Crypto)
Example: Account $10,000 / Commission 0.02% / Slippage 1.0 pips / Risk 1% per trade
SL = ATR(14) × 1.5, TP = SL × Target R:R (default 2.0)
⚙️ Trading Parameters & Considerations
ATRPeriod = 200 / ATRFactor = 8 / trailType = "modified"
Sensitivity = "Medium" (entry ≈6, exit ≈4) / Stability = "Normal" (confirmation bars = 3)
Fibonacci: ex↔trail range → f1=61.8, f2=78.6, f3=88.6, eq=50, l100=trail
Killzone shown in JST; priority order NY > LDN > TKY, with remaining time countdown
🖼 Visual Support
Highlights optimal zone (f3→100%) and Premium/Discount areas; PRIME conditions shown with purple background
Dashboard displays direction 📈/📉, score, confirmation progress, Killzone (JST), TP/SL guidance, and Session info
🔧 Strategy Improvements & Uniqueness
Introduces a 7-factor score + hysteresis to quantify and stabilize “enter/stop” conditions
Defines precise deep pullback zone (88.6–100%) as optimal entry area
Neon multi-layer cloud + fixed-row dashboard for high visibility and live stability
✅ Summary
PK Scalper Pro integrates momentum (Trend), volatility adjustment (ATR), and multi-factor scoring
into a responsive scalping framework.
Its clear visuals and practical design improve reproducibility and decision confidence.
⚠️ No guarantee of future profits — always apply disciplined position sizing and risk management.
Trading Halt DetectorThis is an indicator that plots RED square above or below the last candle when a trading halt occurs. Note that it only plots once the market resumes, not while it's being Halted.
It calculates the time between every candle. If there's more than 1 minutes from a candle to the next one, a red square is going to show.
For exemple, if you trade on the 1min time frame and a Halt up happens, it usualy takes 5 minutes for the market to resume. Since the resuming candle open 5 minutes later, a RED square is going to appear below the last candle before the HALT.
1. When a RED Square appears below the candle, it means that a HALT up occured.
2. When a RED Square appears above the candle, it means that a HALT down occured.
You may use this indicator on multiple time frames but it's been built for 1 to 4 minutes time frame. It' s possible to adjust the time tolerance that you consider being a halt. The default setting is 1 minutes more than the chosen time frame.
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.
Astrology Weekly Time Calendar [yigdeli]Overview
Thanks to @twingall for their support and feedback.
Astrology Weekly Time Calendar is a time-based visualization indicator designed for users who already work with astrology-based market timing methods.
Instead of analyzing price or generating signals, the indicator focuses exclusively on structuring and projecting user-defined time expectations onto the chart.
It displays predefined future time windows in a session-style format, allowing users to visually reference their own outlook within upcoming periods.
📌 This tool does not attempt to predict price behavior. It provides a structured visual context for time-based expectations defined by the user.
📸
Clean chart showing multiple vertical time boxes across a full week.
Caption:
Example of user-defined weekly time windows visualized in a session-style format.
Core Concept
This indicator does not calculate, interpret, or validate astrological data.
All astrology-related expectations:
Are determined externally by the user
Are based on the user’s own research, methodology, or experience
Are manually entered into the script via input sessions
The indicator acts purely as a visual organization layer, aligning these predefined time windows with the chart’s timeframe and timezone.
How It Works
The user performs their own astrology-based time analysis externally
Based on this analysis, the user defines specific time windows (e.g. active, neutral, or mixed periods)
These time windows are manually entered into the indicator inputs
The script projects these ranges forward on the chart as vertical time zones, similar to a session-based tool
The indicator does not evaluate the validity or effectiveness of any external methodology.
All interpretation remains entirely the responsibility of the user.
📸
Zoomed-in chart showing a single day with multiple colored time boxes.
Caption:
Close-up view of intraday time windows with customizable colors and labels.
Visual Structure
Each time window is displayed as a vertical box on the chart
Colors are fully customizable and represent user-defined classifications
Optional labels may display:
Day
Date
Time
The vertical height of boxes is purely cosmetic and does not represent price levels, targets, outcomes, or performance
The indicator is designed to remain visually clean while supporting complex weekly structures.
⚠️ Note on Colors and Example Charts
The colors used in the example charts are default visual settings and are shown for illustration purposes only.
They do not represent factual market outcomes, validated results, or verified historical behavior.
All displayed time windows are purely visual references based on user-defined inputs and should not be interpreted as reflections of actual market performance.
Manual Input – How to Define Time Windows
All time windows displayed by the indicator are manually defined by the user.
Users first determine their own time expectations externally, then enter the corresponding date and time ranges into the script inputs (similar to defining sessions).
The indicator does not generate, modify, or validate these values. It only visualizes the user-defined time windows on the chart.
This approach ensures full flexibility while keeping all interpretation under the user’s control.
How to Fill the Inputs (Example Workflow)
Time windows are defined sequentially, similar to session-based configurations.
Each new time range always starts where the previous one ends.
This ensures a continuous and organized structure throughout the day.
Example (Monday):
First time window: 00:00 → 03:55
Second time window: 03:55 → 07:30
Third time window: 07:30 → 10:00
Fourth time window: 10:00 → 15:00
…and so on
The end time of one window becomes the start time of the next window.
Users are free to define as many time ranges as needed for each day.
Notes Field (Optional)
Each time window includes an optional notes field, which is empty by default.
Users may use this field to record:
Lunar phases
Cycles
Important astrological references
Personal observations
The indicator does not interpret or process these notes.
They are displayed purely for user reference.
Time Zone & Display Options
Time ranges can be defined according to the user’s local time zone using the time zone selector
Users may optionally enable or disable:
Day name
Date
Time
labels directly on the chart
These display settings allow users to customize how much contextual information is shown, without affecting the underlying time windows.
📸
Settings panel showing session/time inputs, color selections, and note fields.
Caption:
Example of manually entered time ranges and optional notes used to define weekly time expectations.
📸
Full settings panel overview with multiple days and sessions configured.
Caption:
Overview of input settings used to organize and customize weekly time windows.
Intended Users
This indicator is intended for:
Users familiar with astrology-based market timing
Traders who already define their own time expectations externally
Advanced or niche users seeking a structured way to visualize time-based outlooks
It is not designed as a general-purpose trading indicator.
What This Script Does NOT Do
❌ Does not generate buy or sell signals
❌ Does not predict price direction
❌ Does not calculate astrological data
❌ Does not provide financial or trading advice
The script is strictly a time-window visualization tool.
Disclaimer
This indicator is provided for visual and analytical purposes only.
It does not constitute financial advice.
Users should apply their own judgment, confirmation methods, and risk management when using this tool.
Past or future visualizations shown in examples do not imply any form of performance expectation.
Intrinsic Fair Value Calculator (Auto)📊 Intrinsic Fair Value Calculator Auto
Multi-Model Institutional Valuation Engine
The Intrinsic Fair Value Calculator Auto is a comprehensive, institutional-grade valuation indicator that combines multiple professional valuation frameworks into a single, automated system. It allows traders and investors to objectively determine whether an asset is undervalued, fairly valued, or overvalued—directly on the chart, in real time.
Unlike basic valuation tools, this indicator does not rely on a single method. Instead, it aggregates and visualizes five widely accepted intrinsic valuation models used by analysts, portfolio managers, and venture investors.
🔑 Valuation Models Included
🔹 1. 10-Year Discounted Cash Flow (DCF) Model
Projects 10 years of future free cash flows, discounts each year back to present value using a risk-adjusted rate, and calculates terminal value using a perpetuity growth model.
This is the gold standard for intrinsic valuation and reflects the true cash-generating ability of a business.
Best for: Long-term investors and fundamental analysis.
🔹 2. EV / EBITDA Valuation Model
Uses Enterprise Value relative to EBITDA to assess how the market is pricing operational earnings, independent of capital structure.
This model is widely used in institutional finance, private equity, and M&A.
Best for: Comparing valuation across companies or industries.
🔹 3. Asset-Based Valuation Model
Estimates intrinsic value based on a company’s net asset value, accounting for assets minus liabilities.
This approach is especially useful for asset-heavy businesses and downside protection analysis.
Best for: Value investing and balance-sheet-driven analysis.
🔹 4. Venture Capital (VC) Method
Estimates future exit value and discounts it back to present value using high risk-adjusted return assumptions.
This model is designed to evaluate high-growth, early-stage, or speculative assets.
Best for: Growth stocks, startups, and high-risk/high-reward opportunities.
🔹 5. Benjamin Graham Formula
A classic intrinsic value formula created by Benjamin Graham, the father of value investing.
It combines earnings power and growth assumptions into a conservative valuation baseline.
Best for: Conservative value investors seeking margin of safety.
📈 What the Indicator Displays
• Individual intrinsic value estimates for each valuation model
• A composite fair value range derived from all models
• Clear undervalued, fair value, and overvalued zones
• Dynamic valuation levels that update with market data
• Clean on-chart visualization for fast decision-making
🎯 How Traders & Investors Use It
• Identify high-confidence accumulation zones
• Spot overvaluation and distribution areas
• Compare price vs. intrinsic value across multiple models
• Build confluence with technical structure and volume
• Reduce emotional decision-making using objective valuation
🌍 Markets & Timeframes
✔ Stocks
✔ Forex
✔ Crypto
✔ Futures
✔ Intraday, Swing, and Long-Term Charts
⚠️ Disclaimer
This indicator is for educational and analytical purposes only and does not constitute financial advice. Always apply proper risk management and confirm signals using additional analysis.
Gold Professional MacrosMacro Window Descriptions
London Opening Sweep (08:00 – 08:30 CET)
Purpose: The "Judas Swing" window. It captures the initial surge of European liquidity, often creating a false move to sweep Asian Session highs or lows before establishing the true London trend.
London LOD/HOD (09:30 – 10:00 CET)
Purpose: The "Maturity" window. This is where the morning trend often establishes its Low of Day (LOD) or High of Day (HOD) before entering a mid-day consolidation.
Pre-NY News Window (13:30 – 14:00 CET)
Purpose: The "High-Impact" window. Corresponds to 07:30–08:00 NY Time, aligning with major US economic data releases (CPI, Jobless Claims) that trigger immediate repricing in Gold.
NY Open Power Surge (15:15 – 15:45 CET)
Purpose: The "Volatility" window. Marks the official New York open. This is the prime time for ICT Silver Bullet setups as heavy institutional volume enters the market.
The Gold Fix Liquidation (16:00 – 16:30 CET)
Purpose: The Master Macro. This is the London Gold Fix. It is the most critical period for Gold, often resulting in massive reversals or final daily expansions as central banks and bullion dealers settle prices globally.
PM Reversal (19:30 – 20:00 CET)
Purpose: The "Correction" window. Often sees Gold retracing to fill Fair Value Gaps (FVG) or imbalances created during the violent NY morning session.
Key Features of the Script
Visual Time-Boxing: Color-coded background zones for instant recognition.
Automated Labeling: Clearly identifies each macro at the moment of inception.
Multi-Timeframe Compatible: Optimized for M1, M5, and M15 execution charts.
Timezone Synchronized: Hard-coded to Europe/Paris (CET) to align perfectly with European and US market overlaps.
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.
55lvls by aradoThis indicator marks highly reactive end-of-session liquidity levels formed just before the New York close, where institutional positioning often leaves its footprint. These levels stay precise across all timeframes and provide clean, objective reference points for price reactions without manual chart work.
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)
Williams %R with Head & Shoulders Pattern DetectionWhat makes this indicator special?
This indicator merges two proven trading concepts into one powerful tool:
1️⃣ Smoothed Williams %R
The classic Williams %R momentum oscillator is smoothed by an EMA to reduce market noise and deliver cleaner signals. The result: fewer false signals, better readability.
2️⃣ Automatic Pattern Recognition
The indicator continuously scans for the two most powerful reversal formations in technical analysis:
🔴 Head & Shoulders (Bearish) → Short signals
🟢 Inverse Head & Shoulders (Bullish) → Long signals
Why detect patterns in the oscillator instead of the chart?
Pattern formations in Williams %R often emerge earlier than in the price chart itself.
The momentum oscillator reveals weakness or strength before it manifests in price – a crucial timing advantage.
Features at a Glance
📊Dual Signal SystemCombines pattern-based entries with classic crossover signals
🎨 Full VisualizationShoulders, head, neckline, and entry levels are automatically drawn⚙️ Customizable ParametersSymmetry tolerance, pattern size, and visualization individually adjustable
🔔 Alert-ReadyPre-configured alerts for all signal types
📋 Live Status TableDisplays detected patterns and current %R value in real-time
Signal Logic
Pattern Entries:
SHORT: H&S detected + Williams %R crosses neckline downward
LONG: Inverse H&S detected + Williams %R crosses neckline upward
Simple Entries (additional):
Crossover at -80 (oversold → Long)
Crossunder at -23 (overbought → Short)
Recommended Settings
Default values are optimized for most timeframes. For higher timeframes (4H+), consider increasing shoulder tolerance to 20%.
⚠️ Disclaimer: This indicator is an analysis tool and not financial advice. Always combine signals with your own risk management and additional analysis.
Pinbar and Engulfing Pattern Indicator v6Identify pin bars and engulfing candle patterns. please refer to documentation on internet how to use it.
SMC Toolkit v6 (PSH/PSL + OB + FVG + BoS/CHoCH)Simple PSH and PSL from previous day. Order block, FVG and break of structure and change the character of the market.
Footprint OverlayFootprint Overlay
Visualize order flow at individual price levels with real-time Bid x Ask, Delta, or Total Volume data
Overview
Footprint Overlay is an order flow indicator that displays volume information at each price level within a candle, directly on your chart. Choose between Delta (buying pressure minus selling pressure), Bid x Ask (sell volume vs. buy volume), or Total Volume per level. This granular, level-by-level view reveals where institutional activity is concentrated, helping you identify key support and resistance zones based on actual order flow.
Key Features
Multiple Display Modes: Choose how you want to see the data:
Delta: Shows net buying or selling pressure at each level (Buy Volume - Sell Volume).
Bid x Ask: Displays sell volume vs. buy volume side-by-side (e.g., "150 x 230").
Total Volume: Shows the combined buy and sell volume at each level.
Native Footprint Support (v6): For supported symbols, enable TradingView's native footprint data for accurate bid/ask volume attribution.
Intrabar Delta Calculation: When native footprint data is unavailable, the indicator uses lower timeframe intrabar data to estimate delta at each price level using proprietary logic that considers candle body, wicks, and price action.
Adaptive Tick Sizing: Automatically calculates an appropriate tick size (row height) based on asset type (crypto, forex, futures, etc.) and chart timeframe. Manual override is also available.
Gradient Mode: Optionally scale box opacity relative to the maximum value in the candle, making it easy to spot the most significant levels at a glance.
Customizable Colors: Set distinct colors for bullish (positive delta) and bearish (negative delta) levels.
Value Filtering: Hide levels where the displayed value is below a specified magnitude to reduce noise.
Label Display: Show delta or volume values directly on each level with K/M formatting for readability.
How It Works
Level Creation: For each confirmed candle, the indicator divides the price range into multiple levels. The number and size of levels are determined by ATR or adaptive tick calculations.
Data Collection: If native footprint data is enabled, the indicator uses TradingView's footprint API to get accurate bid/ask volumes per row. Otherwise, it requests lower timeframe intrabar data (OHLCV) to analyze price action within the main candle.
Delta Calculation: For intrabar mode, delta is calculated using proprietary logic that considers body size, wicks, and price action characteristics. Volume is distributed proportionally across all price levels the intrabar crosses.
Visualization: Each price level is rendered as a colored box. The color indicates direction (bullish/bearish), and the text shows the value based on your selected display mode.
Use Cases
Support and Resistance Identification: Large delta or volume concentrations at specific price levels often indicate significant support or resistance zones where institutional traders are active.
Order Flow Analysis: Understand where buying and selling pressure is concentrated within each candle, helping identify potential reversal or continuation zones.
Entry and Exit Timing: Use footprint data to identify optimal entry and exit points based on actual order flow, not just price action.
Confirmation Tool: Combine with other technical analysis tools. For example, a strong bullish delta at a support level can confirm a potential bounce.
Settings
Display Mode: Choose between Delta, Bid x Ask, or Total Volume.
Show Delta Labels: Toggle to show/hide value labels on each level.
Gradient Mode: Scale box opacity relative to the max value in the candle.
Max Opacity: Control the maximum opacity for level boxes.
Font Size: Adjust the text size for labels.
Min Value to Show: Filter out levels with values below this magnitude.
Max Bars to Draw: Limit drawing to the last N bars to prevent object limits.
Bullish/Bearish Delta Color: Customize colors for bullish and bearish levels.
Text Color: Customize the text color for labels.
Use Footprint Data (v6): Enable TradingView's native footprint data for supported symbols.
Tick Size Mode: Choose between Auto or Manual tick sizing.
Tick Density Multiplier: Adjust the density of price levels.
Manual Footprint Ticks: Set a fixed tick size when in Manual mode.
Technical Notes
The indicator updates in real-time as new intrabar data comes in, providing a live view of order flow on the current candle.
Drawing is limited to the last N bars (configurable) to avoid exceeding TradingView's object limits.
Adaptive tick sizing considers asset type and timeframe for optimal granularity.
Native footprint mode provides the most accurate bid/ask attribution; intrabar mode is a best-effort estimate.
Level size in intrabar mode is calculated using ATR(14) divided by 10, adapting to current market volatility.
TheStrat Suite: Price Action Signals & AlertsWhether you're new to Price Action trading or an old vet, you're used to marking up charts. Switching between timeframes. Manually setting alerts. And then doing it all again.
TheStrat Suite gives you everything you need to analyze and act on setups across multiple timeframes, all in one place.
Full Analysis in a Single View: see candle combos, timeframe continuity, and actionable signals across six timeframes, no chart-hopping required
Your Charts, Fully Marked Up: automatically mark entries, targets (magnitude and exhaustion levels), and take action windows
Automatically Adapts as the Market Changes: see when targets are hit, setups invalidate, or new setups form
Alerts That Are All Signal, No Noise: filter by timeframe continuity, actionable signals, Domino setups, and more
TheStrat Suite is based on TheStrat, a price action trading methodology developed by Rob Smith. Whether you're familiar with the methodology or not, it's easy to pick up.
FEATURES
Combos across six configurable timeframes
Entries and targets (magnitude and exhaustion levels)
Failed 2s / Range reclaims
Take action windows
Domino setup detection
Full Timeframe Continuity (FTFC) status
Multi-condition alert filtering
All multi-timeframe. All with alerts.
KEY CONCEPTS
Combo: The relationship between the current candle and the prior candle, expressed as two numbers (e.g., 2-1, 3-2). The first number is the prior candle type, the second is the current candle type.
Candle Types: 1 (Inside) = high and low within prior candle's range; 2 (Directional) = took out one side of prior candle; 3 (Outside) = took out both sides of prior candle.
Directional Bias (u/d): Indicates whether a candle closed up (u) or down (d) relative to its open. Shown alongside candle type (e.g., 2u, 2d, 3u, 3d).
CC (Current Candle): The candle currently forming on the chart.
C1 (Candle 1): The most recently closed candle, one bar back from the current candle.
C2 (Candle 2): The candle two bars back from the current candle.
HAM (Hammer): A candle where the low broke below the prior candle's low but closed back inside. Indicates potential bullish reversal.
SHO (Shooter): A candle where the high broke above the prior candle's high but closed back inside. Indicates potential bearish reversal.
Failed 2 / Range Reclaim: When a 2 candle takes out one side of a 1 (inside bar) but fails to continue and reverses back through the opposite side. This "failure" often triggers momentum in the opposite direction.
Magnitude (MAG): The measured move target based on the range of the broadening formation or prior candle structure.
Exhaustion Level: A level derived from extended price action that may indicate a potential reversal or pause zone.
Take Action Window: The period during which a lower timeframe entry aligns with a higher timeframe signal. When this window is active, your entry is "in sync" with the larger structure.
Domino Setup: Multiple consecutive timeframes showing inside bars (1s). When one breaks, it can trigger a cascade of setups across timeframes.
Full Timeframe Continuity (FTFC): When all selected timeframes align in the same directional bias (all bullish or all bearish). Often used as a filter for higher-probability setups.
Signal: Any combo that matches the criteria you have defined in your settings and filters. Signals represent the setups you want to see based on your trading preferences.
Actionable Signal: Traditionally, a hammer, shooter, or inside bar. These setups have a defined trigger level and are considered "ready to trade" when that level is approached or broken.
Potential Signal: A setup that is not yet confirmed but may become a signal if certain conditions are met. Potential signals are noted with a * before them in the indicator display.
KNOWN LIMITATIONS (v1.0)
Timeframe Hierarchy: TradingView does not allow requesting data from a timeframe lower than your chart's timeframe. If your chart is set to 1 hour, you cannot display data from the 15-minute or 5-minute timeframes. Always set your chart timeframe equal to or lower than your lowest configured indicator timeframe.
Bar Replay Mode: Performance is unreliable in bar replay mode, especially when involving smaller timeframes. This is a known TradingView limitation, not a bug in the indicator.
Historical Depth: To optimize performance, certain calculations (such as exhaustion levels) are limited to recent bars. This ensures fast load times without impacting real-time functionality.
Label Overlap: When two or more levels are close together, labels may overlap on the chart. This is a TradingView limitation. Users can adjust label display settings to mitigate this issue.
COMMON ISSUES & SOLUTIONS
"I'm seeing too much on my chart." Use the indicator settings to toggle off features you don't need. Alternatively, rely on alerts to notify you when specific conditions are met rather than displaying everything visually.
"I'm getting alerts at the wrong times, or too few, or too many." Check your alert interval setting in TradingView. The alert interval should be set to less than or equal to your lowest configured indicator timeframe. For example, if your lowest timeframe is 5 minutes, set alerts to trigger every 1 minute or "Once Per Bar Close" on a chart timeframe of 5 minutes or lower.
"Levels aren't showing for a timeframe." Confirm your chart timeframe is equal to or lower than the timeframe you're trying to display. A 1-hour chart cannot show 15-minute data.
"Labels or levels disappeared unexpectedly." The indicator automatically hides levels that are no longer relevant based on your selected filters and current market conditions. Check your settings to verify which filters are enabled. If a level was hit, invalidated, or is now duplicated by another timeframe, it may be hidden intentionally to keep your chart clean.
Trading and investing involves risk of financial loss. TheStrat Suite is a charting tool, not financial advice. Past performance does not guarantee future results. You are solely responsible for your trading decisions. 345 Strategies assumes no responsibility for any losses (or gains) incurred.
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.
INDIBOT PRO [Indibot Style]ABO SALTAN //@version=6
indicator("INDIBOT PRO ", overlay=true, max_labels_count=500)
// === WAVE TREND CALC ===
src = hlc3
n1 = input.int(10, "WT Channel Length")
n2 = input.int(21, "WT Signal Smoothing")
obLevel = input.float(2.0, "Overbought Threshold")
osLevel = input.float(-2.0, "Oversold Threshold")
esa = ta.ema(src, n1)
d = ta.ema(math.abs(src - esa), n1)
ci = (src - esa) / (0.015 * d)
wt1 = ta.ema(ci, n2)
wt2 = ta.sma(wt1, 4)
// === CROSS SIGNALS ===
buyCond = ta.crossover(wt1, wt2) and wt1 < osLevel
sellCond = ta.crossunder(wt1, wt2) and wt1 > obLevel
// === PRICE CHART ARROWS ===
plotshape(buyCond, title="Buy Arrow", location=location.belowbar, style=shape.labelup,
color=color.new(color.teal, 0), text="BUY", textcolor=color.white, size=size.small)
plotshape(sellCond, title="Sell Arrow", location=location.abovebar, style=shape.labeldown,
color=color.new(color.red, 0), text="SELL", textcolor=color.white, size=size.small)
// === OSCILLATOR PANEL ===
plot(wt1, color=color.green, title="WT Line", linewidth=2)
plot(wt2, color=color.red, title="Signal Line", linewidth=2)
hline(obLevel, "Overbought", color=color.red)
hline(osLevel, "Oversold", color=color.green)
hline(0, "", color=color.gray)
// === CROSSOVER DOTS ===
plotshape(ta.crossover(wt1, wt2), title="WT Cross Up", location=location.belowbar, color=color.teal,
style=shape.circle, size=size.tiny, offset=-1)
plotshape(ta.crossunder(wt1, wt2), title="WT Cross Down", location=location.abovebar, color=color.red,
style=shape.circle, size=size.tiny, offset=-1)
// === BACKGROUND COLOR ===
bgcolor(wt1 > obLevel ? color.new(color.red, 90) : wt1 < osLevel ? color.new(color.green, 90) : na, title="OB/OS Zone Highlight")
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.
