Market Structure (DeadCat)🌟 Market Structure (DeadCat) - Indicator Overview 🌟
The Market Structure (DeadCat) indicator plots swing highs and lows (HH, HL, LH, LL) using pivot points, helping you spot uptrends, downtrends, and potential reversals. Perfect for traders who use market structure.
🌟 Key Features 🌟
🔹 Swing Point Labels
HH (Higher High): Signals uptrend strength.
HL (Higher Low): Marks bullish support.
LH (Lower High): Hints at weakening uptrend or reversal.
LL (Lower Low): Confirms downtrend momentum.
🔹 Trend Detection
Uptrend: Tracks HH/HL for bullish momentum.
Downtrend: Tracks LH/LL for bearish momentum.
Waits for breaks of prior HH/HL or LH/LL to confirm new swing points, ensuring reliable signals. 🔄
🔹 Customizable Labels
Adjust label text color (default: black) to suit your chart. Supports up to 500 labels for a clean, focused view. 🖌️
🌟 Indicator Settings 🌟
Swing Length: Fixed at 20 bars (left) and 2 bars (right) for pivot detection.
Label Color: Customize text color for better visibility.
Indicadores e estratégias
Swing Point Volume Z-ScoreSWING POINT VOLUME Z-SCORE INDICATOR
A volume analysis tool that identifies statistical volume spikes at swing points with optional higher timeframe confirmation.
This indicator uses Leviathan's method of swing detection. All credit to him for his amazing work (and any mistakes mine). I was also inspired by Trading Riot, who's Capitulation indicator gave me the idea to create this one.
WHAT IT DOES
This indicator combines three analytical approaches:
- Volume Z-score calculation to measure volume significance statistically
- Automatic swing point detection (higher highs, lower lows, etc.)
- Optional higher timeframe volume confirmation
The Z-score measures how many standard deviations current volume is from the average, helping identify when volume activity is genuinely elevated rather than relying on visual assessment.
VISUAL SYSTEM
The indicator uses a color-coded approach for quick assessment:
GREEN - Normal Activity (Z-Score 1.0-2.0)
Above-average volume levels
ORANGE - Elevated Activity (Z-Score 2.0-3.0)
High volume activity that may indicate increased interest
RED - Potential Institutional Activity (Z-Score 3.0+)
Very high volume levels that could suggest significant market participation
HIGHER TIMEFRAME CONFIRMATION
When enabled, the indicator checks volume on a higher timeframe:
- Checkmark symbol indicates HTF volume also shows elevation
- X symbol indicates HTF volume doesn't confirm
- Auto-selects appropriate higher timeframe or allows manual selection
KEY FEATURES
Statistical Approach: Uses Z-score methodology rather than arbitrary volume thresholds
Adaptive Thresholds: Can adjust based on market volatility conditions
Swing Focus: Concentrates analysis on structurally important price levels
Volume Trends: Shows whether volume is accelerating or decelerating
Success Tracking: Monitors how often HTF confirmation proves effective
DISPLAY OPTIONS
Basic Mode: Essential features with clean interface
Advanced Mode: Additional customization and analytics
Label Sizing: Four size options to fit different screen setups
Table Position: Moveable info table with transparency control
Custom Colors: Adjustable for different chart themes
PRACTICAL APPLICATIONS
May help identify:
- Volume spikes at support/resistance levels
- Potential accumulation or distribution zones
- Breakout confirmation with volume backing
- Areas where larger market participants might be active
Works on all liquid markets and timeframes, though generally more effective on 15-minute charts and higher.
USAGE NOTES
This is an analytical tool that highlights statistically significant volume events. It should be used as part of a broader analysis approach rather than as a standalone trading system.
The indicator works best when combined with:
- Price action analysis
- Support and resistance identification
- Trend analysis
- Proper risk management
Default settings are designed to work well across most instruments, but users can adjust parameters based on their specific needs and trading style.
TECHNICAL DETAILS
Built with Pine Script v5
Compatible with all TradingView subscription levels
Open source code available for review and learning
Works on stocks, forex, crypto, futures, and other liquid instruments
The statistical approach helps remove some subjectivity from volume analysis, though like all technical indicators, it should be used thoughtfully as part of a complete trading plan.
nkh Multi-TF S/RThis script create a specific marking for each time frame, change pivot to adjust mark.
nkh.
RSI Momentum Divergence Zones [ChartPrime]⯁ OVERVIEW
RSI Momentum Divergence Zones is a hybrid oscillator and chart overlay tool that detects RSI-based momentum divergences and projects them as key zones on the chart. By combining RSI divergence logic with horizontal level plotting, this indicator reveals high-probability support and resistance areas where price has historically reacted to hidden or classic divergences.
⯁ KEY FEATURES
Momentum-Based RSI Source:
Instead of the classic RSI input, this tool uses the momentum of price as the RSI source:
rsiSrc = ta.mom(close, 10)
This emphasizes acceleration and deceleration of price moves, sharpening divergence signals and making them more responsive to early shifts in momentum.
Automatic Divergence Detection (Optional):
When enabled, the indicator continuously scans for:
— Bullish Divergence : Price makes a Lower Low while RSI forms a Higher Low
— Bearish Divergence : Price makes a Higher High while RSI forms a Lower High
It ensures divergence is valid by checking the spacing between pivots (min 5, max 50 bars).
Divergence Labels & Markers (RSI Pane + Chart):
When a valid divergence is detected:
— On RSI pane:
Labels appear at HL/LH points (“Bull” / “Bear”)
Colored lines show pivot structures
— On price chart:
Labels (“▲ Bull” / “Bear ▼”) mark price pivot that triggered the divergence
Lines highlight the exact price level at the divergence origin
Divergence Zones / Levels (Toggleable):
The indicator projects horizontal zones across the chart based on confirmed divergence points.
These levels dynamically extend as long as price respects them, and auto-expire once broken.
They act as S/R levels created by market imbalance caused by divergence reactions.
Dynamic Zone Extension Logic:
Once plotted, divergence levels will extend to the right:
— If price respects the level, the zone keeps growing
— If broken in the opposite direction, the level stops extending and turns dashed (visually showing break)
Zone Layering and Limit Control:
You can limit the number of simultaneous zones shown on the chart (e.g., 10 most recent).
Old zones automatically expire and are removed to keep the chart clean and focused.
Color Customization and Intensity:
Different colors for bullish and bearish zones let you easily distinguish trend direction.
Background fill, line width, and transparency are all adjustable.
Clean Zone Management with Arrays:
Behind the scenes, the script uses custom divLevel type arrays to manage plotted levels, ensuring they stay up-to-date, extend correctly, and delete once invalidated.
⯁ USAGE
Use bullish divergence zones as potential demand areas and bearish ones as supply zones.
Combine RSI pane labels with price-level zones to confirm strength of reversal.
Watch for price approaching a divergence level to anticipate reactions or breakouts.
Use divergence levels as trade triggers, stop-loss guides, or take-profit markers.
Limit signal count using the “Qty Divergence Zones” setting to reduce chart clutter.
Enable divergence detection only when you want to focus on key structural zones — ideal for swing or positional setups.
⯁ CONCLUSION
RSI Momentum Divergence Zones blends oscillator divergence logic with price action structure to uncover hidden strength or weakness in the market. With flexible zone plotting and clean visual signals, this tool empowers traders to identify where momentum turns into structure — turning hidden signals into tradable edges.
Adan Confirmed Bullish Divergence (v1.1) — No RepaintAdan Confirmed Bullish Divergence (v1.1) — No Repaint
Momentum_EMABand📢 Reposting Notice
I am reposting this script because my earlier submission was hidden due to description requirements under TradingView’s House Rules. This updated version fully explains the originality, the reason for combining these indicators, and how they work together. Follow me for future updates and refinements.
🆕 Momentum EMA Band, Rule-Based System
Momentum EMA Band is not just a mashup — it is a purpose-built trading tool for intraday traders and scalpers that integrates three complementary technical concepts into a single rules-based breakout & retest framework.
Originality comes from the specific sequence and interaction of these three filters:
Supertrend → Sets directional bias.
EMA Band breakout with retest logic → Times precise entries.
ADX filter → Confirms momentum strength and avoids noise.
This system is designed to filter out weak setups and false breakouts that standalone indicators often fail to avoid.
🔧 How the Indicator Works — Combined Logic
1️⃣ EMA Price Band — Dynamic Zone Visualization
Plots upper & lower EMA bands (default: 9-period EMA).
Green Band → Price above upper EMA = bullish momentum
Red Band → Price below lower EMA = bearish pressure
Yellow Band → Price within band = neutral zone
Acts as a consolidation zone and breakout trigger level.
2️⃣ Supertrend Overlay — Reliable Trend Confirmation
ATR-based Supertrend adapts to volatility:
Green Line = Uptrend bias
Red Line = Downtrend bias
Ensures trades align with the prevailing trend.
3️⃣ ADX-Based No-Trade Zone — Choppy Market Filter
Manual ADX calculation (default: length 14).
If ADX < threshold (default: 20) and price is inside EMA Band → gray background marks low-momentum zones.
🧩 Why This Mashup Works
Supertrend confirms trend direction.
EMA Band breakout & retest validates the breakout’s strength.
ADX ensures the market has enough trend momentum.
When all align, entries are higher probability and whipsaws are reduced.
📈 Example Trade Walkthrough
Scenario: 5-minute chart, ADX threshold = 20.
Supertrend turns green → trend bias is bullish.
Price consolidates inside the yellow EMA Band.
ADX rises above 20 → trend momentum confirmed.
Price closes above the green EMA Band after retesting the band as support.
Entry triggered on candle close, stop below band, target based on risk-reward.
Exit when Supertrend flips red or ADX momentum drops.
This sequence prevents premature entries, keeps trades aligned with trend, and avoids ranging markets.
🎯 Key Features
✅ Multi-layered confirmation for precision trading
✅ Built-in no-trade zone filter
✅ Fully customizable parameters
✅ Clean visuals for quick decision-making
⚠ Disclaimer: This is Version 1. Educational purposes only. Always use with risk management.
CPI ALERT JOIN TO GET HUGE PROFIT [CPI]📢 Today’s U.S. CPI Report is Out! 📢
The latest Consumer Price Index numbers have been released, and the market is ready for explosive moves! 📈 This report is one of the biggest market movers for Gold, Forex, and Crypto, and today’s volatility could create massive profit opportunities.
💡 Don’t miss out!
📌 Join our Telegram Channel NOW to get instant trade signals, real-time market analysis, and expert strategies designed to help you capture HUGE profits from this news.
🚀 The market is moving fast — secure your advantage and trade like the pros!
🔗
Market Open Impulse [LuciTech]Market Open Impulse Strategy
The Market Open Impulse Strategy is designed to capture significant price movements that occur at market open (2:30 PM UK time). This strategy identifies impulsive candles with high volatility and enters trades based on the direction and strength of the initial market reaction.
How It Works:
The strategy activates exclusively at 2:30 PM UK time during market open sessions. It uses ATR-based volatility filtering to identify impulsive candles that exceed a configurable multiplier (default 1.5x ATR). Long entries are triggered when an impulsive candle closes above its midpoint and above the opening price, while short entries occur when an impulsive candle closes below its midpoint and below the opening price.
Risk management is handled through precise stop loss placement at the opposite extreme of the impulse candle (high for short positions, low for long positions). Take profit levels are calculated using a configurable risk-reward ratio with a default setting of 3:1. Position sizing is automatically calculated based on the percentage risk per trade, and an optional breakeven feature can move the stop loss to the entry price at specified profit levels.
The strategy incorporates time-based filtering to ensure trades only occur during the specified market open window. Visual indicators highlight qualifying impulsive candles and plot all entry and exit levels for clear trade management. The system offers flexible risk management with customizable risk percentage, risk-reward ratios, and breakeven settings, along with multiple stop loss calculation methods including both ATR-based and candle-based options.
Key Parameters:
Market open timing is fully configurable through hour and minute settings for strategy activation. The impulse ATR multiple sets the minimum volatility threshold required for trade qualification, with visual highlighting available for qualifying setups. Risk management parameters include the percentage of account equity to risk per trade, target profit multiples relative to initial risk, and the profit level threshold for breakeven stop loss adjustment. Users can choose between ATR-based or candle-based stop loss calculation methods and adjust technical parameters for volatility calculation including ATR length and smoothing methods.
Applications:
This strategy is particularly effective for trading market open volatility and momentum, capturing institutional order flow during key timing windows, executing short-term swing trades on significant price impulses, and trading markets with predictable opening patterns and consistent volatility characteristics.
Crude Oil Option Auto Hedge made by govindits help for crudeoil option trading and you can easily decide
TRI - Smart Zones============================================================================
# TRI - SMART ZONES v2.0
## Professional Smart Money Concepts Indicator for Pine Script v6
============================================================================
## 📊 OVERVIEW
**TRI - Smart Zones** is a comprehensive Smart Money Concepts indicator that
combines multiple institutional trading concepts into a single, powerful tool.
Built with Pine Script v6 for optimal performance and reliability.
## 🎯 CORE FEATURES
### **Fair Value Gaps (FVG)**
- **Detection**: Automatic identification of price imbalances
- **Types**: Bullish and Bearish Fair Value Gaps
- **Threshold**: Customizable gap size requirements (0.1% default)
- **Extension**: Configurable zone projection length
- **Mitigation**: Real-time tracking of gap fills
### **Order Blocks (OB)**
- **Detection**: Volume-based institutional footprint identification
- **Types**: Bullish and Bearish Order Blocks
- **Method**: Pivot-based volume analysis with configurable lookback
- **Validation**: Market structure confirmation required
- **Extension**: Adjustable zone projection
### **BSL/SSL Liquidity Levels**
- **Multi-Timeframe**: Automatic higher timeframe reference
- **Dynamic**: Real-time level updates and extensions
- **Visual**: Clear line markings with timeframe labels
- **Smart**: Adaptive timeframe selection based on current chart
### **Fibonacci Extensions**
- **ZigZag Integration**: Advanced pivot point detection
- **Levels**: Customizable Fibonacci ratios (38.2%, 61.8%, 100%, 161.8%)
- **Projection**: Dynamic extension from swing points
- **Visual**: Subtle dashed lines with level/price labels
### **Smart Dashboard**
- **Zone Statistics**: Real-time FVG and OB counts
- **Success Rates**: Mitigation percentages for each zone type
- **Market Bias**: Intelligent bullish/bearish/neutral assessment
- **Positioning**: Customizable location and size
### **Zone Analysis Engine**
- **Technical Confluence**: RSI, ADX, ATR, Volume analysis
- **VWAP Integration**: Institutional price reference
- **Confidence Scoring**: High/Mid/Low signal classification
- **Signal Arrows**: Visual trade direction indicators
## 🔔 ALERT SYSTEM
### **Market Structure Alerts**
- `Market Bias Changed` - Shift in overall market sentiment
- `BSL Touched` - Buy Side Liquidity level reached
- `SSL Touched` - Sell Side Liquidity level reached
### **Zone Touch Alerts**
- `OB Touched` - Any Order Block interaction
- `Bullish OB Touched` - Bullish Order Block touch
- `Bearish OB Touched` - Bearish Order Block touch
- `FVG Touched` - Any Fair Value Gap interaction
- `Bullish FVG Touched` - Bullish FVG touch
- `Bearish FVG Touched` - Bearish FVG touch
- `Zone Touched` - Any Smart Zone interaction
- `Bullish Zone Touched` - Any bullish zone touch
- `Bearish Zone Touched` - Any bearish zone touch
## ⚙️ CONFIGURATION
### **Zone Detection**
- Enable/disable FVG and OB detection independently
- Maximum zones per type (3-15, default: 8)
- Zone-specific threshold and extension settings
### **Visual Customization**
- Individual color schemes for each zone type
- Adjustable transparency levels
- Configurable line styles and widths
- Dashboard positioning and sizing options
### **Technical Analysis**
- RSI, ADX, ATR period customization
- Volume threshold multipliers
- Confidence level color coding
- Signal display toggle
## 🚀 PINE SCRIPT v6 OPTIMIZATIONS
- **User-Defined Types**: Structured data for zones and statistics
- **Methods**: Type-specific operations for better code organization
- **Enhanced Arrays**: Optimized memory management
- **Switch Statements**: Improved performance for zone classification
- **Error Handling**: Robust input validation and edge case management
- **Performance**: Efficient algorithms for real-time analysis
## 📈 TRADING APPLICATIONS
### **Entry Strategies**
- Zone confluence for high-probability setups
- Multi-timeframe confirmation via BSL/SSL
- Fibonacci extension targets
- Signal arrows for directional bias
### **Risk Management**
- Zone mitigation for stop-loss placement
- Market bias for position sizing
- Dashboard statistics for strategy validation
### **Market Analysis**
- Institutional footprint identification
- Liquidity level mapping
- Market structure assessment
- Trend continuation vs reversal analysis
## 🔧 TECHNICAL SPECIFICATIONS
- **Version**: Pine Script v6
- **Overlay**: True (draws on price chart)
- **Max Objects**: 100 boxes, 100 lines, 50 labels
- **Performance**: Optimized for real-time analysis
- **Compatibility**: All TradingView chart types and timeframes
SMT Oscillator: Smarter Money Divergence Detector [PhenLabs]📊Phenlabs - SMT Oscillator: Smarter Money Divergence Detector
Version: PineScript™v6
📌Description
The SMT Oscillator is a sophisticated tool designed to identify smart money divergence between two correlated assets. By analyzing the momentum and volume-weighted price action of a primary and secondary symbol, traders can spot subtle shifts in market dynamics that often precede significant price movements. This indicator is built to provide a clearer, more filtered view of inter-market relationships, solving the common problem of false signals and market noise. Its primary purpose is to equip traders with a quantifiable edge in detecting potential reversals or continuations that are not obvious on a standard price chart.
🚀Points of Innovation
Dual-Symbol Divergence Core: Directly compares momentum (RSI or MACD) between two user-selected symbols to pinpoint true SMT divergence.
Volume-Weighted Analysis: Integrates volume delta into the divergence calculation, giving more weight to moves backed by significant market participation.
Entropy Filter for Noise Reduction: Employs an entropy calculation to filter out low-quality signals during choppy or consolidating market conditions.
Predictive Forecast Line: Utilizes a linear regression model to project the oscillator’s future trajectory, offering a forward-looking glimpse of potential momentum shifts.
Customizable Signal Sensitivity: Allows fine-tuning of overbought and oversold levels to adapt to different market volatilities and trading styles.
Integrated Signal Alerts: Provides built-in alerts for bullish/bearish zero crosses and overbought/oversold conditions.
🔧Core Components
Momentum Engine: The user can select either RSI or MACD as the underlying engine for the divergence calculation, allowing for flexibility in analysis.
Normalization Function: Price data from both symbols is normalized using percentage change to ensure a true “apples-to-apples” comparison, regardless of their nominal price differences.
Divergence Calculator: The core algorithm that subtracts the secondary symbol’s momentum from the primary’s and normalizes the result using the combined standard deviation.
Smoothing Mechanism: An Exponential Moving Average (EMA) is applied to the raw oscillator output to reduce choppiness and provide a clearer signal line.
🔥Key Features
Multi-Asset Comparison: Go beyond single-asset analysis by comparing correlated pairs like ES/NQ or BTC/ETH to uncover hidden trading opportunities.
Heatmap Visualization: An optional heatmap mode provides an intuitive visual representation of divergence strength, making it easier to gauge market sentiment at a glance.
Configurable Lookback and Timeframe: Adjust the lookback period and analysis timeframe to suit your specific strategy, from short-term scalping to long-term trend analysis.
Signal Markers: Visual markers are plotted directly on the chart for bullish and bearish zero-line crossovers, providing clear entry and exit signals.
🎨Visualization
SMT Oscillator Line: The primary visual element, colored blue for bullish (positive) divergence and orange for bearish (negative) divergence.
Zero Line: A solid horizontal line at the zero level, indicating the equilibrium point between the two assets. Crossovers of this line signal a shift in relative strength.
Overbought/Oversold Zones: Dotted lines at the +80 and -80 levels (customizable) that highlight extreme divergence readings, often indicating potential exhaustion points.
Forecast Line: A predictive line that plots the anticipated path of the oscillator, giving traders an advanced warning of potential changes in momentum.
📖Usage Guidelines
Setting Categories
Primary Symbol
Default: (Chart Symbol)
Description: The main asset you are analyzing. Leave blank to use the symbol currently on your chart.
Secondary Symbol
Default: CME_MINI:ES1! (used with NASDAQ futures due to inherent heavy correlation
Description: The asset to compare against the primary symbol.
Lookback Period
Default: 14
Range: 8-100
Description: Controls the calculation window for momentum (RSI/MACD). Higher values result in a smoother, less sensitive oscillator.
Divergence Type
Default: RSI
Options: RSI, MACD
Description: Choose the momentum indicator to use for the divergence calculation.
Enable Volume Weighting
Default: true
Description: When enabled, gives more weight to divergence signals that are accompanied by significant volume.
✅Best Use Cases
Identifying high-probability reversal points by spotting divergence in overbought or oversold territory.
Confirming the strength of a trend by observing sustained positive or negative divergence.
Pairs trading by taking a long position on the outperforming asset and a short position on the underperforming one during a divergence.
Risk management by recognizing when a current trend is losing its underlying momentum.
⚠️Limitations
Requires Correlated Assets: The indicator’s effectiveness is highly dependent on the selection of two assets with a known correlation (e.g., ES and NQ).
Not a Standalone System: Divergence signals should be used in conjunction with other forms of analysis (price action, market structure) and not as a complete trading system.
Lagging by Nature: As it is based on moving averages and past price data, the oscillator is inherently lagging and may not capture all rapid price changes.
💡What Makes This Unique
Combined Momentum & Volume: Unlike standard oscillators, it fuses momentum with volume delta for a more robust “Smart Money” perspective.
Noise-Filtering Mechanism: The proprietary entropy filter is a unique feature designed to weed out insignificant market chatter and focus on high-conviction signals.
🔬How It Works
Data Normalization:
The script first normalizes the price data of the two selected symbols into percentage changes. This ensures that the comparison is fair, regardless of the difference in their price scales.
Momentum Calculation:
It then calculates the chosen momentum value (either RSI or MACD histogram) for each of the normalized price series.
Divergence Computation:
The core of the indicator lies in subtracting the momentum of the secondary symbol from the primary one. This raw divergence is then optionally weighted by volume and filtered for market noise (entropy) to produce the final oscillator value.
💡Note:
For best results, use this indicator on adequate timeframes to filter out market noise. Always confirm signals with price action analysis before entering a trade.
All-Time High/Low Levels with Dynamic Price Zones📈 All-Time High/Low Levels with Dynamic Price Zones — AlertBlake
🧠 Overview:
This powerful indicator automatically identifies and draws the All-Time High (AT.H) and All-Time Low (AT.L) on your chart, providing a clear visual framework for price action analysis. It also calculates and displays the Midpoint (50%), Upper Quartile (75%), and Lower Quartile (25%) levels, creating a dynamic grid that helps traders pinpoint key psychological levels, support/resistance zones, and potential breakout or reversal areas.
✨ Features:
Auto-Detection of All-Time High and Low:
Tracks the highest and lowest prices in the full visible historical range of the chart.
Automatically updates as new highs or lows are created.
Dynamic Level Calculation:
Midpoint (50%): Halfway between AT.H and AT.L.
25% Level: 25% between AT.L and AT.H.
75% Level: 75% between AT.L and AT.H.
Each level is clearly labeled with its corresponding value.
Labels are positioned to the right of the price for easy reading.
Color-Coded Lines (customizable)
Apex Edge – Liquidity RaiderApex Edge – Liquidity Raider
The Predator That Hunts Where Retail Never Looks
The Liquidity Raider is not your average liquidity line plotter.
This is an institutional-grade hunting system that tracks the pools of liquidity Smart Money algos stalk — and tells you exactly when price is circling in for the strike.
Where most retail tools simply mark lines, this one acts like a predator:
Scans the chart dynamically to detect clustered highs & lows (pivot-based liquidity zones).
Filters noise with sensitivity & price rounding so you only get real liquidity levels — not every random swing.
Plots live BSL (Buy-Side Liquidity) & SSL (Sell-Side Liquidity) lines in clean dotted format.
Auto-deletes levels when swept, so your chart stays clean and focused.
Triggers directional arrows when price comes within your specified % distance to the target liquidity pool — before the market moves.
EMA confluence layer lets you align with institutional flow (customizable Fast & Slow EMAs).
Core Power
Cluster Logic – Finds high-probability liquidity zones using repeated pivot levels.
Sweep Awareness – Lines vanish the moment liquidity is taken, keeping focus on the next pool.
Proximity Strike Detection – Arrow signals only when price is within striking range.
Directional Clarity – Red arrows = targeting BSL, Green arrows = targeting SSL.
Scalable Across Timeframes – Adapts to your chart’s timeframe with dynamic lookback scaling.
Institutional Flow Filter – Optional EMA confirmation keeps you aligned with the real trend.
How to Use
Identify liquidity pools – Dotted green = buy-side, dotted red = sell-side.
Watch proximity arrows – These mean price is in range and hunting that pool.
Align with EMA bias – Enter only in the direction of institutional momentum.
Target the sweep – Your take profit is where the liquidity is resting.
Why Liquidity Raider Wins
This is not a lagging signal system.
It’s a real-time, clean, predictive tool designed to mimic the targeting logic of high-frequency algos.
By removing swept levels and focusing only on the next available pools, Liquidity Raider keeps you one step ahead of the crowd — and perfectly positioned for the kill shot.
ATAI Triangles — Volume-Based & Price Pattern Analysis (v1.01)ATAI Triangles — Volume-Based & Price Pattern Analysis (v1.01)
Overview
ATAI Triangles identifies two synchronized triangle structures — Hi-Lo-Hi (HLH) and Lo-Hi-Lo (LHL) — and analyzes them both geometrically and volumetrically. For each triangle, volume is split between its two legs (segments), providing interpretable insights into buyer vs seller activity along each path.
The idea is that certain geometric shapes, when paired with volume distribution on each leg, can reveal patterns worth exploring. Users are encouraged to share their observations and interpretations in the TradingView comments section so that more aspects of these triangle combinations can be discovered collectively.
Extra (for fun)
For a bit of entertainment, we’ve included a symbolic “hexagram” glyph that appears when both triangle types align in a particular way — it’s just a visual nod to geometry and has no predictive or trading value.
Interface & data clarity
- Inputs and parameters are organized by function (pattern geometry, volume analysis, visuals, HUD, labels).
- Each input includes tooltips explaining its purpose, units, and possible effects on calculations.
- All on-chart objects (polylines, labels, connectors) are named and colored to reflect their role, with volume values formatted in engineering notation (K, M, B).
- HUD columns and label texts use concise terms and consistent units, so that every displayed value is directly traceable to a calculation in the code.
- Daily and lower-timeframe volume series are clearly separated, with update logic documented to indicate intrabar provisional values vs finalized bar-close values.
Usage notes
Designed to be used alongside other indicators and chart tools for context; it is not a standalone signal generator.
All Buy/Sell volumes are absolute (non-negative); Δ = Buy − Sell.
Intrabar values update live and finalize at bar close (no repaint after close).
Disclaimer
For research, discussion, and educational purposes only. This is not financial advice and does not guarantee any outcome. Trade at your own risk.
Nifty Smart Zones & Breakout Bars(5min TF only) by Chaitu50cNifty Smart Zones & Breakout Bars is a purpose-built intraday trading tool, tested extensively on Nifty50 and recommended for Nifty50 use only.
All default settings are optimised specifically for Nifty50 on the 5-minute timeframe for maximum accuracy and clarity.
Why Last Bar of the Session Matters
The last candle of a trading session often represents the final battle between buyers and sellers for that day.
It encapsulates closing sentiment, influenced by end-of-day positioning, profit booking, and institutional activity.
The high and low of this bar frequently act as strong intraday support/resistance in the following sessions.
Price often reacts around these levels, especially when combined with volume surges.
Core Features
Session Last-Candle Zones
Plots a horizontal box at the high and low of the last candle in each session.
Boxes extend to the right to track carry-over levels into new sessions.
Uses a stateless approach — past zones reappear if relevant.
Smart Suppression System
When more than your Base Sessions (No Suppression) are shown, newer zones overlapping or within a proximity distance (in points) of older zones are hidden.
Older zones take priority, reducing chart clutter while keeping critical levels.
Breakout Bar Coloring
Highlights breakout bars in four categories:
Up Break (1-bar)
Down Break (1-bar)
Up Break (2-bar)
Down Break (2-bar)
Breakouts use a break buffer (in ticks) to filter noise.
Toggle coloring on/off instantly.
Volume Context (User Tip)
For best use, pair with volume analysis.
High-volume breakouts from last-session zones have greater conviction and can signal sustained momentum.
Usage Recommendations
Instrument: Nifty50 only (tested & optimised).
Timeframe: 5-minute chart for best results.
Approach:
Watch for price interaction with the plotted last-session zones.
Combine zone breaks with bar color signals and volume spikes for higher-probability trades.
Use suppression to focus on key, non-redundant levels.
Why This Tool is Different
Unlike standard support/resistance plotting, this indicator focuses on session-closing levels, which are more reliable than arbitrary highs/lows because they capture the final market consensus for the session.
The proximity-based suppression ensures your chart stays clean, while breakout paints give instant visual cues for momentum shifts.
Scalping Indicator (EMA + RSI)Buy and Sell Signals. Use with Supply and Demand to find good entries. Do not rely solely on this signal. Monitors with short and long EMA cross along with oversold or overbought RSI.
free course 98304 24602// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) creativecommons.org
// best signal
//@version=5
indicator('free course 98304 24602', overlay = true, max_bars_back = 1500, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
//--------------------------------------------------------------------------------------------------------------------}
// Settings
//---------------------------------------------------------------------------------------------------------------------{
disp = display.all - display.status_line
rpGR = 'Profile Generic Settings'
Showprofle = input.bool(true, 'Show Profile', group = 'Indicator option', display = disp)
rpLN = input.int(200, '  Lookback Length / Fixed Range', minval = 10, maxval = 1500, step = 10 , group = rpGR, display = disp)
rpLN := last_bar_index > rpLN ? rpLN - 1 : last_bar_index
vpSRC = input.string('Volume', '  Profile Source', options = , group = rpGR, display = disp)
vpGR = 'Profile Presentation Settings'
vpTP = 'displays total trading activity/money flow (common interest, both buying and selling trading activity/money flow) over a specified time period at specific price levels ' +
' - high traded node rows : high trading activity/money flow price levels - usually represents consolidation levels (value areas) ' +
' - average traded node rows : average trading activity/money flow price levels ' +
' - low traded node rows : low trading activity/money flow price levels - usually represents supply & demand levels or liquidity levels ' +
'row lengths, indicates the amount of the traded activity/money flow at specific price levels'
vpSH = input.bool(true, 'Volume/Money Flow Profile', group = vpGR, tooltip = vpTP, display = disp)
vpHVC = input.color(color.new(#ffeb3b, 50), '  High Traded Nodes', inline = 'VP1', group = vpGR)
vpHVT = input.int(53, 'Threshold %' , minval = 50, maxval = 99 , step = 1,inline = 'VP1', group = vpGR, tooltip = 'option range ', display = disp) / 100
vpAVC = input.color(color.new(#2962ff, 50), '  Average Traded Nodes', group = vpGR)
vpLVC = input.color(color.new(#f23645, 50), '  Low Traded Nodes', inline = 'VP2', group = vpGR)
vpLVT = input.int(37, 'Threshold %' , minval = 10, maxval = 40 , step = 1,inline = 'VP2', group = vpGR, tooltip = 'option range ', display = disp) / 100
spTP = 'displays the sentiment, the dominat party over a specified time period at the specific price levels ' +
' - bullish node rows : buying trading activity/money flow is higher ' +
' - barish node rows : selling trading activity/money flow is higher ' +
'row lengths, indicates the strength of the buyers/sellers at the specific price levels'
spSH = input.bool(false, 'Sentiment Profile', group = vpGR, tooltip = spTP)
spPTT = 'conditions used to calculate the up/down volume/money flow ' +
'* bar polarity up => if close > open down => if close <= open ' +
'* bar buying/selling pressure up => if (close - low) > (high - close) down => if (close - low) <= (high - close)'
spPT1 = 'Bar Polarity'
spPT2 = 'Bar Buying/Selling Pressure'
spPTY = input.string(spPT1, '  Sentiment Polarity Method', options = , group = vpGR, tooltip = spPTT, display = disp)
spBLC = input.color(color.new(#26a69a, 50), '  Bullish Nodes', inline = 'SP', group = vpGR)
spBRC = input.color(color.new(#ef5350, 50), 'Bearish Nodes', inline = 'SP', group = vpGR)
hmSH = input.bool(false, 'Profile Heatmap', group = vpGR, tooltip = 'tip : higher number of rows results with a better visuals')
hmSO1 = 'Volume/Money Flow Profile'
hmSRC = input.string(hmSO1, '  Heatmap Source', options = , group = vpGR, display = disp)
hmTR = input.int(73, '  Heatmap Transparency' , minval = 0, maxval = 100 , group = vpGR, display = disp)
othGR = 'Other Presentation Settings'
pcTP = 'displays the price level of the highest traded activity/money flow or the changes of the price levels with the highest traded activity/money flow'
rpPC = input.string('Last(Zone)', '  Level of Significance', options = , inline='PoC', group = othGR, tooltip = pcTP, display = disp)
vaSH = input.bool(false, 'Consolidation Zones', group = othGR, display = disp)
vaTH = input.int(25, '  Consolidation Threshold %' , minval = 0, maxval = 100, inline = 'va', group = othGR, display = disp) / 100
vaC = input.color(color.new(#2962ff, 73), '', inline = 'va', group = othGR)
spTT = 'displays the price zone of the highest bullish or bearish sentiment zone'
spPC = input.bool(false, 'Highest Sentiment Zone', inline = 'spP', group = othGR, tooltip = spTT)
rpPL = input.bool(false, 'Profile Price Levels', inline = 'BBe', group = othGR)
rpPLC = input.color(color.new(#00bcd4, 0), '', inline = 'BBe', group = othGR)
rpLS = input.string('Small', "", options= , inline = 'BBe', group = othGR, display = disp)
rpBG = input.bool(false, 'Profile Range Background Fill', inline = 'BG', group = othGR)
rpBGC = input.color(color.new(#00bcd4, 95), '', inline = 'BG', group = othGR)
otGR = 'Other Profile Settings'
rpNR = input.int(25, '  Number of Rows' , minval = 10, maxval = 100 ,step = 5, group = otGR, tooltip = 'option range ', display = disp)
rpW = input.int(13, '  Profile Width %', minval = 10, maxval = 50, group = otGR, tooltip = 'option range ', display = disp) / 100
vpLS = input.string('Auto', "  Profile Text Size", options= , group = otGR, display = disp)
vpHO = input.int(13, '  Profile Horizontal Offset', group = otGR, tooltip = 'option allows negative numbers as well, in case of a use the profiles will overlap with the price chart', display = disp)
//---------------------------------------------------------------------------------------------------------------------}
// User Defined Types
//---------------------------------------------------------------------------------------------------------------------{
// @type bar properties with their values
//
// @field o (float) open price of the bar
// @field h (float) high price of the bar
// @field l (float) low price of the bar
// @field c (float) close price of the bar
// @field v (float) volume of the bar
// @field i (int) index of the bar
type bar
float o = open
float h = high
float l = low
float c = close
float v = volume
int i = bar_index
int n = bar_index
int t = time
//---------------------------------------------------------------------------------------------------------------------}
// Variables
//---------------------------------------------------------------------------------------------------------------------{
bar b = bar.new()
rpVST = array.new_float(rpNR, 0.)
rpVSB = array.new_float(rpNR, 0.)
rpVSD = array.new_float(rpNR, 0.)
var dRP = array.new_box()
var pocPoints = array.new()
var polyline pocPolyline = na
var polyline spPolyline = na
var color llC = na
var color lsC = na
//---------------------------------------------------------------------------------------------------------------------}
// Functions/Methods
//---------------------------------------------------------------------------------------------------------------------{
// @function creates new label object and updates existing label objects
//
// @param details in Pine Scriptâ„¢ language reference manual
//
// @returns none, updated visual objects (labels)
f_drawLabelX(_x, _y, _text, _style, _textcolor, _size, _tooltip) =>
var lb = label.new(_x, _y, _text, xloc.bar_index, yloc.price, color(na), _style, _textcolor, _size, text.align_left, _tooltip)
lb.set_xy(_x, _y)
lb.set_text(_text)
lb.set_tooltip(_tooltip)
lb.set_textcolor(_textcolor)
// @function This function converts string to enumerated size
//
// @param _t custom string
//
// @returns enumerated size
f_gTS(_t) =>
switch _t
'Tiny' => size.tiny
'Small' => size.small
'Normal' => size.normal
'Auto' => size.auto
//---------------------------------------------------------------------------------------------------------------------}
// Calculations
//---------------------------------------------------------------------------------------------------------------------{
bull = spPTY == spPT1 ? b.c > b.o : (b.c - b.l) > (b.h - b.c)
nzV = nz(b.v)
rpS = f_gTS(rpLS)
vpS = f_gTS(vpLS)
var float pLST = na
var float pHST = na
if b.i == last_bar_index - rpLN
pLST := b.l
pHST := b.h
else if b.i > last_bar_index - rpLN
pLST := math.min(b.l, pLST)
pHST := math.max(b.h, pHST)
pSTP = (pHST - pLST) / rpNR
if barstate.islast and not na(nzV) and not timeframe.isseconds and rpLN > 0 and pSTP > 0 and nzV > 0
if dRP.size() > 0
for i = 0 to dRP.size() - 1
box.delete(dRP.shift())
if pocPoints.size() > 0
pocPoints.clear()
a_allPolylines = polyline.all
if array.size(a_allPolylines) > 0
for i = 0 to array.size(a_allPolylines) - 1
polyline.delete(a_allPolylines.get(i))
for bI = rpLN to 0
l = 0
for pLL = pLST to pHST - pSTP by pSTP
if b.h >= pLL and b.l < pLL + pSTP
vPOR = if b.l >= pLL and b.h > pLL + pSTP
(pLL + pSTP - b.l ) / (b.h - b.l )
else if b.h <= pLL + pSTP and b.l < pLL
(b.h - pLL) / (b.h - b.l )
else if (b.l >= pLL and b.h <= pLL + pSTP)
1
else
pSTP / (b.h - b.l )
if vpSRC == 'Money Flow'
rpVST.set(l, rpVST.get(l) + nzV * vPOR * (pLST + (l + .5) * pSTP) )
else
rpVST.set(l, rpVST.get(l) + nzV * vPOR )
if bull and spSH and Showprofle
if vpSRC == 'Money Flow'
rpVSB.set(l, rpVSB.get(l) + nzV * vPOR * (pLST + (l + .5) * pSTP))
else
rpVSB.set(l, rpVSB.get(l) + nzV * vPOR )
l += 1
if rpPC == 'Developing'
if bI == rpLN
pocPoints.push(chart.point.from_index(b.i , pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
else
pocPoints.push(chart.point.from_index(b.i , pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
if rpPC == 'Developing' and Showprofle
pocPolyline := polyline.new(pocPoints, false, false, xloc.bar_index, vpHVC, color(na), line.style_solid, 2)
if rpPC == 'Last(Zone)' and Showprofle or rpPC == 'Last(Line)' and Showprofle
pocPoints.push(chart.point.from_index(b.i , pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
pocPoints.push(chart.point.from_index(b.i, pLST + (rpVST.indexof(rpVST.max()) + .5) * pSTP))
pocPolyline := polyline.new(pocPoints, false, false, xloc.bar_index, vpHVC, color(na), rpPC == 'Last(Line)' ? line.style_solid : line.style_dotted, rpPC == 'Last(Line)' ? 2 : 1)
for l = 0 to rpNR - 1
bbp = 2 * rpVSB.get(l) - rpVST.get(l)
rpVSD.set(l, rpVSD.get(l) + bbp * (bbp > 0 ? 1 : -1) )
if vpSH and Showprofle or spSH and Showprofle
sBI = b.i + (spSH ? rpLN * rpW : 7) + int(rpLN * rpW / 3)
dRP.push(box.new(sBI - 1 + vpHO, pLST + (l + .1) * pSTP, sBI - int(rpLN * rpW / 3) + 1 + vpHO, pLST + (l + .9) * pSTP, #2962ff80, bgcolor = #2962ff10,
text = str.tostring(pLST + (l + .5) * pSTP, format.mintick), text_color = chart.fg_color, text_size = vpS ))
if rpBG and Showprofle
dRP.push(box.new(b.i - rpLN, pLST, b.i, pHST, rpBGC, bgcolor = rpBGC ))
if rpPL and Showprofle
f_drawLabelX(b.i, pHST, str.tostring(pHST, format.mintick), label.style_label_down, rpPLC, rpS,
'Profile High - ' + str.tostring(pHST, format.mintick) + ' %' + str.tostring((pHST - pLST) / pLST * 100, '#.##') + ' higher than the Profile Low ' +
'Total ' + (vpSRC == 'Volume' ? 'Volume : ' : 'Money Flow (' + syminfo.currency + ') : ') + str.tostring(rpVST.sum(), format.volume) +
' Number of bars : ' + str.tostring(rpLN + 1))
f_drawLabelX(b.i, pLST, str.tostring(pLST, format.mintick), label.style_label_up , rpPLC, rpS,
'Profile Low - ' + str.tostring(pLST, format.mintick) + ' %' + str.tostring((pHST - pLST) / pHST * 100, '#.##') + ' lower than the Profile High ' +
'Total ' + (vpSRC == 'Volume' ? 'Volume : ' : 'Money Flow (' + syminfo.currency + ') : ') + str.tostring(rpVST.sum(), format.volume) +
' Number of bars : ' + str.tostring(rpLN + 1))
for l = 0 to rpNR - 1
if dRP.size() < 500
vtLV = rpVST.get(l)
vtMX = rpVST.max()
LpM = vtLV / vtMX
vdMX = rpVSD.max()
DpM = rpVSD.get(l) / vdMX
llC := LpM > vpHVT ? color.from_gradient(LpM, vpHVT, 1, vpAVC, vpHVC) : color.from_gradient(LpM, 0, vpLVT, vpLVC, vpAVC)
bbp = 2 * rpVSB.get(l) - vtLV
lsC := bbp > 0 ? color.from_gradient(DpM, 0, .7, color.new(spBLC, 70 + int(hmTR / 4)), color.new(spBLC, 30 + int(hmTR / 4))) :
color.from_gradient(DpM, 0, .7, color.new(spBRC, 70 + int(hmTR / 4)), color.new(spBRC, 30 + int(hmTR / 4)))
if rpPC == 'Last(Zone)' and LpM == 1 and Showprofle
dRP.push(box.new(b.i , pLST + (rpVST.indexof(vtMX) + .0) * pSTP, b.i, pLST + (rpVST.indexof(vtMX) + 1.) * pSTP, vpHVC, bgcolor = color.new(vpHVC, 73) ))
if vaSH and LpM > vaTH and LpM < 1 and Showprofle
dRP.push(box.new(b.i , pLST + (l + .0) * pSTP, b.i, pLST + (l + 1.) * pSTP, color(na), bgcolor = vaC ))
if vaSH and rpPC != 'Last(Zone)' and LpM == 1 and Showprofle
dRP.push(box.new(b.i , pLST + (l + .0) * pSTP, b.i, pLST + (l + 1.) * pSTP, color(na), bgcolor = vaC ))
if spPC and DpM == 1 and Showprofle
spPolyline := polyline.new(array.from(chart.point.from_index(b.i , pLST + (rpVSD.indexof(vdMX) + .5) * pSTP), chart.point.from_index(b.i, pLST + (rpVSD.indexof(vdMX) + .5) * pSTP)), false, false, xloc.bar_index, lsC, color(na), line.style_dotted, 1)
dRP.push(box.new(b.i , pLST + (rpVSD.indexof(vdMX) + .0) * pSTP, b.i, pLST + (rpVSD.indexof(vdMX) + 1.) * pSTP, lsC, bgcolor = color.new(lsC, 73) ))
if vpSH and Showprofle
sBI = b.i + (spSH ? rpLN * rpW : 7) + int(rpLN * rpW / 3)
eBI = sBI + int(LpM * rpLN * rpW)
dRP.push(box.new(sBI + vpHO, pLST + (l + .1) * pSTP, eBI + vpHO, pLST + (l + .9) * pSTP, llC, bgcolor = llC,
text = str.tostring(vpSRC == 'Money Flow' ? array.get(rpVST, l) : array.get(rpVST, l) * (pLST + (l + .5) * pSTP), format.volume) + ' ' +
syminfo.currency + ' (' + str.tostring(math.abs(vtLV / rpVST.sum() * 100), '#.##') + '%)',
text_halign = text.align_left, text_color = chart.fg_color, text_size = vpS ))
if spSH and Showprofle
sBI = b.i + rpLN * rpW
eBI = sBI - int(DpM * rpLN * rpW)
dRP.push(box.new(sBI + vpHO, pLST + (l + .1) * pSTP, eBI + vpHO, pLST + (l + .9) * pSTP, lsC, bgcolor = lsC,
text = str.tostring(bbp, format.volume ) + (vpSRC == 'Money Flow' ? ' ' + syminfo.currency : '') +
' (' + str.tostring(math.abs(bbp / vtLV * 100), '#.##') + '%)',
text_halign = text.align_right, text_color = chart.fg_color, text_size = vpS ))
if hmSH and Showprofle
dRP.push(box.new(b.i , pLST + (l + .0) * pSTP, b.i, pLST + (l + 1.) * pSTP, hmSRC == hmSO1 ? color.new(llC, hmTR) : lsC, bgcolor = hmSRC == hmSO1 ? color.new(llC, hmTR) : lsC))
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
//---------------------------------------------------------------------------------------------------------------------}
showRevBands = input.bool(true, "Show Reversal Bands", group='Indicator option')
lenRevBands = input.int(30, "Length", group="REVERSAL BANDS")
f_kc(src, len, sensitivity) =>
basis = ta.sma(src, len)
span = ta.atr(len)
= f_kc(close, lenRevBands, 3)
= f_kc(close, lenRevBands, 4)
= f_kc(close, lenRevBands, 5)
= f_kc(close, lenRevBands, 6)
cyan = #00DBFF, cyan30 = color.new(cyan, 100)
pink = #b2b5be, pink30 = color.new(pink, 100)
red = #b2b5be, red30 = color.new(red , 100)
up1 = plot(showRevBands ? upperKC1 : na, "Rev.Zone Upper 1", red30, display = display.none)
up2 = plot(showRevBands ? upperKC2 : na, "Rev.Zone Upper 2", red30, display = display.none)
up3 = plot(showRevBands ? upperKC3 : na, "Rev.Zone Upper 3", red30, display = display.none)
//plot(showRevBands ? upperKC4 : na, "Rev.Zone Upper 4", red30)
//plot(showRevBands ? lowerKC4 : na, "Rev.Zone Lower 4", cyan30)
dn1 = plot(showRevBands ? lowerKC3 : na, "Rev.Zone Lower 3", cyan30, display = display.none)
dn2 = plot(showRevBands ? lowerKC2 : na, "Rev.Zone Lower 2", cyan30, display = display.none)
dn3 = plot(showRevBands ? lowerKC1 : na, "Rev.Zone Lower 1", cyan30, display = display.none)
fill(up1, up2, color = color.new(#f23645, 80))
fill(up2, up3, color = color.new(#f23645, 50))
fill(dn1, dn2, color = color.new(#089981, 50))
fill(dn2, dn3, color = color.new(#089981, 80))
//---------------------------------------------------------------------------------------------------------------------}
//CONSTANTS & STRINGS & INPUTS
//---------------------------------------------------------------------------------------------------------------------{
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'
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( true, '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( true, '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)
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
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 = )
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)
//---------------------------------------------------------------------------------------------------------------------}
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------------------------------------------{
// @type UDT representing alerts as bool fields
// @field internalBullishBOS internal structure custom alert
// @field internalBearishBOS internal structure custom alert
// @field internalBullishCHoCH internal structure custom alert
// @field internalBearishCHoCH internal structure custom alert
// @field swingBullishBOS swing structure custom alert
// @field swingBearishBOS swing structure custom alert
// @field swingBullishCHoCH swing structure custom alert
// @field swingBearishCHoCH swing structure custom alert
// @field internalBullishOrderBlock internal order block custom alert
// @field internalBearishOrderBlock internal order block custom alert
// @field swingBullishOrderBlock swing order block custom alert
// @field swingBearishOrderBlock swing order block custom alert
// @field equalHighs equal high low custom alert
// @field equalLows equal high low custom alert
// @field bullishFairValueGap fair value gap custom alert
// @field bearishFairValueGap fair value gap custom alert
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
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool ob = false
bool swingob = false
bool obtouch = false
// @type UDT representing last swing extremes (top & bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
// @type UDT representing trend bias
// @field bias BULLISH or BEARISH
type trend
int bias
// @type UDT representing Equal Highs Lows display
// @field l_ine displayed line
// @field l_abel displayed label
type equalDisplay
line l_ine = na
label l_abel = na
// @type UDT representing a pivot point (swing point)
// @field currentLevel current price level
// @field lastLevel last price level
// @field crossed true if price level is crossed
// @field barTime bar time
// @field barIndex bar index
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
// @type UDT representing an order block
// @field barHigh bar high
// @field barLow bar low
// @field barTime bar time
// @field bias BULLISH or BEARISH
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 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 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 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
// @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)
//---------------------------------------------------------------------------------------------------------------------}
//USER-DEFINED FUNCTIONS
//---------------------------------------------------------------------------------------------------------------------{
// @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish)
// @returns int
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
// @function Identify whether the current value is the start of a new leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0
// @function Identify whether the current level is the start of a new bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1
// @function Identify whether the current level is the start of a new bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1
// @function create a new label
// @param labelTime bar time coordinate
// @param labelPrice price coordinate
// @param tag text to display
// @param labelColor text color
// @param labelStyle label style
// @returns label ID
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)
// @function create a new line and label representing an EQH or EQL
// @param p_ivot starting pivot
// @param level price level of current pivot
// @param size how many bars ago was the current pivot detected
// @param equalHigh true for EQH, false for EQL
// @returns label ID
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)
// @function store current structure and trailing swing points, and also display swing points and equal highs/lows
// @param size (int) structure size
// @param equalHighLow (bool) true for displaying current highs/lows
// @param internal (bool) true for getting internal structures
// @returns label ID
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)
// @function draw line and label representing a structure
// @param p_ivot base pivot point
// @param tag test to display
// @param structureColor base color
// @param lineStyle line style
// @param labelStyle label style
// @param labelSize text size
// @returns label ID
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)
// @function delete order blocks
// @param internal true for internal order blocks
// @returns orderBlock ID
// @function fetch and store order blocks
// @param p_ivot base pivot point
// @param internal true for internal order blocks
// @param bias BULLISH or BEARISH
// @returns void
// @function draw order blocks as boxes
// @param internal true for internal order blocks
// @returns void
// @function detect and draw structures, also detect and store order blocks
// @param internal true for internal structures or order blocks
// @returns void
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)
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)
// @function get line style from string
// @param style line style
// @returns string
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
// @function draw MultiTimeFrame levels
// @param timeframe base timeframe
// @param sameTimeframe true if chart timeframe is same as base timeframe
// @param style line style
// @param levelColor line and text color
// @returns void
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))
// @function true if chart timeframe is higher than provided timeframe
// @param timeframe timeframe to check
// @returns bool
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
// @function update trailing swing points
// @returns int
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
// @function draw trailing swing points
// @returns void
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')
// @function draw a zone with a label and a box
// @param labelLevel price level for label
// @param labelIndex bar index for label
// @param top top price level for box
// @param bottom bottom price level for box
// @param tag text to display
// @param zoneColor base color
// @param style label style
// @returns void
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)
//---------------------------------------------------------------------------------------------------------------------}
//MUTABLE VARIABLES & EXECUTION
//---------------------------------------------------------------------------------------------------------------------{
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()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showTrendInput
displayStructure(true)
if showStructureInput or showHighLowSwingsInput
displayStructure()
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)
//---------------------------------------------------------------------------------------------------------------------}
//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.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
//---------------------------------------------------------------------------------------------------------------------}
//-----------------------------------------------------------------------------
// Input Settings
//-----------------------------------------------------------------------------
i_3 = "FVGs represent price areas where a significant gap occurred between two trading sessions, indicating a potential continuation or reversal point."
//----------------------------------------
// Order Blocks
//----------------------------------------
var_ob_13 = (time - time ) / 100
//----------------------------------------
// Constants
color CLEAR = color.rgb(0, 0, 0, 100)
//----------------------------------------
// Fair Value Gaps (FVG)
//----------------------------------------
in_fvg_1 = input(true, "Fair Value Gaps (FVG)", group="Fair Value Gaps", inline="fvg_css", tooltip = i_3)
in_fvg_2 = input.timeframe("", "Timeframe", group="Fair Value Gaps", inline="tf")
in_fvg_op = input.int(defval=12, title="Opacity %", minval=0, maxval=100, group="Fair Value Gaps", inline="tf")
in_fvg_3 = input.float(2, "Max Width", minval=0, maxval=5.0, step=0.1, group="Fair Value Gaps", inline="width")
in_fvg_4 = input.bool(false, "Filter FVG", group="Fair Value Gaps", inline="width")
in_fvg_5 = input.string("Close", "Mitigation Method", options= , group="Fair Value Gaps", inline="mt")
in_fvg_6 = input.bool(true, "Fill", group="Fair Value Gaps", inline="mt")
in_fvg_7 = input.bool(false, "Shade", group="Fair Value Gaps", inline="mt")
in_fvg_8 = input.int(defval=8, title="Max FVG", minval=0, maxval=50, group="Fair Value Gaps", inline="OS")
in_fvg_9 = input.int(defval=17, title="Length", minval=0, maxval=100, group="Fair Value Gaps", inline="OS")
in_fvg_10 = input.bool(false, "Extend", group="Fair Value Gaps", inline="OS")
in_fvg_11 = input.color(color.new(#089981, 88), "", group="Fair Value Gaps", inline="fvg_css")
in_fvg_12 = input.color(color.new(#f23645, 88), "", group="Fair Value Gaps", inline="fvg_css")
mid_line_show = input.string("On", " Mid Line", , group="Fair Value Gaps", inline="mid")
in_fvg_13 = input.string("Solid", " Style", , group="Fair Value Gaps", inline="mid")
in_fvg_14 = input.color(#089981, "", group="Fair Value Gaps", inline="mid")
in_fvg_14_2 = input.color(#f23645, "", group="Fair Value Gaps", inline="mid")
in_fvg_16 = input.int(defval=1, title="Line Width", minval=1, maxval=5, group="Fair Value Gaps", inline="mid_w")
in_fvg_15 = input.bool(false, "Extend (Current)", group="Fair Value Gaps", inline="mid_w")
var_fvg_1 = color.new(color.green, 100)
var_fvg_2 = color.new(color.green, 90)
var_fvg_3 = true
var_fvg_4 = true
var_fvg_5 = color.white
var_fvg_6 = "HTF"
var_fvg_7 = 10
var_fvg_8 = 50
in_fvg_op := 100 - in_fvg_op
//-----------------------------------------------------------------------------
// Global Variables
//-----------------------------------------------------------------------------
color transparent = #ffffff00
custom_func_1(res) =>
t = time(res)
not na(t) and (na(t ) or t > t )
custom_func_2(x, y, txt, css, dashed, down, lbl_size) =>
label.new(int(math.avg(x, bar_index)), y, txt, color=transparent, textcolor=css, style=down ? label.style_label_down : label.style_label_up, size=lbl_size)
line.new(x, y, bar_index, y, color=css, style=dashed ? line.style_dotted : line.style_solid)
custom_func_3(_cond, _count) =>
_barssince = bar_index - ta.valuewhen(_cond, bar_index, _count)
_barssince
// Swing Detection/Measurements
custom_func_4(length) =>
var prev = 0
prev := high > ta.highest(length) ? 0 : low < ta.lowest(length) ? 1 : prev
t = prev == 0 and prev != 0 ? high : 0
b = prev == 1 and prev != 1 ? low : 0
var variable_ms_1 = 0, var variable_ms_2 = 0
var variable_ms_3 = 0., var variable_ms_4 = 0, var variable_ms_5 = 0., var variable_ms_6 = 0
var variable_ms_7 = 0., var variable_ms_8 = 0, var variable_ms_9 = 0., var variable_ms_10 = 0
var variable_ms_11 = true, var variable_ms_12 = true
var variable_ms_13 = true, var variable_ms_14 = true
var variable_ms_15 = high, var variable_ms_16 = low
var up_trailing_x = 0, var down_trailing_x = 0
var high_text = "", var low_text = ""
variable_ms_17 = false
variable_ms_18 = false
// Functions
lineStyle(x) =>
switch x
"Solid" => line.style_solid
"Dashed" => line.style_dashed
"Dotted" => line.style_dotted
variable_ms_20 = ta.pivothigh(high, 10, 10)
variable_ms_21 = ta.pivotlow(low, 10, 10)
//-----------------------------------------------------------------------------
// Fair Value Gaps
//-----------------------------------------------------------------------------
// Global Data
var htfH = open
var htfL = open
if close > htfH
htfH := close
if close < htfL
htfL := close
// Security Data, used for HTF Bar Data reference
sClose = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, close , barmerge.gaps_off, barmerge.lookahead_on)
sHighP2 = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, high , barmerge.gaps_off, barmerge.lookahead_on)
sLowP2 = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, low , barmerge.gaps_off, barmerge.lookahead_on)
sOpen = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, open , barmerge.gaps_off, barmerge.lookahead_on)
sBar = request.security(ticker.standard(syminfo.tickerid), in_fvg_2, bar_index, barmerge.gaps_off, barmerge.lookahead_on)
// Array variables to hold data in memory
var variable_fvg_1 = array.new_box(0)
var variable_fvg_2 = array.new_box(0)
var variable_fvg_3 = array.new_box(0)
var variable_fvg_4 = array.new_box(0)
var variable_fvg_5 = array.new_line(0)
var variable_fvg_6 = array.new_line(0)
var variable_fvg_7 = array.new_line(0)
var variable_fvg_8 = array.new_line(0)
var variable_fvg_9 = array.new_line(0)
var variable_fvg_10 = array.new_line(0)
var variable_fvg_11 = array.new_label(0)
var variable_fvg_12 = array.new_label(0)
var variable_fvg_13 = color.new(color.white, 100)
var variable_fvg_14 = false
var variable_fvg_15 = false
variable_fvg_14 := false
variable_fvg_15 := false
// Functions
custom_func_5(_upperlimit, _lowerlimit, _midlimit, _bar, _boxholder, _boxholder_fill, _midholder, _highholder, _lowholder, _labelholder, _boxcolor, _mtfboxcolor, _htf, line_color_mid) =>
variable_fvg_16 = str.tostring(in_fvg_2)
offset = var_fvg_8
variable_fvg_17 = _mtfboxcolor
bg_color = color.new(_mtfboxcolor, in_fvg_op)
if _htf == false
variable_fvg_16 := str.tostring(timeframe.period)
offset := var_fvg_7
variable_fvg_17 := _boxcolor
array.push(_boxholder, box.new(_bar, _upperlimit, _bar + (var_ob_13) * in_fvg_9, _lowerlimit, border_color= na, bgcolor=in_fvg_6 ? bg_color : na, extend=in_fvg_10 ? extend.right : extend.none, xloc=xloc.bar_time, text="", text_color=#787b86, text_halign=text.align_right, text_size=size.small))
array.push(_boxholder_fill, box.new(_bar, _upperlimit, _bar + (var_ob_13) * in_fvg_9, _lowerlimit, border_color= na, bgcolor=in_fvg_6 ? bg_color : na, extend=in_fvg_10 ? extend.right : extend.none, xloc=xloc.bar_time))
array.push(_midholder, line.new(_bar, (_lowerlimit + _upperlimit) / 2.0, _bar + (var_ob_13) * in_fvg_9, _midlimit, color=mid_line_show == "On" ? line_color_mid : #363a4500, extend=in_fvg_10 ? extend.right : extend.none, style=lineStyle(in_fvg_13), width=in_fvg_16, xloc=xloc.bar_time))
array.push(_lowholder, line.new(_bar, _lowerlimit, _bar + (var_ob_13) * in_fvg_9, _lowerlimit, color=var_fvg_3 ? variable_fvg_17 : na, extend=in_fvg_10 ? extend.right : extend.none, width=1, xloc=xloc.bar_time))
array.push(_highholder, line.new(_bar, _upperlimit, _bar + (var_ob_13) * in_fvg_9, _upperlimit, color=var_fvg_3 ? variable_fvg_17 : na, extend=in_fvg_10 ? extend.right : extend.none, width=1, xloc=xloc.bar_time))
// Checks for gap between current candle and 2 previous candle (Fair Value Gap)
custom_func_6(_close, _high, _highp2, _low, _lowp2, _open, _bar, _htf) =>
gap = 0
thold_ = (ta.highest(_high, 300) - ta.lowest(_low, 300)) * math.max(in_fvg_3, 0.1) / 100.
if _open > _close // Red candle
if _lowp2 > _high
if not (in_fvg_4) or math.abs(_lowp2 - _high) > thold_
upperlimit = _high
lowerlimit = _lowp2
midlimit = lowerlimit + ((upperlimit - lowerlimit) / 2.)
gap := 1
if in_fvg_1
custom_func_5(upperlimit, lowerlimit, midlimit, _bar, variable_fvg_1, variable_fvg_3, variable_fvg_9, variable_fvg_5, variable_fvg_7, variable_fvg_11, var_fvg_1, in_fvg_12, _htf,in_fvg_14_2)
else
if _low > _highp2
if not (in_fvg_4) or math.abs(_low - _highp2) > thold_
upperlimit = _low
lowerlimit = _highp2
midlimit = lowerlimit + ((upperlimit - lowerlimit) / 2.)
gap := -1
if in_fvg_1
custom_func_5(upperlimit, lowerlimit, midlimit, _bar, variable_fvg_2, variable_fvg_4, variable_fvg_10, variable_fvg_6, variable_fvg_8, variable_fvg_12, var_fvg_2, in_fvg_11, _htf,in_fvg_14)
gap
// Removes the gap from its relevant array if it has been filled
custom_func_7(_currentgap, _currentgap_fill, _i, _boxholder, _boxholder_fill, _midholder, _highholder, _lowholder, _labelholder) =>
array.remove(_boxholder, _i)
array.remove(_boxholder_fill, _i)
currentmid = array.get(_midholder, _i)
currenthigh = array.get(_highholder, _i)
currentlow = array.get(_lowholder, _i)
array.remove(_midholder, _i)
array.remove(_highholder, _i)
array.remove(_lowholder, _i)
if var_fvg_4
line.delete(currentmid)
line.delete(currenthigh)
line.delete(currentlow)
else
line.set_extend(currentmid, extend.none)
line.set_x2(currentmid, time)
line.set_extend(currenthigh, extend.none)
line.set_x2(currenthigh, time)
line.set_extend(currentlow, extend.none)
line.set_x2(currentlow, time)
if var_fvg_4
box.delete(_currentgap)
box.delete(_currentgap_fill)
else
box.set_extend(_currentgap, extend.none)
box.set_right(_currentgap, time)
// Checks if gap has been filled either by 0.5 fill (var_fvg_3) or SHRINKS the gap to reflect the true value gap left
custom_func_8(_high, _low) =>
variable_fvg_19 = 0
if array.size(variable_fvg_1) > 0
for i = array.size(variable_fvg_1) - 1 to 0
if in_fvg_15
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i)
cmid = array.get(variable_fvg_9, i)
chigh = array.get(variable_fvg_5, i)
clow = array.get(variable_fvg_7, i)
line.set_x2(cmid, timenow + (var_ob_13) * in_fvg_9)
line.set_x2(chigh, timenow + (var_ob_13) * in_fvg_9)
line.set_x2(clow, timenow + (var_ob_13) * in_fvg_9)
box.set_right(currentgap_fill, timenow + (var_ob_13) * in_fvg_9)
box.set_right(currentgap, timenow + (var_ob_13) * in_fvg_9)
if in_fvg_5 == "Touch"
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i)
currentmid = array.get(variable_fvg_9, i)
currenthigh = array.get(variable_fvg_5, i)
currentlow = array.get(variable_fvg_7, i)
currenttop = box.get_top(currentgap)
if high > currenttop
variable_fvg_19 := 1
custom_func_7(currentgap, currentgap_fill, i, variable_fvg_1, variable_fvg_3, variable_fvg_9, variable_fvg_5, variable_fvg_7, variable_fvg_11)
if in_fvg_5 == "Wicks"
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i)
currentmid = array.get(variable_fvg_9, i)
currenthigh = array.get(variable_fvg_5, i)
currentlow = array.get(variable_fvg_7, i)
currenttop = box.get_bottom(currentgap)
currentbottom = box.get_top(currentgap_fill)
if high > currentbottom and in_fvg_7
currentgap_f = array.get(variable_fvg_3, i)
cur_bottom = box.get_bottom(currentgap_f)
_bottom = box.get_bottom(currentgap)
if _bottom == cur_bottom
box.set_bottom(currentgap_f, high)
else
box.set_bottom(currentgap_f, math.max(cur_bottom, high))
box.set_bgcolor(currentgap_f, #787b865e)
if high > currenttop
variable_fvg_19 := 1
custom_func_7(currentgap, currentgap_fill, i, variable_fvg_1, variable_fvg_3, variable_fvg_9, variable_fvg_5, variable_fvg_7, variable_fvg_11)
if in_fvg_5 == "Close"
currentgap_fill = array.get(variable_fvg_3, i)
currentgap = array.get(variable_fvg_1, i
Zero Lag LSMA 3-Color# Zero Lag LSMA 3-Color Indicator
## Overview
The Zero Lag LSMA (ZLSMA) 3-Color is an advanced trend-following indicator that reduces the lag inherent in traditional Linear Regression Moving Averages (LSMA). This indicator provides clear visual signals through a color-coded system and dot markers to identify trend changes with minimal delay.
## What is Zero Lag LSMA?
Zero Lag LSMA is calculated by applying the Linear Regression Moving Average twice and then compensating for the lag:
1. **First LSMA**: Calculate LSMA of the price data
2. **Second LSMA**: Calculate LSMA of the first LSMA
3. **Zero Lag Calculation**: ZLSMA = LSMA + (LSMA - LSMA2)
This method significantly reduces the delay while maintaining the smoothness of the trend line.
## Features
### Color-Coded Trend System
- **Fluorescent Green** (`RGB(0, 255, 0)`): Uptrend - ZLSMA is rising
- **Fluorescent Red** (`RGB(255, 20, 60)`): Downtrend - ZLSMA is falling
- **Gray**: Sideways/Neutral - No clear directional bias
### Trend Change Markers
- **Tiny dots** appear at the exact moment when the trend direction changes
- **Green dots**: Mark the beginning of an uptrend
- **Red dots**: Mark the beginning of a downtrend
### Customizable Parameters
- **Length**: Period for ZLSMA calculation (default: 20)
- **Line Width**: Thickness of the ZLSMA line (default: 2)
- **Show/Hide Toggle**: Option to display or hide the indicator
## Trading Applications
### Trend Identification
- **Green line**: Look for long opportunities
- **Red line**: Look for short opportunities
- **Gray line**: Consider range-bound strategies
### Entry Signals
- **Dot markers** provide precise entry points when trend changes occur
- Green dots can signal potential buy entries
- Red dots can signal potential sell entries
### Trend Confirmation
- Use ZLSMA color changes to confirm other technical analysis signals
- The reduced lag helps traders enter trends earlier than traditional moving averages
## Advantages Over Traditional Moving Averages
1. **Reduced Lag**: Responds faster to price changes than standard moving averages
2. **Clear Visualization**: Color-coding makes trend direction immediately apparent
3. **Precise Timing**: Dot markers highlight exact trend change moments
4. **Smooth Operation**: Maintains smoothness while reducing whipsaws
## Best Practices
### Timeframe Usage
- Works effectively on all timeframes
- Higher timeframes provide more reliable signals
- Lower timeframes offer more trading opportunities but may have more noise
### Risk Management
- Always use proper stop-loss levels
- Consider the overall market context
- Combine with other technical analysis tools for confirmation
### Settings Optimization
- **Shorter periods** (10-15): More sensitive, faster signals
- **Longer periods** (25-50): More stable, fewer false signals
- **Standard period** (20): Good balance between sensitivity and stability
## Alert Conditions
The indicator includes built-in alert conditions for:
- ZLSMA turning upward (trend change to bullish)
- ZLSMA turning downward (trend change to bearish)
## Compatibility
- **Platform**: TradingView
- **Script Version**: Pine Script v6
- **Chart Type**: Works on all chart types
- **Markets**: Suitable for Forex, Stocks, Crypto, Commodities, and Indices
## Disclaimer
This indicator is for educational and informational purposes only. It should not be considered as financial advice. Always conduct your own research and consider your risk tolerance before making trading decisions. Past performance does not guarantee future results.
Fork: BigBeluga TargetTrend with Bounded Box & Potential LabelFork of BigBeluga's TargetTrend indicator with bounding boxes of trend legs with max favorable excursion label added.
KOBK Quantum Oscillator 383 SB## ⚡ **Core Technology**
- **Quantum Oscillator Integration**: Advanced momentum analysis using stealth algorithms
- **Flow Sync Filtering**: Intelligent trend confirmation technology
- **Zone Lock Protection**: Dynamic stop-loss placement based on market structure
- **Pulse Confirmation**: Entry timing optimization for maximum accuracy
## 📊 **Visual Components**
### **Main Chart Display**
- Clean directional signals (▲ Buy / ▼ Sell)
- Flow Sync Filter line for trend awareness
- Professional scanner information panel
- Real-time risk assessment data
### **Quantum Oscillator Panel**
- Dual-line momentum system with crossover signals
- Dynamic histogram showing market strength
- Color-coded momentum zones
- Equilibrium reference line
## 🎨 **Signal Intelligence**
- **Green Signals**: High-probability bullish entries
- **Red Signals**: High-probability bearish entries
- **Color-Coded Momentum**: Bright colors indicate strong moves, faded colors show weakening momentum
- **Background Highlighting**: Subtle visual confirmation of market conditions
## ⚙️ **Key Features**
- **Smart Risk Management**: Automatic stop-loss calculation based on market structure
- **Trend Confirmation**: Built-in filter prevents counter-trend trades
- **Scanner Compatibility**: Works with TradingView's screening tools
- **Real-Time Alerts**: Instant notifications for all signal types
- **Professional Interface**: Clean, uncluttered display designed for serious traders
## 🔒 **Important Usage Note**
**This system is designed as a COMPLETE trading solution and requires ALL components to function properly. The individual indicators are NOT intended for standalone use and will not provide accurate signals when used separately. Always use the complete KOBK ZENOSU TRAP system as intended.**
## 🎯 **Best For**
- Day traders seeking precise entry points
- Swing traders looking for trend confirmation
- Scanner users monitoring multiple markets
- Risk-conscious traders requiring built-in protection
rsi 8 beta 2🔔 How to Use for Entry
BUY Entry when:
Yellow BUY arrow appears
GOLD bar > USD bar
Delta (strength difference) is positive
SELL Entry when:
Blue SELL arrow appears
USD bar > GOLD bar
Delta is negative
Exit either on the opposite arrow or when strength starts weakening.
Savages Supply and Demand LevelsThis supply and demand indicator in my opinion is one of the best S&D indicators on trading view. It is clean, organized and just simple. I have spent thousands of hours determining the best and most reliable ways to identify supply and demand, on every time frame! I am going to explain exactly what I look for.
When looking for a supply level meaning, there is potential for more supply of the following stock to hit the marker, what does that mean? People are going to sell. SO, it represents possible sell ordered at that supply level. So lets get into the grit of this, there are two candles that form when a supply level is formed. The first candle needs to be green, it will have a high, a low , an open and a close. The specifics come into play with the next candle which needs to be red, that candle can NOT break the previous green candles high, and needs to close below the previous candles low. THATS IT! That is a supply level. Now, for a demand level, its the same thing just switched, we need a red candle, that will have a high,low, open and a close. Same thing now, the next candle is going to be green, that green candle can NOT break that previous red candles low and needs to close above that previous red candles high. THATS A DEMAND!
I have spent countless hours back testing and studying this, I am extremely confident that this will be a game changer for whoever uses this. I have marked different types of opening and closes and highs and lows and this specific type of setup has worked countless times for me, the only time it will not work is when there is a liquidity sweep or some sort of news where it causes the price action to swing several points. Also do not use only one time frame and only this indicator, try to use some fair value gap levels and break of structure indicators, there are really good ones on here. I have also built the indicator to get rid of supply and demand levels that have already been hit so you always have a clean and fresh supply and demand level that has not been eaten into yet. I also threw some clean labels on there so it is easy to identify. So once price action hits that supply or demand level, it goes away, it either worked or it gets invalidated.
I hope you enjoy!
Not financial advice
-Savage
[Pandora][Swarm] Rapid Exponential Moving AverageENVISIONING POSSIBILITY
What is the theoretical pinnacle of possibility? The current state of algorithmic affairs falls far short of my aspirations for achievable feasibility. I'm lifting the lid off of Pandora's box once again, very publicly this time, as a brute force challenge to conventional 'wisdom'. The unfolding series of time mandates a transcendental systemic alteration...
THE MOVING AVERAGE ZOO:
The realm of digital signal processing for trading is filled with familiar antiquated filtering tools. Two families of filtration, being 'infinite impulse response' (EMA, RMA, etc.) and 'finite impulse response' (WMA, SMA, etc.), are prevalently employed without question. These filter types are the mules and donkeys of data analysis, broadly accepted for use in finance.
At first glance, they appear sufficient for most tasks, offering a basic straightforward way to reduce noise and highlight trends. Yet, beneath their simplistic facade lies a constellation of limitations and impediments, each having its own finicky quirks. Upon closer inspection, identifiable drawbacks render them far from ideal for many real-world applications in today's volatile markets.
KNOWN FUNDAMENTAL FLAWS:
Despite commonplace moving average (MA) popularity, these conventional filters suffer from an assortment of fundamental flaws. Most of them don't genuinely address core challenges of how to preserve the true dynamics of a signal while suppressing noise and retaining cutoff frequency compliance. Their simple cookie cutter structures make them ill-suited in actuality for dynamic market environments. In reality, they often trade one problem for another dilemma, forsaking analytics to choose between distortion and delay.
A deeper seeded issue remains within frequency compliance, how adequately a filter respects (or disrespects) the underlying signal’s spectral properties according to it's assigned periodic parameter. Traditional MAs habitually distort phase relationships, causing delayed reactions with surplus lag or exaggerations with excessive undershoot/overshoot. For applications requiring timely resilience, such as algorithmic trading, these shortcomings are often functionally unacceptable. What’s needed is vigorous filters that can more accurately retain signal behaviors while minimizing lag without sacrificing smoothness and uniformity. Until then, the public MA zoo remains as a collection of corny compromises, rather than a favorable toolbelt of solutions.
P.S.: In PSv7+, in my opinion, many of these geriatric MAs deserve no future with ease of access for the naive, simply not knowing these filters are most likely creating bigger problems than solving any.
R.E.M.A.
What is this? I prefer to think of it as the "radical EMA", definitely along my lines of a retire everything morte algorithm. This isn't your run of the mill average from the petting zoo. I would categorize it as a paradigm shifting rampant economic masochistic annihilator, sufficiently good enough to begin ruthlessly executing moving averages left and right. Um, yeah... that kind of moving average destructor as you may soon recognize with a few 'Filters+' settings adjustments, realizing ordinary EMA has been doing us an injustice all this time.
Does it possess the capability to relentlessly exterminate most averaging filters in existence? Well, it's about time we find out, by uncaging it on the loose into the greater economic wilderness. Only then can we truly find out if it is indeed a radical exponential market accelerant whose time has come. If it is, then it may eventually become a reality erasing monolithic anomaly destined for greatness, ultimately changing the entire landscape of trading in perpetuity.
UNLEASHING NEXT-GEN:
This lone next generation exoweapon algorithm is intended to initiate the transformative beginning stages of mass filtration deprecation. However, it won't be the only one, just the first arrival of it's alien kind from me. Welcome to notion #1 of my future filtration frontier, on this episode of the algorithmic twilight zone. Where reality takes a twisting turn one dimension beyond practical logic, after persistent models of mindset disintegrate into insignificance, followed by illusory perception confronted into cognitive dissonance.
An evolutionary path to genuine advancement resides outside the prison of preconceptions, manifesting only after divergence from persistent binding restrictions of dogmatic doctrines. Such a genesis in transformative thinking will catalyze unbounded cognitive potential, plowing the way for the cultivation of total redesigns of thought. Futuristic innovative breakthroughs demand the surrender of legacy and outmoded understandings.
Now that the world's largest assembly of investors has been ensembled, there are additional tasks left to perform. I'm compelled to deploy this mathematical-weapon of mass financial creation into it's rightful destined hands, to "WE THE PEOPLE" of TV.
SCRIPT INTENTION:
Deprecate anything and everything as any non-commercial member sees desirably fit. This includes your existing code formulations already in working functional modes of operation AND/OR future projects in the works. Swapping is nearly as simple as copying and pasting with meager modifications, after you have identified comparable likeness in this indicators settings with a visual assessment. Results may become eye opening, but only if you dare to look and test.
Where you may suspect a ta.filter() is lacking sufficient luster or may be flat out majorly deficient, employing rema, drema, trema, or qrema configurations may be a more suitable replacement. That's up to you to discern. My code satire already identifies likely bottom of the barrel suspects that either belong in the extinction record or have already been marked for deprecation. They are ordered more towards the bottom by rank where they belong. SuperSmoother is a masterpiece here to stay, being my original go-to reference filter. Everything you see here is already deprecated, including REMA...
REMA CHARACTERISTICS
- VERY low lag
- No overshoot
- Frequency compliant
- Proper initialization at bar_index==0
- Period parameter accepts poitive floating point numerics (AND integers!)
- Infinite impulse response (IIR) filter
- Compact code footprint
- Minimized computational overhead
