ORB Storico + Box Multipli + Notifiche (final clean v2)Session ORB Live Pro — Pre-Market Boxes & MA Suite
Description (EN):
Session ORB Live Pro is a Pine v6 indicator built for intraday traders who rely on Opening Range Breakouts. It draws session boxes for London, New York, and Asia—plus configurable Pre-London and Pre-New York windows—live from the very first candle (no waiting for 10 bars). The high/low levels update in real time, and optional breakout alerts fire the moment price closes beyond the range. To keep charts clean and relevant for scalping, the boxes auto-hide on chart timeframes above 20 minutes.
Beyond ranges, the tool adds a compact moving-average suite: SMA-50 and RMA-200 out of the box, plus three fully customizable MAs (SMA/EMA/RMA/WMA/HMA) with selectable color, thickness, and style (line, stepline, circles). Each session and pre-session can be toggled on/off and tinted with its own color, so you can tailor the visual map of liquidity grabs and range breaks to your strategy.
Key features
Live ORB boxes for London, New York, Asia (no 10-bar delay).
Pre-sessions: Pre-London & Pre-New York with independent time windows and colors.
Auto visibility filter: boxes show only on ≤ 20m chart TF; hidden on higher TFs.
Breakout alerts when price closes above/below the session range (ready for alert() rules).
MA toolkit: SMA-50, RMA-200 + 3 user MAs (SMA/EMA/RMA/WMA/HMA) with color, style, and width.
Clean inputs using input.session; robust, low-friction UX.
How to use
Set your ORB calculation timeframe (e.g., 15m) and choose which sessions/pre-sessions to display.
Pick colors for each box and enable alerts if you want instant breakout notifications.
Configure the MA suite for trend bias and dynamic S/R (e.g., SMA-50 for momentum, RMA-200 for bias).
Trade the first clean break or the retest of the ORB extremes—your choice. The visual map updates tick by tick.
Penunjuk dan strategi
SMC Volatility Liquidity Prothis one’s a confluence signaler. it fires “BUY CALL” / “BUY PUT” labels only when four things line up at once: trend, volatility squeeze, a liquidity sweep, and MACD momentum. quick breakdown:
what each block does
Trend filter (context)
ema50 > ema200 ⇒ trendUp
ema50 < ema200 ⇒ trendDn
Plots both EMAs for visual context.
Volatility compression (setup)
20-period Bollinger Bands (stdev 2).
bb_squeeze is true when current band width < its 20-SMA ⇒ price is compressed (potential energy building).
Liquidity sweep (trigger)
Tracks 20-bar swing high/low.
Long sweep: high > swingHigh ⇒ price just poked above the prior 20-bar high (took buy-side liquidity).
Short sweep: low < swingLow ⇒ price just poked below the prior 20-bar low (took sell-side liquidity).
MACD momentum (confirmation)
Standard MACD(12,26,9) histogram.
Bullish: hist > 0 and rising versus previous bar.
Bearish: hist < 0 and falling.
the actual entry signals
LongEntry = trendUp AND bb_squeeze AND liquiditySweepLong AND macdBullish
→ prints a green “BUY CALL” label below the bar.
ShortEntry = trendDn AND bb_squeeze AND liquiditySweepShort AND macdBearish
→ prints a red “BUY PUT” label above the bar.
alerts & dashboard
Alerts: fires when those long/short conditions hit so you can set TradingView alerts on them.
On-chart dashboard (bottom-right):
Trend (Bullish/Bearish/Neutral)
Squeeze (Yes/No)
Liquidity (Long/Short/None)
Momentum (Bullish/Bearish/Neutral)
Current Signal (BUY CALL / BUY PUT / WAIT)
(btw the comment says “2 columns × 5 rows” but the table is actually 5 columns × 2 rows—values under each label across the row.)
what it’s trying to capture (in plain english)
Trade with the higher-timeframe bias (EMA 50 over 200).
Enter as volatility compresses (bands tight) and a sweep grabs stops beyond a 20-bar extreme.
Only pull the trigger when momentum agrees (MACD hist direction & side of zero).
caveats / tips
It’s an indicator, not a strategy—no entries/exits/backtests baked in.
Signals are strict (4 filters), so you’ll get fewer but “cleaner” prints; still not magical.
The liquidity-sweep check uses the prior bar’s 20-bar high/low ( ), so on bar close it won’t repaint; intrabar alerts may feel jumpy if you alert “on every tick.”
Consider adding:
Exit logic (e.g., ATR stop + take-profit, or opposite signal).
Minimum squeeze duration (e.g., bb_squeeze true for N bars) to avoid one-bar dips in width.
Cool-down after a signal to prevent clustering.
Session/time or volume filter if you only want liquid hours.
if you want, I can convert this into a backtestable strategy() version with ATR-based stops/targets and a few toggles, so you can see stats right away.
LT's RSI Invalidation Targets//@version=5
indicator("Triple RSI Divergence", overlay=true)
// === INPUTS ===
rsiLength = input.int(14, title="RSI Length")
src = input.source(close, "Source")
lookback = input.int(50, title="Lookback Period")
// === RSI ===
rsi = ta.rsi(src, rsiLength)
// === Find local peaks and troughs ===
isTop = ta.pivothigh(rsi, 5, 5)
isBottom = ta.pivotlow(rsi, 5, 5)
var float rsiTroughs = array.new_float()
var float priceTroughs = array.new_float()
var int rsiTroughBars = array.new_int()
if isBottom
array.unshift(rsiTroughs, rsi )
array.unshift(priceTroughs, low )
array.unshift(rsiTroughBars, bar_index )
if array.size(rsiTroughs) > 3
array.pop(rsiTroughs)
array.pop(priceTroughs)
array.pop(rsiTroughBars)
// === Check for triple bullish divergence ===
bullDiv = false
if array.size(rsiTroughs) == 3
r1 = array.get(rsiTroughs, 2)
r2 = array.get(rsiTroughs, 1)
r3 = array.get(rsiTroughs, 0)
p1 = array.get(priceTroughs, 2)
p2 = array.get(priceTroughs, 1)
p3 = array.get(priceTroughs, 0)
// Price: Lower lows, RSI: Higher lows
if p1 > p2 and p2 > p3 and r1 < r2 and r2 < r3
bullDiv := true
label.new(array.get(rsiTroughBars, 0), low, "Triple Bullish Divergence", style=label.style_label_up, color=color.green, textcolor=color.white)
// === Same for triple bearish divergence ===
var float rsiPeaks = array.new_float()
var float pricePeaks = array.new_float()
var int rsiPeakBars = array.new_int()
if isTop
array.unshift(rsiPeaks, rsi )
array.unshift(pricePeaks, high )
array.unshift(rsiPeakBars, bar_index )
if array.size(rsiPeaks) > 3
array.pop(rsiPeaks)
array.pop(pricePeaks)
array.pop(rsiPeakBars)
bearDiv = false
if array.size(rsiPeaks) == 3
r1 = array.get(rsiPeaks, 2)
r2 = array.get(rsiPeaks, 1)
r3 = array.get(rsiPeaks, 0)
p1 = array.get(pricePeaks, 2)
p2 = array.get(pricePeaks, 1)
p3 = array.get(pricePeaks, 0)
// Price: Higher highs, RSI: Lower highs
if p1 < p2 and p2 < p3 and r1 > r2 and r2 > r3
bearDiv := true
label.new(array.get(rsiPeakBars, 0), high, "Triple Bearish Divergence", style=label.style_label_down, color=color.red, textcolor=color.white)
MACD (The Moving Average Convergence Divergence)The Moving Average Convergence Divergence (MACD) is a momentum indicator used in technical analysis to identify trends, measure their strength, and signal potential reversals. It is calculated by subtracting the 26-period Exponential Moving Average (EMA) from the 12-period EMA, creating the MACD line. A 9-period EMA of the MACD line, known as the signal line, is then plotted to generate buy or sell signals. Positive MACD values suggest upward momentum, while negative values indicate downward momentum. Traders often watch for crossovers, divergences, and movements relative to the zero line to make informed decisions.
Ch Enhanced Buy Sell Volume// ========================================
// 📊 HOW TO READ THIS INDICATOR 📊
// ========================================
//
// 🟢 GREEN BARS (Above Zero) = BUY VOLUME
// 🔴 RED BARS (Below Zero) = SELL VOLUME
//
// 💡 BAR COLORS MEANING:
// • DARK GREEN = Strong buyer dominance (high conviction buying)
// • LIGHT GREEN = Weak buyer dominance (low conviction)
// • DARK RED = Strong seller dominance (high conviction selling)
// • LIGHT RED = Weak seller dominance (low conviction)
//
// 🎯 TRADING SIGNALS:
// • Tall dark green bars = Strong bullish momentum
// • Tall dark red bars = Strong bearish momentum
// • Light colored bars = Weak conviction, potential reversal
// • Green bars > Red bars = Buyers winning
// • Red bars > Green bars = Sellers winning
//
// 📈 BULLISH SIGNALS:
// • Buy% > 70% = Strong buying interest
// • Dark green bars with high delta = Professional buying
// • Buy volume above yellow MA line = Above average buying
//
// 📉 BEARISH SIGNALS:
// • Sell% > 70% = Strong selling pressure
// • Dark red bars with high delta = Professional selling
// • Sell volume below yellow MA line = Above average selling
//
// ⚠️ WARNING SIGNALS:
// • Price up + Red dominance = Bearish divergence
// • Price down + Green dominance = Bullish divergence
// • Low delta (<10%) = Market indecision
//
// 📊 INFO TABLE (Top-Right):
// • Buy%: Percentage of volume that was buying
// • Sell%: Percentage of volume that was selling
// • Delta%: Strength of dominance (difference between buy/sell)
// • Dom: Which side is currently dominant (BUYERS/SELLERS)
//
// 🟡 YELLOW LINES = Volume Moving Average
// • Upper line: Reference for buy volume (green bars)
// • Lower line: Reference for sell volume (red bars)
// • Above yellow = Higher than average volume
// • Below yellow = Lower than average volume
Session High Low TrackerTracks the Asia, London, NY AM and NY PM swing highs and lows. What's different here is when a level is broken, it can continue to draw a dotted line so the levels stay on the chart until
end of day. Also has shading options for each session.
RK Scalper V1.0Version 1.0
Scalper Indicator
Use multiple options to decide the best possible scalping possibilities on 1, 3, 5 and 15 min timeframes
1. 3 different EMA trend lines to decide direction and reversal; option to include EMA crossover to take entry and exit positions
2. Show signal when price cross VWAP with huge volume
3. Show SuperTrend and identify possible reversal when price touches the SuperTrend line
4. Show VWAP line
5. Show SuperTrend VWAP crossover with an option to either include volume spike or not
6. Show VWMA line to decide exit points when price moves below at buy and above at sell positions
7. Show Open=High / Open-Low to see the buy and sell pressure and buyer seller dominance
8. Show Volume spike indication on Volume for NIFTY, BANK NIFTY and MIDCAP NIFTY futures volume on their respective underlying asset
9.
Note: It is batter to use scalp indicator along with trend and momentum indicators to have better results.
Synthesis DeFi - Fractals - Daily - v7.0This is a free trial version of SynthesisDeFi.com fractals.
A simplified fractal analysis indicator that identifies key market structure points on daily timeframes. This tool automatically detects trend reversals and plots fractal highs and lows with connecting lines, helping traders visualize major support and resistance levels
Why use Synthesis DeFi fractals?
Harmonic Patterns
Wycoff
Elliot Waves
Dow Theory
Created by Oliver Fujimori | SynthesisDeFi.com
Perfect for swing traders and position traders focused on daily market structure analysis
ATR Risk Leverage Indicator - PropCominiView the screenshot here:
(i.imgur.com)
이 지표는 시장 변동성을 기반으로 사용자가 결정한 최대감수손실률에 따라서 자동으로 적정 레버리지가 계산되고, 시각화되는 리스크 관리 및 포지션 사이즈닝 지표입니다.
주요 기능
ATR 기반 변동성 측정
지정 기간과 배수로 가격 변동 범위를 계산
현재 가격 대비 상/하한선 라인 표시 → 손절가와 시장 변동성 한눈에 확인
멀티타임프레임 지원
선택한 타임프레임(1, 3, 5, 15, 60, 240, D) ATR과 가격 정보 활용 가능
단일 차트에서 스윙 및 데이 트레이딩 전략 적용 가능
리스크 기반 레버리지 계산
손실 허용 비율(%) 기준으로 적정 레버리지 자동 계산
ATR 손절 거리와 결합 → 안전한 포지션 sizing
직관적 시각화
ATR 상/하한선 라인 표시
테이블로 변동 범위, 변동률, 추천 레버리지 제공
색상, 텍스트 크기, 위치 자유롭게 커스터마이징 가능
장점
리스크 관리 최적화: 과도한 레버리지 사용 방지, 변동성이 큰 구간 포지션 조절 가능
즉각적 의사결정 지원: ATR 범위와 레버리지 정보 한눈에 확인
멀티타임 전략 활용: 다른 시간대 정보로 전략 다양화
초보부터 전문가까지 활용 가능: 손절 거리, 변동률, 레버리지 직관적 확인
사용법
ATR 배수와 기간을 전략과 변동성 수준에 맞게 조정
손실 허용 비율(risk%) 설정 → 적정 레버리지 자동 계산
테이블과 라인 표시 옵션 활용 → 차트 가독성 최적화
멀티타임프레임 분석으로 장중 변동성과 포지션 전략 확인
This indicator automatically calculates the optimal leverage based on market volatility and the maximum acceptable loss percentage set by the user. It visualizes risk management and position sizing, helping traders make informed decisions.
Key Features
ATR-Based Volatility Measurement
Calculates the price range based on the specified period and multiplier.
Displays upper and lower lines relative to the current price → quickly check stop-loss levels and market volatility.
Multi-Timeframe Support
Uses ATR and price data from selected timeframes (1, 3, 5, 15, 60, 240 minutes, or Daily).
Can be applied to both swing and day trading strategies on a single chart.
Risk-Based Leverage Calculation
Automatically calculates optimal leverage based on the user-defined risk percentage.
Combines ATR-based stop-loss distance → ensures safe position sizing.
Intuitive Visualization
Shows ATR-based upper and lower lines.
Displays a table with price range, volatility percentage, and recommended leverage.
Customizable colors, text size, and table position for improved chart readability.
Advantages
Optimized Risk Management: Prevents excessive leverage usage, helps adjust positions during high volatility.
Instant Decision Support: Quickly check ATR ranges and leverage information.
Multi-Timeframe Strategy Utilization: Allows strategy diversification using different timeframes.
Suitable for All Traders: Both beginners and professionals can intuitively check stop-loss distance, volatility, and leverage.
How to Use
Adjust ATR multiplier and period according to your strategy and market volatility.
Set the risk percentage → the indicator automatically calculates the optimal leverage.
Use table and line display options → enhance chart readability.
Analyze multi-timeframe data to monitor intraday volatility and position strategy.
AMHA + 4 EMAs + EMA50/200 Counter + Avg10CrossesDescription:
This script combines two types of Heikin-Ashi visualization with multiple Exponential Moving Averages (EMAs) and a counting function for EMA50/200 crossovers. The goal is to make trends more visible, measure recurring market cycles, and provide statistical context without generating trading signals.
Logic in Detail:
Adaptive Median Heikin-Ashi (AMHA):
Instead of the classic Heikin-Ashi calculation, this method uses the median of Open, High, Low, and Close. The result smooths out price movements, emphasizes trend direction, and reduces market noise.
Standard Heikin-Ashi Overlay:
Classic HA candles are also drawn in the background for comparison and transparency. Both HA types can be shifted below the chart’s price action using a customizable Offset (Ticks) parameter.
EMA Structure:
Five exponential moving averages (21, 50, 100, 200, 500) are included to highlight different trend horizons. EMA50 and EMA200 are emphasized, as their crossovers are widely monitored as potential trend signals. EMA21 and EMA100 serve as additional structure layers, while EMA500 represents the long-term trend.
EMA50/200 Counter:
The script counts how many bars have passed since the last EMA50/200 crossover. This makes it easy to see the age of the current trend phase. A colored label above the chart displays the current counter.
Average of the Last 10 Crossovers (Avg10Crosses):
The script stores the last 10 completed count phases and calculates their average length. This provides historical context and allows traders to compare the current cycle against typical past behavior.
Benefits for Analysis:
Clearer trend visualization through adaptive Heikin-Ashi calculation.
Multi-EMA setup for quick structural assessment.
Objective measurement of trend phase duration.
Statistical insight from the average cycle length of past EMA50/200 crosses.
Flexible visualization through adjustable offset positioning below the price chart.
Usage:
Add the indicator to your chart.
For a clean look, you may switch your chart type to “Line” or hide standard candlesticks.
Interpret visual signals:
White candles = bullish phases
Orange candles = bearish phases
EMAs = structural trend filters (e.g., EMA200 as a long-term boundary)
The counter label shows the current number of bars since the last cross, while Avg10 represents the historical mean.
Special Feature:
This script is not a trading system. It does not provide buy/sell recommendations. Instead, it serves as a visual and statistical tool for market structure analysis. The unique combination of Adaptive Median Heikin-Ashi, multi-EMA framework, and EMA50/200 crossover statistics makes it especially useful for trend-followers and swing traders who want to add cycle-length analysis to their toolkit.
Moon Phases Prediction🌙 Moon Phases (with Next Event Projection)
Introduction
This indicator plots Moon Phases (New Moon and Full Moon) directly on your chart.
In addition to showing historical phases, it also calculates and projects the upcoming next moon phase using precise astronomical formulas.
Features
Marks New Moons with circles above bars.
Marks Full Moons with circles below bars.
Dynamically adjusts background color based on waxing/waning phase.
Calculates and displays the next upcoming moon event as a label positioned in the future.
Works on all timeframes (except Monthly).
How It Works
Uses astronomical approximations (Julian Day → UNIX time conversion).
Detects the last occurred New Moon or Full Moon.
Projects the next moon event by adding half a synodic month (~14.77 days).
Displays the next event label at its exact future date on the chart.
Customization
Waxing Moon color (default: Blue)
Waning Moon color (default: White)
Use Cases
Astro-finance: lunar cycles and market psychology.
Trading strategies: aligning entries/exits with cyclical behavior.
Visualization: adding an extra dimension of timing to chart analysis.
Notes
- The future moon event is displayed as a circle label on the correct date.
- If you cannot see the label, increase your chart’s right margin (Chart Settings → Scales → Right Margin).
- Calculations are approximate but astronomically accurate enough for trading or visual use.
Conclusion
This indicator is a simple yet powerful tool for traders interested in the influence of lunar cycles.
By combining historical phases with a projected next event, you can always be aware of where the market stands in the moon cycle timeline.
DHYT Moon Cycles IndicatorThis indicator tracks the moon cycles which seem to correlate with bullish and bearish periods for Cryptocurrency trading. This indicator allows you to calibrate these windows using recent moon phase dates and times. You can also add customizable highlighted bands before and after these events to highlight these bullish and bearish periods.
Created by: Dan Heilman
RK CPR Buy/Sell Setup Ver1.0Version 1.0
CPR based Buy and Sell Indicator
First option is to show the Buy and Sell indicators, in which multiple options given to users to adjust the buy and sell setup.
1. Include Trend direction
2. Include candlestick touching the EMA 20 / EMA 50 / EMA 100 / VWAP trend lines
3. Include Momentum check
4. Include candlestick patterns to decide buy or sell
5. Exclude Wide CPR day for trading
Second option is the identify the different possible reversal indicators and same are as follows
1. Extreme Reversal
2. Outside Reversal
3. Doji Reversal
4. Triple/Double wick Reversal
5. Pulllback Reversal
Note: It is batter to use reversal indicator along with trend and momentum to have better results.
Adaptive Jump Moving AverageAdaptive Jump Moving Average - Description
This indicator solves the classic moving average lag problem during significant price moves. Traditional MAs (like the 200-day) take forever to catch up after a major drop or rally because they average across all historical periods equally.
How it works:
Tracks price smoothly during normal market conditions
When price moves 20%+ away from the MA, it immediately "resets" to the current price level
Treats that new level as the baseline and continues smooth tracking from there
Advantages over normal MA:
No lag on major moves: A 40% crash doesn't get diluted over 200 days - the MA instantly adapts
Reduces false signals: You won't get late "death cross" signals months after a crash already happened
Better support/resistance: The MA stays relevant to current price action instead of reflecting outdated levels
Keeps the smoothness: During normal volatility, it behaves like a traditional MA without the noise of shorter periods
DHYT 6 MAs, BMSB, Pi Cycle TopThis indicator has 6 Moving averages that are highly customizable and visible on all time frames, it also includes the Bull Market Support Band (BMSB) and the Pi Cycle Top indicator which has been very good at predicting Cycle Tops for Bitcoin (BTC).
You can customize all the moving averages, as well as using simple or exponential. You can also easily customize colors and line weights.
Created by: Dan Heilman
Volume Aggregated (Lite)Volume Aggregated (Lite) is a lightweight yet powerful tool designed to provide traders with a consolidated view of trading volume across major perpetual futures markets. Instead of relying solely on the volume of a single exchange, this indicator aggregates and normalizes data from multiple venues, giving a broader and more representative measure of market activity.
Supported Exchanges:
Binance (USDT.P & USDC.P)
Bybit (USDT.P & USD.P)
OKX (USDT.P & USD.P)
Bitget (USDT.P & USD.P)
Coinbase (USDC.P)
Users can toggle each exchange individually, allowing flexible customization depending on which markets they consider most relevant.
Denomination Options:
COINS: Volume expressed in the base currency (e.g., BTC, ETH).
USD: Volume normalized to USD values by multiplying with price.
Why it’s useful:
Volume is a critical component of technical analysis, reflecting market participation and conviction behind price moves. However, relying on a single exchange can create blind spots, especially in crypto where liquidity is fragmented. By combining data from multiple large exchanges, this indicator offers:
A more comprehensive measure of market interest.
A normalized comparison between exchanges with different quote currencies (e.g., USDT, USD, USDC).
A volume stream that can be used as a custom source for other indicators, strategies, or overlays within TradingView.
Practical Applications:
Trend Confirmation: Check if aggregated volume supports price direction.
Breakout Validation: Identify whether breakouts are backed by broad participation across venues.
Divergence Detection: Spot situations where price moves without sufficient cross-exchange volume.
Custom Indicator Input: Since it outputs a clean series, it can be plugged into moving averages, oscillators, or custom-built scripts.
Technical Details:
The script uses request.security() to pull volume data across exchanges and normalizes values when required (e.g., USD-quoted pairs divided by the instrument’s price). It then aggregates all valid inputs into a single stream. The result is displayed as color-coded columns (green for bullish candles, red for bearish), making it easy to interpret at a glance.
This “Lite” version keeps the focus on core functionality: aggregation, normalization, and straightforward visualization—avoiding unnecessary complexity while remaining highly adaptable for custom analysis.
Double Top/Bottom Screener - Today Only v3 //@version=6
indicator("Double Top/Bottom Screener - Today Only", overlay=true, max_lines_count=500)
// Inputs
leftBars = input.int(5, "Left Bars")
rightBars = input.int(5, "Right Bars")
tolerance = input.float(0.02, "Max Difference (e.g., 0.02 for 2 cents)", step=0.01)
atrLength = input.int(14, "ATR Length for Normalized Distance", minval=1)
requiredPeaks = input.int(3, "Required Identical Peaks", minval=2, maxval=5)
// Declarations of persistent variables and arrays
var array resistanceLevels = array.new(0)
var array resistanceCounts = array.new(0)
var array supportLevels = array.new(0)
var array supportCounts = array.new(0)
var array resLines = array.new(0)
var array supLines = array.new(0)
var bool hasDoubleTop = false
var bool hasDoubleBottom = false
var float doubleTopLevel = na
var float doubleBottomLevel = na
var int todayStart = na
var float nearestDoubleLevel = na // Explicitly declared as na by default
// Step 1: Identify Swing Highs/Lows
swingHigh = ta.pivothigh(high, leftBars, rightBars)
swingLow = ta.pivotlow(low, leftBars, rightBars)
// Today's premarket start (04:00 AM ET)
todayStart := timestamp(syminfo.timezone, year, month, dayofmonth, 4, 0, 0)
// Clear arrays and delete lines on the first bar or new day
if barstate.isfirst or (dayofmonth != dayofmonth and time >= todayStart)
// Delete all existing lines only if arrays are not empty
if array.size(resLines) > 0
for i = array.size(resLines) - 1 to 0
line.delete(array.get(resLines, i))
if array.size(supLines) > 0
for i = array.size(supLines) - 1 to 0
line.delete(array.get(supLines, i))
// Clear arrays
array.clear(resistanceLevels)
array.clear(supportLevels)
array.clear(resistanceCounts)
array.clear(supportCounts)
array.clear(resLines)
array.clear(supLines)
// Reset flags and levels
hasDoubleTop := false
hasDoubleBottom := false
doubleTopLevel := na
doubleBottomLevel := na
nearestDoubleLevel := na // Ensure reset on new day
// Add new swings only if today and after premarket
if not na(swingHigh) and time >= todayStart and dayofmonth == dayofmonth
bool isEqualHigh = false
int peakIndex = -1
float prevLevel = na
if array.size(resistanceLevels) > 0
for i = 0 to array.size(resistanceLevels) - 1
prevLevel := array.get(resistanceLevels, i)
if math.abs(swingHigh - prevLevel) <= tolerance
isEqualHigh := true
peakIndex := i
break
if isEqualHigh and peakIndex >= 0
array.set(resistanceCounts, peakIndex, array.get(resistanceCounts, peakIndex) + 1)
if array.get(resistanceCounts, peakIndex) == requiredPeaks
hasDoubleTop := true
doubleTopLevel := prevLevel
else
array.push(resistanceLevels, swingHigh)
array.push(resistanceCounts, 1)
line newResLine = line.new(bar_index - rightBars, swingHigh, bar_index, swingHigh, color=color.red, width=2, extend=extend.none)
array.push(resLines, newResLine)
if not na(swingLow) and time >= todayStart and dayofmonth == dayofmonth
bool isEqualLow = false
int peakIndex = -1
float prevLevel = na
if array.size(supportLevels) > 0
for i = 0 to array.size(supportLevels) - 1
prevLevel := array.get(supportLevels, i)
if math.abs(swingLow - prevLevel) <= tolerance
isEqualLow := true
peakIndex := i
break
if isEqualLow and peakIndex >= 0
array.set(supportCounts, peakIndex, array.get(supportCounts, peakIndex) + 1)
if array.get(supportCounts, peakIndex) == requiredPeaks
hasDoubleBottom := true
doubleBottomLevel := prevLevel
else
array.push(supportLevels, swingLow)
array.push(supportCounts, 1)
line newSupLine = line.new(bar_index - rightBars, swingLow, bar_index, swingLow, color=color.green, width=2, extend=extend.none)
array.push(supLines, newSupLine)
// Monitor and remove broken levels/lines; reset pattern if the equal level breaks
if array.size(resistanceLevels) > 0
for i = array.size(resistanceLevels) - 1 to 0
float level = array.get(resistanceLevels, i)
if close > level
line.delete(array.get(resLines, i))
array.remove(resLines, i)
array.remove(resistanceLevels, i)
array.remove(resistanceCounts, i)
if level == doubleTopLevel
hasDoubleTop := false
doubleTopLevel := na
nearestDoubleLevel := na // Reset if level breaks
if array.size(supportLevels) > 0
for i = array.size(supportLevels) - 1 to 0
float level = array.get(supportLevels, i)
if close < level
line.delete(array.get(supLines, i))
array.remove(supLines, i)
array.remove(supportLevels, i)
array.remove(supportCounts, i)
if level == doubleBottomLevel
hasDoubleBottom := false
doubleBottomLevel := na
nearestDoubleLevel := na // Reset if level breaks
// Limit arrays (after removals)
if array.size(resistanceLevels) > 10
line oldLine = array.shift(resLines)
line.delete(oldLine)
array.shift(resistanceLevels)
array.shift(resistanceCounts)
if array.size(supportLevels) > 10
line oldLine = array.shift(supLines)
line.delete(oldLine)
array.shift(supportLevels)
array.shift(supportCounts)
// Pattern Signal: 1 only if the exact required number of peaks is met
patternSignal = (hasDoubleTop or hasDoubleBottom) ? 1 : 0
// New: Nearest Double Level Price - Only update if pattern is active today
if time >= todayStart and dayofmonth == dayofmonth // Restrict to today
if (hasDoubleTop and not na(doubleTopLevel)) or (hasDoubleBottom and not na(doubleBottomLevel))
if hasDoubleTop and not na(doubleTopLevel)
nearestDoubleLevel := doubleTopLevel
if hasDoubleBottom and not na(doubleBottomLevel)
nearestDoubleLevel := na(nearestDoubleLevel) ? doubleBottomLevel : (math.abs(close - doubleBottomLevel) < math.abs(close - nearestDoubleLevel) ? doubleBottomLevel : nearestDoubleLevel)
else
nearestDoubleLevel := na // Reset to na if no pattern today
else
nearestDoubleLevel := na // Reset for historical bars
// New: Distance to Nearest Level (using ATR for normalization)
var float atr = ta.atr(atrLength)
var float distanceNormalizedATR = na
if not na(nearestDoubleLevel) and not na(atr) and atr > 0
distanceNormalizedATR := math.abs(close - nearestDoubleLevel) / atr
// Outputs
plot(patternSignal, title="Pattern Signal", color=patternSignal == 1 ? color.purple : na, style=plot.style_circles)
plot(nearestDoubleLevel, title="Nearest Double Level Price", color=color.orange)
plot(distanceNormalizedATR, title="Normalized Distance (ATR)", color=color.green)
bgcolor(patternSignal == 1 ? color.new(color.purple, 80) : na)
if patternSignal == 1 and barstate.isconfirmed
alert("Double Pattern detected on " + syminfo.ticker + " at " + str.tostring(close), alert.freq_once_per_bar_close)
if barstate.islast
var table infoTable = table.new(position.top_right, 1, 3, bgcolor=color.new(color.black, 50))
table.cell(infoTable, 0, 0, "Pattern: " + str.tostring(patternSignal), bgcolor=patternSignal == 1 ? color.purple : color.gray)
table.cell(infoTable, 0, 1, "Level: " + str.tostring(nearestDoubleLevel, "#.##"), bgcolor=color.orange)
table.cell(infoTable, 0, 2, "ATR Dist: " + str.tostring(distanceNormalizedATR, "#.##"), bgcolor=color.green)
55 ABR Currentcurrent bar range
abr
previous_bar ibs
当前K线范围 (Curr Bar Rng)：显示当前正在形成的K线的价格幅度（最高价-最低价）
平均K线范围 (ABR)：计算指定周期内（默认8根K线）的平均K线范围，这个数值可以帮助交易者了解市场的平均波动性
内部K线强度 (IBS)：显示前一根已完成K线的内部强度百分比
This Pine Script indicator creates a real-time information panel in the top-right corner of TradingView charts, displaying three key trading metrics:Core Features:
Current Bar Range: Shows the price range (high - low) of the currently forming candlestick, providing immediate awareness of intraday volatility.
Average Bar Range (ABR): Calculates the mean candlestick range over a specified lookback period (default: 8 bars). This metric helps traders assess whether current market volatility is above or below recent norms.
Internal Bar Strength (IBS): Displays the previous completed bar's internal strength as a percentage,
RSI Signals Multi-Layer RSI System with Classical Divergence**DrFX RSI Signals Fixed** is an advanced RSI-based trading system that combines duration-filtered extreme conditions with classical divergence detection and momentum confirmation. This enhanced version addresses common RSI false signals through multi-layer filtering while adding proper divergence analysis for identifying high-probability reversal points.
**Core Innovation & Originality**
This indicator uniquely integrates five analytical layers:
1. **Duration-Validated Extreme Zones** - Confirms RSI has remained overbought/oversold for minimum bars within lookback period
2. **Classical Divergence Detection** - Proper implementation comparing swing highs/lows in both price and RSI
3. **Momentum Confirmation Signals** - RSI crossing 50-line after extreme conditions for trend confirmation
4. **Multi-Signal Classification** - Four distinct signal types (Buy, Sell, Strong Buy, Strong Sell, Momentum)
5. **Visual Zone Highlighting** - Background coloring for instant extreme zone identification
**Technical Implementation & Improvements**
**Enhanced Duration Filter:**
Unlike the previous version, this system uses a refined approach:
```
for i = 0 to lookback_bars - 1
if rsi > overbought
barsInOverbought := barsInOverbought + 1
```
This counts actual bars within the lookback period (default 20 bars) where RSI was extreme, requiring minimum duration (default 4 bars) for signal validation.
**Classical Divergence Detection:**
The system implements proper divergence analysis, a significant improvement over simple delta comparison:
**Bullish Divergence Logic:**
- Price makes lower low: `low < prevPriceLow`
- RSI makes higher low: `rsi > prevRsiLow`
- Indicates weakening downward momentum despite lower prices
**Bearish Divergence Logic:**
- Price makes higher high: `high > prevPriceHigh`
- RSI makes lower high: `rsi < prevRsiHigh`
- Indicates weakening upward momentum despite higher prices
**Signal Generation Framework:**
**Primary Signals:**
- **Buy Signal**: RSI crosses above oversold (30) after meeting duration requirements
- **Sell Signal**: RSI crosses below overbought (70) after meeting duration requirements
**Strong Signals:**
- **Strong Buy**: Buy signal + bullish divergence confirmation
- **Strong Sell**: Sell signal + bearish divergence confirmation
**Momentum Signals:**
- **Momentum Buy (M+)**: RSI crosses above 50 after recent oversold conditions
- **Momentum Sell (M-)**: RSI crosses below 50 after recent overbought conditions
**What Makes This Version Superior**
**Compared to Standard RSI:**
1. **Duration Requirement**: Prevents signals on brief RSI spikes
2. **Lookback Validation**: Ensures extreme conditions actually occurred recently
3. **Proper Divergence**: Uses swing high/low comparison, not just bar-to-bar deltas
4. **Momentum Layer**: Adds trend confirmation via 50-line crosses
**Compared to Previous Version:**
1. **Pine Script v5**: Modern syntax with improved performance
2. **Configurable Parameters**: All values adjustable via inputs
3. **Better Divergence**: Classical divergence logic replaces simplified delta method
4. **Additional Signals**: Momentum confirmations for trend following
5. **Visual Enhancements**: Background coloring and improved signal differentiation
6. **Alert System**: Built-in alert conditions for all signal types
**Parameter Configuration**
**Customizable Inputs:**
- **Overbought Level** (70): Upper threshold, range 50-90
- **Oversold Level** (30): Lower threshold, range 10-50
- **RSI Period** (14): Calculation period, range 2-50
- **Minimum Duration** (4): Required bars in extreme zone, range 1-20
- **Lookback Bars** (20): Period to check for extreme conditions, range 5-100
- **Divergence Lookback** (5): Period for divergence swing comparison, range 2-20
**Optimization Guidelines:**
- **Shorter Duration** (2-3): More frequent signals, higher noise
- **Longer Duration** (5-7): Fewer signals, better quality
- **Smaller Lookback** (10-15): Faster response, may miss context
- **Larger Lookback** (30-50): More context, potentially delayed signals
**Signal Interpretation Guide**
**Visual Signal Hierarchy:**
**Light Green Triangle (Buy):**
- RSI recovered from oversold
- Duration requirements met
- Entry on reversal from oversold territory
**Light Red Triangle (Sell):**
- RSI declined from overbought
- Duration requirements met
- Entry on reversal from overbought territory
**Blue Triangle (Strong Buy):**
- Buy signal with bullish divergence
- Highest probability long setup
- Price made lower low, RSI made higher low
**Magenta Triangle (Strong Sell):**
- Sell signal with bearish divergence
- Highest probability short setup
- Price made higher high, RSI made lower high
**Tiny Green Circle (M+):**
- RSI crossed above 50 after oversold
- Momentum confirmation for uptrend
- Secondary entry or trend confirmation
**Tiny Red Circle (M-):**
- RSI crossed below 50 after overbought
- Momentum confirmation for downtrend
- Secondary entry or trend confirmation
**Background Coloring:**
- **Light Red Background**: RSI > 70 (overbought zone)
- **Light Green Background**: RSI < 30 (oversold zone)
**Trading Strategy Application**
**Conservative Approach (Strong Signals Only):**
1. Wait for blue/magenta triangles (divergence confirmed)
2. Enter on signal bar close or next bar open
3. Stop loss beyond recent swing high/low
4. Target minimum 2:1 risk/reward ratio
**Aggressive Approach (All Signals):**
1. Take light green/red triangles for earlier entries
2. Use momentum circles as confirmation
3. Tighter stops with partial profit taking
4. Scale positions based on signal strength
**Momentum Trading:**
1. Use momentum signals (M+/M-) as trend filters
2. Take primary signals aligned with momentum direction
3. Avoid counter-momentum signals in strong trends
4. Exit when opposing momentum signal appears
**Multi-Timeframe Strategy:**
1. Check higher timeframe for strong signals
2. Execute on lower timeframe primary signals
3. Use momentum signals for position management
4. Align all timeframe signals for best probability
**Optimal Market Conditions**
**Best Performance:**
- Mean-reverting markets with clear RSI extremes
- Range-bound or consolidating conditions
- Markets respecting support/resistance levels
- Timeframes: 15min to 4H for active trading
**Strong Signal Advantages:**
- Divergence signals often mark major turning points
- Work well at market structure levels
- Effective in both trending and ranging markets
- Higher success rate justifies waiting for setup
**Momentum Signal Benefits:**
- Confirms trend direction after extreme readings
- Useful for adding to positions
- Helps avoid counter-trend trades
- Works well in trending markets where reversals fail
**Technical Advantages**
**Divergence Accuracy:**
The improved divergence detection uses proper swing analysis rather than simple bar-to-bar comparison. This identifies genuine momentum shifts where price action diverges from oscillator movement over a meaningful period.
**Duration Logic:**
The for-loop counting method ensures the system checks actual RSI values within the lookback period, not just whether RSI touched levels. This distinguishes between sustained conditions and brief spikes.
**Momentum Filter:**
The 50-line crosses after extreme conditions provide an additional confirmation layer, helping traders distinguish between failed reversals (no momentum follow-through) and sustained moves (momentum confirmation).
**Risk Management Integration**
**Signal Priority:**
1. **Highest**: Strong signals with divergence (blue/magenta triangles)
2. **Medium**: Primary signals without divergence (light green/red triangles)
3. **Confirmation**: Momentum signals (tiny circles)
**Position Sizing:**
- Larger positions on strong signals (divergence present)
- Standard positions on primary signals
- Smaller positions or adds on momentum signals
**Stop Placement:**
- Beyond recent swing structure
- Below/above divergence swing low/high for strong signals
- Trail stops when momentum signals align with position
**Alert System**
Built-in alert conditions for:
- Buy Signal: RSI buy without divergence
- Sell Signal: RSI sell without divergence
- Strong Buy Alert: Buy with bullish divergence
- Strong Sell Alert: Sell with bearish divergence
Configure alerts via TradingView's alert system to receive notifications for chosen signal types.
**Important Considerations**
**Strengths:**
- Multiple confirmation layers reduce false signals
- Classical divergence improves reversal detection
- Momentum signals add trend-following capability
- Highly customizable for different trading styles
- No repainting - all signals fixed at bar close
**Limitations:**
- Duration requirements may cause missed quick reversals
- Divergence lookback period affects sensitivity
- Not suitable as standalone system
- Requires understanding of RSI principles and divergence concepts
**Best Practices:**
- Combine with price action and support/resistance
- Use higher timeframe context for directional bias
- Respect overall market trend and structure
- Implement proper position sizing based on signal type
- Test parameters on your specific instrument and timeframe
**Comparison Summary**
This enhanced version represents a significant upgrade:
- Upgraded to Pine Script v5 modern standards
- Proper classical divergence detection (not simplified)
- Added momentum confirmation signals
- Fully customizable parameters via inputs
- Visual background zone highlighting
- Comprehensive alert system
- Better signal differentiation through color coding
The system transforms basic RSI analysis into a multi-dimensional trading tool suitable for various market conditions and trading styles.
**Disclaimer**: This indicator is designed for educational and analytical purposes. While the multi-layer filtering and classical divergence detection improve upon standard RSI implementations, no indicator guarantees profitable trades. The duration filtering reduces false signals but may delay entries. Divergence signals, while statistically favorable, can fail in strong trending conditions. Always use proper risk management, position sizing, and stop-loss orders. Consider multiple confirmation methods and market context before making trading decisions. Past performance does not guarantee future results.
CCI vs Two EMAs + Trendlines + Breakout HighlightPerfect indicator which analyzes the cci4000 & 2 EMAS.
BOCS AdaptiveBOCS Adaptive Strategy - Automated Volatility Breakout System
WHAT THIS STRATEGY DOES:
This is an automated trading strategy that detects consolidation patterns through volatility analysis and executes trades when price breaks out of these channels. Take-profit and stop-loss levels are calculated dynamically using Average True Range (ATR) to adapt to current market volatility. The strategy closes positions partially at the first profit target and exits the remainder at the second target or stop loss.
TECHNICAL METHODOLOGY:
Price Normalization Process:
The strategy begins by normalizing price to create a consistent measurement scale. It calculates the highest high and lowest low over a user-defined lookback period (default 100 bars). The current close price is then normalized using the formula: (close - lowest_low) / (highest_high - lowest_low). This produces values between 0 and 1, allowing volatility analysis to work consistently across different instruments and price levels.
Volatility Detection:
A 14-period standard deviation is applied to the normalized price series. Standard deviation measures how much prices deviate from their average - higher values indicate volatility expansion, lower values indicate consolidation. The strategy uses ta.highestbars() and ta.lowestbars() functions to track when volatility reaches peaks and troughs over the detection length period (default 14 bars).
Channel Formation Logic:
When volatility crosses from a high level to a low level, this signals the beginning of a consolidation phase. The strategy records this moment using ta.crossover(upper, lower) and begins tracking the highest and lowest prices during the consolidation. These become the channel boundaries. The duration between the crossover and current bar must exceed 10 bars minimum to avoid false channels from brief volatility spikes. Channels are drawn using box objects with the recorded high/low boundaries.
Breakout Signal Generation:
Two detection modes are available:
Strong Closes Mode (default): Breakout occurs when the candle body midpoint math.avg(close, open) exceeds the channel boundary. This filters out wick-only breaks.
Any Touch Mode: Breakout occurs when the close price exceeds the boundary.
When price closes above the upper channel boundary, a bullish breakout signal generates. When price closes below the lower boundary, a bearish breakout signal generates. The channel is then removed from the chart.
ATR-Based Risk Management:
The strategy uses request.security() to fetch ATR values from a specified timeframe, which can differ from the chart timeframe. For example, on a 5-minute chart, you can use 1-minute ATR for more responsive calculations. The ATR is calculated using ta.atr(length) with a user-defined period (default 14).
Exit levels are calculated at the moment of breakout:
Long Entry Price = Upper channel boundary
Long TP1 = Entry + (ATR × TP1 Multiplier)
Long TP2 = Entry + (ATR × TP2 Multiplier)
Long SL = Entry - (ATR × SL Multiplier)
For short trades, the calculation inverts:
Short Entry Price = Lower channel boundary
Short TP1 = Entry - (ATR × TP1 Multiplier)
Short TP2 = Entry - (ATR × TP2 Multiplier)
Short SL = Entry + (ATR × SL Multiplier)
Trade Execution Logic:
When a breakout occurs, the strategy checks if trading hours filter is satisfied (if enabled) and if position size equals zero (no existing position). If volume confirmation is enabled, it also verifies that current volume exceeds 1.2 times the 20-period simple moving average.
If all conditions are met:
strategy.entry() opens a position using the user-defined number of contracts
strategy.exit() immediately places a stop loss order
The code monitors price against TP1 and TP2 levels on each bar
When price reaches TP1, strategy.close() closes the specified number of contracts (e.g., if you enter with 3 contracts and set TP1 close to 1, it closes 1 contract). When price reaches TP2, it closes all remaining contracts. If stop loss is hit first, the entire position exits via the strategy.exit() order.
Volume Analysis System:
The strategy uses ta.requestUpAndDownVolume(timeframe) to fetch up volume, down volume, and volume delta from a specified timeframe. Three display modes are available:
Volume Mode: Shows total volume as bars scaled relative to the 20-period average
Comparison Mode: Shows up volume and down volume as separate bars above/below the channel midline
Delta Mode: Shows net volume delta (up volume - down volume) as bars, positive values above midline, negative below
The volume confirmation logic compares breakout bar volume to the 20-period SMA. If volume ÷ average > 1.2, the breakout is classified as "confirmed." When volume confirmation is enabled in settings, only confirmed breakouts generate trades.
INPUT PARAMETERS:
Strategy Settings:
Number of Contracts: Fixed quantity to trade per signal (1-1000)
Require Volume Confirmation: Toggle to only trade signals with volume >120% of average
TP1 Close Contracts: Exact number of contracts to close at first target (1-1000)
Use Trading Hours Filter: Toggle to restrict trading to specified session
Trading Hours: Session input in HHMM-HHMM format (e.g., "0930-1600")
Main Settings:
Normalization Length: Lookback bars for high/low calculation (1-500, default 100)
Box Detection Length: Period for volatility peak/trough detection (1-100, default 14)
Strong Closes Only: Toggle between body midpoint vs close price for breakout detection
Nested Channels: Allow multiple overlapping channels vs single channel at a time
ATR TP/SL Settings:
ATR Timeframe: Source timeframe for ATR calculation (1, 5, 15, 60, etc.)
ATR Length: Smoothing period for ATR (1-100, default 14)
Take Profit 1 Multiplier: Distance from entry as multiple of ATR (0.1-10.0, default 2.0)
Take Profit 2 Multiplier: Distance from entry as multiple of ATR (0.1-10.0, default 3.0)
Stop Loss Multiplier: Distance from entry as multiple of ATR (0.1-10.0, default 1.0)
Enable Take Profit 2: Toggle second profit target on/off
VISUAL INDICATORS:
Channel boxes with semi-transparent fill showing consolidation zones
Green/red colored zones at channel boundaries indicating breakout areas
Volume bars displayed within channels using selected mode
TP/SL lines with labels showing both price level and distance in points
Entry signals marked with up/down triangles at breakout price
Strategy status table showing position, contracts, P&L, ATR values, and volume confirmation status
HOW TO USE:
For 2-Minute Scalping:
Set ATR Timeframe to "1" (1-minute), ATR Length to 12, TP1 Multiplier to 2.0, TP2 Multiplier to 3.0, SL Multiplier to 1.5. Enable volume confirmation and strong closes only. Use trading hours filter to avoid low-volume periods.
For 5-15 Minute Day Trading:
Set ATR Timeframe to match chart or use 5-minute, ATR Length to 14, TP1 Multiplier to 2.0, TP2 Multiplier to 3.5, SL Multiplier to 1.2. Volume confirmation recommended but optional.
For Hourly+ Swing Trading:
Set ATR Timeframe to 15-30 minute, ATR Length to 14-21, TP1 Multiplier to 2.5, TP2 Multiplier to 4.0, SL Multiplier to 1.5. Volume confirmation optional, nested channels can be enabled for multiple setups.
BACKTEST CONSIDERATIONS:
Strategy performs best during trending or volatility expansion phases
Consolidation-heavy or choppy markets produce more false signals
Shorter timeframes require wider stop loss multipliers due to noise
Commission and slippage significantly impact performance on sub-5-minute charts
Volume confirmation generally improves win rate but reduces trade frequency
ATR multipliers should be optimized for specific instrument characteristics
COMPATIBLE MARKETS:
Works on any instrument with price and volume data including forex pairs, stock indices, individual stocks, cryptocurrency, commodities, and futures contracts. Requires TradingView data feed that includes volume for volume confirmation features to function.
KNOWN LIMITATIONS:
Stop losses execute via strategy.exit() and may not fill at exact levels during gaps or extreme volatility
request.security() on lower timeframes requires higher-tier TradingView subscription
False breakouts inherent to breakout strategies cannot be completely eliminated
Performance varies significantly based on market regime (trending vs ranging)
Partial closing logic requires sufficient position size relative to TP1 close contracts setting
RISK DISCLOSURE:
Trading involves substantial risk of loss. Past performance of this or any strategy does not guarantee future results. This strategy is provided for educational purposes and automated backtesting. Thoroughly test on historical data and paper trade before risking real capital. Market conditions change and strategies that worked historically may fail in the future. Use appropriate position sizing and never risk more than you can afford to lose. Consider consulting a licensed financial advisor before making trading decisions.
ACKNOWLEDGMENT & CREDITS:
This strategy is built upon the channel detection methodology created by AlgoAlpha in the "Smart Money Breakout Channels" indicator. Full credit and appreciation to AlgoAlpha for pioneering the normalized volatility approach to identifying consolidation patterns and sharing this innovative technique with the TradingView community. The enhancements added to the original concept include automated trade execution, multi-timeframe ATR-based risk management, partial position closing by contract count, volume confirmation filtering, and real-time position monitoring.
Double Top/Bottom Screener - Today Only v2 //@version=6
indicator("Double Top/Bottom Screener - Today Only", overlay=true, max_lines_count=500)
// Inputs
leftBars = input.int(5, "Left Bars")
rightBars = input.int(5, "Right Bars")
tolerance = input.float(0.02, "Max Difference (e.g., 0.02 for 2 cents)", step=0.01)
atrLength = input.int(14, "ATR Length for Normalized Distance", minval=1)
requiredPeaks = input.int(3, "Required Identical Peaks", minval=2, maxval=5)
// Declarations of persistent variables and arrays
var array resistanceLevels = array.new(0)
var array resistanceCounts = array.new(0)
var array supportLevels = array.new(0)
var array supportCounts = array.new(0)
var array resLines = array.new(0)
var array supLines = array.new(0)
var bool hasDoubleTop = false
var bool hasDoubleBottom = false
var float doubleTopLevel = na
var float doubleBottomLevel = na
var int todayStart = na
// Step 1: Identify Swing Highs/Lows
swingHigh = ta.pivothigh(high, leftBars, rightBars)
swingLow = ta.pivotlow(low, leftBars, rightBars)
// Today's premarket start (04:00 AM ET)
todayStart := timestamp(syminfo.timezone, year, month, dayofmonth, 4, 0, 0)
// Clear arrays and delete lines on the first bar or new day
if barstate.isfirst or (dayofmonth != dayofmonth and time >= todayStart)
// Delete all existing lines only if arrays are not empty
if array.size(resLines) > 0
for i = array.size(resLines) - 1 to 0
line.delete(array.get(resLines, i))
if array.size(supLines) > 0
for i = array.size(supLines) - 1 to 0
line.delete(array.get(supLines, i))
// Clear arrays
array.clear(resistanceLevels)
array.clear(supportLevels)
array.clear(resistanceCounts)
array.clear(supportCounts)
array.clear(resLines)
array.clear(supLines)
// Reset flags
hasDoubleTop := false
hasDoubleBottom := false
doubleTopLevel := na
doubleBottomLevel := na
// Add new swings only if today and after premarket
if not na(swingHigh) and time >= todayStart and dayofmonth == dayofmonth
bool isEqualHigh = false
int peakIndex = -1
float prevLevel = na
if array.size(resistanceLevels) > 0
for i = 0 to array.size(resistanceLevels) - 1
prevLevel := array.get(resistanceLevels, i)
if math.abs(swingHigh - prevLevel) <= tolerance
isEqualHigh := true
peakIndex := i
break
if isEqualHigh and peakIndex >= 0
array.set(resistanceCounts, peakIndex, array.get(resistanceCounts, peakIndex) + 1)
if array.get(resistanceCounts, peakIndex) == requiredPeaks
hasDoubleTop := true
doubleTopLevel := prevLevel
else
array.push(resistanceLevels, swingHigh)
array.push(resistanceCounts, 1)
line newResLine = line.new(bar_index - rightBars, swingHigh, bar_index, swingHigh, color=color.red, width=2, extend=extend.none)
array.push(resLines, newResLine)
if not na(swingLow) and time >= todayStart and dayofmonth == dayofmonth
bool isEqualLow = false
int peakIndex = -1
float prevLevel = na
if array.size(supportLevels) > 0
for i = 0 to array.size(supportLevels) - 1
prevLevel := array.get(supportLevels, i)
if math.abs(swingLow - prevLevel) <= tolerance
isEqualLow := true
peakIndex := i
break
if isEqualLow and peakIndex >= 0
array.set(supportCounts, peakIndex, array.get(supportCounts, peakIndex) + 1)
if array.get(supportCounts, peakIndex) == requiredPeaks
hasDoubleBottom := true
doubleBottomLevel := prevLevel
else
array.push(supportLevels, swingLow)
array.push(supportCounts, 1)
line newSupLine = line.new(bar_index - rightBars, swingLow, bar_index, swingLow, color=color.green, width=2, extend=extend.none)
array.push(supLines, newSupLine)
// Monitor and remove broken levels/lines; reset pattern if the equal level breaks
if array.size(resistanceLevels) > 0
for i = array.size(resistanceLevels) - 1 to 0
float level = array.get(resistanceLevels, i)
if close > level
line.delete(array.get(resLines, i))
array.remove(resLines, i)
array.remove(resistanceLevels, i)
array.remove(resistanceCounts, i)
if level == doubleTopLevel
hasDoubleTop := false
doubleTopLevel := na
if array.size(supportLevels) > 0
for i = array.size(supportLevels) - 1 to 0
float level = array.get(supportLevels, i)
if close < level
line.delete(array.get(supLines, i))
array.remove(supLines, i)
array.remove(supportLevels, i)
array.remove(supportCounts, i)
if level == doubleBottomLevel
hasDoubleBottom := false
doubleBottomLevel := na
// Limit arrays (after removals)
if array.size(resistanceLevels) > 10
line oldLine = array.shift(resLines)
line.delete(oldLine)
array.shift(resistanceLevels)
array.shift(resistanceCounts)
if array.size(supportLevels) > 10
line oldLine = array.shift(supLines)
line.delete(oldLine)
array.shift(supportLevels)
array.shift(supportCounts)
// Pattern Signal: 1 only if the exact required number of peaks is met
patternSignal = (hasDoubleTop or hasDoubleBottom) ? 1 : 0
// New: Nearest Double Level Price
var float nearestDoubleLevel = na
if hasDoubleTop and not na(doubleTopLevel)
nearestDoubleLevel := doubleTopLevel
if hasDoubleBottom and not na(doubleBottomLevel)
nearestDoubleLevel := na(nearestDoubleLevel) ? doubleBottomLevel : (math.abs(close - doubleBottomLevel) < math.abs(close - nearestDoubleLevel) ? doubleBottomLevel : nearestDoubleLevel)
// New: Distance to Nearest Level (using ATR for normalization)
var float atr = ta.atr(atrLength)
var float distanceNormalizedATR = na
if not na(nearestDoubleLevel) and not na(atr) and atr > 0
distanceNormalizedATR := math.abs(close - nearestDoubleLevel) / atr
// Optional Bounce Signal (for reference)
bounceSignal = 0
if array.size(resistanceLevels) > 0
for i = 0 to array.size(resistanceLevels) - 1
float level = array.get(resistanceLevels, i)
if low <= level and high >= level and close < level
bounceSignal := 1
if array.size(supportLevels) > 0
for i = 0 to array.size(supportLevels) - 1
float level = array.get(supportLevels, i)
if high >= level and low <= level and close > level
bounceSignal := 1
// Outputs
plot(patternSignal, title="Pattern Signal", color=patternSignal == 1 ? color.purple : na, style=plot.style_circles)
plot(bounceSignal, title="Bounce Signal", color=bounceSignal == 1 ? color.yellow : na, style=plot.style_circles)
plot(nearestDoubleLevel, title="Nearest Double Level Price", color=color.orange)
plot(distanceNormalizedATR, title="Normalized Distance (ATR)", color=color.green)
bgcolor(patternSignal == 1 ? color.new(color.purple, 80) : na)
if patternSignal == 1 and barstate.isconfirmed
alert("Double Pattern detected on " + syminfo.ticker + " at " + str.tostring(close), alert.freq_once_per_bar_close)
if barstate.islast
var table infoTable = table.new(position.top_right, 1, 4, bgcolor=color.new(color.black, 50))
table.cell(infoTable, 0, 0, "Pattern: " + str.tostring(patternSignal), bgcolor=patternSignal == 1 ? color.purple : color.gray)
table.cell(infoTable, 0, 1, "Bounce: " + str.tostring(bounceSignal), bgcolor=bounceSignal == 1 ? color.yellow : color.gray)
table.cell(infoTable, 0, 2, "Level: " + str.tostring(nearestDoubleLevel, "#.##"), bgcolor=color.orange)
table.cell(infoTable, 0, 3, "ATR Dist: " + str.tostring(distanceNormalizedATR, "#.##"), bgcolor=color.green)
