Rozpocznij

Wskaźniki Billa Williamsa

Awesome Oscillator + ADX Divergence System – RCT FUSION PRO Descripción del script: This script enhances the classic Awesome Oscillator (AO) by integrating non-repainting divergence detection and scaled ADX/DMI trend confirmation, creating a unified framework for identifying high-confluence trade setups. The combination is not arbitrary: divergences in AO signal potential reversals, while ADX validates whether the market has sufficient trend strength to act on them. 1. Customizable Awesome Oscillator: The AO is calculated as the difference between a fast and slow moving average of the median price (HL2). Users can choose between SMA (default) or EMA for both legs. The histogram changes color based on momentum acceleration (green when rising, red when falling), with built-in alerts for color transitions. 2. Divergence Engine (Non-Repainting): Automatically detects regular and hidden bullish/bearish divergences between price and the AO: Regular bullish: Price makes a lower low, AO makes a higher low (potential reversal up). Hidden bullish: Price makes a higher low, AO makes a lower low (continuation signal). Equivalent logic applies for bearish cases. All lines and labels are drawn only after the candle closes, eliminating repainting. Users can toggle visibility, adjust pivot sensitivity (lookback range: 1–60 bars), and choose between 1- or 2-pivot confirmation. 3. Scaled ADX & DMI Overlay: The standard ADX (14-period) and +DI/-DI lines are dynamically scaled to match the amplitude of the AO. This allows direct visual comparison: When AO shows a bullish divergence and +DI > -DI and ADX > 23, the setup gains confluence. The Key Level line (offset to -7) serves as a dynamic reference for ADX strength relative to AO momentum. ADX, DM+, and DM- can be toggled independently. How to use: Look for divergence signals below zero (bullish) or above zero (bearish) in the AO. Confirm with ADX > 23 (strong trend) and directional alignment (+DI > -DI for longs, vice versa for shorts). Use color-change alerts in AO as secondary momentum triggers. This system is designed for swing and intraday traders who seek confirmation across momentum, price structure, and trend strength—reducing false signals through convergence. Versión en español : Este script mejora el Oscilador Awesome (AO) clásico al integrar detección de divergencias sin repintado y confirmación de tendencia mediante ADX/DMI escalado, creando un marco unificado para identificar entradas con alta confluencia. La combinación no es arbitraria: las divergencias en el AO señalan posibles giros, mientras que el ADX valida si el mercado tiene fuerza de tendencia suficiente para actuar. El AO personalizable permite elegir entre SMA o EMA. Las divergencias (regulares y ocultas) se detectan solo tras el cierre de la vela. El ADX y los DM+/- se escalan dinámicamente para alinearse visualmente con el AO, permitiendo evaluar confluencia en tiempo real. Ideal para traders que buscan confirmación entre estructura de precio, momentum y fuerza de tendencia.
Wskaźnik Pine Script®
od CARLOSVIZCARRA17
Williams Accelerator Oscillator — ACWhat it is The Accelerator Oscillator (AC) measures the acceleration/deceleration of momentum. It’s derived from the Awesome Oscillator (AO) and shows whether momentum is speeding up or slowing down. In this implementation, columns are green when AC rises vs. the previous bar and red when it falls. How it’s calculated Price source: Median Price (HL2) by default; Close can be used instead. AO = SMA(HL2, fastLen) − SMA(HL2, slowLen) (defaults: 5 & 34). AC = AO − SMA(AO, signalLen) (default: 5). Coloring: Green if AC > AC , else Red. Zero line (optional) helps contextualize acceleration around neutral. How to read it (typical interpretation) Above 0: Upside acceleration (bullish pressure increasing). Below 0: Downside acceleration (bearish pressure increasing). Color sequences: Consecutive green columns suggest increasing upside acceleration; consecutive red columns suggest increasing downside acceleration. Note: AC reflects change in momentum, not trend direction by itself. Many traders confirm with trend filters or price structure before acting. Inputs AO Fast SMA (default 5) AO Slow SMA (default 34) AC Signal SMA (default 5) — smoothing for the AO used in AC calc Use Median Price (HL2) for AO (on/off) Show zero line (on/off) Show AO (for reference) (on/off) Show AC signal (SMA of AO) (on/off) Plots AC Histogram — column chart colored by acceleration (green/red). Zero — optional baseline at 0. AO — optional reference line. AO Signal (SMA) — optional smoothing line of AO. Alerts AC crosses above 0 — acceleration flips positive. AC crosses below 0 — acceleration flips negative. AC green above zero — AC rising and > 0. AC red below zero — AC falling and < 0. Usage tips On lower timeframes, consider a slightly larger signalLen to reduce noise. Confirm with price action, trend filters, or volatility context. Values update intrabar; for stricter signals, confirm on bar close. Limitations AC is built from moving averages and is therefore lagging relative to raw price. It is not normalized; behavior can vary by instrument and timeframe. Do not use in isolation for entries/exits without risk management. Credits Concept by Bill Williams. This script is an independent implementation for educational and research purposes. Disclaimer No financial advice. Markets involve risk; test thoroughly before live use.
Wskaźnik Pine Script®
od trading_mura
PORSCHEThe PORSCHE indicator is a combined, all-in-one Pine v5 tool for intraday and swing traders. It merges a Full Combo suite (EMA clouds, EMA band, Hull moving-average bands, UT Bot signals and a Swing High/Low detector) with Traders Reality features (yesterday/last-week high & low, PVSRA vector candles and configurable Vector Candle Zones). At the end it also adds a Sessions module that plots Asia, Sydney, Tokyo, Shanghai, Europe/London, New York and NYSE session boxes and an information table. All original inputs, styles and alert conditions are preserved. Ideal for traders who want a multi-feature overlay to identify trend direction, high-probability zones, session structure and key swing levels — but note it draws many graphics and zones so it can be resource-heavy on lower-spec setups or very long histories.
Wskaźnik Pine Script®
od RaulMPM
Guardeer//@version=5 indicator("Guardeer", shorttitle = "Guardeer", 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 (true , "Show swing point" , inline = "1", group = "High and Low" , tooltip = "Display swing point") show_mtb = input.bool (true , "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.gray , "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 = 0 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
Wskaźnik Pine Script®
od sunilshelke200
2
Candle Colored by Volume Z-score with S/R [Morty]All Credits to : I have just added Support and Resistance line This indicator colors the candles according to the z-score of the trading volume. You can easily see the imbalance on the chart. You can use it at any timeframe. In statistics, the standard score (Z-score) is the number of standard deviations by which the value of a raw score (i.e., an observed value or data point) is above or below the mean value of what is being observed or measured. Raw scores above the mean have positive standard scores, while those below the mean have negative standard scores. This script uses trading volume as source of z-score by default. Due to the lack of volume data for some index tickers, you can also choose candle body size as source of z-score. features: - custom source of z-score - volume - candle body size - any of above two - all of above two - custom threshold of z-score - custom color chemes - custom chart type - alerts default color schemes: - green -> excheme bullish imbalance - blue -> large bullish imbalance - red -> excheme bearish imbalance - purple -> large bearish imbalance - yellow -> low volume bars, indicates "balance", after which volatility usually increases and tends to continue the previous trend Examples: * Personally, I use dark theme and changed the candle colors to black/white for down/up. Volume as Z-score source
Wskaźnik Pine Script®
od nithinshenoy7
FU + SMI Validator (Proper FU, 30m)Overview The FU + SMI Validator is a sophisticated technical analysis indicator designed to detect Proper FU (Fakeouts or Liquidity Sweeps) on the 30-minute timeframe. This tool aims to help traders identify high-probability reversal setups that occur when price briefly breaks key levels (sweeping liquidity), then reverses with momentum confirmation. Fakeouts are common market events where price action “hunts stops” before reversing direction. Correctly identifying these events can offer excellent entry points with defined risk. This indicator combines price action logic with momentum and volatility filters to provide reliable signals. Core Concepts Proper FU (Fakeout) Detection At its core, the script identifies proper fakeouts by checking if the current bar’s price: For bullish fakeouts: dips below the previous bar’s low (sweeping stops) and then closes above the previous bar’s high For bearish fakeouts: spikes above the previous bar’s high and then closes below the previous bar’s low This ensures that the breakout is a true sweep rather than just a one-sided close. Optionally, the script can require one additional confirmation bar after the FU, ensuring that the momentum is sustained and reducing false signals. SMI-style Momentum Validation To improve the quality of signals, the indicator uses a proxy for the Stochastic Momentum Index (SMI) by calculating the difference between current and past linear regression slopes of price. This momentum check helps ensure that fakeouts occur alongside actual directional strength. Key points: Momentum must be increasing in the direction of the FU signal. Momentum filters can be enabled or disabled based on user preference. Squeeze Condition to Avoid Low-Volatility Traps The script includes a volatility filter based on a squeeze-like condition: It compares Bollinger Bands (BB) and Keltner Channels (KC). When BB bands contract inside KC bands, the market is in a squeeze state, signaling low volatility. Fakeouts during squeeze conditions are often unreliable; the script can filter these out to reduce false alarms. Killzone Session Timing Filter Recognizing that liquidity and volatility vary by session, this tool supports optional filtering for: London Killzone: 09:00 to 10:30 (UK time) New York Killzone: 13:00 to 14:30 (UK time) Signals only trigger during these high-activity windows if enabled, helping traders focus on periods with the best liquidity and market participation. Note: For Killzone filtering to work accurately, your TradingView chart must be set to the UK timezone. Features & Benefits Robust FU detection ensures the breakout price action is meaningful, reducing noise. Momentum filter via linear regression slope captures trend strength in a smooth, mathematically sound way. Low-volatility squeeze avoidance helps reduce false signals in choppy or range-bound markets. Killzone timing filter focuses your attention on the most liquid and active market hours. Optional confirmation bar increases signal reliability. Raw FU markers allow visualization of all detected fakeouts for pattern recognition and manual analysis. Alerts built-in for both valid buy and sell FU setups, enabling real-time notification and quicker decision-making. Customization Options Killzone usage: Enable or disable the session timing filter. Sessions: Configure London and New York killzone time ranges. Momentum alignment: Enable or disable momentum filter based on SMI proxy. Volatility filter: Avoid signals during squeeze or low-volatility conditions. FU confirmation: Option to require one additional confirming candle after the initial FU. Squeeze and momentum parameters: Adjust Bollinger Bands length and multiplier, Keltner Channel length and ATR multiplier. Raw FU markers: Show or hide all detected fakeouts regardless of filters. How to Use This Indicator Apply to 30-minute charts for forex pairs, indices, cryptocurrencies, or other instruments. Set your chart timezone to UK time if using Killzone filters. Adjust input parameters based on your preferred sessions and risk tolerance. Look for green “VALID BUY FU” labels below bars for bullish fakeout entries. Look for red “VALID SELL FU” labels above bars for bearish fakeout entries. Use the alert system to receive notifications on setups. Combine with your existing analysis or risk management strategy for entries, stops, and profit targets. Why Use FU + SMI Validator? Fakeouts are some of the most lucrative but tricky setups for many traders. Without proper filters, they can lead to false entries and losses. This script integrates price action, momentum, volatility, and session timing into one package, providing a robust tool to spot high-quality fakeout opportunities and improve trading confidence. Limitations Requires chart to be set to UK timezone for session filters. Designed specifically for 30-minute timeframe — performance on other timeframes may vary. Momentum is a proxy, not a direct SMI calculation. Like all indicators, best used in conjunction with sound risk management and other analysis tools. Potential Enhancements Conversion into a full strategy script for backtesting entries and exits. Addition of other momentum indicators (RSI, MACD) or volume filters. Customizable time zones or auto time zone detection. Multi-timeframe analysis capabilities. Visual dashboard for summary of signal stats.
Wskaźnik Pine Script®
od frazerlittle
2