Stochastic Momentum IndexStochastic Momentum Index indicator script. This indicator was originally developed by William Blau (Stocks & Commodities V. 11:1 (11-18)).
Tìm kiếm tập lệnh với "电力行业+股票+11年涨幅"
Hosoda’s CloudsMany investors aim to develop trading systems with a high win rate, mistakenly associating it with substantial profits. In reality, high returns are typically achieved through greater exposure to market trends, which inevitably lowers the win rate due to increased risk and more volatile conditions.
The system I present, called “Hosoda’s Clouds” in honor of Goichi Hosoda , the creator of the Ichimoku Kinko Hyo indicator, is likely one of the first profitable systems many traders will encounter. Designed to capture trends, it performs best in markets with clear directional movements and is less suitable for range-bound markets like Forex, which often exhibit lateral price action.
This system is not recommended for low timeframes, such as minute charts, due to the random and emotionally driven nature of price movements in those periods. For a deeper exploration of this topic, I recommend reading my article “Timeframe is Everything”, which discusses the critical importance of selecting the appropriate timeframe.
I suggest testing and applying the “Hosoda’s Clouds” strategy on assets with a strong trending nature and a proven track record of performance. Ideal markets include Tesla (1-hour, 4-hour, and daily), BTC/USDT (daily), SPY (daily), and XAU/USD (daily), as these have consistently shown clear directional trends over time.
Commissions and Configuration
Commissions can be adjusted in the system’s settings to suit individual needs. For evaluating the effectiveness of “Hosoda’s Clouds,” I’ve used a standard commission of $1 per order as a baseline, though this can be modified in the code to accommodate different brokers or preferences.
The margin per trade is set to $1,000 by default, but users are encouraged to experiment with different margin settings in the configuration to match their trading style.
Rules of the “Hosoda’s Clouds” System (Bullish Strategy)
This strategy is designed to capture trending movements in bullish markets using the Ichimoku Kinko Hyo indicator. The rules are as follows:
Long Entry: A long position is triggered when the Tenkan-sen crosses above the Kijun-sen below the Ichimoku cloud, identifying potential reversals or bounces in a bearish context.
Stop Loss (SL): Placed at the low of the candle 12 bars prior to the entry candle. This setting has proven optimal in my tests, but it can be adjusted in the code based on risk tolerance.
Take Profit (TP): The position is closed when the Tenkan-sen crosses below the bottom of the Ichimoku cloud (the minimum of Senkou Span A and Senkou Span B).
Notes on the Code
margin_long=0: Ideal for strategies requiring a fixed position size, particularly useful for manual entries or testing with a constant capital allocation.
margin_long=100: Recommended for high-frequency systems where positions are closed quickly, simulating gradual growth based on realized profits and reflecting real-world broker constraints.
System Performance
The following performance metrics account for $1 per order commissions and were tested on the specified assets and timeframes:
Tesla (H1)
Trades: 148
Win Rate: 29.05%
Period: Jan 2, 2014 – Jan 6, 2020 (+172%)
Simple Annual Growth Rate: +34.3%
Trades: 130
Win Rate: 30.77%
Period: Jan 2, 2020 – Sep 24, 2025 (+858.90%)
Simple Annual Growth Rate: +150.7%
Tesla (H4)
Trades: 102
Win Rate: 32.35%
Period: Jun 29, 2010 – Sep 24, 2025 (+11,356.36%)
Simple Annual Growth Rate: +758.5%
Tesla (Daily)
Trades: 56
Win Rate: 35.71%
Period: Jun 29, 2010 – Sep 24, 2025 (+3,166.64%)
Simple Annual Growth Rate: +211.5%
BTC/USDT (Daily)
Trades: 44
Win Rate: 31.82%
Period: Sep 30, 2017 – Sep 24, 2025 (+2,592.23%)
Simple Annual Growth Rate: +324.8%
SPY (Daily)
Trades: 81
Win Rate: 37.04%
Period: Jan 23, 1993 – Sep 24, 2025 (+476.90%)
Simple Annual Growth Rate: +14.3%
XAU/USD (Daily)
Trades: 216
Win Rate: 32.87%
Period: Jan 6, 1833 – Sep 24, 2025 (+5,241.73%)
Simple Annual Growth Rate: +27.1%
SPX (Daily)
Trades: 217
Win Rate: 38.25%
Period: Feb 1, 1871 – Sep 24, 2025 (+16,791.02%)
Simple Annual Growth Rate: +108.1%
Conclusion
With the “ Hosoda’s Clouds ” strategy, I aim to showcase the potential of technical analysis to generate consistent profits in trending markets, challenging recent doubts about its effectiveness. My goal is for this system to serve as both a practical tool for traders and a source of inspiration for the trading community I deeply respect. I hope it encourages the creation of new strategies, fosters creativity in technical analysis, and empowers traders to approach the markets with confidence and discipline.
ATH Projection (2013, 2017, 2021 -> 2025)//@version=6
indicator(title="ATH Projection (2013, 2017, 2021 -> 2025)", overlay=true, max_labels_count=20, max_lines_count=20)
// ----------- Inputs (ATH manuels) -----------
t1 = input.time(defval=timestamp("2013-12-01T00:00:00"), title="Date ATH #1 (2013)")
p1 = input.float(defval=1100.0, title="Prix ATH #1 (2013)")
t2 = input.time(defval=timestamp("2017-12-01T00:00:00"), title="Date ATH #2 (2017)")
p2 = input.float(defval=20000.0, title="Prix ATH #2 (2017)")
t3 = input.time(defval=timestamp("2021-11-01T00:00:00"), title="Date ATH #3 (2021)")
p3 = input.float(defval=69000.0, title="Prix ATH #3 (2021)")
// Projection future (ex: fin 2025)
t_proj = input.time(defval=timestamp("2025-12-01T00:00:00"), title="Date cible (fin 2025)")
// ----------- Utilitaire -----------
f_days(t) => ((t - t1) / 86400000.0) + 1.0 // nb jours depuis t1 (+1 pour éviter log(0))
// ----------- Coordonnées X (jours) -----------
x1 = f_days(t1)
x2 = f_days(t2)
x3 = f_days(t3)
xP = f_days(t_proj)
// ----------- Régression power-law (3 points) -----------
X1 = math.log(x1), Y1 = math.log(p1)
X2 = math.log(x2), Y2 = math.log(p2)
X3 = math.log(x3), Y3 = math.log(p3)
n = 3.0
sumX = X1 + X2 + X3
sumY = Y1 + Y2 + Y3
sumX2 = X1*X1 + X2*X2 + X3*X3
sumXY = X1*Y1 + X2*Y2 + X3*Y3
denom = n*sumX2 - sumX*sumX
var float a = na
var float b = na
b := denom != 0 ? (n*sumXY - sumX*sumY) / denom : na
a := na(b) ? na : math.exp((sumY - b*sumX) / n)
// ----------- Courbe au fil des barres -----------
x_now = f_days(time)
curve = (not na(a) and not na(b) and x_now > 0) ? a * math.pow(x_now, b) : na
plot(series=curve, title="Courbe prévision (power-law)", color=color.fuchsia, linewidth=2)
// ----------- Projection fin 2025 -----------
proj2025 = (not na(a) and not na(b) and xP > 0) ? a * math.pow(xP, b) : na
bi_proj = ta.valuewhen(time >= t_proj, bar_index, 0)
x_for_label = na(bi_proj) ? bar_index : bi_proj
// Label affichant la projection
var label lbl = na
if barstate.islast and not na(proj2025)
txt = "Projection 2025 ≈ " + str.tostring(proj2025, format.price)
if na(lbl)
lbl := label.new(x=x_for_label, y=proj2025, text=txt, xloc=xloc.bar_index, style=label.style_label_up, color=color.green, textcolor=color.white, size=size.normal)
else
label.set_x(id=lbl, x=x_for_label)
label.set_y(id=lbl, y=proj2025)
label.set_text(id=lbl, text=txt)
S&P500 Net Issues Block 11Description:
This indicator calculates and plots net advancers minus decliners for 13 predefined blocks of S&P 500 stocks. Each block represents a sector or a selected subset of stocks.
Features:
Shows net issues (advancers – decliners) for each block separately.
13 blocks plotted with distinct colors for easy identification.
Fully compatible with 1-minute, intraday, or higher timeframe charts.
Ideal for identifying sector momentum and market breadth trends.
Can be used standalone or combined with other indicators such as market indices (e.g., S&P 500 futures or TICK).
Usage:
Green/red/blue/orange lines represent different blocks; positive values indicate more advancing stocks than declining, negative values indicate more declining stocks.
Best viewed on intraday charts for short-term market breadth analysis.
Disclaimer:
This indicator is for educational and analytical purposes only. Not a buy/sell signal. Use proper risk management and verify data before trading.
Advanced Trading System - [WOLONG X DBG]Advanced Multi-Timeframe Trading System
Overview
This technical analysis indicator combines multiple established methodologies to provide traders with market insights across various timeframes. The system integrates SuperTrend analysis, moving average clouds, MACD-based candle coloring, RSI analysis, and multi-timeframe trend detection to suggest potential entry and exit opportunities for both swing and day trading approaches.
Methodology
The indicator employs a multi-layered analytical approach based on established technical analysis principles:
Core Signal Generation
SuperTrend Engine: Utilizes adaptive SuperTrend calculations with customizable sensitivity (1-20) combined with SMA confirmation filters to identify potential trend changes and continuations
Braid Filter System: Implements moving average filtering using multiple MA types (McGinley Dynamic, EMA, DEMA, TEMA, Hull, Jurik, FRAMA) with percentage-based strength filtering to help reduce false signals
Multi-Timeframe Analysis: Analyzes trend conditions across 10 different timeframes (1-minute to Daily) using EMA-based trend detection for broader market context
Advanced Features
MACD Candle Coloring: Applies dynamic 4-level candle coloring system based on MACD histogram momentum and signal line relationships for visual trend strength assessment
RSI Analysis: Identifies potential reversal areas using RSI oversold/overbought conditions with SuperTrend confirmation
Take Profit Analysis: Features dual-mode TP detection using statistical slope analysis and Parabolic SAR integration for exit timing analysis
Key Components
Signal Types
Primary Signals: Green ▲ for potential long entries, Red ▼ for potential short entries with trend and SMA alignment
Reversal Signals: Small circular indicators for RSI-based counter-trend possibilities
Take Profit Markers: X-cross symbols indicating statistical TP analysis zones
Pullback Signals: Purple arrows for potential trend continuation entries using Parabolic SAR
Visual Elements
8-Layer MA Cloud: Customizable moving average cloud system with 3 color themes for trend visualization
Real-Time Dashboard: Multi-timeframe trend analysis table showing bullish/bearish status across all timeframes
Dynamic Candle Colors: 4-intensity MACD-based coloring system (ranging from light to strong trend colors)
Entry/SL/TP Labels: Automatic calculation and display of suggested entry points, stop losses, and multiple take profit levels
Usage Instructions
Basic Configuration
Sensitivity Setting: Start with default value 6
Increase (7-15) for more frequent signals in volatile markets
Decrease (3-5) for higher quality signals in trending markets
MA Filter Type: McGinley Dynamic recommended for smoother signals
Filter Strength: Set to 80% for balanced filtering, adjust based on market conditions
Signal Interpretation
Long Entry: Green ▲ suggests when price crosses above SuperTrend with bullish SMA alignment
Short Entry: Red ▼ suggests when price crosses below SuperTrend with bearish SMA alignment
Reversal Opportunities: Small circles indicate RSI-based counter-trend analysis
Take Profit Zones: X-crosses mark statistical TP areas based on slope analysis
Dashboard Analysis
Green Cells: Bullish trend detected on that timeframe
Red Cells: Bearish trend detected on that timeframe
Multi-Timeframe Confluence: Look for alignment across multiple timeframes for stronger signal confirmation
Risk Management Features
Automatic Calculations
ATR-Based Stop Loss: Dynamic stop loss calculation using ATR multiplier (default 1.9x)
Multiple Take Profit Levels: Three TP targets with 1:1, 1:2, and 1:3 risk-reward ratios
Position Sizing Guidance: Entry labels display suggested price levels for order placement
Confirmation Requirements
Trend Alignment: Requires SuperTrend and SMA confirmation before signal generation
Filter Validation: Braid filter must show sufficient strength before signals activate
Multi-Timeframe Context: Dashboard provides broader market context for decision making
Optimal Settings
Timeframe Recommendations
Scalping: 1M-5M charts with sensitivity 8-12
Day Trading: 15M-1H charts with sensitivity 6-8
Swing Trading: 4H-Daily charts with sensitivity 4-6
Market Conditions
Trending Markets: Reduce sensitivity, increase filter strength
Ranging Markets: Increase sensitivity, enable reversal signals
High Volatility: Adjust ATR risk factor to 2.0-2.5
Advanced Features
Customization Options
MA Cloud Periods: 8 customizable periods for cloud layers (default: 2,6,11,18,21,24,28,34)
Color Themes: Three professional color schemes plus transparent option
Dashboard Position: 9 positioning options with 4 size settings
Signal Filtering: Individual toggle controls for each signal type
Technical Specifications
Moving Average Types: 21 different MA calculations including advanced types (Jurik, FRAMA, VIDA, CMA)
Pullback Detection: Parabolic SAR with customizable start, increment, and maximum values
Statistical Analysis: Linear regression slope calculation for trend-based TP analysis
Important Limitations
Lagging Nature: Some signals may appear after potential entry points due to confirmation requirements
Ranging Markets: May produce false signals during extended sideways price action
High Volatility: Requires parameter adjustment during news events or unusual market conditions
Computational Load: Multiple timeframe analysis may impact performance on slower devices
No Guarantee: All signals are suggestions based on technical analysis and may be incorrect
Educational Disclaimers
This indicator is designed for educational and analytical purposes only. It represents a technical analysis tool based on mathematical calculations of historical price data and should not be considered as financial advice or trading recommendations.
Risk Warning: Trading involves substantial risk of loss and is not suitable for all investors. Past performance of any trading system or methodology is not necessarily indicative of future results. The high degree of leverage can work against you as well as for you.
Important Notes:
Always conduct your own analysis before making trading decisions
Use appropriate position sizing and risk management strategies
Never risk more than you can afford to lose
Consider your investment objectives, experience level, and risk tolerance
Seek advice from qualified financial professionals when needed
Performance Disclaimer: Backtesting results do not guarantee future performance. Market conditions change constantly, and what worked in the past may not work in the future. Always paper trade new strategies before risking real capital.
cd_indiCATor_CxGeneral:
This indicator is the redesigned, simplified, and feature-enhanced version of the previously shared indicators:
cd_cisd_market_Cx, cd_HTF_Bias_Cx, cd_sweep&cisd_Cx, cd_SMT_Sweep_CISD_Cx, and cd_RSI_divergence_Cx.
Within the holistic setup, the indicator tracks:
• HTF bias
• Market structure (trend) in the current timeframe
• Divergence between selected pairs (SMT)
• Divergence between price and RSI values
• Whether the price is in an important area (FVG, iFVG, and Volume Imbalance)
• Whether the price is at a key level
• Whether the price is within a user-defined special timeframe
The main condition and trigger of the setup is an HTF sweep with CISD confirmation on the aligned timeframe.
When the main condition occurs, the indicator provides the user with a real-time market status summary, enriched with other data.
________________________________________
What’s new?
-In the SMT module:
• Triad SMT analysis (e.g.: NQ1!, ES1!, and YM1!)
• Dyad SMT analysis (e.g.: EURUSD, GBPUSD)
• Alternative pair definition and divergence analysis for non-correlated assets
o For crypto assets (xxxUSDT <--> xxxUSDT.P) (e.g.: SOLUSDT.P, SOLUSDT)
o For stocks, divergence analysis by comparing the asset with its value in another currency
(BIST:xxx <--> BIST:xxx / EURTRY), (BAT:xxx <--> BAT:xxx / EURUSD)
-Special timeframe definition
-Configurable multi-option alarm center
-Alternative summary presentation (check list / status table / stickers)
________________________________________
Details and usage:
The user needs to configure four main sections:
• Pair and correlated pairs
• Timeframes (Auto / Manual)
• Alarm center
• Visual arrangement and selections
Pair Selections:
The user should adjust trading pairs according to their trade preferences.
Examples:
• Triad: NQ1!-ES1!-YM1!, BTC-ETH-Total3
• Dyad: NAS100-US500, XAUUSD-XAGUSD, XRPUSDT-XLMUSDT
Single pairs:
-Crypto Assets:
If crypto assets are not in the triad or dyad list, they are automatically matched as:
Perpetual <--> Spot (e.g.: DOGEUSDT.P <--> DOGEUSDT)
If the asset is already defined in a dyad list (e.g., DOGE – SHIB), the dyad definition takes priority.
________________________________________
-Stocks:
If stocks are defined in the dyad list (e.g.: BIST:THYAO <--> BIST:PGSUS), the dyad definition takes priority.
If not defined, the stock is compared with its value in the selected currency.
For example, in the Turkish Stock Exchange:
BIST:FENER stock, if EUR is chosen from the menu, is compared as BIST:FENER / OANDA:EURTRY.
Here, “OANDA” and the stock market currency (TRY) are automatically applied for the exchange rate.
For NYSE:XOM, its pair will be NYSE:XOM / EURUSD.
________________________________________
Timeframes:
By default, the menu is set to “Auto.” In this mode, aligned timeframes are automatically selected.
Aligned timeframes (LTF-HTF):
1m-15m, 3m-30m, 5m-1h, 15m-4h, 1h-D, 4h-W, D-M
Example: if monitoring the chart on 5m:
• 1h sweep + 5m CISD confirmation
• D sweep + 1h CISD confirmation (bias)
• 5m market structure
• 1h SMT and 1h RSI divergence analysis
For manual selections, the user must define the timeframes for Sweep and HTF bias.
FVG, iFVG, and Volume Imbalance timeframes must be manually set in both modes.
________________________________________
Alarm Center:
The user can choose according to preferred criteria.
Each row has options.
“Yes” → included in alarm condition.
“No” → not included in alarm condition.
If special timeframe criteria are added to the alarm, the hour range must also be entered in the same row, and the “Special Zone” tab (default: -4) should be checked.
Key level timeframes and plot options must be set manually.
Example alarm setup:
Alongside the main Sweep + CISD condition, if we also want HTF bias + Trend alignment + key level (W, D) and special timeframe (09:00–11:00), we should set up the menu as follows:
________________________________________
Visual Arrangement and Selections:
Users can control visibility with checkboxes according to their preferences.
In the Table & Sticker tab, table options and labels can be controlled.
• Summary Table has two options: Check list and Status Table
• From the HTF bias section, real-time bias and HTF sweep zone (optional) are displayed
• The RSI divergence section only shows divergence analysis results
• The SMT 2 sub-section only functions when triad is selected
Labels are shown on the bar where the sweep + CISD condition occurs, displaying the current situation.
With the Check box option, all criteria’s real-time status is shown (True/False).
Status Table provides a real-time summary table.
Although the menu may look crowded, most settings only need to be adjusted once during initial use.
________________________________________
What’s next?
• Suggestions from users
• Standard deviation projection
• Mitigation/order blocks (cd special mtg)
• PSP /TPD
________________________________________
Final note:
Every additional criterion in the alarm settings will affect alarm frequency.
Multiple conditions occurring at the same time is not, by itself, sufficient to enter a trade—you should always apply your own judgment.
Looking forward to your feedback and suggestions.
Happy trading! 🎉
Volume Bubbles & Liquidity Heatmap [LuxAlgo]The Volume Bubbles & Liquidity Heatmap indicator highlights volume and liquidity clearly and precisely with its volume bubbles and liquidity heat map, allowing to identify key price areas.
Customize the bubbles with different time frames and different display modes: total volume, buy and sell volume, or delta volume.
🔶 USAGE
The primary objective of this tool is to offer traders a straightforward method for analyzing volume on any selected timeframe.
By default, the tool displays buy and sell volume bubbles for the daily timeframe over the last 2,000 bars. Traders should be aware of the difference between the timeframe of the chart and that of the bubbles.
The tool also displays a liquidity heat map to help traders identify price areas where liquidity accumulates or is lacking.
🔹 Volume Bubbles
The bubbles have three possible display modes:
Total Volume: Displays the total volume of trades per bubble.
Buy & Sell Volume: Each bubble is divided into buy and sell volume.
Delta Volume: Displays the difference between buy and sell volume.
Each bubble represents the trading volume for a given period. By default, the timeframe for each bubble is set to daily, meaning each bubble represents the trading volume for each day.
The size of each bubble is proportional to the volume traded; a larger bubble indicates greater volume, while a smaller bubble indicates lower volume.
The color of each bubble indicates the dominant volume: green for buy volume and red for sell volume.
One of the tool's main goals is to facilitate simple, clear, multi-timeframe volume analysis.
The previous chart shows Delta Volume bubbles with various chart and bubble timeframe configurations.
To correctly visualize the bubbles, traders must ensure there is a sufficient number of bars per bubble. This is achieved by using a lower chart timeframe and a higher bubble timeframe.
As can be seen in the image above, the greater the difference between the chart and bubble timeframes, the better the visualization.
🔹 Liquidity Heatmap
The other main element of the tool is the liquidity heatmap. By default, it divides the chart into 25 different price areas and displays the accumulated trading volume on each.
The image above shows a 4-hour BTC chart displaying only the liquidity heatmap. Traders should be aware of these key price areas and observe how the price behaves in them, looking for possible opportunities to engage with the market.
The main parameters for controlling the heatmap on the settings panel are Rows and Cell Minimum Size. Rows modifies the number of horizontal price areas displayed, while Cell Minimum Size modifies the minimum size of each liquidity cell in each row.
As can be seen in the above BTC hourly chart, the cell size is 24 at the top and 168 at the bottom. The cells are smaller on top and bigger on the bottom.
The color of each cell reflects the liquidity size with a gradient; this reflects the total volume traded within each cell. The default colors are:
Red: larger liquidity
Yellow: medium liquidity
Blue: lower liquidity
🔹 Using Both Tools Together
This indicator provides the means to identify directional bias and market timing.
The main idea is that if buyers are strong, prices are likely to increase, and if sellers are strong, prices are likely to decrease. This gives us a directional bias for opening long or short positions. Then, we combine our directional bias with price rejection or acceptance of key liquidity levels to determine the timing of opening or closing our positions.
Now, let's review some charts.
This first chart is BTC 1H with Delta Weekly Bubbles. Delta Bubbles measure the difference between buy and sell volume, so we can easily see which group is dominant (buyers or sellers) and how strong they are in any given week. This, along with the key price areas displayed by the Liquidity Heatmap, can help us navigate the markets.
We divided market behavior into seven groups, and each group has several bubbles, numbered from 1 to 17.
Bubbles 1, 2, and 3: After strong buyers market consolidates with positive delta, prices move up next week.
Bubbles 3, 4, and 5: Strength changes from buyers to sellers. Next week, prices go down.
Bubbles 6 and 7: The market trades at higher prices, but with negative delta. Next week, prices go down.
Bubbles 7, 8, and 9: Strength changes from sellers to buyers. Next weeks (9 and 10), prices go up.
Bubbles 10, 11, and 12: After strong buyers prices trade higher with a negative delta. Next weeks (12 and 13) prices go down.
Bubbles 12, 14, and 15: Strength changes from sellers to buyers; next week, prices increase.
Bubbles 15 and 16: The market trades higher with a very small positive delta; next week, prices go down.
Current bubble/week 17 is not yet finished. Right now, it is trading lower, but with a smaller negative delta than last week. This may signal that sellers are losing strength and that a potential reversal will follow, with prices trading higher.
This is the same BTC 1H chart, but with price rejections from key liquidity areas acting as strong price barriers.
When prices reach a key area with strong liquidity and are rejected, it signals a good time to take action.
By observing price behavior at certain key price levels, we can improve our timing for entering or exiting the markets.
🔶 DETAILS
🔹 Bubbles Display
From the settings panel, traders can configure the bubbles with four main parameters: Mode, Timeframe, Size%, and Shape.
The image above shows five-minute BTC charts with execution over the last 3,500 bars, different display modes, a daily timeframe, 100% size, and shape one.
The Size % parameter controls the overall size of the bubbles, while the Shape parameter controls their vertical growth.
Since the chart has two scales, one for time and one for price, traders can use the Shape parameter to make the bubbles round.
The chart above shows the same bubbles with different size and shape parameters.
You can also customize data labels and timeframe separators from the settings panel.
🔶 SETTINGS
Execute on last X bars: Number of bars for indicator execution
🔹 Bubbles
Display Bubbles: Enable/Disable volume bubbles.
Bubble Mode: Select from the following options: total volume, buy and sell volume, or the delta between buy and sell volume.
Bubble Timeframe: Select the timeframe for which the bubbles will be displayed.
Bubble Size %: Select the size of the bubbles as a percentage.
Bubble Shape: Select the shape of the bubbles. The larger the number, the more vertical the bubbles will be stretched.
🔹 Labels
Display Labels: Enable/Disable data labels, select size and location.
🔹 Separators
Display Separators: Enable/Disable timeframe separators and select color.
🔹 Liquidity Heatmap
Display Heatmap: Enable/Disable liquidity heatmap.
Heatmap Rows: select number of rows to be displayed.
Cell Minimum Size: Select the minimum size for each cell in each row.
Colors.
🔹 Style
Buy & Sell Volume Colors.
Mayfair FX Scalper V-10 Price Action + SMC//@version=5
indicator("Mayfair FX Scalper V-10 Price Action + SMC", overlay=true)
// === INPUTS ===
rsiLength = input.int(14, title="RSI Length")
overbought = input.float(73, title="SELL Level")
oversold = input.float(31, title="BUY Level")
rsiSrc = input.source(open, title="RSI Source")
// === Color Inputs ===
entryLineColor = input.color(color.white, title="entry Label Color")
entryLabelColor = input.color(color.white, title="entry Lable Color")
slLineColor = input.color(color.red, title="Stop Loss Line Color")
slLabelColor = input.color(color.red, title="Stop Loss Label Color")
tpLineColor = input.color(color.blue, title="Take Profit Line Color")
tpLabelColor = input.color(color.blue, title="Take Profit Color")
entryTextColor = input.color(color.rgb(0, 0, 0) , title="entry Text Color")
slTextColor = input.color(color.white, title="Stop Lose Color")
tpTextColor = input.color(color.white, title="Take Profit Text Color")
//indicator("Author Info Display"
// Create table
var table infoTable = table.new(position.top_right, 2, 6, bgcolor=color.new(#000000, 1), border_width=1)
if barstate.islast
table.cell(infoTable, 0, 0, "Author:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 0, "MR WOW", text_color=color.rgb(255, 251, 0), text_size=size.large)
table.cell(infoTable, 0, 1, "YouTube:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 1, "www.youtube.com/@iammrwow", text_color=color.rgb(255, 251, 0), text_size=size.small)
table.cell(infoTable, 0, 3, "Website:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 3, "www.mrwowea.com", text_color=color.rgb(255, 251, 0), text_size=size.small)
// === RSI CALCULATION ===
rsi = ta.rsi(rsiSrc, rsiLength)
rawBuySignal = rsi < oversold
rawSellSignal = rsi > overbought
// === Confirmed Signals ===
isBullish = close > open
isBearish = close < open
newBuy = rawBuySignal and isBullish and close > open == false
newSell = rawSellSignal and isBearish and close < open == false
// === Trade State Variables ===
var bool inPosition = false
var bool isBuy = false
var float entryPrice = na
var float slPrice = na
var float tp1Price = na
var float tp2Price = na
var float tp3Price = na
var int entryBarIndex = na
var label labels = array.new()
var line lines = array.new()
// === Instrument & Timeframe SL/TP Setup ===
isGold = str.contains(syminfo.ticker, "XAU") or str.contains(syminfo.ticker, "GOLD")
instrumentType = syminfo.type == "crypto" ? "Crypto" : isGold ? "Gold" : syminfo.currency == "JPY" ? "JPY" : "Forex"
tf = timeframe.period
slPipsGold = tf == "1" ? 30 : tf == "3" ? 45 : tf == "5" ? 50 : tf == "15" ? 60 : 70
slPipsCrypto = tf == "1" ? 5 : tf == "3" ? 8 : tf == "5" ? 12 : tf == "15" ? 15 : 10
slPipsForex = tf == "1" ? 6 : tf == "3" ? 9 : tf == "5" ? 11 : tf == "15" ? 15 : 15
gold_slDist = 0.1 * slPipsGold
gold_tp1Dist = gold_slDist
gold_tp2Dist = gold_slDist * 2
gold_tp3Dist = gold_slDist * 3
pipSize = instrumentType == "Crypto" ? 1.0 : instrumentType == "Gold" or instrumentType == "JPY" ? 0.01 : 0.0001
slPips = instrumentType == "Crypto" ? slPipsCrypto : instrumentType == "Gold" ? slPipsGold : slPipsForex
slDist = slPips * pipSize
tp1Dist = slDist
tp2Dist = slDist * 2
tp3Dist = slDist * 3
// === Draw Line & Label ===
drawLine(y, txt, col, lblCol, extendToCurrent) =>
int lineEnd = extendToCurrent ? bar_index : entryBarIndex + 2
array.push(lines, line.new(entryBarIndex, y, lineEnd, y, color=col, width=2, extend=extend.none))
textCol = str.contains(txt, "Entry") ? entryTextColor : str.contains(txt, "Stop") ? slTextColor : tpTextColor
array.push(labels, label.new(lineEnd, y, txt, style=label.style_label_left, color=color.new(lblCol, 0), textcolor=textCol, size=size.small))
// === Check Exit ===
slHit = inPosition and ((isBuy and low <= slPrice) or (not isBuy and high >= slPrice))
tp3Hit = inPosition and ((isBuy and high >= tp3Price) or (not isBuy and low <= tp3Price))
shouldExit = slHit or tp3Hit
if shouldExit
for l in labels
label.delete(l)
array.clear(labels)
for ln in lines
line.delete(ln)
array.clear(lines)
inPosition := false
entryPrice := na
slPrice := na
tp1Price := na
tp2Price := na
tp3Price := na
entryBarIndex := na
// === Confirmed Signal with No Position ===
confirmedBuy = not inPosition and newBuy
confirmedSell = not inPosition and newSell
// === Signal Markers ===
plotshape(series=confirmedBuy, location=location.belowbar, color=color.rgb(33, 150, 243), style=shape.triangleup, text="BUY", textcolor=color.rgb(33, 150, 243))
plotshape(series=confirmedSell, location=location.abovebar, color=color.rgb(254, 254, 255), style=shape.triangledown, text="SELL", textcolor=color.rgb(239, 238, 247))
// === Entry Execution ===
if confirmedBuy or confirmedSell
entryPrice := close
entryBarIndex := bar_index
isBuy := confirmedBuy
inPosition := true
if isGold
slPrice := isBuy ? entryPrice - gold_slDist : entryPrice + gold_slDist
tp1Price := isBuy ? entryPrice + gold_tp1Dist : entryPrice - gold_tp1Dist
tp2Price := isBuy ? entryPrice + gold_tp2Dist : entryPrice - gold_tp2Dist
tp3Price := isBuy ? entryPrice + gold_tp3Dist : entryPrice - gold_tp3Dist
else
slPrice := isBuy ? entryPrice - slDist : entryPrice + slDist
tp1Price := isBuy ? entryPrice + tp1Dist : entryPrice - tp1Dist
tp2Price := isBuy ? entryPrice + tp2Dist : entryPrice - tp2Dist
tp3Price := isBuy ? entryPrice + tp3Dist : entryPrice - tp3Dist
drawLine(entryPrice, "Entry Price - After Candle Above Entry Price Then Place Trade: " + str.tostring(entryPrice), entryLineColor, entryLabelColor, false)
drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, false)
drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, false)
drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, false)
drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, false)
// === Update TP/SL Lines if Still in Trade ===
if inPosition and not (confirmedBuy or confirmedSell)
for ln in lines
line.delete(ln)
array.clear(lines)
for l in labels
label.delete(l)
array.clear(labels)
drawLine(entryPrice, "After Candle Closed Above Entry Line Buy & Below Sell :Entry Price-" + str.tostring(entryPrice), entryLineColor, entryLabelColor, true)
drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, true)
drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, true)
drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, true)
drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, true)
// === Bollinger Bands Inputs ===
bb_length = input.int(20, title="SMA & StdDev Length")
src = input.source(close, title="Source")
// === Bollinger Band Colors ===
color_upper_2_3 = input.color(color.new(#0db107, 64), title="Upper Band 2–3 Color")
color_upper_3_4 = input.color(color.new(#05c41f, 58), title="Upper Band 3–4 Color")
color_lower_2_3 = input.color(color.new(#bdbc9d, 80), title="Lower Band 2–3 Color")
color_lower_3_4 = input.color(color.new(#e9e6bf, 63), title="Lower Band 3–4 Color")
// === Bollinger Band Calculations ===
sma = ta.sma(src, bb_length)
stdev = ta.stdev(src, bb_length)
bb2_upper = sma + 2 * stdev
bb2_lower = sma - 2 * stdev
bb3_upper = sma + 3 * stdev
bb3_lower = sma - 3 * stdev
bb4_upper = sma + 4 * stdev
bb4_lower = sma - 4 * stdev
// === Hidden Plots for Fill ===
p_bb2_upper = plot(bb2_upper, color=na)
p_bb3_upper = plot(bb3_upper, color=na)
p_bb4_upper = plot(bb4_upper, color=na)
p_bb2_lower = plot(bb2_lower, color=na)
p_bb3_lower = plot(bb3_lower, color=na)
p_bb4_lower = plot(bb4_lower, color=na)
// === Band Zone Fills ===
fill(p_bb2_upper, p_bb3_upper, color=color_upper_2_3)
fill(p_bb3_upper, p_bb4_upper, color=color_upper_3_4)
fill(p_bb2_lower, p_bb3_lower, color=color_lower_2_3)
fill(p_bb3_lower, p_bb4_lower, color=color_lower_3_4)
//SMc
BULLISH_LEG = 1
BEARISH_LEG = 0
BULLISH = +1
BEARISH = -1
GREEN = #9c9c9c
RED = #9c9c9c
BLUE = #9c9c9c
GRAY = #ffffff
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b
HISTORICAL = 'Historical'
PRESENT = 'Present'
COLORED = 'Colored'
MONOCHROME = 'Monochrome'
ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'
TINY = size.tiny
SMALL = size.small
NORMAL = size.normal
ATR = 'Atr'
RANGE = 'Cumulative Mean Range'
CLOSE = 'Close'
HIGHLOW = 'High/Low'
SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'
SMART_GROUP = 'Smart Money Concepts'
INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'
modeTooltip = 'Allows to display historical Structure or only the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart'
modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = )
styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = )
showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip)
showInternalsInput = input( true, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = )
internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = )
internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = )
showStructureInput = input( true, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = )
swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = )
swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = )
showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( true, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)
showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob')
internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( false, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = )
internalBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Bullish OB', group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Bearish OB', group = BLOCKS_GROUP)
showEqualHighsLowsInput = input( true, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = )
showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = )
dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = )
weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = )
monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly')
showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP)
//---------------------------------------------------------------------------------------------------------------------}
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------------------------------------------{
// @type UDT representing alerts as bool fields
// @field internalBullishBOS internal structure custom alert
// @field internalBearishBOS internal structure custom alert
// @field internalBullishCHoCH internal structure custom alert
// @field internalBearishCHoCH internal structure custom alert
// @field swingBullishBOS swing structure custom alert
// @field swingBearishBOS swing structure custom alert
// @field swingBullishCHoCH swing structure custom alert
// @field swingBearishCHoCH swing structure custom alert
// @field internalBullishOrderBlock internal order block custom alert
// @field internalBearishOrderBlock internal order block custom alert
// @field swingBullishOrderBlock swing order block custom alert
// @field swingBearishOrderBlock swing order block custom alert
// @field equalHighs equal high low custom alert
// @field equalLows equal high low custom alert
// @field bullishFairValueGap fair value gap custom alert
// @field bearishFairValueGap fair value gap custom alert
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false
// @type UDT representing last swing extremes (top & bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
// @type UDT representing Fair Value Gaps
// @field top top price
// @field bottom bottom price
// @field bias bias (BULLISH or BEARISH)
// @field topBox top box
// @field bottomBox bottom box
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox
// @type UDT representing trend bias
// @field bias BULLISH or BEARISH
type trend
int bias
// @type UDT representing Equal Highs Lows display
// @field l_ine displayed line
// @field l_abel displayed label
type equalDisplay
line l_ine = na
label l_abel = na
// @type UDT representing a pivot point (swing point)
// @field currentLevel current price level
// @field lastLevel last price level
// @field crossed true if price level is crossed
// @field barTime bar time
// @field barIndex bar index
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
// @type UDT representing an order block
// @field barHigh bar high
// @field barLow bar low
// @field barTime bar time
// @field bias BULLISH or BEARISH
type orderBlock
float barHigh
float barLow
int barTime
int bias
// @variable current swing pivot high
var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array fairValueGaps = array.new()
// @variable storage for parsed highs
var array parsedHighs = array.new()
// @variable storage for parsed lows
var array parsedLows = array.new()
// @variable storage for raw highs
var array highs = array.new()
// @variable storage for raw lows
var array lows = array.new()
// @variable storage for bar time values
var array times = array.new()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing order blocks)
var array swingOrderBlocks = array.new()
// @variable storage for orderBlock UDTs (internal order blocks)
var array internalOrderBlocks = array.new()
// @variable storage for swing order blocks boxes
var array swingOrderBlocksBoxes = array.new()
// @variable storage for internal order blocks boxes
var array internalOrderBlocksBoxes = array.new()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time
// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
// @variable source to use in bearish order blocks mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high
// @variable source to use in bullish order blocks mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)
//---------------------------------------------------------------------------------------------------------------------}
//USER-DEFINED FUNCTIONS
//---------------------------------------------------------------------------------------------------------------------{
// @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish)
// @returns int
leg(int size) =>
var leg = 0
newLegHigh = high > ta.highest( size)
newLegLow = low < ta.lowest( size)
if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg
// @function Identify whether the current value is the start of a new leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0
// @function Identify whether the current level is the start of a new bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1
// @function Identify whether the current level is the start of a new bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1
// @function create a new label
// @param labelTime bar time coordinate
// @param labelPrice price coordinate
// @param tag text to display
// @param labelColor text color
// @param labelStyle label style
// @returns label ID
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) =>
var label l_abel = na
if modeInput == PRESENT
l_abel.delete()
l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small)
// @function create a new line and label representing an EQH or EQL
// @param p_ivot starting pivot
// @param level price level of current pivot
// @param size how many bars ago was the current pivot detected
// @param equalHigh true for EQH, false for EQL
// @returns label ID
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay
string tag = 'EQL'
color equalColor = swingBullishColor
string labelStyle = label.style_label_up
if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down
if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)
e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput)
// @function store current structure and trailing swing points, and also display swing points and equal highs/lows
// @param size (int) structure size
// @param equalHighLow (bool) true for displaying current highs/lows
// @param internal (bool) true for getting internal structures
// @returns label ID
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)
if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow
if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low , size, false)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh
if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high ,size,true)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)
// @function draw line and label representing a structure
// @param p_ivot base pivot point
// @param tag test to display
// @param structureColor base color
// @param lineStyle line style
// @param labelStyle label style
// @param labelSize text size
// @returns label ID
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)
if modeInput == PRESENT
l_ine.delete()
l_abel.delete()
l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle)
l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize)
// @function delete order blocks
// @param internal true for internal order blocks
// @returns orderBlock ID
deleteOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
for in orderBlocks
bool crossedOderBlock = false
if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)
// @function fetch and store order blocks
// @param p_ivot base pivot point
// @param internal true for internal order blocks
// @param bias BULLISH or BEARISH
// @returns void
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput)
array a_rray = na
int parsedIndex = na
if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())
orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias)
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
if orderBlocks.size() >= 100
orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)
// @function draw order blocks as boxes
// @param internal true for internal order blocks
// @returns void
drawOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
orderBlocksSize = orderBlocks.size()
if orderBlocksSize > 0
maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize))
array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes
for in parsedOrdeBlocks
orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor)
box b_ox = b_oxes.get(index)
b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow))
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)
// @function detect and draw structures, also detect and store order blocks
// @param internal true for internal structures or order blocks
// @returns void
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true
if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)
pivot p_ivot = internal ? internalHigh : swingHigh
trend t_rend = internal ? internalTrend : swingTrend
lineStyle = internal ? line.style_dashed : line.style_solid
labelSize = internal ? internalStructureSize : swingStructureSize
extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput
if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS
if internal
currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BULLISH
displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)
p_ivot := internal ? internalLow : swingLow
extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput
if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS
if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BEARISH
displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)
// @function draw one fair value gap box (each fair value gap has two boxes)
// @param leftTime left time coordinate
// @param rightTime right time coordinate
// @param topPrice top price level
// @param bottomPrice bottom price level
// @param boxColor box color
// @returns box ID
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor)
// @function delete fair value gaps
// @returns fairValueGap ID
deleteFairValueGaps() =>
for in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)
// @function draw fair value gaps
// @returns fairValueGap ID
drawFairValueGaps() =>
= request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on)
barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)
newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0
bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe
if bullishFairValueGap
currentAlerts.bullishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor)))
// @function get line style from string
// @param style line style
// @returns string
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
// @function draw MultiTimeFrame levels
// @param timeframe base timeframe
// @param sameTimeframe true if chart timeframe is same as base timeframe
// @param style line style
// @param levelColor line and text color
// @returns void
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
= request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on)
float parsedTop = sameTimeframe ? high : topLevel
float parsedBottom = sameTimeframe ? low : bottomLevel
int parsedLeftTime = sameTimeframe ? time : leftTime
int parsedRightTime = sameTimeframe ? time : rightTime
int parsedTopTime = time
int parsedBottomTime = time
if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex = times.binary_search_rightmost(parsedRightTime)
array timeArray = times.slice(leftIndex,rightIndex)
array topArray = highs.slice(leftIndex,rightIndex)
array bottomArray = lows.slice(leftIndex,rightIndex)
parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime
var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
// @function true if chart timeframe is higher than provided timeframe
// @param timeframe timeframe to check
// @returns bool
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
// @function update trailing swing points
// @returns int
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime
// @function draw trailing swing points
// @returns void
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny)
rightTimeBar = last_bar_time + 20 * (time - time )
topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High')
bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low')
// @function draw a zone with a label and a box
// @param labelLevel price level for label
// @param labelIndex bar index for label
// @param top top price level for box
// @param bottom bottom price level for box
// @param tag text to display
// @param zoneColor base color
// @param style label style
// @returns void
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)
b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))
l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))
// @function draw premium/discount zones
// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down)
equilibriumLevel = math.avg(trailing.top, trailing.bottom)
drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left)
drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up)
//---------------------------------------------------------------------------------------------------------------------}
//MUTABLE VARIABLES & EXECUTION
//---------------------------------------------------------------------------------------------------------------------{
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor)
if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()
if showHighLowSwingsInput
drawHighLowSwings()
if showPremiumDiscountZonesInput
drawPremiumDiscountZones()
if showFairValueGapsInput
deleteFairValueGaps()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showInternalOrderBlocksInput or showTrendInput
displayStructure(true)
if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput
displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)
if showSwingOrderBlocksInput
deleteOrderBlocks()
if showFairValueGapsInput
drawFairValueGaps()
if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)
if showSwingOrderBlocksInput
drawOrderBlocks()
lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex
if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)
if showDailyLevelsInput and not higherTimeframe('D')
drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)
if showWeeklyLevelsInput and not higherTimeframe('W')
drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)
if showMonthlyLevelsInput and not higherTimeframe('M')
drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)
//---------------------------------------------------------------------------------------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed')
alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed')
//---------------------------------------------------------------------------------------------------------------------}
Supertrend0913This Pine Script (`@version=6`) combines **two Supertrend indicators** and a set of **moving averages (EMA & MA)** into one overlay chart tool for TradingView.
**Key features:**
* **Supertrend \ & \ :**
* Each has independent ATR period, multiplier, and ATR calculation method.
* Plots trend lines (green/red for \ , blue/yellow for \ ).
* Generates **buy/sell signals** when trend direction changes.
* Includes **alert conditions** for buy, sell, and trend reversals.
* **Moving Averages:**
* 6 EMAs (lengths 21, 55, 100, 200, 300, 400).
* 5 SMAs (lengths 11, 23, 25, 39, 200).
* Each plotted in different colors for trend visualization.
👉 In short: it’s a **combined trading tool** that overlays two configurable Supertrend systems with alerts plus multiple EMAs/SMAs to help identify trend direction, signals, and potential entry/exit points.
ICT Silver Bullet Zones (All Sessions, Custom Labels)CT Silver Bullet Zones
This indicator is designed for traders who follow the ICT *Silver Bullet* concept.
It automatically marks the **Silver Bullet window** (10:00–11:00 by default) across the **London, New York AM, New York PM, and Asia sessions**, with customizable settings for each session.
### Features:
* Separate adjustable time windows for **London, NY AM, NY PM, and Asia Silver Bullet sessions**.
* Colored session boxes with individual **opacity controls**.
* **Session labels placed at the top** of each zone, with customizable text size, color, and background opacity.
* Works on all timeframes and highlights only the Silver Bullet trading windows.
This tool is meant to help traders quickly identify ICT Silver Bullet opportunities in all major sessions without manual plotting.
AInfluence Manual Data Input Utility Indicator V101AInfluence (Manual Data Input Utility Indicator) V101
Overview
This utility indicator enables you to plot an external data series directly on your TradingView chart. It is designed for users who want to correlate custom datasets, such as sentiment analysis, economic data, or other external metrics, with price action.
Instructions
1. Add the indicator to your chart.
2. Go into the indicator's "Settings" panel.
3. Paste your pre-formatted data into the text input field.
Data Formatting Rules
The script requires a specific format for each data point, which consists of a numerical value and a timestamp
• Structure: Each data point must be on a new line.
• Limit: You can paste a maximum of 146 records.
Example Data:
93.1562,2025-09-06 00:59:11
94.9062,2025-09-06 01:59:21
93.4062,2025-09-06 02:59:18
95.2188,2025-09-06 03:59:31
93.4062,2025-09-06 04:59:21
91.4583,2025-09-06 05:58:51
93.7812,2025-09-06 06:59:17
The source code for this indicator is open and accessible.
Custom Time Range HighlightThis indicator highlights specific time ranges on your TradingView chart with customizable background colors and labels, making it easier to identify key trading sessions and ICT (Inner Circle Trader) Killzones. It is designed for traders who want to mark important market hours, such as major sessions (Asia, New York, London) or high-volatility Killzones, with full control over activation, timing, colors, and transparency.
Features
Customizable Time Ranges: Define up to 9 different time ranges, including one custom range, three major market sessions (Asia, New York, London), and five ICT Killzones (Asia, NY Open, NY Close, London Open, London Close).
Individual Activation: Enable or disable each time range independently via checkboxes in the settings. By default, only the ICT Killzones are active.
Custom Colors and Transparency: Set unique background and label colors for each range, with adjustable transparency for both.
Labeled Time Ranges: Each active range is marked with a customizable label at the start of the period, displayed above the chart for easy identification.
Priority Handling: If multiple ranges overlap, the range with the higher number (e.g., Asia Killzone over Custom Range) determines the background color.
CET Time Zone: Time ranges are based on Central European Time (CET, Europe/Vienna). Adjust the hours and minutes to match your trading needs.
Settings
The indicator settings are organized into three groups for clarity:
Custom Range: A flexible range (default: 15:30–18:00 CET) for user-defined periods.
Session - Asia, NY, London: Major market sessions (Asia: 01:00–10:00, New York: 14:00–23:00, London: 09:00–18:00 CET).
ICT Killzones - Asia, NY, London: High-volatility periods (NY Open: 13:00–16:00, NY Close: 20:00–23:00, London Open: 08:00–11:00, London Close: 16:00–18:00, Asia: 02:00–05:00 CET).
For each range, you can:
Toggle activation (default: only ICT Killzones enabled).
Adjust start and end times (hours and minutes).
Customize the label text.
Choose background and label colors with transparency levels (0–100).
How to Use
Add the indicator to your chart.
Open the settings to enable/disable specific ranges, adjust their times, or customize colors and labels.
The chart will highlight active time ranges with the selected background colors and display labels at the start of each range.
Use it to focus on key trading periods, such as ICT Killzones for high-probability setups or major sessions for market analysis.
Notes
Ensure your time ranges align with your trading instrument’s session times.
Overlapping ranges prioritize higher-numbered ranges (e.g., Asia Killzone overrides London Session).
Ideal for day traders, scalpers, or ICT strategy followers who need clear visual cues for specific market hours.
Feedback
If you have suggestions for improvements or need help with customization, feel free to leave a comment or contact the author!
Fury by Tetrad on TESLA v2Fury by Tetrad — TSLA v2 (Free Version)
📊 Fury v2 on TSLA — Financial Snapshot
First trade: August 11, 2010
Last trade: September 5, 2025
Net Profit: $10,549.10 (≈ +10,549%)
Gross Profit: $10,554.36
Gross Loss: $5.26
Commission Paid: $86.95
⚖️ Risk/Return Ratios
Sharpe Ratio: 0.42
Sortino Ratio: 17.63
Profit Factor: 2005.38
🔄 Trade Statistics
Total Trades: 37
Winning Trades: 37
Losing Trades: 0
Win Rate: 100%
Fury is a momentum-reversion hybrid designed for Tesla (TSLA) on higher-liquidity timeframes. It combines Bollinger Bands (signal extremes) with RSI (exhaustion filter) to time mean-reversion pops/drops, then exits via price multipliers or optional time-based stops. A Market Direction toggle (Market Neutral / Long Only / Short Only) lets you align with macro bias or risk constraints. Intrabar simulation is enabled for realistic stop/limit behavior, and labeled entries/exits improve visual auditability.
How it works
Entries:
• Long when price pierces lower band and RSI is below the long threshold.
• Short when price pierces upper band and RSI is above the short threshold.
Exits:
• Profit targets via entry×multiplier (independent for long/short).
• Optional price-based stop factors per side.
• Optional time stop (N days) to cap trade duration.
Controls:
• Market Direction switch (Neutral / Long Only / Short Only).
• Tunable BB length/multiplier, RSI length/thresholds, exit multipliers, stops.
Intended use
Swing or position trading TSLA; can be adapted to other high-beta equities with parameter retuning. Use on liquid timeframes and validate with robust out-of-sample testing.
Disclaimers
Backtests are approximations; past performance ≠ future results. Educational use only. Not financial advice.
Stay connected
Follow on TradingView for updates • Telegram: t.me • Website: tetradprotocol.com
ICT Sweep + FVG Entry (v6) • Pro Pack 📌 ICT Sweep + FVG Entry Pro Pack
This indicator combines key ICT price action concepts with practical execution tools to help traders spot high-probability setups faster and more objectively. It’s designed for scalpers and intraday traders who want to keep their chart clean but never miss critical market structure events.
🔑 Features
Liquidity Pools (HTF)
• Auto-detects recent swing highs/lows from higher timeframes (5m/15m).
• Draws both lines and optional rectangles/zones for clear liquidity areas.
Liquidity Sweeps (BSL/SSL)
• Identifies when price sweeps above/below liquidity pools and rejects back.
• Optional Grade-A sweep filter (wick size + strong re-entry).
Fair Value Gaps (FVGs)
• Highlights bullish/bearish imbalances.
• Optional midline (50%) entry for precision.
• Auto-invalidation when price fully closes inside the gap.
Killzones (New York)
• Highlights AM (9:30–11:30) and PM (14:00–15:30) killzones.
• Option to block signals outside killzones for higher strike rate.
Bias Badge (DR50)
• Displays if price is trading in a Bull, Bear, or Range context based on displacement range midpoint.
SMT Assist (NQ vs ES)
• Detects simple divergences between indices:
Bearish SMT → NQ makes HH while ES doesn’t.
Bullish SMT → NQ makes LL while ES doesn’t.
SL/TP Helper & R:R Label
• Automatically draws stop loss (at sweep extreme) and target (opposite pool or recent swing).
• Displays expected Risk:Reward ratio and blocks entries if below your chosen minimum.
Filters
• ATR filter ensures signals only appear in sufficient volatility.
• Sweep quality filter avoids weak wicks and fake-outs.
🎯 How to Use
Start on HTF (5m/15m) → Identify liquidity zones and bias.
Drop to LTF (1m) → Wait for a liquidity sweep confirmation.
Check for FVG in the sweep’s direction → Look for retest entry.
Use the SL/TP helper to validate your risk/reward before taking the trade.
Focus entries during NY Killzones for maximum effectiveness.
✅ Why this helps
This tool reduces screen time and hesitation by automating repetitive ICT concepts:
Liquidity pools, sweeps, and FVGs are marked automatically.
Killzone timing and SMT divergence are simplified.
Clear visual signals for entries with built-in RR filter help keep your trading mechanical.
⚠️ Disclaimer: This script is for educational purposes only. It does not provide financial advice or guarantee results. Always use proper risk management.
Tzotchev Trend Measure [EdgeTools]Are you still measuring trend strength with moving averages? Here is a better variant at scientific level:
Tzotchev Trend Measure: A Statistical Approach to Trend Following
The Tzotchev Trend Measure represents a sophisticated advancement in quantitative trend analysis, moving beyond traditional moving average-based indicators toward a statistically rigorous framework for measuring trend strength. This indicator implements the methodology developed by Tzotchev et al. (2015) in their seminal J.P. Morgan research paper "Designing robust trend-following system: Behind the scenes of trend-following," which introduced a probabilistic approach to trend measurement that has since become a cornerstone of institutional trading strategies.
Mathematical Foundation and Statistical Theory
The core innovation of the Tzotchev Trend Measure lies in its transformation of price momentum into a probability-based metric through the application of statistical hypothesis testing principles. The indicator employs the fundamental formula ST = 2 × Φ(√T × r̄T / σ̂T) - 1, where ST represents the trend strength score bounded between -1 and +1, Φ(x) denotes the normal cumulative distribution function, T represents the lookback period in trading days, r̄T is the average logarithmic return over the specified period, and σ̂T represents the estimated daily return volatility.
This formulation transforms what is essentially a t-statistic into a probabilistic trend measure, testing the null hypothesis that the mean return equals zero against the alternative hypothesis of non-zero mean return. The use of logarithmic returns rather than simple returns provides several statistical advantages, including symmetry properties where log(P₁/P₀) = -log(P₀/P₁), additivity characteristics that allow for proper compounding analysis, and improved validity of normal distribution assumptions that underpin the statistical framework.
The implementation utilizes the Abramowitz and Stegun (1964) approximation for the normal cumulative distribution function, achieving accuracy within ±1.5 × 10⁻⁷ for all input values. This approximation employs Horner's method for polynomial evaluation to ensure numerical stability, particularly important when processing large datasets or extreme market conditions.
Comparative Analysis with Traditional Trend Measurement Methods
The Tzotchev Trend Measure demonstrates significant theoretical and empirical advantages over conventional trend analysis techniques. Traditional moving average-based systems, including simple moving averages (SMA), exponential moving averages (EMA), and their derivatives such as MACD, suffer from several fundamental limitations that the Tzotchev methodology addresses systematically.
Moving average systems exhibit inherent lag bias, as documented by Kaufman (2013) in "Trading Systems and Methods," where he demonstrates that moving averages inevitably lag price movements by approximately half their period length. This lag creates delayed signal generation that reduces profitability in trending markets and increases false signal frequency during consolidation periods. In contrast, the Tzotchev measure eliminates lag bias by directly analyzing the statistical properties of return distributions rather than smoothing price levels.
The volatility normalization inherent in the Tzotchev formula addresses a critical weakness in traditional momentum indicators. As shown by Bollinger (2001) in "Bollinger on Bollinger Bands," momentum oscillators like RSI and Stochastic fail to account for changing volatility regimes, leading to inconsistent signal interpretation across different market conditions. The Tzotchev measure's incorporation of return volatility in the denominator ensures that trend strength assessments remain consistent regardless of the underlying volatility environment.
Empirical studies by Hurst, Ooi, and Pedersen (2013) in "Demystifying Managed Futures" demonstrate that traditional trend-following indicators suffer from significant drawdowns during whipsaw markets, with Sharpe ratios frequently below 0.5 during challenging periods. The authors attribute these poor performance characteristics to the binary nature of most trend signals and their inability to quantify signal confidence. The Tzotchev measure addresses this limitation by providing continuous probability-based outputs that allow for more sophisticated risk management and position sizing strategies.
The statistical foundation of the Tzotchev approach provides superior robustness compared to technical indicators that lack theoretical grounding. Fama and French (1988) in "Permanent and Temporary Components of Stock Prices" established that price movements contain both permanent and temporary components, with traditional moving averages unable to distinguish between these elements effectively. The Tzotchev methodology's hypothesis testing framework specifically tests for the presence of permanent trend components while filtering out temporary noise, providing a more theoretically sound approach to trend identification.
Research by Moskowitz, Ooi, and Pedersen (2012) in "Time Series Momentum in the Cross Section of Asset Returns" found that traditional momentum indicators exhibit significant variation in effectiveness across asset classes and time periods. Their study of multiple asset classes over decades revealed that simple price-based momentum measures often fail to capture persistent trends in fixed income and commodity markets. The Tzotchev measure's normalization by volatility and its probabilistic interpretation provide consistent performance across diverse asset classes, as demonstrated in the original J.P. Morgan research.
Comparative performance studies conducted by AQR Capital Management (Asness, Moskowitz, and Pedersen, 2013) in "Value and Momentum Everywhere" show that volatility-adjusted momentum measures significantly outperform traditional price momentum across international equity, bond, commodity, and currency markets. The study documents Sharpe ratio improvements of 0.2 to 0.4 when incorporating volatility normalization, consistent with the theoretical advantages of the Tzotchev approach.
The regime detection capabilities of the Tzotchev measure provide additional advantages over binary trend classification systems. Research by Ang and Bekaert (2002) in "Regime Switches in Interest Rates" demonstrates that financial markets exhibit distinct regime characteristics that traditional indicators fail to capture adequately. The Tzotchev measure's five-tier classification system (Strong Bull, Weak Bull, Neutral, Weak Bear, Strong Bear) provides more nuanced market state identification than simple trend/no-trend binary systems.
Statistical testing by Jegadeesh and Titman (2001) in "Profitability of Momentum Strategies" revealed that traditional momentum indicators suffer from significant parameter instability, with optimal lookback periods varying substantially across market conditions and asset classes. The Tzotchev measure's statistical framework provides more stable parameter selection through its grounding in hypothesis testing theory, reducing the need for frequent parameter optimization that can lead to overfitting.
Advanced Noise Filtering and Market Regime Detection
A significant enhancement over the original Tzotchev methodology is the incorporation of a multi-factor noise filtering system designed to reduce false signals during sideways market conditions. The filtering mechanism employs four distinct approaches: adaptive thresholding based on current market regime strength, volatility-based filtering utilizing ATR percentile analysis, trend strength confirmation through momentum alignment, and a comprehensive multi-factor approach that combines all methodologies.
The adaptive filtering system analyzes market microstructure through price change relative to average true range, calculates volatility percentiles over rolling windows, and assesses trend alignment across multiple timeframes using exponential moving averages of varying periods. This approach addresses one of the primary limitations identified in traditional trend-following systems, namely their tendency to generate excessive false signals during periods of low volatility or sideways price action.
The regime detection component classifies market conditions into five distinct categories: Strong Bull (ST > 0.3), Weak Bull (0.1 < ST ≤ 0.3), Neutral (-0.1 ≤ ST ≤ 0.1), Weak Bear (-0.3 ≤ ST < -0.1), and Strong Bear (ST < -0.3). This classification system provides traders with clear, quantitative definitions of market regimes that can inform position sizing, risk management, and strategy selection decisions.
Professional Implementation and Trading Applications
The indicator incorporates three distinct trading profiles designed to accommodate different investment approaches and risk tolerances. The Conservative profile employs longer lookback periods (63 days), higher signal thresholds (0.2), and reduced filter sensitivity (0.5) to minimize false signals and focus on major trend changes. The Balanced profile utilizes standard academic parameters with moderate settings across all dimensions. The Aggressive profile implements shorter lookback periods (14 days), lower signal thresholds (-0.1), and increased filter sensitivity (1.5) to capture shorter-term trend movements.
Signal generation occurs through threshold crossover analysis, where long signals are generated when the trend measure crosses above the specified threshold and short signals when it crosses below. The implementation includes sophisticated signal confirmation mechanisms that consider trend alignment across multiple timeframes and momentum strength percentiles to reduce the likelihood of false breakouts.
The alert system provides real-time notifications for trend threshold crossovers, strong regime changes, and signal generation events, with configurable frequency controls to prevent notification spam. Alert messages are standardized to ensure consistency across different market conditions and timeframes.
Performance Optimization and Computational Efficiency
The implementation incorporates several performance optimization features designed to handle large datasets efficiently. The maximum bars back parameter allows users to control historical calculation depth, with default settings optimized for most trading applications while providing flexibility for extended historical analysis. The system includes automatic performance monitoring that generates warnings when computational limits are approached.
Error handling mechanisms protect against division by zero conditions, infinite values, and other numerical instabilities that can occur during extreme market conditions. The finite value checking system ensures data integrity throughout the calculation process, with fallback mechanisms that maintain indicator functionality even when encountering corrupted or missing price data.
Timeframe validation provides warnings when the indicator is applied to unsuitable timeframes, as the Tzotchev methodology was specifically designed for daily and higher timeframe analysis. This validation helps prevent misapplication of the indicator in contexts where its statistical assumptions may not hold.
Visual Design and User Interface
The indicator features eight professional color schemes designed for different trading environments and user preferences. The EdgeTools theme provides an institutional blue and steel color palette suitable for professional trading environments. The Gold theme offers warm colors optimized for commodities trading. The Behavioral theme incorporates psychology-based color contrasts that align with behavioral finance principles. The Quant theme provides neutral colors suitable for analytical applications.
Additional specialized themes include Ocean, Fire, Matrix, and Arctic variations, each optimized for specific visual preferences and trading contexts. All color schemes include automatic dark and light mode optimization to ensure optimal readability across different chart backgrounds and trading platforms.
The information table provides real-time display of key metrics including current trend measure value, market regime classification, signal strength, Z-score, average returns, volatility measures, filter threshold levels, and filter effectiveness percentages. This comprehensive dashboard allows traders to monitor all relevant indicator components simultaneously.
Theoretical Implications and Research Context
The Tzotchev Trend Measure addresses several theoretical limitations inherent in traditional technical analysis approaches. Unlike moving average-based systems that rely on price level comparisons, this methodology grounds trend analysis in statistical hypothesis testing, providing a more robust theoretical foundation for trading decisions.
The probabilistic interpretation of trend strength offers significant advantages over binary trend classification systems. Rather than simply indicating whether a trend exists, the measure quantifies the statistical confidence level associated with the trend assessment, allowing for more nuanced risk management and position sizing decisions.
The incorporation of volatility normalization addresses the well-documented problem of volatility clustering in financial time series, ensuring that trend strength assessments remain consistent across different market volatility regimes. This normalization is particularly important for portfolio management applications where consistent risk metrics across different assets and time periods are essential.
Practical Applications and Trading Strategy Integration
The Tzotchev Trend Measure can be effectively integrated into various trading strategies and portfolio management frameworks. For trend-following strategies, the indicator provides clear entry and exit signals with quantified confidence levels. For mean reversion strategies, extreme readings can signal potential turning points. For portfolio allocation, the regime classification system can inform dynamic asset allocation decisions.
The indicator's statistical foundation makes it particularly suitable for quantitative trading strategies where systematic, rules-based approaches are preferred over discretionary decision-making. The standardized output range facilitates easy integration with position sizing algorithms and risk management systems.
Risk management applications benefit from the indicator's ability to quantify trend strength and provide early warning signals of potential trend changes. The multi-timeframe analysis capability allows for the construction of robust risk management frameworks that consider both short-term tactical and long-term strategic market conditions.
Implementation Guide and Parameter Configuration
The practical application of the Tzotchev Trend Measure requires careful parameter configuration to optimize performance for specific trading objectives and market conditions. This section provides comprehensive guidance for parameter selection and indicator customization.
Core Calculation Parameters
The Lookback Period parameter controls the statistical window used for trend calculation and represents the most critical setting for the indicator. Default values range from 14 to 63 trading days, with shorter periods (14-21 days) providing more sensitive trend detection suitable for short-term trading strategies, while longer periods (42-63 days) offer more stable trend identification appropriate for position trading and long-term investment strategies. The parameter directly influences the statistical significance of trend measurements, with longer periods requiring stronger underlying trends to generate significant signals but providing greater reliability in trend identification.
The Price Source parameter determines which price series is used for return calculations. The default close price provides standard trend analysis, while alternative selections such as high-low midpoint ((high + low) / 2) can reduce noise in volatile markets, and volume-weighted average price (VWAP) offers superior trend identification in institutional trading environments where volume concentration matters significantly.
The Signal Threshold parameter establishes the minimum trend strength required for signal generation, with values ranging from -0.5 to 0.5. Conservative threshold settings (0.2 to 0.3) reduce false signals but may miss early trend opportunities, while aggressive settings (-0.1 to 0.1) provide earlier signal generation at the cost of increased false positive rates. The optimal threshold depends on the trader's risk tolerance and the volatility characteristics of the traded instrument.
Trading Profile Configuration
The Trading Profile system provides pre-configured parameter sets optimized for different trading approaches. The Conservative profile employs a 63-day lookback period with a 0.2 signal threshold and 0.5 noise sensitivity, designed for long-term position traders seeking high-probability trend signals with minimal false positives. The Balanced profile uses a 21-day lookback with 0.05 signal threshold and 1.0 noise sensitivity, suitable for swing traders requiring moderate signal frequency with acceptable noise levels. The Aggressive profile implements a 14-day lookback with -0.1 signal threshold and 1.5 noise sensitivity, optimized for day traders and scalpers requiring frequent signal generation despite higher noise levels.
Advanced Noise Filtering System
The noise filtering mechanism addresses the challenge of false signals during sideways market conditions through four distinct methodologies. The Adaptive filter adjusts thresholds based on current trend strength, increasing sensitivity during strong trending periods while raising thresholds during consolidation phases. The Volatility-based filter utilizes Average True Range (ATR) percentile analysis to suppress signals during abnormally volatile conditions that typically generate false trend indications.
The Trend Strength filter requires alignment between multiple momentum indicators before confirming signals, reducing the probability of false breakouts from consolidation patterns. The Multi-factor approach combines all filtering methodologies using weighted scoring to provide the most robust noise reduction while maintaining signal responsiveness during genuine trend initiations.
The Noise Sensitivity parameter controls the aggressiveness of the filtering system, with lower values (0.5-1.0) providing conservative filtering suitable for volatile instruments, while higher values (1.5-2.0) allow more signals through but may increase false positive rates during choppy market conditions.
Visual Customization and Display Options
The Color Scheme parameter offers eight professional visualization options designed for different analytical preferences and market conditions. The EdgeTools scheme provides high contrast visualization optimized for trend strength differentiation, while the Gold scheme offers warm tones suitable for commodity analysis. The Behavioral scheme uses psychological color associations to enhance decision-making speed, and the Quant scheme provides neutral colors appropriate for quantitative analysis environments.
The Ocean, Fire, Matrix, and Arctic schemes offer additional aesthetic options while maintaining analytical functionality. Each scheme includes optimized colors for both light and dark chart backgrounds, ensuring visibility across different trading platform configurations.
The Show Glow Effects parameter enhances plot visibility through multiple layered lines with progressive transparency, particularly useful when analyzing multiple timeframes simultaneously or when working with dense price data that might obscure trend signals.
Performance Optimization Settings
The Maximum Bars Back parameter controls the historical data depth available for calculations, with values ranging from 5,000 to 50,000 bars. Higher values enable analysis of longer-term trend patterns but may impact indicator loading speed on slower systems or when applied to multiple instruments simultaneously. The optimal setting depends on the intended analysis timeframe and available computational resources.
The Calculate on Every Tick parameter determines whether the indicator updates with every price change or only at bar close. Real-time calculation provides immediate signal updates suitable for scalping and day trading strategies, while bar-close calculation reduces computational overhead and eliminates signal flickering during bar formation, preferred for swing trading and position management applications.
Alert System Configuration
The Alert Frequency parameter controls notification generation, with options for all signals, bar close only, or once per bar. High-frequency trading strategies benefit from all signals mode, while position traders typically prefer bar close alerts to avoid premature position entries based on intrabar fluctuations.
The alert system generates four distinct notification types: Long Signal alerts when the trend measure crosses above the positive signal threshold, Short Signal alerts for negative threshold crossings, Bull Regime alerts when entering strong bullish conditions, and Bear Regime alerts for strong bearish regime identification.
Table Display and Information Management
The information table provides real-time statistical metrics including current trend value, regime classification, signal status, and filter effectiveness measurements. The table position can be customized for optimal screen real estate utilization, and individual metrics can be toggled based on analytical requirements.
The Language parameter supports both English and German display options for international users, while maintaining consistent calculation methodology regardless of display language selection.
Risk Management Integration
Effective risk management integration requires coordination between the trend measure signals and position sizing algorithms. Strong trend readings (above 0.5 or below -0.5) support larger position sizes due to higher probability of trend continuation, while neutral readings (between -0.2 and 0.2) suggest reduced position sizes or range-trading strategies.
The regime classification system provides additional risk management context, with Strong Bull and Strong Bear regimes supporting trend-following strategies, while Neutral regimes indicate potential for mean reversion approaches. The filter effectiveness metric helps traders assess current market conditions and adjust strategy parameters accordingly.
Timeframe Considerations and Multi-Timeframe Analysis
The indicator's effectiveness varies across different timeframes, with higher timeframes (daily, weekly) providing more reliable trend identification but slower signal generation, while lower timeframes (hourly, 15-minute) offer faster signals with increased noise levels. Multi-timeframe analysis combining trend alignment across multiple periods significantly improves signal quality and reduces false positive rates.
For optimal results, traders should consider trend alignment between the primary trading timeframe and at least one higher timeframe before entering positions. Divergences between timeframes often signal potential trend reversals or consolidation periods requiring strategy adjustment.
Conclusion
The Tzotchev Trend Measure represents a significant advancement in technical analysis methodology, combining rigorous statistical foundations with practical trading applications. Its implementation of the J.P. Morgan research methodology provides institutional-quality trend analysis capabilities previously available only to sophisticated quantitative trading firms.
The comprehensive parameter configuration options enable customization for diverse trading styles and market conditions, while the advanced noise filtering and regime detection capabilities provide superior signal quality compared to traditional trend-following indicators. Proper parameter selection and understanding of the indicator's statistical foundation are essential for achieving optimal trading results and effective risk management.
References
Abramowitz, M. and Stegun, I.A. (1964). Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. Washington: National Bureau of Standards.
Ang, A. and Bekaert, G. (2002). Regime Switches in Interest Rates. Journal of Business and Economic Statistics, 20(2), 163-182.
Asness, C.S., Moskowitz, T.J., and Pedersen, L.H. (2013). Value and Momentum Everywhere. Journal of Finance, 68(3), 929-985.
Bollinger, J. (2001). Bollinger on Bollinger Bands. New York: McGraw-Hill.
Fama, E.F. and French, K.R. (1988). Permanent and Temporary Components of Stock Prices. Journal of Political Economy, 96(2), 246-273.
Hurst, B., Ooi, Y.H., and Pedersen, L.H. (2013). Demystifying Managed Futures. Journal of Investment Management, 11(3), 42-58.
Jegadeesh, N. and Titman, S. (2001). Profitability of Momentum Strategies: An Evaluation of Alternative Explanations. Journal of Finance, 56(2), 699-720.
Kaufman, P.J. (2013). Trading Systems and Methods. 5th Edition. Hoboken: John Wiley & Sons.
Moskowitz, T.J., Ooi, Y.H., and Pedersen, L.H. (2012). Time Series Momentum. Journal of Financial Economics, 104(2), 228-250.
Tzotchev, D., Lo, A.W., and Hasanhodzic, J. (2015). Designing robust trend-following system: Behind the scenes of trend-following. J.P. Morgan Quantitative Research, Asset Management Division.
Savitzky-Golay Hampel Filter | AlphaNattSavitzky-Golay Hampel Filter | AlphaNatt
A revolutionary indicator combining NASA's satellite data processing algorithms with robust statistical outlier detection to create the most scientifically advanced trend filter available on TradingView.
"This is the same mathematics that processes signals from the Hubble Space Telescope and analyzes data from the Large Hadron Collider - now applied to financial markets."
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 SCIENTIFIC PEDIGREE
Savitzky-Golay Filter Applications:
NASA: Satellite telemetry and space probe data processing
CERN: Particle physics data analysis at the LHC
Pharmaceutical: Chromatography and spectroscopy analysis
Astronomy: Processing signals from radio telescopes
Medical: ECG and EEG signal processing
Hampel Filter Usage:
Aerospace: Cleaning sensor data from aircraft and spacecraft
Manufacturing: Quality control in precision engineering
Seismology: Earthquake detection and analysis
Robotics: Sensor fusion and noise reduction
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🧬 THE MATHEMATICS
1. Savitzky-Golay Filter
The SG filter performs local polynomial regression on data points:
Fits a polynomial of degree n to a sliding window of data
Evaluates the polynomial at the center point
Preserves higher moments (peaks, valleys) unlike moving averages
Maintains derivative information for true momentum analysis
Originally published in Analytical Chemistry (1964)
Mathematical Properties:
Optimal smoothing in the least-squares sense
Preserves statistical moments up to polynomial order
Exact derivative calculation without additional lag
Superior frequency response vs traditional filters
2. Hampel Filter
A robust outlier detector based on Median Absolute Deviation (MAD):
Identifies outliers using robust statistics
Replaces spurious values with polynomial-fitted estimates
Resistant to up to 50% contaminated data
MAD is 1.4826 times more robust than standard deviation
Outlier Detection Formula:
|x - median| > k × 1.4826 × MAD
Where k is the threshold parameter (typically 3 for 99.7% confidence)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💎 WHY THIS IS SUPERIOR
vs Moving Averages:
Preserves peaks and valleys (critical for catching tops/bottoms)
No lag penalty for smoothness
Maintains derivative information
Polynomial fitting > simple averaging
vs Other Filters:
Outlier immunity (Hampel component)
Scientifically optimal smoothing
Preserves higher-order features
Used in billion-dollar research projects
Unique Advantages:
Feature Preservation: Maintains market structure while smoothing
Spike Immunity: Ignores false breakouts and stop hunts
Derivative Accuracy: True momentum without additional indicators
Scientific Validation: 60+ years of academic research
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚙️ PARAMETER OPTIMIZATION
1. Polynomial Order (2-5)
2 (Quadratic): Maximum smoothing, gentle curves
3 (Cubic): Balanced smoothing and responsiveness (recommended)
4-5 (Higher): More responsive, preserves more features
2. Window Size (7-51)
Must be odd number
Larger = smoother but more lag
Formula: 2×(desired smoothing period) + 1
Default 21 = analyzes 10 bars each side
3. Hampel Threshold (1.0-5.0)
1.0: Aggressive outlier removal (68% confidence)
2.0: Moderate outlier removal (95% confidence)
3.0: Conservative outlier removal (99.7% confidence) (default)
4.0+: Only extreme outliers removed
4. Final Smoothing (1-7)
Additional WMA smoothing after filtering
1 = No additional smoothing
3-5 = Recommended for most timeframes
7 = Ultra-smooth for position trading
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 TRADING STRATEGIES
Signal Recognition:
Cyan Line: Bullish trend with positive derivative
Pink Line: Bearish trend with negative derivative
Color Change: Trend reversal with polynomial confirmation
1. Trend Following Strategy
Enter when price crosses above cyan filter
Exit when filter turns pink
Use filter as dynamic stop loss
Best in trending markets
2. Mean Reversion Strategy
Enter long when price touches filter from below in uptrend
Enter short when price touches filter from above in downtrend
Exit at opposite band or filter color change
Excellent for range-bound markets
3. Derivative Strategy (Advanced)
The SG filter preserves derivative information
Acceleration = second derivative > 0
Enter on positive first derivative + positive acceleration
Exit on negative second derivative (momentum slowing)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📈 PERFORMANCE CHARACTERISTICS
Strengths:
Outlier Immunity: Ignores stop hunts and flash crashes
Feature Preservation: Catches tops/bottoms better than MAs
Smooth Output: Reduces whipsaws significantly
Scientific Basis: Not curve-fitted or optimized to markets
Considerations:
Slight lag in extreme volatility (all filters have this)
Requires odd window sizes (mathematical requirement)
More complex than simple moving averages
Best with liquid instruments
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔬 SCIENTIFIC BACKGROUND
Savitzky-Golay Publication:
"Smoothing and Differentiation of Data by Simplified Least Squares Procedures"
- Abraham Savitzky & Marcel Golay
- Analytical Chemistry, Vol. 36, No. 8, 1964
Hampel Filter Origin:
"Robust Statistics: The Approach Based on Influence Functions"
- Frank Hampel et al., 1986
- Princeton University Press
These techniques have been validated in thousands of scientific papers and are standard tools in:
NASA's Jet Propulsion Laboratory
European Space Agency
CERN (Large Hadron Collider)
MIT Lincoln Laboratory
Max Planck Institutes
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💡 ADVANCED TIPS
News Trading: Lower Hampel threshold before major events to catch spikes
Scalping: Use Order=2 for maximum smoothness, Window=11 for responsiveness
Position Trading: Increase Window to 31+ for long-term trends
Combine with Volume: Strong trends need volume confirmation
Multiple Timeframes: Use daily for trend, hourly for entry
Watch the Derivative: Filter color changes when first derivative changes sign
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ IMPORTANT NOTICES
Not financial advice - educational purposes only
Past performance does not guarantee future results
Always use proper risk management
Test settings on your specific instrument and timeframe
No indicator is perfect - part of complete trading system
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🏆 CONCLUSION
The Savitzky-Golay Hampel Filter represents the pinnacle of scientific signal processing applied to financial markets. By combining polynomial regression with robust outlier detection, traders gain access to the same mathematical tools that:
Guide spacecraft to other planets
Detect gravitational waves from black holes
Analyze particle collisions at near light-speed
Process signals from deep space
This isn't just another indicator - it's rocket science for trading .
"When NASA needs to separate signal from noise in billion-dollar missions, they use these exact algorithms. Now you can too."
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Developed by AlphaNatt
Version: 1.0
Release: 2025
Pine Script: v6
"Where Space Technology Meets Market Analysis"
Not financial advice. Always DYOR
Market Opening Time### TradingView Pine Script "Market Opening Time" Explanation
This Pine Script (`@version=5`) is an indicator that visually highlights market trading sessions (Sydney, London, New York, etc.) by changing the chart's background color. It adjusts for U.S. and Australian Daylight Saving Time (DST).
---
#### **1. Overview**
- **Purpose**: Changes the chart's background color based on UTC time zones to highlight market sessions.
- **Features**:
- Automatically adjusts for U.S. DST (2nd Sunday of March to 1st Sunday of November) and Australian DST (1st Sunday of October to 1st Sunday of April).
- Assigns colors to four time zones (00:00, 06:30, 14:00, 21:00).
- **Use Case**: Helps forex/stock traders identify active market sessions.
---
#### **2. Key Logic**
- **DST Detection**:
- `f_isUSDst`: Checks U.S. DST status.
- `f_isAustraliaDst`: Checks Australian DST status.
- **Time Adjustment** (`f_getAdjustedTime`):
- U.S. DST off: Shifts `time3` (14:00) forward by 1 hour.
- Australian DST off: Shifts `time4` (21:00) forward by 1 hour.
- **Time Conversion** (`f_timeToMinutes`): Converts time (e.g., "14:00") to minutes (e.g., 840).
- **Current Time** (`f_currentTimeInMinutes`): Gets UTC time in minutes.
- **Background Color** (`f_getBackgroundColor`):
- Applies colors based on time ranges:
- 00:00–06:30: Orange (Asia)
- 06:30–14:00: Purple (London)
- 14:00–21:00: Blue (New York, DST-adjusted)
- 21:00–00:00: Red (Sydney, DST-adjusted)
- Outside ranges: Gray
---
#### **3. Settings**
- **Time Zones**:
- `time1` = 00:00 (Orange)
- `time2` = 06:30 (Purple)
- `time3` = 14:00 (Blue, DST-adjusted)
- `time4` = 21:00 (Red, DST-adjusted)
- **Colors**: Transparency set to 90 for visibility.
---
#### **4. Example**
- **September 5, 2025, 10:25 PM JST (13:25 UTC)**:
- U.S. DST active, Australian DST inactive.
- 13:25 UTC falls between `time2` (06:30) and `time3` (14:00) → Background is **Purple** (London session).
- **Effect**: Background color changes dynamically to reflect active sessions.
---
#### **5. Customization**
- Modify `time1`–`time4` or colors for different sessions.
- Add time zones for other markets (e.g., Tokyo).
---
#### **6. Notes**
- Uses UTC; ensure chart is set to UTC.
- DST rules are U.S./Australia-specific; verify for other regions.
A simple, visual tool for tracking market sessions.
----
### TradingView Pine Script「Market Opening Time」解説
このPine Script（`@version=5`）は、市場の取引時間帯（シドニー、ロンドン、ニューヨークなど）を背景色で視覚化するインジケーターです。米国とオーストラリアの夏時間（DST）を考慮し、時間帯を調整します。
---
#### **1. 概要**
- **目的**: UTC基準の時間帯に基づき、チャートの背景色を変更して市場セッションを強調。
- **機能**:
- 米国DST（3月第2日曜～11月第1日曜）とオーストラリアDST（10月第1日曜～4月第1日曜）を自動調整。
- 4つの時間帯（00:00、06:30、14:00、21:00）に色を割り当て。
- **用途**: FXや株式トレーダーが市場のアクティブ時間を把握。
---
#### **2. 主要ロジック**
- **DST判定**:
- `f_isUSDst`: 米国DSTを判定。
- `f_isAustraliaDst`: オーストラリアDSTを判定。
- **時間調整** (`f_getAdjustedTime`):
- 米国DST非適用時: `time3`（14:00）を1時間遅延。
- オーストラリアDST非適用時: `time4`（21:00）を1時間遅延。
- **時間変換** (`f_timeToMinutes`): 時間（例: "14:00"）を分単位（840）に変換。
- **現在時刻** (`f_currentTimeInMinutes`): UTCの現在時刻を分単位で取得。
- **背景色** (`f_getBackgroundColor`):
- 時間帯に応じた色を適用:
- 00:00～06:30: オレンジ（アジア）
- 06:30～14:00: 紫（ロンドン）
- 14:00～21:00: 青（ニューヨーク、DST調整）
- 21:00～00:00: 赤（シドニー、DST調整）
- 時間外: グレー
---
#### **3. 設定**
- **時間帯**:
- `time1` = 00:00（オレンジ）
- `time2` = 06:30（紫）
- `time3` = 14:00（青、DST調整）
- `time4` = 21:00（赤、DST調整）
- **色**: 透明度90で視認性確保。
---
#### **4. 使用例**
- **2025年9月5日22:25 JST（13:25 UTC）**:
- 米国DST適用、豪DST非適用。
- 13:25は`time2`（06:30）～`time3`（14:00）の間 → 背景色は**紫**（ロンドン）。
- **効果**: 時間帯に応じて背景色が変化し、市場セッションを直感的に把握。
---
#### **5. カスタマイズ**
- 時間帯（`time1`～`time4`）や色を変更可能。
- 他の市場（例: 東京）に対応する時間帯を追加可能。
---
#### **6. 注意点**
- UTC基準のため、チャート設定をUTCに。
- DSTルールは米国・オーストラリア準拠。他地域では要確認。
シンプルで視覚的な市場時間インジケーターです。
Live Market - Performance MonitorLive Market — Performance Monitor
Study material (no code) — step-by-step training guide for learners
________________________________________
1) What this tool is — short overview
This indicator is a live market performance monitor designed for learning. It scans price, volume and volatility, detects order blocks and trendline events, applies filters (volume & ATR), generates trade signals (BUY/SELL), creates simple TP/SL trade management, and renders a compact dashboard summarizing market state, risk and performance metrics.
Use it to learn how multi-factor signals are constructed, how Greeks-style sensitivity is replaced by volatility/ATR reasoning, and how a live dashboard helps monitor trade quality.
________________________________________
2) Quick start — how a learner uses it (step-by-step)
1. Add the indicator to a chart (any ticker / timeframe).
2. Open inputs and review the main groups: Order Block, Trendline, Signal Filters, Display.
3. Start with defaults (OB periods ≈ 7, ATR multiplier 0.5, volume threshold 1.2) and observe the dashboard on the last bar.
4. Walk the chart back in time (use the last-bar update behavior) and watch how signals, order blocks, trendlines, and the performance counters change.
5. Run the hands-on labs below to build intuition.
________________________________________
3) Main configurable inputs (what you can tweak)
• Order Block Relevant Periods (default ~7): number of consecutive candles used to define an order block.
• Min. Percent Move for Valid OB (threshold): minimum percent move required for a valid order block.
• Number of OB Channels: how many past order block lines to keep visible.
• Trendline Period (tl_period): pivot lookback for detecting highs/lows used to draw trendlines.
• Use Wicks for Trendlines: whether pivot uses wicks or body.
• Extension Bars: how far trendlines are projected forward.
• Use Volume Filter + Volume Threshold Multiplier (e.g., 1.2): requires volume to be greater than multiplier × average volume.
• Use ATR Filter + ATR Multiplier: require bar range > ATR × multiplier to filter noise.
• Show Targets / Table settings / Colors for visualization.
________________________________________
4) Core building blocks — what the script computes (plain language)
Price & trend:
• Spot / LTP: current close price.
• EMA 9 / 21 / 50: fast, medium, slow moving averages to define short/medium trend.
o trend_bullish: EMA9 > EMA21 > EMA50
o trend_bearish: EMA9 < EMA21 < EMA50
o trend_neutral: otherwise
Volatility & noise:
• ATR (14): average true range used for dynamic target and filter sizing.
• dynamic_zone = ATR × atr_multiplier: minimum bar range required for meaningful move.
• Annualized volatility: stdev of price changes × sqrt(252) × 100 — used to classify volatility (HIGH/MEDIUM/LOW).
Momentum & oscillators:
• RSI 14: overbought/oversold indicator (thresholds 70/30).
• MACD: EMA(12)-EMA(26) and a 9-period signal line; histogram used for momentum direction and strength.
• Momentum (ta.mom 10): raw momentum over 10 bars.
Mean reversion / band context:
• Bollinger Bands (20, 2σ): upper, mid, lower.
o price_position measures where price sits inside the band range as 0–100.
Volume metrics:
• avg_volume = SMA(volume, 20) and volume_spike = volume > avg_volume × volume_threshold
o volume_ratio = volume / avg_volume
Support & Resistance:
• support_level = lowest low over 20 bars
• resistance_level = highest high over 20 bars
• current_position = percent of price between support & resistance (0–100)
________________________________________
5) Order Block detection — concept & logic
What it tries to find: a bar (the base) followed by N candles in the opposite direction (a classical order block setup), with a minimum % move to qualify. The script records the high/low of the base candle, averages them, and plots those levels as OB channels.
How learners should think about it (conceptual):
1. An order block is a signature area where institutions (theory) left liquidity — often seen as a large bar followed by a sequence of directional candles.
2. This indicator uses a configurable number of subsequent candles to confirm that the pattern exists.
3. When found, it stores and displays the base candle’s high/low area so students can see how price later reacts to those zones.
Implementation note for learners: the tool keeps a limited history of OB lines (ob_channels). When new OBs exceed the count, the oldest lines are removed — good practice to avoid clutter.
________________________________________
6) Trendline detection — idea & interpretation
• The script finds pivot highs and lows using a symmetric lookback (tl_period and half that as right/left).
• It then computes a trendline slope from successive pivots and projects the line forward (extension_bars).
• Break detection: Resistance break = close crosses above the projected resistance line; Support break = close crosses below projected support.
Learning tip: trendlines here are computed from pivot points and time. Watch how changing tl_period (bigger = smoother, fewer pivots) alters the trendlines and break signals.
________________________________________
7) Signal generation & filters — step-by-step
1. Primary triggers:
o Bullish trigger: order block bullish OR resistance trendline break.
o Bearish trigger: bearish order block OR support trendline break.
2. Filters applied (both must pass unless disabled):
o Volume filter: volume must be > avg_volume × volume_threshold.
o ATR filter: bar range (high-low) must exceed ATR × atr_multiplier.
o Not in an existing trade: new trades only start if trade_active is false.
3. Trend confirmation:
o The primary trigger is only confirmed if trend is bullish/neutral for buys or bearish/neutral for sells (EMA alignment).
4. Result:
o When confirmed, a long or short trade is activated with TP/SL calculated from ATR multiples.
________________________________________
8) Trade management — what the tool does after a signal
• Entry management: the script marks a trade as trade_active and sets long_trade or short_trade flags.
• TP & SL rules:
o Long: TP = high + 2×ATR ; SL = low − 1×ATR
o Short: TP = low − 2×ATR ; SL = high + 1×ATR
• Monitoring & exit:
o A trade closes when price reaches TP or SL.
o When TP/SL hit, the indicator updates win_count and total_pnl using a very simple calculation (difference between TP/SL and previous close).
o Visual lines/labels are drawn for TP and updated as the trade runs.
Important learner notes:
• The script does not store a true entry price (it uses close in its P&L math), so PnL is an approximation — treat this as a learning proxy, not a position accounting system.
• There’s no sizing, slippage, or fee accounted — students must manually factor these when translating to real trades.
• This indicator is not a backtesting strategy; strategy.* functions would be needed for rigorous backtest results.
________________________________________
9) Signal strength & helper utilities
• Signal strength is a composite score (0–100) made up of four signals worth 25 points each:
1. RSI extreme (overbought/oversold) → 25
2. Volume spike → 25
3. MACD histogram magnitude increasing → 25
4. Trend existence (bull or bear) → 25
• Progress bars (text glyphs) are used to visually show RSI and signal strength on the table.
Learning point: composite scoring is a way to combine orthogonal signals — study how changing weights changes outcomes.
________________________________________
10) Dashboard — how to read each section (walkthrough)
The dashboard is split into sections; here's how to interpret them:
1. Market Overview
o LTP / Change%: immediate price & daily % change.
2. RSI & MACD
o RSI value plus progress bar (overbought 70 / oversold 30).
o MACD histogram sign indicates bullish/bearish momentum.
3. Volume Analysis
o Volume ratio (current / average) and whether there’s a spike.
4. Order Block Status
o Buy OB / Sell OB: the average base price of detected order blocks or “No Signal.”
5. Signal Status
o 🔼 BUY or 🔽 SELL if confirmed, or ⚪ WAIT.
o No-trade vs Active indicator summarizing market readiness.
6. Trend Analysis
o Trend direction (from EMAs), market sentiment score (composite), volatility level and band/position metrics.
7. Performance
o Win Rate = wins / signals (percentage)
o Total PnL = cumulative PnL (approximate)
o Bull / Bear Volume = accumulated volumes attributable to signals
8. Support & Resistance
o 20-bar highest/lowest — use as nearby reference points.
9. Risk & R:R
o Risk Level from ATR/price as a percent.
o R:R Ratio computed from TP/SL if a trade is active.
10. Signal Strength & Active Trade Status
• Numeric strength + progress bar and whether a trade is currently active with TP/SL display.
________________________________________
11) Alerts — what will notify you
The indicator includes pre-built alert triggers for:
• Bullish confirmed signal
• Bearish confirmed signal
• TP hit (long/short)
• SL hit (long/short)
• No-trade zone
• High signal strength (score > 75%)
Training use: enable alerts during a replay session to be notified when the indicator would have signalled.
________________________________________
12) Labs — hands-on exercises for learners (step-by-step)
Lab A — Order Block recognition
1. Pick a 15–30 minute timeframe on a liquid ticker.
2. Use default OB periods (7). Mark each time the dashboard shows a Buy/Sell OB.
3. Manually inspect the chart at the base candle and the following sequence — draw the OB zone by hand and watch later price reactions to it.
4. Repeat with OB periods 5 and 10; note stability vs noise.
Lab B — Trendline break confirmation
1. Increase trendline period (e.g., 20), watch trendlines form from pivots.
2. When a resistance break is flagged, compare with MACD & volume: was momentum aligned?
3. Note false breaks vs confirmed moves — change extension_bars to see projection effects.
Lab C — Filter sensitivity
1. Toggle Use Volume Filter off, and record the number and quality of signals in a 2-day window.
2. Re-enable volume filter and change threshold from 1.2 → 1.6; note how many low-quality signals are filtered out.
Lab D — Trade management simulation
1. For each signalled trade, record the time, close entry approximation, TP, SL, and eventual hit/miss.
2. Compute actual PnL if you had entered at the open of the next bar to compare with the script’s PnL math.
3. Tabulate win rate and average R:R.
Lab E — Performance review & improvement
1. Build a spreadsheet of signals over 30–90 periods with columns: Date, Signal type, Entry price (real), TP, SL, Exit, PnL, Notes.
2. Analyze which filters or indicators contributed most to winners vs losers and adjust weights.
________________________________________
13) Common pitfalls, assumptions & implementation notes (things to watch)
• P&L simplification: total_pnl uses close as a proxy entry price. Real entry/exit prices and slippage are not recorded — so PnL is approximate.
• No position sizing or money management: the script doesn’t compute position size from equity or risk percent.
• Signal confirmation logic: composite "signal_strength" is a simple 4×25 point scheme — explore different weights or additional signals.
• Order block detection nuance: the script defines the base candle and checks the subsequent sequence. Be sure to verify whether the intended candle direction (base being bullish vs bearish) aligns with academic/your trading definition — read the code carefully and test.
• Trendline slope over time: slope is computed using timestamps; small differences may make lines sensitive on very short timeframes — using bar_index differences is usually more stable.
• Not a true backtester: to evaluate performance statistically you must transform the logic into a strategy script that places hypothetical orders and records exact entry/exit prices.
________________________________________
14) Suggested improvements for advanced learners
• Record true entry price & timestamp for accurate PnL.
• Add position sizing: risk % per trade using SL distance and account size.
• Convert to strategy. (Pine Strategy)* to run formal backtests with equity curves, drawdowns, and metrics (Sharpe, Sortino).
• Log trades to an external spreadsheet (via alerts + webhook) for offline analysis.
• Add statistics: average win/loss, expectancy, max drawdown.
• Add additional filters: news time blackout, market session filters, multi-timeframe confirmation.
• Improve OB detection: combine wick/body, volume spike at base bar, and liquidity sweep detection.
________________________________________
15) Glossary — quick definitions
• ATR (Average True Range): measure of typical range; used to size targets and stops.
• EMA (Exponential Moving Average): trend smoothing giving more weight to recent prices.
• RSI (Relative Strength Index): momentum oscillator; >70 overbought, <30 oversold.
• MACD: momentum oscillator using difference of two EMAs.
• Bollinger Bands: volatility bands around SMA.
• Order Block: a base candle area with subsequent confirmation candles; a zone of institutional interest (learning model).
• Pivot High/Low: local turning point defined by candles on both sides.
• Signal Strength: combined score from multiple indicators.
• Win Rate: proportion of signals that hit TP vs total signals.
• R:R (Risk:Reward): ratio of potential reward (TP distance) to risk (entry to SL).
________________________________________
16) Limitations & assumptions (be explicit)
• This is an indicator for learning — not a trading robot or broker connection.
• No slippage, fees, commissions or tie-in to real orders are considered.
• The logic is heuristic (rule-of-thumb), not a guarantee of performance.
• Results are sensitive to timeframe, market liquidity, and parameter choices.
________________________________________
17) Practical classroom / study plan (4 sessions)
• Session 1 — Foundations: Understand EMAs, ATR, RSI, MACD, Bollinger Bands. Run the indicator and watch how these numbers change on a single day.
• Session 2 — Zones & Filters: Study order blocks and trendlines. Test volume & ATR filters and note changes in false signals.
• Session 3 — Simulated trading: Manually track 20 signals, compute real PnL and compare to the dashboard.
• Session 4 — Improvement plan: Propose changes (e.g., better PnL accounting, alternative OB rule) and test their impact.
________________________________________
18) Quick reference checklist for each signal
1. Was an order block or trendline break detected? (primary trigger)
2. Did volume meet threshold? (filter)
3. Did ATR filter (bar size) show a real move? (filter)
4. Was trend aligned (EMA 9/21/50)? (confirmation)
5. Signal confirmed → mark entry approximation, TP, SL.
6. Monitor dashboard (Signal Strength, Volatility, No-trade zone, R:R).
7. After exit, log real entry/exit, compute actual PnL, update spreadsheet.
________________________________________
19) Educational caveat & final note
This tool is built for training and analysis: it helps you see how common technical building blocks combine into trade ideas, but it is not a trading recommendation. Use it to develop judgment, to test hypotheses, and to design robust systems with proper backtesting and risk control before risking capital.
________________________________________
20) Disclaimer (must include)
Training & Educational Only — This material and the indicator are provided for educational purposes only. Nothing here is investment advice or a solicitation to buy or sell financial instruments. Past simulated or historical performance does not predict future results. Always perform full backtesting and risk management, and consider seeking advice from a qualified financial professional before trading with real capital.
________________________________________
Natal & Transit Planetary Aspect Table📐 Natal & Transit Planetary Aspect Table
This open-source TradingView indicator displays a customizable table of astrological aspects between natal (first trade or custom date) planetary positions and current/live transits. Built in Pine Script v6, it leverages the AstroLib library for accurate geocentric or heliocentric longitude calculations, supporting a range of financial assets and historical events. Ideal for astro-finance enthusiasts, it highlights major and minor aspects with orbs, applying/separating status, and color-coded visuals. Supports 10 planetary bodies in geocentric mode (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto) or 11 in heliocentric mode (adds Earth).
Why Use This Indicator?
Astrology offers a unique lens for market analysis by examining planetary alignments relative to an asset's "birth" date (e.g., first trade), potentially revealing cycles, trends, and timing insights that complement technical and fundamental strategies. This tool empowers traders to integrate astro-finance principles, visualizing cosmic influences that may correlate with price movements, reversals, or volatility—backed by historical presets and customizable options for personalized research.
Key Features:
- 23 preset natal dates for assets like BTC, ETH, NYSE, and more (e.g., BTC genesis block on 2009-01-03), with credits to Susan Abbott Gidel for most of the first trade dates from her book " Trading In Sync With Commodities: Introducing Astrology To Your Technical Toolbox ."
- Manual natal and transit timestamp inputs for flexibility.
- Supports geocentric (default) or heliocentric views (displayed as 𝒢 or ℋ in the table), with adjustable observer location (latitude, longitude, timezone).
- Configurable aspects: Conjunction (☌), Opposition (☍), Trine (△), Square (□), Sextile (⚹), and minors like Semi-Sextile (⚺), Quincunx (⚻), etc., with user-defined orbs and colors.
- Applying (a) or separating (s) status is determined by comparing the orb on the current bar to the previous one—if decreasing, applying; if increasing, separating. This simplified approach may differ from traditional astrological methods that consider planetary speeds, directions (direct/retrograde), and which body is faster/slower.
- Table displays planet symbols or names, degrees/signs with tooltips showing exact longitude (e.g., hovering over a planet symbol reveals its precise degree), and aspect symbols/tags (e.g., ⚹a for applying sextile).
- Tooltip on the dates cell to view the exact transit and natal dates for easy tracking.
- Live mode updates with chart timeframe; test mode allows the user to move the transit date historically or to the future via a custom timestamp.
- Customizable table position, text size, colors, and visibility.
How to Use:
1. Add the indicator to your TradingView chart.
2. Select a preset or manual natal date in settings.
3. Choose live transits or test mode with a custom timestamp.
4. Enable/disable aspects and adjust orbs/colors as needed.
5. Hover over cells for detailed tooltips (e.g., exact orb and applying/separating status).
Powered by @BarefootJoey AstroLib for ephemeris data. For best accuracy, verify positions against external sources.
