Pivot Reversal Signals - Multi ConfirmationPivot Reversal Signals - Multi-Confirmation System
Overview
A comprehensive reversal detection indicator designed for daytraders that combines six independent technical signals to identify high-probability pivot points. The indicator uses a scoring system to classify signal strength as Weak, Medium, or Strong based on the number of confirmations present.
How It Works
The indicator monitors six key reversal signals simultaneously:
1. RSI Divergence - Detects when price makes new highs/lows but RSI shows weakening momentum
2. MACD Divergence - Identifies divergence between price action and MACD histogram
3. Key Level Touch - Confirms price is at significant support/resistance (previous day high/low, premarket high/low, VWAP, 50 SMA)
4. Reversal Candlestick Patterns - Recognizes bullish/bearish engulfing, hammers, and shooting stars
5. Moving Average Confluence - Validates bounces/rejections at stacked moving averages (9/20/50)
6. Volume Spike - Confirms increased participation (default: 1.5x average volume)
Signal Strength Classification
• Weak (3/6 confirmations) - Small circles for situational awareness only
• Medium (4/6 confirmations) - Regular triangles, viable entry signals
• Strong (5-6/6 confirmations) - Large triangles with background highlight, highest probability setups
Visual Features
• Entry Signals: Green triangles (up) for long entries, red triangles (down) for short entries
• Exit Warnings: Orange X markers when opposing signals appear
• Signal Labels: Show confirmation score (e.g., "5/6") and strength level
• Key Levels Displayed:
o Previous Day High/Low - Solid green/red lines (uses actual daily data)
o Premarket High/Low - Blue/orange circles (4:00 AM - 9:30 AM EST)
o VWAP - Purple line
o Moving Averages - 9 EMA (blue), 20 EMA (orange), 50 SMA (red)
• Background Tinting: Subtle color on strongest reversal zones
Key Level Detection
The indicator uses request.security() to accurately fetch previous day's high/low from daily timeframe data, ensuring precise level placement. Premarket high/low levels are dynamically tracked during premarket sessions (4:00 AM - 9:30 AM EST) and plotted throughout the trading day, providing critical support/resistance zones that often influence price action during regular hours.
Customizable Parameters
• Signal strength thresholds (adjust required confirmations)
• RSI settings (length, overbought/oversold levels)
• MACD parameters (fast/slow/signal lengths)
• Moving average periods
• Volume spike multiplier
• Toggle individual display elements (levels, MAs, labels)
Best Practices
• Use on 5-minute charts for entries, confirm on 15-minute for direction
• Focus on Medium and Strong signals; Weak signals provide context only
• Strong signals (5-6 confirmations) have the highest win rate
• Pay special attention to reversals at premarket high/low - these levels frequently hold
• Previous day high/low often acts as major support/resistance
• Always use proper risk management and stop losses
• Works best in moderately trending markets
Alert Capabilities
Set custom alerts for:
• Strong long/short signals
• All entry signals (medium + strong)
• Exit warnings for open positions
Ideal For
• Daytraders and scalpers (especially SPY, QQQ, and liquid equities)
• Swing traders seeking precise entries
• Traders who prefer confirmation-based systems
• Anyone looking to reduce false signals with multi-factor validation
• Traders who utilize premarket levels in their strategy
Technical Notes
• Uses Pine Script v6
• Premarket hours: 4:00 AM - 9:30 AM EST
• Previous day levels pulled from daily timeframe for accuracy
• Maximum 500 labels to maintain chart performance
• All key levels update dynamically in real-time
________________________________________
Note: This indicator provides signal analysis only and should be used as part of a complete trading strategy. Past performance does not guarantee future results. Always practice proper risk management.
在腳本中搜尋"价格在30元内股票"
Moving VWAP-KAMA CloudMoving VWAP-KAMA Cloud
Overview
The Moving VWAP-KAMA Cloud is a high-conviction trend filter designed to solve a major problem with standard indicators: Noise. By combining a smoothed Volume Weighted Average Price (MVWAP) with Kaufman’s Adaptive Moving Average (KAMA), this indicator creates a "Value Zone" that identifies the true structural trend while ignoring choppy price action.
Unlike brittle lines that break constantly, this cloud is "slow" by design—making it exceptionally powerful for spotting genuine trend reversals and filtering out fakeouts.
How It Works
This script uses a unique "Double Smoothing" architecture:
The Anchor (MVWAP): We take the standard VWAP and smooth it with a 30-period EMA. This represents the "Fair Value" baseline where volume has supported price over time.
The Filter (KAMA): We apply Kaufman's Adaptive Moving Average to the already smoothed MVWAP. KAMA is unique because it flattens out during low-volatility (choppy) periods and speeds up during high-momentum trends.
The Cloud:
Green/Teal Cloud: Bullish Structure (MVWAP > KAMA)
Purple Cloud: Bearish Structure (MVWAP < KAMA)
🔥 The "Reversal Slingshot" Strategy
Backtests reveal a powerful behavior during major trend changes, particularly after long bear markets:
The Resistance Phase: During a long-term downtrend, price will repeatedly rally into the Purple Cloud and get rejected. The flattened KAMA line acts as a "concrete ceiling," keeping the bearish trend intact.
The Breakout & Flip: When price finally breaks above the cloud with conviction, and the cloud flips Green, it signals a structural regime change.
The "Slingshot" Retest: Often, immediately after this flip, price will drop back into the top of the cloud. This is the "Slingshot" moment. The old resistance becomes new, hardened support.
The Rally: From this support bounce, stocks often launch into a sustained, multi-month bull run. This setup has been observed repeatedly at the bottom of major corrections.
How to Use This Indicator
1. Dynamic Support & Resistance
The KAMA Wall: When price retraces into the cloud, the KAMA line often flattens out, acting as a hard "floor" or "wall." A break of this wall usually signals a genuine trend change, not just a stop hunt.
2. Trend Confirmation (Regime Filter)
Bullish Regime: If price is holding above the cloud, only look for Long setups.
Bearish Regime: If price is holding below the cloud, only look for Short setups.
No-Trade Zone: If price is stuck inside the cloud, the market is traversing fair value. Stand aside until a clear winner emerges.
3. Multi-Timeframe Versatility
While designed for trend confirmation on higher timeframes (4H, Daily), this indicator adapts beautifully to lower timeframes (5m, 15m) for intraday scalping.
On Lower Timeframes: The cloud reacts much faster, acting as a dynamic "VWAP Band" that helps intraday traders stay on the right side of momentum during the session.
Settings
Moving VWAP Period (30): The lookback period for the base VWAP smoothing.
KAMA Settings (10, 10, 30): Controls the sensitivity of the adaptive filter.
Cloud Transparency: Adjust to keep your chart clean.
Alerts Included
Price Cross Over/Under MVWAP
Price Cross Over/Under KAMA
Cloud Flip (Bullish/Bearish Trend Change)
Tip for Traders
This is not a signal entry indicator. It is a Trend Conviction tool. Use it to filter your entries from faster indicators (like RSI or MACD). If your fast indicator signals "Buy" but the cloud is Purple, the probability is low. Wait for the Cloud Flip
Smart RSI MTF Matrix [DotGain]Summary
Are you tired of trading trend signals, only to miss the bigger picture because you are focused on a single timeframe?
The Smart RSI MTF Matrix is the ultimate "Cockpit View" for momentum traders. Unlike chart overlays that can sometimes clutter your price action, this indicator organizes RSI conditions across 10 different timeframes simultaneously into a clean, separate Heatmap pane.
It monitors everything from the 5-minute chart all the way up to the 12-Month view , giving you a complete X-ray vision of the market's momentum structure instantly.
⚙️ Core Components and Logic
The Smart RSI MTF Matrix relies on a sophisticated hierarchy to deliver clear, actionable context:
Multi-Timeframe Engine: The script runs 10 independent RSI calculations in the background, organized in rows from bottom (Short Term) to top (Long Term).
Classic RSI Thresholds:
Overbought (> 70): Indicates price may be extended to the upside.
Oversold (< 30): Indicates price may be extended to the downside.
Smart Visibility System (The "Secret Sauce"): Not all signals are equal. A 5-minute signal is "noise" compared to a Yearly signal. This indicator automatically applies Transparency to differentiate importance. The visibility increases by 10% for each higher timeframe slot (Row).
🚦 How to Read the Matrix
The indicator plots dots in 10 stacked rows. The position and opacity tell you the direction and significance:
🟥 RED DOTS (Overbought Condition)
Trigger: RSI is above 70 on that specific timeframe.
Meaning: Potential bearish reversal or pullback.
🟩 GREEN DOTS (Oversold Condition)
Trigger: RSI is below 30 on that specific timeframe.
Meaning: Potential bullish reversal or bounce.
⚪ GRAY DOTS (Neutral)
Trigger: RSI is between 30 and 70.
Meaning: No extreme momentum present.
👻 TRANSPARENCY (Signal Strength)
The visibility of the dot tells you exactly which Timeframe (Row) is triggered. The higher the row, the more solid the color:
Faint (10-30% Visibility): Rows 1-3 (5m, 15m, 1h). Used for scalping entries.
Medium (40-60% Visibility): Rows 4-6 (4h, 1D, 1W). Used for swing trading context.
Solid (70-100% Visibility): Rows 7-10 (1M, 3M, 6M, 12M). Used for identifying major macro cycles.
Visual Elements
Structure: Row 1 (Bottom) represents the 5-minute timeframe. Row 10 (Top) represents the 12-Month timeframe.
Vertical Alignment: If you see a vertical column of Red or Green dots, it indicates Multi-Timeframe Confluence —a highly probable reversal point.
Key Benefit
The goal of the Smart RSI MTF Matrix is to keep your main chart clean while providing maximum information. You can instantly see if a short-term pullback (Faint Green Dot) is happening within a long-term uptrend (Solid Gray/Red Dot), allowing for precision entries.
Have fun :)
Disclaimer
This "Smart RSI MTF Matrix" indicator is provided for informational and educational purposes only. It does not, and should not be construed as, financial, investment, or trading advice.
The signals generated by this tool (both "Buy" and "Sell" indications) are the result of a specific set of algorithmic conditions. They are not a direct recommendation to buy or sell any asset. All trading and investing in financial markets involves substantial risk of loss. You can lose all of your invested capital.
Past performance is not indicative of future results. The signals generated may produce false or losing trades. The creator (© DotGain) assumes no liability for any financial losses or damages you may incur as a result of using this indicator.
You are solely responsible for your own trading and investment decisions. Always conduct your own research (DYOR) and consider your personal risk tolerance before making any trades.
Patrice - GC M1 Bot (MACD EMA RSI)//@version=6
indicator("Patrice - GC M1 Bot (MACD EMA RSI)", overlay = true)
//----------------------
// Inputs (optimisés GC)
//----------------------
emaLenFast = input.int(9, "EMA rapide")
emaLenSlow = input.int(14, "EMA lente")
rsiLen = input.int(14, "RSI length")
atrLen = input.int(14, "ATR length")
volLen = input.int(20, "Volume moyenne")
slMult = input.float(0.4, "SL = ATR x", step = 0.1)
tpMult = input.float(0.7, "TP = ATR x", step = 0.1)
minAtr = input.float(0.7, "ATR minimum pour trader", step = 0.1)
maxDistEmaPct = input.float(0.3, "Distance max EMA9 (%)", step = 0.1)
//----------------------
// Indicateurs
//----------------------
ema9 = ta.ema(close, emaLenFast)
ema14 = ta.ema(close, emaLenSlow)
= ta.macd(close, 12, 26, 9)
hist = macdLine - signalLine
rsi = ta.rsi(close, rsiLen)
atr = ta.atr(atrLen)
volMa = ta.sma(volume, volLen)
//----------------------
// Session 9:30 - 11:00 (NY)
//----------------------
hourSession = hour(time, "America/New_York")
minuteSession = minute(time, "America/New_York")
inSession = (hourSession == 9 and minuteSession >= 30) or
(hourSession > 9 and hourSession < 11) or
(hourSession == 11 and minuteSession == 0)
//----------------------
// Filtres vol / ATR / distance EMA
//----------------------
volFilter = volume > volMa
atrFilter = atr > minAtr
distEmaPct = math.abs(close - ema9) / close * 100.0
distFilter = distEmaPct < maxDistEmaPct
//----------------------
// Tendance
//----------------------
bullTrend = close > ema9 and close > ema14 and ema9 > ema14
bearTrend = close < ema9 and close < ema14 and ema9 < ema14
//----------------------
// MACD : 2e barre
//----------------------
bullSecondBar = hist > 0 and hist > 0 and hist <= 0
bearSecondBar = hist < 0 and hist < 0 and hist >= 0
//----------------------
// Filtres RSI
//----------------------
rsiLongOk = rsi < 70 and rsi >= 45 and rsi <= 65
rsiShortOk = rsi > 30 and rsi >= 35 and rsi <= 55
//----------------------
// Gestion du risque (simple pour l'instant)
//----------------------
canTradeRisk = true
//----------------------
// Conditions d'entrée
//----------------------
longCond = bullTrend and bullSecondBar and rsiLongOk and inSession and volFilter and atrFilter and distFilter and canTradeRisk
shortCond = bearTrend and bearSecondBar and rsiShortOk and inSession and volFilter and atrFilter and distFilter and canTradeRisk
//----------------------
// SL / TP (info seulement, pas d'ordres)
//----------------------
slPoints = atr * slMult
tpPoints = atr * tpMult
longSL = close - slPoints
longTP = close + tpPoints
shortSL = close + slPoints
shortTP = close - tpPoints
//----------------------
// Visuels
//----------------------
plot(ema9, title = "EMA 9")
plot(ema14, title = "EMA 14")
plotshape(longCond, title = "Signal Long", style = shape.triangleup, location = location.belowbar, size = size.tiny, text = "L")
plotshape(shortCond, title = "Signal Short", style = shape.triangledown, location = location.abovebar, size = size.tiny, text = "S")
//----------------------
// Conditions d'ALERTE
//----------------------
alertcondition(longCond, title = "ALERTE LONG", message = "Signal LONG Patrice GC bot")
alertcondition(shortCond, title = "ALERTE SHORT", message = "Signal SHORT Patrice GC bot")
Smart Money Flow - Exchange & TVL Composite# Smart Money Flow - Exchange & TVL Composite Indicator
## Overview
The **Smart Money Flow (SMF)** indicator combines two powerful on-chain metrics - **Exchange Flows** and **Total Value Locked (TVL)** - to create a composite index that tracks institutional and "smart money" movement in the cryptocurrency market. This indicator helps traders identify accumulation and distribution phases by analyzing where capital is flowing.
## What It Does
This indicator normalizes and combines:
- **Exchange Net Flow** (from IntoTheBlock): Tracks Bitcoin/Ethereum movement to and from exchanges
- **Total Value Locked** (from DefiLlama): Measures capital locked in DeFi protocols
The composite index is displayed on a 0-100 scale with clear zones for overbought/oversold conditions.
## Core Concept
### Exchange Flows
- **Negative Flow (Outflows)** = Bullish Signal
- Coins moving OFF exchanges → Long-term holding/accumulation
- Indicates reduced selling pressure
- **Positive Flow (Inflows)** = Bearish Signal
- Coins moving TO exchanges → Preparation for selling
- Indicates potential distribution phase
### Total Value Locked (TVL)
- **Rising TVL** = Bullish Signal
- Capital flowing into DeFi protocols
- Increased ecosystem confidence
- **Falling TVL** = Bearish Signal
- Capital exiting DeFi protocols
- Decreased ecosystem confidence
### Combined Signals
**🟢 Strong Bullish (70-100):**
- Exchange outflows + Rising TVL
- Smart money accumulating and deploying capital
**🔴 Strong Bearish (0-30):**
- Exchange inflows + Falling TVL
- Smart money preparing to sell and exiting positions
**⚪ Neutral (40-60):**
- Mixed or balanced flows
## Key Features
### ✅ Auto-Detection
- Automatically detects chart symbol (BTC/ETH)
- Uses appropriate exchange flow data for each asset
### ✅ Weighted Composite
- Customizable weights for Exchange Flow and TVL components
- Default: 50/50 balance
### ✅ Normalized Scale
- 0-100 index scale
- Configurable lookback period for normalization (default: 90 days)
### ✅ Signal Zones
- **Overbought**: 70+ (Strong bullish pressure)
- **Oversold**: 30- (Strong bearish pressure)
- **Extreme**: 85+ / 15- (Very strong signals)
### ✅ Clean Interface
- Minimal visual clutter by default
- Only main index line and MA visible
- Optional elements can be enabled:
- Background color zones
- Divergence signals
- Trend change markers
- Info table with detailed metrics
### ✅ Divergence Detection
- Identifies when price diverges from smart money flows
- Potential reversal warning signals
### ✅ Alerts
- Extreme overbought/oversold conditions
- Trend changes (crossing 50 line)
- Bullish/bearish divergences
## How to Use
### 1. Trend Confirmation
- Index above 50 = Bullish trend
- Index below 50 = Bearish trend
- Use with price action for confirmation
### 2. Reversal Signals
- **Extreme readings** (>85 or <15) suggest potential reversal
- Look for divergences between price and indicator
### 3. Accumulation/Distribution
- **70+**: Accumulation phase - smart money buying/holding
- **30-**: Distribution phase - smart money selling
### 4. DeFi Health
- Monitor TVL component for DeFi ecosystem strength
- Combine with exchange flows for complete picture
## Settings
### Data Sources
- **Exchange Flow**: IntoTheBlock real-time data
- **TVL**: DefiLlama aggregated DeFi TVL
- **Manual Mode**: For testing or custom data
### Indicator Settings
- **Smoothing Period (MA)**: Default 14 periods
- **Normalization Lookback**: Default 90 days
- **Exchange Flow Weight**: Adjustable 0-100%
- **Overbought/Oversold Levels**: Customizable thresholds
### Visual Options
- Show/Hide Moving Average
- Show/Hide Zone Lines
- Show/Hide Background Colors
- Show/Hide Divergence Signals
- Show/Hide Trend Markers
- Show/Hide Info Table
## Data Requirements
⚠️ **Important Notes:**
- Uses **daily data** from IntoTheBlock and DefiLlama
- Works on any chart timeframe (data updates daily)
- Auto-switches between BTC and ETH based on chart
- All other crypto charts default to BTC exchange flow data
## Best Practices
1. **Use on Daily+ Timeframes**
- On-chain data is daily, most effective on D/W/M charts
2. **Combine with Price Action**
- Use as confirmation, not standalone signals
3. **Watch for Divergences**
- Price making new highs while indicator falling = warning
4. **Monitor Extreme Zones**
- Sustained readings >85 or <15 indicate strong conviction
5. **Context Matters**
- Consider broader market conditions and fundamentals
## Calculation
1. **Exchange Net Flow** = Inflows - Outflows (inverted for index)
2. **TVL Rate of Change** = % change over smoothing period
3. **Normalize** both metrics to 0-100 scale
4. **Composite Index** = (ExchangeFlow × Weight) + (TVL × Weight)
5. **Smooth** with moving average
## Disclaimer
This indicator uses on-chain data for analysis. While valuable, it should not be used as the sole basis for trading decisions. Always combine with other technical analysis tools, fundamental analysis, and proper risk management.
On-chain data reflects blockchain activity but may lag price action. Use this indicator as part of a comprehensive trading strategy.
---
## Credits
**Data Sources:**
- IntoTheBlock: Exchange flow metrics
- DefiLlama: Total Value Locked data
**Indicator by:** @iCD_creator
**Version:** 1.0
**Pine Script™ Version:** 6
---
## Updates & Support
For questions, suggestions, or bug reports, please comment below or message the author.
**Like this indicator? Leave a 👍 and share your feedback!**
Hash Supertrend [Hash Capital Research]Hash Supertrend Strategy by Hash Capital Research
Overview
Hash Supertrend is a professional-grade trend-following strategy that combines the proven Supertrend indicator with institutional visual design and flexible time filtering.
The strategy uses ATR-based volatility bands to identify trend direction and executes position reversals when the trend flips.This implementation features a distinctive fluorescent color system with customizable glow effects, making trend changes immediately visible while maintaining the clean, professional aesthetic expected in quantitative trading environments.
Entry Signals:
Long Entry: Price crosses above the Supertrend line (trend flips bullish)
Short Entry: Price crosses below the Supertrend line (trend flips bearish)
Controls the lookback period for volatility calculation
Lower values (7-10): More sensitive to price changes, generates more signals
Higher values (12-14): Smoother response, fewer signals but potentially delayed entries
Recommended range: 7-14 depending on market volatility
Factor (Default: 3.0)
Restricts trading to specific hours
Useful for avoiding low-liquidity sessions, overnight gaps, or known choppy periods
When disabled, strategy trades 24/7
Start Hour (Default: 9) & Start Minute (Default: 30)
Define when the trading session begins
Uses exchange timezone in 24-hour format
Example: 9:30 = 9:30 AM
End Hour (Default: 16) & End Minute (Default: 0)
Controls the vibrancy of the fluorescent color system
1-3: Subtle, muted colors
4-6: Balanced, moderate saturation
7-10: Bright, highly saturated fluorescent appearance
Affects both the Supertrend line and trend zones
Glow Effect (Default: On)
Adds luminous halo around the Supertrend line
Creates a multi-layered visual with depth
Particularly effective during strong trends
Glow Intensity (Default: 5.0)
Displays tiny fluorescent dots at entry points
Green dot below bar: Long entry
Red dot above bar: Short entry
Provides clear visual confirmation of executed trades
Show Trend Zone (Default: On)
Strong trending markets (2020-style bull runs, sustained bear markets)
Markets with clear directional bias
Instruments with consistent volatility patterns
Timeframes: 15m to Daily (optimal on 1H-4H)
Challenging Conditions:
Choppy, range-bound markets
Low volatility consolidation periods
Highly news-driven instruments with frequent gaps
Very low timeframes (1m-5m) prone to noise
Recommended AssetsCryptocurrency:
Steff- OBX- DTA OBX – US Open 15-Minute Zone Indicator
This indicator highlights the first 15 minutes of the U.S. stock market opening, also known as the OBX (Opening Balance Extension).
It is designed specifically for Nasdaq and S&P 500, which open at 09:30 New York time — corresponding to 15:30 Danish time.
What this indicator does:
• Marks the price range from 09:30–09:45 (U.S. time) as a zone on your chart
• Automatically adjusts to your local timezone, so the zone always aligns with Danish time
• Extends the zone to the right so you can track how price interacts with OBX throughout the day
• Draws all historical OBX zones so you can analyze previous reactions
• Rebuilds zones automatically when switching timeframes
• Detects breakouts from the zone
• Tracks balancing time only after a real breakout occurs
• Can automatically remove a zone if price spends a continuous amount of time inside it after the breakout (you set the minutes yourself)
• Allows full customization of OBX start time, duration, and behavior
• Individual zones can be manually deleted without being redrawn by the indicator
Why the OBX matters:
The OBX represents one of the most influential time windows in intraday trading because it reflects:
• The first injection of liquidity after the U.S. market opens
• Institutional positioning and algorithmic adjustments
• Early volatility and directional bias
• Common zones for reversals, breakouts, or mean reversion
• Key high-probability reaction levels used by professional traders
This indicator gives you a clear visual representation of when the market reacts to the U.S. open and how price interacts with the opening range throughout the session.
Kripto Fema ind/ This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// © Femayakup
//@version=5
indicator(title = "Kripto Fema ind", shorttitle="Kripto Fema ind", overlay=true, format=format.price, precision=2,max_lines_count = 500, max_labels_count = 500, max_bars_back=500)
showEma200 = input(true, title="EMA 200")
showPmax = input(true, title="Pmax")
showLinreg = input(true, title="Linreg")
showMavilim = input(true, title="Mavilim")
showNadaray = input(true, title="Nadaraya Watson")
ma(source, length, type) =>
switch type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)
//Ema200
timeFrame = input.timeframe(defval = '240',title= 'EMA200 TimeFrame',group = 'EMA200 Settings')
len200 = input.int(200, minval=1, title="Length",group = 'EMA200 Settings')
src200 = input(close, title="Source",group = 'EMA200 Settings')
offset200 = input.int(title="Offset", defval=0, minval=-500, maxval=500,group = 'EMA200 Settings')
out200 = ta.ema(src200, len200)
higherTimeFrame = request.security(syminfo.tickerid,timeFrame,out200 ,barmerge.gaps_on,barmerge.lookahead_on)
ema200Plot = showEma200 ? higherTimeFrame : na
plot(ema200Plot, title="EMA200", offset=offset200)
//Linreq
group1 = "Linreg Settings"
lengthInput = input.int(100, title="Length", minval = 1, maxval = 5000,group = group1)
sourceInput = input.source(close, title="Source")
useUpperDevInput = input.bool(true, title="Upper Deviation", inline = "Upper Deviation", group = group1)
upperMultInput = input.float(2.0, title="", inline = "Upper Deviation", group = group1)
useLowerDevInput = input.bool(true, title="Lower Deviation", inline = "Lower Deviation", group = group1)
lowerMultInput = input.float(2.0, title="", inline = "Lower Deviation", group = group1)
group2 = "Linreg Display Settings"
showPearsonInput = input.bool(true, "Show Pearson's R", group = group2)
extendLeftInput = input.bool(false, "Extend Lines Left", group = group2)
extendRightInput = input.bool(true, "Extend Lines Right", group = group2)
extendStyle = switch
extendLeftInput and extendRightInput => extend.both
extendLeftInput => extend.left
extendRightInput => extend.right
=> extend.none
group3 = "Linreg Color Settings"
colorUpper = input.color(color.new(color.blue, 85), "Linreg Renk", inline = group3, group = group3)
colorLower = input.color(color.new(color.red, 85), "", inline = group3, group = group3)
calcSlope(source, length) =>
max_bars_back(source, 5000)
if not barstate.islast or length <= 1
else
sumX = 0.0
sumY = 0.0
sumXSqr = 0.0
sumXY = 0.0
for i = 0 to length - 1 by 1
val = source
per = i + 1.0
sumX += per
sumY += val
sumXSqr += per * per
sumXY += val * per
slope = (length * sumXY - sumX * sumY) / (length * sumXSqr - sumX * sumX)
average = sumY / length
intercept = average - slope * sumX / length + slope
= calcSlope(sourceInput, lengthInput)
startPrice = i + s * (lengthInput - 1)
endPrice = i
var line baseLine = na
if na(baseLine) and not na(startPrice) and showLinreg
baseLine := line.new(bar_index - lengthInput + 1, startPrice, bar_index, endPrice, width=1, extend=extendStyle, color=color.new(colorLower, 0))
else
line.set_xy1(baseLine, bar_index - lengthInput + 1, startPrice)
line.set_xy2(baseLine, bar_index, endPrice)
na
calcDev(source, length, slope, average, intercept) =>
upDev = 0.0
dnDev = 0.0
stdDevAcc = 0.0
dsxx = 0.0
dsyy = 0.0
dsxy = 0.0
periods = length - 1
daY = intercept + slope * periods / 2
val = intercept
for j = 0 to periods by 1
price = high - val
if price > upDev
upDev := price
price := val - low
if price > dnDev
dnDev := price
price := source
dxt = price - average
dyt = val - daY
price -= val
stdDevAcc += price * price
dsxx += dxt * dxt
dsyy += dyt * dyt
dsxy += dxt * dyt
val += slope
stdDev = math.sqrt(stdDevAcc / (periods == 0 ? 1 : periods))
pearsonR = dsxx == 0 or dsyy == 0 ? 0 : dsxy / math.sqrt(dsxx * dsyy)
= calcDev(sourceInput, lengthInput, s, a, i)
upperStartPrice = startPrice + (useUpperDevInput ? upperMultInput * stdDev : upDev)
upperEndPrice = endPrice + (useUpperDevInput ? upperMultInput * stdDev : upDev)
var line upper = na
lowerStartPrice = startPrice + (useLowerDevInput ? -lowerMultInput * stdDev : -dnDev)
lowerEndPrice = endPrice + (useLowerDevInput ? -lowerMultInput * stdDev : -dnDev)
var line lower = na
if na(upper) and not na(upperStartPrice) and showLinreg
upper := line.new(bar_index - lengthInput + 1, upperStartPrice, bar_index, upperEndPrice, width=1, extend=extendStyle, color=color.new(colorUpper, 0))
else
line.set_xy1(upper, bar_index - lengthInput + 1, upperStartPrice)
line.set_xy2(upper, bar_index, upperEndPrice)
na
if na(lower) and not na(lowerStartPrice) and showLinreg
lower := line.new(bar_index - lengthInput + 1, lowerStartPrice, bar_index, lowerEndPrice, width=1, extend=extendStyle, color=color.new(colorUpper, 0))
else
line.set_xy1(lower, bar_index - lengthInput + 1, lowerStartPrice)
line.set_xy2(lower, bar_index, lowerEndPrice)
na
showLinregPlotUpper = showLinreg ? upper : na
showLinregPlotLower = showLinreg ? lower : na
showLinregPlotBaseLine = showLinreg ? baseLine : na
linefill.new(showLinregPlotUpper, showLinregPlotBaseLine, color = colorUpper)
linefill.new(showLinregPlotBaseLine, showLinregPlotLower, color = colorLower)
// Pearson's R
var label r = na
label.delete(r )
if showPearsonInput and not na(pearsonR) and showLinreg
r := label.new(bar_index - lengthInput + 1, lowerStartPrice, str.tostring(pearsonR, "#.################"), color = color.new(color.white, 100), textcolor=color.new(colorUpper, 0), size=size.normal, style=label.style_label_up)
//Mavilim
group4 = "Mavilim Settings"
mavilimold = input(false, title="Show Previous Version of MavilimW?",group=group4)
fmal=input(3,"First Moving Average length",group = group4)
smal=input(5,"Second Moving Average length",group = group4)
tmal=fmal+smal
Fmal=smal+tmal
Ftmal=tmal+Fmal
Smal=Fmal+Ftmal
M1= ta.wma(close, fmal)
M2= ta.wma(M1, smal)
M3= ta.wma(M2, tmal)
M4= ta.wma(M3, Fmal)
M5= ta.wma(M4, Ftmal)
MAVW= ta.wma(M5, Smal)
col1= MAVW>MAVW
col3= MAVWpmaxsrc ? pmaxsrc-pmaxsrc : 0
vdd1=pmaxsrc
ma = 0.0
if mav == "SMA"
ma := ta.sma(pmaxsrc, length)
ma
if mav == "EMA"
ma := ta.ema(pmaxsrc, length)
ma
if mav == "WMA"
ma := ta.wma(pmaxsrc, length)
ma
if mav == "TMA"
ma := ta.sma(ta.sma(pmaxsrc, math.ceil(length / 2)), math.floor(length / 2) + 1)
ma
if mav == "VAR"
ma := VAR
ma
if mav == "WWMA"
ma := WWMA
ma
if mav == "ZLEMA"
ma := ZLEMA
ma
if mav == "TSF"
ma := TSF
ma
ma
MAvg=getMA(pmaxsrc, length)
longStop = Normalize ? MAvg - Multiplier*atr/close : MAvg - Multiplier*atr
longStopPrev = nz(longStop , longStop)
longStop := MAvg > longStopPrev ? math.max(longStop, longStopPrev) : longStop
shortStop = Normalize ? MAvg + Multiplier*atr/close : MAvg + Multiplier*atr
shortStopPrev = nz(shortStop , shortStop)
shortStop := MAvg < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop
dir = 1
dir := nz(dir , dir)
dir := dir == -1 and MAvg > shortStopPrev ? 1 : dir == 1 and MAvg < longStopPrev ? -1 : dir
PMax = dir==1 ? longStop: shortStop
plot(showsupport ? MAvg : na, color=#fbff04, linewidth=2, title="EMA9")
pALL=plot(PMax, color=color.new(color.red, transp = 0), linewidth=2, title="PMax")
alertcondition(ta.cross(MAvg, PMax), title="Cross Alert", message="PMax - Moving Avg Crossing!")
alertcondition(ta.crossover(MAvg, PMax), title="Crossover Alarm", message="Moving Avg BUY SIGNAL!")
alertcondition(ta.crossunder(MAvg, PMax), title="Crossunder Alarm", message="Moving Avg SELL SIGNAL!")
alertcondition(ta.cross(pmaxsrc, PMax), title="Price Cross Alert", message="PMax - Price Crossing!")
alertcondition(ta.crossover(pmaxsrc, PMax), title="Price Crossover Alarm", message="PRICE OVER PMax - BUY SIGNAL!")
alertcondition(ta.crossunder(pmaxsrc, PMax), title="Price Crossunder Alarm", message="PRICE UNDER PMax - SELL SIGNAL!")
buySignalk = ta.crossover(MAvg, PMax)
plotshape(buySignalk and showsignalsk ? PMax*0.995 : na, title="Buy", text="Buy", location=location.absolute, style=shape.labelup, size=size.tiny, color=color.new(color.green, transp = 0), textcolor=color.white)
sellSignallk = ta.crossunder(MAvg, PMax)
plotshape(sellSignallk and showsignalsk ? PMax*1.005 : na, title="Sell", text="Sell", location=location.absolute, style=shape.labeldown, size=size.tiny, color=color.new(color.red, transp = 0), textcolor=color.white)
// buySignalc = ta.crossover(pmaxsrc, PMax)
// plotshape(buySignalc and showsignalsc ? PMax*0.995 : na, title="Buy", text="Buy", location=location.absolute, style=shape.labelup, size=size.tiny, color=#0F18BF, textcolor=color.white)
// sellSignallc = ta.crossunder(pmaxsrc, PMax)
// plotshape(sellSignallc and showsignalsc ? PMax*1.005 : na, title="Sell", text="Sell", location=location.absolute, style=shape.labeldown, size=size.tiny, color=#0F18BF, textcolor=color.white)
// mPlot = plot(ohlc4, title="", style=plot.style_circles, linewidth=0,display=display.none)
longFillColor = highlighting ? (MAvg>PMax ? color.new(color.green, transp = 90) : na) : na
shortFillColor = highlighting ? (MAvg math.exp(-(math.pow(x, 2)/(h * h * 2)))
//-----------------------------------------------------------------------------}
//Append lines
//-----------------------------------------------------------------------------{
n = bar_index
var ln = array.new_line(0)
if barstate.isfirst and repaint
for i = 0 to 499
array.push(ln,line.new(na,na,na,na))
//-----------------------------------------------------------------------------}
//End point method
//-----------------------------------------------------------------------------{
var coefs = array.new_float(0)
var den = 0.
if barstate.isfirst and not repaint
for i = 0 to 499
w = gauss(i, h)
coefs.push(w)
den := coefs.sum()
out = 0.
if not repaint
for i = 0 to 499
out += src * coefs.get(i)
out /= den
mae = ta.sma(math.abs(src - out), 499) * mult
upperN = out + mae
lowerN = out - mae
//-----------------------------------------------------------------------------}
//Compute and display NWE
//-----------------------------------------------------------------------------{
float y2 = na
float y1 = na
nwe = array.new(0)
if barstate.islast and repaint
sae = 0.
//Compute and set NWE point
for i = 0 to math.min(499,n - 1)
sum = 0.
sumw = 0.
//Compute weighted mean
for j = 0 to math.min(499,n - 1)
w = gauss(i - j, h)
sum += src * w
sumw += w
y2 := sum / sumw
sae += math.abs(src - y2)
nwe.push(y2)
sae := sae / math.min(499,n - 1) * mult
for i = 0 to math.min(499,n - 1)
if i%2 and showNadaray
line.new(n-i+1, y1 + sae, n-i, nwe.get(i) + sae, color = upCss)
line.new(n-i+1, y1 - sae, n-i, nwe.get(i) - sae, color = dnCss)
if src > nwe.get(i) + sae and src < nwe.get(i) + sae and showNadaray
label.new(n-i, src , '▼', color = color(na), style = label.style_label_down, textcolor = dnCss, textalign = text.align_center)
if src < nwe.get(i) - sae and src > nwe.get(i) - sae and showNadaray
label.new(n-i, src , '▲', color = color(na), style = label.style_label_up, textcolor = upCss, textalign = text.align_center)
y1 := nwe.get(i)
//-----------------------------------------------------------------------------}
//Dashboard
//-----------------------------------------------------------------------------{
var tb = table.new(position.top_right, 1, 1
, bgcolor = #1e222d
, border_color = #373a46
, border_width = 1
, frame_color = #373a46
, frame_width = 1)
if repaint
tb.cell(0, 0, 'Repainting Mode Enabled', text_color = color.white, text_size = size.small)
//-----------------------------------------------------------------------------}
//Plot
//-----------------------------------------------------------------------------}
// plot(repaint ? na : out + mae, 'Upper', upCss)
// plot(repaint ? na : out - mae, 'Lower', dnCss)
//Crossing Arrows
// plotshape(ta.crossunder(close, out - mae) ? low : na, "Crossunder", shape.labelup, location.absolute, color(na), 0 , text = '▲', textcolor = upCss, size = size.tiny)
// plotshape(ta.crossover(close, out + mae) ? high : na, "Crossover", shape.labeldown, location.absolute, color(na), 0 , text = '▼', textcolor = dnCss, size = size.tiny)
//-----------------------------------------------------------------------------}
//////////////////////////////////////////////////////////////////////////////////
enableD = input (true, "DIVERGANCE ON/OFF" , group="INDICATORS ON/OFF")
//DIVERGANCE
prd1 = input.int (defval=5 , title='PIVOT PERIOD' , minval=1, maxval=50 , group="DIVERGANCE")
source = input.string(defval='HIGH/LOW' , title='SOURCE FOR PIVOT POINTS' , options= , group="DIVERGANCE")
searchdiv = input.string(defval='REGULAR/HIDDEN', title='DIVERGANCE TYPE' , options= , group="DIVERGANCE")
showindis = input.string(defval='FULL' , title='SHOW INDICATORS NAME' , options= , group="DIVERGANCE")
showlimit = input.int(1 , title='MINIMUM NUMBER OF DIVERGANCES', minval=1, maxval=11 , group="DIVERGANCE")
maxpp = input.int (defval=20 , title='MAXIMUM PIVOT POINTS TO CHECK', minval=1, maxval=20 , group="DIVERGANCE")
maxbars = input.int (defval=200 , title='MAXIMUM BARS TO CHECK' , minval=30, maxval=200 , group="DIVERGANCE")
showlast = input (defval=false , title='SHOW ONLY LAST DIVERGANCE' , group="DIVERGANCE")
dontconfirm = input (defval=false , title="DON'T WAIT FOR CONFORMATION" , group="DIVERGANCE")
showlines = input (defval=false , title='SHOW DIVERGANCE LINES' , group="DIVERGANCE")
showpivot = input (defval=false , title='SHOW PIVOT POINTS' , group="DIVERGANCE")
calcmacd = input (defval=true , title='MACD' , group="DIVERGANCE")
calcmacda = input (defval=true , title='MACD HISTOGRAM' , group="DIVERGANCE")
calcrsi = input (defval=true , title='RSI' , group="DIVERGANCE")
calcstoc = input (defval=true , title='STOCHASTIC' , group="DIVERGANCE")
calccci = input (defval=true , title='CCI' , group="DIVERGANCE")
calcmom = input (defval=true , title='MOMENTUM' , group="DIVERGANCE")
calcobv = input (defval=true , title='OBV' , group="DIVERGANCE")
calcvwmacd = input (true , title='VWMACD' , group="DIVERGANCE")
calccmf = input (true , title='CHAIKIN MONEY FLOW' , group="DIVERGANCE")
calcmfi = input (true , title='MONEY FLOW INDEX' , group="DIVERGANCE")
calcext = input (false , title='CHECK EXTERNAL INDICATOR' , group="DIVERGANCE")
externalindi = input (defval=close , title='EXTERNAL INDICATOR' , group="DIVERGANCE")
pos_reg_div_col = input (defval=#ffffff , title='POSITIVE REGULAR DIVERGANCE' , group="DIVERGANCE")
neg_reg_div_col = input (defval=#00def6 , title='NEGATIVE REGULAR DIVERGANCE' , group="DIVERGANCE")
pos_hid_div_col = input (defval=#00ff0a , title='POSITIVE HIDDEN DIVERGANCE' , group="DIVERGANCE")
neg_hid_div_col = input (defval=#ff0015 , title='NEGATIVE HIDDEN DIVERGANCE' , group="DIVERGANCE")
reg_div_l_style_ = input.string(defval='SOLID' , title='REGULAR DIVERGANCE LINESTYLE' , options= , group="DIVERGANCE")
hid_div_l_style_ = input.string(defval='SOLID' , title='HIDDEN DIVERGANCE LINESTYLE' , options= , group="DIVERGANCE")
reg_div_l_width = input.int (defval=2 , title='REGULAR DIVERGANCE LINEWIDTH' , minval=1, maxval=5 , group="DIVERGANCE")
hid_div_l_width = input.int (defval=2 , title='HIDDEN DIVERGANCE LINEWIDTH' , minval=1, maxval=5 , group="DIVERGANCE")
showmas = input.bool (defval=false , title='SHOW MOVING AVERAGES (50 & 200)', inline='MA' , group="DIVERGANCE")
cma1col = input.color (defval=#ffffff , title='' , inline='MA' , group="DIVERGANCE")
cma2col = input.color (defval=#00def6 , title='' , inline='MA' , group="DIVERGANCE")
//PLOTS
plot(showmas ? ta.sma(close, 50) : na, color=showmas ? cma1col : na)
plot(showmas ? ta.sma(close, 200) : na, color=showmas ? cma2col : na)
var reg_div_l_style = reg_div_l_style_ == 'SOLID' ? line.style_solid : reg_div_l_style_ == 'DASHED' ? line.style_dashed : line.style_dotted
var hid_div_l_style = hid_div_l_style_ == 'SOLID' ? line.style_solid : hid_div_l_style_ == 'DASHED' ? line.style_dashed : line.style_dotted
rsi = ta.rsi(close, 14)
= ta.macd(close, 12, 26, 9)
moment = ta.mom(close, 10)
cci = ta.cci(close, 10)
Obv = ta.obv
stk = ta.sma(ta.stoch(close, high, low, 14), 3)
maFast = ta.vwma(close, 12)
maSlow = ta.vwma(close, 26)
vwmacd = maFast - maSlow
Cmfm = (close - low - (high - close)) / (high - low)
Cmfv = Cmfm * volume
cmf = ta.sma(Cmfv, 21) / ta.sma(volume, 21)
Mfi = ta.mfi(close, 14)
var indicators_name = array.new_string(11)
var div_colors = array.new_color(4)
if barstate.isfirst and enableD
array.set(indicators_name, 0, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 1, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 2, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 3, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 4, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 5, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 6, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 7, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 8, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 9, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 10, showindis == "DON'T SHOW" ? '' : '')
array.set(div_colors, 0, pos_reg_div_col)
array.set(div_colors, 1, neg_reg_div_col)
array.set(div_colors, 2, pos_hid_div_col)
array.set(div_colors, 3, neg_hid_div_col)
float ph1 = ta.pivothigh(source == 'CLOSE' ? close : high, prd1, prd1)
float pl1 = ta.pivotlow(source == 'CLOSE' ? close : low, prd1, prd1)
plotshape(ph1 and showpivot, text='H', style=shape.labeldown, color=color.new(color.white, 100), textcolor=#00def6, location=location.abovebar, offset=-prd1)
plotshape(pl1 and showpivot, text='L', style=shape.labelup, color=color.new(color.white, 100), textcolor=#ffffff, location=location.belowbar, offset=-prd1)
var int maxarraysize = 20
var ph_positions = array.new_int(maxarraysize, 0)
var pl_positions = array.new_int(maxarraysize, 0)
var ph_vals = array.new_float(maxarraysize, 0.)
var pl_vals = array.new_float(maxarraysize, 0.)
if ph1
array.unshift(ph_positions, bar_index)
array.unshift(ph_vals, ph1)
if array.size(ph_positions) > maxarraysize
array.pop(ph_positions)
array.pop(ph_vals)
if pl1
array.unshift(pl_positions, bar_index)
array.unshift(pl_vals, pl1)
if array.size(pl_positions) > maxarraysize
array.pop(pl_positions)
array.pop(pl_vals)
positive_regular_positive_hidden_divergence(src, cond) =>
divlen = 0
prsc = source == 'CLOSE' ? close : low
if dontconfirm or src > src or close > close
startpoint = dontconfirm ? 0 : 1
for x = 0 to maxpp - 1 by 1
len = bar_index - array.get(pl_positions, x) + prd1
if array.get(pl_positions, x) == 0 or len > maxbars
break
if len > 5 and (cond == 1 and src > src and prsc < nz(array.get(pl_vals, x)) or cond == 2 and src < src and prsc > nz(array.get(pl_vals, x)))
slope1 = (src - src ) / (len - startpoint)
virtual_line1 = src - slope1
slope2 = (close - close ) / (len - startpoint)
virtual_line2 = close - slope2
arrived = true
for y = 1 + startpoint to len - 1 by 1
if src < virtual_line1 or nz(close ) < virtual_line2
arrived := false
break
virtual_line1 -= slope1
virtual_line2 -= slope2
virtual_line2
if arrived
divlen := len
break
divlen
negative_regular_negative_hidden_divergence(src, cond) =>
divlen = 0
prsc = source == 'CLOSE' ? close : high
if dontconfirm or src < src or close < close
startpoint = dontconfirm ? 0 : 1
for x = 0 to maxpp - 1 by 1
len = bar_index - array.get(ph_positions, x) + prd1
if array.get(ph_positions, x) == 0 or len > maxbars
break
if len > 5 and (cond == 1 and src < src and prsc > nz(array.get(ph_vals, x)) or cond == 2 and src > src and prsc < nz(array.get(ph_vals, x)))
slope1 = (src - src ) / (len - startpoint)
virtual_line1 = src - slope1
slope2 = (close - nz(close )) / (len - startpoint)
virtual_line2 = close - slope2
arrived = true
for y = 1 + startpoint to len - 1 by 1
if src > virtual_line1 or nz(close ) > virtual_line2
arrived := false
break
virtual_line1 -= slope1
virtual_line2 -= slope2
virtual_line2
if arrived
divlen := len
break
divlen
//CALCULATIONS
calculate_divs(cond, indicator_1) =>
divs = array.new_int(4, 0)
array.set(divs, 0, cond and (searchdiv == 'REGULAR' or searchdiv == 'REGULAR/HIDDEN') ? positive_regular_positive_hidden_divergence(indicator_1, 1) : 0)
array.set(divs, 1, cond and (searchdiv == 'REGULAR' or searchdiv == 'REGULAR/HIDDEN') ? negative_regular_negative_hidden_divergence(indicator_1, 1) : 0)
array.set(divs, 2, cond and (searchdiv == 'HIDDEN' or searchdiv == 'REGULAR/HIDDEN') ? positive_regular_positive_hidden_divergence(indicator_1, 2) : 0)
array.set(divs, 3, cond and (searchdiv == 'HIDDEN' or searchdiv == 'REGULAR/HIDDEN') ? negative_regular_negative_hidden_divergence(indicator_1, 2) : 0)
divs
var all_divergences = array.new_int(44)
array_set_divs(div_pointer, index) =>
for x = 0 to 3 by 1
array.set(all_divergences, index * 4 + x, array.get(div_pointer, x))
array_set_divs(calculate_divs(calcmacd , macd) , 0)
array_set_divs(calculate_divs(calcmacda , deltamacd) , 1)
array_set_divs(calculate_divs(calcrsi , rsi) , 2)
array_set_divs(calculate_divs(calcstoc , stk) , 3)
array_set_divs(calculate_divs(calccci , cci) , 4)
array_set_divs(calculate_divs(calcmom , moment) , 5)
array_set_divs(calculate_divs(calcobv , Obv) , 6)
array_set_divs(calculate_divs(calcvwmacd, vwmacd) , 7)
array_set_divs(calculate_divs(calccmf , cmf) , 8)
array_set_divs(calculate_divs(calcmfi , Mfi) , 9)
array_set_divs(calculate_divs(calcext , externalindi), 10)
total_div = 0
for x = 0 to array.size(all_divergences) - 1 by 1
total_div += math.round(math.sign(array.get(all_divergences, x)))
total_div
if total_div < showlimit
array.fill(all_divergences, 0)
var pos_div_lines = array.new_line(0)
var neg_div_lines = array.new_line(0)
var pos_div_labels = array.new_label(0)
var neg_div_labels = array.new_label(0)
delete_old_pos_div_lines() =>
if array.size(pos_div_lines) > 0
for j = 0 to array.size(pos_div_lines) - 1 by 1
line.delete(array.get(pos_div_lines, j))
array.clear(pos_div_lines)
delete_old_neg_div_lines() =>
if array.size(neg_div_lines) > 0
for j = 0 to array.size(neg_div_lines) - 1 by 1
line.delete(array.get(neg_div_lines, j))
array.clear(neg_div_lines)
delete_old_pos_div_labels() =>
if array.size(pos_div_labels) > 0
for j = 0 to array.size(pos_div_labels) - 1 by 1
label.delete(array.get(pos_div_labels, j))
array.clear(pos_div_labels)
delete_old_neg_div_labels() =>
if array.size(neg_div_labels) > 0
for j = 0 to array.size(neg_div_labels) - 1 by 1
label.delete(array.get(neg_div_labels, j))
array.clear(neg_div_labels)
delete_last_pos_div_lines_label(n) =>
if n > 0 and array.size(pos_div_lines) >= n
asz = array.size(pos_div_lines)
for j = 1 to n by 1
line.delete(array.get(pos_div_lines, asz - j))
array.pop(pos_div_lines)
if array.size(pos_div_labels) > 0
label.delete(array.get(pos_div_labels, array.size(pos_div_labels) - 1))
array.pop(pos_div_labels)
delete_last_neg_div_lines_label(n) =>
if n > 0 and array.size(neg_div_lines) >= n
asz = array.size(neg_div_lines)
for j = 1 to n by 1
line.delete(array.get(neg_div_lines, asz - j))
array.pop(neg_div_lines)
if array.size(neg_div_labels) > 0
label.delete(array.get(neg_div_labels, array.size(neg_div_labels) - 1))
array.pop(neg_div_labels)
pos_reg_div_detected = false
neg_reg_div_detected = false
pos_hid_div_detected = false
neg_hid_div_detected = false
var last_pos_div_lines = 0
var last_neg_div_lines = 0
var remove_last_pos_divs = false
var remove_last_neg_divs = false
if pl1
remove_last_pos_divs := false
last_pos_div_lines := 0
last_pos_div_lines
if ph1
remove_last_neg_divs := false
last_neg_div_lines := 0
last_neg_div_lines
divergence_text_top = ''
divergence_text_bottom = ''
distances = array.new_int(0)
dnumdiv_top = 0
dnumdiv_bottom = 0
top_label_col = color.white
bottom_label_col = color.white
old_pos_divs_can_be_removed = true
old_neg_divs_can_be_removed = true
startpoint = dontconfirm ? 0 : 1
for x = 0 to 10 by 1
div_type = -1
for y = 0 to 3 by 1
if array.get(all_divergences, x * 4 + y) > 0
div_type := y
if y % 2 == 1
dnumdiv_top += 1
top_label_col := array.get(div_colors, y)
top_label_col
if y % 2 == 0
dnumdiv_bottom += 1
bottom_label_col := array.get(div_colors, y)
bottom_label_col
if not array.includes(distances, array.get(all_divergences, x * 4 + y))
array.push(distances, array.get(all_divergences, x * 4 + y))
new_line = showlines ? line.new(x1=bar_index - array.get(all_divergences, x * 4 + y), y1=source == 'CLOSE' ? close : y % 2 == 0 ? low : high , x2=bar_index - startpoint, y2=source == 'CLOSE' ? close : y % 2 == 0 ? low : high , color=array.get(div_colors, y), style=y < 2 ? reg_div_l_style : hid_div_l_style, width=y < 2 ? reg_div_l_width : hid_div_l_width) : na
if y % 2 == 0
if old_pos_divs_can_be_removed
old_pos_divs_can_be_removed := false
if not showlast and remove_last_pos_divs
delete_last_pos_div_lines_label(last_pos_div_lines)
last_pos_div_lines := 0
last_pos_div_lines
if showlast
delete_old_pos_div_lines()
array.push(pos_div_lines, new_line)
last_pos_div_lines += 1
remove_last_pos_divs := true
remove_last_pos_divs
if y % 2 == 1
if old_neg_divs_can_be_removed
old_neg_divs_can_be_removed := false
if not showlast and remove_last_neg_divs
delete_last_neg_div_lines_label(last_neg_div_lines)
last_neg_div_lines := 0
last_neg_div_lines
if showlast
delete_old_neg_div_lines()
array.push(neg_div_lines, new_line)
last_neg_div_lines += 1
remove_last_neg_divs := true
remove_last_neg_divs
if y == 0
pos_reg_div_detected := true
pos_reg_div_detected
if y == 1
neg_reg_div_detected := true
neg_reg_div_detected
if y == 2
pos_hid_div_detected := true
pos_hid_div_detected
if y == 3
neg_hid_div_detected := true
neg_hid_div_detected
if div_type >= 0
divergence_text_top += (div_type % 2 == 1 ? showindis != "DON'T SHOW" ? array.get(indicators_name, x) + '\n' : '' : '')
divergence_text_bottom += (div_type % 2 == 0 ? showindis != "DON'T SHOW" ? array.get(indicators_name, x) + '\n' : '' : '')
divergence_text_bottom
if showindis != "DON'T SHOW"
if dnumdiv_top > 0
divergence_text_top += str.tostring(dnumdiv_top)
divergence_text_top
if dnumdiv_bottom > 0
divergence_text_bottom += str.tostring(dnumdiv_bottom)
divergence_text_bottom
if divergence_text_top != ''
if showlast
delete_old_neg_div_labels()
array.push(neg_div_labels, label.new(x=bar_index, y=math.max(high, high ), color=top_label_col, style=label.style_diamond, size = size.auto))
if divergence_text_bottom != ''
if showlast
delete_old_pos_div_labels()
array.push(pos_div_labels, label.new(x=bar_index, y=math.min(low, low ), color=bottom_label_col, style=label.style_diamond, size = size.auto))
// POSITION AND SIZE
PosTable = input.string(defval="Bottom Right", title="Position", options= , group="Table Location & Size", inline="1")
SizTable = input.string(defval="Auto", title="Size", options= , group="Table Location & Size", inline="1")
Pos1Table = PosTable == "Top Right" ? position.top_right : PosTable == "Middle Right" ? position.middle_right : PosTable == "Bottom Right" ? position.bottom_right : PosTable == "Top Center" ? position.top_center : PosTable == "Middle Center" ? position.middle_center : PosTable == "Bottom Center" ? position.bottom_center : PosTable == "Top Left" ? position.top_left : PosTable == "Middle Left" ? position.middle_left : position.bottom_left
Siz1Table = SizTable == "Auto" ? size.auto : SizTable == "Huge" ? size.huge : SizTable == "Large" ? size.large : SizTable == "Normal" ? size.normal : SizTable == "Small" ? size.small : size.tiny
tbl = table.new(Pos1Table, 21, 16, border_width = 1, border_color = color.gray, frame_color = color.gray, frame_width = 1)
// Kullanıcı tarafından belirlenecek yeşil ve kırmızı zaman dilimi sayısı
greenThreshold = input.int(5, minval=1, maxval=10, title="Yeşil Zaman Dilimi Sayısı", group="Alarm Ayarları")
redThreshold = input.int(5, minval=1, maxval=10, title="Kırmızı Zaman Dilimi Sayısı", group="Alarm Ayarları")
// TIMEFRAMES OPTIONS
box01 = input.bool(true, "TF ", inline = "01", group="Select Timeframe")
tf01 = input.timeframe("1", "", inline = "01", group="Select Timeframe")
box02 = input.bool(false, "TF ", inline = "02", group="Select Timeframe")
tf02 = input.timeframe("3", "", inline = "02", group="Select Timeframe")
box03 = input.bool(true, "TF ", inline = "03", group="Select Timeframe")
tf03 = input.timeframe("5", "", inline = "03", group="Select Timeframe")
box04 = input.bool(true, "TF ", inline = "04", group="Select Timeframe")
tf04 = input.timeframe("15", "", inline = "04", group="Select Timeframe")
box05 = input.bool(false, "TF ", inline = "05", group="Select Timeframe")
tf05 = input.timeframe("30", "", inline = "05", group="Select Timeframe")
box06 = input.bool(true, "TF ", inline = "01", group="Select Timeframe")
tf06 = input.timeframe("60", "", inline = "01", group="Select Timeframe")
box07 = input.bool(false, "TF ", inline = "02", group="Select Timeframe")
tf07 = input.timeframe("120", "", inline = "02", group="Select Timeframe")
box08 = input.bool(false, "TF ", inline = "03", group="Select Timeframe")
tf08 = input.timeframe("180", "", inline = "03", group="Select Timeframe")
box09 = input.bool(true, "TF ", inline = "04", group="Select Timeframe")
tf09 = input.timeframe("240", "", inline = "04", group="Select Timeframe")
box10 = input.bool(false, "TF ", inline = "05", group="Select Timeframe")
tf10 = input.timeframe("D", "", inline = "05", group="Select Timeframe")
// indicator('Tillson FEMA', overlay=true)
length1 = input(1, 'FEMA Length')
a1 = input(0.7, 'Volume Factor')
e1 = ta.ema((high + low + 2 * close) / 4, length1)
e2 = ta.ema(e1, length1)
e3 = ta.ema(e2, length1)
e4 = ta.ema(e3, length1)
e5 = ta.ema(e4, length1)
e6 = ta.ema(e5, length1)
c1 = -a1 * a1 * a1
c2 = 3 * a1 * a1 + 3 * a1 * a1 * a1
c3 = -6 * a1 * a1 - 3 * a1 - 3 * a1 * a1 * a1
c4 = 1 + 3 * a1 + a1 * a1 * a1 + 3 * a1 * a1
FEMA = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3
tablocol1 = FEMA > FEMA
tablocol3 = FEMA < FEMA
color_1 = col1 ? color.rgb(149, 219, 35): col3 ? color.rgb(238, 11, 11) : color.yellow
plot(FEMA, color=color_1, linewidth=3, title='FEMA')
tilson1 = FEMA
tilson1a =FEMA
// DEFINITION OF VALUES
symbol = ticker.modify(syminfo.tickerid, syminfo.session)
tfArr = array.new(na)
tilson1Arr = array.new(na)
tilson1aArr = array.new(na)
// DEFINITIONS OF RSI & CCI FUNCTIONS APPENDED IN THE TIMEFRAME OPTIONS
cciNcciFun(tf, flg) =>
= request.security(symbol, tf, )
if flg and (barstate.isrealtime ? true : timeframe.in_seconds(timeframe.period) <= timeframe.in_seconds(tf))
array.push(tfArr, na(tf) ? timeframe.period : tf)
array.push(tilson1Arr, tilson_)
array.push(tilson1aArr, tilson1a_)
cciNcciFun(tf01, box01), cciNcciFun(tf02, box02), cciNcciFun(tf03, box03), cciNcciFun(tf04, box04),
cciNcciFun(tf05, box05), cciNcciFun(tf06, box06), cciNcciFun(tf07, box07), cciNcciFun(tf08, box08),
cciNcciFun(tf09, box09), cciNcciFun(tf10, box10)
// TABLE AND CELLS CONFIG
// Post Timeframe in format
tfTxt(x)=>
out = x
if not str.contains(x, "S") and not str.contains(x, "M") and
not str.contains(x, "W") and not str.contains(x, "D")
if str.tonumber(x)%60 == 0
out := str.tostring(str.tonumber(x)/60)+"H"
else
out := x + "m"
out
if barstate.islast
table.clear(tbl, 0, 0, 20, 15)
// TITLES
table.cell(tbl, 0, 0, "⏱", text_color=color.white, text_size=Siz1Table, bgcolor=#000000)
table.cell(tbl, 1, 0, "FEMA("+str.tostring(length1)+")", text_color=#FFFFFF, text_size=Siz1Table, bgcolor=#000000)
j = 1
greenCounter = 0 // Yeşil zaman dilimlerini saymak için bir sayaç
redCounter = 0
if array.size(tilson1Arr) > 0
for i = 0 to array.size(tilson1Arr) - 1
if not na(array.get(tilson1Arr, i))
//config values in the cells
TF_VALUE = array.get(tfArr,i)
tilson1VALUE = array.get(tilson1Arr, i)
tilson1aVALUE = array.get(tilson1aArr, i)
SIGNAL1 = tilson1VALUE >= tilson1aVALUE ? "▲" : tilson1VALUE <= tilson1aVALUE ? "▼" : na
// Yeşil oklar ve arka planı ayarla
greenArrowColor1 = SIGNAL1 == "▲" ? color.rgb(0, 255, 0) : color.rgb(255, 0, 0)
greenBgColor1 = SIGNAL1 == "▲" ? color.rgb(25, 70, 22) : color.rgb(93, 22, 22)
allGreen = tilson1VALUE >= tilson1aVALUE
allRed = tilson1VALUE <= tilson1aVALUE
// Determine background color for time text
timeBgColor = allGreen ? #194616 : (allRed ? #5D1616 : #000000)
txtColor = allGreen ? #00FF00 : (allRed ? #FF4500 : color.white)
if allGreen
greenCounter := greenCounter + 1
redCounter := 0
else if allRed
redCounter := redCounter + 1
greenCounter := 0
else
redCounter := 0
greenCounter := 0
// Dinamik pair değerini oluşturma
pair = "USDT_" + syminfo.basecurrency + "USDT"
// Bot ID için kullanıcı girişi
bot_id = input.int(12387976, title="Bot ID", minval=0,group ='3Comas Message', inline = '1') // Varsayılan değeri 12387976 olan bir tamsayı girişi alır
// E-posta tokenı için kullanıcı girişi
email_token = input("cd4111d4-549a-4759-a082-e8f45c91fa47", title="Email Token",group ='3Comas Message', inline = '1')
// USER INPUT FOR DELAY
delay_seconds = input.int(0, title="Delay Seconds", minval=0, maxval=86400,group ='3Comas Message', inline = '1')
// Dinamik mesajın oluşturulması
message = '{ "message_type": "bot", "bot_id": ' + str.tostring(bot_id) + ', "email_token": "' + email_token + '", "delay_seconds": ' + str.tostring(delay_seconds) + ', "pair": "' + pair + '"}'
// Kullanıcının belirlediği yeşil veya kırmızı zaman dilimi sayısına ulaşıldığında alarmı tetikle
if greenCounter >= greenThreshold
alert(message, alert.freq_once_per_bar_close)
// if redCounter >= redThreshold
// alert(message, alert.freq_once_per_bar_close)
// Kullanıcının belirlediği yeşil veya kırmızı zaman dilimi sayısına ulaşıldığında alarmı tetikle
// if greenCounter >= greenThreshold
// alert("Yeşil zaman dilimi sayısı " + str.tostring(greenThreshold) + " adede ulaştı", alert.freq_once_per_bar_close)
// if redCounter >= redThreshold
// alert("Kırmızı zaman dilimi sayısı " + str.tostring(redThreshold) + " adede ulaştı", alert.freq_once_per_bar_close)
table.cell(tbl, 0, j, tfTxt(TF_VALUE), text_color=txtColor, text_halign=text.align_left, text_size=Siz1Table, bgcolor=timeBgColor)
table.cell(tbl, 1, j, str.tostring(tilson1VALUE, "#.#######")+SIGNAL1, text_color=greenArrowColor1, text_halign=text.align_right, text_size=Siz1Table, bgcolor=greenBgColor1)
j += 1
prd = input.int(defval=10, title='Pivot Period', minval=4, maxval=30, group='Setup')
ppsrc = input.string(defval='High/Low', title='Source', options= , group='Setup')
maxnumpp = input.int(defval=20, title=' Maximum Number of Pivot', minval=5, maxval=100, group='Setup')
ChannelW = input.int(defval=10, title='Maximum Channel Width %', minval=1, group='Setup')
maxnumsr = input.int(defval=5, title=' Maximum Number of S/R', minval=1, maxval=10, group='Setup')
min_strength = input.int(defval=2, title=' Minimum Strength', minval=1, maxval=10, group='Setup')
labelloc = input.int(defval=20, title='Label Location', group='Colors', tooltip='Positive numbers reference future bars, negative numbers reference histical bars')
linestyle = input.string(defval='Dashed', title='Line Style', options= , group='Colors')
linewidth = input.int(defval=2, title='Line Width', minval=1, maxval=4, group='Colors')
resistancecolor = input.color(defval=color.red, title='Resistance Color', group='Colors')
supportcolor = input.color(defval=color.lime, title='Support Color', group='Colors')
showpp = input(false, title='Show Point Points')
float src1 = ppsrc == 'High/Low' ? high : math.max(close, open)
float src2 = ppsrc == 'High/Low' ? low : math.min(close, open)
float ph = ta.pivothigh(src1, prd, prd)
float pl = ta.pivotlow(src2, prd, prd)
plotshape(ph and showpp, text='H', style=shape.labeldown, color=na, textcolor=color.new(color.red, 0), location=location.abovebar, offset=-prd)
plotshape(pl and showpp, text='L', style=shape.labelup, color=na, textcolor=color.new(color.lime, 0), location=location.belowbar, offset=-prd)
Lstyle = linestyle == 'Dashed' ? line.style_dashed : linestyle == 'Solid' ? line.style_solid : line.style_dotted
//calculate maximum S/R channel zone width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * ChannelW / 100
var pivotvals = array.new_float(0)
if ph or pl
array.unshift(pivotvals, ph ? ph : pl)
if array.size(pivotvals) > maxnumpp // limit the array size
array.pop(pivotvals)
get_sr_vals(ind) =>
float lo = array.get(pivotvals, ind)
float hi = lo
int numpp = 0
for y = 0 to array.size(pivotvals) - 1 by 1
float cpp = array.get(pivotvals, y)
float wdth = cpp <= lo ? hi - cpp : cpp - lo
if wdth <= cwidth // fits the max channel width?
if cpp <= hi
lo := math.min(lo, cpp)
else
hi := math.max(hi, cpp)
numpp += 1
numpp
var sr_up_level = array.new_float(0)
var sr_dn_level = array.new_float(0)
sr_strength = array.new_float(0)
find_loc(strength) =>
ret = array.size(sr_strength)
for i = ret > 0 ? array.size(sr_strength) - 1 : na to 0 by 1
if strength <= array.get(sr_strength, i)
break
ret := i
ret
ret
check_sr(hi, lo, strength) =>
ret = true
for i = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
//included?
if array.get(sr_up_level, i) >= lo and array.get(sr_up_level, i) <= hi or array.get(sr_dn_level, i) >= lo and array.get(sr_dn_level, i) <= hi
if strength >= array.get(sr_strength, i)
array.remove(sr_strength, i)
array.remove(sr_up_level, i)
array.remove(sr_dn_level, i)
ret
else
ret := false
ret
break
ret
var sr_lines = array.new_line(11, na)
var sr_labels = array.new_label(11, na)
for x = 1 to 10 by 1
rate = 100 * (label.get_y(array.get(sr_labels, x)) - close) / close
label.set_text(array.get(sr_labels, x), text=str.tostring(label.get_y(array.get(sr_labels, x))) + '(' + str.tostring(rate, '#.##') + '%)')
label.set_x(array.get(sr_labels, x), x=bar_index + labelloc)
label.set_color(array.get(sr_labels, x), color=label.get_y(array.get(sr_labels, x)) >= close ? color.red : color.lime)
label.set_textcolor(array.get(sr_labels, x), textcolor=label.get_y(array.get(sr_labels, x)) >= close ? color.white : color.black)
label.set_style(array.get(sr_labels, x), style=label.get_y(array.get(sr_labels, x)) >= close ? label.style_label_down : label.style_label_up)
line.set_color(array.get(sr_lines, x), color=line.get_y1(array.get(sr_lines, x)) >= close ? resistancecolor : supportcolor)
if ph or pl
//because of new calculation, remove old S/R levels
array.clear(sr_up_level)
array.clear(sr_dn_level)
array.clear(sr_strength)
//find S/R zones
for x = 0 to array.size(pivotvals) - 1 by 1
= get_sr_vals(x)
if check_sr(hi, lo, strength)
loc = find_loc(strength)
// if strength is in first maxnumsr sr then insert it to the arrays
if loc < maxnumsr and strength >= min_strength
array.insert(sr_strength, loc, strength)
array.insert(sr_up_level, loc, hi)
array.insert(sr_dn_level, loc, lo)
// keep size of the arrays = 5
if array.size(sr_strength) > maxnumsr
array.pop(sr_strength)
array.pop(sr_up_level)
array.pop(sr_dn_level)
for x = 1 to 10 by 1
line.delete(array.get(sr_lines, x))
label.delete(array.get(sr_labels, x))
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
rate = 100 * (mid - close) / close
array.set(sr_labels, x + 1, label.new(x=bar_index + labelloc, y=mid, text=str.tostring(mid) + '(' + str.tostring(rate, '#.##') + '%)', color=mid >= close ? color.red : color.lime, textcolor=mid >= close ? color.white : color.black, style=mid >= close ? label.style_label_down : label.style_label_up))
array.set(sr_lines, x + 1, line.new(x1=bar_index, y1=mid, x2=bar_index - 1, y2=mid, extend=extend.both, color=mid >= close ? resistancecolor : supportcolor, style=Lstyle, width=linewidth))
f_crossed_over() =>
ret = false
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
if close <= mid and close > mid
ret := true
ret
ret
f_crossed_under() =>
ret = false
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
if close >= mid and close < mid
ret := true
ret
ret
alertcondition(f_crossed_over(), title='Resistance Broken', message='Resistance Broken')
alertcondition(f_crossed_under(), title='Support Broken', message='Support Broken')
Multitime ATR (5m/15m/30m)Special thanks to Ogura
“This indicator displays ATR values for timeframes shorter than 30 minutes.”
“An ATR indicator designed to visualize volatility across 5-minute, 15-minute, and 30-minute timeframes.”
30分未満のATRを表示するインジケーターです。おぐさんありがとう。
RSI MTF 15m + 1h (Oriol)//@version=5
indicator("RSI MTF 15m + 1h (Oriol)", overlay = false, timeframe = "", timeframe_gaps = true)
// ─── PARÀMETRES ─────────────────────────────────────────────
rsiLength = input.int(14, "Període RSI")
src = input.source(close, "Font de preu")
tfFast = input.timeframe("15", "Timeframe ràpid (RSI 15m)")
tfSlow = input.timeframe("60", "Timeframe lent (RSI 1h)")
showSignals = input.bool(true, "Mostrar senyals LONG/SHORT")
// ─── RSI MULTITIMEFRAME ────────────────────────────────────
// RSI del timeframe ràpid (per defecte 15m)
src_fast = request.security(syminfo.tickerid, tfFast, src)
rsi_fast = ta.rsi(src_fast, rsiLength)
// RSI del timeframe lent (per defecte 1h)
src_slow = request.security(syminfo.tickerid, tfSlow, src)
rsi_slow = ta.rsi(src_slow, rsiLength)
// ─── DIBUIX RSI ─────────────────────────────────────────────
plot(rsi_fast, title = "RSI ràpid (15m)", color = color.new(color.aqua, 0), linewidth = 2)
plot(rsi_slow, title = "RSI lent (1h)", color = color.new(color.orange, 0), linewidth = 2)
hline(70, "Sobrecomprat", color = color.new(color.red, 70), linestyle = hline.style_dashed)
hline(30, "Sobrevenut", color = color.new(color.lime, 70), linestyle = hline.style_dashed)
hline(50, "Mitja", color = color.new(color.gray, 80))
// ─── CONDICIONS D’EXEMPLE ───────────────────────────────────
// LONG: RSI 1h < 40 i RSI 15m creua cap amunt 30
// SHORT: RSI 1h > 60 i RSI 15m creua cap avall 70
longCond = (rsi_slow < 40) and ta.crossover(rsi_fast, 30)
shortCond = (rsi_slow > 60) and ta.crossunder(rsi_fast, 70)
// ─── SENYALS (SENSE SCOPE LOCAL) ────────────────────────────
plotshape(showSignals and longCond,
title = "Possible LONG",
style = shape.triangleup,
location = location.bottom,
color = color.new(color.lime, 0),
size = size.small,
text = "LONG")
plotshape(showSignals and shortCond,
title = "Possible SHORT",
style = shape.triangledown,
location = location.top,
color = color.new(color.red, 0),
size = size.small,
text = "SHORT")
// ─── ALERTES ────────────────────────────────────────────────
alertcondition(longCond, title = "Senyals LONG RSI 15m+1h",
message = "Condició LONG RSI 15m + 1h complerta")
alertcondition(shortCond, title = "Senyals SHORT RSI 15m+1h",
message = "Condició SHORT RSI 15m + 1h complerta")
RSI (Custom Background) KDMThis code is a custom version of the RSI (Relative Strength Index) indicator.
Its main purpose is to compare recent price gains and losses to determine whether the market is in an overbought or oversold condition.
30–50 zone (purple tone): represents a weak or pullback area.
50–70 zone (green tone): represents a strengthening or dominant buying area.
Additionally, when the RSI line moves above 70, a green gradient background highlights the overbought region; when it moves below 30, a red gradient background emphasizes the oversold region.
Like the classic RSI, this version is a momentum indicator showing whether the price is losing or gaining strength.
The key difference is the colored background, which allows you to visually identify the RSI zones (e.g., 30–50 weak, 50–70 strong) much faster and more clearly.
SJ Fx Session RangeSJ Fx Session Range Indicator
A Professional Forex Session Tracking Tool with Opening Range Analysis
Overview
The SJ Fx Session Range indicator is a comprehensive tool designed to help forex traders visualize major trading sessions (Asia, Europe+London, and New York) along with their first 15-minute opening ranges. Built with Pine Script v5, this indicator provides clear session boundaries, high/low ranges, and customizable opening range analysis to enhance your trading decisions.
Key Features
1. Trading Session Boxes
- Three major forex sessions: Asia, Europe+London, and New York
- Color-coded session boxes with transparent backgrounds for easy visualization
- Automatic session high/low tracking
- Session labels displayed inside boxes for quick identification
- Displays up to 50 historical sessions for pattern analysis
2. Opening Range Analysis
- Tracks first 15-minute opening range for Europe, London, and NY sessions
- Plots high, low, and mid-range levels
- Customizable line colors for each session's opening range
- Background highlights during the first 15 minutes of each session
- Helps identify potential breakout or reversal zones
3. Daylight Saving Time Support
- Built-in DST toggle for easy seasonal adjustment
- Automatically adjusts all session timings by 1 hour when enabled
- Clear tooltip instructions for when to enable/disable DST
- Default timings configured for IST timezone (Asia/Kolkata)
4. User-Friendly Design
- Clean input interface organized by session categories
- Fixed optimal settings for boxes and lines (50-day history)
- All session times are easily customizable with helpful tooltips
- Warning tooltips to prevent accidental timing changes
Default Session Times (when DST is disabled)
- Asia Session: 04:00 - 12:30 IST
- Europe + London Session: 12:30 - 20:00 IST
- New York Session: 20:00 - 02:30 IST
How to Use
1. Add to Chart: Apply the indicator to any forex pair chart
2. Adjust DST: Enable the "Start Daylight Saving Time Change" checkbox on the second Sunday in March; disable on the first Sunday in November
3. Customize Sessions: Toggle individual sessions on/off based on your trading preference
4. Opening Range Colors: Customize the opening range line colors for better visibility
5. Session Times: Default times are optimized for IST; modify only if trading from a different timezone
Technical Specifications
- Version: Pine Script v5
- Overlay: Yes (draws directly on price chart)
- Maximum Objects: 500 boxes, 500 lines
- History: 50 days of session data
- Timezone: Asia/Kolkata (IST) - customizable in code
Use Cases
- Identify high-liquidity trading periods
- Track session volatility patterns
- Monitor opening range breakouts/breakdowns
- Analyze session-specific price action
- Plan entries around major session opens
- Avoid trading during low-liquidity periods
Performance
Optimized for efficient rendering with:
- Fixed 50-day history limit for optimal performance
- Automatic cleanup of old session boxes and lines
- Lightweight code structure for fast chart loading
Customization Options
Available Inputs:
- Enable/disable individual sessions
- Adjust session timings (with safety tooltips)
- Toggle DST on/off
- Show/hide opening range analysis
- Customize opening range line colors for each session
Fixed for Optimal Performance:
- Session box colors (Asia: Aqua, Europe: Green, NY: Red)
- 50-day historical display
- Line width and style
- Mid-range line always displayed
Educational Value
This indicator helps traders:
- Understand forex market structure and session overlaps
- Recognize high-probability trading times
- Develop session-based trading strategies
- Improve timing of trade entries and exits
Open Source License
This script is published under Mozilla Public License 2.0, allowing you to:
- Use freely for personal trading
- Modify and adapt to your needs
- Learn from the code structure
- Share improvements with the community
Credits
Developed by Shantanu Joshi
- Designed for forex traders focusing on session-based strategies
- Built with clean, well-documented Pine Script v5 code
- Regular updates and improvements based on user feedback
Support & Feedback
If you find this indicator useful:
- Give it a thumbs up
- Share your trading results in the comments
- Suggest improvements or new features
- Report any issues for quick resolution
Disclaimer
This indicator is for educational and informational purposes only. It does not constitute financial advice. Always conduct your own research and risk management before making trading decisions. Past performance does not guarantee future results.
Compatible with: CFDs of forex pairs, commodities, indices, and crypto.
Best used on: 5-minutes
Recommended chart type: Candlestick charts
RSI Regime: Continuation vs Reversal Indicator Description: RSI Regime (Continuation vs. Reversal)
This indicator uses the standard Relative Strength Index (RSI) to analyze market momentum and categorize it into three "regimes." Its primary goal is to help you determine if an overbought (OB) or oversold (OS) signal is likely to be a continuation of the current trend or a reversal point.
It also identifies "Fast Trend Starts," which are exceptionally fast and powerful moves from one extreme to the other.
Core Features & How to Read It
1. The Three RSI Regimes (Background Color) The script calculates a moving average (SMA) of the RSI to determine the dominant medium-term momentum. This is shown as the background color:
Bull Regime (Green Background): The RSI's average is high (e.g., above 55). The market is in a clear uptrend.
Bear Regime (Red Background): The RSI's average is low (e.g., below 45). The market is in a clear downtrend.
Range Regime (Orange Background): The RSI's average is in the middle. The market is consolidating or undecided.
2. Overbought (OB) & Oversold (OS) Signals
When the RSI line crosses into the overbought (e.g., >70) or oversold (e.g., <30) zones, the indicator generates one of two types of signals:
A) Continuation Signals (Small Triangles: ►)
These signals suggest an OB/OS reading is just a "pause" and the main trend will likely continue.
Orange ► (at the top): Appears when RSI becomes overbought while the market is already in a Bull Regime. This suggests the uptrend is strong, and this OB signal may not lead to a big drop.
Teal ► (at the bottom): Appears when RSI becomes oversold while the market is already in a Bear Regime. This suggests the downtrend is strong, and this OS signal may not lead to a big bounce.
(Note: An optional Price EMA filter can be enabled to make these signals more strict.)
B) Reversal Signals (Small Labels: "OS→>50" / "OB→<50")
These labels appear after an OB/OS signal to confirm that a reversal has actually occurred.
"OS→>50 Reversal" (Aqua Label): Appears if the RSI becomes oversold and then recovers back above the 50 midline within a set number of bars. This confirms the oversold dip was a reversal point.
"OB→<50 Reversal" (Orange Label): Appears if the RSI becomes overbought and then falls back below the 50 midline within a set number of bars. This confirms the overbought peak was a reversal point.
3. "Fast Trend Starts" (Large Labels)
This is a unique feature that identifies the fastest percentile of market moves. It measures how many bars it takes for the RSI to go from one extreme to the other and flags when a move is in the top 5% (default) of all historical moves.
"Long Pullbacks (Fast OS→BullRange)" (Large Green Label): This powerful signal appears when the RSI moves from oversold (<30) all the way up to the bull range (>60) exceptionally fast. It identifies a very strong, fast, and decisive bounce that could signal the start of a new uptrend.
"Short Pumps (Fast OB→BearRange)" (Large Red Label): This appears when the RSI moves from overbought (>70) all the way down to the bear range (<40) exceptionally fast. It identifies a very sharp, fast rejection or "pump-and-dump" that could signal the start of a new downtrend.
Key User Inputs
RSI Length (14): The lookback period for the main RSI calculation.
OB (70) / OS (30): The standard overbought and oversold levels.
Bull/Bear Range Threshold (60/40): These are the levels used to confirm the "Fast Trend Starts." They are separate from the OB/OS levels.
RSI Regime SMA Length (21): The lookback period for the moving average that determines the background regime.
Use Price EMA filter (true): If checked, the small "Continuation" triangles will only appear if the price is also above (for bulls) or below (for bears) its own 50-period EMA.
Fastest X% duration (5.0): This sets the percentile for the "Fast Trend Start" labels. 5.0 means it only flags moves that are in the fastest 5% of all recorded moves.
Algorithm Predator - ML-liteAlgorithm Predator - ML-lite
This indicator combines four specialized trading agents with an adaptive multi-armed bandit selection system to identify high-probability trade setups. It is designed for swing and intraday traders who want systematic signal generation based on institutional order flow patterns , momentum exhaustion , liquidity dynamics , and statistical mean reversion .
Core Architecture
Why These Components Are Combined:
The script addresses a fundamental challenge in algorithmic trading: no single detection method works consistently across all market conditions. By deploying four independent agents and using reinforcement learning algorithms to select or blend their outputs, the system adapts to changing market regimes without manual intervention.
The Four Trading Agents
1. Spoofing Detector Agent 🎭
Detects iceberg orders through persistent volume at similar price levels over 5 bars
Identifies spoofing patterns via asymmetric wick analysis (wicks exceeding 60% of bar range with volume >1.8× average)
Monitors order clustering using simplified Hawkes process intensity tracking (exponential decay model)
Signal Logic: Contrarian—fades false breakouts caused by institutional manipulation
Best Markets: Consolidations, institutional trading windows, low-liquidity hours
2. Exhaustion Detector Agent ⚡
Calculates RSI divergence between price movement and momentum indicator over 5-bar window
Detects VWAP exhaustion (price at 2σ bands with declining volume)
Uses VPIN reversals (volume-based toxic flow dissipation) to identify momentum failure
Signal Logic: Counter-trend—enters when momentum extreme shows weakness
Best Markets: Trending markets reaching climax points, over-extended moves
3. Liquidity Void Detector Agent 💧
Measures Bollinger Band squeeze (width <60% of 50-period average)
Identifies stop hunts via 20-bar high/low penetration with immediate reversal and volume spike
Detects hidden liquidity absorption (volume >2× average with range <0.3× ATR)
Signal Logic: Breakout anticipation—enters after liquidity grab but before main move
Best Markets: Range-bound pre-breakout, volatility compression zones
4. Mean Reversion Agent 📊
Calculates price z-scores relative to 50-period SMA and standard deviation (triggers at ±2σ)
Implements Ornstein-Uhlenbeck process scoring (mean-reverting stochastic model)
Uses entropy analysis to detect algorithmic trading patterns (low entropy <0.25 = high predictability)
Signal Logic: Statistical reversion—enters when price deviates significantly from statistical equilibrium
Best Markets: Range-bound, low-volatility, algorithmically-dominated instruments
Adaptive Selection: Multi-Armed Bandit System
The script implements four reinforcement learning algorithms to dynamically select or blend agents based on performance:
Thompson Sampling (Default - Recommended):
Uses Bayesian inference with beta distributions (tracks alpha/beta parameters per agent)
Balances exploration (trying underused agents) vs. exploitation (using proven winners)
Each agent's win/loss history informs its selection probability
Lite Approximation: Uses pseudo-random sampling from price/volume noise instead of true random number generation
UCB1 (Upper Confidence Bound):
Calculates confidence intervals using: average_reward + sqrt(2 × ln(total_pulls) / agent_pulls)
Deterministic algorithm favoring agents with high uncertainty (potential upside)
More conservative than Thompson Sampling
Epsilon-Greedy:
Exploits best-performing agent (1-ε)% of the time
Explores randomly ε% of the time (default 10%, configurable 1-50%)
Simple, transparent, easily tuned via epsilon parameter
Gradient Bandit:
Uses softmax probability distribution over agent preference weights
Updates weights via gradient ascent based on rewards
Best for Blend mode where all agents contribute
Selection Modes:
Switch Mode: Uses only the selected agent's signal (clean, decisive)
Blend Mode: Combines all agents using exponentially weighted confidence scores controlled by temperature parameter (smooth, diversified)
Lock Agent Feature:
Optional manual override to force one specific agent
Useful after identifying which agent dominates your specific instrument
Only applies in Switch mode
Four choices: Spoofing Detector, Exhaustion Detector, Liquidity Void, Mean Reversion
Memory System
Dual-Layer Architecture:
Short-Term Memory: Stores last 20 trade outcomes per agent (configurable 10-50)
Long-Term Memory: Stores episode averages when short-term reaches transfer threshold (configurable 5-20 bars)
Memory Boost Mechanism: Recent performance modulates agent scores by up to ±20%
Episode Transfer: When an agent accumulates sufficient results, averages are condensed into long-term storage
Persistence: Manual restoration of learned parameters via input fields (alpha, beta, weights, microstructure thresholds)
How Memory Works:
Agent generates signal → outcome tracked after 8 bars (performance horizon)
Result stored in short-term memory (win = 1.0, loss = 0.0)
Short-term average influences agent's future scores (positive feedback loop)
After threshold met (default 10 results), episode averaged into long-term storage
Long-term patterns (weighted 30%) + short-term patterns (weighted 70%) = total memory boost
Market Microstructure Analysis
These advanced metrics quantify institutional order flow dynamics:
Order Flow Toxicity (Simplified VPIN):
Measures buy/sell volume imbalance over 20 bars: |buy_vol - sell_vol| / (buy_vol + sell_vol)
Detects informed trading activity (institutional players with non-public information)
Values >0.4 indicate "toxic flow" (informed traders active)
Lite Approximation: Uses simple open/close heuristic instead of tick-by-tick trade classification
Price Impact Analysis (Simplified Kyle's Lambda):
Measures market impact efficiency: |price_change_10| / sqrt(volume_sum_10)
Low values = large orders with minimal price impact ( stealth accumulation )
High values = retail-dominated moves with high slippage
Lite Approximation: Uses simplified denominator instead of regression-based signed order flow
Market Randomness (Entropy Analysis):
Counts unique price changes over 20 bars / 20
Measures market predictability
High entropy (>0.6) = human-driven, chaotic price action
Low entropy (<0.25) = algorithmic trading dominance (predictable patterns)
Lite Approximation: Simple ratio instead of true Shannon entropy H(X) = -Σ p(x)·log₂(p(x))
Order Clustering (Simplified Hawkes Process):
Tracks self-exciting event intensity (coordinated order activity)
Decays at 0.9× per bar, spikes +1.0 when volume >1.5× average
High intensity (>0.7) indicates clustering (potential spoofing/accumulation)
Lite Approximation: Simple exponential decay instead of full λ(t) = μ + Σ α·exp(-β(t-tᵢ)) with MLE
Signal Generation Process
Multi-Stage Validation:
Stage 1: Agent Scoring
Each agent calculates internal score based on its detection criteria
Scores must exceed agent-specific threshold (adjusted by sensitivity multiplier)
Agent outputs: Signal direction (+1/-1/0) and Confidence level (0.0-1.0)
Stage 2: Memory Boost
Agent scores multiplied by memory boost factor (0.8-1.2 based on recent performance)
Successful agents get amplified, failing agents get dampened
Stage 3: Bandit Selection/Blending
If Adaptive Mode ON:
Switch: Bandit selects single best agent, uses only its signal
Blend: All agents combined using softmax-weighted confidence scores
If Adaptive Mode OFF:
Traditional consensus voting with confidence-squared weighting
Signal fires when consensus exceeds threshold (default 70%)
Stage 4: Confirmation Filter
Raw signal must repeat for consecutive bars (default 3, configurable 2-4)
Minimum confidence threshold: 0.25 (25%) enforced regardless of mode
Trend alignment check: Long signals require trend_score ≥ -2, Short signals require trend_score ≤ 2
Stage 5: Cooldown Enforcement
Minimum bars between signals (default 10, configurable 5-15)
Prevents over-trading during choppy conditions
Stage 6: Performance Tracking
After 8 bars (performance horizon), signal outcome evaluated
Win = price moved in signal direction, Loss = price moved against
Results fed back into memory and bandit statistics
Trading Modes (Presets)
Pre-configured parameter sets:
Conservative: 85% consensus, 4 confirmations, 15-bar cooldown
Expected: 60-70% win rate, 3-8 signals/week
Best for: Swing trading, capital preservation, beginners
Balanced: 70% consensus, 3 confirmations, 10-bar cooldown
Expected: 55-65% win rate, 8-15 signals/week
Best for: Day trading, most traders, general use
Aggressive: 60% consensus, 2 confirmations, 5-bar cooldown
Expected: 50-58% win rate, 15-30 signals/week
Best for: Scalping, high-frequency trading, active management
Elite: 75% consensus, 3 confirmations, 12-bar cooldown
Expected: 58-68% win rate, 5-12 signals/week
Best for: Selective trading, high-conviction setups
Adaptive: 65% consensus, 2 confirmations, 8-bar cooldown
Expected: Varies based on learning
Best for: Experienced users leveraging bandit system
How to Use
1. Initial Setup (5 Minutes):
Select Trading Mode matching your style (start with Balanced)
Enable Adaptive Learning (recommended for automatic agent selection)
Choose Thompson Sampling algorithm (best all-around performance)
Keep Microstructure Metrics enabled for liquid instruments (>100k daily volume)
2. Agent Tuning (Optional):
Adjust Agent Sensitivity multipliers (0.5-2.0):
<0.8 = Highly selective (fewer signals, higher quality)
0.9-1.2 = Balanced (recommended starting point)
1.3 = Aggressive (more signals, lower individual quality)
Monitor dashboard for 20-30 signals to identify dominant agent
If one agent consistently outperforms, consider using Lock Agent feature
3. Bandit Configuration (Advanced):
Blend Temperature (0.1-2.0):
0.3 = Sharp decisions (best agent dominates)
0.5 = Balanced (default)
1.0+ = Smooth (equal weighting, democratic)
Memory Decay (0.8-0.99):
0.90 = Fast adaptation (volatile markets)
0.95 = Balanced (most instruments)
0.97+ = Long memory (stable trends)
4. Signal Interpretation:
Green triangle (▲): Long signal confirmed
Red triangle (▼): Short signal confirmed
Dashboard shows:
Active agent (highlighted row with ► marker)
Win rate per agent (green >60%, yellow 40-60%, red <40%)
Confidence bars (█████ = maximum confidence)
Memory size (short-term buffer count)
Colored zones display:
Entry level (current close)
Stop-loss (1.5× ATR)
Take-profit 1 (2.0× ATR)
Take-profit 2 (3.5× ATR)
5. Risk Management:
Never risk >1-2% per signal (use ATR-based stops)
Signals are entry triggers, not complete strategies
Combine with your own market context analysis
Consider fundamental catalysts and news events
Use "Confirming" status to prepare entries (not to enter early)
6. Memory Persistence (Optional):
After 50-100 trades, check Memory Export Panel
Record displayed alpha/beta/weight values for each agent
Record VPIN and Kyle threshold values
Enable "Restore From Memory" and input saved values to continue learning
Useful when switching timeframes or restarting indicator
Visual Components
On-Chart Elements:
Spectral Layers: EMA8 ± 0.5 ATR bands (dynamic support/resistance, colored by trend)
Energy Radiance: Multi-layer glow boxes at signal points (intensity scales with confidence, configurable 1-5 layers)
Probability Cones: Projected price paths with uncertainty wedges (15-bar projection, width = confidence × ATR)
Connection Lines: Links sequential signals (solid = same direction continuation, dotted = reversal)
Kill Zones: Risk/reward boxes showing entry, stop-loss, and dual take-profit targets
Signal Markers: Triangle up/down at validated entry points
Dashboard (Configurable Position & Size):
Regime Indicator: 4-level trend classification (Strong Bull/Bear, Weak Bull/Bear)
Mode Status: Shows active system (Adaptive Blend, Locked Agent, or Consensus)
Agent Performance Table: Real-time win%, confidence, and memory stats
Order Flow Metrics: Toxicity and impact indicators (when microstructure enabled)
Signal Status: Current state (Long/Short/Confirming/Waiting) with confirmation progress
Memory Panel (Configurable Position & Size):
Live Parameter Export: Alpha, beta, and weight values per agent
Adaptive Thresholds: Current VPIN sensitivity and Kyle threshold
Save Reminder: Visual indicator if parameters should be recorded
What Makes This Original
This script's originality lies in three key innovations:
1. Genuine Meta-Learning Framework:
Unlike traditional indicator mashups that simply display multiple signals, this implements authentic reinforcement learning (multi-armed bandits) to learn which detection method works best in current conditions. The Thompson Sampling implementation with beta distribution tracking (alpha for successes, beta for failures) is statistically rigorous and adapts continuously. This is not post-hoc optimization—it's real-time learning.
2. Episodic Memory Architecture with Transfer Learning:
The dual-layer memory system mimics human learning patterns:
Short-term memory captures recent performance (recency bias)
Long-term memory preserves historical patterns (experience)
Automatic transfer mechanism consolidates knowledge
Memory boost creates positive feedback loops (successful strategies become stronger)
This architecture allows the system to adapt without retraining , unlike static ML models that require batch updates.
3. Institutional Microstructure Integration:
Combines retail-focused technical analysis (RSI, Bollinger Bands, VWAP) with institutional-grade microstructure metrics (VPIN, Kyle's Lambda, Hawkes processes) typically found in academic finance literature and professional trading systems, not standard retail platforms. While simplified for Pine Script constraints, these metrics provide insight into informed vs. uninformed trading , a dimension entirely absent from traditional technical analysis.
Mashup Justification:
The four agents are combined specifically for risk diversification across failure modes:
Spoofing Detector: Prevents false breakout losses from manipulation
Exhaustion Detector: Prevents chasing extended trends into reversals
Liquidity Void: Exploits volatility compression (different regime than trending)
Mean Reversion: Provides mathematical anchoring when patterns fail
The bandit system ensures the optimal tool is automatically selected for each market situation, rather than requiring manual interpretation of conflicting signals.
Why "ML-lite"? Simplifications and Approximations
This is the "lite" version due to necessary simplifications for Pine Script execution:
1. Simplified VPIN Calculation:
Academic Implementation: True VPIN uses volume bucketing (fixed-volume bars) and tick-by-tick buy/sell classification via Lee-Ready algorithm or exchange-provided trade direction flags
This Implementation: 20-bar rolling window with simple open/close heuristic (close > open = buy volume)
Impact: May misclassify volume during ranging/choppy markets; works best in directional moves
2. Pseudo-Random Sampling:
Academic Implementation: Thompson Sampling requires true random number generation from beta distributions using inverse transform sampling or acceptance-rejection methods
This Implementation: Deterministic pseudo-randomness derived from price and volume decimal digits: (close × 100 - floor(close × 100)) + (volume % 100) / 100
Impact: Not cryptographically random; may have subtle biases in specific price ranges; provides sufficient variation for agent selection
3. Hawkes Process Approximation:
Academic Implementation: Full Hawkes process uses maximum likelihood estimation with exponential kernels: λ(t) = μ + Σ α·exp(-β(t-tᵢ)) fitted via iterative optimization
This Implementation: Simple exponential decay (0.9 multiplier) with binary event triggers (volume spike = event)
Impact: Captures self-exciting property but lacks parameter optimization; fixed decay rate may not suit all instruments
4. Kyle's Lambda Simplification:
Academic Implementation: Estimated via regression of price impact on signed order flow over multiple time intervals: Δp = λ × Δv + ε
This Implementation: Simplified ratio: price_change / sqrt(volume_sum) without proper signed order flow or regression
Impact: Provides directional indicator of impact but not true market depth measurement; no statistical confidence intervals
5. Entropy Calculation:
Academic Implementation: True Shannon entropy requires probability distribution: H(X) = -Σ p(x)·log₂(p(x)) where p(x) is probability of each price change magnitude
This Implementation: Simple ratio of unique price changes to total observations (variety measure)
Impact: Measures diversity but not true information entropy with probability weighting; less sensitive to distribution shape
6. Memory System Constraints:
Full ML Implementation: Neural networks with backpropagation, experience replay buffers (storing state-action-reward tuples), gradient descent optimization, and eligibility traces
This Implementation: Fixed-size array queues with simple averaging; no gradient-based learning, no state representation beyond raw scores
Impact: Cannot learn complex non-linear patterns; limited to linear performance tracking
7. Limited Feature Engineering:
Advanced Implementation: Dozens of engineered features, polynomial interactions (x², x³), dimensionality reduction (PCA, autoencoders), feature selection algorithms
This Implementation: Raw agent scores and basic market metrics (RSI, ATR, volume ratio); minimal transformation
Impact: May miss subtle cross-feature interactions; relies on agent-level intelligence rather than feature combinations
8. Single-Instrument Data:
Full Implementation: Multi-asset correlation analysis (sector ETFs, currency pairs, volatility indices like VIX), lead-lag relationships, risk-on/risk-off regimes
This Implementation: Only OHLCV data from displayed instrument
Impact: Cannot incorporate broader market context; vulnerable to correlated moves across assets
9. Fixed Performance Horizon:
Full Implementation: Adaptive horizon based on trade duration, volatility regime, or profit target achievement
This Implementation: Fixed 8-bar evaluation window
Impact: May evaluate too early in slow markets or too late in fast markets; one-size-fits-all approach
Performance Impact Summary:
These simplifications make the script:
✅ Faster: Executes in milliseconds vs. seconds (or minutes) for full academic implementations
✅ More Accessible: Runs on any TradingView plan without external data feeds, APIs, or compute servers
✅ More Transparent: All calculations visible in Pine Script (no black-box compiled models)
✅ Lower Resource Usage: <500 bars lookback, minimal memory footprint
⚠️ Less Precise: Approximations may reduce statistical edge by 5-15% vs. academic implementations
⚠️ Limited Scope: Cannot capture tick-level dynamics, multi-order-book interactions, or cross-asset flows
⚠️ Fixed Parameters: Some thresholds hardcoded rather than dynamically optimized
When to Upgrade to Full Implementation:
Consider professional Python/C++ versions with institutional data feeds if:
Trading with >$100K capital where precision differences materially impact returns
Operating in microsecond-competitive environments (HFT, market making)
Requiring regulatory-grade audit trails and reproducibility
Backtesting with tick-level precision for strategy validation
Need true real-time adaptation with neural network-based learning
For retail swing/day trading and position management, these approximations provide sufficient signal quality while maintaining usability, transparency, and accessibility. The core logic—multi-agent detection with adaptive selection—remains intact.
Technical Notes
All calculations use standard Pine Script built-in functions ( ta.ema, ta.atr, ta.rsi, ta.bb, ta.sma, ta.stdev, ta.vwap )
VPIN and Kyle's Lambda use simplified formulas optimized for OHLCV data (see "Lite" section above)
Thompson Sampling uses pseudo-random noise from price/volume decimal digits for beta distribution sampling
No repainting: All calculations use confirmed bar data (no forward-looking)
Maximum lookback: 500 bars (set via max_bars_back parameter)
Performance evaluation: 8-bar forward-looking window for reward calculation (clearly disclosed)
Confidence threshold: Minimum 0.25 (25%) enforced on all signals
Memory arrays: Dynamic sizing with FIFO queue management
Limitations and Disclaimers
Not Predictive: This indicator identifies patterns in historical data. It cannot predict future price movements with certainty.
Requires Human Judgment: Signals are entry triggers, not complete trading strategies. Must be confirmed with your own analysis, risk management rules, and market context.
Learning Period Required: The adaptive system requires 50-100 bars minimum to build statistically meaningful performance data for bandit algorithms.
Overfitting Risk: Restoring memory parameters from one market regime to a drastically different regime (e.g., low volatility to high volatility) may cause poor initial performance until system re-adapts.
Approximation Limitations: Simplified calculations (see "Lite" section) may underperform academic implementations by 5-15% in highly efficient markets.
No Guarantee of Profit: Past performance, whether backtested or live-traded, does not guarantee future performance. All trading involves risk of loss.
Forward-Looking Bias: Performance evaluation uses 8-bar forward window—this creates slight look-ahead for learning (though not for signals). Real-time performance may differ from indicator's internal statistics.
Single-Instrument Limitation: Does not account for correlations with related assets or broader market regime changes.
Recommended Settings
Timeframe: 15-minute to 4-hour charts (sufficient volatility for ATR-based stops; adequate bar volume for learning)
Assets: Liquid instruments with >100k daily volume (forex majors, large-cap stocks, BTC/ETH, major indices)
Not Recommended: Illiquid small-caps, penny stocks, low-volume altcoins (microstructure metrics unreliable)
Complementary Tools: Volume profile, order book depth, market breadth indicators, fundamental catalysts
Position Sizing: Risk no more than 1-2% of capital per signal using ATR-based stop-loss
Signal Filtering: Consider external confluence (support/resistance, trendlines, round numbers, session opens)
Start With: Balanced mode, Thompson Sampling, Blend mode, default agent sensitivities (1.0)
After 30+ Signals: Review agent win rates, consider increasing sensitivity of top performers or locking to dominant agent
Alert Configuration
The script includes built-in alert conditions:
Long Signal: Fires when validated long entry confirmed
Short Signal: Fires when validated short entry confirmed
Alerts fire once per bar (after confirmation requirements met)
Set alert to "Once Per Bar Close" for reliability
Taking you to school. — Dskyz, Trade with insight. Trade with anticipation.
MTF EMA Trading SystemHere's a comprehensive description and usage guide for publishing your MTF EMA Trading System indicator on TradingView:
MTF EMA Trading System - Pro Edition
📊 Indicator Overview
The MTF EMA Trading System is an advanced multi-timeframe exponential moving average indicator designed for traders seeking high-probability setups with multiple confirmations. Unlike simple EMA crossover systems, this indicator combines trend alignment, momentum, volume analysis, and previous day confluence to generate reliable long and short signals with optimal risk-reward ratios.
✨ Key Features
1. Multi-Timeframe EMA Analysis
Configure 5 independent EMAs (default: 9, 21, 50, 100, 200)
Each EMA can pull data from ANY timeframe (5m, 15m, 1H, 4H, 1D, etc.)
Color-coded lines with customizable widths
End-of-line labels showing EMA period and timeframe (e.g., "EMA200 ")
Perfect for analyzing higher timeframe trends on lower timeframe charts
2. Advanced Signal Generation (Beyond Simple Crosses)
The system requires MULTIPLE confirmations before generating a signal:
LONG Signals Require:
✅ Price action trigger (EMA cross, bounce from key EMA, or pullback setup)
✅ Bullish EMA alignment (EMAs in proper ascending order)
✅ Volume spike confirmation (configurable threshold)
✅ RSI momentum confirmation (bullish but not overbought)
✅ Sufficient EMA separation (avoids choppy/whipsaw conditions)
✅ Price above previous day's low (confluence with support)
SHORT Signals Require:
✅ Price action trigger (EMA cross, rejection from key EMA, or pullback setup)
✅ Bearish EMA alignment (EMAs in proper descending order)
✅ Volume spike confirmation
✅ RSI momentum confirmation (bearish but not oversold)
✅ Sufficient EMA separation
✅ Price below previous day's high (confluence with resistance)
3. Real-Time Dashboard
Displays critical market conditions at a glance:
Overall trend direction (Bullish/Bearish/Neutral)
Price position relative to all EMAs
Volume status (spike or normal)
RSI momentum reading
EMA confluence strength
EMA separation quality
Current ATR value
Previous day high/low levels
Current signal status (LONG/SHORT/WAIT)
Risk-reward ratio
4. Clean Visual Design
Large, clear trade signal markers (green triangles for LONG, red triangles for SHORT)
No chart clutter - only essential information displayed
Customizable signal sizes
Professional color-coded dashboard
5. Built-In Risk Management
ATR-based calculations for stop loss placement
1:2 risk-reward ratio by default
All levels displayed in dashboard for easy reference
🎯 How to Use This Indicator
Step 1: Initial Setup
Add the indicator to your TradingView chart
Configure your preferred timeframes for each EMA:
EMA 9: Leave blank (uses chart timeframe) - Fast reaction to price
EMA 21: Leave blank or set to 15m - Key pivot level
EMA 50: Set to 1H - Intermediate trend
EMA 100: Set to 4H - Major trend filter
EMA 200: Set to 1D - Overall market bias
Adjust signal settings based on your trading style:
Conservative: Keep all confirmations enabled
Aggressive: Disable volume or momentum requirements
Scalping: Reduce min EMA separation to 0.2-0.3%
Step 2: Reading the Dashboard
Before taking any trade, check the dashboard:
Trend: Only take LONG signals in bullish trends, SHORT signals in bearish trends
Position: Confirm price is on the correct side of EMAs
Volume: Green spike = strong confirmation
RSI: Avoid extremes (>70 or <30)
Confluence: "Strong" = high probability setup
Separation: "Good" = trending market, avoid "Low" separation
Step 3: Trade Entry
For LONG Trades:
Wait for green triangle to appear below price
Verify dashboard shows:
Bullish or Neutral trend
Volume spike (preferred)
RSI between 50-70
Good separation
Enter at market or on next bar
Set stop loss at: Entry - (ATR × 2)
Set target at: Entry + (ATR × 4)
For SHORT Trades:
Wait for red triangle to appear above price
Verify dashboard shows:
Bearish or Neutral trend
Volume spike (preferred)
RSI between 30-50
Good separation
Enter at market or on next bar
Set stop loss at: Entry + (ATR × 2)
Set target at: Entry - (ATR × 4)
Step 4: Trade Management
Use the ATR values from dashboard for position sizing
Trail stops using the fastest EMA (EMA 9) as price moves in your favor
Exit partial position at 1:1 risk-reward, let remainder run to target
Exit immediately if dashboard trend changes against your position
💡 Best Practices
Timeframe Recommendations:
Scalping: 1m-5m chart with 5m, 15m, 1H, 4H, 1D EMAs
Day Trading: 5m-15m chart with 15m, 1H, 4H, 1D EMAs
Swing Trading: 1H-4H chart with 4H, 1D, 1W EMAs
Position Trading: 1D chart with 1D, 1W, 1M EMAs
Market Conditions:
Best in: Trending markets with clear direction
Avoid: Tight consolidation, low volume periods, major news events
Filter trades: Only take signals aligned with higher timeframe trend
Risk Management:
Never risk more than 1-2% per trade
Use ATR from dashboard to calculate position size
Respect the stop loss levels
Don't force trades when dashboard shows weak conditions
⚙️ Customization Options
EMA Settings (for each of 5 EMAs):
Length (period)
Timeframe (multi-timeframe capability)
Color
Line width
Show/hide toggle
Signal Settings:
Volume confirmation (on/off)
Volume spike threshold (1.0-3.0x)
Momentum confirmation (on/off)
RSI overbought/oversold levels
Minimum EMA separation percentage
ATR period and stop multiplier
Display Settings:
Show/hide EMA labels
Show/hide trade signals
Signal marker size (tiny/small/normal/large)
Show/hide dashboard
🔔 Alert Setup
The indicator includes 4 alert conditions:
LONG Signal - Fires when all long confirmations are met
SHORT Signal - Fires when all short confirmations are met
Bullish Setup - Early warning when trend aligns bullish with volume
Bearish Setup - Early warning when trend aligns bearish with volume
To set up alerts:
Right-click on chart → Add Alert
Select "MTF EMA Trading System"
Choose your desired alert condition
Configure notification method (popup, email, SMS, webhook)
📈 Performance Tips
Increase Win Rate:
Only trade in direction of higher timeframe trend
Wait for volume spike confirmation
Avoid trades during first 30 minutes and last 15 minutes of session
Skip trades when separation is "Low"
Reduce False Signals:
Increase minimum EMA separation to 0.7-1.0%
Enable all confirmation requirements
Only trade when confluence shows "Strong"
Combine with support/resistance levels
Optimize for Your Market:
Stocks: Use 9, 21, 50, 100, 200 EMAs
Forex: Consider 8, 13, 21, 55, 89 EMAs (Fibonacci)
Crypto: May need wider ATR multiplier (2.5-3.0x) for volatility
⚠️ Important Notes
This indicator is designed to reduce false signals by requiring multiple confirmations
No indicator is 100% accurate - always use proper risk management
Backtesting recommended before live trading
Market conditions change - adjust settings as needed
Works best in liquid markets with clear price action
🎓 Conclusion
The MTF EMA Trading System transforms simple moving average analysis into a sophisticated, multi-confirmation trading strategy. By combining trend alignment, momentum, volume, and confluence, it helps traders identify high-probability setups while filtering out noise and false signals. The clean interface and comprehensive dashboard make it suitable for both beginners and experienced traders across all markets and timeframes.
Dual EMA Status Table (15m & 30m)It checks whether the 9 EMA is above or below the 21 EMA on:
the 15-minute chart, and
the 30-minute chart,
and then displays their alignment in a table:
Timeframe 9 vs 21 Status
15 min 9 > 21 Bullish
30 min 9 > 21 Bullish
CONFIRM ✅ Bullish
✅ “Bullish Confirm” → 9 EMA > 21 EMA on both → uptrend bias
❌ “Bearish Confirm” → 9 EMA < 21 EMA on both → downtrend bias
⚠️ “Mixed” → 15 m and 30 m disagree → stay neutral or wait
💡 How to Use It as a Trading Signal
You can treat it as a buy/sell framework with confirmation rules:
🔹 Buy (Long) bias
Table shows ✅ Bullish confirmation
9 EMA > 21 EMA on both timeframes
Ideally, price pulls back near one of the EMAs and then bounces
You could enter after a bullish candle close above the EMAs
📍 Example entry rule:
Enter long when “✅ Bullish” appears and price closes above both EMAs on the 15 min chart.
Stop-loss below the 21 EMA or recent swing low.
🔹 Sell (Short) bias
Table shows ❌ Bearish confirmation
9 EMA < 21 EMA on both timeframes
Price retraces upward and rejects near EMAs
📍 Example entry rule:
Enter short when “❌ Bearish” appears and price closes below both EMAs on the 15 min chart.
Stop-loss above 21 EMA or recent swing high.
Moving Averages DTMoving Averages Combo: SMA 30-50-100-200 + EMA 5-8-21 (Golden & Death Cross Ready)
This clean and lightweight indicator plots the most used simple and exponential moving averages in one single script — perfect for swing traders, position traders, and scalpers.
— Simple Moving Averages (Daily timeframe focus):
• SMA 30 (Red) — Early trend detection
• SMA 50 (Blue) — Classic medium-term trend
• SMA 100 (Green) — Institutional reference
• SMA 200 (Orange) — The legendary Golden/Death Cross line
— Fast Exponential Moving Averages (Perfect for pullbacks & entries):
• EMA 5 (Purple) — Ultra-fast reaction
• EMA 8 (Yellow) — Fibonacci-based favorite
• EMA 21 (Black) — 21-day cycle + Fibonacci
Why this combination works so well:
• EMA 8 + EMA 21 = Powerful short-term trend filter (used by thousands of crypto & forex traders)
• SMA 50/200 = Classic Golden & Death Cross signals
• SMA 30/100 = Extra confirmation layers used by banks and funds
Features:
✓ All MAs on a single indicator (no chart clutter)
✓ Clean colors with perfect contrast on light/dark themes
✓ Ready for alerts: set alert on EMA 8 crossing EMA 21 or SMA 50 crossing SMA 200
✓ Works on all markets & timeframes (stocks, forex, crypto, futures)
How to use:
• Bullish signal: Price above SMA 200 + EMA 8 > EMA 21 + SMA 50 > SMA 200
• Bearish signal: Price below SMA 200 + EMA 8 < EMA 21
• Pullback entries: Wait for price to touch EMA 21 in uptrend
Trend Meter [MMT]The Trend Meter is a dynamic Pine Script indicator designed to provide traders with a clear, multi-dimensional view of market trends and momentum across different timeframes and metrics. By integrating Exponential Moving Averages (EMAs), Volume-Weighted Average Price (VWAP), higher timeframe (HTF) analysis, and Regular Trading Hours (RTH) breakouts, this indicator offers a comprehensive tool for identifying bullish, bearish, or neutral market conditions. Its customizable visual display and label system make it ideal for traders seeking actionable insights for trend-following, breakout, or reversal strategies.
Key Features:
1. Multi-Metric Trend Analysis:
- Trend Meter : Compares a Fast EMA (default: 9) and Slow EMA (default: 21) to determine short-term trend direction.
- Bias Meter : Uses a longer-term Bias EMA (default: 35) to assess the overall market bias based on the close price.
- VWAP Meter : Evaluates price position relative to the VWAP for dynamic support/resistance insights.
- HTF Meter : Analyzes higher timeframe (default: 60-minute) price action, detecting breakouts of previous highs/lows and candle direction.
- RTH Meter : Tracks price breakouts above/below the US Regular Trading Hours (09:30–16:00 EST) 15m opening range (09:30–09:45 EST).
2. Color-Coded Visuals:
- Each metric is displayed as a horizontal line with customizable colors (green for bullish, red for bearish, gray for neutral).
- Visual style options (dotted, dashed, or solid lines) allow for personalized chart clarity.
3. Dynamic Labels:
- Optional labels for each metric (Trend, Bias, VWAP, HTF, RTH) with customizable text, size (tiny to huge), and color.
- Labels update in real-time, providing clear identification of each meter’s role and current state.
4. Flexible Metric Selection:
- Toggle individual metrics (EMA, VWAP, HTF, RTH) on/off to focus on relevant indicators for your trading style.
- Option to use the previous bar’s close price for calculations, reducing noise in volatile markets.
5. RTH and Opening Range Analysis:
- Calculates the high/low of the opening range (09:30–09:45 EST) during RTH sessions.
- Signals bullish or bearish conditions when the price breaks above/below the opening range outside the initial 15-minute window.
6. Higher Timeframe Breakout Detection:
- Monitors HTF price action to identify breakouts of the previous candle’s high or low, combined with the HTF candle’s direction for trend confirmation.
How to Use:
- Trend Confirmation : Use the Trend and Bias Meters to confirm short-term and long-term market direction.
- Breakout Trading : Leverage the RTH Meter for breakout setups above/below the opening range during US trading hours.
- Support/Resistance : Utilize the VWAP Meter to identify dynamic price levels for entries or exits.
- Higher Timeframe Context : Monitor the HTF Meter for broader market trend alignment, ideal for swing or position trading.
- Customization : Adjust EMA lengths, toggle metrics, and customize visual styles and labels to suit your chart preferences.
Settings:
- Bias Settings :
- Fast EMA (default: 9), Slow EMA (default: 21), Bias EMA (default: 35).
- Higher Timeframe (default: 60-minute).
- Option to use previous close price for calculations.
- Enable/disable individual metrics (EMA, VWAP, HTF, RTH).
- Visual Settings :
- Bullish (green), bearish (red), and neutral (gray) colors.
- Line style (dotted, dashed, solid).
- Label Settings :
- Enable/disable labels.
- Customize label size (tiny, small, normal, large, huge) and text color.
- Custom text for each meter’s label (Trend, Bias, VWAP, HTF, RTH).
Notes:
- Optimized for intraday trading (e.g., 1m, 5m, 15m) but adaptable to any timeframe.
- RTH and opening range calculations are tailored for US markets (EST timezone); adjust session times in the code for other markets.
- Higher timeframe analysis enhances context for multi-timeframe strategies.
Ideal For:
- Intraday traders targeting RTH breakout opportunities.
- Swing traders aligning with higher timeframe trends.
- Traders using VWAP and EMA-based strategies for trend and momentum analysis.
- Those seeking a clean, customizable dashboard for multi-metric market analysis.
ADX Trend Strength Filter + TRAMA [DotGain]Summary
Are you tired of trading trend signals, only to get stopped out in volatile, sideways chop?
The ADX Trend Strength Filter (ADX TSF) is designed to solve this exact problem. It is a comprehensive trend-following system that only generates signals when a trend not only has the right direction and momentum, but also sufficient strength.
This indicator filters out weak or indecisive market phases (the "chop") and will only color the bars Green or Red when all conditions for a strong, confirmed trend are met.
⚙️ Core Components and Logic
The ADX TSF relies on a triple-filter logic to generate a clear trade signal:
Trend Filter (TRAMA): A TRAMA (Trending Adaptive Moving Average) is used as the main trendline. This adaptive average automatically adjusts to market volatility, acting as a dynamic support/resistance level.
Price > TRAMA = Bullish
Price < TRAMA = Bearish
Momentum Filter (RSI Crossover): Momentum is measured by a crossover of two moving averages of the RSI (a fast EMA and a slow SMA). This confirms whether the momentum is pointing in the same direction as the trend.
Strength Filter (ADX): This is the most important filter. A signal is only considered valid if the ADX (Average Directional Index) is above a defined threshold (Default: 30). This ensures the trend has sufficient strength.
🚦 How to Read the Indicator
The indicator has three states, displayed directly as bar colors on your chart:
🟩 GREEN BARS (Strong Uptrend) All three conditions are met:
Price is above the TRAMA.
RSI momentum is bullish (Fast MA > Slow MA).
ADX is above 30 (Strong trend is present).
🟥 RED BARS (Strong Downtrend) All three conditions are met:
Price is below the TRAMA.
RSI momentum is bearish (Fast MA < Slow MA).
ADX is above 30 (Strong trend is present).
🟧 ORANGE BARS (Neutral / Caution) This state appears if any of the following conditions are true:
Weak Trend: The ADX is below 30. The market is in consolidation or a sideways phase. (This is the primary filter!)
Indecision: The price is caught in the "Neutral Zone" between the TRAMA and the 200 SMA.
Visual Elements
Bar Colors: (Green/Red/Orange) Show the current trend status.
TRAMA (Orange Line): Your primary adaptive trendline.
200 SMA (White Line): Serves as a reference for the long-term trend.
Orange Background (Fill): Fills the area between the TRAMA and SMA to visually highlight the "Neutral Zone."
Key Benefit
The goal of the ADX TSF is to keep traders out of weak, unpredictable markets and help them participate only in strong, momentum-confirmed trends.
Have fun :)
Disclaimer
This "Buy The F*cking Dip" (BTFD) indicator is provided for informational and educational purposes only. It does not, and should not be construed as, financial, investment, or trading advice.
The signals generated by this tool (both "Buy" and "Sell") are the result of a specific set of algorithmic conditions. They are not a direct recommendation to buy or sell any asset. All trading and investing in financial markets involves substantial risk of loss. You can lose all of your invested capital.
Past performance is not indicative of future results. The signals generated may produce false or losing trades. The creator (© DotGain) assumes no liability for any financial losses or damages you may incur as a result of using this indicator.
You are solely responsible for your own trading and investment decisions. Always conduct your own research (DYOR) and consider your personal risk tolerance before making any trades.
Trend & Strength Detector TSDTrend Strength Detector (TSD)
*Objective Trend Quality Measurement for Educational Market Analysis*
Note: This mathematical framework is a proprietary quantitative model developed by Ario Pinelab, inspired by classical EMA, ADX, RSI and MACD principles, yet not documented in any public technical or academic publication.
## 🎯 Purpose & Design Philosophy
The ** Trend Strength Detector- TSD ** is an educational research tool that provides **quantitative measurement of trend quality** through two independent scoring systems (0-100 scale). It answers the analytical question: *"How strong and aligned is the current market trend environment?"*
This indicator is designed with a **modular, complementary approach** to work alongside various analysis methodologies, particularly pattern-based recognition systems.
## 🔗 Complementary Research Framework
### Designed to Work With Pattern Detection Systems
This indicator provides **environmental context measurement** that complements qualitative pattern recognition tools. It works particularly well alongside systems like:
- **RMBS Smart Detector - Multi-Factor Momentum System**
- Traditional chart pattern analyzers
- Any momentum-based pattern identification tools
🔍 **To find RMBS Smart Detector:**
- Search in TradingView Indicators Library: `" RMBS Smart Detector - Multi-Factor Momentum System"`
- Look for: *Multi-Factor Momentum System*
- By author: ` `
### Why This Complementary Approach?
**Trend Quality Measurement** (TSD - this tool) provides:
- ✅ Structural trend alignment (0-100 score)
- ✅ Momentum intensity levels (0-100 score)
- ✅ Environment classification (Strong/Moderate/Weak)
- 📌 **Answers:** *"HOW STRONG is the underlying trend environment?"*
### Educational Research Value
When used together in a research context, these tools enable systematic study of questions like:
- How do reversal patterns behave when Strength Score is above 70 vs below 30?
- Do continuation patterns in weakening environments (declining scores) show different characteristics?
- What is the correlation between high Alignment Scores and pattern "success rates"?
- Can environment classification help identify genuine trend initiation vs false starts?
⚠️ **Important Note:** Both tools are **independent and work standalone**. TSD provides value whether used alone or with other analysis methods. The relationship with RMBS (or any pattern tool) is **complementary for research purposes**, not dependent.
---
###Mathematical Foundation
##TSA Formula: scoring method developed by Ario
-Trend Model (0 – 100)
TAS = EMA Alignment (0–40) + Price Position (0–30) + Trend Consistency (0–30)
EMA Alignment checks EMA_fast vs EMA_slow vs EMA_trend structure.
Price Position evaluates if Close is above/below all EMAs.
Consistency = 3 × max(bullish,bearish bars within 10 candles).
-Strength Model (0 – 100)
Strength = ADX (0–50) + EMA Slope (0–25) + RSI (0–15) + MACD (0–10)
ADX measures trend energy; Slope shows EMA momentum %;
RSI assesses zone positioning; MACD confirms directional agreement.
Note: This formula represents a proprietary quantitative model by Ario_Pinelab, inspired by classical technical concepts but not published in any external reference.________________________________________
📊 Environment Classification
Based on Total Strength Score:
🟢 Strong Environment: Score ≥ 60
→ Well-defined momentum, clear directional bias
🟡 Moderate Environment: 40 ≤ Score < 60
→ Mixed signals, transitional conditions
🔴 Weak Environment: Score < 40
→ Ranging, choppy, low conviction movement
Color Coding:
• Green background: Strong (≥60)
• Yellow background: Moderate (40-59)
• Red background: Weak (<40)
________________________________________
📈 Visual Components
Main Chart Display
Score Labels (Top-Right Corner):
┌─────────────────────────────────┐
│ 📊 Alignment: 75 | Strength: 82 │
│ Environment: Strong 🟢 │
└─────────────────────────────────┘
Color-Coded Background:
• Environment strength visually indicated via background color
• Helps quick identification of market regime
• Customizable transparency (default: 90%)
Reference Lines:
• Dotted line at 60: Strong/Moderate threshold
• Dotted line at 40: Moderate/Weak threshold
• Mid-line at 50: Neutral reference
________________________________________
🔧 Customization Settings
Input Parameters
The best setting is the default mode.
🚫 Important Disclaimers & Limitations
What This Indicator IS:
✅ Educational measurement tool for trend quality research
✅ Quantitative assessment of current market environment
✅ Complementary analysis tool for pattern-based systems
✅ Historical data analyzer for systematic study
✅ Multi-factor scoring system based on technical calculations
What This Indicator IS NOT:
❌ NOT a trading system or signal generator
❌ NOT financial advice or trade recommendations
❌ NOT predictive of future price movements
❌ NOT a guarantee of pattern success/failure
❌ NOT a substitute for comprehensive risk management
________________________________________
Known Limitations
1. Lagging Nature:
⚠️ All components (EMA, ADX, RSI, MACD) are calculated
from historical price data
→ Scores reflect CURRENT and RECENT conditions
→ Cannot predict sudden reversals or black swan events
→ Trend measurements lag actual price turning points
2. Whipsaw Risk:
⚠️ In choppy/ranging markets, scores may fluctuate rapidly
→ Moderate zone (40-60) can see frequent transitions
→ Low timeframes more susceptible to noise
→ Consider higher timeframes for stable measurements
3. Component Conflicts:
⚠️ Individual components may disagree
→ Example: Strong ADX but weak RSI alignment
→ Scores average these conflicts (may hide nuance)
→ Check individual components for deeper insight
4. Not Predictive:
⚠️ High scores do NOT guarantee continuation
⚠️ Low scores do NOT guarantee reversal
→ Measurement ≠ Prediction
→ Use for CONTEXT, not SIGNALS
→ Combine with comprehensive analysis
________________________________________
Risk Acknowledgments
Market Risk:
• All trading involves substantial risk of loss
• Past performance (even systematic studies) does not guarantee future results
• No indicator, system, or methodology can eliminate market risk
Measurement Limitations:
• Scores are mathematical calculations, not market predictions
• Environmental classification is descriptive, not prescriptive
• Strong measurements can deteriorate rapidly without warning
Educational Purpose:
• This tool is designed for LEARNING about market structure
• Not designed, tested, or validated as a standalone trading system
• Any trading decisions are user’s sole responsibility
No Warranty:
• Indicator provided “as-is” for educational purposes
• No guarantee of accuracy, reliability, or profitability
• Users must verify calculations and apply critical thinking
Open Source
Full Pine Script code available for educational study and modification. Feedback and improvement suggestions welcome.
“All logic is presented for research and educational visualization.”
---
Directional Strength and Momentum Index█ OVERVIEW
“Directional Strength and Momentum Index” (DSMI) is a technical analysis indicator inspired by DMI, but due to different source data, it produces distinct results. DSMI combines direction measurement, trend strength, and overheat levels into a single index, enhanced with gradient fills, extreme zones, entry signals, candle coloring, and a summary table.
█ CONCEPT
The classic DMI, despite its relatively simple logic, can seem somewhat chaotic due to separate +DI and -DI lines and the need for manual interpretation of their relationships. The DSMI indicator was created to increase clarity and speed up results, consolidating key information into a single index from 0 to 100 that simultaneously:
- Indicates trend direction (bullish/bearish)
- Measures movement strength
- Identifies overheat levels
- Generates ready entry signals
DMI (ADX + +DI / -DI) measures trend direction and strength, but does so based solely on comparing price movements between candles. ADX shows whether the trend is orderly and growing (e.g., above 20–30), but does not assess how dynamic the movement is.
DSMI, on the other hand, takes into account candle size and actual market aggression, thus showing directional momentum — whether the trend has real “fuel” to sustain or accelerate, not just whether it is orderly.
The main calculation difference involves replacing True Range with candle size (high-low) and using directional EMA instead of Wilder smoothing. This allows DSMI to react faster to momentum changes, eliminating delays typical of classic DMI based on TR.
This gives the trader an immediate picture of the market situation without analyzing multiple lines.
█ FEATURES
DSMI Main Line:
- EMA(Directional Index) based on +DS and -DS
- Scale 0–100, smooth color gradient depending on strength
+DS / -DS:
- Positive and Negative Directional Strength
- Gradient fill between lines — more intense with stronger trend
Extreme Zones:
- Default 20 and 80
- Gradient fill outside zones
Trend Strength Levels:
- Weak (<10) → neutral
- Moderate (up to 35)
- Strong (up to 45)
- Overheated (up to 55)
- Extreme (>55)
All levels editable
Entry Signals:
- Activated on crossing entry level (default 20)
Or on direction change when DSMI already ≥ entry level
- Highlighted background (green/red)
Candle Coloring:
- According to current trend
Trend Strength Table:
- Top-right corner
- Shows current strength (WEAK/STRONG etc.) + DSMI value
Alerts:
- DSMI Bullish Entry
- DSMI Bearish Entry
█ HOW TO USE
Add to Chart: Paste code in Pine Editor or find in indicator library.
Settings:
DSMI Parameters:
- DSMI Period → default 20
- Show DSMI Line → on/off
Extreme Zones:
- Lower Level → default 20
- Upper Level → default 80
Trend Strength Levels:
- Weak, Moderate, Strong, Overheated → adjust to strategy
Trend Colors:
- BULLISH → default green
- BEARISH → default red
- NEUTRAL → gray
Entry Signals:
- Show Highlight → on/off
- DSMI Entry Level → default 20
Signal Interpretation:
- DSMI Line: Main strength indicator.
- Gradient between +DS and -DS: Visualizes side dominance.
- Crossing 18 with direction confirmation → entry signal.
- Extreme Zones: Potential reversal or continuation points after correction.
- Table: Quick overview of current trend condition.
█ APPLICATIONS
The indicator works well in:
- Trend-following: Enter on signal, exit on direction change or overheat. When a new trend appears, consider entering a position, preferably with a rising trend strength indicator.
- Scalping/daytrading: Shorter period (7–10), lower entry level.
- Swing/position: Longer period (20–30), higher entry level, extreme zones as filters.
- Noise filtering: Ignores consolidation below “Weak” – increasing value e.g. to 15 highlights consolidation zones, but no signals appear there.
Style Adjustment:
- Aggressive strategies → shorten period and entry level
- Conservative → extend period, raise entry level (25–30), watch “Overheated”
“Weak” level (<10 default) → neutral; increasing it e.g. to 15 gives fewer but higher-quality signals. The Weak zone value controls the level below which no signals appear, and the gradient turns gray (often aligned with consolidation zones).
Combine with:
- Support/resistance levels
- Fair Value Gaps (FVG)
- Volume (Volume Profile, VWAP)
- Other oscillators (RSI, Stochastic)
█ NOTES
- Works on all markets and timeframes.
- Adjust period and levels to instrument volatility.
- Higher entry level → fewer signals, higher quality.
- Neutral color below “Weak” – avoids trading in consolidation.
- Gradient and table enable quick assessment without line analysis.
X Tail that Wagsintraday session-framework and ETH-anchored VWAP tool for TradingView. It draws today’s OVN (ETH) high/mid/low, today’s RTH-day open, previous day open/high/low, and a carried ETH VWAP handle (yesterday’s 4:00 PM NY VWAP, projected forward) to give you a clean, non-repainting scaffold for bias, structure, and execution. All timestamps are New York–local with DST handled explicitly, so historical sessions align correctly across time changes.
Key Capabilities
ETH OVN Range (18:00 → 09:30 NY)
Captures the rolling overnight high/low and computes the mid; at 09:30 NY it locks those levels and extends them to 16:00 NY (same day).
Optional labels (size/color configurable) placed slightly to the right of the 4 PM timestamp for readability.
Daily Handles (Today & Previous Day)
Today’s open line starts at the ETH open (anchor preserved) and extends toward 4 PM NY (or up to the “current bar + 5 bars” cap), with label control.
Previous day open/high/low plotted as discrete reference lines for carry-over structure.
ETH-Anchored VWAP (Live) + Bands
ETH-anchored VWAP runs only during the active ETH session (DST-aware).
Optional VWAP bands (0.5×, 1.0×, 2.0× multipliers) plotted as line-break series.
Carried ETH VWAP Handle (PD 4 PM Snapshot)
At 16:00 NY, the script snapshots the final ETH VWAP value.
On the next ETH open, it projects that value as a static dashed line through the session (non-mutating, non-repainting), with optional label.
Labeling & Styling
Single-toggle label system with color and five sizes.
Per-line color/width controls for quick visual hierarchy.
Internal “tail” logic keeps right endpoints near price (open-anchored lines extend to min(4 PM, now + 5 bars)), avoiding chart-wide overdraw.
Robust Session Logic
All session boundaries computed in NY local time; DST rules applied for historical bars.
Cross-midnight windows handled safely (no gaps or misalignment around day rolls).
Primary Use Cases
Session Bias & Context
Use OVN H/M/L and today’s open to define structural bias zones before RTH begins. A break-and-hold above OVN mid, for example, can filter long ideas; conversely, rejection at OVN high can warn of mean reversion.
Carry-Forward Mean/Value Reference
The carried ETH VWAP (PD 4 PM) acts as a “value memory” line for the next day. Traders can:
Fade tests away from it in balanced conditions,
Use it as a pullback/acceptance gauge during trends,
Track liquidity grabs when price spikes through and reclaims.
Execution Planning & Risk
Anchor stops/targets around PD H/L and OVN H/M/L for well-defined invalidation.
Combine with your entry model (order-flow, momentum, or pattern) to time fades at range extremes or momentum breaks from OVN mid.
Confluence Mapping
Layer the tool with opening range tools, HTF zones, or profile/VWAPs (weekly/daily) to spot high-quality confluence where multiple references cluster.
Regime & Day-Type Read
Quickly see whether RTH accepts/rejects the OVN range or gravitates to PD VWAP handle, helping classify the day (trend, balanced, double-distribution, etc.).
Quick Start
Apply to your intraday chart (any instrument supported by TradingView; best on ≤15m for live intraday context).
In Current Day group, keep Open and OVN HL on; optionally display the mid.
In Previous Day group, enable PD Open/HL for carry-over levels.
Enable AVWAP if you want live ETH-anchored VWAP and its Bands for distance context.
Keep PD VWAP on to project yesterday’s 4 PM ETH VWAP as a static dashed line into today.
Use the Label group to size/color the on-chart tags.
Settings Overview (Plain-English)
Label: Toggle labels on/off; choose label text color and size.
Current Day:
Open (color/width) — daily open line anchored at ETH open.
OVN HL (and Mid) — overnight high/low and midpoint, locked at 09:30 and extended to 16:00.
AVWAP + Bands — ETH-anchored VWAP with optional 0.5×/1×/2× bands.
Previous Day:
PD Open/HL — yesterday’s daily handles.
PD VWAP — the carried snapshot of yesterday’s 4 PM ETH VWAP projected forward (dashed).
Notes & Best Practices
Time Zone: All session logic is hard-coded to America/New_York and DST-robust. No manual DST tweaks required.
Non-Repainting: The carried PD VWAP line is a snapshot; once drawn, it does not back-fill or mutate.
Intraday Use: Designed for intraday execution. It will display on higher TFs, but the session granularity is most informative at ≤15m.
Performance: Script caps lines/labels (500) and uses short “tails” to keep charts responsive.
Compatibility: Uses request.security(..., "D", series, lookahead_on) intentionally to lock daily handles early for planning; this is by design.
Typical Playbook Examples
Fade Extremes in Balance: As RTH opens inside OVN, look for rejection wicks at OVN High with confluence from PD VWAP handle overhead; risk above OVN High.
Trend Continuation: In directional sessions, acceptances above OVN Mid with price pulling back to the live ETH VWAP can offer continuation entries.
Reversion to Value: Sharp extensions away from the carried PD VWAP that quickly stall often revert to that handle; use it as a target or as an acceptance test.
Smart Money Flow Index (SMFI) - Advanced SMC [PhenLabs]📊Smart Money Flow Index (SMFI)
Version: PineScript™v6
📌Description
The Smart Money Flow Index (SMFI) is an advanced Smart Money Concepts implementation that tracks institutional trading behavior through multi-dimensional analysis. This comprehensive indicator combines volume-validated Order Block detection, Fair Value Gap identification with auto-mitigation tracking, dynamic Liquidity Zone mapping, and Break of Structure/Change of Character detection into a unified system.
Unlike basic SMC indicators, SMFI employs a proprietary scoring algorithm that weighs five critical factors: Order Block strength (validated by volume), Fair Value Gap size and recency, proximity to Liquidity Zones, market structure alignment (BOS/CHoCH), and multi-timeframe confluence. This produces a Smart Money Score (0-100) where readings above 70 represent optimal institutional setup conditions.
🚀Points of Innovation
Volume-Validated Order Block Detection – Only displays Order Blocks when formation candle exceeds customizable volume multiplier (default 1.5x average), filtering weak zones and highlighting true institutional accumulation/distribution
Auto-Mitigation Tracking System – Fair Value Gaps and Order Blocks automatically update status when price mitigates them, with visual distinction between active and filled zones preventing trades on dead levels
Proprietary Smart Money Score Algorithm – Combines weighted factors (OB strength 25%, FVG proximity 20%, Liquidity 20%, Structure 20%, MTF 15%) into single 0-100 confidence rating updating in real-time
ATR-Based Adaptive Calculations – All distance measurements use 14-period Average True Range ensuring consistent function across any instrument, timeframe, or volatility regime without manual recalibration
Dynamic Age Filtering – Automatically removes liquidity levels and FVGs older than configurable thresholds preventing chart clutter while maintaining relevant levels
Multi-Timeframe Confluence Integration – Analyzes higher timeframe bias with customizable multipliers (2-10x) and incorporates HTF trend direction into Smart Money Score for institutional alignment
🔧Core Components
Order Block Engine – Detects institutional supply/demand zones using characteristic patterns (down-move-then-strong-up for bullish, up-move-then-strong-down for bearish) with minimum volume threshold validation, tracks mitigation when price closes through zones
Fair Value Gap Scanner – Identifies price imbalances where current candle's low/high leaves gap with two-candle-prior high/low, filters by minimum size percentage, monitors 50% fill for mitigation status
Liquidity Zone Mapper – Uses pivot high/low detection with configurable lookback to mark swing points where stop losses cluster, extends horizontal lines to visualize sweep targets, manages lifecycle through age-based removal
Market Structure Analyzer – Tracks pivot progression to identify trend through higher-highs/higher-lows (bullish) or lower-highs/lower-lows (bearish), detects Break of Structure and Change of Character for trend/reversal confirmation
Scoring Calculation Engine – Evaluates proximity to nearest Order Blocks using ATR-normalized distance, assesses FVG recency and distance, calculates liquidity proximity with age weighting, combines structure bias and MTF trend into smoothed final score
🔥Key Features
Customizable Display Limits – Control maximum Order Blocks (1-10), Liquidity Zones (1-10), and FVG age (10-200 bars) to maintain clean charts focused on most relevant institutional levels
Gradient Strength Visualization – All zones render with transparency-adjustable coloring where stronger/newer zones appear more solid and weaker/older zones fade progressively providing instant visual hierarchy
Educational Label System – Optional labels identify each zone type (Bullish OB, Bearish OB, Bullish FVG, Bearish FVG, BOS) with color-coded text helping traders learn SMC concepts through practical application
Real-Time Smart Money Score Dashboard – Top-right table displays current score (0-100) with color coding (green >70, yellow 30-70, red <30) plus trend arrow for at-a-glance confidence assessment
Comprehensive Alert Suite – Configurable notifications for Order Block formation, Fair Value Gap detection, Break of Structure events, Change of Character signals, and high Smart Money Score readings (>70)
Buy/Sell Signal Integration – Automatically plots triangle markers when Smart Money Score exceeds 70 with aligned market structure and fresh Order Block detection providing clear entry signals
🎨Visualization
Order Block Boxes – Shaded rectangles extend from formation bar spanning high-to-low of institutional candle, bullish zones in green, bearish in red, with customizable transparency (80-98%)
Fair Value Gap Zones – Rectangular areas marking imbalances, active FVGs display in bright colors with adjustable transparency, mitigated FVGs switch to gray preventing trades on filled zones
Liquidity Level Lines – Dashed horizontal lines extend from pivot creation points, swing highs in bearish color (short targets above), swing lows in bullish color (long targets below), opacity decreases with age
Structure Labels – "BOS" labels appear above/below price when Break of Structure confirmed, colored by direction (green bullish, red bearish), positioned at 1% beyond highs/lows for visibility
Educational Info Panel – Bottom-right table explains key terminology (OB, FVG, BOS, CHoCH) and score interpretation (>70 high probability) with semi-transparent background for readability
📖Usage Guidelines
General Settings
Show Order Blocks – Default: On, toggles visibility of institutional supply/demand zones, disable when focusing solely on FVGs or Liquidity
Show Fair Value Gaps – Default: On, controls FVG zone display including active and mitigated imbalances
Show Liquidity Zones – Default: On, manages liquidity line visibility, disable on lower timeframes to reduce clutter
Show Market Structure – Default: On, toggles BOS/CHoCH label display
Show Smart Money Score – Default: On, controls score dashboard visibility
Order Block Settings
OB Lookback Period – Default: 20, Range: 5-100, controls bars scanned for Order Block patterns, lower values detect recent activity, higher values find older blocks
Min Volume Multiplier – Default: 1.5, Range: 1.0-5.0, sets minimum volume threshold as multiple of 20-period average, higher values (2.0+) filter for strongest institutional candles
Max Order Blocks to Display – Default: 3, Range: 1-10, limits simultaneous Order Blocks shown, lower settings (1-3) maintain focus on most recent zones
Fair Value Gap Settings
Min FVG Size (%) – Default: 0.3, Range: 0.1-2.0, defines minimum gap size as percentage of close price, lower values detect micro-imbalances, higher values focus on significant gaps
Max FVG Age (bars) – Default: 50, Range: 10-200, removes FVGs older than specified bars, lower settings (10-30) for scalping, higher (100-200) for swing trading
Show FVG Mitigation – Default: On, displays filled FVGs in gray providing visual history, disable to show only active untouched imbalances
Liquidity Zone Settings
Liquidity Lookback – Default: 50, Range: 20-200, sets pivot detection period for swing highs/lows, lower values (20-50) mark shorter-term liquidity, higher (100-200) identify major swings
Max Liquidity Age (bars) – Default: 100, Range: 20-500, removes liquidity lines older than specified bars, adjust based on timeframe
Liquidity Sensitivity – Default: 0.5, Range: 0.1-1.0, controls pivot detection sensitivity, lower values mark only major swings, higher values identify minor swings
Max Liquidity Zones to Display – Default: 3, Range: 1-10, limits total liquidity levels shown maintaining chart clarity
Market Structure Settings
Pivot Length – Default: 5, Range: 3-15, defines bars to left/right for pivot validation, lower values (3-5) create sensitive structure breaks, higher (10-15) filter for major shifts
Min Structure Move (%) – Default: 1.0, Range: 0.1-5.0, sets minimum percentage move required between pivots to confirm structure change
Multi-Timeframe Settings
Enable MTF Analysis – Default: On, activates higher timeframe trend analysis incorporation into Smart Money Score
Higher Timeframe Multiplier – Default: 4, Range: 2-10, multiplies current timeframe to determine analysis timeframe (4x on 15min = 1hour)
Visual Settings
Bullish Color – Default: Green (#089981), sets color for bullish Order Blocks, FVGs, and structure elements
Bearish Color – Default: Red (#f23645), defines color for bearish elements
Neutral Color – Default: Gray (#787b86), controls color of mitigated zones and neutral elements
Show Educational Labels – Default: On, displays text labels on zones identifying type (OB, FVG, BOS), disable once familiar with patterns
Order Block Transparency – Default: 92, Range: 80-98, controls Order Block box transparency
FVG Transparency – Default: 92, Range: 80-98, sets Fair Value Gap zone transparency independently from Order Blocks
Alert Settings
Alert on Order Block Formation – Default: On, triggers notification when new volume-validated Order Block detected
Alert on FVG Formation – Default: On, sends alert when Fair Value Gap appears enabling quick response to imbalances
Alert on Break of Structure – Default: On, notifies when BOS or CHoCH confirmed
Alert on High Smart Money Score – Default: On, alerts when Smart Money Score crosses above 70 threshold indicating high-probability setup
✅Best Use Cases
Order Block Retest Entries – After Break of Structure, wait for price retrace into fresh bullish Order Block with Smart Money Score >70, enter long on zone reaction targeting next liquidity level
Fair Value Gap Retracement Trading – When price creates FVG during strong move then retraces, enter as price approaches unfilled gap expecting institutional orders to continue trend
Liquidity Sweep Reversals – Monitor price approaching swing high/low liquidity zones against prevailing Smart Money Score trend, after stop hunt sweep watch for rejection into premium Order Block/FVG
Multi-Timeframe Confluence Setups – Identify alignment when current timeframe Order Block coincides with higher timeframe FVG plus MTF analysis showing matching trend bias
Break of Structure Continuations – After BOS confirms trend direction, trade pullbacks to nearest Order Block or FVG in direction of structure break using Smart Money Score >70 as entry filter
Change of Character Reversal Plays – When CHoCH detected indicating potential reversal, look for Smart Money Score pivot with opposing Order Block formation then enter on structure confirmation
⚠️Limitations
Lagging Pivot Calculations – Pivot-based features (Liquidity Zones, Market Structure) require bars to right of pivot for confirmation, meaning these elements identify levels retrospectively with delay equal to lookback period
Whipsaw in Ranging Markets – During choppy conditions, Order Blocks fail frequently and structure breaks produce false signals as Smart Money Score fluctuates without clear institutional bias, best used in trending markets
Volume Data Dependency – Order Block volume validation requires accurate volume data which may be incomplete on Forex pairs or limited in crypto exchange feeds
Subjectivity in Scoring Weights – Proprietary 25-20-20-20-15 weighting reflects general institutional behavior but may not optimize for specific instruments or market regimes, user cannot adjust factor weights
Visual Complexity on Lower Timeframes – Sub-hour timeframes generate excessive zones creating cluttered charts, requires aggressive display limit reduction and higher minimum thresholds
No Fundamental Integration – Indicator analyzes purely technical price action and volume without incorporating economic events, news catalysts, or fundamental shifts that override technical levels
💡What Makes This Unique
Unified SMC Ecosystem – Unlike indicators displaying Order Blocks OR FVGs OR Liquidity separately, SMFI combines all three institutional concepts plus market structure into single cohesive system
Proprietary Confidence Scoring – Rather than manual setup assessment, automated Smart Money Score quantifies probability by weighting five institutional dimensions into actionable 0-100 rating
Volume-Filtered Quality – Eliminates weak Order Blocks forming without institutional volume confirmation, ensuring displayed zones represent genuine accumulation/distribution
Adaptive Lifecycle Management – Automatically updates mitigation status and removes aged zones preventing trades on dead levels through continuous validity and age monitoring
Educational Integration – Built-in tooltips, labeled zones, and reference panel make indicator functional for both learning Smart Money Concepts and executing strategies
🔬How It Works
Order Block Detection – Scans for patterns where strong directional move follows counter-move creating last down-candle before rally (bullish OB) or last up-candle before sell-off (bearish OB), validates formations only when candle exhibits volume exceeding configurable multiple (default 1.5x) of 20-bar average volume
Fair Value Gap Identification – Compares current candle’s high/low against two-candles-prior low/high to detect price imbalances, calculates gap size as percentage of close and filters micro-gaps below minimum threshold (default 0.3%), monitors whether subsequent price fills 50% triggering mitigation status
Liquidity Zone Mapping – Employs pivot detection using configurable lookback (default 50 bars) to identify swing highs/lows where retail stops cluster, extends horizontal reference lines from pivot creation and applies age-based filtering to remove stale zones
Market Structure Analysis – Tracks pivot progression using structure-specific lookback (default 5 bars) to determine trend, confirms uptrend when new pivot high exceeds previous by minimum move percentage, detects Break of Structure when price breaks recent pivot level, flags Change of Character for potential reversals
Multi-Timeframe Confluence – When enabled, requests security data from higher timeframe (current TF × HTF multiplier, default 4x), compares HTF close against HTF 20-period MA to determine bias, contributes ±50 points to score ensuring alignment with institutional positioning on superior timeframe
Smart Money Score Calculation – Evaluates Order Block component via ATR-normalized distance producing max 100-point contribution weighted at 25%, assesses FVG factor through age penalty and distance at 20% weight, calculates Liquidity proximity at 20%, incorporates structure bias (±50-100 points) at 20%, adds MTF component at 15%, applies 3-period smoothing to reduce volatility
Visual Rendering and Lifecycle – Draws Order Block boxes, Fair Value Gap rectangles with color coding (green/red active, gray mitigated), extends liquidity dashed lines with fade-by-age opacity, plots BOS labels, displays Smart Money Score dashboard, continuously updates checking mitigation conditions and removing elements exceeding age/display limits
💡Note:
The Smart Money Flow Index combines multiple Smart Money Concepts into unified institutional order flow analysis. For optimal results, use the Smart Money Score as confluence filter rather than standalone entry signal – scores above 70 indicate high-probability setups but should be combined with risk management, higher timeframe bias, and market regime understanding.
