เริ่มกันเลย

Candlestick analysis

Direction via Zone Break [by rukich]🟠 OVERVIEW The indicator shows the direction of movement and zones: SSL, BSL, FVG. Zones serve as support/resistance and as validation/invalidation of a movement reversal. 🟠 COMPONENTS The direction of movement is built based on a three-candle swing high (BSL) and swing low (SSL) pattern. If swing high (BSL) and swing low (SSL) are formed, and then an internal swing high/low is formed (depending on the direction of movement), then in case the initial movement continues — for example, in an upward movement — the new swing low (SSL) will be the minimum before the update, i.e., the internal low, while the swing high (BSL) will be formed according to the three-candle pattern. A change of direction is considered when a candle closes beyond the key swing high/low (BSL/SSL), depending on the direction of movement. For example, in an upward movement, a break occurs when a candle closes beyond the swing low (SSL). After that, the swing high (BSL) will be the nearest fractal (swing high), and the swing low (SSL) will be formed according to the three-candle pattern. All the above logic also applies to downward movements. Within each movement, there can be FVG zones, which can act as support/resistance or indicate weakness in the movement direction. Note: if the movement is upward, only bullish FVG+ will be displayed; if the movement is downward, only bearish FVG- will be displayed. Weakness of movement direction. For example, consider an upward impulse with the nearest FVG+ zone. If the price closes beyond the lower boundary of the zone, it will be considered invalidated (inv. FVG-), which in turn indicates weakness in the movement direction and a possible local short, which may subsequently lead to a break of the entire movement. 🟠 HOW TO USE There are only two visual settings in the configuration: Show previous SSL/BSL – enables/disables the display of all previous SSL/BSL zones Show Bullish/Bearish trend – enables/disables background shading between SSL and BSL for visual understanding of the movement direction On the chart, the following are displayed: Labels with current SSL/BSL FVG+- / inv. FVG+- zones, for trading in the movement direction In case the nearest FVG is invalidated, a label will appear with the text: Weak bullish/bearish & local short/long (this is not a signal, but only indicates the probability of a potential move based on the weakness of the nearest zone) 🟠 CONCLUSION The indicator helps determine the current movement with zones for trading in the direction, and also indicates movement weakness through invalidation of the nearest zones.
อินดิเคเตอร์ Pine Script®
โดย rukich
9
Price Action Concepts [RUDYINDICATOR]/// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) creativecommons.org // © RUDYBANK INDICATOR - formerly know as RUDY INDICATOR //@version=5 indicator("Price Action Concepts ", shorttitle = "RUDYINDICATOR-V1 - Price Action RUDYINDICATOR ", 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.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 >
อินดิเคเตอร์ Pine Script®
โดย zh_kelimbet
LiqVision Institutional Suite v6.2 – Hybrid ModeLiqVision Institutional Suite v6.2 — Hybrid Mode (Lightning Edition) Een ultra-geoptimaliseerde Smart Money-indicator gebaseerd op institutionele principes: Liquidity, Market Structure, Order Blocks, FVG’s en Model 1/2 setups. Dit script combineert meerdere professionele SMC-concepten in één engine: 🔷 Functionaliteiten 1. Liquidity Engine Automatische detectie van EQH, EQL en Liquidity Sweeps Dynamische lijnprojectie met smart cleanup Slimme sweep-detectie voor high-probability entries 2. Market Structure Engine BOS & CHOCH detectie Trend continuatie- en reversalsignalen Swing-based pivot logic 3. Order Block Engine Automatische OB-detectie met displacement filtering Bullish & Bearish macro Order Blocks HTF glow overlay (nieuw in v6.2) 4. FVG Engine Major Fair Value Gap detection Up/Down imbalance visual engine HTF-based color restoration (v6.2 fix) 5. Model 1 & Model 2 Signal Engine Trend continuation entries (Model 1) Reversal setups gebaseerd op HTF liquidity & displacement (Model 2) Auto-tapping logic geïntegreerd met OB/FVG 6. Hybrid Mode Rendering Slimme shading afhankelijk van timeframe: LTF → Hide OB/FVG MTF → White overlays HTF → Premium glow visuals 🔷 Alerts Volledige alert-ondersteuning voor: Model 1 Buy/Sell Model 2 Buy/Sell Liquidity Sweep BOS Up/Down CHOCH Up/Down OB Tap FVG Tap Any alert() function call Geschikt voor Telegram, Discord, bots en externe signal pipelines. 🔷 Gebruik Voeg de indicator toe Kies timeframe (1m–4h aanbevolen) Activeer alerts via “Any alert() function call” Volg Model 1/2 entries voor optimaal resultaat ⚡ DISCLAIMER Dit script is uitsluitend bedoeld voor educatieve doeleinden. Geen financieel advies. Resultaten uit het verleden geven geen garantie voor de toekomst.
อินดิเคเตอร์ Pine Script®
โดย Liqvision
TTP IFVG Signals With EMA /ICT Gold scalpingThis script uses original logic and alerting rules. in Japan finding ICT IFVG and EMA conditions. #IFVG, Forex, ICT, EMA, Scalping, Indicator This indicator automatically finds IFVG (Imbalance / Fair Value Gap) zones and gives you a buy or sell signal when price comes back and breaks out through that gap. It also draws a colored box over the gap so you can see the zone visually, and it raises alerts when a new signal appears. High-level logic: On every bar, the script looks back up to “IFVG_GapBars” bars. For each offset i it checks a 3-candle pattern: – If the low of the newer candle is above the high of the older candle: bullish FVG (price jumped up, leaving a gap). – If the high of the newer candle is below the low of the older candle: bearish FVG (price jumped down, leaving a gap). When a valid FVG is found: – For a bullish FVG it looks for a later close that breaks down through that gap (sell signal). – For a bearish FVG it looks for a later close that breaks up through that gap (buy signal). – A moving-average trend filter must agree (downtrend for sells, uptrend for buys). – It checks that price has not already “filled” the gap before the breakout. If all conditions are satisfied, it: – Sets signal_dir = 1 for a buy, or -1 for a sell. – Draws a box from the original FVG bar to the bar just before the breakout (extended a bit to the right), between the gap high and gap low. – Plots an ▲ label for buys or ▼ label for sells. – Triggers the corresponding alert conditions. Now the parameters: PipSizeMultilier (PipSizeManual) Multiplies the symbol’s minimum tick size (syminfo.mintick). It is used when converting “MinFVG_Pips” into an actual price distance. If you feel the indicator is too sensitive (too many small gaps), you can increase this multiplier to effectively require a larger price difference. TickSize Internal value = syminfo.mintick * PipSizeMultiplier. This is the actual price step the script uses as a “pip” when checking minimum gap size. FVG Search Lookback (IFVG_GapBars) How many bars back from the current bar the script will scan for a 3-candle FVG pattern. Larger value = it can find older FVGs, but loop cost is higher. Min FVG Size (Pips/Points) (MinFVG_Pips) Minimum allowed size of the gap, measured in “pips/points” using TickSize. If the vertical distance between the gap high and gap low is smaller than this, the gap is ignored. 0.0 means “no size filter” (every FVG is allowed). FVG Epsilon (Price Units) (FVG_EpsPoints) Tolerance for the FVG detection. It is subtracted/added in the condition that checks “low > old high” or “high < old low”. 0.0 means strict gap (no overlap at all). A small positive epsilon allows tiny overlaps to still count as a gap. Show IFVG Zones (ShowZones) If true, the script draws a box over the IFVG zone when a signal is confirmed. If false, no boxes are drawn; you only see the ▲ / ▼ markers and alerts. Buy Zone Color (ZoneColorBuy) Fill color and border color for boxes created from bearish FVGs that later produce a buy signal. Sell Zone Color (ZoneColorSell) Fill color and border color for boxes created from bullish FVGs that later produce a sell signal. Box Extension (Bars) (BoxExtension) How many extra bars to extend the right side of the box beyond the breakout bar. The internal right coordinate is “bar_index - 1 + BoxExtension”. Increase this if you want the zone to visually extend further into the future. MA Period (MA_Period) Lookback length of the moving average used as a trend filter. MA Type (MA_Kind) Type of moving average: “SMA” or “EMA”. If SMA is chosen, the script uses ta.sma; if EMA, it uses ta.ema. Moving-average filter behavior: For sell signals (from bullish FVG): MA must be sloping down (MA < MA ) and price must be below MA. For buy signals (from bearish FVG): MA must be sloping up (MA > MA ) and price must be above MA. If these conditions are not satisfied, the FVG is ignored even if the gap and breakout conditions are met. Signals and alerts: signal_dir = 1 → buy signal, ▲ label below the bar, “IFVG Buy Alert” / “IFVG Buy/Sell Alert” can fire. signal_dir = -1 → sell signal, ▼ label above the bar, “IFVG Sell Alert” / “IFVG Buy/Sell Alert” can fire. signal_dir = 0 → no new signal on this bar. In short: This indicator finds 3-candle IFVG gaps, filters them by size and trend, waits for a clean breakout through the gap, draws a box on the original gap zone, and gives you a clear buy or sell signal plus alerts.
อินดิเคเตอร์ Pine Script®
โดย stray34sk2
FluxPulse Beacon## FluxPulse Beacon FluxPulse Beacon applies a microstructure lens to every bar, combining directional thrust, realized volatility, and multi-timeframe liquidity checks to decide whether the tape is being pushed by real sponsorship or just noise. The oscillator's color-coded columns and adaptive burst thresholds transform complex flow dynamics into a single actionable flux score for futures and equities traders. HOW IT WORKS Momentum Extraction – Price differentials over a configurable pulse distance are smoothed using exponential moving averages to isolate directional thrust without reacting to single prints. Volatility + Liquidity Normalization – The momentum stream is divided by realized volatility and multiplied by both local and higher-timeframe EMA volume ratios, ensuring pulses only appear when volatility and liquidity align. Adaptive Thresholding – A volatility-derived standard deviation of flux is blended with the base threshold so bursts scale automatically between low-volatility and high-volatility market conditions. Divergence Engine – Linear regression slopes compare price vs. flux to tag bullish/bearish divergences, highlighting stealth accumulation or distribution zones. HOW TO USE IT Continuation Entries : Go with the trend when histogram bars stay above the adaptive threshold, the signal line confirms, and trend bias agrees—this is where liquidity-backed follow-through lives. Fade Plays : Watch for divergence alerts and shrinking compression values; when flux prints below zero yet price grinds higher, hidden selling pressure often precedes rollovers. Session Filter : Compression percentage in the diagnostics table instantly tells you whether to trade thin overnight sessions—low compression means stand down. VISUAL FEATURES Dynamic background heat maps flux magnitude, while threshold lines provide a quick read on whether a pulse is statistically significant. Diagnostics table displays live flux, signal, adaptive threshold, and compression for quick reference. Alert-first workflow: The surface is intentionally clean—bursts and divergences are delivered via alerts instead of on-chart clutter. PARAMETERS Trend EMA Length (default: 34): Defines the macro bias anchor; increase for higher-timeframe confirmation. Pulse Distance (default: 8): Controls how sensitive momentum extraction becomes. Volatility Window (default: 21): Sample window for realized volatility normalization. Liquidity Window (default: 55): Volume smoothing window that proxies liquidity expansion. Liquidity Reference TF (default: 60): Select a higher timeframe to cross-check whether current volume matches institutional flows. Adaptive Threshold (default: enabled): Disable for fixed thresholds on slower markets; enable for high-volatility assets. Base Burst Threshold (default: 1.25): Minimum flux magnitude that qualifies as an actionable pulse. ALERTS The indicator includes four alert conditions: Bull Burst: Detects upside liquidity pulses Bear Burst: Detects downside liquidity pulses Bull Divergence: Flags bullish delta divergence Bear Divergence: Flags bearish delta divergence LIMITATIONS This indicator is designed for liquid futures and equity markets. Performance may degrade in low-volume or highly illiquid instruments. The adaptive threshold system works best on timeframes where sufficient volatility history exists (typically 15-minute charts and above). Divergence signals are probabilistic and should be confirmed with price action. INSERT_CHART_SNAPSHOT_URL_HERE --- ## RangeLattice Mapper RangeLattice Mapper constructs a higher-timeframe scaffolding on any intraday chart, locking in structural highs/lows, mid/quarter grids, VWAP confluence, and live acceptance/break analytics. It provides a non-repainting overlay that turns range management into a disciplined process. HOW IT WORKS Structure Harvesting – Using request.security() , the script samples highs/lows from a user-selected timeframe (default 240 minutes) over a configurable lookback to establish the dominant range. Grid Construction – Midpoint and quarter levels are derived mathematically, mirroring how institutional traders map distribution/accumulation zones. Acceptance Detection – Consecutive closes inside the range flip an acceptance flag and darken the cloud, signaling balanced auction conditions. Break Confirmation – Multi-bar closes outside the structure raise break labels and alerts, filtering the countless fake-outs that plague breakout traders. VWAP Fan Overlay – Session VWAP plus ATR-based bands provide a live measure of flow centering relative to the lattice. HOW TO USE IT Range Plays : Fade taps of the outer rails only when acceptance is active and VWAP sits inside the grid—this is where mean-reversion works best. Breakout Plays : Wait for confirmed break labels before entering expansion trades; the dashboard's Width/ATR metric tells you if the expansion has enough fuel. Market Prep : Carry the same lattice from pre-market into regular trading hours by keeping the structure timeframe fixed; alerts keep you notified even when managing multiple tickers. VISUAL FEATURES Range Tap and Mid Pivot markers provide a tape-reading breadcrumb trail for journaling. Cloud fill opacity tightens when acceptance persists, visually signaling balance compressions ready to break. Dashboard displays absolute width, ATR-normalized width, and current state (Balanced vs Transitional) so you can glance across charts quickly. Acceptance Flag toggle: Keep the repeated acceptance squares hidden until you need to audit balance. PARAMETERS Structure Timeframe (default: 240): Choose the timeframe whose ranges matter most (4H for indices, Daily for stocks). Structure Lookback (default: 60): Bars sampled on the structure timeframe. Acceptance Bars (default: 8): How many consecutive bars inside the range confirm balance. Break Confirmation Bars (default: 3): Bars required outside the range to validate a breakout. ATR Reference (default: 14): ATR period for width normalization. Show Midpoint Grid (default: enabled): Display the midpoint and quarter levels. Show Adaptive VWAP Fan (default: enabled): Toggle the VWAP channel for assets where volume distribution matters most. Show Acceptance Flags (default: disabled): Turn the acceptance markers on/off for maximum visual control. Show Range Dashboard (default: enabled): Disable if screen space is limited, re-enable during prep sessions. ALERTS The indicator includes five alert conditions: Range High Tap: Price interacted with the RangeLattice high Range Low Tap: Price interacted with the RangeLattice low Range Mid Tap: Price interacted with the RangeLattice mid Range Break Up: Confirmed upside breakout Range Break Down: Confirmed downside breakout LIMITATIONS This indicator works best on liquid instruments with clear structural levels. On very low timeframes (1-minute and below), the structure may update too frequently to be useful. The acceptance/break confirmation system requires patience—faster traders may find the multi-bar confirmation too slow for scalping. The VWAP fan is session-based and resets daily, which may not suit all trading styles. ---
อินดิเคเตอร์ Pine Script®
โดย officialjackofalltrades
EMA + Sessions + RSI Strategy v1.0A professional trading strategy that combines multiple technical indicators for high-probability entries. This system uses EMA crossovers, RSI zone filtering, and trend confirmation to identify optimal trading opportunities while managing risk with advanced position management tools. Key Features: ✅ Dual Entry Signals (EMA21 + EMA100 crossover conditions) ✅ Trend Filter EMA750 (trade only with the major trend) ✅ Complete Risk Management (SL 1%, TP 3% default) ✅ Trailing Stop & Breakeven (maximize profits, protect capital) ✅ Compact Statistics Table (real-time performance metrics) ✅ RSI & Session Filters (avoid low-probability setups) ✅ Optional Pyramiding (scale into winning positions) Perfect for swing trading and trend-following on any timeframe. Fully customizable to match your trading style.
กลยุทธ์ Pine Script®
โดย jake_theboss
1
Structure Analysis + Hammer Alert# Structure Resistance + Hammer Alert ## 📊 Indicator Overview This indicator integrates Structure Breakout Analysis with Candlestick Pattern Recognition, helping traders identify market trend reversal points and strong momentum signals. Through visual markers and background colors, you can quickly grasp the bullish/bearish market structure. --- ## 🎯 Core Features ### 1️⃣ Structure Resistance System - Auto-plot Previous High/Low: Automatically marks key support/resistance based on pivot points - Structure Breakout Detection: Shows "BULL" when price breaks above previous high, "BEAR" when breaking below previous low - Trend Background Color: Green background for bullish structure, red background for bearish structure ### 2️⃣ Bullish Momentum Candles (Hammer Patterns) Detects candles with long lower shadows, indicating strong buying pressure at lows: - 💪Strong Bull (Bullish Hammer): Green marker, bullish close with significant lower shadow - 💪Weak Bull (Bearish Hammer): Teal marker, bearish close but strong lower shadow ### 3️⃣ Bearish Momentum Candles (Inverted Hammer/Shooting Star) Detects candles with long upper shadows, indicating strong selling pressure at highs: - 💪Weak Bear (Bullish Inverted Hammer): Orange marker, bullish close but significant upper shadow - 💪Strong Bear (Shooting Star): Red marker, bearish close with significant upper shadow ### 4️⃣ Smart Marker Sizing Markers automatically adjust size based on current trend: - With-Trend Signals: Larger markers (e.g., hammer in bullish trend) - Counter-Trend Signals: Smaller markers (e.g., shooting star in bullish trend) - Neutral Trend: Medium-sized markers --- ## ⚙️ Parameter Settings ### Structure Resistance Parameters - Swing Length: Default 5, higher values = clearer structure but fewer signals - Show Lines/Labels: Toggle on/off options ### Bullish Momentum (Hammer) Parameters - Lower Shadow/Body Ratio: Default 2.0, lower shadow must be 2x body size - Upper Shadow/Body Ratio Limit: Default 0.2, upper shadow cannot be too long - Body Position Ratio: Default 2.0, ensures body is at the top of candle ### Bearish Momentum (Inverted Hammer) Parameters - Upper Shadow/Body Ratio: Default 2.0, upper shadow must be 2x body size - Lower Shadow/Body Ratio Limit: Default 0.2, lower shadow cannot be too long - Body Position Ratio: Default 2.0, ensures body is at the bottom of candle ### Filter & Display Settings - Minimum Body Size: Filters out doji-like candles with tiny bodies - Pattern Type Toggles: Show/hide different pattern types individually - Background Transparency: Adjust background color intensity (higher = more transparent) - Label Distance: Adjust marker distance from candles --- ## 📈 Usage Guidelines ### Trading Signal Interpretation **Long Signals (Strongest to Weakest):** 1. Bullish Structure + Bullish Hammer (💪Strong Bull) → Strongest long signal 2. Bullish Structure + Bearish Hammer (💪Weak Bull) → Secondary long signal 3. Bearish Structure + Hammer → Potential reversal signal **Short Signals (Strongest to Weakest):** 1. Bearish Structure + Shooting Star (💪Strong Bear) → Strongest short signal 2. Bearish Structure + Bullish Inverted Hammer (💪Weak Bear) → Secondary short signal 3. Bullish Structure + Shooting Star → Potential reversal signal ### Practical Tips ✅ Trend Following: Prioritize large marker signals (aligned with trend) ✅ Structure Confirmation: Wait for structure breakout before entry to avoid false breaks ✅ Multiple Timeframes: Confirm trend direction with higher timeframes ⚠️ Counter-Trend Caution: Small marker signals (counter-trend) require stricter risk management --- ## 🔔 Alert Setup This indicator provides 9 alert conditions: - Individual Patterns: Bullish Hammer, Bearish Hammer, Bullish Inverted Hammer, Shooting Star - Combined Signals: Bullish Momentum, Bearish Momentum, Bull/Bear Momentum - Structure Breakouts: Bullish Structure Break, Bearish Structure Break --- ## 💡 FAQ **Q: Why do hammers sometimes appear without markers?** A: Check "Minimum Body Size" setting - the candle body may be too small and filtered out **Q: Too many or too few markers?** A: Adjust "Lower Shadow/Body Ratio" or "Upper Shadow/Body Ratio" parameters - higher ratios = stricter conditions **Q: How to see only the strongest signals?** A: Disable "Bearish Hammer" and "Bullish Inverted Hammer", keep only "Bullish Hammer" and "Shooting Star" **Q: Can it be used on all timeframes?** A: Yes, but recommended for 15-minute and higher timeframes - shorter timeframes have more noise --- ## 📝 Disclaimer ⚠️ This indicator is a supplementary tool and should be used with other technical analysis methods ⚠️ Past performance does not guarantee future results - always practice proper risk management ⚠️ Recommended to test on demo account before live trading --- **Version:** Pine Script v6 **Applicable Markets:** Stocks, Futures, Cryptocurrencies, and all markets
อินดิเคเตอร์ Pine Script®
โดย ssun_6
CCI TIME COUNT//@version=6 indicator("CCI Multi‑TF", overlay=true) // === Inputs === // CCI Inputs cciLength = input.int(20, "CCI Length", minval=1) src = input.source(hlc3, "Source") // Timeframes timeframes = array.from("1", "3", "5", "10", "15", "30", "60", "1D", "1W") labels = array.from("1m", "3m", "5m", "10m", "15m", "30m", "60m", "Daily", "Weekly") // === Table Settings === tblPos = input.string('Top Right', 'Table Position', options = , group = 'Table Settings') i_textSize = input.string('Small', 'Text Size', options = , group = 'Table Settings') textSize = i_textSize == 'Small' ? size.small : i_textSize == 'Normal' ? size.normal : i_textSize == 'Large' ? size.large : size.tiny textColor = color.white // Resolve table position var pos = switch tblPos 'Top Left' => position.top_left 'Top Right' => position.top_right 'Bottom Left' => position.bottom_left 'Bottom Right' => position.bottom_right 'Middle Left' => position.middle_left 'Middle Right' => position.middle_right => position.top_right // === Custom CCI Function === customCCI(source, length) => sma = ta.sma(source, length) dev = ta.dev(source, length) (source - sma) / (0.015 * dev) // === CCI Values for All Timeframes === var float cciVals = array.new_float(array.size(timeframes)) for i = 0 to array.size(timeframes) - 1 tf = array.get(timeframes, i) cciVal = request.security(syminfo.tickerid, tf, customCCI(src, cciLength)) array.set(cciVals, i, cciVal) // === Countdown Timers === var string countdowns = array.new_string(array.size(timeframes)) for i = 0 to array.size(timeframes) - 1 tf = array.get(timeframes, i) closeTime = request.security(syminfo.tickerid, tf, time_close) sec_left = barstate.isrealtime and not na(closeTime) ? math.max(0, (closeTime - timenow) / 1000) : na min_left = sec_left >= 0 ? math.floor(sec_left / 60) : na sec_mod = sec_left >= 0 ? math.floor(sec_left % 60) : na timer_text = barstate.isrealtime and not na(sec_left) ? str.format("{0,number,00}:{1,number,00}", min_left, sec_mod) : "–" array.set(countdowns, i, timer_text) // === Build Table === if barstate.islast rows = array.size(timeframes) + 1 var table t = table.new(pos, 3, rows, frame_color=color.rgb(252, 250, 250), border_color=color.rgb(243, 243, 243)) // Headers table.cell(t, 0, 0, "Timeframe", text_color=textColor, bgcolor=color.rgb(238, 240, 242), text_size=textSize) table.cell(t, 1, 0, "CCI (" + str.tostring(cciLength) + ")", text_color=textColor, bgcolor=color.rgb(239, 243, 246), text_size=textSize) table.cell(t, 2, 0, "Time to Close", text_color=textColor, bgcolor=color.rgb(239, 244, 248), text_size=textSize) // Data Rows for i = 0 to array.size(timeframes) - 1 row = i + 1 label = array.get(labels, i) cciVal = array.get(cciVals, i) countdown = array.get(countdowns, i) // Color CCI: Green if < -100, Red if > 100 cciColor = cciVal < -100 ? color.green : cciVal > 100 ? color.red : color.rgb(236, 237, 240) // Background warning if <60 seconds to close tf = array.get(timeframes, i) closeTime = request.security(syminfo.tickerid, tf, time_close) sec_left = barstate.isrealtime and not na(closeTime) ? math.max(0, (closeTime - timenow) / 1000) : na countdownBg = sec_left < 60 ? color.rgb(255, 220, 220, 90) : na // Table cells table.cell(t, 0, row, label, text_color=color.rgb(239, 240, 244), text_size=textSize) table.cell(t, 1, row, str.tostring(cciVal, "#.##"), text_color=cciColor, text_size=textSize) table.cell(t, 2, row, countdown, text_color=color.rgb(232, 235, 243), bgcolor=countdownBg, text_size=textSize)
อินดิเคเตอร์ Pine Script®
โดย rk2007
Monday Range Levels (Fixed for Forex/XAU)Monday Range Levels Indicator (10-Line Summary) 1. Core Purpose: Defines the initial weekly range in Forex and XAU/USD for structured trading. 2. Range Definition: Automatically plots the High and Low price levels from the first hours of the 3. Monday session. 4. Liquidity Focus: Used primarily to anticipate liquidity sweeps at the start of the trading week. 5. Specific Market: Optimized for high-volatility pairs, especially XAU/USD (Gold) and major Forex pairs. 6. Session Control: Accurately identifies the start of the week regardless of local settings. 7. Timezone Customization: Allows flexible adjustment to NY Time, UTC, or UTC+7 (Vietnam Time). 8. Visual Clarity: Full customization options for line colors, text size, and range shading. 9. Strategic Use: Supports Breakout Trading and Mean Reversion strategies throughout the week. 10. Discipline Tool: Encourages structured trading by providing fixed, objective reference levels. Application: Simple, reliable tool for consistent Day Trading and Scalping. "If I get enough love/support, I'll be dropping more indicators for the fam!"
อินดิเคเตอร์ Pine Script®
โดย TheLight_TSOD
TQQQ Vibha Strategy – Auto Ranges + Rally Days1. Buy only after an intermediate bottom A 20-day lowest low becomes the potential bottom. 2. Wait 3–4 days of higher highs & higher lows higherSeq logic enforces that. 3. Avoid buying when too extended from the 200-day Enforced with: close <= ma200 * (1 + maxExtension) (default 10%) 4. Must close back above 200-day Needed for “change of character” 5. Sell immediately if price breaks the Day-1 rally low (“line in the sand”) Script sets lineInSand = bottom low If price undercuts → close position immediately 6. Range-top rejection Track touches of range top (highest high since bottom) Three failures = sell (“3 strikes rule”)
กลยุทธ์ Pine Script®
โดย basantd
Correlation Scanner📊 CORRELATION SCANNER - Financial Instruments Correlation Analyzer 🎯 ORIGINALITY AND PURPOSE Correlation Scanner is a professional tool for analyzing correlation relationships between different financial instruments. Unlike standard correlation indicators that show the relationship between only two instruments, this script allows you to simultaneously track the correlation of up to 10 customizable instruments with a selected base asset. The indicator is designed for traders working with cross-market analysis, portfolio diversification, and searching for related assets for arbitrage strategies. 🔧 HOW IT WORKS The indicator uses the built-in ta.correlation() function to calculate the Pearson correlation coefficient between instrument closing prices over a specified period. Mathematical foundation: 1. Correlation Calculation: for each instrument, the correlation coefficient with the base asset is calculated over N bars (default 60) 2. Results Sorting: instruments are automatically ranked by absolute correlation value (from strongest to weakest) 3. Visualization: results are displayed in a table with color coding: - Green: positive correlation (instruments move in the same direction) - Red: negative correlation (instruments move in opposite directions) - Color intensity depends on correlation strength 4. Correlation Strength Classification: - Very Strong (💪💪💪): |r| > 0.8 — very strong relationship - Strong (💪💪): |r| > 0.6 — strong relationship - Medium (💪): |r| > 0.4 — medium relationship - Weak: |r| > 0.2 — weak relationship - Very Weak: |r| ≤ 0.2 — very weak relationship 📋 SETTINGS AND USAGE MAIN PARAMETERS: • Main Instrument — base instrument for comparison (default TVC:DXY - US Dollar Index) • Correlation Period — calculation period in bars (10-500, default 60) • Number of Instruments to Display — number of instruments to show (1-10) • Table Position — table location on the chart INSTRUMENT CONFIGURATION: The indicator allows configuring up to 10 instruments for analysis. For each, you can specify: • Instrument — instrument ticker (e.g., FX_IDC:EURUSD) • Name — display name (emojis supported) VISUAL SETTINGS: • Show Chart Label with Correlation — display current chart's correlation with base instrument • Table Header Color — table header color • Table Row Background — table row background color 💡 USAGE EXAMPLES 1. DOLLAR IMPACT ANALYSIS: set DXY as the base instrument and track how dollar index changes affect currency pairs, gold, and cryptocurrencies 2. HEDGING ASSETS SEARCH: find instruments with strong negative correlation for risk diversification 3. PAIRS TRADING: identify assets with high positive correlation to find divergences and arbitrage opportunities 4. CROSS-MARKET ANALYSIS: track relationships between stocks, bonds, commodities, and currencies 5. SYSTEMIC RISK ASSESSMENT: identify periods of increased correlation between assets, which may indicate systemic risks ⚠️ IMPORTANT NOTES • Correlation does NOT imply causation • Correlation can change over time — regularly review the analysis period • High past correlation doesn't guarantee the relationship will persist in the future • Recommended to use the indicator in combination with fundamental analysis 🔔 ALERTS The indicator includes a built-in alert condition: triggers when strong correlation (|r| > 0.8) is detected between the current chart and the base instrument.
อินดิเคเตอร์ Pine Script®
โดย Smart-Day-Trader
Wick Size Percentage (%) IndicatorA lightweight utility script that measures the wick size of every bar in percentages. It helps identify significant rejection blocks and volatility spikes by displaying the exact % value above and below each candle. Perfect for ICT concepts and precise risk management. This indicator is designed for price action traders who need precise measurements of market volatility and rejection. It automatically calculates and displays the size of both the upper and lower wicks of a candle as a percentage relative to the open price. Key Features: Dual Measurement: Separately calculates the upper wick (high to body) and lower wick (body to low). Percentage Based: Values are shown in percentages (%) rather than price points, making it easier to compare volatility across different assets (Crypto, Forex, Stocks). Dynamic Labels: Visual labels appear above and below the candles for quick reading. Fully Customizable: Users can adjust the decimal precision (e.g., for low timeframe scalping), change text size, and toggle visibility to keep the chart clean. Data Window Support: Values are also visible in the side Data Window for detailed analysis without clutter.
อินดิเคเตอร์ Pine Script®
โดย rigobertoleiva
First Session Candle (Transparent Label) Change timezone & more"Global First Candle Rule: Session Refinement Tool" "This tool/template is designed to apply the First Candle Rule across the world's three major trading sessions: New York (NYO), Asia (AO), and London (LO). It uses New York Time (NY) as the default reference, but the timezone can be easily adjusted to UTC or UTC+7 (Vietnam Time). 🎁 Free for the community!"
อินดิเคเตอร์ Pine Script®
โดย TheLight_TSOD
1
Volumetric Inverse Fair Value Gap (IFVG) [Kodexius]The Volumetric Inverse Fair Value Gap (IFVG) indicator detects and visualizes inverse fair value gaps (IFVGs) zones where previous inefficiencies in price (fair value gaps) are later invalidated or “inverted.” Unlike traditional FVG indicators, this tool integrates volume-based analysis to quantify the bullish, bearish, and overall strength of each inversion. It visually represents these metrics within a dynamically updating box on the chart, giving traders deeper insight into market reactions when liquidity imbalances are filled and reversed. Features Inverse fair value gap detection The script identifies bullish and bearish fair value gaps, stores them as pending zones, and turns them into inverse fair value gaps when price trades back through the gap in the opposite direction. Each valid inversion becomes an active IFVG zone on the chart. Sensitivity control with ATR filter and strict mode A minimum gap size based on ATR is used to filter out small and noisy gaps. Strict mode can be enabled so that any wick contact between the relevant candles prevents the gap from being accepted as a fair value gap. This lets you decide how clean and selective the zones should be. Show Last N Boxes control The indicator can keep only the most recent N IFVG zones visible. Older zones are removed from the chart once the number of active objects exceeds the user setting. This prevents clutter on higher timeframes or long histories and keeps attention on the most relevant recent zones. Ghost box for the original gap When the ghost option is enabled, the script draws a faint box that marks the original fair value gap from which the inverse zone came. This makes it easy to see where the initial imbalance appeared and how price later inverted that area. Volumetric bull, bear and strength metrics For each IFVG, the script estimates how much of the bar volume is associated with buying and how much with selling, then computes bull percentage, bear percentage and a strength score that uses a percentile rank of volume. These values are stored with the IFVG object and drive the visualization inside the zone. Three band visual layout inside each IFVG Each active IFVG is drawn as a container with three horizontal sections. The top band represents the bull percentage, the middle band the bear percentage and the bottom band the strength metric. The width of each bar reflects its respective value so you can read the structure of the zone at a glance. Customizable colors and label text Colors for bull, bear, strength, the empty background area, the ghost box and label text can be adjusted in the inputs. This allows you to match the indicator to different chart themes or highlight specific aspects such as strength or direction. Automatic invalidation and cleanup When price clearly closes beyond the IFVG in a way that breaks the logic of that zone, the script marks it as inactive and deletes all boxes and labels linked to it. Only valid and active IFVGs remain on the chart, which keeps the display clean and focused. Calculations 1. Detecting Fair Value Gaps (FVGs) A fair value gap is identified when price action leaves an imbalance between candle wicks. Depending on the mode: Bullish FVG: When low > high Bearish FVG: When high < low Optionally, the strict mode ensures wicks do not touch. The gap’s significance is filtered using the ATR multiplier input to exclude minor noise. Once detected, FVGs are stored as pending zones until inverted by opposite movement (price crossing through). bool bull_cond = strict_mode ? (low > high ) : (close > high ) bool bear_cond = strict_mode ? (high < low ) : (close < low ) float gap_size = 0.0 if bull_cond and close > open gap_size := low - high if bear_cond and close < open gap_size := low - high 2. Creating IFVGs (Inversions) When price later moves through a previous FVG in the opposite direction, an Inverse FVG (IFVG) is created. For example: A previous bearish FVG becomes bullish IFVG if price moves upward through it. A previous bullish FVG becomes bearish IFVG if price moves downward through it. The IFVG is initialized with structural boundaries (top, bottom) and timestamp metadata to anchor visualization. if not p.is_bull_gap and close > p.top inverted := true to_bull := true if p.is_bull_gap and close < p.btm inverted := true to_bull := false 3. Volume Metrics (Bull, Bear, Strength) Each IFVG calculates buy and sell volumes from the current bar’s price spread and total volume. Bull % = proportion of upward (buy) volume Bear % = proportion of downward (sell) volume Strength % = normalized percentile rank of total volume These are obtained through a custom function that estimates directional volume contribution: calc_metrics(float o, float h, float l, float c, float v) => float rng = h - l float buy_v = 0.0 if rng == 0 buy_v := v * 0.5 else if c >= o buy_v := v * ((math.abs(c - o) + (math.min(o, c) - l)) / rng) else buy_v := v * ((h - math.max(o, c)) / rng) float sell_v = v - buy_v float total = buy_v + sell_v float p_bull = total > 0 ? buy_v / total : 0 float p_bear = total > 0 ? sell_v / total : 0 float p_str = ta.percentrank(v, 100) / 100.0
อินดิเคเตอร์ Pine Script®
โดย Kodexius
7
Double candle engulfing (Optimized)Double Engulfing Pattern Detector (DELO) This indicator identifies strong trend reversal signals by detecting the confirmation of two consecutive Engulfing Candlestick Patterns. ✨ Key Features: Bullish Engulfing: Triggers a Buy Signal when two consecutive bullish engulfing patterns are confirmed. Bearish Engulfing: Triggers a Sell Signal when two consecutive bearish engulfing patterns are confirmed.
อินดิเคเตอร์ Pine Script®
โดย nitron2030
Trillotron 5000 Checklist AssistantTrillotron 5000’s Checklist Assistant is a complete multi-factor trading confirmation system designed to help traders avoid low-quality entries and only take high-probability setups. The indicator evaluates market structure, multi-timeframe EMA alignment, volume, ATR, key levels, and candle confirmation to determine whether a chart meets the full criteria for a CALL (bullish) or PUT (bearish) setup. When all conditions align, the indicator highlights the chart with a colored background (green for CALL, red for PUT) and prints a clear signal label on the bar. This tool helps reinforce discipline, reduce impulsive trades, and support consistent decision-making across all timeframes.
อินดิเคเตอร์ Pine Script®
โดย gwureh214
MM Wash Detector (Discreet)MM Wash Detector identifies weekly liquidity sweeps created by market makers. It highlights two conditions: Bull Wash – price wicks above the weekly range to grab liquidity, then reverses Bear Wash – price wicks below the weekly range to grab liquidity, then reverses This tool is designed for traders who want to spot engineered stop-hunts, liquidity grabs, and manipulation pockets where reversals often begin. Labels are intentionally discreet for minimal chart clutter. ✅ 2. Short & Simple Shows when market makers sweep liquidity above or below the weekly range. Bull Wash = liquidity grab above Bear Wash = liquidity grab below Discreet labels. No clutter. ✅ 3. Aggressive / Smart-Money Style Tracks weekly stop-hunts engineered by smart money. A “Wash” prints when price creates an exaggerated wick outside the weekly range with a small body and volume confirmation. These zones often mark liquidity collection before a reversal or displacement move. ✅ 4. Beginner-Friendly This indicator helps you see when the price makes a long wick above or below the weekly candle — a sign that big players might be triggering stops and collecting liquidity. These liquidity grabs are often followed by a reversal. Bull Wash = sweep above Bear Wash = sweep below
อินดิเคเตอร์ Pine Script®
โดย basantd
🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner🚀 Enhanced BUY & SELL Pullback Scanner
อินดิเคเตอร์ Pine Script®
โดย Patta121314