EMAs Bullish/Bearish Confluence [Trend Bias]EMA Confluence Zones
This indicator is designed to simplify trend identification by visually highlighting "Confluence Zones" —areas where short-term, medium-term, and long-term momentum are fully aligned.
While traders can manually add three Moving Averages to a chart, identifying the exact moment all three align (the "Perfect Stack") can be visually difficult during live trading. This script automates that process, converting complex line crosses into simple background color zones and providing actionable alerts for the exact moment a trend alignment begins.
🛠 How It Works
The script utilizes three customizable Exponential Moving Averages (EMAs) to detect the market bias:
Short EMA: Represents immediate price action/momentum.
Medium EMA: Represents the intermediate trend.
Long EMA: Represents the major trend baseline.
Calculations & Logic
The indicator checks for a specific hierarchical alignment (Stacking) of these averages:
1. 🟢 Bullish Confluence (Buy Zone):** Returns true when `Short > Medium` AND `Medium >Long`. This confirms that momentum is rising across all three monitored timeframes.
2. 🔴 Bearish Confluence (Sell Zone):** Returns true when `Short < Medium` AND `Medium < Long`. This confirms that momentum is falling across all three monitored timeframes.
3. ⚪ Neutral (No Color): Any other state indicates a choppy or consolidating market where the EMAs are intertwined.
---
🚀 Key Features
*Visual Bias Confirmation: The background highlights Green (Bullish) or Red (Bearish) only when the "Perfect Stack" conditions are met.
Trend Start Alerts: Unlike standard EMA cross alerts, this script includes custom alert conditions that trigger only on the first bar where the confluence becomes valid. This prevents spam alerts during a prolonged trend.
Full Customization: Users can adjust the lengths of all three EMAs to fit specific strategies (e.g., Scalping vs. Swing Trading).
Clean Chart Mode: Includes options to hide the EMA lines entirely and rely solely on the background color for a minimalist "Naked Trading" setup.
🎯 How to Use
1. Trend Filter: Use the background color to determine your directional bias. If the background is Green, look only for Long setups on lower timeframes. If Red, look only for Short setups.
2. Breakout Confirmation: If price breaks a key level, wait for the background color to flip. This confirms that the Moving Averages have caught up to the move, validating the breakout strength.
3. Exit Signal: If you are in a trend trade and the background color disappears (turns transparent), it indicates the trend momentum is fading and the EMAs are beginning to cross/compress.
⚙️ Settings
EMA Lengths: Default is 20, 50, 100. These can be changed to common combinations like (9, 21, 55) or (50, 100, 200).
Visuals: Toggle lines or background colors on/off and adjust transparency to keep your chart readable.
---
Disclaimer: This script is for informational purposes only. Past performance of a trend following method does not guarantee future results. Always use proper risk management.
Exponential Moving Average (EMA)
Buy Sell SignalBuy Sell Signal - EMA Crossover with Dynamic Risk Management
OVERVIEW
This indicator combines a dual EMA crossover system with ATR-based dynamic stop loss and take profit levels to provide complete trade management signals. Unlike basic EMA crossover scripts, this tool automatically calculates and displays entry points, stop losses, and take profit targets based on market volatility, offering traders a complete trading framework in a single indicator.
HOW IT WORKS
The indicator uses three core components working together:
Trend Detection: A fast EMA (default 5) and slow EMA (default 13) identify trend direction. When the fast EMA crosses above the slow EMA, it signals bullish momentum; when it crosses below, it signals bearish momentum.
Entry Validation: Optional candle confirmation filter ensures the crossover is accompanied by a bullish/bearish candle close, reducing false signals in choppy markets.
Risk Management: Uses ATR (Average True Range, default 14 periods) to calculate:
Stop Loss: Positioned below/above recent swing low/high minus ATR multiplier (default 0.5x)
Take Profit: Calculated using customizable risk-reward ratio (default 3:1)
KEY FEATURES
✅ Automatic Position Tracking: Monitors active trades and displays current position status (LONG/SHORT/No position)
✅ Visual Trade Management: Shows entry price (white dashed line), stop loss (red line), and take profit (green line) in real-time
✅ Trade Outcome Signals: Displays clear markers when TP is hit (🎯), SL is triggered (❌), or position is invalidated by opposite signal
✅ Information Dashboard: Live table showing entry price, SL, TP, and actual R:R ratio
✅ Smart Position Invalidation: Automatically closes and invalidates previous positions when opposite trend signal appears
✅ Customizable Alerts: Five alert conditions for BUY/SELL signals, TP hits, SL triggers, and invalidations
INPUTS
Fast EMA Length (default 5): Responsive to recent price action
Slow EMA Length (default 13): Defines broader trend direction
ATR Period (default 14): Volatility measurement period
SL Multiplier (default 0.5): Distance from swing point to stop loss
Risk:Reward Ratio (default 3.0): Target profit relative to risk
Candle Confirmation (default ON): Requires bullish/bearish candle on crossover
HOW TO USE
Apply the indicator to your chart (works on all timeframes)
Adjust EMA periods based on your trading style (shorter for scalping, longer for swing trading)
Set your preferred risk-reward ratio
Enable alerts for automated notifications
When a BUY/SELL signal appears, the indicator automatically calculates and displays your complete trade plan
Monitor the information table for live position updates
Exit when TP is reached or SL is triggered
TRADING METHODOLOGY
This script implements a momentum-following strategy based on exponential moving average crossovers, enhanced with volatility-adjusted risk parameters. The ATR-based stop loss adapts to market conditions—wider stops in volatile markets, tighter stops in calm markets. The position invalidation feature prevents traders from holding outdated positions when market sentiment shifts.
BEST PRACTICES
Use on trending markets for best results
Higher timeframes (4H, Daily) produce fewer but more reliable signals.
For scalpe use 5 and 15 minutes(Risk).
Consider market context and fundamental factors alongside signals
Adjust ATR multiplier based on asset volatility
Test different EMA combinations for your preferred instruments
ORIGINALITY
While EMA crossover systems are common, this script's value lies in its complete integration of entry logic, dynamic risk management, position tracking, and automated invalidation—features typically requiring multiple separate indicators. The ATR-based stop loss calculation and automatic R:R visualization provide practical trade execution guidance that basic crossover indicators lack.
Important Notes:
This indicator does not guarantee profitable trades
Always practice proper risk management
Backtest settings on historical data before live trading
Past performance does not indicate future results
Displacement Intelligence Channel (DIC) @darshaksscThe Displacement Intelligence Channel (DIC) is a clean, minimal, non-repainting analytical tool designed to help traders observe how price behaves around its dynamic equilibrium.
It does not generate buy/sell signals, does not predict future price movement, and should not be interpreted as financial advice.
All calculations are based strictly on confirmed historical bars.
⭐ What This Indicator Does
Price constantly fluctuates between expansion (large moves) and compression (small moves).
The DIC analyzes these changes through:
Displacement (how far price moves per bar)
ATR response (how volatility reacts over time)
Dynamic width calculation (channel widens or tightens as volatility changes)
EMA-based core midline (a smooth equilibrium reference)
The result is a smart two-line channel that adapts to market conditions without cluttering the chart.
This is NOT a fair value gap, moving average ribbon, or premium/discount model.
It is a purely mathematical displacement-ATR engine.
⭐ How It Works
The indicator builds three elements:
1. Intelligence Midline
A smooth EMA that acts as the channel’s core “equilibrium.”
It gives a stable reference of where price is gravitating during the current session or trend.
2. Adaptive Upper Boundary
Calculated using displacement + ATR.
When volatility increases, the channel expands outward.
When volatility compresses, the channel tightens.
3. Adaptive Lower Boundary
Mirrors the upper boundary.
Also expands and contracts based on market conditions.
All lines update only on confirmed bar closes, keeping the script non-repainting.
⭐ What to Look For (Purely Analytical)
This indicator does not imply trend continuation, reversal, or breakout.
Instead, here’s what traders typically observe:
1. Price Reactions Around the Midline
Price often oscillates around the midline during equilibrium phases.
Strong deviation from the midline highlights expansion or momentum phases.
2. Channel Expansion / Contraction
Wider channel → increased volatility, displacement, and uncertainty
Tighter channel → compression and calm conditions
Traders may use this for context only — not for decision-making.
3. Respect of Channel Boundary
When market structure respects the upper/lower channel lines, it simply indicates volatility boundaries, not overbought/oversold conditions.
⭐ How to Add This Indicator
Open TradingView
Select any chart
Click Indicators → Invite-Only Scripts / My Scripts
Choose “Displacement Intelligence Channel (DIC)”
The channel will appear automatically on the chart
⭐ Recommended Settings (Optional)
These settings do not change signals (because the indicator has none).
They only adjust sensitivity:
Center EMA Length (default 34)
Smoother or faster midline
Displacement Lookback (default 21)
Controls how much recent displacement affects width
ATR Lookback (default 21)
Governs how volatility is interpreted
Min/Max Multipliers
Limits how tight or wide the channel can expand
Adjust them cautiously for different timeframes or asset classes.
⭐ Important Notes
This tool is non-repainting
It does not use future data
It does not repaint previous channel widths
It follows TradingView House Rules
It contains no signals, no alerts, and no predictions
The DIC is designed for visual context only and should be used as an analytical overlay, not as a stand-alone decision tool.
⭐ Disclaimer
This script is strictly for informational and educational purposes only.
It does not provide or imply any trading signals, financial advice, or expected outcomes.
Always do your own research and consult a licensed financial professional before making trading decisions.
Multi EMA and SMA with VWAP Indicator📊 Custom Multi-MA & VWAP Indicator
A comprehensive and fully customizable moving average indicator that combines 6 Exponential Moving Averages (EMAs), 3 Simple Moving Averages (SMAs), and VWAP in one clean, easy-to-use tool.
✨ Features:
6 Configurable EMAs:
• Default periods: 9, 21, 50, 100, 150, 200
• Fully adjustable lengths
• Individual color customization
• Show/hide toggles for each EMA
3 Configurable SMAs:
• Default periods: 20, 50, 100
• Fully adjustable lengths
• Individual color customization
• Show/hide toggles for each SMA
• Thicker lines for easy distinction from EMAs
VWAP (Volume Weighted Average Price):
• Toggle on/off
• Customizable color and line width
• Essential for intraday trading and institutional levels
🎯 Use Cases:
• Trend identification and confirmation
• Support and resistance levels
• Entry and exit signals
• Multi-timeframe analysis
• Day trading and swing trading strategies
• Institutional price levels (VWAP)
⚙️ Fully Customizable:
Every aspect of this indicator is configurable through the settings panel:
• Adjust any MA period to fit your trading strategy
• Choose your preferred colors for better chart visualization
• Enable/disable specific MAs to reduce chart clutter
• Customize VWAP line thickness
📈 Perfect For:
• Traders who use multiple moving averages in their strategy
• Those seeking an all-in-one MA solution
• Clean chart organization with one indicator instead of multiple
• Both beginners and experienced traders
💡 Tips:
• Use shorter EMAs (9, 21) for quick trend changes
• Longer EMAs (100, 150, 200) act as strong support/resistance
• VWAP is particularly useful for intraday trading
• Customize colors to match your chart theme
Version: Pine Script v6
Overlay: Yes (plots directly on price chart)
paigep.llc - SuperMASuperMA is a multi-layered moving-average and candle-coloring system that combines SMA, EMA, and optional HMA logic to help traders visualize trend shifts, pullbacks, and momentum changes in a clean, structured way.
The script includes multiple modules: trend-based moving averages, pullback signals, exit logic, and an optional HMA cross engine.
📌 Core Features
1. Full SMA + EMA Framework
The indicator plots multiple moving averages (8, 9, 13, 20, 50, 200) using both SMA and EMA calculations. Each line automatically colors bullish or bearish based on its relationship to the 200-period baseline.Users can toggle SMAs and EMAs independently for clearer chart control.
2. Main Trend Entry & Exit Logic (8×200 and 8×20)
Built-in crossover logic detects:
Main Entry: SMA 8 crossing above/below EMA 200
Main Exit: SMA 8 and SMA 20 cross (with an option to choose which SMA is treated as the “fast” leg)
A “first exit only” option allows the script to ignore additional exit signals until a new trend regime begins.
3. Pullback Module (20 SMA Interaction)
Pullback entries and exits occur when price crosses the 20 SMA during existing trend conditions.
This includes:
Pullback entries through the 20 SMA
Pullback exits back across the 20 SMA
Labels and candle colors are available for all pullback events.
4. Optional HMA Cross Module
A separate module allows traders to use two Hull Moving Averages (HMA) with customizable:
Lengths
Independent timeframes
Line colors
Cross-based entries and exits
This module has its own events, labels, and optional candle coloring.
5. Advanced Candle Coloring System
Candle coloring is layered in priority order, based on:
Main trend entries
Main exits
HMA entries
HMA exits
Pullback entries
Pullback exits
Trend-only candles (based on SMA 8 relative to EMA 200)
Users may also independently color wicks and borders.
6. Configurable Alerts (Fully Decoupled from Visuals)
Alerts are available for all major events, including:
Main Entries (8×200)
Main Exits (8×20)
Pullback Entries and Exits
HMA Entries and Exits
Bull or Bear Trend candles
Any colored candle event
Alerts can fire on bar close only or intrabar, depending on user preference.
📌 Use Cases
SuperMA helps traders visualize:
Trend direction using SMA/EMA structure
Momentum shifts through HMA crosses
Pullback zones around the 20 SMA
Early regime transitions based on the 8×200 relationship
Candle-level context through color-coded bars
The indicator works across all markets and timeframes.
⚠️ Note
This tool is for visual and analytical assistance only. It does not guarantee future performance and should be combined with additional analysis and risk management.
paigep.llc - SuperMA
SuperMA is a multi-layered moving-average and candle-coloring system that combines SMA, EMA, and optional HMA logic to help traders visualize trend shifts, pullbacks, and momentum changes in a clean, structured way.
The script includes multiple modules: trend-based moving averages, pullback signals, exit logic, and an optional HMA cross engine.
📌 Core Features
1. Full SMA + EMA Framework
The indicator plots multiple moving averages (8, 9, 13, 20, 50, 200) using both SMA and EMA calculations. Each line automatically colors bullish or bearish based on its relationship to the 200-period baseline. Users can toggle SMAs and EMAs independently for clearer chart control.
2. Main Trend Entry & Exit Logic (8×200 and 8×20)
Built-in crossover logic detects:
Main Entry: SMA 8 crossing above/below EMA 200
Main Exit: SMA 8 and SMA 20 cross (with an option to choose which SMA is treated as the “fast” leg)
A “first exit only” option allows the script to ignore additional exit signals until a new trend regime begins.
3. Pullback Module (20 SMA Interaction)
Pullback entries and exits occur when price crosses the 20 SMA during existing trend conditions.
This includes:
Pullback entries through the 20 SMA
Pullback exits back across the 20 SMA
Labels and candle colors are available for all pullback events.
4. Optional HMA Cross Module
A separate module allows traders to use two Hull Moving Averages (HMA) with customizable:
Lengths
Independent timeframes
Line colors
Cross-based entries and exits
This module has its own events, labels, and optional candle coloring.
5. Advanced Candle Coloring System
Candle coloring is layered in priority order, based on:
Main trend entries
Main exits
HMA entries
HMA exits
Pullback entries
Pullback exits
Trend-only candles (based on SMA 8 relative to EMA 200)
Users may also independently color wicks and borders.
6. Configurable Alerts (Fully Decoupled from Visuals)
Alerts are available for all major events, including:
Main Entries (8×200)
Main Exits (8×20)
Pullback Entries and Exits
HMA Entries and Exits
Bull or Bear Trend candles
Any colored candle event
Alerts can fire on bar close only or intrabar, depending on user preference.
Use Cases
SuperMA helps traders visualize:
Trend direction using SMA/EMA structure
Momentum shifts through HMA crosses
Pullback zones around the 20 SMA
Early regime transitions based on the 8×200 relationship
Candle-level context through color-coded bars
The indicator works across all markets and timeframes.
⚠️ Note
This tool is for visual and analytical assistance only. It does not guarantee future performance and should be combined with additional analysis and risk management.
EMA CrossMoving averages based trend indicator
Plots
Hull Moving average 34
Simple MA 200
Exponential MA 5
Signals on crossing and turn around points.
Multi MAThis TradingView indicator displays four customizable moving averages on your price chart: two Exponential Moving Averages (EMAs) and two Simple Moving Averages (SMAs).
The default settings show a 10-period EMA (aqua), 21-period EMA (orange), 50-period SMA (green), and 200-period SMA (red), which are commonly used timeframes for trend analysis.
Each moving average can be individually toggled on or off, and their lengths and colors are fully adjustable through the indicator settings.
The EMAs react more quickly to price changes while the SMAs provide smoother, more gradual trend indicators, making this useful for identifying support/resistance levels and trend direction.
Traders often watch for crossovers between these moving averages as potential entry or exit signals, with the 50/200 SMA cross being particularly significant as the "golden cross" or "death cross."
ema_sw_alligatorA powerful and visually intuitive trading indicator that plots four exponential moving averages (EMA 8, 13, 48, 200) with customizable offsets and dynamic gradient visualization between the fast EMAs.
key features:
- four ema periods: displays ema 8, 13, 48, and 200 with customizable lengths
- customizable offsets: each ema can be shifted forward or backward in time (default: ema 200 offset 20, ema 48 offset 5, ema 13 offset 10, ema 8 offset 0)
- dynamic gradient system: visual color gradient between ema 8 and ema 13 that changes based on momentum:
-- green gradient when ema 8 crosses above ema 13 (bullish momentum)
-- red gradient when ema 8 crosses below ema 13 (bearish momentum)
- full customization:
- toggle individual ema visibility on/off
- customize colors for each ema line
- adjust gradient colors and transparency
- modify offset values for each ema
trading strategy:
ENTRY (Long)
- DAILY Chart
- 8 EMA crosses above 200 and 13 EMA
- Price remains above 200 EMA
- Break of Structure
Stay in:
- IF price stays above 8/13 and 48EMA after Entry
EXIT / STOP:
- Stop under recent swing low
- Exit when price crosses below 13 EMA IF under Entry
- Exit when price crosses below 48 EMA IF under Entry
trading applications:
- identify trend direction using the ema alignment
- spot potential entry points when ema 8 crosses ema 13 with gradient color confirmation
- use ema 48 and ema 200 as longer-term trend filters
- the offset feature helps anticipate potential support/resistance levels
- clear entry and exit rules based on EMA crossovers and price structure
settings overview:
- adjust ema lengths according to your trading style
- modify offsets to fine-tune the indicator's responsiveness
- customize colors for better visual clarity
- control gradient transparency to balance visibility and chart readability
perfect for swing traders, day traders, and anyone who uses moving average crossovers in their trading strategy. the visual gradient makes it easy to identify momentum shifts at a glance, while the clear trading rules provide a systematic approach to entries and exits.
Mambo MA & HAMambo MA & HA is a combined trend-view indicator that overlays Heikin Ashi direction markers and up to eight customizable moving averages on any chart.
The goal is to give a clear, uncluttered visual summary of short-term and long-term trend direction using both regular chart data and Heikin Ashi structure.
This indicator displays:
Heikin Ashi (HA) directional markers on the chart timeframe
Optional Heikin Ashi markers from a second, higher timeframe
Up to eight different moving averages (SMA, EMA, SMMA/RMA, WMA, VWMA)
Adjustable colors and transparency for visual layering
Offset controls for HA markers to prevent overlap with price candles
It is designed for visual clarity without altering the underlying price candles.
Heikin Ashi Direction Markers (Chart Timeframe)
The indicator generates HA OHLC values internally and compares the HA open and close:
Green (bullish) HA candle → triangle-up marker plotted above the bar
Red (bearish) HA candle → triangle-down marker plotted above the bar
The triangles use soft pastel colors for minimal obstruction:
Up marker: light green (rgb 204, 232, 204)
Down marker: light red (rgb 255, 204, 204)
The “HA Offset (chart TF ticks)” input lets users shift the triangle vertically in price terms to avoid overlapping the real candles or MAs.
Heikin Ashi Markers from a Second Timeframe
An optional second timeframe (default: 60m) shows additional HA direction:
Green HA (higher timeframe) → tiny triangle-up below the bar
Red HA (higher timeframe) → tiny triangle-down below the bar
This allows a trader to see higher-timeframe HA structure without switching charts.
The offset for the second timeframe is independent (“HA Offset (extra TF ticks)”).
Custom Moving Averages (Up to Eight)
The indicator includes eight individually configurable MAs, each with:
On/off visibility toggle
MA type
SMA
EMA
SMMA / RMA
WMA
VWMA
Source
Length
Color (with preset 70% transparency for visual stacking)
The default MA lengths are: 10, 20, 50, 100, 150, 200, 250, 300.
All MA colors are slightly transparent by design to avoid obscuring price bars and HA markers.
Purpose of the Indicator
This tool provides a simple combined view of:
Immediate trend direction (chart-TF HA markers)
Higher-timeframe HA trend bias (extra-TF markers)
Overall moving-average structure from short to very long periods
It is particularly useful for:
Monitoring trend continuation vs. reversal
Confirming entries with multi-TF Heikin Ashi direction
Identifying pullbacks relative to layered moving averages
Viewing trend context without switching timeframes
There are no signals, alerts, or strategy components.
It is strictly a visual trend-context tool.
Key Features Summary
Two-timeframe Heikin Ashi direction
Separate offsets for HA markers
Eight fully configurable MAs
Clean color scheme with low opacity
Non-intrusive overlays
Compatible with all markets and chart types
3 EMA Crossover (Text Color Customizable) - Fixed3 Ema crossover 9/15/21
it will generate buy and sell signal on crossover.
Trend TraderMost trend indicators don’t offer continuation signals or accurate bounce points, so I created this indicator that uses one of the most common trading levels (EMAs). This indicator uses the 50, 100, and 200 EMAs along with WaveTrend signals to trade trends. Buy Signals are filtered so that they only show up when the 100 EMA is above the 200. And Inverse for Sell Signals.
This indicator works well with both Stocks and Crypto. Default settings work best on 15 min, 1H, 2H, and 4H.
(Chart examples are using Heikin Ashi Candles, on Log Scale.)
*Buy and Sell Signals do not repaint.
Settings:
- Ability to show all buy and sell signals regardless of trend.
- To change the sensitivity of the buy and sell signals, change the “Average Length”
- (The lower the number the more sensitive, the higher the number the less they pop up)
- Ability to change EMA Lengths
imgur.com
Triple 9 Bias filter Triple 9 Bias – Precision Multi-Timeframe Directional Filter
Technical Overview
The Triple 9 Bias is a precision multi-timeframe directional filter built exclusively for 5-minute (and lower) trading.
It stacks three EMA-9 trend directions (4H + 1H + 15m) as Primary confluence and uses only the 4H RSI-14 as Secondary confirmation.
Integrity Check: Zero repaint · Zero lookahead · Works identically on any chart timeframe.
The Trading Rule (Simple)
Long Trades: Only trade longs when all three EMA-9s are UP + 4H RSI > 50
Short Trades: Only trade shorts when all three EMA-9s are DOWN + 4H RSI < 50
Otherwise — stand aside.
Display Components
A. Plotted Higher-Timeframe EMAs (No Repainting)
All values are pulled from closed higher-timeframe bars.
4H EMA 9 (Red step-line)
1H EMA 9 (Purple step-line)
15m EMA 9 (Orange step-line)
B. Locked Dashboard (Bottom-Right)
Clean table split into Primary and Secondary sections for instant bias reading.
Colour Logic:
🟢 Lime = UP / BUY
🔴 Red = DOWN / SELL
Background Logic:
Full Green: Only when all three EMA-9s are UP
Full Red: Only when all three EMA-9s are DOWN
Gray: Otherwise = no trade
Indicator Breakdown
3.1. Primary Confluence – EMA 9 Slope
4H EMA 9 direction (compared 10 bars back)
1H EMA 9 direction (compared 6 bars back)
15m EMA 9 direction (compared 6 bars back)
3.2. Secondary Confluence
4H RSI-14 vs 50 level (BUY if >50, SELL if <50)
High-Probability Signal: When Primary = all three “UP” and Secondary = “BUY” → highest-probability bullish bias (and vice-versa for bearish).
Price Action - EMA ClusterAligned with Al Brooks' multi-timeframe analysis in his series, this plots three EMA20 lines on 5m charts: current (line), 15m (stepline), and 60m (stepline). Visible only on 5m timeframe for clarity. EMAs act as dynamic trend channels—price above signals bull bias, below bear. Test extremes: Pullbacks to EMA often offer second-leg entries in trends. Customize colors for better visualization of always-in direction.
Strict Weekly 50/200 WMA Signals True Weekly Only-Strict Weekly 50/200 WMA Signals True Weekly Only => also on other time frames than weekly (like daily, etc.) always indicates the indicators based on the weekly chart
-especially useful for Crypto
-gives buy and sell signals when the 200 WMA or the 50 WMA are crossed
-typically above the 50 WMA indicates a bull market
-reaching below the 200 WMA indicates a bear market and typically for investors with a longer time frame (>2-4 years) a good entry point
Naveen Prabhu with EMA//@version=6
indicator('Naveen Prabhu with EMA', overlay = true, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
a = input(2, title = 'Key Vaule. \'This changes the sensitivity\'')
c = input(5, title = 'ATR Period')
h = input(false, title = 'Signals from Heikin Ashi Candles')
BULLISH_LEG = 1
BEARISH_LEG = 0
BULLISH = +1
BEARISH = -1
GREEN = #089981
RED = #F23645
BLUE = #2157f3
GRAY = #878b94
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b
HISTORICAL = 'Historical'
PRESENT = 'Present'
COLORED = 'Colored'
MONOCHROME = 'Monochrome'
ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'
TINY = size.tiny
SMALL = size.small
NORMAL = size.normal
ATR = 'Atr'
RANGE = 'Cumulative Mean Range'
CLOSE = 'Close'
HIGHLOW = 'High/Low'
SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'
SMART_GROUP = 'Smart Money Concepts'
INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'
modeTooltip = 'Allows to display historical Structure or only the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart Number of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart Number of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks It is recommended to use the cumulative mean range method when a low amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows Lower values will return fewer but more pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart'
modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = )
styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = )
showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip)
showInternalsInput = input( false, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = )
internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = )
internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = )
showStructureInput = input( false, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = )
swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = )
swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = )
showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( false, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)
showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob')
internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( true, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = )
internalBullishOrderBlockColor = input.color(color.new(GREEN, 80), 'Internal Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#f77c80, 80), 'Internal Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(GREEN, 80), 'Bullish OB', group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#b22833, 80), 'Bearish OB', group = BLOCKS_GROUP)
showEqualHighsLowsInput = input( false, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = )
showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = )
dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = )
weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = )
monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly')
showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP)
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox
type trend
int bias
type equalDisplay
line l_ine = na
label l_abel = na
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
type orderBlock
float barHigh
float barLow
int barTime
int bias
// @variable current swing pivot high
var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array fairValueGaps = array.new()
// @variable storage for parsed highs
var array parsedHighs = array.new()
// @variable storage for parsed lows
var array parsedLows = array.new()
// @variable storage for raw highs
var array highs = array.new()
// @variable storage for raw lows
var array lows = array.new()
// @variable storage for bar time values
var array times = array.new()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing order blocks)
var array swingOrderBlocks = array.new()
// @variable storage for orderBlock UDTs (internal order blocks)
var array internalOrderBlocks = array.new()
// @variable storage for swing order blocks boxes
var array swingOrderBlocksBoxes = array.new()
// @variable storage for internal order blocks boxes
var array internalOrderBlocksBoxes = array.new()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time
// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
// @variable source to use in bearish order blocks mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high
// @variable source to use in bullish order blocks mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)
leg(int size) =>
var leg = 0
newLegHigh = high > ta.highest( size)
newLegLow = low < ta.lowest( size)
if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg
startOfNewLeg(int leg) => ta.change(leg) != 0
startOfBearishLeg(int leg) => ta.change(leg) == -1
startOfBullishLeg(int leg) => ta.change(leg) == +1
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) =>
var label l_abel = na
if modeInput == PRESENT
l_abel.delete()
l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small)
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay
string tag = 'EQL'
color equalColor = swingBullishColor
string labelStyle = label.style_label_up
if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down
if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)
e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput)
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)
if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow
if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low , size, false)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh
if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high ,size,true)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)
if modeInput == PRESENT
l_ine.delete()
l_abel.delete()
l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle)
l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize)
deleteOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
for in orderBlocks
bool crossedOderBlock = false
if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput)
array a_rray = na
int parsedIndex = na
if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())
orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias)
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
if orderBlocks.size() >= 100
orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)
drawOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
orderBlocksSize = orderBlocks.size()
if orderBlocksSize > 0
maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize))
array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes
for in parsedOrdeBlocks
orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor)
box b_ox = b_oxes.get(index)
b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow))
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true
if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)
pivot p_ivot = internal ? internalHigh : swingHigh
trend t_rend = internal ? internalTrend : swingTrend
lineStyle = internal ? line.style_dashed : line.style_solid
labelSize = internal ? internalStructureSize : swingStructureSize
extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput
if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS
if internal
currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BULLISH
displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)
p_ivot := internal ? internalLow : swingLow
extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput
if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS
if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BEARISH
displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor)
deleteFairValueGaps() =>
for in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)
// @function draw fair value gaps
// @returns fairValueGap ID
drawFairValueGaps() =>
= request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on)
barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)
newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0
bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe
if bullishFairValueGap
currentAlerts.bullishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor)))
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
= request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on)
float parsedTop = sameTimeframe ? high : topLevel
float parsedBottom = sameTimeframe ? low : bottomLevel
int parsedLeftTime = sameTimeframe ? time : leftTime
int parsedRightTime = sameTimeframe ? time : rightTime
int parsedTopTime = time
int parsedBottomTime = time
if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex = times.binary_search_rightmost(parsedRightTime)
array timeArray = times.slice(leftIndex,rightIndex)
array topArray = highs.slice(leftIndex,rightIndex)
array bottomArray = lows.slice(leftIndex,rightIndex)
parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime
var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny)
rightTimeBar = last_bar_time + 20 * (time - time )
topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High')
bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low')
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)
b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))
l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))
// @function draw premium/discount zones
// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down)
equilibriumLevel = math.avg(trailing.top, trailing.bottom)
drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left)
drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up)
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor)
if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()
if showHighLowSwingsInput
drawHighLowSwings()
if showPremiumDiscountZonesInput
drawPremiumDiscountZones()
if showFairValueGapsInput
deleteFairValueGaps()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showInternalOrderBlocksInput or showTrendInput
displayStructure(true)
if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput
displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)
if showSwingOrderBlocksInput
deleteOrderBlocks()
if showFairValueGapsInput
drawFairValueGaps()
if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)
if showSwingOrderBlocksInput
drawOrderBlocks()
lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex
if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)
if showDailyLevelsInput and not higherTimeframe('D')
drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)
if showWeeklyLevelsInput and not higherTimeframe('W')
drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)
if showMonthlyLevelsInput and not higherTimeframe('M')
drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)
xATR = ta.atr(c)
nLoss = a * xATR
src = h ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close, lookahead = barmerge.lookahead_off) : close
xATRTrailingStop = 0.0
iff_1 = src > nz(xATRTrailingStop , 0) ? src - nLoss : src + nLoss
iff_2 = src < nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? math.min(nz(xATRTrailingStop ), src + nLoss) : iff_1
xATRTrailingStop := src > nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? math.max(nz(xATRTrailingStop ), src - nLoss) : iff_2
pos = 0
iff_3 = src > nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? -1 : nz(pos , 0)
pos := src < nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? 1 : iff_3
xcolor = pos == -1 ? color.red : pos == 1 ? color.green : color.blue
ema = ta.ema(src, 1)
above = ta.crossover(ema, xATRTrailingStop)
below = ta.crossover(xATRTrailingStop, ema)
buy = src > xATRTrailingStop and above
sell = src < xATRTrailingStop and below
barbuy = src > xATRTrailingStop
barsell = src < xATRTrailingStop
//---------------------------------------------------------------------------------------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed')
alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed')
alertcondition(buy, 'UT Long', 'UT Long')
alertcondition(sell, 'UT Short', 'UT Short')
plotshape(buy, title = 'Buy', text = 'Buy', style = shape.labelup, location = location.belowbar, color = color.new(color.green, 0), textcolor = color.new(color.white, 0), size = size.tiny)
plotshape(sell, title = 'Sell', text = 'Sell', style = shape.labeldown, location = location.abovebar, color = color.new(color.red, 0), textcolor = color.new(color.white, 0), size = size.tiny)
//--------------------------------------------------------------------------------------
// EMA ADDITIONS (Editable)
//--------------------------------------------------------------------------------------
ema5Len = input.int(5, "5 EMA Length", minval = 1)
ema9Len = input.int(9, "9 EMA Length", minval = 1)
ema5 = ta.ema(src, ema5Len)
ema9 = ta.ema(src, ema9Len)
plot(ema5, "EMA 5", color = color.red, linewidth = 2)
plot(ema9, "EMA 9", color = color.blue, linewidth = 2)
barcolor(barbuy ? color.green : na)
barcolor(barsell ? color.red : na)
HTF BIAS FILTER🧭HTF Bias Filter Indicator: 5 in 1 indicator
Technical Overview
The Bias Filter is a comprehensive multi-timeframe tool designed to confirm directional bias using five key indicators before entering a trade. It plots higher-timeframe Moving Averages directly on the chart and provides an immediate status summary via a static dashboard.
The more confluence on the dashboard, the greater the probability of the direction of the trade.
1. 📊 Display Components
A. Plotted Lines
The indicator uses the request.security function to draw Moving Averages from higher timeframes onto your current chart:
1H EMA 21 (Purple): The 21-period Exponential Moving Average calculated on the 1-Hour (60 min) chart. Plotted using a step-line style.
4H EMA 50 (Red): The 50-period Exponential Moving Average calculated on the 4-Hour (240 min) chart. Plotted using a step-line style.
B. Directional Dashboard
A fixed-position summary table is anchored to the bottom-right corner of the chart, providing a quick glance at the current status of all five filters.
2. 🎨 Colour Logic
Each of the five indicators is assigned a colour based on its current directional signal. The more indicators that show the same colour (confluence), the stronger the signal and the higher the likelihood of a high-probability trade.
🟢 Green indicators are signaling UP/BUY (Bullish momentum or trend).
🔴 Red indicators are signaling DOWN/SELL (Bearish momentum or trend).
⚫ Gray indicators are signaling Mixed or flat directions (neutral or undecided).
Note: The dashboard's main header color is determined by a strict confluence logic (All four 4H filters must align for Green/Red), while individual indicator colors follow the simple rules above.
3. 📋 Indicator Breakdown and Logic
The dashboard provides the direction of five different filters.
3.1. Higher-Timeframe (HTF) Trend Indicators
These two signals determine the immediate slope and direction of the primary Moving Averages:
4H EMA 50:
Timeframe: 4-Hour (240 min)
Logic: Compares the current EMA value to the value two bars ago on the 4H chart.
Output: UP ↑, DOWN ↓, or FLAT ⏸
1H EMA 21:
Timeframe: 1-Hour (60 min)
Logic: Compares the current EMA value to the value two bars ago on the 1H chart.
Output: UP ↑, DOWN ↓, or FLAT ⏸
3.2. 4-Hour Confluence Filters
These three indicators provide supplementary confirmation on Volume, Price Position, and Momentum, all calculated on the 4-Hour (240 min) chart:
4H OBV (Smoothed):
Timeframe: 4-Hour (240 min)
Logic: Direction is based on the current value of the 21-bar smoothed On-Balance Volume (OBV) compared to its value nine bars ago.
Output: UP ↑, DOWN ↓, or FLAT ⏸
4H ATR DIR (EMA Proxy):
Timeframe: 4-Hour (240 min)
Logic: Determines the price position by comparing the current Close price against the 4H EMA 50.
Output: BUY 🟢 (Close > EMA 50), SELL 🔴 (Close < EMA 50), or FLAT ⏸️ (Close = EMA 50).
4H RSI (14):
Timeframe: 4-Hour (240 min)
Logic: Momentum check comparing the 14-period Relative Strength Index (RSI) value against the 50 level.
Output: BUY 🟢 (RSI > 50), SELL 🔴 (RSI < 50), or FLAT ⏸️ (RSI = 50).
MTF EMA Directional Bias -1hr and 4hr A compact, fixed-position table (bottom-right corner) that shows the current slope direction of two higher-timeframe EMAs:
4H EMA 50 → direction over the last 2 bars (UP ↑, DOWN ↓, or FLAT ⏸)
1H EMA 21 → direction over the last 2 bars (UP ↑, DOWN ↓, or FLAT ⏸)
Background color logic:
Green → both 4H and 1H EMAs are sloping upward
Red → both 4H and 1H EMAs are sloping downward
Gray → mixed or flat directions (no confluence)
Additionally draws the actual 1H EMA-21 (purple) and 4H EMA-50 (red) as step-lines on the chart.
9/21 EMA Trend TOP rIGHT CORNER INDICATORCrossover indicator for the 9 & 21 EMA. Buy Sell for cross up or down respectively. Daily, weekly and Monthly trend.
GBPUSD Weekly Cross LinesThis indicator tracks 20/50 EMA crossovers on GBPUSD (Weekly timeframe) and displays the crossover points across all symbols and timeframes, allowing traders to visually align current price action with key historical turning points in GBPUSD.
The script works by detecting bullish (20 EMA crossing above 50 EMA) and bearish (20 EMA crossing below 50 EMA) signals since 2010, using request.security() to source data from GBPUSD weekly candles, even if the indicator is applied to AAPL, EURJPY, BTCUSD, or any other asset.
Each crossover is marked with a vertical line that persists across all charts, offering a powerful way to:
Compare current market context with GBPUSD’s historical trend shifts
Observe intermarket correlations
Align trading timing across multiple assets
Spot macro trend transitions that ripple across global markets
EMA 5/10/20/34/55/60/120/255Overview
- Plots eight Exponential Moving Averages on the price chart: EMA(5/10/20/34/55/60/120/255) .
- Designed for light (white) theme with high-contrast colors and uniform linewidth=1 .
- Written in Pine Script v6 ( overlay=true ), no alerts or extra visuals.
Why These Lengths
- 5, 10 : Short-term momentum and intraday rhythm.
- 20, 34 : Swing trend and pullback structure (34 is Fibonacci-based).
- 55, 60 : Deeper swing/weekly alignment commonly used by trend traders.
- 120, 255 : Mid/long-term trend filters (~half-year and ~annual trading days).
How To Read
- Trend filter: Price above EMA(120/255) favors bullish context; below favors bearish.
- Alignment: Strong bull trend when 5 > 10 > 20 > 34 > 55 > 60 > 120 > 255 and slopes up; inverse for bear trends.
- Pullbacks: Shallow pullbacks often respect 5/10 ; standard pullbacks 20/34 ; deeper tests 55/60 .
- Slope matters: Up/flat/down slopes of the longer EMAs ( 120/255 ) reflect trend strength more reliably than single crossovers.
Typical Use Cases
- Trend following: Trade in the direction of 120/255 and the stacked EMA order.
- Pullback entries: Look for stabilizing price action around 20/34 within a trend.
- Breakout confirmation: Sustain above/below a key EMA, then retest and hold.
- Risk management: Place stops beyond nearby EMAs, optionally buffered by ATR.
Tips
- Use the Data Window to identify each EMA line by its title ( EMA(5) , EMA(10) , etc.).
- Combine with volatility/strength filters (e.g., ATR, ADX) to reduce range-bound noise.
- Multi-timeframe consistency (e.g., higher TF EMA(255) aligned with current TF EMA(55/60) ) improves selectivity.
Limitations
- All moving averages are lagging by design; expect delayed signals.
- In consolidations, frequent crossovers can create whipsaws; apply filters or focus on slope and structure.
Disclaimer
- For educational purposes only. Not financial advice. Always validate on your instruments and timeframes and manage risk accordingly.
SMI Color Red/Green📌 TradingView Description – SMI Red/Green Momentum Line
🔥 Stochastics Momentum Index (SMI) – Dynamic Red/Green Version
This indicator is an enhanced and modernized version of the Stochastic Momentum Index (SMI), designed to deliver a more visual, intuitive, and responsive view of trend momentum.
It includes:
✔️ Smoothed SMI
✔️ Dynamic Red/Green momentum coloring
✔️ Signal EMA line
✔️ Overbought/Oversold zones with shading
🎨 Dynamic Red/Green SMI Line
The main SMI line automatically changes color based on momentum direction:
Green → Bullish momentum (SMI rising)
Red → Bearish momentum (SMI falling)
This provides instant visual feedback and highlights early momentum changes even before traditional signal-line crossovers.
📉 Indicator Structure
1️⃣ Smoothed SMI
The SMI is calculated using the price’s position inside its range and then smoothed with an SMA to reduce noise.
2️⃣ EMA Signal Line
A customizable EMA acts as a signal line, providing:
Clear bullish/bearish crossovers
Trend confirmation
Cleaner entry/exit signals
3️⃣ Overbought / Oversold Zones
Extreme levels are highlighted using color-filled zones:
Red Zone (Overbought) → potential bearish reversal
Green Zone (Oversold) → potential bullish reversal
Levels are fully adjustable.
💡 How to Use It
The indicator works exceptionally well across all timeframes.
The most powerful signals are:
✔️ SMI crossing above/below the EMA
SMI crosses above EMA → bullish signal
SMI crosses below EMA → bearish signal
✔️ Leaving Overbought/Oversold zones
SMI exits the oversold zone → potential long setup
SMI exits the overbought zone → potential short setup
✔️ Color shifts (momentum direction)
Red → Green : early bullish momentum
Green → Red : early bearish momentum
Perfect for scalping, day trading, and swing trading.
🚀 Why This Version Is Better
Extremely visual momentum reading
Noise reduction through smoothing
Instantly readable color-coded trend
Strong OB/OS zone visualization
Works on any market and timeframe
Great in combination with RSI, MACD, HMA, ALMA, and trend filters
If you'd like, I can also write:
🔹 a SEO-optimized title,
🔹 recommended TradingView tags,
🔹 or a shorter promotional description.
Hash Momentum IndicatorHash Momentum Indicator
Overview
The Hash Momentum Indicator provides real-time momentum-based trading signals with visual entry/exit markers and automatic risk management levels. This is the indicator version of the popular Hash Momentum Strategy, designed for traders who want signal alerts without backtesting functionality.
Perfect for: Live trading, automation via alerts, multi-indicator setups, and clean chart visualization.
What Makes This Indicator Special
1. Pure Momentum-Based Signals
Captures price acceleration in real-time - not lagging moving average crossovers. Enters when momentum exceeds a dynamic ATR-based threshold, catching moves as they begin accelerating.
2. Automatic Risk Management Visualization
Every signal automatically displays:
Entry level (white dashed line)
Stop loss level (red line)
Take profit target (green line)
Partial TP levels (dotted green lines)
3. Smart Trade Management
Trade Cooldown: Prevents overtrading by enforcing waiting period between signals
EMA Trend Filter: Only trades with the trend (optional)
Session Filters: Trade only during Tokyo/London/New York sessions (optional)
Weekend Toggle: Avoid low-liquidity weekend periods (optional)
4. Clean Visual Design
🟢 Tiny green dot = Long entry signal
🔴 Tiny red dot = Short entry signal
🔵 Blue X = Long exit
🟠 Orange X = Short exit
No cluttered labels or dashboard - just clean signals
5. Professional Alerts Ready
Set up TradingView alerts for:
Long signals
Short signals
Long exits
Short exits
How It Works
Step 1: Calculate Momentum
Momentum = Current Price - Price
Normalized by standard deviation for consistency
Must exceed ATR × Threshold to trigger
Step 2: Confirm Acceleration
Momentum must be increasing (positive momentum change)
Price must be moving in signal direction
Step 3: Apply Filters
EMA Filter: Long only above EMA, short only below EMA (if enabled)
Session Filter: Check if in allowed trading session (if enabled)
Weekend Filter: Block signals on Sat/Sun (if enabled)
Cooldown: Ensure minimum bars passed since last signal
Step 4: Generate Signal
All conditions met = Entry signal fires
Lines automatically drawn for entry, stop, and targets
Step 5: Exit Detection
Opposite momentum detected = Exit signal
Stop loss or take profit hit = Exit signal
Lines removed from chart
⚙️ Settings Guide
Core Strategy
Momentum Length (Default: 13)
Number of bars for momentum calculation. Higher values = stronger signals but fewer trades.
Aggressive: 10
Balanced: 13
Conservative: 18-24
Momentum Threshold (Default: 2.25)
ATR multiplier for signal generation. Higher values = only trade the biggest momentum moves.
Aggressive: 2.0
Balanced: 2.25
Conservative: 2.5-3.0
Risk:Reward Ratio (Default: 2.5)
Your target profit as a multiple of your risk. With 2.2% stop and 2.5 R:R, your target is 5.5% profit.
Conservative: 3.0+ (need 25% win rate to profit)
Balanced: 2.5 (need 29% win rate to profit)
Aggressive: 2.0 (need 33% win rate to profit)
