Log Regression Oscillator Channel [BigBeluga]
This unique overlay tool blends logarithmic trend analysis with dynamic oscillator behavior. It projects RSI, MFI, or Stochastic lines directly into a log regression channel on the price chart — offering an intuitive way to detect overbought/oversold momentum within the broader price structure.
🔵Key Features:
Logarithmic Regression Channel:
➣ Draws a trend-based channel using logarithmic regression, adapting to price growth curvature over time.
➣ Features upper, lower, and optional midline boundaries to visualize trend flow and range extremes.
Oscillator Overlay (RSI / MFI / Stochastic):
➣ Projects your chosen oscillator inside the channel using dynamic polylines.
➣ Allows switching between RSI, Money Flow Index, or Stochastic for versatile momentum insight.
Threshold-Based Scaling:
➣ The top and bottom of the channel represent traditional oscillator thresholds (e.g., RSI 70/30).
➣ Users can modify the scale in settings to customize what "overbought" or "oversold" means visually.
Signal Line Integration:
➣ Adds a yellow moving average (signal line) for smoother confirmation of oscillator turns.
➣ Helps identify divergence, momentum shifts, and fakeouts with better clarity.
Live Oscillator Readout:
➣ Displays the real-time oscillator value at the right edge of the chart.
➣ Ensures traders stay aware of current momentum levels without switching panels.
🔵Usage:
Momentum Context:
➣ When the oscillator touches the upper regression band, it may signal local overbought pressure.
➣ Touching the lower band may indicate oversold conditions within the current log trend.
Divergence Detection:
➣ Use the oscillator’s behavior relative to the channel slope to spot divergence from price.
➣ For example, RSI rising inside a falling channel can flag early trend shifts.
Trend-Sensitive Entries:
➣ Combine oscillator signals with log channel direction to filter trades in trend alignment.
➣ Signal line crossovers inside the channel act as early warning for momentum turns.
The Log Regression Oscillator Channel transforms how traders view classic momentum tools. By embedding oscillators into a logarithmic trend structure, it offers unmatched clarity on momentum positioning relative to price expansion. Ideal for swing traders, mean-reverters, or trend followers looking to sharpen entries and exits with style.
Bands and Channels
Adaptive Fibonacci Pullback System -FibonacciFluxAdaptive Fibonacci Pullback System (AFPS) - FibonacciFlux
This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0). Original concepts by FibonacciFlux.
Abstract
The Adaptive Fibonacci Pullback System (AFPS) presents a sophisticated, institutional-grade algorithmic strategy engineered for high-probability trend pullback entries. Developed by FibonacciFlux, AFPS uniquely integrates a proprietary Multi-Fibonacci Supertrend engine (0.618, 1.618, 2.618 ratios) for harmonic volatility assessment, an Adaptive Moving Average (AMA) Channel providing dynamic market context, and a synergistic Multi-Timeframe (MTF) filter suite (RSI, MACD, Volume). This strategy transcends simple indicator combinations through its strict, multi-stage confluence validation logic. Historical simulations suggest that specific MTF filter configurations can yield exceptional performance metrics, potentially achieving Profit Factors exceeding 2.6 , indicative of institutional-level potential, while maintaining controlled risk under realistic trading parameters (managed equity risk, commission, slippage).
4 hourly MTF filtering
1. Introduction: Elevating Pullback Trading with Adaptive Confluence
Traditional pullback strategies often struggle with noise, false signals, and adapting to changing market dynamics. AFPS addresses these challenges by introducing a novel framework grounded in Fibonacci principles and adaptive logic. Instead of relying on static levels or single confirmations, AFPS seeks high-probability pullback entries within established trends by validating signals through a rigorous confluence of:
Harmonic Volatility Context: Understanding the trend's stability and potential turning points using the unique Multi-Fibonacci Supertrend.
Adaptive Market Structure: Assessing the prevailing trend regime via the AMA Channel.
Multi-Dimensional Confirmation: Filtering signals with lower-timeframe Momentum (RSI), Trend Alignment (MACD), and Market Conviction (Volume) using the MTF suite.
The objective is to achieve superior signal quality and adaptability, moving beyond conventional pullback methodologies.
2. Core Methodology: Synergistic Integration
AFPS's effectiveness stems from the engineered synergy between its core components:
2.1. Multi-Fibonacci Supertrend Engine: Utilizes specific Fibonacci ratios (0.618, 1.618, 2.618) applied to ATR, creating a multi-layered volatility envelope potentially resonant with market harmonics. The averaged and EMA-smoothed result (`smoothed_supertrend`) provides a robust, dynamic trend baseline and context filter.
// Key Components: Multi-Fibonacci Supertrend & Smoothing
average_supertrend = (supertrend1 + supertrend2 + supertrend3) / 3
smoothed_supertrend = ta.ema(average_supertrend, st_smooth_length)
2.2. Adaptive Moving Average (AMA) Channel: Provides dynamic market context. The `ama_midline` serves as a key filter in the entry logic, confirming the broader trend bias relative to adaptive price action. Extended Fibonacci levels derived from the channel width offer potential dynamic S/R zones.
// Key Component: AMA Midline
ama_midline = (ama_high_band + ama_low_band) / 2
2.3. Multi-Timeframe (MTF) Filter Suite: An optional but powerful validation layer (RSI, MACD, Volume) assessed on a lower timeframe. Acts as a **validation cascade** – signals must pass all enabled filters simultaneously.
2.4. High-Confluence Entry Logic: The core innovation. A pullback entry requires a specific sequence and validation:
Price interaction with `average_supertrend` and recovery above/below `smoothed_supertrend`.
Price confirmation relative to the `ama_midline`.
Simultaneous validation by all enabled MTF filters.
// Simplified Long Entry Logic Example (incorporates key elements)
long_entry_condition = enable_long_positions and
(low < average_supertrend and close > smoothed_supertrend) and // Pullback & Recovery
(close > ama_midline and close > ama_midline) and // AMA Confirmation
(rsi_filter_long_ok and macd_filter_long_ok and volume_filter_ok) // MTF Validation
This strict, multi-stage confluence significantly elevates signal quality compared to simpler pullback approaches.
1hourly filtering
3. Realistic Implementation and Performance Potential
AFPS is designed for practical application, incorporating realistic defaults and highlighting performance potential with crucial context:
3.1. Realistic Default Strategy Settings:
The script includes responsible default parameters:
strategy('Adaptive Fibonacci Pullback System - FibonacciFlux', shorttitle = "AFPS", ...,
initial_capital = 10000, // Accessible capital
default_qty_type = strategy.percent_of_equity, // Equity-based risk
default_qty_value = 4, // Default 4% equity risk per initial trade
commission_type = strategy.commission.percent,
commission_value = 0.03, // Realistic commission
slippage = 2, // Realistic slippage
pyramiding = 2 // Limited pyramiding allowed
)
Note: The default 4% risk (`default_qty_value = 4`) requires careful user assessment and adjustment based on individual risk tolerance.
3.2. Historical Performance Insights & Institutional Potential:
Backtesting provides insights into historical behavior under specific conditions (always specify Asset/Timeframe/Dates when sharing results):
Default Performance Example: With defaults, historical tests might show characteristics like Overall PF ~1.38, Max DD ~1.16%, with potential Long/Short performance variance (e.g., Long PF 1.6+, Short PF < 1).
Optimized MTF Filter Performance: Crucially, historical simulations demonstrate that meticulous configuration of the MTF filters (particularly RSI and potentially others depending on market) can significantly enhance performance. Under specific, optimized MTF filter settings combined with appropriate risk management (e.g., 7.5% risk), historical tests have indicated the potential to achieve **Profit Factors exceeding 2.6**, alongside controlled drawdowns (e.g., ~1.32%). This level of performance, if consistently achievable (which requires ongoing adaptation), aligns with metrics often sought in institutional trading environments.
Disclaimer Reminder: These results are strictly historical simulations. Past performance does not guarantee future results. Achieving high performance requires careful parameter tuning, adaptation to changing markets, and robust risk management.
3.3. Emphasizing Risk Management:
Effective use of AFPS mandates active risk management. Utilize the built-in Stop Loss, Take Profit, and Trailing Stop features. The `pyramiding = 2` setting requires particularly diligent oversight. Do not rely solely on default settings.
4. Conclusion: Advancing Trend Pullback Strategies
The Adaptive Fibonacci Pullback System (AFPS) offers a sophisticated, theoretically grounded, and highly adaptable framework for identifying and executing high-probability trend pullback trades. Its unique blend of Fibonacci resonance, adaptive context, and multi-dimensional MTF filtering represents a significant advancement over conventional methods. While requiring thoughtful implementation and risk management, AFPS provides discerning traders with a powerful tool potentially capable of achieving institutional-level performance characteristics under optimized conditions.
Acknowledgments
Developed by FibonacciFlux. Inspired by principles of Fibonacci analysis, adaptive averaging, and multi-timeframe confirmation techniques explored within the trading community.
Disclaimer
Trading involves substantial risk. AFPS is an analytical tool, not a guarantee of profit. Past performance is not indicative of future results. Market conditions change. Users are solely responsible for their decisions and risk management. Thorough testing is essential. Deploy at your own considered risk.
Volume Flow with Bollinger Bands and EMA Cross SignalsThe Volume Flow with Bollinger Bands and EMA Cross Signals indicator is a custom technical analysis tool designed to identify potential buy and sell signals based on several key components:
Volume Flow: This component combines price movement and trading volume to create a signal that indicates the strength or weakness of price movements. When the price is rising with increasing volume, it suggests strong buying activity, whereas falling prices with increasing volume indicate strong selling pressure.
Bollinger Bands: Bollinger Bands consist of three lines:
The Basis (middle line), which is a Simple Moving Average (SMA) of the price over a set period.
The Upper Band, which is the Basis plus a multiple of the standard deviation (typically 2).
The Lower Band, which is the Basis minus a multiple of the standard deviation. Bollinger Bands help identify periods of high volatility and potential overbought/oversold conditions. When the price touches the upper band, it might indicate that the market is overbought, while touching the lower band might indicate oversold conditions.
EMA Crossovers: The script includes two Exponential Moving Averages (EMAs):
Fast EMA: A shorter-term EMA, typically more sensitive to price changes.
Slow EMA: A longer-term EMA, responding slower to price changes. The crossover of the Fast EMA crossing above the Slow EMA (bullish crossover) signals a potential buy opportunity, while the Fast EMA crossing below the Slow EMA (bearish crossover) signals a potential sell opportunity.
Background Color and Candle Color: The indicator highlights the chart's background with specific colors based on the signals:
Green background for buy signals.
Yellow background for sell signals. Additionally, the candles are colored green for buy signals and yellow for sell signals to visually reinforce the trade opportunities.
Buy/Sell Labels: Small labels are placed on the chart:
"BUY" label in green is placed below the bar when a buy signal is generated.
"SELL" label in yellow is placed above the bar when a sell signal is generated.
Working of the Indicator:
Volume Flow Calculation: The Volume Flow is calculated by multiplying the price change (current close minus the previous close) with the volume. This product is then smoothed with a Simple Moving Average (SMA) over a user-defined period (length). The result is then multiplied by a multiplier to adjust its sensitivity.
Price Change = close - close
Volume Flow = Price Change * Volume
Smoothed Volume Flow = SMA(Volume Flow, length)
The Volume Flow Signal is then: Smooth Volume Flow * Multiplier
This calculation represents the buying or selling pressure in the market.
Bollinger Bands: Bollinger Bands are calculated using the Simple Moving Average (SMA) of the closing price (basis) and the Standard Deviation (stdev) of the price over a period defined by the user (bb_length).
Basis (Middle Band) = SMA(close, bb_length)
Upper Band = Basis + (bb_std_dev * Stdev)
Lower Band = Basis - (bb_std_dev * Stdev)
The upper and lower bands are plotted alongside the price to identify the price's volatility. When the price is near the upper band, it could be overbought, and near the lower band, it could be oversold.
EMA Crossovers: The Fast EMA and Slow EMA are calculated using the Exponential Moving Average (EMA) function. The crossovers are detected by checking:
Buy Signal (Bullish Crossover): When the Fast EMA crosses above the Slow EMA.
Sell Signal (Bearish Crossover): When the Fast EMA crosses below the Slow EMA.
The long_condition variable checks if the Fast EMA crosses above the Slow EMA, and the short_condition checks if it crosses below.
Visual Signals:
Background Color: The background is colored green for a buy signal and yellow for a sell signal. This gives an immediate visual cue to the trader.
Bar Color: The candles are colored green for buy signals and yellow for sell signals.
Labels:
A "BUY" label in green appears below the bar when the Fast EMA crosses above the Slow EMA.
A "SELL" label in yellow appears above the bar when the Fast EMA crosses below the Slow EMA.
Summary of Buy/Sell Logic:
Buy Signal:
The Fast EMA crosses above the Slow EMA (bullish crossover).
Volume flow is positive, indicating buying pressure.
Background turns green and candles are colored green.
A "BUY" label appears below the bar.
Sell Signal:
The Fast EMA crosses below the Slow EMA (bearish crossover).
Volume flow is negative, indicating selling pressure.
Background turns yellow and candles are colored yellow.
A "SELL" label appears above the bar.
Usage of the Indicator:
This indicator is designed to help traders identify potential entry (buy) and exit (sell) points based on:
The interaction of Exponential Moving Averages (EMAs).
The strength and direction of Volume Flow.
Price volatility using Bollinger Bands.
By combining these components, the indicator provides a comprehensive view of market conditions, helping traders make informed decisions on when to enter and exit trades.
EMA Crossover 9/21 📈 **EMA Crossover Signal Line**
Created by **Ahmet AKSOY (tugeday)**
This indicator visualizes the crossover between two EMAs using a single dynamic-colored line.
✅ **How it works:**
- The script calculates two EMAs: a short-period EMA and a long-period EMA.
- Only the **short EMA line** is displayed on the chart.
- When the short EMA **crosses above** the long EMA (bullish crossover), the line color turns **green**.
- When the short EMA **crosses below** the long EMA (bearish crossover), the line color turns **red**.
- The line color remains based on the last crossover signal.
🎛️ **Customizable Inputs:**
- Short EMA period (default: 9)
- Long EMA period (default: 21)
All EMA periods can be adjusted from the settings panel, allowing traders to fine-tune the indicator to match their strategy.
Simple, clean, and effective.
Developed by **Ahmet AKSOY (tugeday)** — enjoy and trade smart!
Key-level-3.1 ob bb msb fvg
//@version=5
indicator("Key-level-3.1 ob bb msb fvg","key level 3" ,overlay = true, max_lines_count = 66, max_labels_count = 66)
// -----------------------------------------------------------------------------
// edited by berkusa
// -----------------------------------------------------------------------------
showprice= input.bool(true, title = "fiyatlari goster veya gosterme ")
///level func
f_create_level(_type, _start_condition, _active_condition, _global_level_array, _color, _line_width, _line_ext, _line_style, _label_size, _title, _iter, _is_enabled) =>
var float _price = na
var int _start_time = na
var float _hh = na
var float _ll = na
var line _price_line = line.new(x1 = na, y1 = na, x2 = na, y2 = na, xloc = xloc.bar_time, color = _color, width = _line_width, style = _line_style)
var label _price_label = label.new(x = na, y = na, xloc = xloc.bar_time, style = label.style_label_left, color = #00000000, size = _label_size, textcolor = _color)
_end_time = int(time + _line_ext * ta.change(time))
if _type == "open"
if _start_condition
_price := open
_start_time := time
else if _type == "high"
if _start_condition
_price := high
_start_time := time
else if _active_condition
_price := math.max(_price, high)
else if _type == "low"
if _start_condition
_price := low
_start_time := time
else if _active_condition
_price := math.min(_price, low)
else if _type == "eq"
if _start_condition
_hh := high
_ll := low
_price := math.avg(_hh, _ll)
_start_time := time
else if _active_condition
_hh := math.max(_hh, high)
_ll := math.min(_ll, low)
_price := math.avg(_hh, _ll)
float _price_val = _iter == 0 ? _price : ta.valuewhen(_start_condition, _price , _iter - 1)
int _start_time_val = _iter == 0 ? _start_time : ta.valuewhen(_start_condition, _start_time , _iter - 1)
_found_existing = array.indexof(_global_level_array, _price_val) > -1
if _is_enabled
if _found_existing
line.set_xy1(_price_line, x = na, y = na)
line.set_xy2(_price_line, x = na, y = na)
label.set_xy(_price_label, x = na, y = na)
else
array.push(_global_level_array, _price_val)
line.set_xy1(_price_line, x = _start_time_val, y = _price_val)
line.set_xy2(_price_line, x = _end_time, y = _price_val)
label.set_xy(_price_label, x = _end_time, y = _price_val)
label.set_text(_price_label , text = showprice? _title + " : " + str.tostring(_price_val): _title )
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// }
// Necessary Variables {
// -----------------------------------------------------------------------------
// Global arrays used to detect duplicate levels.
// Duplication is detected implicitly by execution order and whether the level has already been placed in the global array.
float global_open_array = array.new_float()
float global_high_array = array.new_float()
float global_low_array = array.new_float()
float global_eq_array = array.new_float()
new_H4 = ta.change(time("240")) != 0
new_day = ta.change(time("D")) != 0
new_week = ta.change(time("W")) != 0
new_month = ta.change(time("M")) != 0
new_quarter = ta.change(time("3M")) != 0
new_year = ta.change(time("12M")) != 0
is_monday = dayofweek == dayofweek.monday
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// }
// Global settings {
// -----------------------------------------------------------------------------
//inp_open_line_style = input.string("Solid", options = , title = "Open Line Style", group = "Global Settings")
//inp_high_line_style = input.string("Dashed", options = , title = "High Line Style", group = "Global Settings")
//inp_low_line_style = input.string("Dashed", options = , title = "Low Line Style", group = "Global Settings")
//inp_eq_line_style = input.string("Dotted", options = , title = "EQ Line Style", group = "Global Settings")
inp_open_line_style = "Solid"// input.string("Solid", options = , title = "Open Line Style", group = "Global Settings")
inp_high_line_style = "Dashed"// input.string("Dashed", options = , title = "High Line Style", group = "Global Settings")
inp_low_line_style = "Dashed"// input.string("Dashed", options = , title = "Low Line Style", group = "Global Settings")
inp_eq_line_style = "Dotted"// input.string("Dotted", options = , title = "EQ Line Style", group = "Global Settings")
inp_text_size = input.string("Small", options = , title = "Text Size", group = "Global Settings")
inp_ext = input.int(30, title = "Line Extension", group = "Global Settings")
text_size = inp_text_size == "Small" ? size.small : inp_text_size == "Normal" ? size.normal : size.large
open_line_style = inp_open_line_style == "Solid" ? line.style_solid : inp_open_line_style == "Dotted" ? line.style_dotted : line.style_dashed
high_line_style = inp_high_line_style == "Solid" ? line.style_solid : inp_high_line_style == "Dotted" ? line.style_dotted : line.style_dashed
low_line_style = inp_low_line_style == "Solid" ? line.style_solid : inp_low_line_style == "Dotted" ? line.style_dotted : line.style_dashed
eq_line_style = inp_eq_line_style == "Solid" ? line.style_solid : inp_eq_line_style == "Dotted" ? line.style_dotted : line.style_dashed
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// }
// H4 and Prev H4
// -----------------------------------------------------------------------------
h4 = input.bool(true, title = "H4", group = "H4 Levels", inline = "1")
inp_show_H4_open = input.bool(true, title = "OPEN", group = "H4 Levels", inline = "1")
inp_show_H4_high = input.bool(false, title = "HIGH", group = "H4 Levels", inline = "1")
inp_show_H4_low = input.bool(false, title = "LOW", group = "H4 Levels", inline = "1")
inp_show_H4_eq = input.bool(false, title = "EQ", group = "H4 Levels", inline = "1")
inp_H4_col = input.color(color.teal, title = "color", group = "H4 Levels", inline = "2")
inp_H4_line_width =1// input.int(1, title = "Line width", minval = 1, group = "H4 Levels", inline = "2")
H4_ok = timeframe.isintraday and timeframe.multiplier < 240
f_create_level("open", new_H4, not new_H4, global_open_array, inp_H4_col, inp_H4_line_width, inp_ext, open_line_style, text_size, "H4-O", 0, inp_show_H4_open and H4_ok and h4 )
f_create_level("high", new_H4, not new_H4, global_high_array, inp_H4_col, inp_H4_line_width, inp_ext, high_line_style, text_size, "H4-H", 0, inp_show_H4_high and H4_ok and h4 )
f_create_level("low", new_H4, not new_H4, global_low_array, inp_H4_col, inp_H4_line_width, inp_ext, low_line_style, text_size, "H4-L", 0, inp_show_H4_low and H4_ok and h4 )
f_create_level("eq", new_H4, not new_H4, global_eq_array, inp_H4_col, inp_H4_line_width, inp_ext, eq_line_style, text_size, "H4-EQ", 0, inp_show_H4_eq and H4_ok and h4 )
prev_H4 = input.bool(true, title = "P-H4", group = "Prev H4 Levels", inline = "1")
inp_show_prev_H4_open = input.bool(true, title = "OPEN", group = "Prev H4 Levels", inline = "1")
inp_show_prev_H4_high = input.bool(false, title = "HIGH", group = "Prev H4 Levels", inline = "1")
inp_show_prev_H4_low = input.bool(false, title = "LOW", group = "Prev H4 Levels", inline = "1")
inp_show_prev_H4_eq = input.bool(false, title = "EQ", group = "Prev H4 Levels", inline = "1")
inp_prev_H4_col = input.color(color.olive, title = "color", group = "Prev H4 Levels", inline = "2")
inp_prev_H4_line_width =1// input.int(1, title = "Line width", minval = 1, group = "Prev H4 Levels", inline = "2")
f_create_level("open", new_H4, not new_H4, global_open_array, inp_prev_H4_col, inp_prev_H4_line_width, inp_ext, open_line_style, text_size, "P-H4-O", 1, inp_show_prev_H4_open and H4_ok and prev_H4)
f_create_level("high", new_H4, not new_H4, global_high_array, inp_prev_H4_col, inp_prev_H4_line_width, inp_ext, high_line_style, text_size, "P-H4-H", 1, inp_show_prev_H4_high and H4_ok and prev_H4)
f_create_level("low", new_H4, not new_H4, global_low_array, inp_prev_H4_col, inp_prev_H4_line_width, inp_ext, low_line_style, text_size, "P-H4-L", 1, inp_show_prev_H4_low and H4_ok and prev_H4)
f_create_level("eq", new_H4, not new_H4, global_eq_array, inp_prev_H4_col, inp_prev_H4_line_width, inp_ext, eq_line_style, text_size, "P-H4-EQ", 1, inp_show_prev_H4_eq and H4_ok and prev_H4)
// -----------------------------------------------------------------------------
// Daily and Prev Daily
// -----------------------------------------------------------------------------
daily = input.bool(true, title = "D", group = "Daily Levels", inline = "1")
inp_show_daily_open = input.bool(true, title = "OPEN", group = "Daily Levels", inline = "1")
inp_show_daily_high = input.bool(true, title = "HIGH", group = "Daily Levels", inline = "1")
inp_show_daily_low = input.bool(true, title = "LOW", group = "Daily Levels", inline = "1")
inp_show_daily_eq = input.bool(true, title = "EQ", group = "Daily Levels", inline = "1")
inp_daily_col = input.color(color.silver, title = "color", group = "Daily Levels", inline = "2")
inp_daily_line_width =1// input.int(1, title = "Line width", minval = 1, group = "Daily Levels", inline = "2")
daily_ok = timeframe.isintraday
f_create_level("open", new_day, not new_day, global_open_array, inp_daily_col, inp_daily_line_width, inp_ext, open_line_style, text_size, "DO", 0, inp_show_daily_open and daily_ok and daily)
f_create_level("high", new_day, not new_day, global_high_array, inp_daily_col, inp_daily_line_width, inp_ext, high_line_style, text_size, "DH", 0, inp_show_daily_high and daily_ok and daily)
f_create_level("low", new_day, not new_day, global_low_array, inp_daily_col, inp_daily_line_width, inp_ext, low_line_style, text_size, "DL", 0, inp_show_daily_low and daily_ok and daily)
f_create_level("eq", new_day, not new_day, global_eq_array, inp_daily_col, inp_daily_line_width, inp_ext, eq_line_style, text_size, "D-EQ", 0, inp_show_daily_eq and daily_ok and daily)
prev_daily = input.bool(true, title = "PD", group = "Prev Daily Levels", inline = "1")
inp_show_prev_daily_open = input.bool(true, title = "OPEN", group = "Prev Daily Levels", inline = "1")
inp_show_prev_daily_high = input.bool(true, title = "HIGH", group = "Prev Daily Levels", inline = "1")
inp_show_prev_daily_low = input.bool(true, title = "LOW", group = "Prev Daily Levels", inline = "1")
inp_show_prev_daily_eq = input.bool(false, title = "EQ", group = "Prev Daily Levels", inline = "1")
inp_prev_daily_col = input.color(color.gray, title = "color", group = "Prev Daily Levels", inline = "2")
inp_prev_daily_line_width = 1//input.int(1, title = "Line width", minval = 1, group = "Prev Daily Levels", inline = "2")
dd = input.int(1, title = "dayback", minval = 1,maxval=7, group = "Prev Daily Levels", inline = "2")
if dd >= 1
f_create_level("open", new_day, not new_day, global_open_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, open_line_style, text_size, "P-DO", 1, inp_show_prev_daily_open and daily_ok and prev_daily )
f_create_level("high", new_day, not new_day, global_high_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, high_line_style, text_size, "P-DH", 1 , inp_show_prev_daily_high and daily_ok and prev_daily )
f_create_level("low", new_day, not new_day, global_low_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, low_line_style, text_size, "P-DL", 1, inp_show_prev_daily_low and daily_ok and prev_daily )
f_create_level("eq", new_day, not new_day, global_eq_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, eq_line_style, text_size, "P-D-EQ", 1, inp_show_prev_daily_eq and daily_ok and prev_daily )
if dd >= 2
f_create_level("open", new_day, not new_day, global_open_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, open_line_style, text_size, "P-DO-2", 2, inp_show_prev_daily_open and daily_ok and prev_daily )
f_create_level("high", new_day, not new_day, global_high_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, high_line_style, text_size, "P-DH-2", 2 , inp_show_prev_daily_high and daily_ok and prev_daily )
f_create_level("low", new_day, not new_day, global_low_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, low_line_style, text_size, "P-DL-2", 2, inp_show_prev_daily_low and daily_ok and prev_daily )
f_create_level("eq", new_day, not new_day, global_eq_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, eq_line_style, text_size, "P-D-EQ-2", 2, inp_show_prev_daily_eq and daily_ok and prev_daily )
if dd >= 3
f_create_level("open", new_day, not new_day, global_open_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, open_line_style, text_size, "P-DO-3", dd, inp_show_prev_daily_open and daily_ok and prev_daily )
f_create_level("high", new_day, not new_day, global_high_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, high_line_style, text_size, "P-DH-3", dd , inp_show_prev_daily_high and daily_ok and prev_daily )
f_create_level("low", new_day, not new_day, global_low_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, low_line_style, text_size, "P-DL-3", dd, inp_show_prev_daily_low and daily_ok and prev_daily )
f_create_level("eq", new_day, not new_day, global_eq_array, inp_prev_daily_col, inp_prev_daily_line_width, inp_ext, eq_line_style, text_size, "P-D-EQ-3", dd, inp_show_prev_daily_eq and daily_ok and prev_daily )
// -----------------------------------------------------------------------------
// Weekly and Prev Weekly
// -----------------------------------------------------------------------------
weekly = input.bool(true, title = "W", group = "Weekly Levels", inline = "1")
inp_show_weekly_open = input.bool(true, title = "OPEN", group = "Weekly Levels", inline = "1")
inp_show_weekly_high = input.bool(true, title = "HIGH", group = "Weekly Levels", inline = "1")
inp_show_weekly_low = input.bool(true, title = "LOW", group = "Weekly Levels", inline = "1")
inp_show_weekly_eq = input.bool(false, title = "EQ", group = "Weekly Levels", inline = "1")
inp_weekly_col = input.color(color.aqua, title = "color", group = "Weekly Levels", inline = "2")
inp_weekly_line_width =1// input.int(1, title = "Line width", minval = 1, group = "Weekly Levels", inline = "2")
weekly_ok = timeframe.isintraday or timeframe.isdaily
f_create_level("open", new_week, not new_week, global_open_array, inp_weekly_col, inp_weekly_line_width, inp_ext, open_line_style, text_size, "WO", 0, inp_show_weekly_open and weekly_ok and weekly )
f_create_level("high", new_week, not new_week, global_high_array, inp_weekly_col, inp_weekly_line_width, inp_ext, high_line_style, text_size, "WH", 0, inp_show_weekly_high and weekly_ok and weekly )
f_create_level("low", new_week, not new_week, global_low_array, inp_weekly_col, inp_weekly_line_width, inp_ext, low_line_style, text_size, "WL", 0, inp_show_weekly_low and weekly_ok and weekly )
f_create_level("eq", new_week, not new_week, global_eq_array, inp_weekly_col, inp_weekly_line_width, inp_ext, eq_line_style, text_size, "W-EQ", 0, inp_show_weekly_eq and weekly_ok and weekly )
prev_weekly = input.bool(true, title = "PW", group = "Prev Weekly Levels", inline = "1")
inp_show_prev_weekly_open = input.bool(true, title = "OPEN", group = "Prev Weekly Levels", inline = "1")
inp_show_prev_weekly_high = input.bool(false, title = "HIGH", group = "Prev Weekly Levels", inline = "1")
inp_show_prev_weekly_low = input.bool(false, title = "LOW", group = "Prev Weekly Levels", inline = "1")
inp_show_prev_weekly_eq = input.bool(false, title = "EQ", group = "Prev Weekly Levels", inline = "1")
inp_prev_weekly_col = input.color(color.blue, title = "color", group = "Prev Weekly Levels", inline = "2")
inp_prev_weekly_line_width = 1//input.int(1, title = "Line width", minval = 1, group = "Prev Weekly Levels", inline = "2")
ww = input.int(1, title = "weekback", minval = 1,maxval=5, group = "Prev Weekly Levels", inline = "2")
f_create_level("open", new_week, not new_week, global_open_array, inp_prev_weekly_col, inp_prev_weekly_line_width, inp_ext, open_line_style, text_size, "P-WO", ww, inp_show_prev_weekly_open and weekly_ok and prev_weekly)
f_create_level("high", new_week, not new_week, global_high_array, inp_prev_weekly_col, inp_prev_weekly_line_width, inp_ext, high_line_style, text_size, "P-WH", ww, inp_show_prev_weekly_high and weekly_ok and prev_weekly)
f_create_level("low", new_week, not new_week, global_low_array, inp_prev_weekly_col, inp_prev_weekly_line_width, inp_ext, low_line_style, text_size, "P-WL", ww, inp_show_prev_weekly_low and weekly_ok and prev_weekly)
f_create_level("eq", new_week, not new_week, global_eq_array, inp_prev_weekly_col, inp_prev_weekly_line_width, inp_ext, eq_line_style, text_size, "P-W-EQ", ww, inp_show_prev_weekly_eq and weekly_ok and prev_weekly)
// Monday and Prev Monday
// -----------------------------------------------------------------------------
// Note : Monday range is a special case and is why the _active_condition is implemented in the function. We only want start on Monday, and ONLY update levels during monday.
monday_open = input.bool(false, title = "MonD", group = "Monday Levels", inline = "1")
inp_show_monday_open = input.bool(false, title = "OPEN", group = "Monday Levels", inline = "1")
inp_show_monday_high = input.bool(false, title = "HIGH", group = "Monday Levels", inline = "1")
inp_show_monday_low = input.bool(false, title = "LOW", group = "Monday Levels", inline = "1")
inp_show_monday_eq = input.bool(false, title = "EQ", group = "Monday Levels", inline = "1")
inp_monday_col = input.color(color.fuchsia, title = "color", group = "Monday Levels", inline = "2")
inp_monday_line_width = 1//input.int(1, title = "Line width", minval = 1, group = "Monday Levels", inline = "2")
monday_ok = timeframe.isintraday
f_create_level("open", new_week, is_monday, global_open_array, inp_monday_col, inp_monday_line_width, inp_ext, open_line_style, text_size, "M.Day-O", 0, inp_show_monday_open and monday_ok and monday_open)
f_create_level("high", new_week, is_monday, global_high_array, inp_monday_col, inp_monday_line_width, inp_ext, high_line_style, text_size, "M.Day-H", 0, inp_show_monday_high and monday_ok and monday_open)
f_create_level("low", new_week, is_monday, global_low_array, inp_monday_col, inp_monday_line_width, inp_ext, low_line_style, text_size, "M.Day-L", 0, inp_show_monday_low and monday_ok and monday_open)
f_create_level("eq", new_week, is_monday, global_eq_array, inp_monday_col, inp_monday_line_width, inp_ext, eq_line_style, text_size, "M.Day-EQ", 0, inp_show_monday_eq and monday_ok and monday_open)
prev_monday = input.bool(false, title = "p-mon", group = "Prev Monday Levels", inline = "1")
inp_show_prev_monday_open = input.bool(false, title = "OPEN", group = "Prev Monday Levels", inline = "1")
inp_show_prev_monday_high = input.bool(false, title = "HIGH", group = "Prev Monday Levels", inline = "1")
inp_show_prev_monday_low = input.bool(false, title = "LOW", group = "Prev Monday Levels", inline = "1")
inp_show_prev_monday_eq = input.bool(false, title = "EQ", group = "Prev Monday Levels", inline = "1")
inp_prev_monday_col = input.color(color.purple, title = "color", group = "Prev Monday Levels", inline = "2")
inp_prev_monday_line_width = 1//input.int(1, title = "Line width", minval = 1, group = "Prev Monday Levels", inline = "2")
f_create_level("open", new_week, is_monday, global_open_array, inp_prev_monday_col, inp_prev_monday_line_width, inp_ext, open_line_style, text_size, "P-M.Day-O", 1, inp_show_prev_monday_open and monday_ok and prev_monday and prev_monday)
f_create_level("high", new_week, is_monday, global_high_array, inp_prev_monday_col, inp_prev_monday_line_width, inp_ext, high_line_style, text_size, "P-M.Day-H", 1, inp_show_prev_monday_high and monday_ok and prev_monday and prev_monday)
f_create_level("low", new_week, is_monday, global_low_array, inp_prev_monday_col, inp_prev_monday_line_width, inp_ext, low_line_style, text_size, "P-M.Day-L", 1, inp_show_prev_monday_low and monday_ok and prev_monday and prev_monday)
f_create_level("eq", new_week, is_monday, global_eq_array, inp_prev_monday_col, inp_prev_monday_line_width, inp_ext, eq_line_style, text_size, "P-M.Day-EQ", 1, inp_show_prev_monday_eq and monday_ok and prev_monday and prev_monday)
// -----------------------------------------------------------------------------
// Monthly and Prev Monthly
// -----------------------------------------------------------------------------
monthly = input.bool(true, title = "M", group = "Monthly Levels", inline = "1")
inp_show_monthly_open = input.bool(true, title = "OPEN", group = "Monthly Levels", inline = "1")
inp_show_monthly_high = input.bool(true, title = "HIGH", group = "Monthly Levels", inline = "1")
inp_show_monthly_low = input.bool(true, title = "LOW", group = "Monthly Levels", inline = "1")
inp_show_monthly_eq = input.bool(false, title = "EQ", group = "Monthly Levels", inline = "1")
inp_monthly_col = input.color(color.lime, title = "color", group = "Monthly Levels", inline = "2")
inp_monthly_line_width = 1//input.int(1, title = "Line width", minval = 1 ,group = "Monthly Levels", inline = "2")
monthly_ok = timeframe.isintraday or timeframe.isdaily
f_create_level("open", new_month, not new_month, global_open_array, inp_monthly_col, inp_monthly_line_width, inp_ext, open_line_style, text_size, "MO", 0, inp_show_monthly_open and monthly_ok and monthly )
f_create_level("high", new_month, not new_month, global_high_array, inp_monthly_col, inp_monthly_line_width, inp_ext, high_line_style, text_size, "MH", 0, inp_show_monthly_high and monthly_ok and monthly )
f_create_level("low", new_month, not new_month, global_low_array, inp_monthly_col, inp_monthly_line_width, inp_ext, low_line_style, text_size, "ML", 0, inp_show_monthly_low and monthly_ok and monthly )
f_create_level("eq", new_month, not new_month, global_eq_array, inp_monthly_col, inp_monthly_line_width, inp_ext, eq_line_style, text_size, "M-EQ", 0, inp_show_monthly_eq and monthly_ok and monthly )
prev_monthly = input.bool(true, title = "PM", group = "Prev Monthly Levels", inline = "1")
inp_show_prev_monthly_open = input.bool(true, title = "OPEN", group = "Prev Monthly Levels", inline = "1")
inp_show_prev_monthly_high = input.bool(false, title = "HIGH", group = "Prev Monthly Levels", inline = "1")
inp_show_prev_monthly_low = input.bool(false, title = "LOW", group = "Prev Monthly Levels", inline = "1")
inp_show_prev_monthly_eq = input.bool(false, title = "EQ", group = "Prev Monthly Levels", inline = "1")
inp_prev_monthly_col = input.color(color.green, title = "color", group = "Prev Monthly Levels", inline = "2")
inp_prev_monthly_line_width =1// input.int(1, title = "Line width", minval = 1, group = "Prev Monthly Levels", inline = "2")
mm = input.int(1, title = "monthback", minval = 1,maxval=13, group = "Prev Monthly Levels", inline = "2")
f_create_level("open", new_month, not new_month, global_open_array, inp_prev_monthly_col, inp_prev_monthly_line_width, inp_ext, open_line_style, text_size, "P-MO", mm, inp_show_prev_monthly_open and monthly_ok and prev_monthly and prev_monthly )
f_create_level("high", new_month, not new_month, global_high_array, inp_prev_monthly_col, inp_prev_monthly_line_width, inp_ext, high_line_style, text_size, "P-MH", mm, inp_show_prev_monthly_high and monthly_ok and prev_monthly and prev_monthly )
f_create_level("low", new_month, not new_month, global_low_array, inp_prev_monthly_col, inp_prev_monthly_line_width, inp_ext, low_line_style, text_size, "P-ML", mm, inp_show_prev_monthly_low and monthly_ok and prev_monthly and prev_monthly )
f_create_level("eq", new_month, not new_month, global_eq_array, inp_prev_monthly_col, inp_prev_monthly_line_width, inp_ext, eq_line_style, text_size, "P-M-EQ", mm, inp_show_prev_monthly_eq and monthly_ok and prev_monthly and prev_monthly )
// -----------------------------------------------------------------------------
// Quarterly and Prev Quarterly
// -----------------------------------------------------------------------------
quarterly = input.bool(false, title = "Q", group = "Quarterly Levels", inline = "1")
inp_show_quarterly_open = input.bool(false, title = "OPEN", group = "Quarterly Levels", inline = "1")
inp_show_quarterly_high = input.bool(false, title = "HIGH", group = "Quarterly Levels", inline = "1")
inp_show_quarterly_low = input.bool(false, title = "LOW", group = "Quarterly Levels", inline = "1")
inp_show_quarterly_eq = input.bool(false, title = "EQ", group = "Quarterly Levels", inline = "1")
inp_quarterly_col = input.color(color.orange, title = "color", group = "Quarterly Levels", inline = "2")
inp_quarterly_line_width = 1//input.int(1, title = "Line width", minval = 1, group = "Quarterly Levels", inline = "2")
quarterly_ok = timeframe.isintraday or timeframe.isdaily or timeframe.isweekly
f_create_level("open", new_quarter, not new_quarter, global_open_array, inp_quarterly_col, inp_quarterly_line_width, inp_ext, open_line_style, text_size, "3M-O", 0, inp_show_quarterly_open and quarterly_ok and quarterly)
f_create_level("high", new_quarter, not new_quarter, global_high_array, inp_quarterly_col, inp_quarterly_line_width, inp_ext, high_line_style, text_size, "3M-H", 0, inp_show_quarterly_high and quarterly_ok and quarterly)
f_create_level("low", new_quarter, not new_quarter, global_low_array, inp_quarterly_col, inp_quarterly_line_width, inp_ext, low_line_style, text_size, "3M-L", 0, inp_show_quarterly_low and quarterly_ok and quarterly)
f_create_level("eq", new_quarter, not new_quarter, global_eq_array, inp_quarterly_col, inp_quarterly_line_width, inp_ext, eq_line_style, text_size, "3M-EQ", 0, inp_show_quarterly_eq and quarterly_ok and quarterly)
prev_quarterly = input.bool(false, title = "PQ", group = "Prev Quarterly Levels", inline = "1")
inp_show_prev_quarterly_open = input.bool(false, title = "OPEN", group = "Prev Quarterly Levels", inline = "1")
inp_show_prev_quarterly_high = input.bool(false, title = "HIGH", group = "Prev Quarterly Levels", inline = "1")
inp_show_prev_quarterly_low = input.bool(false, title = "LOW", group = "Prev Quarterly Levels", inline = "1")
inp_show_prev_quarterly_eq = input.bool(false, title = "EQ", group = "Prev Quarterly Levels", inline = "1")
inp_prev_quarterly_col = input.color(color.yellow, title = "color", group = "Prev Quarterly Levels", inline = "2")
inp_prev_quarterly_line_width = 1//input.int(1, title = "Line width", minval = 1, group = "Prev Quarterly Levels", inline = "2")
qq = input.int(1, title = "Quarterback", minval = 1,maxval=12, group = "Prev Quarterly Levels", inline = "2")
f_create_level("open", new_quarter, not new_quarter, global_open_array, inp_prev_quarterly_col, inp_prev_quarterly_line_width, inp_ext, open_line_style, text_size, "P 3MOpen", mm, inp_show_prev_quarterly_open and quarterly_ok and prev_quarterly and qq)
f_create_level("high", new_quarter, not new_quarter, global_high_array, inp_prev_quarterly_col, inp_prev_quarterly_line_width, inp_ext, high_line_style, text_size, "Prev 3MHIGH", mm, inp_show_prev_quarterly_high and quarterly_ok and prev_quarterly and qq)
f_create_level("low", new_quarter, not new_quarter, global_low_array, inp_prev_quarterly_col, inp_prev_quarterly_line_width, inp_ext, low_line_style, text_size, "P-3MLOW", mm, inp_show_prev_quarterly_low and quarterly_ok and prev_quarterly and qq)
f_create_level("eq", new_quarter, not new_quarter, global_eq_array, inp_prev_quarterly_col, inp_prev_quarterly_line_width, inp_ext, eq_line_style, text_size, "P-3M-EQ", mm, inp_show_prev_quarterly_eq and quarterly_ok and prev_quarterly and qq)
// -----------------------------------------------------------------------------
// Yearly & Prev Yearly
// -----------------------------------------------------------------------------
yearly = input.bool(false, title = "Y", group = "Yearly Levels", inline = "1")
inp_show_yearly_open = input.bool(false, title = "OPEN", group = "Yearly Levels", inline = "1")
inp_show_yearly_high = input.bool(false, title = "HIGH", group = "Yearly Levels", inline = "1")
inp_show_yearly_low = input.bool(false, title = "LOW", group = "Yearly Levels", inline = "1")
inp_show_yearly_eq = input.bool(false, title = "EQ", group = "Yearly Levels", inline = "1")
inp_yearly_col = input.color(color.red, title = "color", group = "Yearly Levels", inline = "2")
inp_yearly_line_width = input.int(1, title = "Line width", minval = 1, group = "Yearly Levels", inline = "2")
yearly_ok = timeframe.isintraday or timeframe.isdaily or timeframe.isweekly or (timeframe.ismonthly and timeframe.multiplier < 12)
f_create_level("open", new_year, not new_year, global_open_array, inp_yearly_col, inp_yearly_line_width, inp_ext, open_line_style, text_size, "YO", 0, inp_show_yearly_open and yearly_ok)
f_create_level("high", new_year, not new_year, global_high_array, inp_yearly_col, inp_yearly_line_width, inp_ext, high_line_style, text_size, "Yearly HIGH", 0, inp_show_yearly_high and yearly_ok)
f_create_level("low", new_year, not new_year, global_low_array, inp_yearly_col, inp_yearly_line_width, inp_ext, low_line_style, text_size, "Yearly LOW", 0, inp_show_yearly_low and yearly_ok)
f_create_level("eq", new_year, not new_year, global_eq_array, inp_yearly_col, inp_yearly_line_width, inp_ext, eq_line_style, text_size, "Yearly EQ", 0, inp_show_yearly_eq and yearly_ok)
prev_yearly = input.bool(false, title = "PY", group = "Prev Yearly Levels", inline = "1")
inp_show_prev_yearly_open = input.bool(false, title = "OPEN", group = "Prev Yearly Levels", inline = "1")
inp_show_prev_yearly_high = input.bool(false, title = "HIGH", group = "Prev Yearly Levels", inline = "1")
inp_show_prev_yearly_low = input.bool(false, title = "LOW", group = "Prev Yearly Levels", inline = "1")
inp_show_prev_yearly_eq = input.bool(false, title = "EQ", group = "Prev Yearly Levels", inline = "1")
inp_prev_yearly_col = input.color(color.maroon, title = "color", group = "Prev Yearly Levels", inline = "2")
inp_prev_yearly_line_width = input.int(1, title = "Line width", minval = 1, group = "Prev Yearly Levels", inline = "2")
yy = input.int(1, title = "yearback", minval = 1, maxval=2, group = "Prev Yearly Levels", inline = "2")
f_create_level("open", new_year, not new_year, global_open_array, inp_prev_yearly_col, inp_prev_yearly_line_width, inp_ext, open_line_style, text_size, "P-YO", yy, inp_show_prev_yearly_open and yearly_ok and prev_yearly)
f_create_level("high", new_year, not new_year, global_high_array, inp_prev_yearly_col, inp_prev_yearly_line_width, inp_ext, high_line_style, text_size, "Prev Yearly HIGH", yy, inp_show_prev_yearly_high and yearly_ok and prev_yearly)
f_create_level("low", new_year, not new_year, global_low_array, inp_prev_yearly_col, inp_prev_yearly_line_width, inp_ext, low_line_style, text_size, "Prev Yearly LOW", yy, inp_show_prev_yearly_low and yearly_ok and prev_yearly)
f_create_level("eq", new_year, not new_year, global_eq_array, inp_prev_yearly_col, inp_prev_yearly_line_width, inp_ext, eq_line_style, text_size, "Prev Yearly EQ", yy, inp_show_prev_yearly_eq and yearly_ok and prev_yearly)
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//imbalance finder
color gray0 = color.new(color.gray, 0)
color yellow0 = color.new(#FFF700, 0)
bool showgreydiamond = input(defval=false, title='İmbalance back test helper' ,group='=== Information ===')
bool showib = input(defval=false, title='İmbalance bar' ,group='=== Information ===')
Imbcol = input.color(yellow0, 'Imbalance Color', inline="1" ,group='=== Information ===')
Dimcol = input.color(gray0, 'Imbalance back test diamond color', inline="1" ,group='=== Information ===')
TopImbalance = low <= open and high >= close
TopImbalancesize = low - high
if TopImbalance and showib and TopImbalancesize > 0
BOX1 = box.new(left=bar_index , top=low , right=bar_index , bottom=high )
box.set_bgcolor(BOX1, na)
box.set_border_color(BOX1, Imbcol )
//plot(TopImbalance and TopImbalancesize > 0 ? low : na , color=Imbcol)
//plot(TopImbalance and TopImbalancesize > 0 ? high : na , color=Imbcol)
BottomImbalance = high >= open and low <= close
BottomImbalancesize = low - high
if BottomImbalance and showib and BottomImbalancesize > 0
BOX2 = box.new(left=bar_index , top=low , right=bar_index , bottom=high )
box.set_bgcolor(BOX2, na )
box.set_border_color(BOX2, Imbcol )
//plot(BottomImbalance and BottomImbalancesize > 0 ? low : na , color=Imbcol)
//plot(BottomImbalance and BottomImbalancesize > 0 ? high : na , color=Imbcol)
DownImbalance = TopImbalance and TopImbalancesize > 0
plotshape(DownImbalance and showgreydiamond, style=shape.diamond, location=location.abovebar, color=Dimcol, size=size.tiny)
UpImbalance = BottomImbalance and BottomImbalancesize > 0
plotshape(UpImbalance and showgreydiamond, style=shape.diamond, location=location.belowbar, color=Dimcol, size=size.tiny)
alertcondition(DownImbalance , title='Down Imbalance', message='Down Imbalance')
alertcondition(UpImbalance , title='Up Imbalance', message='Up Imbalance')
alertcondition(DownImbalance or UpImbalance , title='Imbalance Present ', message='Imbalance Present')
// MBS
//indicator(title='Order Blocks', overlay=true)
bool msb_a_sv = input.bool (true, title='Alert MSB')
bool msb_sv = input.bool (true, title='Plot MSB lines')
color mbs_color1 = input.color(#00e1ff, title='MSB Color Bullish')
color mbs_color2 = input.color(#ff00bf, title='MSB Color Bearish')
bool box_sv = input.bool (false, title='Plot Orderblocks')
color u_s = input.color (color.rgb(255, 0, 0, 90), title='Untested Supply Color')
color t_s = input.color (color.rgb(192, 192, 192, 93), title='Tested Supply Color')
color u_d = input.color (color.rgb(0, 255, 0, 90), title='Untested Demand Color')
color t_d = input.color (color.rgb(192, 192, 192, 93), title='Tested Demand Color')
bool m_sv = input.bool (false, title='Plot Breakerblocks')
color u_b = input.color (color.new(color.blue, 90), title='Untested Breaker Color')
color t_b = input.color (color.rgb(192, 192, 192, 90), title='Tested Breaker Color')
bool ob_a_sv = input.bool (false, title='Alert Orderblock test')
bool bb_a_sv = input.bool (false, title='Alert Breakerblock test')
bool r_a_sv = input.bool (false, title='Alert New Range')
bool rt_a_sv = input.bool (false, title='Alert Range test')
var float pvh1_price = array.new_float (30, na) // high
var int pvh1_time = array.new_int (30, na)
var float pvl1_price = array.new_float (30, na) // low
var int pvl1_time = array.new_int (30, na)
var float pvh2_price = array.new_float (10, na) // higher high
var int pvh2_time = array.new_int (10, na)
var float pvl2_price = array.new_float (10, na) // lower low
var int pvl2_time = array.new_int (10, na)
var float htcmrll_price = na // high that created most recent ll
var int htcmrll_time = na
var float ltcmrhh_price = na // low that created most recent hh
var int ltcmrhh_time = na
var box long_boxes = array.new_box() // orderblocks
var box short_boxes = array.new_box()
var box m_long_boxes = array.new_box() // breakerblocks
var box m_short_boxes = array.new_box()
var line bull_bos_lines = array.new_line() // MSB lines
var line bear_bos_lines = array.new_line()
var line range_h_lines = array.new_line() // Range lines
var line range_25_lines = array.new_line()
var line range_m_lines = array.new_line()
var line range_75_lines = array.new_line()
var line range_l_lines = array.new_line()
var label la_ph2 = array.new_label() // 2nd order pivots
var label la_pl2 = array.new_label()
var float temp_pv_0 = na
var float temp_pv_1 = na
var float temp_pv_2 = na
var int temp_time = na
var float last_range_h = na
var float last_range_l = na
var line range_m = na
var line range_25 = na
var line range_75 = na
var float box_top = na
var float box_bottom = na
var int h_a_time = 0
var int l_a_time = 0
var int mh_a_time = 0
var int ml_a_time = 0
var int rh_a_time = 0
var int rl_a_time = 0
bool pvh = high < high and high > high
bool pvl = low > low and low < low
int pv1_time = bar_index
float pv1_high = high
float pv1_low = low
bool new_ph_2nd = false
bool new_pl_2nd = false
string alert = na
if barstate.isconfirmed
if pvh
array.pop(pvh1_price)
array.pop(pvh1_time)
array.unshift(pvh1_price, pv1_high)
array.unshift(pvh1_time, pv1_time)
if array.size(pvh1_price) > 2
temp_pv_0 := array.get(pvh1_price, 0)
temp_pv_1 := array.get(pvh1_price, 1)
temp_pv_2 := array.get(pvh1_price, 2)
if temp_pv_0 < temp_pv_1 and temp_pv_1 > temp_pv_2
array.pop(pvh2_price)
array.pop(pvh2_time)
array.unshift(pvh2_price, temp_pv_1)
array.unshift(pvh2_time, array.get(pvh1_time, 1))
new_ph_2nd := true
if temp_pv_1 > array.get(pvh2_price, 1)
for i = 0 to array.size(pvl2_time) - 1 by 1
temp_ltcmrhh_time = array.get(pvl2_time, i)
if temp_ltcmrhh_time < array.get(pvh2_time, 0)
ltcmrhh_price := array.get(pvl2_price, i)
ltcmrhh_time := temp_ltcmrhh_time
break
if temp_pv_0 < ltcmrhh_price
if msb_sv
array.push(bear_bos_lines, line.new(x1=ltcmrhh_time, y1=ltcmrhh_price, x2=bar_index, y2=ltcmrhh_price, color=mbs_color2, width=2))
box_top := array.get(pvh2_price, 0)
box_bottom := math.max(low , low )
array.push(short_boxes, box.new(left=array.get(pvh2_time, 0), top=box_top, right=bar_index, bottom=box_bottom, bgcolor= box_sv ? u_s : na , border_color=na, extend=extend.right))
if msb_a_sv
alert := alert + 'Bearish MSB @ ' + str.tostring(ltcmrhh_price) + ' ' + 'New Supply Zone : '+ str.tostring(box_top) + ' - ' + str.tostring(box_bottom) + ' '
ltcmrhh_price := na
if pvl
array.pop(pvl1_price)
array.pop(pvl1_time)
array.unshift(pvl1_price, pv1_low)
array.unshift(pvl1_time, pv1_time)
if array.size(pvl1_price) > 2
temp_pv_0 := array.get(pvl1_price, 0)
temp_pv_1 := array.get(pvl1_price, 1)
temp_pv_2 := array.get(pvl1_price, 2)
if temp_pv_0 > temp_pv_1 and temp_pv_1 < temp_pv_2
array.pop(pvl2_price)
array.pop(pvl2_time)
array.unshift(pvl2_price, temp_pv_1)
array.unshift(pvl2_time, array.get(pvl1_time, 1))
new_pl_2nd := true
if temp_pv_1 < array.get(pvl2_price, 1)
for i = 0 to array.size(pvh2_time) - 1 by 1
temp_htcmrll_time = array.get(pvh2_time, i)
if temp_htcmrll_time < array.get(pvl2_time, 0)
htcmrll_price := array.get(pvh2_price, i)
htcmrll_time := temp_htcmrll_time
break
if temp_pv_0 > htcmrll_price
if msb_sv
array.push(bull_bos_lines, line.new(x1=htcmrll_time, y1=htcmrll_price, x2=bar_index, y2=htcmrll_price, color=mbs_color1, width=2))
box_top := math.min(high , high )
box_bottom := array.get(pvl2_price, 0)
array.push(long_boxes, box.new(left=array.get(pvl2_time, 0), top=box_top, right=bar_index, bottom=box_bottom, bgcolor= box_sv ? u_d : na, border_color=na, extend=extend.right))
if msb_a_sv
alert := alert + 'Bullish MSB @ ' + str.tostring(htcmrll_price) + ' ' + 'New Demand Zone : '+ str.tostring(box_bottom) + ' - ' + str.tostring(box_top) + ' '
htcmrll_price := na
if array.size(short_boxes) > 0
for i = array.size(short_boxes) - 1 to 0 by 1
tbox = array.get(short_boxes, i)
top = box.get_top(tbox)
bottom = box.get_bottom(tbox)
ago = box.get_left(tbox)
if array.get(pvh1_price, 0) > bottom
if box_sv
box.set_bgcolor(tbox, t_s)
if ob_a_sv and close < bottom
if array.get(pvh1_time, 0) != h_a_time
h_a_time := array.get(pvh1_time, 0)
alert := alert + 'Supply Zone Test @ ' + str.tostring(array.get(pvh1_price, 0)) + ' (age = ' + str.tostring(bar_index-ago) + ' bars) '
if array.get(pvl1_price, 0) > top
if m_sv
box.set_bgcolor(tbox, u_b)
array.push(m_long_boxes, tbox)
else
box.delete(tbox)
array.remove(short_boxes, i)
if msb_sv
line.delete(array.get(bear_bos_lines, i))
array.remove(bear_bos_lines, i)
if array.size(long_boxes) > 0
for i = array.size(long_boxes) - 1 to 0 by 1
lbox = array.get(long_boxes, i)
top = box.get_top(lbox)
bottom = box.get_bottom(lbox)
ago = box.get_left(lbox)
if array.get(pvl1_price, 0) < top
if box_sv
box.set_bgcolor(lbox, t_d)
if ob_a_sv and close > top
if array.get(pvl1_time, 0) != l_a_time
l_a_time := array.get(pvl1_time, 0)
alert := alert + 'Demand Zone Test @ ' + str.tostring(array.get(pvl1_price, 0)) + ' (age = ' + str.tostring(bar_index-ago) + ' bars) '
if array.get(pvh1_price, 0) < bottom
if m_sv
box.set_bgcolor(lbox, u_b)
array.push(m_short_boxes, lbox)
else
box.delete(lbox)
array.remove(long_boxes, i)
if msb_sv
line.delete(array.get(bull_bos_lines, i))
array.remove(bull_bos_lines, i)
if array.size(m_short_boxes) > 0
for i = array.size(m_short_boxes) - 1 to 0 by 1
tbox = array.get(m_short_boxes, i)
top = box.get_top(tbox)
bottom = box.get_bottom(tbox)
ago = box.get_left(tbox)
if array.get(pvh1_price, 0) > bottom
box.set_bgcolor(tbox, t_b)
if bb_a_sv and close < bottom
if array.get(pvh1_time, 0) != mh_a_time
mh_a_time := array.get(pvh1_time, 0)
alert := alert + 'Breakerblock Test Up @ ' + str.tostring(array.get(pvh1_price, 0)) + ' (age = ' + str.tostring(bar_index-ago) + ' bars) '
if array.get(pvl1_price, 0) > top
box.delete(tbox)
array.remove(m_short_boxes, i)
if array.size(m_long_boxes) > 0
for i = array.size(m_long_boxes) - 1 to 0 by 1
lbox = array.get(m_long_boxes, i)
top = box.get_top(lbox)
bottom = box.get_bottom(lbox)
ago = box.get_left(lbox)
if array.get(pvl1_price, 0) < top
box.set_bgcolor(lbox, t_b)
if bb_a_sv and close > top
if array.get(pvl1_time, 0) != ml_a_time
ml_a_time := array.get(pvl1_time, 0)
alert := alert + 'Breakerblock Test Down @ ' + str.tostring(array.get(pvl1_price, 0)) + ' (age = ' + str.tostring(bar_index-ago) + ' bars) '
if array.get(pvh1_price, 0) < bottom
box.delete(lbox)
array.remove(m_long_boxes, i)
alert := not na(alert) ? (alert + 'Current price = ' + str.tostring(close) + ' ') : na
exec = not na(alert) ? true : false
if exec==true
alert(alert, alert.freq_once_per_bar_close)
Nifty 1m EMA Pullback Scalper Signals
### **Master the Market with the Sniper Scalping Strategy for Nifty (1-Minute Timeframe)**
Unlock the power of precision trading with this expertly crafted **Sniper Scalping Strategy**, designed specifically for the Nifty index on a lightning-fast 1-minute timeframe. Perfect for traders who thrive on quick decisions and small, consistent profits, this strategy combines multiple indicators to deliver razor-sharp entries and exits—ideal for India’s dynamic market.
#### **Why This Strategy Stands Out**
- **Pinpoint Accuracy**: Harness the synergy of the **5 EMA and 10 EMA crossover** to lock onto the short-term trend, while the **Stochastic Oscillator (14,3,3)** times your entries and exits with surgical precision.
- **Fast and Effective**: Tailored for the 1-minute chart, this strategy capitalizes on Nifty’s volatility, targeting **10-point profits** with a tight **5-point stop-loss**—keeping your risk low and rewards high.
- **Trend + Momentum**: Blend trend-following (EMAs) with momentum signals (Stochastic) for a robust, multi-dimensional approach that cuts through market noise.
#### **How It Works**
- **Buy Signal**: Enter long when the 5 EMA crosses above the 10 EMA and the Stochastic rises above 20—catching the uptrend at its sweet spot.
- **Sell Signal**: Go short when the 5 EMA dips below the 10 EMA and the Stochastic falls below 80—riding the downtrend with confidence.
- **Exit Like a Pro**: Take profits at 10 points or when the Stochastic hits overbought/oversold extremes, ensuring you’re in and out before the market shifts.
#### **Perfect for Nifty Scalpers**
Built for the fast-paced world of Nifty trading, this strategy shines during high-volatility sessions like the market open or global overlaps. Whether you’re a beginner honing your skills or a seasoned trader seeking consistency, the Sniper Scalping Strategy offers a clear, actionable framework to scalp profits with discipline and precision.
#### **Get Started**
Test it in a demo account, refine it to your style, and watch your scalping game soar. Trade smart, stay focused, and let the Sniper Scalping Strategy turn Nifty’s 1-minute moves into your edge!
MA Crossover Buy/Sell Signals//@version=5
indicator("MA Crossover Buy/Sell Signals", overlay=true)
// Input for moving average lengths
fastLength = input.int(9, title="Fast MA Length", minval=1)
slowLength = input.int(21, title="Slow MA Length", minval=1)
// Calculate moving averages
fastMA = ta.sma(close, fastLength)
slowMA = ta.sma(close, slowLength)
// Define buy and sell conditions
buySignal = ta.crossover(fastMA, slowMA)
sellSignal = ta.crossunder(fastMA, slowMA)
// Plot moving averages on the chart
plot(fastMA, color=color.blue, title="Fast MA")
plot(slowMA, color=color.red, title="Slow MA")
// Plot buy and sell signals
plotshape(buySignal, title="Buy", location=location.belowbar, color=color.green, style=shape.triangleup, size=size.small)
plotshape(sellSignal, title="Sell", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small)
MOPS Indicator - Master of ProfitsWhat this Script Does
1. Quick Buy (QB)
Conditions:
MACD crossover
RSI < 50
Trend is up (EMA50 > EMA200)
➡️ Places a label below the bar:
"QB Entry: xxx SL: xxx | TP: xxx | R:R"
2. Quick Sell (QS)
Conditions:
MACD crossunder
RSI > 50
Trend is down (EMA50 < EMA200)
➡️ Label appears above the bar.
3. Close Quick Buy (QBC)
When the previous candle had QB and now a MACD crossunder happens.
➡️ Label "QBC" above bar to close long.
4. Close Quick Sell (QSC)
Previous candle had QS and now MACD crossover.
➡️ Label "QSC" below bar to close short.
5. Bull Buy (BullB)
When price crosses above middle Bollinger Band + MACD cross + price between BB Middle & Upper + MACD above zero.
➡️ Entry label below bar.
6. Bear Sell (BearS)
Opposite logic to BullB, label above bar.
7. Close BullB / Close BearS
Opposite exit signals using price movement and MACD.
8. Swing Buy / Swing Sell
When price breaks Fibonacci retracement levels with trend confirmation.
Raman Ka IndicatorSell Side indicator. this is additional confirmation for trade where there is momentum. dont trade basis this indicator, use this as a extra confirmation to get trades sell side only
Heikin Ashi Buy/Sell with Custom TimeframeSimple indicator that can catch trend,it helps to catch trends,prevent noise and uses heikin ashi calculation
RSI + BB %B Modify V2.0Hi,
I have created an indicator with combine of RSI and Bollinger Band %B.
RSI settings has been altered for best result. RSI Length is 25. Also BB %B ha been customized, Value is 50 instead of 20.
This indicator need to used with EMA ribbon, 10-20-50 and 200.
I believe that you will figure out the setup.
Thanks.
Support & Resistance LevelsSupport & Resistance Levels (MTF) is an indicator that highlights key support and resistance zones using data from higher timeframes. It helps traders spot strong price levels and align entries with the broader market trend.
RSI + VWAP + MA + Volume Signalsa script using a good level of rsi with much filtrations from MA and vwap
5M Pro Toolkit Ultimate by dnnfafx🎯 Script Purpose
This script is a multi-indicator trading toolkit designed for use on the 5-minute chart (5M timeframe). It combines trend filters, momentum indicators, volume spikes, support/resistance levels, and candlestick pattern detection to assist in technical analysis and provide potential confluence signals for entries.
📌 Main Components
1. User Inputs
Allows users to customize key indicator settings:
EMA lengths (Short and Long)
RSI period
MACD parameters (fast, slow, signal)
Volume spike multiplier
Pivot left/right bar count
2. Trend Filter: EMA 50 and EMA 200
pine
Salin
Edit
emaShort = ta.ema(close, emaShortLen)
emaLong = ta.ema(close, emaLongLen)
Determines the trend direction.
EMA 50 (orange) and EMA 200 (blue) are plotted on the main chart.
3. RSI (Relative Strength Index)
pine
Salin
Edit
rsi = ta.rsi(close, rsiLen)
Measures price momentum.
Horizontal lines at 70 (Overbought) and 30 (Oversold) for quick reference.
4. MACD Histogram
pine
Salin
Edit
= ta.macd(close, macdFast, macdSlow, macdSignal)
macdHist = macdLine - signalLine
Plots the MACD histogram as vertical bars.
Useful for identifying trend strength and potential reversals.
5. Volume Spike Detection
pine
Salin
Edit
volSpike = volume > volMA * volMultiplier
Detects significant volume surges compared to the 20-period volume average.
Displays a red triangle below the candle when a spike occurs.
6. Support & Resistance (Pivot High/Low)
pine
Salin
Edit
pivotHigh = ta.pivothigh(high, pivotLeft, pivotRight)
pivotLow = ta.pivotlow(low, pivotLeft, pivotRight)
Automatically detects local highs (resistance) and lows (support) using pivot logic.
Resistance lines in red, Support lines in green.
7. Candlestick Pattern Detection
Identifies four popular patterns:
Bullish Engulfing (green label "Engulf" below the bar)
Bearish Engulfing (red label "Engulf" above the bar)
Hammer (lime triangle)
Shooting Star (fuchsia triangle)
8. Confluence Entry Logic (Incomplete)
pine
Salin
Edit
buyCond = rsi
This section is currently incomplete.
It's likely intended to define a buy condition based on the confluence of RSI, MACD, EMA trend, volume spike, and candlestick patterns.
🧩 Conclusion
This toolkit is an all-in-one solution for intraday 5-minute trading, combining trend, momentum, volume, price action, and pattern recognition. While the entry logic (buyCond) is not yet finished, the structure is well laid out and can serve as the foundation for a manual or automated trading strategy.
EMA + MA + Daily Pivot Levels + Supertrend
🔹 20 EMA – A fast-moving average to track short-term trend
🔹 100 & 200 SMA – Long-term trend indicators
🔹 Daily Pivot Levels – PDH, PDL, Pivot Point, R1, S1
🔹 Supertrend (10, 2) – Trend-following signal with color-coded direction
Iron Condor Sideways Market Detector📘 Description: Iron Condor Sideways Market Detector
This indicator helps option traders find sideways markets for Iron Condor strategy.
🔍 What it does:
📏 Detects when the market is moving in a small range.
✅ Gives a signal when the price is not trending and staying flat.
📉 Shows a label below the candle when conditions are right for an Iron Condor setup.
📊 How it works:
RSI between 40 and 60
→ Market is not overbought or oversold.
ADX below 25
→ Market has low trend strength.
Bollinger Band width is small
→ Price volatility is low.
Price range is within a fixed %
→ Market is moving inside a tight range.
🔔 Alerts:
You get an alert when all sideways conditions are true.
Great for planning neutral option strategies like Iron Condor.
---------------------------------------------------------------------------
⚠️ Risk Disclaimer
📈 Trading involves risk. Always trade with proper knowledge and money management.
💸 You can lose part or all of your capital. Only invest what you can afford to lose.
🧠 This indicator is a tool, not a guarantee of profit.
🕵️♂️ Always verify signals with your own analysis before taking any position.
🛠️ Past performance of any strategy or tool does not guarantee future results.
📊 Options strategies like Iron Condor require understanding of option greeks, volatility, and risk/reward balance.
Supertrend + Fair Value Gap [Combined]//@version=5
indicator("Supertrend + Fair Value Gap ", overlay = true, max_lines_count = 500, max_boxes_count = 500)
// === SUPER TREND ===
atrPeriod = input.int(10, "ATR Length", minval = 1)
factor = input.float(3.0, "Factor", minval = 0.01, step = 0.01)
= ta.supertrend(factor, atrPeriod)
supertrend := bar_index == 0 ? na : supertrend
upTrend = plot(direction < 0 ? supertrend : na, "Up Trend", color=color.green, style=plot.style_linebr)
downTrend = plot(direction < 0 ? na : supertrend, "Down Trend", color=color.red, style=plot.style_linebr)
bodyMiddle = plot(bar_index == 0 ? na : (open + close) / 2, "Body Middle", display=display.none)
fill(bodyMiddle, upTrend, title="Uptrend background", color=color.new(color.green, 90), fillgaps=false)
fill(bodyMiddle, downTrend, title="Downtrend background", color=color.new(color.red, 90), fillgaps=false)
alertcondition(direction > direction, title='Downtrend to Uptrend', message='The Supertrend value switched from Downtrend to Uptrend')
alertcondition(direction < direction, title='Uptrend to Downtrend', message='The Supertrend value switched from Uptrend to Downtrend')
alertcondition(direction != direction, title='Trend Change', message='The Supertrend value switched trend')
// === FAIR VALUE GAP ===
thresholdPer = input.float(0, "FVG Threshold %", minval=0, maxval=100, step=.1, inline='threshold')
auto = input.bool(false, "Auto", inline='threshold')
showLast = input.int(0, "Unmitigated Levels", minval=0)
mitigationLevels = input.bool(false, "Mitigation Levels")
tf = input.timeframe('', "FVG Timeframe")
extend = input.int(20, "Extend", minval=0, inline='extend', group="Style")
dynamic = input.bool(false, "Dynamic", inline='extend', group="Style")
bullCss = input.color(color.new(#089981, 70), "Bullish FVG", group="Style")
bearCss = input.color(color.new(#f23645, 70), "Bearish FVG", group="Style")
showDash = input.bool(false, "Show Dashboard", group="Dashboard")
dashLoc = input.string("Top Right", "Location", options= , group="Dashboard")
textSize = input.string("Small", "Text Size", options= , group="Dashboard")
type fvg
float max
float min
bool isbull
int t = time
method tosolid(color id) => color.rgb(color.r(id), color.g(id), color.b(id))
n = bar_index
detect() =>
var new_fvg = fvg.new(na, na, na, na)
threshold = auto ? ta.cum((high - low) / low) / bar_index : thresholdPer / 100
bull_fvg = low > high and close > high and (low - high ) / high > threshold
bear_fvg = high < low and close < low and (low - high) / high > threshold
if bull_fvg
new_fvg := fvg.new(low, high , true)
else if bear_fvg
new_fvg := fvg.new(low , high, false)
var float max_bull_fvg = na, var float min_bull_fvg = na, var bull_count = 0, var bull_mitigated = 0
var float max_bear_fvg = na, var float min_bear_fvg = na, var bear_count = 0, var bear_mitigated = 0
var t = 0
var fvg_records = array.new(0)
var fvg_areas = array.new(0)
= request.security(syminfo.tickerid, tf, detect())
if bull_fvg and new_fvg.t != t
if dynamic
max_bull_fvg := new_fvg.max
min_bull_fvg := new_fvg.min
if not dynamic
fvg_areas.unshift(box.new(n - 2, new_fvg.max, n + extend, new_fvg.min, na, bgcolor=bullCss))
fvg_records.unshift(new_fvg)
bull_count += 1
t := new_fvg.t
else if dynamic
max_bull_fvg := math.max(math.min(close, max_bull_fvg), min_bull_fvg)
if bear_fvg and new_fvg.t != t
if dynamic
max_bear_fvg := new_fvg.max
min_bear_fvg := new_fvg.min
if not dynamic
fvg_areas.unshift(box.new(n - 2, new_fvg.max, n + extend, new_fvg.min, na, bgcolor=bearCss))
fvg_records.unshift(new_fvg)
bear_count += 1
t := new_fvg.t
else if dynamic
min_bear_fvg := math.min(math.max(close, min_bear_fvg), max_bear_fvg)
// Mitigation logic
if fvg_records.size() > 0
for i = fvg_records.size() - 1 to 0
get = fvg_records.get(i)
if get.isbull and close < get.min
if mitigationLevels
line.new(get.t, get.min, time, get.min, xloc.bar_time, color=bullCss, style=line.style_dashed)
if not dynamic
area = fvg_areas.remove(i)
area.delete()
fvg_records.remove(i)
bull_mitigated += 1
else if not get.isbull and close > get.max
if mitigationLevels
line.new(get.t, get.max, time, get.max, xloc.bar_time, color=bearCss, style=line.style_dashed)
if not dynamic
area = fvg_areas.remove(i)
area.delete()
fvg_records.remove(i)
bear_mitigated += 1
// Unmitigated lines
var unmitigated = array.new(0)
if barstate.islast and showLast > 0 and fvg_records.size() > 0
for element in unmitigated
element.delete()
unmitigated.clear()
for i = 0 to math.min(showLast - 1, fvg_records.size() - 1)
get = fvg_records.get(i)
unmitigated.push(line.new(get.t, get.isbull ? get.min : get.max, time, get.isbull ? get.min : get.max, xloc.bar_time, color=get.isbull ? bullCss : bearCss))
// Dashboard
var table_position = dashLoc == 'Bottom Left' ? position.bottom_left : dashLoc == 'Top Right' ? position.top_right : position.bottom_right
var table_size = textSize == 'Tiny' ? size.tiny : textSize == 'Small' ? size.small : size.normal
var tb = table.new(table_position, 3, 3, bgcolor=#1e222d, border_color=#373a46, border_width=1, frame_color=#373a46, frame_width=1)
if showDash
if bar_index == 0
tb.cell(1, 0, "Bullish", text_color=bullCss.tosolid(), text_size=table_size)
tb.cell(2, 0, "Bearish", text_color=bearCss.tosolid(), text_size=table_size)
tb.cell(0, 1, "Count", text_color=color.white, text_size=table_size)
tb.cell(0, 2, "Mitigated", text_color=color.white, text_size=table_size)
if barstate.islast
tb.cell(1, 1, str.tostring(bull_count), text_color=bullCss.tosolid(), text_size=table_size)
tb.cell(2, 1, str.tostring(bear_count), text_color=bearCss.tosolid(), text_size=table_size)
tb.cell(1, 2, str.tostring(bull_mitigated / bull_count * 100, format.percent), text_color=bullCss.tosolid(), text_size=table_size)
tb.cell(2, 2, str.tostring(bear_mitigated / bear_count * 100, format.percent), text_color=bearCss.tosolid(), text_size=table_size)
// Plots for dynamic
max_bull_plot = plot(max_bull_fvg, color=na)
min_bull_plot = plot(min_bull_fvg, color=na)
fill(max_bull_plot, min_bull_plot, color=bullCss)
max_bear_plot = plot(max_bear_fvg, color=na)
min_bear_plot = plot(min_bear_fvg, color=na)
fill(max_bear_plot, min_bear_plot, color=bearCss)
// Alerts
alertcondition(bull_count > bull_count , "Bullish FVG", "Bullish FVG detected")
alertcondition(bear_count > bear_count , "Bearish FVG", "Bearish FVG detected")
alertcondition(bull_mitigated > bull_mitigated , "Bullish FVG Mitigation", "Bullish FVG mitigated")
alertcondition(bear_mitigated > bear_mitigated , "Bearish FVG Mitigation", "Bearish FVG mitigated")
EMA 34 Crossover with Break Even Stop LossEMA 34 Crossover with Break Even Stop Loss Strategy
This trading strategy is based on the 34-period Exponential Moving Average (EMA) and aims to enter long positions when the price crosses above the EMA 34. The strategy is designed to manage risk effectively with a dynamic stop loss and take-profit mechanism.
Key Features:
EMA 34 Crossover:
The strategy generates a long entry signal when the closing price of the current bar crosses above the 34-period EMA, with the condition that the previous closing price was below the EMA. This crossover indicates a potential upward trend.
Risk Management:
Upon entering a trade, the strategy sets a stop loss at the low of the previous bar. This helps in controlling the downside risk.
A take profit level is set at a 10:1 risk-to-reward ratio, meaning the potential profit is ten times the amount risked on the trade.
Break-even Stop Loss:
As the price moves in favor of the trade and reaches a 3:1 risk-to-reward ratio, the strategy moves the stop loss to the entry price (break-even). This ensures that no loss will be incurred if the market reverses, effectively protecting profits.
Exit Conditions:
The strategy exits the trade when either the stop loss is hit (if the price drops below the stop loss level) or the take profit target is reached (if the price rises to the take profit level).
If the price reaches the break-even level (entry price), the stop loss is adjusted to lock in profits and prevent any loss.
Visualization:
The stop loss and take profit levels are plotted on the chart for easy visualization, helping traders track the status of their trade.
Trade Management Summary:
Long Entry: When price crosses above the 34-period EMA.
Stop Loss: Set to the low of the previous candle.
Take Profit: Set to a 10:1 risk-to-reward ratio.
Break-even: Stop loss is moved to entry price when a 3:1 risk-to-reward ratio is reached.
Exit: The trade is closed either when the stop loss or take profit levels are hit.
This strategy is designed to minimize losses by employing a dynamic stop loss and to maximize gains by setting a favorable risk-to-reward ratio, making it suitable for traders who prefer a structured, automated approach to risk management and trend-following.
Trend Break + Fibonacci + RSI Filter//@version=5
indicator("Trend Break + Fibonacci + RSI Filter", overlay=true)
// === INPUTS ===
lookback = input.int(100, title="Lookback период для минимума/максимума")
rsiLen = input.int(14, title="RSI Length")
rsiShortLevel = input.int(55, title="RSI Min для Шорта (на ретесте)")
rsiLongLevel = input.int(45, title="RSI Max для Лонга (на ретесте)")
// === PRICE EXTREMES ===
var float hi = na
var float lo = na
hi := ta.highest(close, lookback)
lo := ta.lowest(close, lookback)
// === FIB LEVELS ===
fib0 = hi
fib1 = lo
fib0382 = fib1 + (fib0 - fib1) * 0.382
fib05 = fib1 + (fib0 - fib1) * 0.5
fib0618 = fib1 + (fib0 - fib1) * 0.618
// === RSI ===
rsi = ta.rsi(close, rsiLen)
// === EMA TREND (вместо трендовой линии как пример) ===
fastEMA = ta.ema(close, 8)
slowEMA = ta.ema(close, 21)
// === CONDITIONS ===
// Пробой EMA-линии (как замена отбойной трендовой)
breakDown = ta.crossunder(fastEMA, slowEMA)
breakUp = ta.crossover(fastEMA, slowEMA)
// Ретест фибо зоны (внутри 0.382–0.5)
inFibZoneShort = close < fib0382 and close > fib05
inFibZoneLong = close > fib0382 and close < fib05
// RSI фильтр
validRSI_short = rsi > rsiShortLevel
validRSI_long = rsi < rsiLongLevel
// === TRADING SIGNALS ===
shortSignal = breakDown and inFibZoneShort and validRSI_short
longSignal = breakUp and inFibZoneLong and validRSI_long
// === PLOTS ===
plotshape(shortSignal, location=location.abovebar, color=color.red, style=shape.labeldown, text="SHORT")
plotshape(longSignal, location=location.belowbar, color=color.green, style=shape.labelup, text="LONG")
plot(fib0, title="Fibo 0", color=color.gray)
plot(fib0382, title="Fibo 0.382", color=color.orange)
plot(fib05, title="Fibo 0.5", color=color.orange)
plot(fib0618, title="Fibo 0.618", color=color.orange)
plot(fib1, title="Fibo 1", color=color.gray)
// === ALERTS ===
alertcondition(shortSignal, title="Short Signal", message="💥 SHORT сигнал!")
alertcondition(longSignal, title="Long Signal", message="🚀 LONG сигнал!")
LUX CLARA - EMA + VWAP (No ATR Filter) - v6EMA STRAT SHOUT OUTOUTLIERSSSSS
Overview:
an intraday strategy built around two core principles:
Trend Confirmation using the 50 EMA (Exponential Moving Average) in relation to the VWAP (Volume-Weighted Average Price).
Entry Signals triggered by the 8 EMA crossing the 50 EMA in the direction of that confirmed trend.
Key Logic:
Bullish Trend if the 50 EMA is above VWAP. Only long entries are allowed when the 8 EMA crosses above the 50 EMA during that bullish phase.
Bearish Trend if the 50 EMA is below VWAP. Only short entries are allowed when the 8 EMA crosses below the 50 EMA during that bearish phase.
Intraday Focus: Trades are restricted to a user-defined session window (default 7:30 AM–11:30 AM), aligning entries/exits with peak intraday liquidity.
Exit Rule: Positions close automatically when the 8 EMA crosses back in the opposite direction of the entry.
Why It Works:
EMA + VWAP helps detect both immediate momentum (EMAs) and overall institutional bias (VWAP).
By confining trades to a set intraday window, the strategy aims to capture morning volatility while avoiding choppy afternoon or overnight sessions.
Customization:
Users can adjust EMA lengths, session times, or incorporate stops/targets for additional risk management.
It can be tested on various symbols and intraday timeframes to gauge performance and robustness.
