Quarterly Theory ICT 03 [TradingFinder] Precision Swing Points🔵 Introduction
Precision Swing Point (PSP) is a divergence pattern in the closing of candles between two correlated assets, which can indicate a potential trend reversal. This structure appears at market turning points and highlights discrepancies between the price behavior of two related assets.
PSP typically forms in key timeframes such as 5-minute, 15-minute, and 90-minute charts, and is often used in combination with Smart Money Concepts (SMT) to confirm trade entries.
PSP is categorized into Bearish PSP and Bullish PSP :
Bearish PSP : Occurs when an asset breaks its previous high, and its middle candle closes bullish, while the correlated asset closes bearish at the same level. This divergence signals weakness in the uptrend and a potential price reversal downward.
Bullish PSP : Occurs when an asset breaks its previous low, and its middle candle closes bearish, while the correlated asset closes bullish at the same level. This suggests weakness in the downtrend and a potential price increase.
🟣 Trading Strategies Using Precision Swing Point (PSP)
PSP can be integrated into various trading strategies to improve entry accuracy and filter out false signals. One common method is combining PSP with SMT (divergence between correlated assets), where traders identify divergence and enter a trade only after PSP confirms the move.
Additionally, PSP can act as a liquidity gap, meaning that price tends to react to the wick of the PSP candle, making it a favorable entry point with a tight stop-loss and high risk-to-reward ratio. Furthermore, PSP combined with Order Blocks and Fair Value Gaps in higher timeframes allows traders to identify stronger reversal zones.
In lower timeframes, such as 5-minute or 15-minute charts, PSP can serve as a confirmation for more precise entries in the direction of the higher timeframe trend. This is particularly useful in scalping and intraday trading, helping traders execute smarter entries while minimizing unnecessary stop-outs.
🔵 How to Use
PSP is a trading pattern based on divergence in candle closures between two correlated assets. This divergence signals a difference in trend strength and can be used to identify precise market turning points. PSP is divided into Bullish PSP and Bearish PSP, each applicable for long and short trades.
🟣 Bullish PSP
A Bullish PSP forms when, at a market turning point, the middle candle of one asset closes bearish while the correlated asset closes bullish. This discrepancy indicates weakness in the downtrend and a potential price reversal upward.
Traders can use this as a signal for long (buy) trades. The best approach is to wait for price to return to the wick of the PSP candle, as this area typically acts as a liquidity level.
f PSP forms within an Order Block or Fair Value Gap in a higher timeframe, its reliability increases, allowing for entries with tight stop-loss and optimal risk-to-reward ratios.
🟣 Bearish PSP
A Bearish PSP forms when, at a market turning point, the middle candle of one asset closes bullish while the correlated asset closes bearish. This indicates weakness in the uptrend and a potential price decline.
Traders use this pattern to enter short (sell) trades. The best entry occurs when price retests the wick of the PSP candle, as this level often acts as a resistance zone, pushing price lower.
If PSP aligns with a significant liquidity area or Order Block in a higher timeframe, traders can enter with greater confidence and place their stop-loss just above the PSP wick.
Overall, PSP is a highly effective tool for filtering false signals and improving trade entry precision. Combining PSP with SMT, Order Blocks, and Fair Value Gaps across multiple timeframes allows traders to execute higher-accuracy trades with lower risk.
🔵 Settings
Mode :
2 Symbol : Identifies PSP and PCP between two correlated assets.
3 Symbol : Compares three assets to detect more complex divergences and stronger confirmation signals.
Second Symbol : The second asset used in PSP and correlation calculations.
Third Symbol : Used in three-symbol mode for deeper PSP and PCP analysis.
Filter Precision X Point : Enables or disables filtering for more precise PSP and PCP detection. This filter only identifies PSP and PCP when the base asset's candle qualifies as a Pin Bar.
Trend Effect : By changing the Trend Effect status to "Off," all Pin bars, whether bullish or bearish, are displayed regardless of the current market trend. If the status remains "On," only Pin bars in the direction of the main market trend are shown.
Bullish Pin Bar Setting : Using the "Ratio Lower Shadow to Body" and "Ratio Lower Shadow to Higher Shadow" settings, you can customize your bullish Pin bar candles. Larger numbers impose stricter conditions for identifying bullish Pin bars.
Bearish Pin Bar Setting : Using the "Ratio Higher Shadow to Body" and "Ratio Higher Shadow to Lower Shadow" settings, you can customize your bearish Pin bar candles. Larger numbers impose stricter conditions for identifying bearish Pin bars.
🔵 Conclusion
Precision Swing Point (PSP) is a powerful analytical tool in Smart Money trading strategies, helping traders identify precise market turning points by detecting divergences in candle closures between correlated assets. PSP is classified into Bullish PSP and Bearish PSP, each playing a crucial role in detecting trend weaknesses and determining optimal entry points for long and short trades.
Using the PSP wick as a key liquidity level, integrating it with SMT, Order Blocks, and Fair Value Gaps, and analyzing higher timeframes are effective techniques to enhance trade entries. Ultimately, PSP serves as a complementary tool for improving entry accuracy and reducing unnecessary stop-outs, making it a valuable addition to Smart Money trading methodologies.
チャートパターン
BEING RSI Divergence Buy/Sell Signals//@version=5
indicator("RSI Divergence Buy/Sell Signals", overlay=true)
// RSI Calculation
length = 14
rsiSource = close
rsi = ta.rsi(rsiSource, length)
// Overbought and Oversold Levels
overbought = 70
oversold = 30
// Price and RSI Pivot Points
pivotLeft = 5
pivotRight = 5
priceHighPivot = ta.pivothigh(high, pivotLeft, pivotRight)
priceLowPivot = ta.pivotlow(low, pivotLeft, pivotRight)
rsiHighPivot = ta.pivothigh(rsi, pivotLeft, pivotRight)
rsiLowPivot = ta.pivotlow(rsi, pivotLeft, pivotRight)
// Bearish Divergence (Price Higher High but RSI Lower High)
bearishDivergence = na(priceHighPivot) ? false : priceHighPivot > ta.valuewhen(priceHighPivot, priceHighPivot, 1) and rsiHighPivot < ta.valuewhen(rsiHighPivot, rsiHighPivot, 1) and rsiHighPivot > overbought
// Bullish Divergence (Price Lower Low but RSI Higher Low)
bullishDivergence = na(priceLowPivot) ? false : priceLowPivot < ta.valuewhen(priceLowPivot, priceLowPivot, 1) and rsiLowPivot > ta.valuewhen(rsiLowPivot, rsiLowPivot, 1) and rsiLowPivot < oversold
// Plot Buy/Sell Signals
plotshape(bullishDivergence, location=location.belowbar, color=color.green, style=shape.labelup, title="Buy Signal", size=size.small)
plotshape(bearishDivergence, location=location.abovebar, color=color.red, style=shape.labeldown, title="Sell Signal", size=size.small)
// Background Highlighting for Overbought/Oversold
bgcolor(rsi > overbought ? color.red : rsi < oversold ? color.green : na, transp=90)
// Display RSI on Chart
hline(overbought, "Overbought", color=color.red)
hline(oversold, "Oversold", color=color.green) OWNER; BY SOHAN SOLANKI
SemaforI simply added ADR and Daily Open Line to DevLucem's Semafor script. Thank you, DevLucem for your work on producing this semafor indicator in the first place. It was exactly what I was looking for.
Volume-Price Divergence RSIUnderstanding the Display
Once added, you'll see a new panel below your price chart with:
Purple Line: This is the RSI (Relative Strength Index)
Red Dashed Line: The overbought threshold (default: 70)
Green Dashed Line: The oversold threshold (default: 30)
Blue Columns: Volume histogram
Dark Blue Line: Volume moving average
Trading Signals
Look for these markers on the indicator panel:
Green Triangle (↑): Buy signal - appears when there's a bullish divergence AND RSI conditions are met (oversold and rising)
Red Triangle (↓): Sell signal - appears when there's a bearish divergence AND RSI conditions are met (overbought and falling)
Lime Diamond (◆): Bullish divergence without RSI confirmation
Orange Diamond (◆): Bearish divergence without RSI confirmation
What These Signals Mean
Buy Signal (Green Triangle):
Price is making lower lows BUT volume is making higher lows
RSI is in oversold territory (below 30) and starting to rise
This suggests potential upward reversal
Sell Signal (Red Triangle):
Price is making higher highs BUT volume is making lower highs
RSI is in overbought territory (above 70) and starting to fall
This suggests potential downward reversal
Customizing the Indicator
To adjust settings:
Right-click on the indicator
Select "Settings"
In the "Inputs" tab, you can modify:
RSI Period (default: 14)
Volume MA Period (default: 20)
Lookback Period for finding pivot points (default: 10)
RSI Overbought level (default: 70)
RSI Oversold level (default: 30)
Setting Alerts
To get notified when a signal appears:
Right-click on the indicator
Select "Add Alert"
Choose the condition you want to be alerted for:
Buy Signal
Sell Signal
Bullish Divergence
Bearish Divergence
Configure notification preferences and save
Trading Strategy
This indicator is best used:
On higher timeframes (4H, Daily) for more reliable signals
As confirmation with other indicators or price action
At market extremes where divergences are more meaningful
With proper risk management (stop losses below recent swing lows for buys, above recent swing highs for sells)
Remember that no indicator is 100% accurate. This tool works by identifying situations where price movement isn't confirmed by volume, suggesting a potential reversal, especially when RSI conditions align.
Valerio Diotallevi
Trade The Fear - UltimateTrade The Fear - Ultimate (TTF - Ultimate)
Overview
"Trade The Fear - Ultimate" (TTF - Ultimate) is a powerful, all-in-one technical analysis indicator designed to help traders identify key market opportunities. Combining support/resistance break-and-retest detection, reversal and breakout signals, and RSI divergence analysis, this indicator provides a comprehensive toolkit for trading across various markets and timeframes. Built with flexibility in mind, TTF - Ultimate offers customizable settings and rich visualizations to suit different trading styles.
What It Does
1. **Break and Retest Detection**
- Identifies support and resistance levels using pivot points.
- Detects breakouts when price crosses these levels and highlights potential retests for confirmation.
- Visualizes zones with boxes and labels for easy interpretation.
2. **Reversal and Breakout Identification**
- Spots reversal patterns using weighted moving averages and volume strength.
- Flags breakout opportunities with strong momentum, supported by volume analysis.
- Tracks trend direction with a dynamic trend line and candle coloring.
3. **RSI Divergence Analysis**
- Calculates RSI and detects bullish/bearish divergences between price and momentum.
- Marks divergences with clear visual cues to signal potential reversals.
4. **Visual Tools & Alerts**
- Displays support/resistance zones, breakouts, retests, reversals, and divergences with boxes, labels, and shapes.
- Colors candles based on trend state for quick trend recognition.
- Includes customizable alerts for all key events.
How to Use It
1. **Add to Chart**
- Search for "Trade The Fear - Ultimate" in TradingView’s indicator library and add it to your chart.
- The indicator overlays directly on your price chart.
2. **Key Visual Elements**
- **Boxes**: Red for support, Green for resistance—indicate key zones.
- **Labels**: "Break" for breakouts, "Retest" or "P. Re" for retests—mark significant price actions.
- **Shapes**: Triangles for reversals/divergences, diamonds for breakouts—highlight trade setups.
- **Trend Line**: Colored line (green/red) tracks trend direction.
- **Candle Colors**: Green (bullish), Red (bearish), Yellow (breakout)—show market state.
3. **Trading Strategies**
- **Break and Retest**: Enter trades when price breaks a level (e.g., support) and retests it as new resistance (bearish) or support (bullish).
- **Reversals**: Look for triangle markers (R) with RSI divergence for potential trend changes.
- **Breakouts**: Trade diamond markers (B) with yellow candles for strong momentum moves.
- **Trend Following**: Use candle colors and the trend line to ride bullish (green) or bearish (red) trends.
4. **Customize Settings**
- Open the indicator settings to tweak:
- **Lookback Periods**: Adjust sensitivity for breaks, retests, and reversals (e.g., 20 bars default).
- **Repainting**: Choose "On" for real-time signals or "Off" for confirmed signals.
- **Colors/Styles**: Modify box outlines, label sizes, and colors to your preference.
- **Alerts**: Enable/disable specific alerts (e.g., breakouts, retests, divergences).
- **Volume Threshold**: Set the level for strong breakout confirmation (default: 2).
5. **Alerts**
- Set up alerts via TradingView’s alert menu to get notified of:
- New support/resistance levels.
- Breakouts and confirmed retests.
- Reversals, breakouts, and RSI divergences.
Best Practices
- **Timeframes**: Works on all timeframes—shorter for scalping, longer for swing trading.
- **Markets**: Applicable to stocks, forex, crypto, and more.
- **Confirmation**: Combine with other indicators (e.g., volume, moving averages) for stronger signals.
- **Risk Management**: Always use stop-losses and proper position sizing.
V Pattern TrendDESCRIPTION:
The V Pattern Trend Indicator is designed to identify and highlight V-shaped reversal patterns in price action. It detects both bullish and bearish V formations using a five-candle structure, helping traders recognize potential trend reversal points. The indicator filters out insignificant patterns by using customizable settings based on ATR, percentage, or points, ensuring that only meaningful V patterns are displayed.
CALCULATION METHOD
The user can choose how the minimum length of a V pattern is determined. The available options are:
- ATR (Average True Range) – Filters V patterns based on ATR, making the detection adaptive to market volatility.
- Percentage (%) – Considers V patterns where the absolute price difference between the V low and V high is greater than a user-defined percentage of the V high.
- Points – Uses a fixed number of points to filter valid V patterns, making it useful for assets with consistent price ranges.
ATR SETTINGS
- ATR Length – Defines the number of periods for ATR calculation.
- ATR Multiplier – Determines the minimum V length as a multiple of ATR.
PERCENTAGE THRESHOLD
- Sets a minimum percentage difference between the V high and V low for a pattern to be considered valid.
POINTS THRESHOLD
- Defines the minimum price movement (in points) required for a V pattern to be considered significant.
PATTERN VISUALIZATION
- A bullish V pattern is plotted using two upward-sloping lines, with a filled green region to highlight the formation.
- A bearish V pattern is plotted using two downward-sloping lines, with a filled red region to indicate the reversal.
- The indicator dynamically updates and marks only the most recent valid patterns.
UNDERSTANDING V PATTERNS
A V pattern is a sharp reversal formation where price moves strongly in one direction and then rapidly reverses in the opposite direction, forming a "V" shape on the chart.
BULLISH V PATTERN
- A bullish V pattern is formed when the price makes three consecutive lower lows, followed by two consecutive higher lows.
- The pattern is confirmed when the highest high of the formation is greater than the previous highs within the structure.
- This pattern suggests a potential trend reversal from bearish to bullish.
- The lowest point of the pattern represents the V low, which acts as a support level.
bull_five_candle_v = low > low and low > low and low > low and low > low
and high > math.max(high , high , high ) and high > math.max(high , high , high )
BEARISH V PATTERN
- A bearish V pattern is detected when the price makes three consecutive higher highs, followed by two consecutive lower highs.
- The pattern is confirmed when the lowest low of the formation is lower than the previous lows within the structure.
- This pattern signals a possible trend reversal from bullish to bearish.
- The highest point of the pattern represents the V high, which acts as a resistance level.
bear_five_candle_v = high < high and high < high and high < high and high < high
and low < math.min(low , low , low ) and low < math.min(low , low , low )
HOW THIS IS UNIQUE
- Advanced Filtering Mechanism – Unlike basic reversal indicators, this tool provides customizable filtering based on ATR, percentage, or points, ensuring that only significant V patterns are displayed.
- Enhanced Visual Clarity – The indicator uses color-coded fills and structured plotting to make reversal patterns easy to recognize.
- Works Across Market Conditions – Adaptable to different market environments, filtering out weak or insignificant price fluctuations.
- Multi-Timeframe Usability – Can be applied across different timeframes and asset classes, making it useful for both intraday and swing trading.
HOW TRADERS CAN USE THIS INDICATOR
- Identify potential trend reversals early based on structured price action.
- Filter out weak or insignificant reversals to focus only on strong V formations.
- Use the V pattern’s highs and lows as key support and resistance zones for trade entries and exits.
- Combine with other indicators like moving averages, trendlines, or momentum oscillators for confirmation.
PO3 + SMC + X0.45//@version=6
indicator('SMC + x0,45', shorttitle = 'SMC+x0,45', overlay = true, max_lines_count = 500)
//-----Input-------
GroupSMC = 'SMC'
showSMC = input.bool(true, 'Show SMC/Style', group = GroupSMC, inline = 'SMC/Style')
lineSMC = input.string(title = '', options = , defval = '(─)', group = GroupSMC, inline = 'SMC/Style', display = display.none)
lineStyleSMC = lineSMC == '(┈)' ? line.style_dotted : lineSMC == '(╌)' ? line.style_dashed : line.style_solid
colorSMC = input.color(color.rgb(4, 205, 255), 'Color/Width', group = GroupSMC, inline = 'Color/Width')
widthSMC = input.int(defval = 1, title = '', minval = 1, step = 1, group = GroupSMC, inline = 'Color/Width', display = display.none)
//Break
showBreak = input.bool(true, 'SMC break', group = GroupSMC, inline = 'SMC/break')
lineBreak = input.string(title = '', options = , defval = '(╌)', group = GroupSMC, inline = 'SMC/break', display = display.none)
lineStyleBreak = lineBreak == '(╌)' ? line.style_dashed : lineBreak == '(┈)' ? line.style_dotted : line.style_solid
colorBreak = input.color(#137ef8, 'Color/Width', group = GroupSMC, inline = 'SMC/Color/Width')
widthBreak = input.int(defval = 1, title = '', minval = 1, step = 1, group = GroupSMC, inline = 'SMC/Color/Width', display = display.none)
//choch
showChoch = input.bool(true, 'CHOCH', group = GroupSMC, inline = 'SMC/CHOCH')
lineChoch = input.string(title = '', options = , defval = '(─)', group = GroupSMC, inline = 'SMC/CHOCH', display = display.none)
lineStyleChoch = lineChoch == '(─)' ? line.style_solid : lineChoch == '(╌)' ? line.style_dashed : line.style_dotted
colorChoch = input.color(color.red, 'Color/Width', group = GroupSMC, inline = 'SMC/CHOCH/Color/Width')
widthChoch = input.int(defval = 1, title = '', minval = 1, step = 1, group = GroupSMC, inline = 'SMC/CHOCH/Color/Width', display = display.none)
//CHOCH
var arrayLineChoCh = array.new_line()
var arrayX_CHOCH_Up = array.new_int(1, time)
var arrayY_CHOCH_Up = array.new_float(1, close)
var arrayX_CHOCH_Dow = array.new_int(1, time)
var arrayY_CHOCH_Dow = array.new_float(1, close)
//alertChoch = 1: CHoCH/BOS up, 2: CHoCH/BOS dow
int alertChoch = 0
//Imbalance
showImbalance = input.bool(false, 'Show/Color', group = 'Imbalance', inline = 'Imbalance')
colorImbalance = input.color(color.blue, '', group = 'Imbalance', inline = 'Imbalance')
//Orderblock
showOrderblock = input.bool(true, 'Show/Color', group = 'Orderblock', inline = 'Orderblock')
colorOrderblock = input.color(color.rgb(0, 252, 63, 76), '', group = 'Orderblock', inline = 'Orderblock')
//Global
var arrayXSMC = array.new_int(5, time)
var arrayYSMC = array.new_float(5, close)
var arrayLineSMC = array.new_line()
int drawLineSMC = 0
var arrayLineBreak = array.new_line()
var arrayX_Break_Up = array.new_int(1, time)
var arrayY_Break_Up = array.new_float(1, close)
var arrayX_Break_Dow = array.new_int(1, time)
var arrayY_Break_Dow = array.new_float(1, close)
var arrayBos_Type = array.new_int(1, 0)
var bool runStart = true
var arrayBreakType = array.new_int(1, 0)
drawLineSMC := 0
bodyHigh = close > open ? close : open
bodyLow = close > open ? open : close
highPrev = high
lowPrev = low
var float highWick_Prev = high
var float lowWick_Prev = low
//alert = 1:create high, 2: create low
int alertType = 0
//sweepType = 1: sweep high, 2: sweep low
int sweepType = 0
if runStart
if open < close
array.unshift(arrayYSMC, low)
array.unshift(arrayXSMC, time)
array.unshift(arrayYSMC, high)
array.unshift(arrayXSMC, time)
array.unshift(arrayY_Break_Dow, low)
array.unshift(arrayX_Break_Dow, time)
else
array.unshift(arrayYSMC, high)
array.unshift(arrayXSMC, time)
array.unshift(arrayYSMC, low)
array.unshift(arrayXSMC, time)
array.unshift(arrayY_Break_Up, high)
array.unshift(arrayX_Break_Up, time)
runStart := false
runStart
//up trend
if array.get(arrayYSMC, 0) > array.get(arrayYSMC, 1)
//Bos / Impulse
if array.get(arrayBos_Type, 0) == 1
//brearish reversal
if low < lowPrev
if high > array.get(arrayYSMC, 0)
array.set(arrayYSMC, 0, high)
array.set(arrayXSMC, 0, time)
array.unshift(arrayYSMC, low)
array.unshift(arrayXSMC, time)
drawLineSMC := 3
drawLineSMC
else
array.unshift(arrayYSMC, low)
array.unshift(arrayXSMC, time)
drawLineSMC := 1
drawLineSMC
//create high
array.unshift(arrayBreakType, 4)
arrayBos_Type.set(0, 4)
//continue up
else
if high > array.get(arrayYSMC, 0)
array.set(arrayYSMC, 0, high)
array.set(arrayXSMC, 0, time)
drawLineSMC := 2
drawLineSMC
//No bos / xu huong tang phu correction / pullback
else //bearish reversal
if low < array.get(arrayYSMC, 1)
if high > array.get(arrayYSMC, 0)
array.set(arrayYSMC, 0, high)
array.set(arrayXSMC, 0, time)
array.unshift(arrayYSMC, low)
array.unshift(arrayXSMC, time)
drawLineSMC := 3
drawLineSMC
else
array.unshift(arrayYSMC, low)
array.unshift(arrayXSMC, time)
drawLineSMC := 1
drawLineSMC
//continue up
else
if high > array.get(arrayYSMC, 0)
array.set(arrayXSMC, 0, time)
array.set(arrayYSMC, 0, high)
drawLineSMC := 2
drawLineSMC
//end up trend
//dow trend
else //Bos / impulse
if array.get(arrayBos_Type, 0) == 2
//bullish reversal
if high > highPrev
if low < array.get(arrayYSMC, 0)
array.set(arrayYSMC, 0, low)
array.set(arrayXSMC, 0, time)
array.unshift(arrayYSMC, high)
array.unshift(arrayXSMC, time)
drawLineSMC := 3
drawLineSMC
else
array.unshift(arrayYSMC, high)
array.unshift(arrayXSMC, time)
drawLineSMC := 1
drawLineSMC
//create low
array.unshift(arrayBreakType, 3)
arrayBos_Type.set(0, 3)
//continue dow
else
if low < array.get(arrayYSMC, 0)
array.set(arrayYSMC, 0, low)
array.set(arrayXSMC, 0, time)
drawLineSMC := 2
drawLineSMC
//No bos /correction, pullback
else //bullish reversal
if high > array.get(arrayYSMC, 1)
if low < array.get(arrayYSMC, 0)
array.set(arrayXSMC, 0, time)
array.set(arrayYSMC, 0, low)
array.unshift(arrayXSMC, time)
array.unshift(arrayYSMC, high)
drawLineSMC := 3
drawLineSMC
else
array.unshift(arrayXSMC, time)
array.unshift(arrayYSMC, high)
drawLineSMC := 1
drawLineSMC
//continue dow
else
if low <= array.get(arrayYSMC, 0)
array.set(arrayXSMC, 0, time)
array.set(arrayYSMC, 0, low)
drawLineSMC := 2
drawLineSMC
//break
//get point beak dow
if barstate.isconfirmed and array.get(arrayYSMC, 0) > array.get(arrayYSMC, 1)
array.unshift(arrayX_Break_Dow, array.get(arrayXSMC, 1))
array.unshift(arrayY_Break_Dow, array.get(arrayYSMC, 1))
//bear up
if array.get(arrayYSMC, 0) > array.get(arrayYSMC, 2) and array.get(arrayY_Break_Up, 0) != array.get(arrayYSMC, 2)
array.unshift(arrayX_Break_Up, array.get(arrayXSMC, 2))
array.unshift(arrayY_Break_Up, array.get(arrayYSMC, 2))
alertType := 2
alertType
//get point break up
if barstate.isconfirmed and array.get(arrayYSMC, 0) < array.get(arrayYSMC, 1)
array.unshift(arrayX_Break_Up, array.get(arrayXSMC, 1))
array.unshift(arrayY_Break_Up, array.get(arrayYSMC, 1))
if array.get(arrayYSMC, 0) < array.get(arrayYSMC, 2) and array.get(arrayY_Break_Dow, 0) != array.get(arrayYSMC, 2)
array.unshift(arrayX_Break_Dow, array.get(arrayXSMC, 2))
array.unshift(arrayY_Break_Dow, array.get(arrayYSMC, 2))
alertType := 1
alertType
//break dow
if bodyLow < array.get(arrayY_Break_Dow, 0) and bodyLow <= lowWick_Prev and low == arrayYSMC.get(0) and array.size(arrayY_Break_Dow) > 1
float lineY_Break = 0
int lineX_Break = 0
if array.size(arrayLineBreak) > 0
lineY_Break := line.get_y1(array.get(arrayLineBreak, 0))
lineX_Break := line.get_x1(array.get(arrayLineBreak, 0))
lineX_Break
if lineY_Break != array.get(arrayY_Break_Dow, 0) or lineX_Break != array.get(arrayX_Break_Dow, 0)
if showBreak == false
colorBreak := color.rgb(0, 0, 0, 100)
colorBreak
array.unshift(arrayLineBreak, line.new(x1 = array.get(arrayX_Break_Dow, 0), y1 = array.get(arrayY_Break_Dow, 0), x2 = time, y2 = array.get(arrayY_Break_Dow, 0), color = colorBreak, xloc = xloc.bar_time, style = lineStyleBreak, width = widthBreak))
//set break type
array.unshift(arrayBreakType, 2)
//set bos type Dow
array.unshift(arrayBos_Type, 2)
//break up
if bodyHigh > array.get(arrayY_Break_Up, 0) and bodyHigh >= highWick_Prev and high == arrayYSMC.get(0) and array.size(arrayY_Break_Up) > 1
float lineY_Break = 0
int lineX_Break = 0
if array.size(arrayLineBreak) > 0
lineY_Break := line.get_y1(array.get(arrayLineBreak, 0))
lineX_Break := line.get_x1(array.get(arrayLineBreak, 0))
lineX_Break
if lineY_Break != array.get(arrayY_Break_Dow, 0) or lineX_Break != array.get(arrayX_Break_Dow, 0)
if showBreak == false
colorBreak := color.rgb(0, 0, 0, 100)
colorBreak
array.unshift(arrayLineBreak, line.new(x1 = array.get(arrayX_Break_Up, 0), y1 = array.get(arrayY_Break_Up, 0), x2 = time, y2 = array.get(arrayY_Break_Up, 0), color = colorBreak, xloc = xloc.bar_time, style = lineStyleBreak, width = widthBreak))
//set break type
array.unshift(arrayBreakType, 1)
//set bos type up
array.unshift(arrayBos_Type, 1)
//end break
//Insider bar
if high <= highPrev and low >= lowPrev
highPrev := highPrev
lowPrev := lowPrev
lowPrev
//xu huong tang
if array.get(arrayYSMC, 0) > array.get(arrayYSMC, 1)
highWick_Prev := array.get(arrayYSMC, 0)
highWick_Prev
else
lowWick_Prev := array.get(arrayYSMC, 0)
lowWick_Prev
//end
//draw line
if showSMC
if drawLineSMC == 2
if array.size(arrayLineSMC) > 0
line.set_xy2(array.get(arrayLineSMC, 0), array.get(arrayXSMC, 0), array.get(arrayYSMC, 0))
else
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), array.get(arrayXSMC, 0), array.get(arrayYSMC, 0), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
else if drawLineSMC == 1
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), array.get(arrayXSMC, 0), array.get(arrayYSMC, 0), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
else if drawLineSMC == 3
if array.size(arrayLineSMC) > 0
line.set_xy2(array.get(arrayLineSMC, 0), array.get(arrayXSMC, 1), array.get(arrayYSMC, 1))
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), array.get(arrayXSMC, 0), array.get(arrayYSMC, 0), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
else if drawLineSMC == 4
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 2), array.get(arrayYSMC, 2), array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), array.get(arrayXSMC, 0), array.get(arrayYSMC, 0), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
else if drawLineSMC == 5
if array.size(arrayLineSMC) > 0
line.set_xy2(array.get(arrayLineSMC, 0), array.get(arrayXSMC, 2), array.get(arrayYSMC, 2))
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 2), array.get(arrayYSMC, 2), array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
array.unshift(arrayLineSMC, line.new(array.get(arrayXSMC, 1), array.get(arrayYSMC, 1), array.get(arrayXSMC, 0), array.get(arrayYSMC, 0), color = colorSMC, xloc = xloc.bar_time, width = widthSMC, style = lineStyleSMC))
//end line
//Imbalance
if showImbalance
bearishImb = high < low and close < open
bullishImb = low > high and close > open
//Bullish
if bullishImb
box.new(left = bar_index , top = low, right = bar_index, bottom = high , bgcolor = colorImbalance, border_color = colorImbalance)
//Bearish
if bearishImb
box.new(left = bar_index , top = high, right = bar_index, bottom = low , bgcolor = colorImbalance, border_color = colorImbalance)
//end Imbalance
//CHOCH
if showChoch
//get choch up
if array.get(arrayYSMC, 0) < array.get(arrayYSMC, 2) and array.get(arrayYSMC, 1) > array.get(arrayYSMC, 3)
//label.new(x=bar_index, y=low, text=str.tostring(array.get(arrayYSMC, 1)) , color=color.rgb(255, 255, 255, 30), style=label.style_label_up, textalign=text.align_center, size = size.normal)
array.unshift(arrayY_CHOCH_Up, array.get(arrayYSMC, 1))
array.unshift(arrayX_CHOCH_Up, array.get(arrayXSMC, 1))
//point choch dow
if array.get(arrayYSMC, 0) > array.get(arrayYSMC, 2) and array.get(arrayYSMC, 1) < array.get(arrayYSMC, 3)
array.unshift(arrayY_CHOCH_Dow, array.get(arrayYSMC, 1))
array.unshift(arrayX_CHOCH_Dow, array.get(arrayXSMC, 1))
//xu huong tang
if array.get(arrayYSMC, 0) > array.get(arrayYSMC, 1)
float pointYChochUp = array.get(arrayY_CHOCH_Up, 0)
int pointXChochUp = array.get(arrayX_CHOCH_Up, 0)
//lấy vị trí line choch
float pointY_Line_choch = 0
int pointX_Line_choch = 0
if array.size(arrayLineChoCh) > 0
//pointY_Line_choch := line.get_y1(array.get(arrayLineChoCh,0))
pointX_Line_choch := line.get_x1(array.get(arrayLineChoCh, 0))
pointX_Line_choch
//cay nen dau tien pha qua
if bodyHigh > pointYChochUp
//label.new(x=bar_index, y=high, text= str.tostring(pointX_Line_choch) + ' ' +str.tostring(pointXChochUp) , color=color.rgb(255, 255, 255, 30), style=label.style_label_down, textalign=text.align_center, size = size.normal)
//line choch up
if pointX_Line_choch != pointXChochUp
array.unshift(arrayLineChoCh, line.new(x1 = pointXChochUp, y1 = pointYChochUp, x2 = time, y2 = pointYChochUp, color = colorChoch, xloc = xloc.bar_time, style = lineStyleChoch, width = widthChoch))
alertChoch := 1
alertChoch
//label.new(x=bar_index, y=high, text="U" , color=color.rgb(255, 255, 255, 30), style=label.style_label_down, textalign=text.align_center, size = size.tiny)
//xu huong giam
if array.get(arrayYSMC, 0) < array.get(arrayYSMC, 1)
float pointYChochDow = array.get(arrayY_CHOCH_Dow, 0)
int pointXChochDow = array.get(arrayX_CHOCH_Dow, 0)
//lấy vị trí line choch
float pointY_Line_choch = 0
int pointX_Line_choch = 0
if array.size(arrayLineChoCh) > 0
//pointY_Line_choch := line.get_y1(array.get(arrayLineChoCh,0))
pointX_Line_choch := line.get_x1(array.get(arrayLineChoCh, 0))
pointX_Line_choch
if bodyLow < pointYChochDow
//line choch dow
if pointX_Line_choch != pointXChochDow
array.unshift(arrayLineChoCh, line.new(x1 = pointXChochDow, y1 = pointYChochDow, x2 = time, y2 = pointYChochDow, color = colorChoch, xloc = xloc.bar_time, style = lineStyleChoch, width = widthChoch))
alertChoch := 2
alertChoch
//end CHOCH
//label.new(x=bar_index, y=low, text= str.tostring(arrayBreakType.get(0)) , color=color.rgb(255, 255, 255, 30), style=label.style_label_up, textalign=text.align_center, size = size.tiny)
//order block
if showOrderblock
if low > high
if low > high
box.new(left = bar_index , top = high , right = bar_index, bottom = low , bgcolor = colorOrderblock, border_color = colorOrderblock)
else
if low <= low
box.new(left = bar_index , top = high , right = bar_index, bottom = low , bgcolor = colorOrderblock, border_color = colorOrderblock)
else
box.new(left = bar_index , top = high , right = bar_index, bottom = low , bgcolor = colorOrderblock, border_color = colorOrderblock)
//OB UP
if high < low
if high < low
box.new(left = bar_index , top = low , right = bar_index, bottom = high , bgcolor = colorOrderblock, border_color = colorOrderblock)
else
if high <= high
box.new(left = bar_index , top = low , right = bar_index, bottom = high , bgcolor = colorOrderblock, border_color = colorOrderblock)
else
box.new(left = bar_index , top = low , right = bar_index, bottom = high , bgcolor = colorOrderblock, border_color = colorOrderblock)
//insider/outside bar
insideBar = high < high and low > low
outsideBar = high > high and low < low
color = insideBar ? color.rgb(211, 212, 102) : outsideBar ? color.rgb(245, 169, 6) : na
barcolor(color = color, title = 'Inside/Outside Bar')
//Alert
//create high, low
alertcondition(alertType == 1 and barstate.isconfirmed, title = 'Create High ', message = 'Create High')
alertcondition(alertType == 2 and barstate.isconfirmed, title = 'Create Low ', message = 'Create Low')
//sweep
alertcondition(sweepType == 1 and barstate.isconfirmed, title = 'Sweep High ', message = 'Sweep High')
alertcondition(sweepType == 2 and barstate.isconfirmed, title = 'Sweep Low ', message = 'Sweep Low')
//Choch
alertcondition(alertChoch == 1, title = 'CHoCH Up ', message = 'CHoCH Up')
alertcondition(alertChoch == 2, title = 'CHoCH Dow ', message = 'CHoCH Dow')
PinbarRatio = input(0.45, 'Pin bar body over whole candle')
// return 1 if bullish pinbar, -1 if bearish pinbar
isPinBar(ratio) =>
range_1 = high - low
upper = high - range_1 * ratio
lower = low + range_1 * ratio
bullish = open >= lower and close >= lower
bearish = open <= upper and close <= upper
bullish ? 1 : bearish ? -1 : 0
insidebar = high < high and low > low
pinbar = isPinBar(PinbarRatio)
plotchar(pinbar == 1, 'Pin bar', '●', color = color.new(#000000, 0), location = location.belowbar, size = size.tiny)
plotchar(pinbar == -1, 'Pin bar', '●', color = color.new(#000000, 0), location = location.abovebar, size = size.tiny)
alertcondition(insidebar, 'Pin bar', 'Pin bar')
Gold Price LevelsThis indicator identifies and displays key price levels for gold trading. It highlights important psychological and technical price points that often act as support and resistance levels.
Features
Automatically identifies and displays key price levels ending in 92, 84, 78, 55, 42, 27, and 00
Special emphasis on critical levels ending in 68, 32, and 10 with increased line width
Color-coded visualization: green for levels above current price, red for levels below
Customizable line style, width, and label visibility
Automatically adjusts to different price ranges (works with any gold price)
How to Use
This indicator helps gold traders identify potential support and resistance zones. Watch for price reactions at these levels for potential trade entries, exits, or stop placement. The thicker lines (68, 32, 10) often represent more significant price levels where stronger reactions may occur.
Perfect for both day traders and swing traders looking to optimize their gold trading strategy with key price levels.
Optimized XAU/USD - Clean SignalsOptimized XAU/USD - Clean Signals 🚀🔥
This script is designed to provide clear and optimized buy and sell signals specifically for XAU/USD (Gold) but can be applied to other assets as well. The logic is based on a combination of Zero-Lag Moving Average (ZLMA), EMA 50, EMA 200, RSI, and MACD to capture strong momentum shifts while reducing false signals.
🔹 Main Features:
✅ BUY (🔥) & SELL (💧) signals appear when price crosses above or below the ZLMA while respecting EMA 50.
✅ EMA 50 & EMA 200 plotted to indicate trend direction.
✅ RSI Divergences and MACD Confirmation improve accuracy of entries.
✅ Reduced false signals by incorporating smart filtering mechanisms.
✅ Automatic alerts for both Buy & Sell signals, making it ideal for automated trading strategies.
✅ Works on multiple timeframes (Recommended: 15m, 30m, 1H).
📌 How it Works:
• BUY SIGNAL (🔥): Triggered when the price crosses above the ZLMA while above EMA 50.
• SELL SIGNAL (💧): Triggered when the price crosses below the ZLMA while below EMA 50.
• EMA 50 & 200: Helps confirm overall trend strength.
• RSI Divergences & MACD: Adds confluence to avoid weak signals.
• No Stop Loss or Take Profit is displayed to keep the chart clean, allowing the user to manage risk separately.
⚡ Ideal For:
🔹 Swing Traders & Scalpers looking for optimized entries.
🔹 Gold (XAU/USD) traders who want a refined signal strategy.
🔹 Traders using TradingView Alerts for automation.
🎯 Try it now and optimize your trading experience! 🚀🔥
Diamond PatternDiamond Pattern Indicator
This indicator is designed to detect the Diamond Pattern, a technical formation that often signals potential trend reversals. The diamond pattern can lead to strong price movements, making it a valuable tool for traders.
Features:
✅ Automatic Detection – Identifies diamond patterns on the chart.
✅ Trend Reversal Signals – Highlights potential price direction changes.
✅ Multi-Timeframe Compatibility – Works across all timeframes.
✅ User-Friendly – Simple to use with no complex settings required.
How to Use:
1. Add the indicator to your chart.
2. Monitor for the formation of a Diamond Pattern.
3. Use the breakout direction to guide your trading decisions.
Spyder NQ💵 Estratégias USA Tech 📈
🚀Análises e tendências para maximizar seus lucros.
🤑 Renda extra em Dólares!
SMA Crossover Strategy//@version=5
indicator("SMA Crossover Strategy", overlay = true)
// SMA Indicators
sma50 = ta.sma(close, 50)
sma200 = ta.sma(close, 200)
// Buy & Sell Conditions
buyCondition = ta.crossover(sma50, sma200) // BUY Signal
sellCondition = ta.crossunder(sma50, sma200) // SELL Signal
// Plotting SMA Lines
plot(sma50, color = color.green, linewidth = 2, title = "SMA 50")
plot(sma200, color = color.red, linewidth = 2, title = "SMA 200")
// Entry & Exit Signals
plotshape(buyCondition, style = shape.labelup, location = location.belowbar, color = color.green, size = size.large, title = "BUY Signal")
plotshape(sellCondition, style = shape.labeldown, location = location.abovebar, color = color.red, size = size.large, title = "SELL Signal")
RSI Pro+ (Дивергенции, зоны, сигналы) - SHIFU_INSHIFU_IN Divergence Indicator — индикатор, выявляющий бычьи и медвежьи дивергенции на основе RSI.
🏆 Подходит для определения разворотных точек на графике.
🔹 S (SHORT) — медвежья дивергенция, когда RSI ослабевает, но цена растет → возможное падение.
🔹 L (LONG) — бычья дивергенция, когда RSI начинает расти, а цена делает новый минимум → возможный рост.
Использование:
Дивергенции полезны на высоких таймфреймах (H1, H4, D1)
Лучше комбинировать с уровнями поддержки/сопротивления.
_______________________________________________________________________
SHIFU_IN Divergence Indicator is designed to detect bullish and bearish divergences based on RSI.
🏆 Useful for spotting reversal points on the chart.
🔹 S (SHORT) — Bearish divergence, where RSI weakens while price keeps rising → potential drop.
🔹 L (LONG) — Bullish divergence, where RSI starts rising while price makes a new low → potential upward move.
How to use:
Works best on higher timeframes (H1, H4, D1)
Recommended to combine with support/resistance levels
UT Bot Alerts with Two EMAs, VWAP & Daily CPRThis for my Personal use, you can Use it for your own risk. I Not Exper On this.
Whale Candles DetectorWhale Candles Detector adalah indikator yang mengesan kehadiran whales dalam pasaran berdasarkan volum dan saiz candlestick.
🔹 Ciri utama:
✅ Mengenal pasti candle whales berdasarkan volum tinggi (≥2x volum sebelumnya) dan badan candle besar (≥2x saiz sebelumnya).
✅ Menukar warna candle whales kepada putih untuk membezakannya dengan candle biasa.
✅ Menampilkan simbol BUY (🟢) di atas candle jika whales sedang membeli.
✅ Menampilkan simbol SELL (🔴) di bawah candle jika whales sedang menjual.
📌 Kegunaan:
Mengenal pasti pergerakan besar dalam pasaran yang didorong oleh pemain besar.
Membantu pedagang memahami sama ada kenaikan atau kejatuhan harga disokong oleh volum sebenar.
Boleh digunakan dalam swing trading atau day trading untuk mencari titik masuk yang lebih tepat.
Gunakan pada timeframe yang lebih tinggi (contoh: 1H ke atas) untuk hasil lebih baik. 🚀
Grease Trap V1.0The Grease Trap V1.0 indicator is a dynamic, Fibonacci-based strategy that calculates unique moving averages to generate trading signals. Below is an overview of its main components and functionality:
How It Works
Fibonacci Grouped Averages:
Dynamic Fibonacci Sequence:
The indicator uses a custom function that dynamically builds a Fibonacci sequence. The user can set the number of Fibonacci elements for two separate calculations:
One for the Indicator Average (default: 9 elements).
One for the Base Average (default: 14 elements).
Grouped Averaging:
Using these Fibonacci numbers, the script groups historical closing prices into segments. For each group (with a length determined by a Fibonacci number), it computes an average. These individual group averages are then averaged together to produce a single dynamic average.
Plotting and Visual Cues:
Two Lines:
The indicator plots two lines on the chart:
Primary Dynamic Fibonacci Grouped Average
Base Dynamic Fibonacci Grouped Average
Color Coding:
The colors of these lines change based on their relationship to the current high price and to each other. For example, if the primary average is above the high or crosses above the base average, it might be shown in green or yellow, whereas certain conditions trigger red, signaling caution.
Crossover Dots:
When the primary average crosses above the base (a bullish signal), a green dot is plotted. Conversely, when it crosses below (a bearish signal), a red dot is displayed. These dots help visually pinpoint the moments of potential trade entry or exit.
Trading Signals and Orders:
Buy Signal:
Triggered when the primary average crosses above the base average. On a buy signal:
If in a short position, it closes that position.
Then, it enters a long position.
Sell Signal:
Triggered when the primary average crosses below the base average. On a sell signal:
If in a long position, it closes that position.
Then, it enters a short position.
Profit Target Management:
The indicator includes automated profit management:
For long positions, it sets an exit order when the price rises by a user-defined percentage (default: 2%).
For short positions, it sets an exit order when the price falls by a similar percentage.
Alerts:
The script is equipped with alert conditions. Traders receive notifications whenever a buy or sell signal is generated, helping them stay on top of potential trading opportunities.
Customization
User Inputs:
Traders can adjust:
The number of Fibonacci elements for each average calculation.
Profit target percentages for both long and short positions.
Data Length Requirement:
The script ensures it uses at least 200 data points (or the total number of available bars, whichever is greater) for a robust calculation of the averages.
In Summary
The Grease Trap V1.0 indicator combines the mathematical elegance of Fibonacci sequences with dynamic grouped averaging. It offers:
Innovative Moving Averages: Based on Fibonacci groupings of historical price data.
Clear Visual Cues: Through color-coded lines and crossover dots.
Automated Trading Actions: With built-in order management and profit targets.
Alert Notifications: So traders are instantly aware of key market signals.
This makes the Grease Trap V1.0 a comprehensive tool for both signal generation and automated strategy execution, suitable for traders looking to integrate Fibonacci principles into their trading systems.
Optimized Intraday StrategyThis is Trading Strategy for 70% winning ratio. Kindly trade at your own risk, this chart/indicator/strategy doesn't guarantee profits.
Support & Resistance + EMA + Swing SL (3 Min)### **📌 Brief Description of the Script**
This **Pine Script indicator** for TradingView displays **Support & Resistance levels, EMAs (21 & 26), and Swing High/Low-based Stop-Loss (SL) points** on a **3-minute timeframe**.
---
### **🔹 Key Features & Functionality**
1️⃣ **🟥 Support & Resistance Calculation:**
- Finds the **highest & lowest price over the last 50 candles**
- Plots **Resistance (Red) & Support (Green) levels**
2️⃣ **📈 EMA (Exponential Moving Averages):**
- **21 EMA (Blue)** and **26 EMA (Orange)** for trend direction
- Helps in identifying bullish or bearish momentum
3️⃣ **📊 Swing High & Swing Low Detection:**
- Identifies **Swing Highs (Higher than last 5 candles) as SL for Short trades**
- Identifies **Swing Lows (Lower than last 5 candles) as SL for Long trades**
- Plots these levels as **Purple (Swing High SL) & Yellow (Swing Low SL) dotted lines**
4️⃣ **📌 Labels on Swing Points:**
- **"HH SL"** is placed on Swing Highs
- **"LL SL"** is placed on Swing Lows
5️⃣ **⚡ Breakout Detection:**
- Detects if **price crosses above Resistance** (Bullish Breakout)
- Detects if **price crosses below Support** (Bearish Breakout)
- Background color changes to **Green (Bullish)** or **Red (Bearish)**
6️⃣ **🚨 Alerts for Breakouts:**
- Sends alerts when **price breaks above Resistance or below Support**
---
### **🎯 How to Use This Indicator?**
- **Trade with Trend:** Follow **EMA crossovers** and Support/Resistance levels
- **Set Stop-Loss:** Use **Swing High as SL for Shorts** & **Swing Low as SL for Longs**
- **Look for Breakouts:** Enter trades when price **crosses Resistance or Support**
This script is **ideal for scalping & intraday trading** in a **3-minute timeframe** 🚀🔥
Let me know if you need **any modifications or improvements!** 📊💹
Clean OHLC Lines | BaksPlots clean, non-repainting OHLC lines from higher timeframes onto your chart. Ideal for tracking key price levels (open, high, low, close) with precision and minimal clutter.
Core Functionality
Clean OHLC Lines = Historical Levels + Non-Repainting Logic
• Uses lookahead=on to anchor historical lines, ensuring no repainting.
• Displays OHLC lines for customizable timeframes (15min to Monthly).
• Optional candlestick boxes for visual context.
Key Features
• Multi-Timeframe OHLC:
Plot lines from 15min, 30min, 1H, 4H, Daily, Weekly, or Monthly timeframes.
• Non-Repainting Logic:
Historical lines remain static and never recalculate.
• Customizable Styles:
Adjust colors, line widths (1px-4px), and transparency for high/low/open/close lines.
• Candle Display:
Toggle candlestick boxes with bull/bear colors and adjustable borders.
• Past Lines Limit:
Control how many historical lines are displayed (1-500 bars).
User Inputs
• Timeframe:
Select the OHLC timeframe (e.g., "D" for daily).
• # Past Lines:
Limit historical lines to avoid overcrowding (default: 10).
• H/L Mode:
Draw high/low lines from the current or previous period.
• O/C Mode:
Anchor open/close lines to today’s open or yesterday’s close.
• Line Styles:
Customize colors, transparency, and styles (solid/dotted/dashed).
• Candle Display:
Toggle boxes/wicks and adjust bull/bear colors.
Important Notes
⚠️ Alignment:
• Monthly/weekly timeframes use fixed approximations (30d/7d).
• For accuracy, ensure your chart’s timeframe ≤ the selected OHLC timeframe (e.g., use 1H chart for daily lines).
⚠️ Performance:
• Reduce # Past Lines on low-end devices for smoother performance.
Risk Disclaimer
Trading involves risk. OHLC lines reflect historical price levels and do not predict future behavior. Use with other tools and risk management.
Open-Source Notice
This script is open-source under the Mozilla Public License 2.0. Modify or improve it freely, but republishing must follow TradingView’s House Rules.
📈 Happy trading!
