Get started

Chart patterns

Smart Directional Fib Zone (Selectable Session)🎯 Overview This indicator plots a dynamic Fibonacci zone between the 0.5 and 0.618 levels , calculated from the previous day’s price action , and is designed specifically for intraday traders. It visually highlights key retracement or reaction areas where the market often pauses or reverses. 🔍 How it works At the start of each day, the script automatically captures: the previous day’s open (pdo), high (pdh), low (pdl), and close (pdc). It then determines if the previous day was bullish (Close > Open) or bearish (Close < Open). Based on that: If the previous day was bullish, it projects the Fibonacci levels down from the high (typical for expecting retracements). If bearish, it projects them up from the low. The two key levels are: 0.5 (50%) retracement / projection 0.618 (61.8%) retracement / projection A colored zone is plotted between these levels to act as a leading guide for intraday setups. ⏰ Time filtering & session customization A unique feature is the dynamic session filtering: By default, the zone is only plotted during active market hours, keeping your chart clean outside trading hours. The script provides a dropdown selector so you can quickly switch between: India session (9:15 to 15:30) Europe session (9:00 to 17:30) US session (9:30 to 16:00) Or even define your own custom session times. This makes it ideal for intraday traders in any region. 🎨 Visual features The fill zone changes color based on the previous day’s sentiment: Green zone if the previous day was bullish Red zone if the previous day was bearish 🚨 Alerts The script includes an alert condition, so you can easily set up TradingView alerts to notify you when: Price enters the Fibonacci zone. This is extremely helpful for catching retracements or reversals without staring at the screen all day. ⚙️ How to use ✅ Works on any intraday timeframe (1 min, 5 min, 15 min, etc.). ✅ Simply add it to your chart, pick your session in the dropdown, and watch the Fibonacci zone automatically adjust to your selected market hours. Use it as a confluence tool alongside other indicators like VWAP, EMAs, Bollinger Bands, or price action patterns to time entries and exits. 💪 Why this is powerful This is more than a simple Fib retracement tool: It dynamically adapts to the previous day’s sentiment, helping you trade in alignment with recent market psychology. The session filtering ensures your charts are focused only on the periods
Pine Script® indicator
by JS_Trading_Tradingmadesimple
Silver Bullet🎯 Silver Bullet Macro Time & Bias Framework The Silver Bullet script is a complete framework for identifying high-probability trading windows and directional bias, inspired by ICT concepts. ✅ Key Features: • Macro Sessions Detection – Automatically identifies key time windows (ICT Killzones or custom hours) on any timeframe. • Dynamic Session Boxes – Visual boxes marking each session’s high/low range. • Bias Calculation – Determines Long or Short bias using price action within the session. • Fibonacci Levels – Automatically draws Fibonacci retracements and extensions relative to session ranges. • Adaptive Labels & Tables – Clear labels showing session range, bias, entry, target, and stop levels. • Customizable Timezones & Styles – Supports all chart timezones, different text sizes, and flexible display positions. ⸻ 📈 Optimized for the 5-Minute Chart, but can be applied to other intraday timeframes. 🌐 Learn more & contact support: www.macrobullet.trade
Pine Script® indicator
by MacroBullet
The Essa System V1.5The Essa System V1.5 Overview The Essa System is a comprehensive trading strategy and backtesting tool designed for traders who use market structure and Fibonacci retracements. It automatically identifies significant trading ranges, calculates key retracement levels, and then backtests a complete trading strategy based on entries at these levels. This is more than just an indicator; it's a full suite of analytical tools designed to help you develop, test, and analyze a complete trading plan directly on your chart. How It Works The system's logic is based on a classic price action concept: Range Detection: First, it automatically identifies a significant trading range by finding the highest high and lowest low based on pivot points over a user-defined lookback period. Fibonacci Analysis: Once the range direction (bullish or bearish) is established, the script calculates and displays key Fibonacci retracement levels (50%, 61.8%, 70.5%, and 78.6%). Trade Execution: The system then looks for historical and live trading opportunities, entering a trade when the price pulls back to one of the enabled Fibonacci levels. All trades are managed with a predefined Stop Loss and Take Profit in pips. Key Features Automatic Range & Fibonacci Analysis: Automatically draws the primary trading range and key Fib levels, updating as market structure evolves. Historical Backtesting: Plots all historical trade entries based on the strategy rules, allowing for a complete performance review over the chosen chart history. Detailed Trade Visuals: Displays active trades on the chart with clear lines and boxes for entry, stop loss, and take profit zones. Advanced Session Filtering: Allows you to isolate trades to specific market sessions (London, New York, Asia) with timezone support and daily trade limits. Built-in Risk Management: A cornerstone of the system. It automatically calculates the required position size for each trade based on your specified Account Size, Risk Percentage, and Stop Loss. Comprehensive Performance Tables: The script includes two powerful analytical tables: Trade Helper Table: Shows the status of live or potential upcoming trades, including entry/SL/TP prices and the calculated position size. History Table: Logs all recent trades and calculates key statistics like Profit Factor, Win Rate, and the overall PnL impact on your account balance. Customizable Strategy: Fine-tune every aspect of the strategy with inputs for the lookback period, SL/TP in pips, which Fib levels are tradable, and a cooldown timer to prevent over-trading. How to Use Add the indicator to your chart. Navigate to the settings and, under "Account Settings," configure your Account Size and Risk Per Trade (%). This is essential for the PnL and position sizing calculations to be meaningful. Under "Session Filter Settings," adjust the sessions you wish to trade. Analyze the historical trades and the performance tables to understand the strategy's behaviour on your chosen asset and timeframe. Disclaimer: This is a tool for strategy analysis and backtesting. It is not financial advice. Past performance is not indicative of future results. Always use proper risk management.
Pine Script® indicator
by Essa02
1
Lum3n Reversal IndicatorLum3n Reversal Indicator The Lum3n Reversal Indicator is a dynamic, multi-signal tool built to identify high-probability market reversals. It combines classic candlestick pattern recognition with RSI exhaustion levels, volume spikes, trend confirmation, and support zone proximity to generate actionable buy and sell signals—each scored with a confidence value. Key Features Comprehensive Pattern Detection: Identifies bullish and bearish patterns including hammers, engulfing candles, stars, tweezers, and doji types. RSI Filtering System: Uses configurable RSI levels to differentiate between weak, strong, and extreme signals. Trend Confirmation Engine: Incorporates smoothed stochastic logic to filter signals based on broader trend conditions. Volume Spike Detection: Confirms signal strength by detecting high-volume events above the 20-period average. Support-Based Buy Logic: Two customizable support levels allow the script to detect price rejection at key areas. Halo Pulse Visualization: Highlights ultra-high-confidence setups (strength ≥ 120) with transparent bubble markers. Signal Labels with Score: All valid buy/sell signals are marked on the chart with confidence scores for easy filtering. Optional Gradient Candle Coloring: Dynamically colors candles based on trend strength for visual clarity. Built-in Alerts: Includes alert conditions for standard and high-conviction Lum3n Buy/Sell triggers. How to Use It Buy signals appear when bullish candlestick patterns align with oversold RSI levels, trend confirmation, volume surges, and proximity to key support levels. Sell signals are generated from bearish pattern setups combined with RSI overbought conditions and bearish trend-volume alignment. Confidence scores range based on how many conditions align. High-conviction setups will be scored above 100, with 120+ triggering the Halo Pulse visualization. Best used with additional confirmation such as trendlines, moving averages, or higher-timeframe structure. Customizable Inputs Support zones and RSI thresholds Trend sensitivity and volume filter strength Bullish and bearish color themes Optional candle coloring toggle for cleaner charts
Pine Script® indicator
by Lum3n
ZakionBitcoin Trailing Stop StrategyThe trailing stop indicator dynamically adjusts stop-loss (SL) levels to lock in profits as price moves favorably. It uses pivot levels and ATR to set optimal SL points, balancing risk and reward. Trade confirmation filters, a key feature, ensure entries align with market conditions, reducing false signals. In 2023 a study showed filtered entries improve win rates by 15% in forex. This enhances trade precision. SL settings, ranging from very tight to very wide, adapt to volatility via ATR calculations. These settings anchor SL to previous pivot levels, ensuring alignment with market structure. This caters to diverse trading styles, from scalping to swing trading. The indicator colors the profit zone between the entry point (EP) and SL, using light green for buy trades and light red for sell trades. This visual cue highlights profit potential. It’s ideal for traders seeking dynamic risk management. A table displays real-time trade details, including EP, SL, and profit/loss (PNL). Backtests show trailing stops cut losses by 20% in trending markets. This transparency aids decision-making.
Pine Script® strategy
by ZakionBitcoin
Price Action Concepts [StratifyTrade]// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) creativecommons.org // © StratifyTrade - formerly know as HunterAlgos //@version=5 indicator("Price Action Concepts ", shorttitle = "Price Action Concepts ", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500, max_bars_back = 500, max_polylines_count = 100) //-----------------------------------------------------------------------------{ //Boolean set //-----------------------------------------------------------------------------{ s_BOS = 0 s_CHoCH = 1 i_BOS = 2 i_CHoCH = 3 i_pp_CHoCH = 4 green_candle = 5 red_candle = 6 s_CHoCHP = 7 i_CHoCHP = 8 boolean = array.from( false , false , false , false , false , false , false , false , false ) //-----------------------------------------------------------------------------{ // User inputs //-----------------------------------------------------------------------------{ show_swing_ms = input.string ("All" , "Swing        " , inline = "1", group = "MARKET STRUCTURE" , options = ) show_internal_ms = input.string ("All" , "Internal     " , inline = "2", group = "MARKET STRUCTURE" , options = ) internal_r_lookback = input.int (5 , "" , inline = "2", group = "MARKET STRUCTURE" , minval = 2) swing_r_lookback = input.int (50 , "" , inline = "1", group = "MARKET STRUCTURE" , minval = 2) ms_mode = input.string ("Manual" , "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE" , tooltip = " Use selected lenght Use automatic lenght" ,options = ) show_mtf_str = input.bool (true , "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE" , tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green = Bullish. Red = Bearish") show_eql = input.bool (false , "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE") plotcandle_bool = input.bool (false , "Plotcandle" , inline = "3", group = "MARKET STRUCTURE" , tooltip = "Displays a cleaner colored candlestick chart in place of the default candles. (requires hiding the current ticker candles)") barcolor_bool = input.bool (false , "Bar Color" , inline = "4", group = "MARKET STRUCTURE" , tooltip = "Color the candle bodies according to market strucutre trend") i_ms_up_BOS = input.color (#089981 , "" , inline = "2", group = "MARKET STRUCTURE") i_ms_dn_BOS = input.color (#f23645 , "" , inline = "2", group = "MARKET STRUCTURE") s_ms_up_BOS = input.color (#089981 , "" , inline = "1", group = "MARKET STRUCTURE") s_ms_dn_BOS = input.color (#f23645 , "" , inline = "1", group = "MARKET STRUCTURE") lvl_daily = input.bool (false , "Day   " , inline = "1", group = "HIGHS & LOWS MTF") lvl_weekly = input.bool (false , "Week " , inline = "2", group = "HIGHS & LOWS MTF") lvl_monthly = input.bool (false , "Month" , inline = "3", group = "HIGHS & LOWS MTF") lvl_yearly = input.bool (false , "Year  " , inline = "4", group = "HIGHS & LOWS MTF") css_d = input.color (color.blue , "" , inline = "1", group = "HIGHS & LOWS MTF") css_w = input.color (color.blue , "" , inline = "2", group = "HIGHS & LOWS MTF") css_m = input.color (color.blue , "" , inline = "3", group = "HIGHS & LOWS MTF") css_y = input.color (color.blue , "" , inline = "4", group = "HIGHS & LOWS MTF") s_d = input.string ('⎯⎯⎯' , '' , inline = '1', group = 'HIGHS & LOWS MTF' , options = ) s_w = input.string ('⎯⎯⎯' , '' , inline = '2', group = 'HIGHS & LOWS MTF' , options = ) s_m = input.string ('⎯⎯⎯' , '' , inline = '3', group = 'HIGHS & LOWS MTF' , options = ) s_y = input.string ('⎯⎯⎯' , '' , inline = '4', group = 'HIGHS & LOWS MTF' , options = ) ob_show = input.bool (true , "Show Last    " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volumetric order blocks on the chart Ammount of volumetric order blocks to show") ob_num = input.int (5 , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Orderblocks number", minval = 1, maxval = 10) ob_metrics_show = input.bool (true , "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volume metrics that have formed the orderblock") css_metric_up = input.color (color.new(#089981, 50) , "         " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS") css_metric_dn = input.color (color.new(#f23645 , 50) , "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS") ob_swings = input.bool (false , "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display swing volumetric order blocks") css_swing_up = input.color (color.new(color.gray , 90) , "                 " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS") css_swing_dn = input.color (color.new(color.silver, 90) , "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS") ob_filter = input.string ("None" , "Filtering             " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options = ) ob_mitigation = input.string ("Absolute" , "Mitigation           " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Trigger to remove volumetric order blocks", options = ) ob_pos = input.string ("Precise" , "Positioning          " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Position of the Order Block Cover the whole candle Cover half candle Adjust to volatility Same as Accurate but more precise", options = ) use_grayscale = input.bool (false , "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Use gray as basic order blocks color") use_show_metric = input.bool (true , "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show volume associated with the orderblock and his relevance") use_middle_line = input.bool (true , "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show mid-line order blocks") use_overlap = input.bool (true , "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Hide overlapping order blocks") use_overlap_method = input.string ("Previous" , "Overlap Method    " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = " Preserve the most recent volumetric order blocks Preserve the previous volumetric order blocks", options = ) ob_bull_css = input.color (color.new(#089981 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS") ob_bear_css = input.color (color.new(#f23645 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS") show_acc_dist_zone = input.bool (false , "" , inline = "1", group = "Accumulation And Distribution") zone_mode = input.string ("Fast" , "" , inline = "1", group = "Accumulation And Distribution" , tooltip = " Find small zone pattern formation Find bigger zone pattern formation" ,options = ) acc_css = input.color (color.new(#089981 , 60) , "" , inline = "1", group = "Accumulation And Distribution") dist_css = input.color (color.new(#f23645 , 60) , "" , inline = "1", group = "Accumulation And Distribution") show_lbl = input.bool (false , "Show swing point" , inline = "1", group = "High and Low" , tooltip = "Display swing point") show_mtb = input.bool (false , "Show High/Low/Equilibrium" , inline = "2", group = "High and Low" , tooltip = "Display Strong/Weak High And Low and Equilibrium") toplvl = input.color (color.red , "Premium Zone   " , inline = "3", group = "High and Low") midlvl = input.color (color.white , "Equilibrium Zone" , inline = "4", group = "High and Low") btmlvl = input.color (#089981 , "Discount Zone    " , inline = "5", group = "High and Low") fvg_enable = input.bool (false , "        " , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap") what_fvg = input.string ("FVG" , "" , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap", options = ) fvg_num = input.int (5 , "Show Last  " , inline = "1a", group = "FAIR VALUE GAP" , tooltip = "Number of fvg to show") fvg_upcss = input.color (color.new(#089981, 80) , "" , inline = "1", group = "FAIR VALUE GAP") fvg_dncss = input.color (color.new(color.red , 80) , "" , inline = "1", group = "FAIR VALUE GAP") fvg_extend = input.int (10 , "Extend FVG" , inline = "2", group = "FAIR VALUE GAP" , tooltip = "Extend the display of the FVG.") fvg_src = input.string ("Close" , "Mitigation  " , inline = "3", group = "FAIR VALUE GAP" , tooltip = " Use the close of the body as trigger Use the extreme point of the body as trigger", options = ) fvg_tf = input.timeframe ("" , "Timeframe " , inline = "4", group = "FAIR VALUE GAP" , tooltip = "Timeframe of the fair value gap") t = color.t (ob_bull_css) invcol = color.new (color.white , 100) //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - UDT } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} type bar float o = open float c = close float h = high float l = low float v = volume int n = bar_index int t = time type Zphl line top line bottom label top_label label bottom_label bool stopcross bool sbottomcross bool itopcross bool ibottomcross string txtup string txtdn float topy float bottomy float topx float bottomx float tup float tdn int tupx int tdnx float itopy float itopx float ibottomy float ibottomx float uV float dV type FVG box box line ln bool bull float top float btm int left int right type ms float p int n float l type msDraw int n float p color css string txt bool bull type obC float top float btm int left float avg float dV float cV int wM int blVP int brVP int dir float h float l int n type obD box ob box eOB box blB box brB line mL type zone chart.point points float p int c int t type hqlzone box pbx box ebx box lbx label plb label elb label lbl type ehl float pt int t float pb int b type pattern string found = "None" bool isfound = false int period = 0 bool bull = false type alerts bool chochswing = false bool chochplusswing = false bool swingbos = false bool chochplus = false bool choch = false bool bos = false bool equal = false bool ob = false bool swingob = false bool zone = false bool fvg = false bool obtouch = false //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - End } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - General Setup } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} bar b = bar.new() var pattern p = pattern.new() alerts blalert = alerts.new() alerts bralert = alerts.new() if p.isfound p.period += 1 if p.period == 50 p.period := 0 p.found := "None" p.isfound := false p.bull := na switch b.c > b.o => boolean.set(green_candle, true) b.c < b.o => boolean.set(red_candle , true) f_zscore(src, lookback) => (src - ta.sma(src, lookback)) / ta.stdev(src, lookback) var int iLen = internal_r_lookback var int sLen = swing_r_lookback vv = f_zscore(((close - close ) / close ) * 100,iLen) if ms_mode == "Dynamic" switch vv >= 1.5 or vv <= -1.5 => iLen := 10 vv >= 1.6 or vv <= -1.6 => iLen := 9 vv >= 1.7 or vv <= -1.7 => iLen := 8 vv >= 1.8 or vv <= -1.8 => iLen := 7 vv >= 1.9 or vv <= -1.9 => iLen := 6 vv >= 2.0 or vv <= -2.0 => iLen := 5 => iLen var msline = array.new(0) iH = ta.pivothigh(high, iLen, iLen) sH = ta.pivothigh(high, sLen, sLen) iL = ta.pivotlow (low , iLen, iLen) sL = ta.pivotlow (low , sLen, sLen) //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - End } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - ARRAYS } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} hl () => = request.security(syminfo.tickerid , 'D' , hl() , lookahead = barmerge.lookahead_on) = request.security(syminfo.tickerid , 'W' , hl() , lookahead = barmerge.lookahead_on) = request.security(syminfo.tickerid , 'M' , hl() , lookahead = barmerge.lookahead_on) = request.security(syminfo.tickerid , '12M', hl() , lookahead = barmerge.lookahead_on) lstyle(style) => out = switch style '⎯⎯⎯' => line.style_solid '----' => line.style_dashed '····' => line.style_dotted mtfphl(h, l ,tf ,css, pdhl_style) => var line hl = line.new( na , na , na , na , xloc = xloc.bar_time , color = css , style = lstyle(pdhl_style) ) var line ll = line.new( na , na , na , na , xloc = xloc.bar_time , color = css , style = lstyle(pdhl_style) ) var label lbl = label.new( na , na , xloc = xloc.bar_time , text = str.format('P{0}L', tf) , color = invcol , textcolor = css , size = size.small , style = label.style_label_left ) var label hlb = label.new( na , na , xloc = xloc.bar_time , text = str.format('P{0}H', tf) , color = invcol , textcolor = css , size = size.small , style = label.style_label_left ) hy = ta.valuewhen(h != h , h , 1) hx = ta.valuewhen(h == high , time , 1) ly = ta.valuewhen(l != l , l , 1) lx = ta.valuewhen(l == low , time , 1) if barstate.islast extension = time + (time - time ) * 50 line.set_xy1(hl , hx , hy) line.set_xy2(hl , extension , hy) label.set_xy(hlb, extension , hy) line.set_xy1(ll , lx , ly) line.set_xy2(ll , extension , ly) label.set_xy(lbl, extension , ly) if lvl_daily mtfphl(pdh , pdl , 'D' , css_d, s_d) if lvl_weekly mtfphl(pwh , pwl , 'W' , css_w, s_w) if lvl_monthly mtfphl(pmh , pml, 'M' , css_m, s_m) if lvl_yearly mtfphl(pyh , pyl , '12M', css_y, s_y) //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - End } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - Market Structure } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} method darkcss(color css, float factor, bool bull) => blue = color.b(css) * (1 - factor) red = color.r(css) * (1 - factor) green = color.g(css) * (1 - factor) color.rgb(red, green, blue, 0) method f_line(msDraw d, size, style) => var line id = na var label lbl = na id := line.new( d.n , d.p , b.n , d.p , color = d.css , width = 1 , style = style ) if msline.size() >= 250 line.delete(msline.shift()) msline.push(id) lbl := label.new( int(math.avg(d.n, b.n)) , d.p , d.txt , color = invcol , textcolor = d.css , style = d.bull ? label.style_label_down : label.style_label_up , size = size , text_font_family = font.family_monospace ) structure(bool mtf) => msDraw drw = na bool isdrw = false bool isdrwS = false var color css = na var color icss = na var int itrend = 0 var int trend = 0 bool bull_ob = false bool bear_ob = false bool s_bull_ob = false bool s_bear_ob = false n = bar_index var ms up = ms.new( array.new() , array.new< int >() , array.new() ) var ms dn = ms.new( array.new() , array.new< int >() , array.new() ) var ms sup = ms.new( array.new() , array.new< int >() , array.new() ) var ms sdn = ms.new( array.new() , array.new< int >() , array.new() ) switch show_swing_ms "All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, true ) "CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, false ) "CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, true ) "BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false ) "None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false ) => na switch show_internal_ms "All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, true ) "CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, false) "CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, true ) "BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false) "None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false) => na switch iH => up.p.unshift(b.h ) up.l.unshift(b.h ) up.n.unshift(n ) iL => dn.p.unshift(b.l ) dn.l.unshift(b.l ) dn.n.unshift(n ) sL => sdn.p.unshift(b.l ) sdn.l.unshift(b.l ) sdn.n.unshift(n ) sH => sup.p.unshift(b.h ) sup.l.unshift(b.h ) sup.n.unshift(n ) // INTERNAL BULLISH STRUCTURE if up.p.size() > 0 and dn.l.size() > 1 if ta.crossover(b.c, up.p.first()) bool CHoCH = na string txt = na if itrend < 0 CHoCH := true switch not CHoCH => txt := "BOS" css := i_ms_up_BOS blalert.bos := true if boolean.get(i_BOS) and mtf == false and na(drw) isdrw := true drw := msDraw.new( up.n.first() , up.p.first() , i_ms_up_BOS , txt , true ) CHoCH => dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" : "CHoCH" css := i_ms_up_BOS.darkcss(0.25, true) if (dn.l.first() > dn.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw) isdrw := true drw := msDraw.new( up.n.first() , up.p.first() , i_ms_up_BOS.darkcss(0.25, true) , txt , true ) if mtf == false switch ob_filter == "None" => bull_ob := true ob_filter == "BOS" and txt == "BOS" => bull_ob := true ob_filter == "CHoCH" and txt == "CHoCH" => bull_ob := true ob_filter == "CHoCH+" and txt == "CHoCH+" => bull_ob := true itrend := 1 up.n.clear() up.p.clear() // INTERNAL BEARISH STRUCTURE if dn.p.size() > 0 and up.l.size() > 1 if ta.crossunder(b.c, dn.p.first()) bool CHoCH = na string txt = na if itrend > 0 CHoCH := true switch not CHoCH => bralert.bos := true txt := "BOS" css := i_ms_dn_BOS if boolean.get(i_BOS) and mtf == false and na(drw) isdrw := true drw := msDraw.new( dn.n.first() , dn.p.first() , i_ms_dn_BOS , txt , false ) CHoCH => if up.l.first() < up.l.get(1) bralert.chochplus := true else bralert.choch := true txt := up.l.first() < up.l.get(1) ? "CHoCH+" : "CHoCH" css := i_ms_dn_BOS.darkcss(0.25, false) if (up.l.first() < up.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw) isdrw := true drw := msDraw.new( dn.n.first() , dn.p.first() , i_ms_dn_BOS.darkcss(0.25, false) , txt , false ) if mtf == false switch ob_filter == "None" => bear_ob := true ob_filter == "BOS" and txt == "BOS" => bear_ob := true ob_filter == "CHoCH" and txt == "CHoCH" => bear_ob := true ob_filter == "CHoCH+" and txt == "CHoCH+" => bear_ob := true itrend := -1 dn.n.clear() dn.p.clear() // SWING BULLISH STRUCTURE if sup.p.size() > 0 and sdn.l.size() > 1 if ta.crossover(b.c, sup.p.first()) bool CHoCH = na string txt = na if trend < 0 CHoCH := true switch not CHoCH => blalert.swingbos := true txt := "BOS" icss := s_ms_up_BOS if boolean.get(s_BOS) and mtf == false and na(drw) isdrwS := true drw := msDraw.new( sup.n.first() , sup.p.first() , s_ms_up_BOS , txt , true ) CHoCH => if sdn.l.first() > sdn.l.get(1) blalert.chochplusswing := true else blalert.chochswing := true txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" : "CHoCH" icss := s_ms_up_BOS.darkcss(0.25, true) if (sdn.l.first() > sdn.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw) isdrwS := true drw := msDraw.new( sup.n.first() , sup.p.first() , s_ms_up_BOS.darkcss(0.25, true) , txt , true ) if mtf == false switch ob_filter == "None" => s_bull_ob := true ob_filter == "BOS" and txt == "BOS" => s_bull_ob := true ob_filter == "CHoCH" and txt == "CHoCH" => s_bull_ob := true ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bull_ob := true trend := 1 sup.n.clear() sup.p.clear() // SWING BEARISH STRUCTURE if sdn.p.size() > 0 and sup.l.size() > 1 if ta.crossunder(b.c, sdn.p.first()) bool CHoCH = na string txt = na if trend > 0 CHoCH := true switch not CHoCH => bralert.swingbos := true txt := "BOS" icss := s_ms_dn_BOS if boolean.get(s_BOS) and mtf == false and na(drw) isdrwS := true drw := msDraw.new( sdn.n.first() , sdn.p.first() , s_ms_dn_BOS , txt , false ) CHoCH => if sup.l.first() < sup.l.get(1) bralert.chochplusswing := true else bralert.chochswing := true txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" : "CHoCH" icss := s_ms_dn_BOS.darkcss(0.25, false) if (sup.l.first() < sup.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw) isdrwS := true drw := msDraw.new( sdn.n.first() , sdn.p.first() , s_ms_dn_BOS.darkcss(0.25, false) , txt , false ) if mtf == false switch ob_filter == "None" => s_bear_ob := true ob_filter == "BOS" and txt == "BOS" => s_bear_ob := true ob_filter == "CHoCH" and txt == "CHoCH" => s_bear_ob := true ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bear_ob := true trend := -1 sdn.n.clear() sdn.p.clear() = structure(false) if isdrw f_line(drw, size.small, line.style_dashed) if isdrwS f_line(drw, size.small, line.style_solid) = request.security("", "15" , structure(true)) = request.security("", "60" , structure(true)) = request.security("", "240" , structure(true)) = request.security("", "1440" , structure(true)) if show_mtf_str var tab = table.new(position = position.top_right, columns = 10, rows = 10, bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color = color.rgb(54, 58, 69, 100), border_width = 1) table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2) table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2) table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2) table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2) table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace) table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace) table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace) table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace) table.cell(tab, 0, 5, text = "Detected Pattern", text_halign = text.align_center, text_size = size.normal, text_color = color.silver, bgcolor = chart.bg_color, text_font_family = font.family_monospace) table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center, text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ? i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25, false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace) table.merge_cells(tab, 0, 5, 1, 5) table.merge_cells(tab, 0, 6, 1, 6) //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - End } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - Strong/Weak High/Low And Equilibrium } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} var phl = Zphl.new( na , na , label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style = label.style_label_down , size = size.tiny , text = "") , label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style = label.style_label_up , size = size.tiny , text = "") , true , true , true , true , "" , "" , 0 , 0 , 0 , 0 , high , low , 0 , 0 , 0 , 0 , 0 , 0 , na , na ) zhl(len)=> upper = ta.highest(len) lower = ta.lowest(len) var float out = 0 out := b.h > upper ? 0 : b.l < lower ? 1 : out top = out == 0 and out != 0 ? b.h : 0 btm = out == 1 and out != 1 ? b.l : 0 = zhl(sLen) = zhl(iLen) upphl(trend) => var label lbl = label.new( na , na , color = invcol , textcolor = toplvl , style = label.style_label_down , size = size.small ) if top phl.stopcross := true phl.txtup := top > phl.topy ? "HH" : "HL" if show_lbl topl = label.new( b.n - swing_r_lookback , top , phl.txtup , color = invcol , textcolor = toplvl , style = label.style_label_down , size = size.small ) line.delete(phl.top ) phl.top := line.new( b.n - sLen , top , b.n , top , color = toplvl) phl.topy := top phl.topx := b.n - sLen phl.tup := top phl.tupx := b.n - sLen if itop phl.itopcross := true phl.itopy := itop phl.itopx := b.n - iLen phl.tup := math.max(high, phl.tup) phl.tupx := phl.tup == high ? b.n : phl.tupx phl.uV := phl.tup != phl.tup ? b.v : phl.uV if barstate.islast line.set_xy1( phl.top , phl.tupx , phl.tup ) line.set_xy2( phl.top , b.n + 50 , phl.tup ) label.set_x( lbl , b.n + 50 ) label.set_y( lbl , phl.tup ) dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100 label.set_text (lbl, trend < 0 ? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)" : "Weak High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)") dnphl(trend) => var label lbl = label.new( na , na , color = invcol , textcolor = btmlvl , style = label.style_label_up , size = size.small ) if btm phl.sbottomcross := true phl.txtdn := btm > phl.bottomy ? "LH" : "LL" if show_lbl btml = label.new( b.n - swing_r_lookback , btm, phl.txtdn , color = invcol , textcolor = btmlvl , style = label.style_label_up , size = size.small ) line.delete(phl.bottom ) phl.bottom := line.new( b.n - sLen , btm , b.n , btm , color = btmlvl ) phl.bottomy := btm phl.bottomx := b.n - sLen phl.tdn := btm phl.tdnx := b.n - sLen if ibtm phl.ibottomcross := true phl.ibottomy := ibtm phl.ibottomx := b.n - iLen phl.tdn := math.min(low, phl.tdn) phl.tdnx := phl.tdn == low ? b.n : phl.tdnx phl.dV := phl.tdn != phl.tdn ? b.v : phl.dV if barstate.islast line.set_xy1( phl.bottom , phl.tdnx , phl.tdn ) line.set_xy2( phl.bottom , b.n + 50 , phl.tdn ) label.set_x( lbl , b.n + 50 ) label.set_y( lbl , phl.tdn ) dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100 label.set_text (lbl, trend > 0 ? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)" : "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)") midphl() => avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2()) var line l = line.new( y1 = avg , y2 = avg , x1 = b.n - sLen , x2 = b.n + 50 , color = midlvl , style = line.style_solid ) var label lbl = label.new( x = b.n + 50 , y = avg , text = "Equilibrium" , style = label.style_label_left , color = invcol , textcolor = midlvl , size = size.small ) if barstate.islast more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() + phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1() line.set_xy1(l , more , avg) line.set_xy2(l , b.n + 50, avg) label.set_x (lbl , b.n + 50 ) label.set_y (lbl , avg ) dist = math.abs((l.get_y2() - close) / close) * 100 label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) + "%)") hqlzone() => if barstate.islast var hqlzone dZone = hqlzone.new( box.new( na , na , na , na , bgcolor = color.new(toplvl, 70) , border_color = na ) , box.new( na , na , na , na , bgcolor = color.new(midlvl, 70) , border_color = na ) , box.new( na , na , na , na , bgcolor = color.new(btmlvl, 70) , border_color = na ) , label.new(na, na, text = "Premium" , color = invcol, textcolor = toplvl, style = label.style_label_down, size = size.small) , label.new(na, na, text = "Equilibrium", color = invcol, textcolor = midlvl, style = label.style_label_left, size = size.small) , label.new(na, na, text = "Discount" , color = invcol, textcolor = btmlvl, style = label.style_label_up , size = size.small) ) dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)) , phl.tup) dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup + 0.05 * phl.tdn) dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup + 0.475 * phl.tdn) dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn + 0.475 * phl.tup) dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn + 0.05 * phl.tup) dZone.lbx.set_rightbottom(b.n + 50 , phl.tdn) dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tup) dZone.elb.set_xy( int(b.n + 50) , math.avg(phl.tup, phl.tdn)) dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tdn) if show_mtb upphl (trend) dnphl (trend) hqlzone() //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - End } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - Volumetric Order Block } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} method eB(box b, bool ext, color css, bool swing) => b.unshift( box.new( na , na , na , na , xloc = xloc.bar_time , text_font_family = font.family_monospace , extend = ext ? extend.right : extend.none , border_color = swing ? color.new(css, 0) : color.new(color.white,100) , bgcolor = css , border_width = 1 ) ) method eL(line l, bool ext, bool solid, color css) => l.unshift( line.new( na , na , na , na , width = 1 , color = css , xloc = xloc.bar_time , extend = ext ? extend.right : extend.none , style = solid ? line.style_solid : line.style_dashed ) ) method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) => = request.security( syminfo.tickerid , "" , , lookahead = barmerge.lookahead_off ) var obC obj = obC.new( array.new() , array.new() , array.new< int >() , array.new() , array.new() , array.new() , array.new< int >() , array.new< int >() , array.new< int >() , array.new< int >() , array.new() , array.new() , array.new< int >() ) var obD draw = obD.new( array.new() , array.new() , array.new() , array.new() , array.new() ) if barstate.isfirst for i = 0 to ob_num - 1 draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) : color.new(css,0)) draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css, swing) draw.blB.eB(false, css_metric_up , swing) draw.brB.eB(false, css_metric_dn , swing) draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css, swing) float pos = ob_pos == "Full" ? (bull ? high : low) : ob_pos == "Middle" ? ohlc4 : ob_pos == "Accurate" ? hl2 : hl2 if cdn obj.h.clear() obj.l.clear() obj.n.clear() for i = 1 to math.abs((loc - b.n)) - 1 obj.h.push(hH ) obj.l.push(lL ) obj.n.push(b.t ) // obj.h.reverse() // obj.l.reverse() int iU = obj.l.indexof(obj.l.min()) + 1 int iD = obj.h.indexof(obj.h.max()) + 1 obj.dir.unshift( bull ? (b.c > b.o ? 1 : -1) : (b.c > b.o ? 1 : -1) ) obj.top.unshift( bull ? pos : obj.h.max() ) obj.btm.unshift( bull ? obj.l.min() : pos ) obj.left.unshift( bull ? obj.n.get(obj.l.indexof(obj.l.min())) : obj.n.get(obj.h.indexof(obj.h.max())) ) obj.avg.unshift( math.avg(obj.top.first(), obj.btm.first()) ) obj.cV.unshift( bull ? b.v : b.v ) if ob_pos == "Precise" switch bull true => if obj.avg.get(0) < (b.c < b.o ? b.c : b.o ) and obj.top.get(0) > hlcc4 obj.top.set(0, obj.avg.get(0)) obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first())) false => if obj.avg.get(0) > (b.c < b.o ? b.o : b.c ) and obj.btm.get(0) < hlcc4 obj.btm.set(0, obj.avg.get(0)) obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first())) obj.blVP.unshift ( 0 ) obj.brVP.unshift ( 0 ) obj.wM .unshift ( 1 ) if use_overlap int rmP = use_overlap_method == "Recent" ? 1 : 0 if obj.avg.size() > 1 if bull ? obj.btm.first() < obj.top.get(1) : obj.top.first() > obj.btm.get(1) obj.wM .remove(rmP) obj.cV .remove(rmP) obj.dir .remove(rmP) obj.top .remove(rmP) obj.avg .remove(rmP) obj.btm .remove(rmP) obj.left .remove(rmP) obj.blVP .remove(rmP) obj.brVP .remove(rmP) if barstate.isconfirmed for x = 0 to ob_num - 1 tg = switch ob_mitigation "Middle" => obj.avg "Absolute" => bull ? obj.btm : obj.top for in tg if (bull ? cC < pt : cC > pt) obj.wM .remove(idx) obj.cV .remove(idx) obj.dir .remove(idx) obj.top .remove(idx) obj.avg .remove(idx) obj.btm .remove(idx) obj.left .remove(idx) obj.blVP .remove(idx) obj.brVP .remove(idx) if barstate.islast if obj.avg.size() > 0 // Alert if bull ? ta.crossunder(low , obj.top.get(0)) : ta.crossover (high, obj.btm.get(0)) switch bull true => blalert.obtouch := true false => bralert.obtouch := true float tV = 0 obj.dV.clear() seq = math.min(ob_num - 1, obj.avg.size() - 1) for j = 0 to seq tV += obj.cV.get(j) if j == seq for y = 0 to seq obj.dV.unshift( math.floor( (obj.cV.get(y) / tV) * 100) ) obj.dV.reverse() for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1) dmL = draw.mL .get(i) dOB = draw.ob .get(i) dblB = draw.blB.get(i) dbrB = draw.brB.get(i) deOB = draw.eOB.get(i) dOB.set_lefttop (obj.left .get(i) , obj.top.get(i)) deOB.set_lefttop (b.t , obj.top.get(i)) dOB.set_rightbottom (b.t , obj.btm.get(i)) deOB.set_rightbottom(b.t + (b.t - b.t ) * 100 , obj.btm.get(i)) if use_middle_line dmL.set_xy1(obj.left.get(i), obj.avg.get(i)) dmL.set_xy2(b.t , obj.avg.get(i)) if ob_metrics_show dblB.set_lefttop (obj.left.get(i), obj.top.get(i)) dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i)) dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i)) dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i)) rpBL = dblB.get_right() rpBR = dbrB.get_right() dbrB.set_right(rpBR + (b.t - b.t ) * obj.brVP.get(i)) dblB.set_right(rpBL + (b.t - b.t ) * obj.blVP.get(i)) if use_show_metric txt = switch obj.cV.get(i) >= 1000000000 => str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B" obj.cV.get(i) >= 1000000 => str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M" obj.cV.get(i) >= 1000 => str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K" obj.cV.get(i) < 1000 => str.tostring(math.round(obj.cV.get(i))) deOB.set_text( str.tostring( txt + " (" + str.tostring(obj.dV.get(i)) + "%)") ) deOB.set_text_size (size.auto) deOB.set_text_halign(text.align_left) deOB.set_text_color (use_grayscale ? color.silver : color.new(css, 0)) if ob_metrics_show and barstate.isconfirmed if obj.wM.size() > 0 for i = 0 to obj.avg.size() - 1 switch obj.dir.get(i) 1 => switch obj.wM.get(i) 1 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 2) 2 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 3) 3 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 1) -1 => switch obj.wM.get(i) 1 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 2) 2 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 3) 3 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 1) var hN = array.new(1, b.n) var lN = array.new(1, b.n) var hS = array.new(1, b.n) var lS = array.new(1, b.n) if iH hN.pop() hN.unshift(int(b.n )) if iL lN.pop() lN.unshift(int(b.n )) if sH hS.pop() hS.unshift(int(b.n )) if sL lS.pop() lS.unshift(int(b.n )) if ob_show bull_ob.drawVOB(true , ob_bull_css, hN.first(), false) bear_ob.drawVOB(false, ob_bear_css, lN.first(), false) if ob_swings s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true) s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true) if bull_ob blalert.ob := true if bear_ob bralert.ob := true if s_bull_ob blalert.swingob := true if s_bear_ob blalert.swingob := true //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - End } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{ - FVG | VI | OG } //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} //{----------------------------------------------------------------------------------------------------------------------------------------------} ghl() => request.security(syminfo.tickerid, fvg_tf, [high , low , close , open ]) tfG() => request.security(syminfo.tickerid, fvg_tf, ) cG(bool bull) => = ghl() = tfG() var FVG draw = FVG.new( array.new() , array.new() ) var FVG cords = array.new() float pup = na float pdn = na bool cdn = na int pos = 2 cc = timeframe.change(fvg_tf) if barstate.isfirst for i = 0 to fvg_num - 1 draw.box.unshift(box.new (na, na, na, na, border_color = color.new(color.white, 100), xloc = xloc.bar_time)) draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width = 1, style = line.style_solid)) switch what_fvg "FVG" => pup := bull ? gl : l pdn := bull ? h : gh cdn := bull ? gl > h and cc : gh < l and cc pos := 2 "VI" => pup := bull ? (gc > go ? go : gc) : (gc > go ? go : gc ) pdn := bull ? (gc > go ? gc : go ) : (gc > go ? gc : go) cdn := bull ? go > gc and gh > gl and gc > gc and go > go and gh < math.min(gc, go) and cc : go < gc and gl < gh and gc < gc and go < go and gl > math.max(gc, go) and cc pos := 1 "OG" => pup := bull ? b.l : gl pdn := bull ? gh : gh cdn := bull ? gl > gh and cc : gh < gl and cc pos := 1 if not na(cdn) and cdn cords.unshift( FVG.new( na , na , bull ? true : false , pup , pdn , b.t - (b.t - b.t ) * pos , b.t + (b.t - b.t ) * fvg_extend) ) if bull blalert.fvg := tru
Pine Script® indicator
by TOK15
Renko UT Bot Strategy v6 - ADX FilterDescription: This script implements a Renko-based trailing stop strategy using the UT Bot method, now enhanced with an optional ADX and DI+/- filter to help avoid choppy, low-momentum market conditions. Trades are triggered only when price and EMA cross the adaptive trailing stop and ADX/DI conditions are also met. USE: Start the indicator on a Renko chart and optimize settings for prefered choosen chart Key Features: Adaptive ATR trailing stop based on Renko logic EMA/Trailing Stop crossovers for entries Adjustable ADX and DI+/- filter (no signals if conditions aren’t met) Visual stop line and trade labels on the chart Customizable inputs for ATR, EMA, and filter levels Disclaimer: This strategy is provided for educational and research purposes only. It has not been tested in live trading or with real money. The past performance of this script does not guarantee future results. Trading involves substantial risk, and you can lose all or more of your investment. Before considering any real-money use, please test the strategy thoroughly on a demo account or in TradingView’s paper trading environment. This script is not financial advice. Consult with a licensed financial advisor before making trading decisions. Author PDK1977
Pine Script® strategy
by PDK1977
FVG + RSI Sweep M15FVG + RSI Sweep M15 – Smart Liquidity Trading Indicator This indicator is designed for high-probability intraday trading, optimized for the 15-minute timeframe (M15). It combines: Fair Value Gap (FVG) detection – reveals price imbalance zones RSI reversal signals – identifies overbought/oversold exhaustion Liquidity sweep logic – confirms fakeouts beyond recent highs/lows Time filter – focuses only on high-volume London & New York sessions When all conditions align, it generates clean Buy/Sell signals, with automatic TP and SL levels based on risk–reward logic. Ideal for traders seeking 1–2 precise trades per day with minimal noise.
Pine Script® indicator
by kiemtienso
Fair Value Gap [Custom]📌 FVG Indicator – Smart Money Concepts Tool This script is based on Smart Money Concepts (SMC) and automatically detects and marks Fair Value Gaps (FVG) on the chart, helping traders identify unbalanced price areas left behind by institutional moves. 🧠 What is an FVG? An FVG (Fair Value Gap) is the price gap formed when the market moves rapidly, leaving behind a candle range where no trading occurred — typically between Candle 1’s high and Candle 3’s low (in a three-candle pattern). These gaps often signal imbalance, created during structural breaks or liquidity grabs, and may act as retrace zones or entry points. 🛠 Features: ✅ Automatically detects and highlights FVG zones (high-low range) ✅ Differentiates between open (unfilled) and closed (filled) FVGs ✅ Adjustable timeframe settings (works best on 1H–4H charts) ✅ Option to toggle display of filled FVGs ✅ Great for identifying pullback entries, continuation zones, or reversal setups 💡 Recommended Use: After BOS/CHoCH, watch for price to return to the FVG for entry Combine with Order Blocks and liquidity zones for higher accuracy Best used as part of an ICT or SMC-based trading system
Pine Script® indicator
by ace12313112
Lum3n Trend CloudLum3n Trend Cloud The Lum3n Trend Cloud is a lightweight, easy-to-read trend indicator that helps traders quickly identify bullish, bearish, or neutral conditions using two customizable EMAs (Exponential Moving Averages). How It Works: The indicator uses a short-term EMA and a long-term EMA to determine trend direction. A bullish trend is confirmed when: Price is above both EMAs The short-term EMA is above the long-term EMA A bearish trend is confirmed when: Price is below both EMAs The short-term EMA is below the long-term EMA All other cases are considered neutral or consolidating. Visual Features: Candle Color: 🟢 Lime = Bullish 🔴 Red = Bearish 🟠 Orange = Neutral Trend Cloud Fill: A color-coded band fills the space between the EMAs: Green when bullish Red when bearish Orange when neutral EMAs: Green = Short-term EMA Red = Long-term EMA How to Use It: Use trend direction for trade confirmation or directional bias. Combine with price action, support/resistance, or volume for entries. Neutral zones may signal consolidation, transitions, or chop — avoid overtrading here. Inputs: Short-Term EMA Length (default: 8) Long-Term EMA Length (default: 21)
Pine Script® indicator
by Lum3n
Retracement Bar🔍 Retracement Bar – RB The Retracement Bar (RB) indicator is designed to highlight potential reversal zones by identifying candles where price shows a clear rejection from the extremes. It helps traders spot moments where institutional inventory rebalancing may be occurring — often a precursor to a strong move in the opposite direction. RB highlights bars that: Have a relatively small real body compared to the total candle range. Show a long wick (upper or lower) that exceeds a user-defined percentage of the candle range. Suggest a potential rejection of price — upward or downward — based on candle structure. When these conditions are met, a triangle symbol is plotted: 🔻 Red triangle above a candle suggests a possible short opportunity. 🔺 Green triangle below a candle suggests a possible long opportunity. This indicator does not repaint and triggers only at candle close. 📈 Example – Long Entry Signal: A green triangle appears below a candle (suggesting rejection of lower prices). Steps: Wait for the current RB candle to close. On the next candle: Enter long if price breaks above the high of the RB candle. Alternatively, wait for a pullback and enter based on confirmation (e.g., bullish engulfing, hammer, trendline bounce). Place a stop-loss just below the low of the RB candle. Set a target: Based on a 2:1 risk-reward ratio. Or use the next resistance/Fibonacci level. 📉 Example – Short Entry Signal: A red triangle appears above a candle (suggesting rejection of higher prices). Steps: Wait for the current RB candle to close. On the next candle: Enter short if price breaks below the low of the RB candle. Or wait for confirmation (e.g., bearish engulfing, shooting star, breakdown from a level). Place a stop-loss just above the high of the RB candle. Set a target: 2:1 risk-reward ratio. Or the next support/Fibonacci zone. ✅ Recommended Filters for Better Results: Confluence with support/resistance zones. Trend alignment or reversal context. Additional confirmation from price action patterns or oscillators. Volume analysis for entry strength. 🙏 Acknowledgment Special thanks to Rob Hoffman for inspiring this concept through his original Inventory Retracement Bar (IRB) idea — this indicator is a reinterpretation meant to visually and practically support discretionary price action traders.
Pine Script® indicator
by Giancarlo_Adorno
Gold_Bulls | TP1+TP2 + Trailing SL + Clean Entry//@version=5 indicator("Gold_Bulls | TP1+TP2 + Trailing SL + Clean Entry", overlay=true) // === INPUTS === lookbackDays = input.int(4, "Lookback Days (5m candles)") pivotLen = input.int(5, "Pivot Strength") rr1 = input.float(1.0, "TP1 Risk:Reward") rr2 = input.float(1.5, "TP2 Risk:Reward") trailATRmult = input.float(1.2, "Trailing SL ATR Multiplier") // === TIME FILTER === inLastDays = time > (timenow - lookbackDays * 24 * 60 * 60 * 1000) // === PIVOT S/R === pivotHigh = ta.pivothigh(high, pivotLen, pivotLen) pivotLow = ta.pivotlow(low, pivotLen, pivotLen) resistance = not na(pivotHigh) and inLastDays ? pivotHigh : na support = not na(pivotLow) and inLastDays ? pivotLow : na plotshape(resistance, location=location.abovebar, style=shape.triangledown, color=color.purple, size=size.tiny) plotshape(support, location=location.belowbar, style=shape.triangleup, color=color.blue, size=size.tiny) // === TRACK LAST LEVEL === var float lastSupport = na var float lastResistance = na if not na(support) lastSupport := support if not na(resistance) lastResistance := resistance // === ATR for Trailing SL === atr = ta.atr(14) // === VARIABLES === var float entryBuy = na var float slBuy = na var float tp1Buy = na var float tp2Buy = na var float trailBuy = na var float entrySell = na var float slSell = na var float tp1Sell = na var float tp2Sell = na var float trailSell = na // === CONDITIONAL ENTRY === buyCond = na(entryBuy) and close > lastResistance and ta.barssince(close > lastResistance) == 0 sellCond = na(entrySell) and close < lastSupport and ta.barssince(close < lastSupport) == 0 // === BUY ENTRY === if buyCond entryBuy := close slBuy := ta.lowest(low, 6) risk = entryBuy - slBuy tp1Buy := entryBuy + risk * rr1 tp2Buy := entryBuy + risk * rr2 trailBuy := entryBuy - atr * trailATRmult if not na(entryBuy) trailBuy := math.max(trailBuy, close - atr * trailATRmult) if close < trailBuy or close > tp2Buy entryBuy := na slBuy := na tp1Buy := na tp2Buy := na trailBuy := na // === SELL ENTRY === if sellCond entrySell := close slSell := ta.lowest(low, 6) // as per your request risk = entrySell - slSell tp1Sell := entrySell - risk * rr1 tp2Sell := entrySell - risk * rr2 trailSell := entrySell + atr * trailATRmult if not na(entrySell) trailSell := math.min(trailSell, close + atr * trailATRmult) if close > trailSell or close < tp2Sell entrySell := na slSell := na tp1Sell := na tp2Sell := na trailSell := na // === PLOTS === plotshape(buyCond, location=location.belowbar, style=shape.labelup, color=color.green, text="BUY") plot(entryBuy, title="Buy Entry", color=color.green) plot(slBuy, title="Buy SL", color=color.orange) plot(tp1Buy, title="Buy TP1", color=color.lime) plot(tp2Buy, title="Buy TP2", color=color.teal) plot(trailBuy, title="Buy Trailing SL", color=color.yellow) plotshape(sellCond, location=location.abovebar, style=shape.labeldown, color=color.red, text="SELL") plot(entrySell, title="Sell Entry", color=color.red) plot(slSell, title="Sell SL", color=color.orange) plot(tp1Sell, title="Sell TP1", color=color.green) plot(tp2Sell, title="Sell TP2", color=color.teal) plot(trailSell, title="Sell Trailing SL", color=color.yellow) // === ALERTS === alertcondition(buyCond, title="BUY Signal", message="📈 BUY Signal Triggered!") alertcondition(sellCond, title="SELL Signal", message="📉 SELL Signal Triggered!")
Pine Script® indicator
by Kbstocks724
Price Action Breakout – CALL/PUT AlertsThis strategy generates CALL or PUT alerts based on price breakouts confirmed by EMA and volume filters. 🔍 Breakout Logic 📈 CALL Alert (Bullish Breakout): Price closes above EMA Price breaks above previous high Volume is above average × multiplier 📉 PUT Alert (Bearish Breakout): Price closes below EMA Price breaks below previous low Volume is above average × multiplier 🎯 Alert Structure CALL 📈 / PUT 📉 Entry Price Take Profit (TP) – Based on risk/reward ratio Stop Loss (SL) – Based on percentage distance from entry 📊 Chart Elements Labels on breakout candle with full alert info Horizontal lines for TP and SL levels Works on any timeframe (e.g., 15min for intraday) ✅ Use Case Ideal for options traders, scalpers, and automated alerts
Pine Script® indicator
by Tradegeek21
FutureObitz Official Bank Levels)The FutureObitz Bank Levels indicator, by @FutureObitz is a powerful tool designed to help traders identify key daily structural price levels. It automatically identifies and plots the Daily High (D. High) and Daily Low (D. Low), ensuring these crucial levels are visible and consistent across various chart timeframes (e.g., 15m, 30m, 1h, 4h, and Daily), providing a reliable higher-timeframe perspective. What This Indicator Provides: Dynamic Daily Levels: Automatically calculates and plots daily High, Low, Middle, Middle High, and Middle Low of the current trading day. These lines provide clear reference points for price action. Defined Buy & Sell Zones: Clearly visualizes potential accumulation (Buy Zone) and distribution (Sell Zone) areas. These zones are calculated as a customizable percentage (via inputs) above/below the 'Middle' of the daily range, helping to identify potential entry or exit points. Multi-Timeframe Compatibility: Displays consistent daily levels regardless of the chart's active timeframe, offering a consistent higher-timeframe perspective for intraday traders. Visual Clarity: Includes filled zones for enhanced visibility of key areas. Optional Labels: Provides clear labels for the latest daily levels (D. High, D. Low, D. Middle, D. Buy Zone, D. Sell Zone) on the last bar of your chart for quick reference. This indicator serves as a robust framework for understanding daily price action and identifying potential areas of support, resistance, and trading opportunities. It's an excellent tool for traders who rely on structured levels derived from higher timeframes to inform their decisions.
Pine Script® indicator
by FutureObitz
Candlesticks MTF + Prev Daily RangeCandlesticks MTF + Previous Daily Range This TradingView script displays higher timeframe candlesticks on a lower timeframe chart and optionally projects the previous day's high, low, and close levels. The user can define the timeframe from which the candles are taken, typically a higher timeframe like daily. A specified number of historical candles are drawn on the chart using boxes for candle bodies and lines for wicks. The color of each candle indicates its direction: bullish candles use a "long" color (default teal), and bearish candles use a "short" color (default red). An optional feature allows the projection of the previous daily range. When enabled, the script draws horizontal lines extending across the chart to mark the high, low, and close of the second most recent higher timeframe candle. These lines are color-coded for easy visual identification and can help identify potential support and resistance zones. All visual elements, including the number of candles, their width, and the colors of candles and projection lines, can be customized through the settings. The script dynamically updates in real time, clearing outdated boxes and lines to avoid visual clutter. This makes it a useful tool for traders who want to incorporate multi-timeframe analysis and key price levels directly into their intraday charting.
Pine Script® indicator
by veegee82
🔰 Smart Money RSI Liquidez v1 + EMA50 by Leo OntiverosThis indicator combines Smart Money concepts with RSI and liquidity sweeps to generate precise buy/sell signals—ideal for scalping and intraday trading (3M, 5M, 15M). 🔎 Key Features: ✅ RSI Divergences: Detects bullish and bearish divergences using the 14-period RSI. Signals are stronger in oversold (<30) or overbought (>70) zones. 💧 Liquidity Sweeps: Highlights areas where price sweeps liquidity (new lows/highs) and then reverses. Bullish sweep: price makes a new low and closes bullish. Bearish sweep: price makes a new high and closes bearish. 📈 Smart Confirmed Signals: BUY (🟢): Bullish divergence + RSI oversold + bullish liquidity sweep. SELL (🔴): Bearish divergence + RSI overbought + bearish liquidity sweep. 🎯 Visuals: Arrows and BUY/SELL labels directly on the candle. Background highlights for signal clarity. Includes the EMA50 (orange line) as a trend reference. ⚙️ Recommended Use: Timeframes: 3min, 5min, 15min. Best when combined with market structure (BOS, CHoCH), order blocks, and price action. Extra filter: take signals only in the direction of the EMA50 trend. 📢 Perfect for traders following institutional order flow and looking for high-probability reversal zones confirmed by volume and structure.
Pine Script® indicator
by walterontiveros276
DIP BUYING by HAZEREAL BUY THE DIP - Educational Price Movement Indicator This technical indicator is designed for educational purposes to help traders identify potential price reversal opportunities in equity markets, particularly focusing on NASDAQ-100 index tracking instruments and technology sector ETFs. Key Features: Monitors price movements relative to recent highs over customizable lookback periods Identifies two distinct price decline thresholds: standard (5%+) and extreme (12.3%+) Visual signals with triangular markers and background color zones Real-time data table showing current metrics and status Customizable alert system with webhook-ready JSON formatting Clean overlay design that doesn't obstruct price action How It Works: The indicator tracks the highest price within a specified lookback period and calculates the percentage decline from that high. When price drops below the minimum threshold, it generates visual buy signals. The extreme threshold triggers enhanced alerts for more significant market movements. Best Use Cases: Educational analysis of market volatility patterns Identifying potential support levels during market corrections Studying historical price behavior around significant declines Risk management and position sizing education Important Note: This is a technical analysis tool for educational purposes only. All trading decisions should be based on comprehensive analysis and appropriate risk management. Past performance does not guarantee future results.
Pine Script® indicator
by profitgang