Get started

Search in scripts for "bar"

BE_CustomFx_LibraryLibrary "BE_CustomFx_Library" A handful collection of regular functions, Custom Tools & Utility Functions could be used in regular Scripts. hope these functions can be understood by a non programmer like me too. G_TextValOfNumber(ValueToConvert, RequiredDecimalPlaces, BeginingChar, EndChar) Function to return the String Value of Number with decimal precision with the prefix and suffix characters provided   Parameters:      ValueToConvert : = Number to Convert      RequiredDecimalPlaces : = No of Decimal values Required. supports to a max of 5 decimals else defaults to 2      BeginingChar : = Prefix character which is needed.      EndChar : = Suffix character which is needed.   Returns: Returns Out put with formated value of Given Number for the specified deicimal values with Prefix and suffix string G_TradableValue(ValueToConvert, NeedCustomization, RequiredDecimalPlaces) Function to return the Tradable Value of Number   Parameters:      ValueToConvert : = Number to Convert      NeedCustomization : = set to 1 if you want to customize the decimal percision values. default is No customization needed, which provides output equalent to round_to_mintick      RequiredDecimalPlaces : = if NeedCustomization is set to 1 mention the decimal percision value required. max supported decimal is 5 else defaults to 2   Returns: Returns Out put with formated value of Given Number G_TxtSizeForLables(SizeValue) Function to Get size Value for text values used in Lables   Parameters:      SizeValue : = auto, tiny, small, normal, large, huge. specify either of these values or default value Normal will be displayed as output   Returns: Returns Respective Text size G_Reg_LineType(LineType) Function to Get Line Style Value for text values used in Lines   Parameters:      LineType : = 'solid (─)', 'dotted (┈)', 'dashed (╌)', 'arrow left (←)', 'arrow right (→)', 'arrows both (↔)' or default line style 'dotted (┈)' will be the output   Returns: Returns Respective Line style G_ShapeTypeForLables(ShapeType) Function to Get Shape Style Value for text values used in plot shapes   Parameters:      ShapeType : = 'XCross', 'Cross', 'Triangle Up', 'Triangle Down', 'Flag', 'Circle','Arrow Up', 'Arrow Down','Lable Up', 'Lable Down' or default shpae style Triangle Up will be the output   Returns: Returns Respective Shape style G_Indicator_Val(string, float, int, int) Gets Output of the technical analyis indicator which has length Parameter. RSI, ATR, EMA, SMA, HMA, WMA, VWMA, 'CMO', 'MOM', 'ROC','VWAP'   Parameters:      string : IndicatorName to be specified      float : SrcVal for the TA indicator default is close      int : Length for the TA indicator      int : DecimalValue optional to specify if required formatted output with decimal percision   Returns: Value with the given parameters G_CandleInfo(string, bool, float, bool) function to get Candle Informarion such as both wicksize, top wick size , bottom wick size, full candle size and body size in default points   Parameters:      string : WhatCandleInfo, string input with either of these options "Wick" , "TWick" , "BWick" , "Candle", "Body" , "BearfbVal", "BullfbVal" , "CandleOpen" ,"CandleClose", "CandleHigh" , "CandleLow", "BodyPct"      bool : RepaintingVersion, set to true if required data on the realtime bar else default is set to false      float : FibValueOfCandle, set the fibo value to extract fibvalue of the candle else default is set to 38.2%      bool : AccountforGaps, set to true if required data on considering the gap between previous and current bar else default is set to false   Returns: Returns Respective values for the candles G_BullBearBarCount(int, int) Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      int : HowManyCandlesToCheck The lookback period to look back over      int : BullBear The color of the bar to count (1 = Bull, -1 = Bear), Open = close candles are ignored   Returns: The bar count of how many candles have retraced over the given lookback with specific candles BarToStartYourCalculation(Int) function to get candle co-ordinate in order to use it further for calculating your analysis work . "Heart full Thanks to 3 Pine motivators (LonesomeTheBlue, Myank & Sriki) who helped me cracking this logic"   Parameters:      Int : SelectedCandleNumber (default=450) How many candles you would need to anlysie in your script from the right.   Returns: A boolean - output is returned to say the starting point and continue to diplay true for the future candles isHammer(float, bool, bool) Checks if the current bar is a hammer candle based on the given parameters   Parameters:      float : fib (default=0.382) The fib to base candle body on      bool : colorMatch (default=false) Does the candle need to be green? (true/false)      bool : NeedRepainting (default=false) Specify True if you need them to calculate on the realtime bars   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(float, bool, bool) Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      float : fib (default=0.382) The fib to base candle body on      bool : colorMatch (default=false) Does the candle need to be red? (true/false)      bool : NeedRepainting (default=false) Specify True if you need them to calculate on the realtime bars   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(float, float, bool) Checks if the current bar is a doji candle based on the given parameters   Parameters:      float : _wickSize (default=1.5 times) The maximum allowed times can be top wick size compared to the bottom (and vice versa)      float : _bodySize (default= 5 percent to be mentioned as 0.05) The maximum body size as a percentage compared to the entire candle size      bool : NeedRepainting (default=false) Specify true if you need them to calculate on the realtime bars   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(float, float, bool, bool) Checks if the current bar is a bullish engulfing candle   Parameters:      float : _allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      float : _rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage      bool : _engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?      bool : NeedRepainting (default=false) Specify True if you need them to calculate on the realtime bars   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(float, float, bool, bool) Checks if the current bar is a bearish engulfing candle   Parameters:      float : _allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      float : _rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage      bool : _engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?      bool : NeedRepainting (default=false) Specify True if you need them to calculate on the realtime bars   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle Plot_TrendLineAtDegree(float, float, int, string, bool) helps you to plot the Trendlines based on the specified angle at the defined price to bar ratio   Parameters:      float : Degree (default=14) angle at which Trendline to be plot      float : price2bar_ratio (default=1e-10) The maximum rejection wick size compared to the body as a percentage      int : Bars2Plot (default=6) Does the engulfing candle require the wick to be engulfed as well?      string : LineStyle = 'solid (─)', 'dotted (┈)', 'dashed (╌)', 'arrow left (←)', 'arrow right (→)', 'arrows both (↔)' or default line style 'dotted (┈)' will be the output      bool : PlotOnOpen_Close (default=false) Specify True if you need them to calculate on the Open\Close Values   Returns: plot the Trendlines based on the specified angle at the defined price to bar ratio
Pine Script® library
by TradeWiseWithEase
Donchian DipThe Donchian Dip This strategy is designed to look for good "Buy the Dip" entries on stocks that are clearly in a strong 1-year upward trend. If you do not know how to identify those stocks on your own please do not use this system or continue your education until you do. The Donchian Dip strategy was designed on the daily time frame but works amazingly well on both daily and weekly timeframes. It does still work on intraday charts also if the current trend on the daily chart is in a strong uptrend. Chart Setup: 3-period Donchian Channel with a 1-period offset (hide basis) Bollinger Bands with the default settings of 20/2 (display basis) Entry Signals: There are 3 different entry signals that will be printed on the chart that have similar underlying criteria but are ranked based on skill level just like ski slope skill levels! I recommend only taking green entries until you are familiar with the system and the stocks you are trading. Green Easy Entry: This is the safest buy the dip entry that is normally found at or near a large retracement bottom. You might get one or two bad entries but be persistent and eventually, a great entry will present itself! These are the specifics for the conditions that trigger a Green entry if you want to know what they are: 1. The current bar is an up bar (green or white bar) and closed above the lower Donchian channel 2. Previous bar or 2 bars back closed below the lower Donchian channel 3. Previous bar or 2 bars back closed below the Bollinger Band Basis (20 SMA ) 4. The low of the previous bar or 2 bars back was below the lower Bollinger Band Blue Intermediate Entry: This is a decent entry if you missed the green entry, want to add to an existing position, or are not sure it will pull back far enough to even give a green entry. I would suggest only trade these entries to add to an existing pyramid position or get back into a trade that you were recently stopped out of. However, on high-flying stocks like TSLA these signals and the Black Diamond entry signals might be the only ones you get for a long time. Also, on the weekly chart, Blue or Black entries are sometimes all you will get for a year or more. These are the specifics for the conditions that trigger a Blue entry if you want to know what they are: 1. The current bar is an up bar (green or white bar) and closed above the lower Donchian channel 2. Previous bar or 2 bars back closed below the lower Donchian channel 3. Previous bar or 2 bars back closed below the Bollinger Band Basis (20 SMA ) Black Diamond Advanced Rule: This is normally just a small pullback re-entry signal on a strong trending stock like TSLA ...trade with extreme caution!!! You have been warned but daredevils feel free to give it a shot. I sometimes do trade these entries if the market and sector of the stock I am trading are extremely bullish or if I am looking to add to a position but I use a conservative stop. These are the specifics for the conditions that trigger a Black entry if you want to know what they are: 1. The current bar is an up bar (green or white bar) and closed above the lower Donchian channel 2. Previous bar or 2 bars back closed below the lower Donchian channel 3. Previous bar or 2 bars back closed above the Bollinger Band Basis (20 SMA ) Exit Criteria: The goal of this strategy is to buy the dip and hold as long as possible...let's practice some Paytience and exercise those holding muscles! RLT!!! So, we don't want to exit early but we also want to protect our profits somehow. We do this by using the built-in trailing stops that are defined by dots of three different shades of purple on the chart (feel free to change these in the settings). Simply move your trailing stop to the highest current dot price level. Do not move the trailing stop down ever even if a lower dot is printed later. These are simply the suggested trailing stops and definitely use your own judgment for exits but if you backtest this strategy enough you will most likely discover that in the long run, these trailing stops work really well. I hope this strategy helps you to identify good "Buy the Dip" entries on stocks you love as well as trains you to hold your winners longer for bigger gains. ***HOW TO ADD TO YOUR CHARTS*** 1) Click the "Add to Favorite Scripts" button 2) Go to a stock chart and click the "Indicators" icon at the top 3) Next, on the left, click the "Favorites" and then click the "Naked Put - Growth Indicator v2" 4) It should appear on your charts, and you can click the "gear" icon on the study to edit a few settings. 5) Read the release notes above so you understand how it works.
Pine Script® indicator
by Dustin_D_RLT
8
How to avoid repainting when using security() - PineCoders FAQNOTE The non-repainting technique in this publication that relies on bar states is now deprecated, as we have identified inconsistencies that undermine its credibility as a universal solution. The outputs that use the technique are still available for reference in this publication. However, we do not endorse its usage. See this publication for more information about the current best practices for requesting HTF data and why they work. This indicator shows how to avoid repainting when using the security() function to retrieve information from higher timeframes. What do we mean by repainting? Repainting is used to describe three different things, in what we’ve seen in TV members comments on indicators: 1. An indicator showing results that change during the realtime bar, whether the script is using the security() function or not, e.g., a Buy signal that goes on and then off, or a plot that changes values. 2. An indicator that uses future data not yet available on historical bars. 3. An indicator that uses a negative offset= parameter when plotting in order to plot information on past bars. The repainting types we will be discussing here are the first two types, as the third one is intentional—sometimes even intentionally misleading when unscrupulous script writers want their strategy to look better than it is. Let’s be clear about one thing: repainting is not caused by a bug ; it is caused by the different context between historical bars and the realtime bar, and script coders or users not taking the necessary precautions to prevent it. Why should repainting be avoided? Repainting matters because it affects the behavior of Pine scripts in the realtime bar, where the action happens and counts, because that is when traders (or our systems) take decisions where odds must be in our favor. Repainting also matters because if you test a strategy on historical bars using only OHLC values, and then run that same code on the realtime bar with more than OHLC information, scripts not properly written or misconfigured alerts will alter the strategy’s behavior. At that point, you will not be running the same strategy you tested, and this invalidates your test results , which were run while not having the additional price information that is available in the realtime bar. The realtime bar on your charts is only one bar, but it is a very important bar. Coding proper strategies and indicators on TV requires that you understand the variations in script behavior and how information available to the script varies between when the script is running on historical and realtime bars. How does repainting occur? Repainting happens because of something all traders instinctively crave: more information. Contrary to trader lure, more information is not always better. In the realtime bar, all TV indicators (a.k.a. studies ) execute every time price changes (i.e. every tick ). TV strategies will also behave the same way if they use the calc_on_every_tick = true parameter in their strategy() declaration statement (the parameter’s default value is false ). Pine coders must decide if they want their code to use the realtime price information as it comes in, or wait for the realtime bar to close before using the same OHLC values for that bar that would be used on historical bars. Strategy modelers often assume that using realtime price information as it comes in the realtime bar will always improve their results. This is incorrect. More information does not necessarily improve performance because it almost always entails more noise. The extra information may or may not improve results; one cannot know until the code is run in realtime for enough time to provide data that can be analyzed and from which somewhat reliable conclusions can be derived. In any case, as was stated before, it is critical to understand that if your strategy is taking decisions on realtime tick data, you are NOT running the same strategy you tested on historical bars with OHLC values only. How do we avoid repainting? It comes down to using reliable information and properly configuring alerts, if you use them. Here are the main considerations: 1. If your code is using security() calls, use the syntax we propose to obtain reliable data from higher timeframes. 2. If your script is a strategy, do not use the calc_on_every_tick = true parameter unless your strategy uses previous bar information to calculate. 3. If your script is a study and is using current timeframe information that is compared to values obtained from a higher timeframe, even if you can rely on reliable higher timeframe information because you are correctly using the security() function, you still need to ensure the realtime bar’s information you use (a cross of current close over a higher timeframe MA, for example) is consistent with your backtest methodology, i.e. that your script calculates on the close of the realtime bar. If your system is using alerts, the simplest solution is to configure alerts to trigger Once Per Bar Close . If you are not using alerts, the best solution is to use information from the preceding bar. When using previous bar information, alerts can be configured to trigger Once Per Bar safely. What does this indicator do? It shows results for 9 different ways of using the security() function and illustrates the simplest and most effective way to avoid repainting, i.e. using security() as in the example above. To show the indicator’s lines the most clearly, price on the chart is shown with a black line rather than candlesticks. This indicator also shows how misusing security() produces repainting. All combinations of using a 0 or 1 offset to reference the series used in the security() , as well as all combinations of values for the gaps= and lookahead= parameters are shown. The close in the call labeled “BEST” means that once security has reached the upper timeframe (1 day in our case), it will fetch the previous day’s value. The gaps= parameter is not specified as it is off by default and that is what we need. This ensures that the value returned by security() will not contain na values on any of our chart’s bars. The lookahead security() to use the last available value for the higher timeframe bar we are using (the previous day, in our case). This ensures that security() will return the value at the end of the higher timeframe, even if it has not occurred yet. In our case, this has no negative impact since we are requesting the previous day’s value, with has already closed. The indicator’s Settings/Inputs allow you to set: - The higher timeframe security() calls will use - The source security() calls will use - If you want identifying labels printed on the lines that have no gaps (the lines containing gaps are plotted using very thick lines that appear as horizontal blocks of one bar in length) For the lines to be plotted, you need to be on a smaller timeframe than the one used for the security() calls. Comments in the code explain what’s going on. Look first. Then leap.
Pine Script® indicator
by PineCoders
173
Mayfair FX Scalper V-10 Price Action + SMC//@version=5 indicator("Mayfair FX Scalper V-10 Price Action + SMC", overlay=true) // === INPUTS === rsiLength = input.int(14, title="RSI Length") overbought = input.float(73, title="SELL Level") oversold = input.float(31, title="BUY Level") rsiSrc = input.source(open, title="RSI Source") // === Color Inputs === entryLineColor = input.color(color.white, title="entry Label Color") entryLabelColor = input.color(color.white, title="entry Lable Color") slLineColor = input.color(color.red, title="Stop Loss Line Color") slLabelColor = input.color(color.red, title="Stop Loss Label Color") tpLineColor = input.color(color.blue, title="Take Profit Line Color") tpLabelColor = input.color(color.blue, title="Take Profit Color") entryTextColor = input.color(color.rgb(0, 0, 0) , title="entry Text Color") slTextColor = input.color(color.white, title="Stop Lose Color") tpTextColor = input.color(color.white, title="Take Profit Text Color") //indicator("Author Info Display" // Create table var table infoTable = table.new(position.top_right, 2, 6, bgcolor=color.new(#000000, 1), border_width=1) if barstate.islast table.cell(infoTable, 0, 0, "Author:", text_color=color.white, text_size=size.small) table.cell(infoTable, 1, 0, "MR WOW", text_color=color.rgb(255, 251, 0), text_size=size.large) table.cell(infoTable, 0, 1, "YouTube:", text_color=color.white, text_size=size.small) table.cell(infoTable, 1, 1, "www.youtube.com/@iammrwow", text_color=color.rgb(255, 251, 0), text_size=size.small) table.cell(infoTable, 0, 3, "Website:", text_color=color.white, text_size=size.small) table.cell(infoTable, 1, 3, "www.mrwowea.com", text_color=color.rgb(255, 251, 0), text_size=size.small) // === RSI CALCULATION === rsi = ta.rsi(rsiSrc, rsiLength) rawBuySignal = rsi < oversold rawSellSignal = rsi > overbought // === Confirmed Signals === isBullish = close > open isBearish = close < open newBuy = rawBuySignal and isBullish and close > open == false newSell = rawSellSignal and isBearish and close < open == false // === Trade State Variables === var bool inPosition = false var bool isBuy = false var float entryPrice = na var float slPrice = na var float tp1Price = na var float tp2Price = na var float tp3Price = na var int entryBarIndex = na var label labels = array.new() var line lines = array.new() // === Instrument & Timeframe SL/TP Setup === isGold = str.contains(syminfo.ticker, "XAU") or str.contains(syminfo.ticker, "GOLD") instrumentType = syminfo.type == "crypto" ? "Crypto" : isGold ? "Gold" : syminfo.currency == "JPY" ? "JPY" : "Forex" tf = timeframe.period slPipsGold = tf == "1" ? 30 : tf == "3" ? 45 : tf == "5" ? 50 : tf == "15" ? 60 : 70 slPipsCrypto = tf == "1" ? 5 : tf == "3" ? 8 : tf == "5" ? 12 : tf == "15" ? 15 : 10 slPipsForex = tf == "1" ? 6 : tf == "3" ? 9 : tf == "5" ? 11 : tf == "15" ? 15 : 15 gold_slDist = 0.1 * slPipsGold gold_tp1Dist = gold_slDist gold_tp2Dist = gold_slDist * 2 gold_tp3Dist = gold_slDist * 3 pipSize = instrumentType == "Crypto" ? 1.0 : instrumentType == "Gold" or instrumentType == "JPY" ? 0.01 : 0.0001 slPips = instrumentType == "Crypto" ? slPipsCrypto : instrumentType == "Gold" ? slPipsGold : slPipsForex slDist = slPips * pipSize tp1Dist = slDist tp2Dist = slDist * 2 tp3Dist = slDist * 3 // === Draw Line & Label === drawLine(y, txt, col, lblCol, extendToCurrent) => int lineEnd = extendToCurrent ? bar_index : entryBarIndex + 2 array.push(lines, line.new(entryBarIndex, y, lineEnd, y, color=col, width=2, extend=extend.none)) textCol = str.contains(txt, "Entry") ? entryTextColor : str.contains(txt, "Stop") ? slTextColor : tpTextColor array.push(labels, label.new(lineEnd, y, txt, style=label.style_label_left, color=color.new(lblCol, 0), textcolor=textCol, size=size.small)) // === Check Exit === slHit = inPosition and ((isBuy and low <= slPrice) or (not isBuy and high >= slPrice)) tp3Hit = inPosition and ((isBuy and high >= tp3Price) or (not isBuy and low <= tp3Price)) shouldExit = slHit or tp3Hit if shouldExit for l in labels label.delete(l) array.clear(labels) for ln in lines line.delete(ln) array.clear(lines) inPosition := false entryPrice := na slPrice := na tp1Price := na tp2Price := na tp3Price := na entryBarIndex := na // === Confirmed Signal with No Position === confirmedBuy = not inPosition and newBuy confirmedSell = not inPosition and newSell // === Signal Markers === plotshape(series=confirmedBuy, location=location.belowbar, color=color.rgb(33, 150, 243), style=shape.triangleup, text="BUY", textcolor=color.rgb(33, 150, 243)) plotshape(series=confirmedSell, location=location.abovebar, color=color.rgb(254, 254, 255), style=shape.triangledown, text="SELL", textcolor=color.rgb(239, 238, 247)) // === Entry Execution === if confirmedBuy or confirmedSell entryPrice := close entryBarIndex := bar_index isBuy := confirmedBuy inPosition := true if isGold slPrice := isBuy ? entryPrice - gold_slDist : entryPrice + gold_slDist tp1Price := isBuy ? entryPrice + gold_tp1Dist : entryPrice - gold_tp1Dist tp2Price := isBuy ? entryPrice + gold_tp2Dist : entryPrice - gold_tp2Dist tp3Price := isBuy ? entryPrice + gold_tp3Dist : entryPrice - gold_tp3Dist else slPrice := isBuy ? entryPrice - slDist : entryPrice + slDist tp1Price := isBuy ? entryPrice + tp1Dist : entryPrice - tp1Dist tp2Price := isBuy ? entryPrice + tp2Dist : entryPrice - tp2Dist tp3Price := isBuy ? entryPrice + tp3Dist : entryPrice - tp3Dist drawLine(entryPrice, "Entry Price - After Candle Above Entry Price Then Place Trade: " + str.tostring(entryPrice), entryLineColor, entryLabelColor, false) drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, false) drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, false) drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, false) drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, false) // === Update TP/SL Lines if Still in Trade === if inPosition and not (confirmedBuy or confirmedSell) for ln in lines line.delete(ln) array.clear(lines) for l in labels label.delete(l) array.clear(labels) drawLine(entryPrice, "After Candle Closed Above Entry Line Buy & Below Sell :Entry Price-" + str.tostring(entryPrice), entryLineColor, entryLabelColor, true) drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, true) drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, true) drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, true) drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, true) // === Bollinger Bands Inputs === bb_length = input.int(20, title="SMA & StdDev Length") src = input.source(close, title="Source") // === Bollinger Band Colors === color_upper_2_3 = input.color(color.new(#0db107, 64), title="Upper Band 2–3 Color") color_upper_3_4 = input.color(color.new(#05c41f, 58), title="Upper Band 3–4 Color") color_lower_2_3 = input.color(color.new(#bdbc9d, 80), title="Lower Band 2–3 Color") color_lower_3_4 = input.color(color.new(#e9e6bf, 63), title="Lower Band 3–4 Color") // === Bollinger Band Calculations === sma = ta.sma(src, bb_length) stdev = ta.stdev(src, bb_length) bb2_upper = sma + 2 * stdev bb2_lower = sma - 2 * stdev bb3_upper = sma + 3 * stdev bb3_lower = sma - 3 * stdev bb4_upper = sma + 4 * stdev bb4_lower = sma - 4 * stdev // === Hidden Plots for Fill === p_bb2_upper = plot(bb2_upper, color=na) p_bb3_upper = plot(bb3_upper, color=na) p_bb4_upper = plot(bb4_upper, color=na) p_bb2_lower = plot(bb2_lower, color=na) p_bb3_lower = plot(bb3_lower, color=na) p_bb4_lower = plot(bb4_lower, color=na) // === Band Zone Fills === fill(p_bb2_upper, p_bb3_upper, color=color_upper_2_3) fill(p_bb3_upper, p_bb4_upper, color=color_upper_3_4) fill(p_bb2_lower, p_bb3_lower, color=color_lower_2_3) fill(p_bb3_lower, p_bb4_lower, color=color_lower_3_4) //SMc BULLISH_LEG = 1 BEARISH_LEG = 0 BULLISH = +1 BEARISH = -1 GREEN = #9c9c9c RED = #9c9c9c BLUE = #9c9c9c GRAY = #ffffff MONO_BULLISH = #b2b5be MONO_BEARISH = #5d606b HISTORICAL = 'Historical' PRESENT = 'Present' COLORED = 'Colored' MONOCHROME = 'Monochrome' ALL = 'All' BOS = 'BOS' CHOCH = 'CHoCH' TINY = size.tiny SMALL = size.small NORMAL = size.normal ATR = 'Atr' RANGE = 'Cumulative Mean Range' CLOSE = 'Close' HIGHLOW = 'High/Low' SOLID = '⎯⎯⎯' DASHED = '----' DOTTED = '····' SMART_GROUP = 'Smart Money Concepts' INTERNAL_GROUP = 'Real Time Internal Structure' SWING_GROUP = 'Real Time Swing Structure' BLOCKS_GROUP = 'Order Blocks' EQUAL_GROUP = 'EQH/EQL' GAPS_GROUP = 'Fair Value Gaps' LEVELS_GROUP = 'Highs & Lows MTF' ZONES_GROUP = 'Premium & Discount Zones' modeTooltip = 'Allows to display historical Structure or only the recent ones' styleTooltip = 'Indicator color theme' showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure' showInternalsTooltip = 'Display internal market structure' internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts' showStructureTooltip = 'Display swing market Structure' showSwingsTooltip = 'Display swing point as labels on the chart' showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart' showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart' showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart' orderBlockFilterTooltip = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available' orderBlockMitigationTooltip = 'Select what values to use for order block mitigation' showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart' equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows' equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results' showFairValueGapsTooltip = 'Display fair values gaps on the chart' fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps' fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe' fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart' showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart' modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = ) styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = ) showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip) showInternalsInput = input( true, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip) showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = ) internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull') showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = ) internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear') internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip) internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = ) showStructureInput = input( true, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip) showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = ) swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull') showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = ) swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear') swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = ) showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings') swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings') showHighLowSwingsInput = input( true, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip) showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob') internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob') showSwingOrderBlocksInput = input( false, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob') swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob') orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = ) orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = ) internalBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bullish OB', group = BLOCKS_GROUP) internalBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bearish OB', group = BLOCKS_GROUP) swingBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Bullish OB', group = BLOCKS_GROUP) swingBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Bearish OB', group = BLOCKS_GROUP) showEqualHighsLowsInput = input( true, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip) equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1) equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1) equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = ) showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip) fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip) fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip) fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP) fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP) fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0) showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily') dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = ) dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily') showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly') weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = ) weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly') showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly') monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = ) monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly') showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip) premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP) equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP) discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP) //---------------------------------------------------------------------------------------------------------------------} //DATA STRUCTURES & VARIABLES //---------------------------------------------------------------------------------------------------------------------{ // @type UDT representing alerts as bool fields // @field internalBullishBOS internal structure custom alert // @field internalBearishBOS internal structure custom alert // @field internalBullishCHoCH internal structure custom alert // @field internalBearishCHoCH internal structure custom alert // @field swingBullishBOS swing structure custom alert // @field swingBearishBOS swing structure custom alert // @field swingBullishCHoCH swing structure custom alert // @field swingBearishCHoCH swing structure custom alert // @field internalBullishOrderBlock internal order block custom alert // @field internalBearishOrderBlock internal order block custom alert // @field swingBullishOrderBlock swing order block custom alert // @field swingBearishOrderBlock swing order block custom alert // @field equalHighs equal high low custom alert // @field equalLows equal high low custom alert // @field bullishFairValueGap fair value gap custom alert // @field bearishFairValueGap fair value gap custom alert type alerts bool internalBullishBOS = false bool internalBearishBOS = false bool internalBullishCHoCH = false bool internalBearishCHoCH = false bool swingBullishBOS = false bool swingBearishBOS = false bool swingBullishCHoCH = false bool swingBearishCHoCH = false bool internalBullishOrderBlock = false bool internalBearishOrderBlock = false bool swingBullishOrderBlock = false bool swingBearishOrderBlock = false bool equalHighs = false bool equalLows = false bool bullishFairValueGap = false bool bearishFairValueGap = false // @type UDT representing last swing extremes (top & bottom) // @field top last top swing price // @field bottom last bottom swing price // @field barTime last swing bar time // @field barIndex last swing bar index // @field lastTopTime last top swing time // @field lastBottomTime last bottom swing time type trailingExtremes float top float bottom int barTime int barIndex int lastTopTime int lastBottomTime // @type UDT representing Fair Value Gaps // @field top top price // @field bottom bottom price // @field bias bias (BULLISH or BEARISH) // @field topBox top box // @field bottomBox bottom box type fairValueGap float top float bottom int bias box topBox box bottomBox // @type UDT representing trend bias // @field bias BULLISH or BEARISH type trend int bias // @type UDT representing Equal Highs Lows display // @field l_ine displayed line // @field l_abel displayed label type equalDisplay line l_ine = na label l_abel = na // @type UDT representing a pivot point (swing point) // @field currentLevel current price level // @field lastLevel last price level // @field crossed true if price level is crossed // @field barTime bar time // @field barIndex bar index type pivot float currentLevel float lastLevel bool crossed int barTime = time int barIndex = bar_index // @type UDT representing an order block // @field barHigh bar high // @field barLow bar low // @field barTime bar time // @field bias BULLISH or BEARISH type orderBlock float barHigh float barLow int barTime int bias // @variable current swing pivot high var pivot swingHigh = pivot.new(na,na,false) // @variable current swing pivot low var pivot swingLow = pivot.new(na,na,false) // @variable current internal pivot high var pivot internalHigh = pivot.new(na,na,false) // @variable current internal pivot low var pivot internalLow = pivot.new(na,na,false) // @variable current equal high pivot var pivot equalHigh = pivot.new(na,na,false) // @variable current equal low pivot var pivot equalLow = pivot.new(na,na,false) // @variable swing trend bias var trend swingTrend = trend.new(0) // @variable internal trend bias var trend internalTrend = trend.new(0) // @variable equal high display var equalDisplay equalHighDisplay = equalDisplay.new() // @variable equal low display var equalDisplay equalLowDisplay = equalDisplay.new() // @variable storage for fairValueGap UDTs var array fairValueGaps = array.new() // @variable storage for parsed highs var array parsedHighs = array.new() // @variable storage for parsed lows var array parsedLows = array.new() // @variable storage for raw highs var array highs = array.new() // @variable storage for raw lows var array lows = array.new() // @variable storage for bar time values var array times = array.new() // @variable last trailing swing high and low var trailingExtremes trailing = trailingExtremes.new() // @variable storage for orderBlock UDTs (swing order blocks) var array swingOrderBlocks = array.new() // @variable storage for orderBlock UDTs (internal order blocks) var array internalOrderBlocks = array.new() // @variable storage for swing order blocks boxes var array swingOrderBlocksBoxes = array.new() // @variable storage for internal order blocks boxes var array internalOrderBlocksBoxes = array.new() // @variable color for swing bullish structures var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput // @variable color for swing bearish structures var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput // @variable color for bullish fair value gaps var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput // @variable color for bearish fair value gaps var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput // @variable color for premium zone var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput // @variable color for discount zone var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput // @variable bar index on current script iteration varip int currentBarIndex = bar_index // @variable bar index on last script iteration varip int lastBarIndex = bar_index // @variable alerts in current bar alerts currentAlerts = alerts.new() // @variable time at start of chart var initialTime = time // we create the needed boxes for displaying order blocks at the first execution if barstate.isfirst if showSwingOrderBlocksInput for index = 1 to swingOrderBlocksSizeInput swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right)) if showInternalOrderBlocksInput for index = 1 to internalOrderBlocksSizeInput internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right)) // @variable source to use in bearish order blocks mitigation bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high // @variable source to use in bullish order blocks mitigation bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low // @variable default volatility measure atrMeasure = ta.atr(200) // @variable parsed volatility measure by user settings volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index // @variable true if current bar is a high volatility bar highVolatilityBar = (high - low) >= (2 * volatilityMeasure) // @variable parsed high parsedHigh = highVolatilityBar ? low : high // @variable parsed low parsedLow = highVolatilityBar ? high : low // we store current values into the arrays at each bar parsedHighs.push(parsedHigh) parsedLows.push(parsedLow) highs.push(high) lows.push(low) times.push(time) //---------------------------------------------------------------------------------------------------------------------} //USER-DEFINED FUNCTIONS //---------------------------------------------------------------------------------------------------------------------{ // @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish) // @returns int leg(int size) => var leg = 0 newLegHigh = high > ta.highest( size) newLegLow = low < ta.lowest( size) if newLegHigh leg := BEARISH_LEG else if newLegLow leg := BULLISH_LEG leg // @function Identify whether the current value is the start of a new leg (swing) // @param leg (int) Current leg value // @returns bool startOfNewLeg(int leg) => ta.change(leg) != 0 // @function Identify whether the current level is the start of a new bearish leg (swing) // @param leg (int) Current leg value // @returns bool startOfBearishLeg(int leg) => ta.change(leg) == -1 // @function Identify whether the current level is the start of a new bullish leg (swing) // @param leg (int) Current leg value // @returns bool startOfBullishLeg(int leg) => ta.change(leg) == +1 // @function create a new label // @param labelTime bar time coordinate // @param labelPrice price coordinate // @param tag text to display // @param labelColor text color // @param labelStyle label style // @returns label ID drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) => var label l_abel = na if modeInput == PRESENT l_abel.delete() l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small) // @function create a new line and label representing an EQH or EQL // @param p_ivot starting pivot // @param level price level of current pivot // @param size how many bars ago was the current pivot detected // @param equalHigh true for EQH, false for EQL // @returns label ID drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) => equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay string tag = 'EQL' color equalColor = swingBullishColor string labelStyle = label.style_label_up if equalHigh tag := 'EQH' equalColor := swingBearishColor labelStyle := label.style_label_down if modeInput == PRESENT line.delete( e_qualDisplay.l_ine) label.delete( e_qualDisplay.l_abel) e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted) labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size)) e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput) // @function store current structure and trailing swing points, and also display swing points and equal highs/lows // @param size (int) structure size // @param equalHighLow (bool) true for displaying current highs/lows // @param internal (bool) true for getting internal structures // @returns label ID getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) => currentLeg = leg(size) newPivot = startOfNewLeg(currentLeg) pivotLow = startOfBullishLeg(currentLeg) pivotHigh = startOfBearishLeg(currentLeg) if newPivot if pivotLow pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure drawEqualHighLow(p_ivot, low , size, false) p_ivot.lastLevel := p_ivot.currentLevel p_ivot.currentLevel := low p_ivot.crossed := false p_ivot.barTime := time p_ivot.barIndex := bar_index if not equalHighLow and not internal trailing.bottom := p_ivot.currentLevel trailing.barTime := p_ivot.barTime trailing.barIndex := p_ivot.barIndex trailing.lastBottomTime := p_ivot.barTime if showSwingsInput and not internal and not equalHighLow drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up) else pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure drawEqualHighLow(p_ivot,high ,size,true) p_ivot.lastLevel := p_ivot.currentLevel p_ivot.currentLevel := high p_ivot.crossed := false p_ivot.barTime := time p_ivot.barIndex := bar_index if not equalHighLow and not internal trailing.top := p_ivot.currentLevel trailing.barTime := p_ivot.barTime trailing.barIndex := p_ivot.barIndex trailing.lastTopTime := p_ivot.barTime if showSwingsInput and not internal and not equalHighLow drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down) // @function draw line and label representing a structure // @param p_ivot base pivot point // @param tag test to display // @param structureColor base color // @param lineStyle line style // @param labelStyle label style // @param labelSize text size // @returns label ID drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) => var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time) var label l_abel = label.new(na,na) if modeInput == PRESENT l_ine.delete() l_abel.delete() l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle) l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize) // @function delete order blocks // @param internal true for internal order blocks // @returns orderBlock ID deleteOrderBlocks(bool internal = false) => array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks for in orderBlocks bool crossedOderBlock = false if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH crossedOderBlock := true if internal currentAlerts.internalBearishOrderBlock := true else currentAlerts.swingBearishOrderBlock := true else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH crossedOderBlock := true if internal currentAlerts.internalBullishOrderBlock := true else currentAlerts.swingBullishOrderBlock := true if crossedOderBlock orderBlocks.remove(index) // @function fetch and store order blocks // @param p_ivot base pivot point // @param internal true for internal order blocks // @param bias BULLISH or BEARISH // @returns void storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) => if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput) array a_rray = na int parsedIndex = na if bias == BEARISH a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index) parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max()) else a_rray := parsedLows.slice(p_ivot.barIndex,bar_index) parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min()) orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias) array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks if orderBlocks.size() >= 100 orderBlocks.pop() orderBlocks.unshift(o_rderBlock) // @function draw order blocks as boxes // @param internal true for internal order blocks // @returns void drawOrderBlocks(bool internal = false) => array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks orderBlocksSize = orderBlocks.size() if orderBlocksSize > 0 maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize)) array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes for in parsedOrdeBlocks orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor) box b_ox = b_oxes.get(index) b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh)) b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow)) b_ox.set_border_color( internal ? na : orderBlockColor) b_ox.set_bgcolor( orderBlockColor) // @function detect and draw structures, also detect and store order blocks // @param internal true for internal structures or order blocks // @returns void displayStructure(bool internal = false) => var bullishBar = true var bearishBar = true if internalFilterConfluenceInput bullishBar := high - math.max(close, open) > math.min(close, open - low) bearishBar := high - math.max(close, open) < math.min(close, open - low) pivot p_ivot = internal ? internalHigh : swingHigh trend t_rend = internal ? internalTrend : swingTrend lineStyle = internal ? line.style_dashed : line.style_solid labelSize = internal ? internalStructureSize : swingStructureSize extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition string tag = t_rend.bias == BEARISH ? CHOCH : BOS if internal currentAlerts.internalBullishCHoCH := tag == CHOCH currentAlerts.internalBullishBOS := tag == BOS else currentAlerts.swingBullishCHoCH := tag == CHOCH currentAlerts.swingBullishBOS := tag == BOS p_ivot.crossed := true t_rend.bias := BULLISH displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH)) if displayCondition drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize) if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput) storeOrdeBlock(p_ivot,internal,BULLISH) p_ivot := internal ? internalLow : swingLow extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition string tag = t_rend.bias == BULLISH ? CHOCH : BOS if internal currentAlerts.internalBearishCHoCH := tag == CHOCH currentAlerts.internalBearishBOS := tag == BOS else currentAlerts.swingBearishCHoCH := tag == CHOCH currentAlerts.swingBearishBOS := tag == BOS p_ivot.crossed := true t_rend.bias := BEARISH displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH)) if displayCondition drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize) if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput) storeOrdeBlock(p_ivot,internal,BEARISH) // @function draw one fair value gap box (each fair value gap has two boxes) // @param leftTime left time coordinate // @param rightTime right time coordinate // @param topPrice top price level // @param bottomPrice bottom price level // @param boxColor box color // @returns box ID fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor) // @function delete fair value gaps // @returns fairValueGap ID deleteFairValueGaps() => for in fairValueGaps if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH) eachFairValueGap.topBox.delete() eachFairValueGap.bottomBox.delete() fairValueGaps.remove(index) // @function draw fair value gaps // @returns fairValueGap ID drawFairValueGaps() => = request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on) barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100) newTimeframe = timeframe.change(fairValueGapsTimeframeInput) threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0 bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe if bullishFairValueGap currentAlerts.bullishFairValueGap := true fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor))) if bearishFairValueGap currentAlerts.bearishFairValueGap := true fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor))) // @function get line style from string // @param style line style // @returns string getStyle(string style) => switch style SOLID => line.style_solid DASHED => line.style_dashed DOTTED => line.style_dotted // @function draw MultiTimeFrame levels // @param timeframe base timeframe // @param sameTimeframe true if chart timeframe is same as base timeframe // @param style line style // @param levelColor line and text color // @returns void drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) => = request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on) float parsedTop = sameTimeframe ? high : topLevel float parsedBottom = sameTimeframe ? low : bottomLevel int parsedLeftTime = sameTimeframe ? time : leftTime int parsedRightTime = sameTimeframe ? time : rightTime int parsedTopTime = time int parsedBottomTime = time if not sameTimeframe int leftIndex = times.binary_search_rightmost(parsedLeftTime) int rightIndex = times.binary_search_rightmost(parsedRightTime) array timeArray = times.slice(leftIndex,rightIndex) array topArray = highs.slice(leftIndex,rightIndex) array bottomArray = lows.slice(leftIndex,rightIndex) parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style)) var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style)) var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left) var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left) topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop)) topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop)) topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop)) bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom)) bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom)) bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom)) // @function true if chart timeframe is higher than provided timeframe // @param timeframe timeframe to check // @returns bool higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe) // @function update trailing swing points // @returns int updateTrailingExtremes() => trailing.top := math.max(high,trailing.top) trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime trailing.bottom := math.min(low,trailing.bottom) trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime // @function draw trailing swing points // @returns void drawHighLowSwings() => var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time) var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time) var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny) var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny) rightTimeBar = last_bar_time + 20 * (time - time ) topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top)) topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top)) topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top)) topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High') bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom)) bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom)) bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom)) bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low') // @function draw a zone with a label and a box // @param labelLevel price level for label // @param labelIndex bar index for label // @param top top price level for box // @param bottom bottom price level for box // @param tag text to display // @param zoneColor base color // @param style label style // @returns void drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) => var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small) var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time) b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top)) b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom)) l_abel.set_point( chart.point.new(na,labelIndex,labelLevel)) // @function draw premium/discount zones // @returns void drawPremiumDiscountZones() => drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down) equilibriumLevel = math.avg(trailing.top, trailing.bottom) drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left) drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up) //---------------------------------------------------------------------------------------------------------------------} //MUTABLE VARIABLES & EXECUTION //---------------------------------------------------------------------------------------------------------------------{ parsedOpen = showTrendInput ? open : na candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor) if showHighLowSwingsInput or showPremiumDiscountZonesInput updateTrailingExtremes() if showHighLowSwingsInput drawHighLowSwings() if showPremiumDiscountZonesInput drawPremiumDiscountZones() if showFairValueGapsInput deleteFairValueGaps() getCurrentStructure(swingsLengthInput,false) getCurrentStructure(5,false,true) if showEqualHighsLowsInput getCurrentStructure(equalHighsLowsLengthInput,true) if showInternalsInput or showInternalOrderBlocksInput or showTrendInput displayStructure(true) if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput displayStructure() if showInternalOrderBlocksInput deleteOrderBlocks(true) if showSwingOrderBlocksInput deleteOrderBlocks() if showFairValueGapsInput drawFairValueGaps() if barstate.islastconfirmedhistory or barstate.islast if showInternalOrderBlocksInput drawOrderBlocks(true) if showSwingOrderBlocksInput drawOrderBlocks() lastBarIndex := currentBarIndex currentBarIndex := bar_index newBar = currentBarIndex != lastBarIndex if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar) if showDailyLevelsInput and not higherTimeframe('D') drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput) if showWeeklyLevelsInput and not higherTimeframe('W') drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput) if showMonthlyLevelsInput and not higherTimeframe('M') drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput) //---------------------------------------------------------------------------------------------------------------------} //ALERTS //---------------------------------------------------------------------------------------------------------------------{ alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed') alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed') alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed') alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed') alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed') alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed') alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed') alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed') alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB') alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB') alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB') alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB') alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected') alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected') alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed') alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed') //---------------------------------------------------------------------------------------------------------------------}
Pine Script® indicator
by vzumo6627
Intrabar Volume Delta — RealTime + History (Stocks/Crypto/Forex)Intrabar Volume Delta Grid — RealTime + History (Stocks/Crypto/Forex) # Short Description Shows intrabar Up/Down volume, Delta (absolute/relative) and UpShare% in a compact grid for both real-time and historical bars. Includes an MTF (M1…D1) dashboard, contextual coloring, density controls, and alerts on Δ and UpShare%. Smart historical splitting (“History Mode”) for Crypto/Futures/FX. --- # What it does (Quick) * **UpVol / DownVol / Δ / UpShare%** — visualizes order-flow inside each candle. * **Real-time** — accumulates intrabar volume live by tick-direction. * **History Mode** — splits Up/Down on closed bars via simple or range-aware logic. * **MTF Dashboard** — one table view across M1, M5, M15, M30, H1, H4, D1 (Vol, Up/Down, Δ%, Share, Trend). * **Contextual opacity** — stronger signals appear bolder. * **Label density** — draw every N-th bar and limit to last X bars for performance. * **Alerts** — thresholds for |Δ|, Δ%, and UpShare%. --- # How it works (Real-Time vs History) * **Real-time (open bar):** volume increments into **UpVolRT** or **DownVolRT** depending on last price move (↑ goes to Up, ↓ to Down). This approximates live order-flow even when full tick history isn’t available. * **History (closed bars):** * **None** — no split (Up/Down = 0/0). Safest for equities/indices with unreliable tick history. * **Approx (Close vs Open)** — all volume goes to candle direction (green → Up 100%, red → Down 100%). Fast but yields many 0/100% bars. * **Price Action Based** — splits by Close position within High-Low range; strength = |Close−mid|/(High−Low). Above mid → more Up; below mid → more Down. Falls back to direction if High==Low. * **Auto** — **Stocks/Index → None**, **Crypto/Futures/FX → Approx**. If you see too many 0/100 bars, switch to **Price Action Based**. --- # Rows & Meaning * **Volume** — total bar volume (no split). * **UpVol / DownVol** — directional intrabar volume. * **Delta (Δ)** — UpVol − DownVol. * **Absolute**: raw units * **Relative (Δ%)**: Δ / (Up+Down) × 100 * **Both**: shows both formats * **UpShare%** — UpVol / (Up+Down) × 100. >50% bullish, <50% bearish. * Helpful icons: ▲ (>65%), ▼ (<35%). --- # MTF Dashboard (🔧 Enable Dashboard) A single table with **Vol, Up, Down, Δ%, Share, Trend (🔼/🔽/⏭️)** for selected timeframes (M1…D1). Great for a fast “panorama” read of flow alignment across horizons. --- # Inputs (Grouped) ## Display * Toggle rows: **Volume / Up / Down / Delta / UpShare** * **Delta Display**: Absolute / Relative / Both ## Realtime & History * **History Mode**: Auto / None / Approx / Price Action Based * **Compact Numbers**: 1.2k, 1.25M, 3.4B… ## Theme & UI * **Theme Mode**: Auto / Light / Dark * **Row Spacing**: vertical spacing between rows * **Top Row Y**: moves the whole grid vertically * **Draw Guide Lines**: faint dotted guides * **Text Size**: Tiny / Small / Normal / Large ## 🔧 Dashboard Settings * **Enable Dashboard** * **📏 Table Text Size**: Tiny…Huge * **🦓 Zebra Rows** * **🔲 Table Border** ## ⏰ Timeframes (for Dashboard) * **M1…D1** toggles ## Contextual Coloring * **Enable Contextual Coloring**: opacity by signal strength * **Δ% cap / Share offset cap**: saturation caps * **Min/Max transparency**: solid vs faint extremes ## Label Density & Size * **Show every N-th bar**: draw labels only every Nth bar * **Limit to last X bars**: keep labels only in the most recent X bars ## Colors * Up / Down / Text / Guide ## Alerts * **Delta Threshold (abs)** — |Δ| in volume units * **UpShare > / <** — bullish/bearish thresholds * **Enable Δ% Alert**, **Δ% > +**, **Δ% < −** — relative delta levels --- # How to use (Quick Start) 1. Add the indicator to your chart (overlay=false → separate pane). 2. **History Mode**: * Crypto/Futures/FX → keep **Auto** or switch to **Price Action Based** for richer history. * Stocks/Index → prefer **None** or **Price Action Based** for safer splits. 3. **Label Density**: start with **Limit to last X bars = 30–150** and **Show every N-th bar = 2–4**. 4. **Contextual Coloring**: keep on to emphasize strong Δ% / Share moves. 5. **Dashboard**: enable and pick only the TFs you actually use. 6. **Alerts**: set thresholds (ideas below). --- # Alerts (in TradingView) Add alert → pick this indicator → choose any of: * **Delta exceeds threshold** (|Δ| > X) * **UpShare above threshold** (UpShare% > X) * **UpShare below threshold** (UpShare% < X) * **Relative Delta above +X%** * **Relative Delta below −X%** **Starter thresholds (tune per symbol & TF):** * **Crypto M1/M5**: Δ% > +25…35 (bullish), Δ% < −25…−35 (bearish) * **FX (tick volume)**: UpShare > 60–65% or < 40–35% * **Stocks (liquid)**: set **Absolute Δ** by typical volume scale (e.g., 50k / 100k / 500k) --- # Notes by Market Type * **Crypto/Futures**: 24/7 and high liquidity — **Price Action Based** often gives nicer history splits than Approx. * **Forex (FX)**: TradingView volume is typically **tick volume** (not true exchange volume). Treat Δ/Share as tick-based flow, still very useful intraday. * **Stocks/Index**: historical tick detail can be limited. **None** or **Price Action Based** is a safer default. If you see too many 0/100% shares, switch away from Approx. --- # “All Timeframes” accuracy * Works on **any TF** (M1 → D1/W1). * **Real-time accuracy** is strong for the open bar (live accumulation). * **Historical accuracy** depends on your **History Mode** (None = safest, Approx = fastest/simplest, Price Action Based = more nuanced). * The MTF dashboard uses `request.security` and therefore follows the same logic per TF. --- # Trade Ideas (Use-Cases) * **Scalping (M1–M5)**: a spike in Δ% + UpShare>65% + rising total Vol → momentum entries. * **Intraday (M5–M30–H1)**: when multiple TFs show aligned Δ%/Share (e.g., M5 & M15 bullish), join the trend. * **Swing (H4–D1)**: persistent Δ% > 0 and UpShare > 55–60% → structural accumulation bias. --- # Advantages * **True-feeling live flow** on the open bar. * **Adaptable history** (three modes) to match data quality. * **Clean visual layout** with guides, compact numbers, contextual opacity. * **MTF snapshot** for quick bias read. * **Performance controls** (last X bars, every N-th bar). --- # Limitations & Care * **FX uses tick volume** — interpret Δ/Share accordingly. * **History Mode is an approximation** — confirm with trend/structure/liquidity context. * **Illiquid symbols** can produce noisy or contradictory signals. * **Too many labels** can slow charts → raise N, lower X, or disable guides. --- # Best Practices (Checklist) * Crypto/Futures: prefer **Price Action Based** for history. * Stocks: **None** or **Price Action Based**; be cautious with **Approx**. * FX: pair Δ% & UpShare% with session context (London/NY) and volatility. * If labels overlap: tweak **Row Spacing** and **Text Size**. * In the dashboard, keep only the TFs you actually act on. * Alerts: start around **Δ% 25–35** for “punchy” moves, then refine per asset. --- # FAQ **1) Why do some closed bars show 0%/100% UpShare?** You’re on **Approx** history mode. Switch to **Price Action Based** for smoother splits. **2) Δ% looks strong but price doesn’t move — why?** Δ% is an **order-flow** measure. Price also depends on liquidity pockets, sessions, news, higher-timeframe structure. Use confirmations. **3) Performance slowdown — what to do?** Lower **Limit to last X bars** (e.g., 30–100), increase **Show every N-th bar** (2–6), or disable **Draw Guide Lines**. **4) Dashboard values don’t “match” the grid exactly?** Dashboard is multi-TF via `request.security` and follows the history logic per TF. Differences are normal. --- # Short “Store” Marketing Blurb Intrabar Volume Delta Grid reveals the order-flow inside every candle (Up/Down, Δ, UpShare%) — live and on history. With smart history splitting, an MTF dashboard, contextual emphasis, and flexible alerts, it helps you spot momentum and bias across Crypto, Forex (tick volume), and Stocks. Tidy labels and compact numbers keep the panel readable and fast.
Pine Script® indicator
by a_jabbaroff
CVD Polarity Indicator (With Rolling Smoothed)📊 CVD Polarity Indicator (with Rolling Smoothing) Purpose The CVD Polarity Indicator combines Cumulative Volume Delta (CVD) with price bar direction to measure whether buying or selling pressure is in agreement with price action. It then smooths that signal over time, making it easier to see underlying volume-driven market trends. This indicator is essentially a volume–price agreement oscillator: - It compares price direction with volume delta (CVD). - Translates that into per-bar polarity. - Smooths it into a rolling sum for clarity. - Adds a short EMA to highlight turning points. The end result: a tool that helps you see when price action is backed by real volume flows versus when it’s running on weak participation. __________________________________________________________________________________ 1. Cumulative Volume Delta (CVD) What it is: CVD is the cumulative sum of buying vs. selling pressure measured by volume. - If a bar closes higher than it opens → that bar’s volume is treated as buying pressure (+volume). - If a bar closes lower than it opens → that bar’s volume is treated as selling pressure (–volume). Rolling version: Instead of accumulating indefinitely (which just creates a line that trends forever), this indicator uses a rolling sum over a user-defined number of bars (cumulation_length, default 14). - This shows the net delta in recent bars, making the CVD more responsive and localized. 2. Bar Direction vs. CVD Change Each bar has two pieces of directional information: 1. Bar direction: Whether the candle closed above or below its open (close - open). 2. CVD change: Whether cumulative delta increased or decreased from the prior bar (cvd - cvd ). By comparing these two: - Agreement (both up or both down): → Polarity = +volume (if bullish) or –volume (if bearish). - Disagreement (bar up but CVD down, or bar down but CVD up): → Polarity flips sign, signaling divergence between price and volume. Thus, raw polarity = a per-bar measure of whether price action and volume delta are in sync. 3. Polarity Smoothing (Rolling Polarity) - Problem with raw polarity: It flips bar-to-bar and looks very jagged — not great for seeing trends. - Solution: The indicator applies a rolling sum over the past polarity_length bars (default 14). - This creates a smoother curve, representing the net polarity over time. - Positive values = net bullish alignment (buyers stronger). - Negative values = net bearish alignment (sellers stronger). Think of it like an oscillator showing whether buyers or sellers have had control recently. 4. EMA Smoothing Finally, a 10-period EMA is applied on top of the rolling polarity line: - This further reduces noise. - It helps highlight shifts in the underlying polarity trend. - Crossovers of the polarity line and its EMA can serve as trade signals (bullish/bearish inflection points). ________________________________________________________________________________ How to Read It 1. Polarity above zero → Recent bars show more bullish agreement between price and volume. 2. Polarity below zero → Recent bars show more bearish agreement. 3. Polarity diverging from price → If price goes up but polarity trends down, it signals weakening buying pressure (potential reversal). 4. EMA crossovers → - Polarity crossing above its EMA = bullish momentum shift. - Polarity crossing below its EMA = bearish momentum shift. Practical Use Cases - Trend Confirmation Use polarity to confirm whether a price move is supported by volume. If price rallies but polarity stays negative, the move is weak. - Divergence Signals Watch for divergences between price trend and polarity trend (e.g., higher highs in price but lower highs in polarity). - Momentum Shifts Use EMA crossovers as signals that the underlying balance of buying/selling has flipped.
Pine Script® indicator
by Cruiser
ADR/ATR Session No Probability Table by LKHere you go—clear, English docs you can drop into your script’s description or share with teammates. ADR/ATR Session by LK — Overview This indicator summarizes Average Daily Range (ADR) and Average True Range (ATR) for two horizons: • Session H4 (e.g., 06:00–13:00 on a 4‑hour chart) • Daily (D) It shows: • Current ADR/ATR values (using your chosen smoothing method) • How much of ADR/ATR today/this bar has already been consumed (% of ADR/ATR) • ADR/ATR as a percent of price • Optional probability blocks: likelihood that %ADR will exceed user‑defined thresholds over a lookback window • Optional on‑chart lines for the current H4 and Daily candles: Open, ADR High, ADR Low ⸻ What the metrics mean • ADR (H4 / D): Moving average of the bar range (high - low). • ATR (H4 / D): Moving average of True Range (max(hi-lo, |hi-close |, |lo-close |)). • % of ADR (curr H4): (H4 range of the current H4 bar) / ADR(H4) × 100. Updates live even if the current time is outside the session. • % of ADR (Daily): (today’s intra‑day range) / ADR(D) × 100. • % of ATR (curr H4 / Daily): TR / ATR × 100 for that horizon. • ADR % of Price / ATR % of Price: ADR or ATR divided by current price × 100 (a quick “volatility vs. price” gauge). Session logic (H4): ADR/ATR(H4) only update on bars that fall inside the configured session window; outside the window the values hold steady (no recalculation “bleed”). Daily range tracking: The indicator tracks today’s high/low in real‑time and resets at the day change. ⸻ Inputs (quick reference) Core • Length (ADR/ATR): smoothing length for ADR/ATR (default 21). • Wait for Higher TF Bar Close: if true, updates ADR/ATR only after the higher‑TF bar closes when using request.security. Timeframes • Session Timeframe (H4): default 240. • Daily Timeframe: default D. Session time • Session Timezone: “Chart” (default) or a fixed timezone. • Session Start Hour, End Hour (minutes are fixed to 0 in this version). Smoothing methods • H4 ADR Method / H4 ATR Method: SMA/EMA/RMA/WMA. • Daily ADR Method / Daily ATR Method: SMA/EMA/RMA/WMA. Table appearance • Table BG, Table Text, Table Font Size. Lines (optional) • Show current H4 segments, Show current Daily segments • Line colors for Open / ADR High / ADR Low • Line width Probability • H4 Probability Lookback (bars): number of H4 bars to examine (e.g., 300). • Daily Probability Lookback (days): number of D bars (e.g., 180). • ADR thresholds (%): CSV list of thresholds (e.g., 25,50,55,60,65,70,75,80,85,90,95,100,125,150). The table will show the % of lookback bars where %ADR ≥ threshold. Tip: If you want probabilities only for session H4 bars (not every H4 bar), ask and I can add a toggle to filter by inSess. ⸻ How to read the table H4 block • ADR (method) / ATR (method): the session‑aware averages. • % of ADR (curr H4): live progress of this H4 bar toward the session ADR. • ADR % of Price: ADR(H4) relative to price. • % of ATR (curr H4) and ATR % of Price: same idea for ATR. H4 Probability (lookback N bars) • Rows like “≥ 80% ADR” show the fraction (in %) of the last N H4 bars that reached at least 80% of ADR(H4). Daily block • Mirrors the H4 block, but for Daily. Daily Probability (lookback M days) • Rows like “≥ 100% ADR” show the fraction of the last M daily bars whose daily range reached at least 100% of ADR(D). ⸻ Practical usage • Use % of ADR (curr H4 / Daily) to judge exhaustion or room left in the day/session. E.g., if Daily %ADR is already 95%, be cautious with momentum continuation trades. • The probability tables give a quick historical context: If “≥ 125% ADR” is ~18%, the market rarely stretches that far; your trade sizing/targets can reflect that. • ADR/ATR % of Price helps normalize volatility between instruments. ⸻ Troubleshooting • If probability rows are blank: ensure lookback windows are large enough (and that the chart has enough history). • If ADR/ATR show … (NA): usually you don’t have enough bars for the chosen length/TF yet. • If line segments are missing: verify you’re on a chart with visible current H4/D bars and the toggles are enabled. ⸻ Notes & customization ideas • Add a toggle to count only session bars in H4 probability. • Add separate thresholds for H4 vs Daily. • Let users pick minutes for session start/end if needed. • Add alerts when %ADR crosses specified thresholds. If you want me to bundle any of the “ideas” above into the code, say the word and I’ll ship a clean patch.
Pine Script® indicator
by kimngan894923
Helper Lib by tristanlee85Library "helpers" This library offers various functions and types based on the algorithmic concepts as authored by ICT. kv(key, value)   Returns a string of the key/value set, suitable for debug logging   Parameters:      key (string)      value (string)   Returns: A string formatted as "{key}: {value}" kv(key, value)   Parameters:      key (string)      value (int) kv(key, value)   Parameters:      key (string)      value (float) kv(key, value)   Parameters:      key (string)      value (bool) method enable(this, enable)   Enable/Disable debug logging   Namespace types: Debugger   Parameters:      this (Debugger)      enable (bool) : Set to `true` by default. method group(this, label)   Creates a group label for nested debug() invocations   Namespace types: Debugger   Parameters:      this (Debugger)      label (string) method groupEnd(this, label)   Ends the specified debug group   Namespace types: Debugger   Parameters:      this (Debugger)      label (string) method log(this, s, arg1, arg2, arg3, arg4, arg5)   Logs the param values if debug mode is enabled   Namespace types: Debugger   Parameters:      this (Debugger)      s (string) : Title of the log message      arg1 (string)      arg2 (string)      arg3 (string)      arg4 (string)      arg5 (string) method logIf(this, expr, s, arg1, arg2, arg3, arg4, arg5)   Same behavior as debug() except will only log if the passed expression is true   Namespace types: Debugger   Parameters:      this (Debugger)      expr (bool) : Boolean expression to determine if debug logs should be logged      s (string) : Title of the log message      arg1 (string)      arg2 (string)      arg3 (string)      arg4 (string)      arg5 (string) style_getLineStyleFromType(opt)   Returns the corresponding line style constant for the given LineStyleType   Parameters:      opt (series LineStyleType) : The selected line style type   Returns: The Pine Script line style constant style_getTextSizeFromType(opt)   Returns the corresponding text size constant for the given TextSizeType   Parameters:      opt (series TextSizeType) : The selected text size type   Returns: The Pine Script text size constant style_getTextHAlignFromType(t)   Returns the corresponding horizontal text align constant for the given HAlignType   Parameters:      t (series HAlignType) : The selected text align type   Returns: The Pine Script text align constant style_getTextVAlignFromType(t)   Returns the corresponding vertical text align constant for the given VAlignType   Parameters:      t (series VAlignType) : The selected text align type   Returns: The Pine Script text align constant format_sentimentType(sentiment, pd)   Used to produce a string with the sentiment and PD array type (e.g., "+FVG")   Parameters:      sentiment (series SentimentType) : The sentiment value (e.g., SentimentType.BULLISH)      pd (series PDArrayType) : The price data array (e.g., PDArrayType.FVG)   Returns: A formatted string with the sentiment and PD array (e.g., "+FVG") format_timeToString(timestamp)   Formats a UNIX timestamp into a date and time string based on predefined formats   Parameters:      timestamp (int) : The UNIX timestamp to format   Returns: A formatted string as "MM-dd (E) - HH:mm" method init(this)   Initializes the session and validates the configuration. This MUST be called immediately after creating a new instance.   Namespace types: Session   Parameters:      this (Session) : The Session object reference   Returns: The Session object (chainable) or throws a runtime error if invalid method isActive(this, _time)   Determines if the session is active based on the current bar time   Namespace types: Session   Parameters:      this (Session) : The Session object reference      _time (int)   Returns: `true` if the session is currently active; `false` otherwise method draw(this)   Draws the line and optional label   Namespace types: LineLabel   Parameters:      this (LineLabel) : The LineLabel object reference   Returns: The LineLabel object (chainable) method extend(this, x)   Extends the line and label right to the specified bar index   Namespace types: LineLabel   Parameters:      this (LineLabel) : The LineLabel object reference      x (int) : The bar index to extend to   Returns: The LineLabel object (chainable) method destroy(this)   Removes the line and label from the chart   Namespace types: LineLabel   Parameters:      this (LineLabel) : The LineLabel object reference isFVG(includeVI, barIdx)   Checks if the previous bars form a Fair Value Gap (FVG)   Parameters:      includeVI (bool) : If true, includes Volume Imbalance in the FVG calculation      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A Gap object if a FVG is detected; otherwise, `na` isVolumeImbalance(barIdx)   Checks if the previous bars form a Volume Imbalance (VI)   Parameters:      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A Gap object if a VI is detected; otherwise, `na` isLiquidityVoid(barIdx)   Checks if the previous bars form a Liquidity Void (LV)   Parameters:      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A Gap object if an LV is detected; otherwise, `na` isSwingPoint(barIdx)   Checks if the previous bars form a swing point   Parameters:      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A SwingPoint object if a swing point is detected; otherwise, `na` Debugger   A debug logging utility with group support   Fields:      enabled (series bool)      _debugGroupStack (array) Session   Defines a trading session with a name and time range. When creating a new instance of this type, you MUST call init() immediately.   Fields:      name (series string) : A display-friendly name (e.g., "NY AM")      session (series string) : A string defining the session time range (e.g., "1300-1400")      enabled (series bool) : Optional flag for custom logic; defaults to false      start (series int) : UNIX time representing the session start (set via isActive())      end (series int) : UNIX time representing the session end (set via isActive())      _t (series int)      _start_HH (series float)      _start_mm (series float)      _end_HH (series float)      _end_mm (series float) Gap   Represents a price inefficiency (gap) with details on sentiment and price levels   Fields:      type (series SentimentType) : The sentiment of the gap (e.g., SentimentType.BULLISH)      name (series string) : A display-friendly name (e.g., "+FVG")      startTime (series int) : UNIX time value for the gap's start      endTime (series int) : UNIX time value for the gap's end      startIndex (series int) : Bar index where the gap starts      endIndex (series int) : Bar index where the gap ends      gapLow (series float) : The lowest price level of the gap      gapHigh (series float) : The highest price level of the gap      ce (series float) : The consequent encroachment level of the gap SwingPoint   Represents a swing point with details on type and price level   Fields:      type (series SwingPointType) : The type of swing point (e.g., SwingPointType.HIGH)      time (series int) : UNIX time value for the swing point      barIdx (series int) : Bar index where the swing point occurs      price (series float) : The price level of the swing point which is either the high or low of the middle bar LineLabel   Combines a line and box type to produce a line with a label that is properly aligned   Fields:      x (series int) : The X-axis starting point as a bar index      y (series float) : The Y-axis starting point as the price level      color (series color) : Both the line and text color      width (series int) : Thickness of the line      label (series string) : Text to display      showLabel (series bool) : Boolean to conditionally show/hide the label (default is false)      lineStyle (series LineStyleType) : The style of the line      textSize (series TextSizeType)      _b (series box)      _l (series line)
Pine Script® library
by tristanlee85
TrinityBar**TrinityBar Strategy Description** The TrinityBar strategy is a price‐action based trading model that leverages Bill Williams’ bar thirds concept to generate entry signals and execute market orders automatically. Here’s how it works: 1. **Bar Thirds Calculation:** The strategy calculates the range of both the current fully formed bar and the previous fully formed bar. It then divides each bar’s range into three equal parts (thirds). - For the current bar, the lower third and upper third levels are computed. - The same is done for the previous bar. 2. **Bar Type Classification:** Each bar is classified into one of several types based on where its open and close fall relative to its thirds: - **Bullish Patterns:** - *1‑3 Bar:* Opens in the lower third and closes in the upper third. - *2‑3 Bar:* Opens in the middle third and closes in the upper third. - *3‑3 Bar:* Both open and close are in the upper third. - **Bearish Patterns:** - *3‑1 Bar:* Opens in the upper third and closes in the lower third. - *2‑1 Bar:* Opens in the middle third and closes in the lower third. - *1‑1 Bar:* Both open and close are in the lower third. 3. **Signal Generation:** - **Bullish Signal:** A valid buy is generated when the previous bar exhibits any bullish pattern (1‑3, 2‑3, or 3‑3) and the current bar is either a 1‑3 or a 3‑3 bar. - **Bearish Signal:** A valid sell is generated when the previous bar shows any bearish pattern (1‑1, 2‑1, or 3‑1) and the current bar is either a 1‑1 or a 3‑1 bar. 4. **Visual Alerts:** When a valid signal is identified, the strategy plots a small triangle below the bar for a buy signal (labeled “B” in green) and a triangle above the bar for a sell signal (labeled “S” in red). 5. **Trade Execution:** Once a signal is confirmed: - If a bullish signal is generated, any short positions are closed, and if there is no existing long position, a market long order is entered. - Conversely, if a bearish signal occurs, any long positions are closed, and a market short order is entered if not already in a short position. This strategy is designed to capture significant price expansions by relying solely on price action and bar structure, without relying on lagging indicators. It provides a mechanical, systematic approach that removes emotional bias from trading decisions.
Pine Script® strategy
by Forex-Therapy
Uptrick: Fisher Eclipse1. Name and Purpose Uptrick: Fisher Eclipse is a Pine version 6 extension of the basic Fisher Transform indicator that focuses on highlighting potential turning points in price data. Its purpose is to allow traders to spot shifts in momentum, detect divergence, and adapt signals to different market environments. By combining a core Fisher Transform with additional signal processing, divergence detection, and customizable aggressiveness settings, this script aims to help users see when a price move might be losing momentum or gaining strength. 2. Overview This script uses a Fisher Transform calculation on the average of each bar’s high and low (hl2). The Fisher Transform is designed to amplify price extremes by mapping data into a different scale, making potential reversals more visible than they might be with standard oscillators. Uptrick: Fisher Eclipse takes this concept further by integrating a signal line, divergence detection, bar coloring for momentum intensity, and optional thresholds to reduce unwanted noise. 3. Why Use the Fisher Transform The Fisher Transform is known for converting relatively smoothed price data into a more pronounced scale. This transformation highlights where markets may be overextended. In many cases, standard oscillators move gently, and traders can miss subtle hints that a reversal might be approaching. The Fisher Transform’s mathematical approach tightens the range of values and sharpens the highs and lows. This behavior can allow traders to see clearer peaks and troughs in momentum. Because it is often quite responsive, it can help anticipate areas where price might change direction, especially when compared to simpler moving averages or traditional oscillators. The result is a more evident signal of possible overbought or oversold conditions. 4. How This Extension Improves on the Basic Fisher Transform Uptrick: Fisher Eclipse adds multiple features to the classic Fisher framework in order to address different trading styles and market behaviors: a) Divergence Detection The script can detect bullish or bearish divergences between price and the oscillator over a chosen lookback period, helping traders anticipate shifts in market direction. b) Bar Coloring When momentum exceeds a certain threshold (default 3), bars can be colored to highlight surges of buying or selling pressure. This quick visual reference can assist in spotting periods of heightened activity. After a bar color like this, usually, there is a quick correction as seen in the image below. c) Signal Aggressiveness Levels Users can choose between conservative, moderate, or aggressive signal thresholds. This allows them to tune how quickly the indicator flags potential entries or exits. Aggressive settings might suit scalpers who need rapid signals, while conservative settings may benefit swing traders preferring fewer, more robust indications. d) Minimum Movement Filter A configurable filter can be set to ensure that the Fisher line and its signal have a sufficient gap before triggering a buy or sell signal. This step is useful for traders seeking to minimize signals during choppy or sideways markets. This can be used to eliminate noise as well. By combining all these elements into one package, the indicator attempts to offer a comprehensive toolkit for those who appreciate the Fisher Transform’s clarity but also desire more versatility. 5. Core Components a) Fisher Transform The script calculates a Fisher value using normalized price over a configurable length, highlighting potential peaks and troughs. b) Signal Line The Fisher line is smoothed using a short Simple Moving Average. Crossovers and crossunders are one of the key ways this indicator attempts to confirm momentum shifts. c) Divergence Logic The script looks back over a set number of bars to compare current highs and lows of both price and the Fisher oscillator. When price and the oscillator move in opposing directions, a divergence may occur, suggesting a possible upcoming reversal or weakening trend. d) Thresholds for Overbought and Oversold Horizontal lines are drawn at user-chosen overbought and oversold levels. These lines help traders see when momentum readings reach particular extremes, which can be especially relevant when combined with crossovers in that region. e) Intensity Filter and Bar Coloring If the magnitude of the change in the Fisher Transform meets or exceeds a specified threshold, bars are recolored. This provides a visual cue for significant momentum changes. 6. User Inputs a) length Defines how many bars the script looks back to compute the highest high and lowest low for the Fisher Transform. A smaller length reacts more quickly but can be noisier, while a larger length smooths out the indicator at the cost of responsiveness. b) signal aggressiveness Adjusts the buy and sell thresholds for conservative, moderate, and aggressive trading styles. This can be key in matching the indicator to personal risk preferences or varying market conditions. Conservative will give you less signals and aggressive will give you more signals. c) minimum movement filter Specifies how far apart the Fisher line and its signal line must be before generating a valid crossover signal. d) divergence lookback Controls how many bars are examined when determining if price and the oscillator are diverging. A larger setting might generate fewer signals, while a smaller one can provide more frequent alerts. e) intensity threshold Determines how large a change in the Fisher value must be for the indicator to recolor bars. Strong momentum surges become more noticeable. f) overbought level and oversold level Lets users define where they consider market conditions to be stretched on the upside or downside. 7. Calculation Process a) Price Input The script uses the midpoint of each bar’s high and low, sometimes referred to as hl2. hl2 = (high + low) / 2 b) Range Normalization Determine the maximum (maxHigh) and minimum (minLow) values over a user-defined lookback period (length). Scale the hl2 value so it roughly fits between -1 and +1: value = 2 * ((hl2 - minLow) / (maxHigh - minLow) - 0.5) This step highlights the bar’s current position relative to its recent highs and lows. c) Fisher Calculation Convert the normalized value into the Fisher Transform: fisher = 0.5 * ln( (1 + value) / (1 - value) ) + 0.5 * fisher_previous fisher_previous is simply the Fisher value from the previous bar. Averaging half of the new transform with half of the old value smooths the result slightly and can prevent erratic jumps. ln is the natural logarithm function, which compresses or expands values so that market turns often become more obvious. d) Signal Smoothing Once the Fisher value is computed, a short Simple Moving Average (SMA) is applied to produce a signal line. In code form, this often looks like: signal = sma(fisher, 3) Crossovers of the fisher line versus the signal line can be used to hint at changes in momentum: • A crossover occurs when fisher moves from below to above the signal. • A crossunder occurs when fisher moves from above to below the signal. e) Threshold Checking Users typically define oversold and overbought levels (often -1 and +1). Depending on aggressiveness settings (conservative, moderate, aggressive), these thresholds are slightly shifted to filter out or include more signals. For example, an oversold threshold of -1 might be used in a moderate setting, whereas -1.5 could be used in a conservative setting to require a deeper dip before triggering. f) Divergence Checks The script looks back a specified number of bars (divergenceLookback). For both price and the fisher line, it identifies: • priceHigh = the highest hl2 within the lookback • priceLow = the lowest hl2 within the lookback • fisherHigh = the highest fisher value within the lookback • fisherLow = the lowest fisher value within the lookback If price forms a lower low while fisher forms a higher low, it can signal a bullish divergence. Conversely, if price forms a higher high while fisher forms a lower high, a bearish divergence might be indicated. g) Bar Coloring The script monitors the absolute change in Fisher values from one bar to the next (sometimes called fisherChange): fisherChange = abs(fisher - fisher ) If fisherChange exceeds a user-defined intensityThreshold, bars are recolored to highlight a surge of momentum. Aqua might indicate a strong bullish surge, while purple might indicate a strong bearish surge. This color-coding provides a quick visual cue for traders looking to spot large momentum swings without constantly monitoring indicator values. 8. Signal Generation and Filtering Buy and sell signals occur when the Fisher line crosses the signal line in regions defined as oversold or overbought. The optional minimum movement filter prevents triggering if Fisher and its signal line are too close, reducing the chance of small, inconsequential price fluctuations creating frequent signals. Divergences that appear in oversold or overbought regions can serve as additional evidence that momentum might soon shift. 9. Visualization on the Chart Uptrick: Fisher Eclipse plots two lines: the Fisher line in one color and the signal line in a contrasting shade. The chart displays horizontal dashed lines where the overbought and oversold levels lie. When the Fisher Transform experiences a sharp jump or drop above the intensity threshold, the corresponding price bars may change color, signaling that momentum has undergone a noticeable shift. If the indicator detects bullish or bearish divergence, dotted lines are drawn on the oscillator portion to connect the relevant points. 10. Market Adaptability Because of the different aggressiveness levels and the optional minimum movement filter, Uptrick: Fisher Eclipse can be tailored to multiple trading styles. For instance, a short-term scalper might select a smaller length and more aggressive thresholds, while a swing trader might choose a longer length for smoother readings, along with conservative thresholds to ensure fewer but potentially stronger signals. During strongly trending markets, users might rely more on divergences or large intensity changes, whereas in a range-bound market, oversold or overbought conditions may be more frequent. 11. Risk Management Considerations Indicators alone do not ensure favorable outcomes, and relying solely on any one signal can be risky. Using a stop-loss or other protections is often suggested, especially in fast-moving or unpredictable markets. Divergence can appear before a market reversal actually starts. Similarly, a Fisher Transform can remain in an overbought or oversold region for extended periods, especially if the trend is strong. Cautious interpretation and confirmation with additional methods or chart analysis can help refine entry and exit decisions. 12. Combining with Other Tools Traders can potentially strengthen signals from Uptrick: Fisher Eclipse by checking them against other methods. If a moving average cross or a price pattern aligns with a Fisher crossover, the combined evidence might provide more certainty. Volume analysis may confirm whether a shift in market direction has participation from a broad set of traders. Support and resistance zones could reinforce overbought or oversold signals, particularly if price reaches a historical boundary at the same time the oscillator indicates a possible reversal. 13. Parameter Customization and Examples Some short-term traders run a 15-minute chart, with a shorter length setting, aggressively tight oversold and overbought thresholds, and a smaller divergence lookback. This approach produces more frequent signals, which may appeal to those who enjoy fast-paced trading. More conservative traders might apply the indicator to a daily chart, using a larger length, moderate threshold levels, and a bigger divergence lookback to focus on broader market swings. Results can differ, so it may be helpful to conduct thorough historical testing to see which combination of parameters aligns best with specific goals. 14. Realistic Expectations While the Fisher Transform can reveal potential turning points, no mathematical tool can predict future price behavior with full certainty. Markets can behave erratically, and a period of strong trending may see the oscillator pinned in an extreme zone without a significant reversal. Divergence signals sometimes appear well before an actual trend change occurs. Recognizing these limitations helps traders manage risk and avoids overreliance on any one aspect of the script’s output. 15. Theoretical Background The Fisher Transform uses a logarithmic formula to map a normalized input, typically ranging between -1 and +1, into a scale that can fluctuate around values like -3 to +3. Because the transformation exaggerates higher and lower readings, it becomes easier to spot when the market might have stretched too far, too fast. Uptrick: Fisher Eclipse builds on that foundation by adding a series of practical tools that help confirm or refine those signals. 16. Originality and Uniqueness Uptrick: Fisher Eclipse is not simply a duplicate of the basic Fisher Transform. It enhances the original design in several ways, including built-in divergence detection, bar-color triggers for momentum surges, thresholds for overbought and oversold levels, and customizable signal aggressiveness. By unifying these concepts, the script seeks to reduce noise and highlight meaningful shifts in market direction. It also places greater emphasis on helping traders adapt the indicator to their specific style—whether that involves frequent intraday signals or fewer, more robust alerts over longer timeframes. 17. Summary Uptrick: Fisher Eclipse is an expanded take on the original Fisher Transform oscillator, including divergence detection, bar coloring based on momentum strength, and flexible signal thresholds. By adjusting parameters like length, aggressiveness, and intensity thresholds, traders can configure the script for day-trading, swing trading, or position trading. The indicator endeavors to highlight where price might be shifting direction, but it should still be combined with robust risk management and other analytical methods. Doing so can lead to a more comprehensive view of market conditions. 18. Disclaimer No indicator or script can guarantee profitable outcomes in trading. Past performance does not necessarily suggest future results. Uptrick: Fisher Eclipse is provided for educational and informational purposes. Users should apply their own judgment and may want to confirm signals with other tools and methods. Deciding to open or close a position remains a personal choice based on each individual’s circumstances and risk tolerance.
Pine Script® indicator
by Uptrick
NVOL Normalized Volume & VolatilityOVERVIEW Plots a normalized volume (or volatility) relative to a given bar's typical value across all charted sessions. The concept is similar to Relative Volume (RVOL) and Average True Range (ATR), but rather than using a moving average, this script uses bar data from previous sessions to more accurately separate what's normal from what's anomalous. Compatible on all timeframes and symbols. Having volume and volatility processed within a single indicator not only allows you to toggle between the two for a consistent data display, it also allows you to measure how correlated they are. These measurements are available in the data table. DATA & MATH The core formula used to normalize each bar is: ( Value / Basis ) × Scale Value The current bar's volume or volatility (see INPUTS section). When set to volume, it's exactly what you would expect (the volume of the bar). When set to volatility, it's the bar's range (high - low). Basis A statistical threshold (Mean, Median, or Q3) plus a Sigma multiple (standard deviations). The default is set to the Mean + Sigma × 3 , which represents 99.7% of data in a normal distribution. The values are derived from the current bar's equivalent in other sessions. For example, if the current bar time is 9:30 AM, all previous 9:30 AM bars would be used to get the Mean and Sigma. Thus Mean + Sigma × 3 would represent the Normal Bar Vol at 9:30 AM. Scale Depends on the Normalize setting, where it is 1 when set to Ratio, and 100 when set to Percent. This simply determines the plot's scale (ie. 0 to 1 vs. 0 to 100). INPUTS While the default configuration is recommended for a majority of use cases (see BEST PRACTICES), settings should be adjusted so most of the Normalized Plot and Linear Regression are below the Signal Zone. Only the most extreme values should exceed this area. Normalize Allows you to specify what should be normalized (Volume or Volatility) and how it should be measured (as a Ratio or Percentage). This sets the value and scale in the core formula. Basis Specifies the statistical threshold (Mean, Median, or Q3) and how many standard deviations should be added to it (Sigma). This is the basis in the core formula. Mean is the sum of values divided by the quantity of values. It's what most people think of when they say "average." Median is the middle value, where 50% of the data will be lower and 50% will be higher. Q3 is short for Third Quartile, where 75% of the data will be lower and 25% will be higher (think three quarters). Sample Determines the maximum sample size. All Charted Bars is the default and recommended option, and ignores the adjacent lookback number. Lookback is not recommended, but it is available for comparisons. It uses the adjacent lookback number and is likely to produce unreliable results outside a very specific context that is not suitable for most traders. Normalization is not a moving average. Unless you have a good reason to limit the sample size, do not use this option and instead use All Charted Bars . Show Vol. name on plot Overlays "VOLUME" or "VOLATILITY" on the plot (whichever you've selected). Lin. Reg. Polynomial regressions are great for capturing non-linear patterns in data. TradingView offers a "linear regression curve", which this script uses as a substitute. If you're unfamiliar with either term, think of this like a better moving average. You're able to specify the color, length, and multiple (how much to amplify the value). The linear regression derives its value from the normalized values. Norm. Val. This is the color of the normalized value of the current bar (see DATA & MATH section). You're able to specify the default, within signal, and beyond signal colors. As well as the plot style. Fade in colors between zero and the signal Programmatically adjust the opacity of the primary plot color based on it's normalized value. When enabled, values equal to 0 will be fully transparent, become more opaque as they move away from 0, and be fully opaque at the signal. Adjusting opacity in this way helps make difference more obvious. Plot relative to bar direction If enabled, the normalized value will be multiplied by -1 when a bar's open is greater than the bar's close, mirroring price direction. Technically volume and volatility are directionless. Meaning there's really no such thing as buy volume, sell volume, positive volatility, or negative volatility. There is just volume (1 buy = 1 sell = 1 volume) and volatility (high - low). Even so, visually reflecting the net effect of pricing pressure can still be useful. That's all this setting does. Sig. Zone Signal zones make identifying extremes easier. They do not signal if you should buy or sell, only that the current measurement is beyond what's normal. You are able to adjust the color and bounds of the zone. Int. Levels Interim levels can be useful when you want to visually bracket values into high / medium / low. These levels can have a value anywhere between 0 and 1. They will automatically be multiplied by 100 when the scale is set to Percent. Zero Line This setting allows you to specify the visibility of the zero line to best suit your trading style. Volume & Volatility Stats Displays a table of core values for both volume and volatility. Specifically the actual value, threshold (mean, median, or Q3), sigma (standard deviation), basis, normalized value, and linear regression. Correlation Stats Displays a table of correlation statistics for the current bar, as well as the data set average. Specifically the coefficient, R2, and P-Value. Indices & Sample Size Displays a table of mixed data. Specifically the current bar's index within the session, the current bar's index within the sample, and the sample size used to normalize the current bar's value. BEST PRACTICES NVOL can tell you what's normal for 9:30 AM. RVOL and ATR can only tell you if the current value is higher or lower than a moving average. In a normal distribution (bell curve) 99.7% of data occurs within 3 standard deviations of the mean. This is why the default basis is set to "Mean, 3"; it includes the typical day-to-day fluctuations, better contextualizing what's actually normal, minimizing false positives. This means a ratio value greater than 1 only occurs 0.3% of the time. A series of these values warrants your attention. Which is why the default signal zone is between 1 and 2. Ratios beyond 2 would be considered extreme with the default settings. Inversely, ratio values less than 1 (the normal daily fluctuations) also tell a story. We should expect most values to occur around the middle 3rd, which is why interim levels default to 0.33 and 0.66, visually simplifying a given move's participation. These can be set to whatever you like and only serve as visual aids for your specific trading style. It's worth noting that the linear regression oscillates when plotted directionally, which can help clarify short term move exhaustion and continuation. Akin to a relative strength index (RSI), it may be used to inform a trading decision, but it should not be the only factor.
Pine Script® indicator
by liquid-trader
3
[Defaust] Fractals Fractals Indicator Overview The Fractals Indicator is a technical analysis tool designed to help traders identify potential reversal points in the market by detecting fractal patterns. This indicator is a fork of the original fractals indicator, with adjustments made to the plotting for enhanced visual clarity and usability. What Are Fractals? In trading, a fractal is a pattern consisting of five consecutive bars (candlesticks) that meet specific conditions: Up Fractal (Potential Sell Signal): Occurs when a high point is surrounded by two lower highs on each side. Down Fractal (Potential Buy Signal): Occurs when a low point is surrounded by two higher lows on each side. Fractals help traders identify potential tops and bottoms in the market, signaling possible entry or exit points. Features of the Indicator Customizable Periods (n): Allows you to define the number of periods to consider when detecting fractals, offering flexibility to adapt to different trading strategies and timeframes. Enhanced Plotting Adjustments: This fork introduces adjustments to the plotting of fractal signals for better visual representation on the chart. Visual Signals: Plots up and down triangles on the chart to signify down fractals (potential bullish signals) and up fractals (potential bearish signals), respectively. Overlay on Chart: The fractal signals are overlaid directly on the price chart for immediate visualization. Adjustable Precision: You can set the precision of the plotted values according to your needs. Pine Script Code Explanation Below is the Pine Script code for the Fractals Indicator: //@version=5 indicator(" Fractals", shorttitle=" Fractals", format=format.price, precision=0, overlay=true) // User input for the number of periods to consider for fractal detection n = input.int(title="Periods", defval=2, minval=2) // Initialize flags for up fractal detection bool upflagDownFrontier = true bool upflagUpFrontier0 = true bool upflagUpFrontier1 = true bool upflagUpFrontier2 = true bool upflagUpFrontier3 = true bool upflagUpFrontier4 = true // Loop through previous and future bars to check conditions for up fractals for i = 1 to n // Check if the highs of previous bars are less than the current bar's high upflagDownFrontier := upflagDownFrontier and (high < high ) // Check various conditions for future bars upflagUpFrontier0 := upflagUpFrontier0 and (high < high ) upflagUpFrontier1 := upflagUpFrontier1 and (high <= high and high < high ) upflagUpFrontier2 := upflagUpFrontier2 and (high <= high and high <= high and high < high ) upflagUpFrontier3 := upflagUpFrontier3 and (high <= high and high <= high and high <= high and high < high ) upflagUpFrontier4 := upflagUpFrontier4 and (high <= high and high <= high and high <= high and high <= high and high < high ) // Combine the flags to determine if an up fractal exists flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4 upFractal = (upflagDownFrontier and flagUpFrontier) // Initialize flags for down fractal detection bool downflagDownFrontier = true bool downflagUpFrontier0 = true bool downflagUpFrontier1 = true bool downflagUpFrontier2 = true bool downflagUpFrontier3 = true bool downflagUpFrontier4 = true // Loop through previous and future bars to check conditions for down fractals for i = 1 to n // Check if the lows of previous bars are greater than the current bar's low downflagDownFrontier := downflagDownFrontier and (low > low ) // Check various conditions for future bars downflagUpFrontier0 := downflagUpFrontier0 and (low > low ) downflagUpFrontier1 := downflagUpFrontier1 and (low >= low and low > low ) downflagUpFrontier2 := downflagUpFrontier2 and (low >= low and low >= low and low > low ) downflagUpFrontier3 := downflagUpFrontier3 and (low >= low and low >= low and low >= low and low > low ) downflagUpFrontier4 := downflagUpFrontier4 and (low >= low and low >= low and low >= low and low >= low and low > low ) // Combine the flags to determine if a down fractal exists flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4 downFractal = (downflagDownFrontier and flagDownFrontier) // Plot the fractal symbols on the chart with adjusted plotting plotshape(downFractal, style=shape.triangleup, location=location.belowbar, offset=-n, color=color.gray, size=size.auto) plotshape(upFractal, style=shape.triangledown, location=location.abovebar, offset=-n, color=color.gray, size=size.auto) Explanation: Input Parameter (n): Sets the number of periods for fractal detection. The default value is 2, and it must be at least 2 to ensure valid fractal patterns. Flag Initialization: Boolean variables are used to store intermediate conditions during fractal detection. Loops: Iterate through the specified number of periods to evaluate the conditions for fractal formation. Conditions: Up Fractals: Checks if the current high is greater than previous highs and if future highs are lower or equal to the current high. Down Fractals: Checks if the current low is lower than previous lows and if future lows are higher or equal to the current low. Flag Combination: Logical and and or operations are used to combine the flags and determine if a fractal exists. Adjusted Plotting: The plotting of fractal symbols has been adjusted for better alignment and visual clarity. The offset parameter is set to -n to align the plotted symbols with the correct bars. The color and size have been fine-tuned for better visibility. How to Use the Indicator Adding the Indicator to Your Chart Open TradingView: Go to TradingView. Access the Chart: Click on "Chart" to open the main charting interface. Add the Indicator: Click on the "Indicators" button at the top. Search for " Fractals". Select the indicator from the list to add it to your chart. Configuring the Indicator Periods (n): Default value is 2. Adjust this parameter based on your preferred timeframe and sensitivity. A higher value of n considers more bars for fractal detection, potentially reducing the number of signals but increasing their significance. Interpreting the Signals – Up Fractal (Downward Triangle): Indicates a potential price reversal to the downside. May be used as a signal to consider exiting long positions or tightening stop-loss orders. – Down Fractal (Upward Triangle): Indicates a potential price reversal to the upside. May be used as a signal to consider entering long positions or setting stop-loss orders for short positions. Trading Strategy Suggestions Up Fractal Detection: The high of the current bar (n) is higher than the highs of the previous two bars (n - 1, n - 2). The highs of the next bars meet certain conditions to confirm the fractal pattern. An up fractal symbol (downward triangle) is plotted above the bar at position n - n (due to the offset). Down Fractal Detection: The low of the current bar (n) is lower than the lows of the previous two bars (n - 1, n - 2). The lows of the next bars meet certain conditions to confirm the fractal pattern. A down fractal symbol (upward triangle) is plotted below the bar at position n - n. Benefits of Using the Fractals Indicator Early Signals: Helps in identifying potential reversal points in price movements. Customizable Sensitivity: Adjusting the n parameter allows you to fine-tune the indicator based on different market conditions. Enhanced Visuals: Adjustments to plotting improve the clarity and readability of fractal signals on the chart. Limitations and Considerations Lagging Indicator: Fractals require future bars to confirm the pattern, which may introduce a delay in the signals. False Signals: In volatile or ranging markets, fractals may produce false signals. It's advisable to use them in conjunction with other analysis tools. Not a Standalone Tool: Fractals should be part of a broader trading strategy that includes other indicators and fundamental analysis. Best Practices for Using This Indicator Combine with Other Indicators: Use in combination with trend indicators, oscillators, or volume analysis to confirm signals. Backtesting: Before applying the indicator in live trading, backtest it on historical data to understand its performance. Adjust Periods Accordingly: Experiment with different values of n to find the optimal setting for the specific asset and timeframe you are trading. Disclaimer The Fractals Indicator is intended for educational and informational purposes only. Trading involves significant risk, and you should be aware of the risks involved before proceeding. Past performance is not indicative of future results. Always conduct your own analysis and consult with a professional financial advisor before making any investment decisions. Credits This indicator is a fork of the original fractals indicator, with adjustments made to the plotting for improved visual representation. It is based on standard fractal patterns commonly used in technical analysis and has been developed to provide traders with an effective tool for detecting potential reversal points in the market.
Pine Script® indicator
by defaustofficial
WaveTrend With Divs & RSI(STOCH) Divs by WeloTradesWaveTrend with Divergences & RSI(STOCH) Divergences by WeloTrades Overview The "WaveTrend With Divergences & RSI(STOCH) Divergences" is an advanced Pine Script™ indicator designed for TradingView, offering a multi-dimensional analysis of market conditions. This script integrates several technical indicators—WaveTrend, Money Flow Index (MFI), RSI, and Stochastic RSI—into a cohesive tool that identifies both regular and hidden divergences across these indicators. These divergences can indicate potential market reversals and provide critical trading opportunities. This indicator is not just a simple combination of popular tools; it offers extensive customization options, organized data presentation, and valuable trading signals that are easy to interpret. Whether you're a day trader or a long-term investor, this script enhances your ability to make informed decisions. Originality and Usefulness The originality of this script lies in its integration and the synergy it creates among the indicators used. Rather than merely combining multiple indicators, this script allows them to work together, enhancing each other's strengths. For example, by identifying divergences across WaveTrend, RSI, and Stochastic RSI simultaneously, the script provides multiple layers of confirmation, which reduces the likelihood of false signals and increases the reliability of trading signals. The usefulness of this script is apparent in its ability to offer a consolidated view of market dynamics. It not only simplifies the analytical process by combining different indicators but also provides deeper insights through its divergence detection features. This comprehensive approach is designed to help traders identify potential market reversals, confirm trends, and ultimately make more informed trading decisions. How the Components Work Together 1. Cross-Validation of Signals WaveTrend: This indicator is primarily used to identify overbought and oversold conditions, as well as potential buy and sell signals. WaveTrend's ability to smooth price data and reduce noise makes it a reliable tool for identifying trend reversals. RSI & Stochastic RSI: These momentum oscillators are used to measure the speed and change of price movements. While RSI identifies general overbought and oversold conditions, Stochastic RSI offers a more granular view by tracking the RSI’s level relative to its high-low range over a period of time. When these indicators align with WaveTrend signals, it adds a layer of confirmation that enhances the reliability of the signals. Money Flow Index (MFI): This volume-weighted indicator assesses the inflow and outflow of money in an asset, giving insights into buying and selling pressure. By analyzing the MFI alongside WaveTrend and RSI indicators, the script can cross-validate signals, ensuring that buy or sell signals are supported by actual market volume. Example Bullish scenario: When a bullish divergence is detected on the RSI and confirmed by a corresponding bullish signal on the WaveTrend, along with an increasing Money Flow Index, the probability of a successful trade setup increases. This cross-validation minimizes the risk of acting on false signals, which might occur when relying on a single indicator. Example Bearish scenario: When a bearish divergence is detected on the RSI and confirmed by a corresponding bearish signal on the WaveTrend, along with an decreasing Money Flow Index, the probability of a successful trade setup increases. This cross-validation minimizes the risk of acting on false signals, which might occur when relying on a single indicator. 2. Divergence Detection and Market Reversals Regular Divergences: Occur when the price action and an indicator (like RSI or WaveTrend) move in opposite directions. Regular bullish divergence signals a potential upward reversal when the price makes a lower low while the indicator makes a higher low. Conversely, regular bearish divergence suggests a downward reversal when the price makes a higher high, but the indicator makes a lower high. Hidden Divergences: These occur when the price action and indicator move in the same direction, but with different momentum. Hidden bullish divergence suggests the continuation of an uptrend, while hidden bearish divergence suggests the continuation of a downtrend. By detecting these divergences across multiple indicators, the script identifies potential trend reversals or continuations with greater accuracy. Example: The script might detect a regular bullish divergence on the WaveTrend while simultaneously identifying a hidden bullish divergence on the RSI. This combination suggests that while a trend reversal is possible, the overall market sentiment remains bullish, providing a nuanced view of the market. A Regular Bullish Divergence Example: A Hidden Bullish Divergence Example: A Regular Bearish Divergence Example: A Hidden Bearish Divergence Example: 3. Trend Strength and Sentiment Analysis WaveTrend: Measures the strength and direction of the trend. By identifying the extremes of market sentiment (overbought and oversold levels), WaveTrend provides early signals for potential reversals. Money Flow Index (MFI): Assesses the underlying sentiment by analyzing the flow of money. A rising MFI during an uptrend confirms strong buying pressure, while a falling MFI during a downtrend confirms selling pressure. This helps traders assess whether a trend is likely to continue or reverse. RSI & Stochastic RSI: Offer a momentum-based perspective on the trend’s strength. High RSI or Stochastic RSI values indicate that the asset may be overbought, suggesting a potential reversal. Conversely, low values indicate oversold conditions, signaling a possible upward reversal. Example: During a strong uptrend, the WaveTrend & RSI's might signal overbought conditions, suggesting caution. If the MFI also shows decreasing buying pressure and the RSI reaches extreme levels, these indicators together suggest that the trend might be weakening, and a reversal could be imminent. Example: During a strong downtrend, the WaveTrend & RSI's might signal oversold conditions, suggesting caution. If the MFI also shows increasing buying pressure and the RSI reaches extreme levels, these indicators together suggest that the trend might be weakening, and a reversal could be imminent. Conclusion The "WaveTrend With Divergences & RSI(STOCH) Divergences" script offers a powerful, integrated approach to technical analysis by combining trend, momentum, and sentiment indicators into a single tool. Its unique value lies in the cross-validation of signals, the ability to detect divergences, and the comprehensive view it provides of market conditions. By offering traders multiple layers of analysis and customization options, this script is designed to enhance trading decisions, reduce false signals, and provide clearer insights into market dynamics. WAVETREND Display of WaveTrend: Display of WaveTrend Setting: WaveTrend Indicator Explanation The WaveTrend indicator helps identify overbought and oversold conditions, as well as potential buy and sell signals. Its flexibility allows traders to adapt it to various strategies, making it a versatile tool in technical analysis. WaveTrend Input Settings: WT MA Source: Default: HLC3 What it is: The data source used for calculating the WaveTrend Moving Average. What it does: Determines the input data to smooth price action and filter noise. Example: Using HLC3 (average of High, Low, Close) provides a smoother data representation compared to using just the closing price. Length (WT MA Length): Default: 3 What it is: The period used to calculate the Moving Average. What it does: Adjusts the sensitivity of the WaveTrend indicator, where shorter lengths respond more quickly to price changes. Example: A length of 3 is ideal for short-term analysis, providing quick reactions to price movements. WT Channel Length & Average: Default: WT Channel Length = 9, Average = 12 What it is: Lengths used to calculate the WaveTrend channel and its average. What it does: Smooths out the WaveTrend further, reducing false signals by averaging over a set period. Example: Higher values reduce noise and help in identifying more reliable trends. Channel: Style, Width, and Color: What it is: Customization options for the WaveTrend channel's appearance. What it does: Adjusts how the channel is displayed, including line style, width, and color. Example: Choosing an area style with a distinct color can make the WaveTrend indicator clearly visible on the chart. WT Buy & Sell Signals: What it is: Settings to enable and customize buy and sell signals based on WaveTrend. What it does: Allows for the display of buy/sell signals and customization of their shapes and colors. When it gives a Buy Signal: Generated when the WaveTrend line crosses below an oversold level and then rises back, indicating a potential upward price movement. When it gives a Sell Signal: Triggered when the WaveTrend line crosses above an overbought level and then declines, suggesting a possible downward trend. Example: The script identifies these signals based on mean reversion principles, where prices tend to revert to the mean after reaching extremes. Traders can use these signals to time their entries and exits effectively. WAVETREND OVERBOUGTH AND OVERSOLD LEVELS Display of WaveTrend with Overbought & Oversold Levels: Display of WaveTrend Overbought & Oversold Levels Settings: WaveTrend Overbought & Oversold Levels Explanation WT OB & OS Levels: Default: OB Level 1 = 53, OB Level 2 = 60, OS Level 1 = -53, OS Level 2 = -60 What it is: The default overbought and oversold levels used by the WaveTrend indicator to signal potential market reversals. What it does: When the WaveTrend crosses above the OB levels, it indicates an overbought condition, potentially signaling a reversal or selling opportunity. Conversely, when it crosses below the OS levels, it indicates an oversold condition, potentially signaling a reversal or buying opportunity. Example: A trader might use these levels to time entry or exit points, such as selling when the WaveTrend crosses into the overbought zone or buying when it crosses into the oversold zone. Show OB/OS Levels: Default: True What it is: Toggle options to show or hide the overbought and oversold levels on your chart. What it does: When enabled, these levels will be visually represented on your chart, helping you to easily identify when the market reaches these critical thresholds. Example: Displaying these levels can help you quickly see when the WaveTrend is approaching or has crossed into overbought or oversold territory, allowing for more informed trading decisions. Line Style, Width, and Color for OB/OS Levels: What it is: Options to customize the appearance of the OB and OS levels on your chart, including line style (solid, dotted, dashed), line width, and color. What it does: These settings allow you to adjust how prominently these levels are displayed on your chart, which can help you better visualize and respond to overbought or oversold conditions. Example: Setting a thicker, dashed line in a contrasting color can make these levels stand out more clearly, aiding in quick visual identification. Example of Use: Scenario: A trader wants to identify potential selling points when the market is overbought. They set the OB levels at 53 and 60, choosing a solid, red line style to make these levels clear on their chart. As the WaveTrend crosses above 53, they monitor for further price action, and upon crossing 60, they consider initiating a sell order. WAVETREND DIVERGENCES Display of WaveTrend Divergence: Display of WaveTrend Divergence Setting: WaveTrend Divergence Indicator Explanation The WaveTrend Divergence feature helps identify potential reversal points in the market by highlighting divergences between the price and the WaveTrend indicator. Divergences can signal a shift in market momentum, indicating a possible trend reversal. This component allows traders to visualize and customize divergence detection on their charts. WaveTrend Divergence Input Settings: Potential Reversal Range: Default: 28 What it is: The number of bars to look back when detecting potential tops and bottoms. What it does: Sets the range for identifying possible reversal points based on historical data. Example: A setting of 28 looks back across the last 28 bars to find reversal points, offering a balance between responsiveness and reliability. Reversal Minimum LVL OB & OS: Default: OB = 35, OS = -35 What it is: The minimum overbought and oversold levels required for detecting potential reversals. What it does: Adjusts the thresholds that trigger a reversal signal based on the WaveTrend indicator. Example: A higher OB level reduces the sensitivity to overbought conditions, potentially filtering out false reversal signals. Lookback Bar Left & Right: Default: Left = 10, Right = 1 What it is: The number of bars to the left and right used to confirm a top or bottom. What it does: Helps determine the position of peaks and troughs in the price action. Example: A larger left lookback captures more extended price action before the peak, while a smaller right lookback focuses on the immediate past. Lookback Range Min & Max: Default: Min = 5, Max = 60 What it is: The minimum and maximum range for the lookback period when identifying divergences. What it does: Fine-tunes the detection of divergences by controlling the range over which the indicator looks back. Example: A wider range increases the chances of detecting divergences across different market conditions. R.Div Minimum LVL OB & OS: Default: OB = 53, OS = -53 What it is: The threshold levels for detecting regular divergences. What it does: Adjusts the sensitivity of the regular divergence detection. Example: Higher thresholds make the detection more conservative, identifying only stronger divergence signals. H.Div Minimum LVL OB & OS: Default: OB = 20, OS = -20 What it is: The threshold levels for detecting hidden divergences. What it does: Similar to regular divergence settings but for hidden divergences, which can indicate potential reversals that are less obvious. Example: Lower thresholds make the hidden divergence detection more sensitive, capturing subtler market shifts. Divergence Label Options: What it is: Options to display and customize labels for regular and hidden divergences. What it does: Allows users to visually differentiate between regular and hidden divergences using customizable labels and colors. Example: Using different colors and symbols for regular (R) and hidden (H) divergences makes it easier to interpret signals on the chart. Text Size and Color: What it is: Customization options for the size and color of divergence labels. What it does: Adjusts the readability and visibility of divergence labels on the chart. Example: Larger text size may be preferred for charts with a lot of data, ensuring divergence labels stand out clearly. FAST & SLOW MONEY FLOW INDEX Display of Fast & Slow Money Flow: Display of Fast & Slow Money Flow Setting: Fast Money Flow Indicator Explanation The Fast Money Flow indicator helps traders identify the flow of money into and out of an asset over a shorter time frame. By tracking the volume-weighted average of price movements, it provides insights into buying and selling pressure in the market, which can be crucial for making timely trading decisions. Fast Money Flow Input Settings: Fast Money Flow: Length: Default: 9 What it is: The period used for calculating the Fast Money Flow. What it does: Determines the sensitivity of the Money Flow calculation. A shorter length makes the indicator more responsive to recent price changes, while a longer length provides a smoother signal. Example: A length of 9 is suitable for traders looking to capture quick shifts in market sentiment over a short period. Fast MFI Area Multiplier: Default: 5 What it is: A multiplier applied to the Money Flow area calculation. What it does: Adjusts the size of the Money Flow area on the chart, effectively amplifying or reducing the visual impact of the indicator. Example: A higher multiplier can make the Money Flow more prominent on the chart, aiding in the quick identification of significant money flow changes. Y Position (Y Pos): Default: 0 What it is: The vertical position adjustment for the Fast Money Flow plot on the chart. What it does: Allows you to move the Money Flow plot up or down on the chart to avoid overlap with other indicators. Example: Adjusting the Y Position can be useful if you have multiple indicators on the chart and need to maintain clarity. Fast MFI Style, Width, and Color: What it is: Customization options for how the Fast Money Flow is displayed on the chart. What it does: Enables you to choose between different plot styles (line or area), set the line width, and select colors for positive and negative money flow. Example: Using different colors for positive (green) and negative (red) money flow helps to visually distinguish between periods of buying and selling pressure. Slow Money Flow Indicator Explanation The Slow Money Flow indicator tracks the flow of money into and out of an asset over a longer time frame. It provides a broader perspective on market sentiment, smoothing out short-term fluctuations and highlighting longer-term trends. Slow Money Flow Input Settings: Slow Money Flow: Length: Default: 12 What it is: The period used for calculating the Slow Money Flow. What it does: A longer period smooths out short-term fluctuations, providing a clearer view of the overall money flow trend. Example: A length of 12 is often used by traders looking to identify sustained trends rather than short-term volatility. Slow MFI Area Multiplier: Default: 5 What it is: A multiplier applied to the Slow Money Flow area calculation. What it does: Adjusts the size of the Money Flow area on the chart, helping to emphasize the indicator’s significance. Example: Increasing the multiplier can help highlight the Money Flow in markets with less volatile price action. Y Position (Y Pos): Default: 0 What it is: The vertical position adjustment for the Slow Money Flow plot on the chart. What it does: Allows for vertical repositioning of the Money Flow plot to maintain chart clarity when used with other indicators. Example: Adjusting the Y Position ensures that the Slow Money Flow indicator does not overlap with other key indicators on the chart. Slow MFI Style, Width, and Color: What it is: Customization options for the visual display of the Slow Money Flow on the chart. What it does: Allows you to choose the plot style (line or area), set the line width, and select colors to differentiate positive and negative money flow. Example: Customizing the colors for the Slow Money Flow allows traders to quickly distinguish between buying and selling trends in the market. RSI Display of RSI: Display of RSI Setting: RSI Indicator Explanation The Relative Strength Index (RSI) is a momentum oscillator that measures the speed and change of price movements. It is typically used to identify overbought or oversold conditions in the market, providing traders with potential signals for buying or selling. RSI Input Settings: RSI Source: Default: Close What it is: The data source used for calculating the RSI. What it does: Determines which price data (e.g., close, open) is used in the RSI calculation, affecting how the indicator reflects market conditions. Example: Using the closing price is standard practice, as it reflects the final agreed-upon price for a given time period. MA Type (Moving Average Type): Default: SMA What it is: The type of moving average applied to the RSI for smoothing purposes. What it does: Changes the smoothing technique of the RSI, impacting how quickly the indicator responds to price movements. Example: Using an Exponential Moving Average (EMA) will make the RSI more sensitive to recent price changes compared to a Simple Moving Average (SMA). RSI Length: Default: 14 What it is: The period over which the RSI is calculated. What it does: Adjusts the sensitivity of the RSI. A shorter length (e.g., 7) makes the RSI more responsive to recent price changes, while a longer length (e.g., 21) smooths out the indicator, reducing the number of signals. Example: A 14-period RSI is commonly used for identifying overbought and oversold conditions, providing a balance between sensitivity and reliability. RSI Plot Style, Width, and Color: What it is: Options to customize the appearance of the RSI line on the chart. What it does: Allows you to adjust the visual representation of the RSI, including the line width and color. Example: Setting a thicker line width and a bright color like yellow can make the RSI more visible on the chart, aiding in quick analysis. Display of RSI with RSI Moving Average: RSI Moving Average Explanation The RSI Moving Average adds a smoothing layer to the RSI, helping to filter out noise and provide clearer signals. It is particularly useful for confirming trend strength and identifying potential reversals. RSI Moving Average Input Settings: MA Length: Default: 14 What it is: The period over which the Moving Average is calculated on the RSI. What it does: Adjusts the smoothing of the RSI, helping to reduce false signals and provide a clearer trend indication. Example: A 14-period moving average on the RSI can smooth out short-term fluctuations, making it easier to spot genuine overbought or oversold conditions. MA Plot Style, Width, and Color: What it is: Customization options for how the RSI Moving Average is displayed on the chart. What it does: Allows you to adjust the line width and color, helping to differentiate the Moving Average from the main RSI line. Example: Using a contrasting color for the RSI Moving Average (e.g., magenta) can help it stand out against the main RSI line, making it easier to interpret the indicator. STOCHASTIC RSI Display of Stochastic RSI: Display of Stochastic RSI Setting: Stochastic RSI Indicator Explanation The Stochastic RSI (Stoch RSI) is a momentum oscillator that measures the level of the RSI relative to its high-low range over a set period of time. It is used to identify overbought and oversold conditions, providing potential buy and sell signals based on momentum shifts. Stochastic RSI Input Settings: Stochastic RSI Length: Default: 14 What it is: The period over which the Stochastic RSI is calculated. What it does: Adjusts the sensitivity of the Stochastic RSI. A shorter length makes the indicator more responsive to recent price changes, while a longer length smooths out the fluctuations, reducing noise. Example: A length of 14 is commonly used to identify momentum shifts over a medium-term period, providing a balanced view of potential overbought or oversold conditions. Display of Stochastic RSI %K Line: Stochastic RSI %K Line Explanation The %K line in the Stochastic RSI is the main line that tracks the momentum of the RSI over the chosen period. It is the faster-moving component of the Stochastic RSI, often used to identify entry and exit points. Stochastic RSI %K Input Settings: %K Length: Default: 3 What it is: The period used for smoothing the %K line of the Stochastic RSI. What it does: Smoothing the %K line helps reduce noise and provides a clearer signal for potential market reversals. Example: A smoothing length of 3 is common, offering a balance between responsiveness and noise reduction, making it easier to spot significant momentum shifts. %K Plot Style, Width, and Color: What it is: Customization options for the visual representation of the %K line. What it does: Allows you to adjust the appearance of the %K line on the chart, including line width and color, to fit your visual preferences. Example: Setting a blue color and a medium width for the %K line makes it stand out clearly on the chart, helping to identify key points of momentum change. %K Fill Color (Above): What it is: The fill color that appears above the %K line on the chart. What it does: Adds visual clarity by shading the area above the %K line, making it easier to interpret the direction and strength of momentum. Example: Using a light blue fill color above the %K line can help emphasize bullish momentum, making it visually prominent. Display of Stochastic RSI %D Line: Stochastic RSI %D Line Explanation The %D line in the Stochastic RSI is a moving average of the %K line and acts as a signal line. It is slower-moving compared to the %K line and is often used to confirm signals or identify potential reversals when it crosses the %K line. Stochastic RSI %D Input Settings: %D Length: Default: 3 What it is: The period used for smoothing the %D line of the Stochastic RSI. What it does: Smooths out the %D line, making it less sensitive to short-term fluctuations and more reliable for identifying significant market signals. Example: A length of 3 is often used to provide a smoothed signal line that can help confirm trends or reversals indicated by the %K line. %D Plot Style, Width, and Color: What it is: Customization options for the visual representation of the %D line. What it does: Allows you to adjust the appearance of the %D line on the chart, including line width and color, to match your preferences. Example: Setting an orange color and a thicker line width for the %D line can help differentiate it from the %K line, making crossover points easier to spot. %D Fill Color (Below): What it is: The fill color that appears below the %D line on the chart. What it does: Adds visual clarity by shading the area below the %D line, making it easier to interpret bearish momentum. Example: Using a light orange fill color below the %D line can highlight bearish conditions, making it visually easier to identify. RSI & STOCHASTIC RSI OVERBOUGHT AND OVERSOLD LEVELS Display of RSI & Stochastic with Overbought & Oversold Levels: Display of RSI & Stochastic Overbought & Oversold Settings: RSI & Stochastic Overbought & Oversold Levels Explanation The Overbought (OB) and Oversold (OS) levels for RSI and Stochastic RSI indicators are key thresholds that help traders identify potential reversal points in the market. These levels are used to determine when an asset is likely overbought or oversold, which can signal a potential trend reversal. RSI & Stochastic Overbought & Oversold Input Settings: RSI & Stochastic Level 1 Overbought (OB) & Oversold (OS): Default: OB Level = 170, OS Level = 130 What it is: The first set of thresholds for determining overbought and oversold conditions for both RSI and Stochastic RSI indicators. What it does: When the RSI or Stochastic RSI crosses above the overbought level, it suggests that the asset might be overbought, potentially signaling a sell opportunity. Conversely, when these indicators drop below the oversold level, it suggests the asset might be oversold, potentially signaling a buy opportunity. Example: If the RSI crosses above 170, traders might look for signs of a potential trend reversal to the downside, while a cross below 130 might indicate a reversal to the upside. RSI & Stochastic Level 2 Overbought (OB) & Oversold (OS): Default: OB Level = 180, OS Level = 120 What it is: The second set of thresholds for determining overbought and oversold conditions for both RSI and Stochastic RSI indicators. What it does: These levels provide an additional set of reference points, allowing traders to differentiate between varying degrees of overbought and oversold conditions, potentially leading to more refined trading decisions. Example: When the RSI crosses above 180, it might indicate an extreme overbought condition, which could be a stronger signal for a sell, while a cross below 120 might indicate an extreme oversold condition, which could be a stronger signal for a buy. RSI & Stochastic Overbought (OB) Band Customization: OB Level 1: Width, Style, and Color: What it is: Customization options for the visual appearance of the first overbought band on the chart. What it does: Allows you to set the line width, style (solid, dotted, dashed), and color for the first overbought band, enhancing its visibility on the chart. Example: A dashed red line with medium width can clearly indicate the first overbought level, helping traders quickly identify when this threshold is crossed. OB Level 2: Width, Style, and Color: What it is: Customization options for the visual appearance of the second overbought band on the chart. What it does: Allows you to set the line width, style, and color for the second overbought band, providing a clear distinction from the first band. Example: A dashed red line with a slightly thicker width can represent a more significant overbought level, making it easier to differentiate from the first level. RSI & Stochastic Oversold (OS) Band Customization: OS Level 1: Width, Style, and Color: What it is: Customization options for the visual appearance of the first oversold band on the chart. What it does: Allows you to set the line width, style (solid, dotted, dashed), and color for the first oversold band, making it visually prominent. Example: A dashed green line with medium width can highlight the first oversold level, helping traders identify potential buying opportunities. OS Level 2: Width, Style, and Color: What it is: Customization options for the visual appearance of the second oversold band on the chart. What it does: Allows you to set the line width, style, and color for the second oversold band, providing an additional visual cue for extreme oversold conditions. Example: A dashed green line with a thicker width can represent a more significant oversold level, offering a stronger visual cue for potential buying opportunities. RSI DIVERGENCES Display of RSI Divergence Labels: Display of RSI Divergence Settings: RSI Divergence Lookback Explanation The RSI Divergence settings allow traders to customize the parameters for detecting divergences between the RSI (Relative Strength Index) and price action. Divergences occur when the price moves in the opposite direction to the RSI, potentially signaling a trend reversal. These settings help refine the accuracy of divergence detection by adjusting the lookback period and range. ( NOTE: This setting only imply to the RSI. This doesn't effect the STOCHASTIC RSI. ) RSI Divergence Lookback Input Settings: Lookback Left: Default: 10 What it is: The number of bars to look back from the current bar to detect a potential divergence. What it does: Defines the left-side lookback period for identifying pivot points in the RSI, which are used to spot divergences. A longer lookback period may capture more significant trends but could also miss shorter-term divergences. Example: A setting of 10 bars means the script will consider pivot points up to 10 bars before the current bar to check for divergence patterns. Lookback Right: Default: 1 What it is: The number of bars to look forward from the current bar to complete the divergence pattern. What it does: Defines the right-side lookback period for confirming a potential divergence. This setting helps ensure that the identified divergence is valid by allowing the script to check subsequent bars for confirmation. Example: A setting of 1 bar means the script will look at the next bar to confirm the divergence pattern, ensuring that the signal is reliable. Lookback Range Min: Default: 5 What it is: The minimum range of bars required to detect a valid divergence. What it does: Sets a lower bound on the range of bars considered for divergence detection. A lower minimum range might capture more frequent but possibly less significant divergences. Example: Setting the minimum range to 5 ensures that only divergences spanning at least 5 bars are considered, filtering out very short-term patterns. Lookback Range Max: Default: 60 What it is: The maximum range of bars within which a divergence can be detected. What it does: Sets an upper bound on the range of bars considered for divergence detection. A larger maximum range might capture more significant divergences but could also include less relevant long-term patterns. Example: Setting the maximum range to 60 bars allows the script to detect divergences over a longer timeframe, capturing more extended divergence patterns that could indicate major trend reversals. RSI Divergence Explanation RSI divergences occur when the RSI indicator and price action move in opposite directions, signaling potential trend reversals. This section of the settings allows traders to customize the appearance and detection of both regular and hidden bullish and bearish divergences. RSI Divergence Input Settings: R. Bullish Div Label: Default: True What it is: An option to display labels for regular bullish divergences. What it does: Enables or disables the visibility of labels that mark regular bullish divergences, where the price makes a lower low while the RSI makes a higher low, indicating a potential upward reversal. Example: A trader might use this to spot buying opportunities in a downtrend when a bullish divergence suggests the trend may be reversing. Bullish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of regular bullish divergence labels. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: Selecting a green label color and a distinct line width makes bullish divergences easily recognizable on your chart. R. Bearish Div Label: Default: True What it is: An option to display labels for regular bearish divergences. What it does: Enables or disables the visibility of labels that mark regular bearish divergences, where the price makes a higher high while the RSI makes a lower high, indicating a potential downward reversal. Example: A trader might use this to spot selling opportunities in an uptrend when a bearish divergence suggests the trend may be reversing. Bearish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of regular bearish divergence labels. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: Choosing a red label color and a specific line width makes bearish divergences clearly stand out on your chart. H. Bullish Div Label: Default: False What it is: An option to display labels for hidden bullish divergences. What it does: Enables or disables the visibility of labels that mark hidden bullish divergences, where the price makes a higher low while the RSI makes a lower low, indicating potential continuation of an uptrend. Example: A trader might use this to confirm an existing uptrend when a hidden bullish divergence signals continued buying strength. Hidden Bullish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of hidden bullish divergence labels. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: A softer green color with a thinner line width might be chosen to subtly indicate hidden bullish divergences, keeping the chart clean while providing useful information. H. Bearish Div Label: Default: False What it is: An option to display labels for hidden bearish divergences. What it does: Enables or disables the visibility of labels that mark hidden bearish divergences, where the price makes a lower high while the RSI makes a higher high, indicating potential continuation of a downtrend. Example: A trader might use this to confirm an existing downtrend when a hidden bearish divergence signals continued selling pressure. Hidden Bearish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of hidden bearish divergence labels. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: A muted red color with a thinner line width might be selected to indicate hidden bearish divergences without overwhelming the chart. Divergence Text Size and Color: Default: S (Small) What it is: Settings to adjust the size and color of text labels for RSI divergences. What it does: Allows you to customize the size and color of text labels that display the divergence information on the chart. Example: Choosing a small text size with a bright white color can make divergence labels easily readable without taking up too much space on the chart. STOCHASTIC DIVERGENCES Display of Stochastic RSI Divergence Labels: Display of Stochastic RSI Divergence Settings: Stochastic RSI Divergence Explanation Stochastic RSI divergences occur when the Stochastic RSI indicator and price action move in opposite directions, signaling potential trend reversals. These settings allow traders to customize the detection and visual representation of both regular and hidden bullish and bearish divergences in the Stochastic RSI. Stochastic RSI Divergence Input Settings: R. Bullish Div Label: Default: True What it is: An option to display labels for regular bullish divergences in the Stochastic RSI. What it does: Enables or disables the visibility of labels that mark regular bullish divergences, where the price makes a lower low while the Stochastic RSI makes a higher low, indicating a potential upward reversal. Example: A trader might use this to spot buying opportunities in a downtrend when a bullish divergence in the Stochastic RSI suggests the trend may be reversing. Bullish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of regular bullish divergence labels in the Stochastic RSI. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: Selecting a blue label color and a distinct line width makes bullish divergences in the Stochastic RSI easily recognizable on your chart. R. Bearish Div Label: Default: True What it is: An option to display labels for regular bearish divergences in the Stochastic RSI. What it does: Enables or disables the visibility of labels that mark regular bearish divergences, where the price makes a higher high while the Stochastic RSI makes a lower high, indicating a potential downward reversal. Example: A trader might use this to spot selling opportunities in an uptrend when a bearish divergence in the Stochastic RSI suggests the trend may be reversing. Bearish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of regular bearish divergence labels in the Stochastic RSI. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: Choosing an orange label color and a specific line width makes bearish divergences in the Stochastic RSI clearly stand out on your chart. H. Bullish Div Label: Default: False What it is: An option to display labels for hidden bullish divergences in the Stochastic RSI. What it does: Enables or disables the visibility of labels that mark hidden bullish divergences, where the price makes a higher low while the Stochastic RSI makes a lower low, indicating potential continuation of an uptrend. Example: A trader might use this to confirm an existing uptrend when a hidden bullish divergence in the Stochastic RSI signals continued buying strength. Hidden Bullish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of hidden bullish divergence labels in the Stochastic RSI. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: A softer blue color with a thinner line width might be chosen to subtly indicate hidden bullish divergences, keeping the chart clean while providing useful information. H. Bearish Div Label: Default: False What it is: An option to display labels for hidden bearish divergences in the Stochastic RSI. What it does: Enables or disables the visibility of labels that mark hidden bearish divergences, where the price makes a lower high while the Stochastic RSI makes a higher high, indicating potential continuation of a downtrend. Example: A trader might use this to confirm an existing downtrend when a hidden bearish divergence in the Stochastic RSI signals continued selling pressure. Hidden Bearish Label Color, Line Width, and Line Color: What it is: Settings to customize the appearance of hidden bearish divergence labels in the Stochastic RSI. What it does: Allows you to choose the color of the labels, adjust the width of the divergence lines, and select the color for these lines. Example: A muted orange color with a thinner line width might be selected to indicate hidden bearish divergences without overwhelming the chart. Divergence Text Size and Color: Default: S (Small) What it is: Settings to adjust the size and color of text labels for Stochastic RSI divergences. What it does: Allows you to customize the size and color of text labels that display the divergence information on the chart. Example: Choosing a small text size with a bright white color can make divergence labels easily readable without taking up too much space on the chart. Alert System: Custom Alerts for Divergences and Reversals: What it is: The script includes customizable alert conditions to notify you of detected divergences or potential reversals based on WaveTrend, RSI, and Stochastic RSI. What it does: Helps you stay informed of key market movements without constantly monitoring the charts, enabling timely decisions. Example: Setting an alert for regular bearish divergence on the WaveTrend could notify you of a potential sell opportunity as soon as it is detected. How to Use Alerts: Set up custom alerts in TradingView based on these conditions to be notified of potential trading opportunities. Alerts are triggered when the indicator detects conditions that match the selected criteria, such as divergences or potential reversals. By following the detailed guidelines and examples above, you can effectively use and customize this powerful indicator to suit your trading strategy. For further understanding and customization, refer to the input settings within the script and adjust them to match your trading style and preferences. How Components Work Together Synergy and Cross-Validation: The indicator combines multiple layers of analysis to validate trading signals. For example, a WaveTrend buy signal that coincides with a bullish divergence in RSI and positive fast money flow is likely to be more reliable than any single indicator’s signal. This cross-validation reduces the likelihood of false signals and enhances decision-making. Comprehensive Market Analysis: Each component plays a role in analyzing different aspects of the market. WaveTrend focuses on trend strength, Money Flow indicators assess market sentiment, while RSI and Stochastic RSI offer detailed views of price momentum and potential reversals. Ideal For Traders who require a reliable, multifaceted tool for detecting market trends and reversals. Investors seeking a deeper understanding of market dynamics across different timeframes and conditions, whether in forex, equities, or cryptocurrency markets. This script is designed to provide a comprehensive tool for technical analysis, combining multiple indicators and divergence detection into one versatile and customizable script. It is especially useful for traders who want to monitor various indicators simultaneously and look for convergence or divergence signals across different technical tools. Acknowledgements Special thanks to these amazing creators for inspiration and their creations: I want to thank these amazing creators for creating there amazing indicators , that inspired me and also gave me a head start by making this indicator! Without their amazing indicators it wouldn't be possible! vumanchu: VuManChu Cipher B Divergences. MisterMoTa: RSI + Divergences + Alerts . DevLucem: Plain Stochastic Divergence. Note This indicator is designed to be a powerful tool in your trading arsenal. However , it is essential to backtest and adjust the settings according to your trading strategy before applying it to live trading . If you have any questions or need further assistance, feel free to reach out.
Pine Script® indicator
by WeloTrades
4
GL Gann Swing IndicatorIntroduction The GL Gann Swing Indicator is a versatile tool designed to help traders identify market trends, support and resistance areas, and potential reversals. This indicator applies the principles of Gann Swing Charts, a technique developed by W.D. Gann, which focuses on market swings to determine the overall direction and turning points of price action. Gann Swing Charts are a time-tested method of technical analysis that simplifies price action by focusing on significant highs and lows, thereby eliminating market noise and providing a clearer view of the trend. By analyzing price action and determining swing directions and turning points, the indicator filters out market noise using four distinct bar types: Up Bar: Higher High, Higher Low Down Bar: Lower High, Lower Low Inside Bar: Lower High, Higher Low Outside Bar: Higher High, Lower Low This approach helps traders to: Identify the primary trend direction. Determine key support and resistance levels. Recognize potential reversal points. Filter out minor price fluctuations that do not affect the overall trend. Features Bar Types: Display bar types by checking the Show Bar Type box in the indicator's settings. Up bars appear as green upward-pointing triangles, down bars as red downward-pointing triangles, inside bars as grey circles, and outside bars as blue diamonds. These visual aids help traders quickly identify the type of bar and its significance. Break Lines: These lines highlight when the price rises above a previous swing high or falls below a prior swing low. Green lines indicate breaks of swing highs, while red lines indicate breaks of swing lows. Break lines are enabled by default but can be turned off in the indicator's settings. Break lines provide visual confirmation of trend continuation or reversal. Bar Count: Bar counts help determine if a swing is overextended and if a reversal is likely. This feature is off by default but can be enabled in the indicator's settings. Users can set a minimum bar count to focus on significant swings. Analyzing the number of bars in a swing can help traders gauge the strength and potential exhaustion of a trend. Swing MA (Moving Averages): This feature plots the average of a user-defined number of previous swing highs and lows. Options are available to add two moving averages, allowing for both fast and slow averages. Swing MAs can be enabled in the indicator's settings. These moving averages smooth out the price data, making it easier to identify the underlying trend direction. Why This Indicator is Useful The GL Gann Swing Indicator is particularly useful for several reasons: Trend Identification: By focusing on significant price swings, the indicator helps traders identify the primary trend direction, making it easier to align trades with the overall market movement. Noise Reduction: The indicator filters out minor price fluctuations, allowing traders to focus on meaningful market movements and avoid being misled by short-term volatility. Support and Resistance Levels: By highlighting key swing highs and lows, the indicator helps traders identify crucial support and resistance levels, which are essential for making informed trading decisions. Potential Reversals: The indicator's ability to identify overextended swings and potential reversal points can help traders anticipate market turning points and adjust their strategies accordingly. Customizability: With options to display bar types, break lines, bar counts, and swing moving averages, traders can customize the indicator to suit their specific trading style and preferences. By incorporating Gann Swing principles, the GL Gann Swing Indicator offers traders a powerful tool to enhance their technical analysis, improve their trading decisions, and ultimately achieve better trading outcomes.
Pine Script® indicator
by guusl
19
Bilson Gann CountGann counting is a method for identifying swing points,trends, and overall market structure. It simplifies price action by drawing short trend lines that summarize moves. There's essentially 4 types of bar/candle. Up bar - Higher high and higher low than previous bar Down bar - Lower high and lower low than previous bar Inside bar - Lower high and higher low than previous bar Outside bar - Higher high and lower low than previous bar We use these determinations to decide how the trendline moves through the candles. Up bars we join to the high, down bars we join to the low, inside bars are ignored. There are other indicators that already exist which do this, the difference here is how we handle outside bars. Other gann counting methods skip outside bars, this method determines how to handle the outside bar after the outside bar is broken. examples UP -> OUTSIDE -> UP = Outside bar treated as swing low UP -> OUTSIDE -> DOWN = Outside bar treated as swing high DOWN -> OUTSIDE -> UP = Outside bar treated as swing low DOWN -> OUTSIDE -> DOWN = Outside bar treated as swing high
Pine Script® indicator
by SweetChill
1
Volume Delta Trailing Stop [LuxAlgo]The ' Volume Delta Trailing Stop ' indicator uses Lower Time Frame (LTF) volume delta data which can provide potential entries together with a Volume-Delta based Trailing Stop-line . 🔶 USAGE Our 'Volume Delta Trailing Stop' script can show potential entries/Stop Loss lines A trigger line needs to be broken before a position is taken, after which a Volume Delta-controlled Trailing Stop-line is created: 🔶 DETAILS 🔹 Volume rises when bought or sold 🔹 When the opening price appears on the chart, a buy/sell order has been executed. If that order is less than the available supply of that particular price, volume will rise, without moving the price. 🔹 When the opening price is the same as the closing price, the volume of that bar can be seen as "neutral volume" (nV); nor "up", nor "down" volume. Example A buy order doesn't fill the first available supply in the order book. This price will be the opening price with a certain volume. When at closing time, price still hasn't moved (the first available supply in the order book isn't filled, or no movement downwards), the closing price will be equal to the opening price, but with volume. This can be seen as "neutral volume (nV)". 🔹 Delta Volume (ΔV): this is "up volume" minus "down volume" 🔹 Standard volume is colored red when closing price is lower than opening price ( = "down volume"). 🔹 Standard volume is colored green when closing price is higher OR equal (nV) than opening price ( = "up volume"). 🔹 Neutral Volume The "Neutral-Volume" is considered "Up-Volume" - setting will dictate whether nV is considered as green 'buy' volume or not. 🔶 EXAMPLE 29 July 10:00 -> 10:05, chart timeframe 5 minutes, open 29311.28, close 29313.89 close > open, so the volume (39.55) is colored green ("up volume"). (The Volume script used in the following examples is the open-source publication Volume Columns w. Alerts (V) from LucF ) Let's zoom to the 1-minute TF: The same period is now divided into more bars, volume direction (color) is dependable on the difference between open and close. Counting up and down volume gives a more detailed result, it remains in an upward direction though): (ΔV = +15.51) Let's further zoom in to the 1-second TF: The same period is now divided into even more bars (more possibility for changing direction on each bar) Here we see several bars that haven't moved in price, but they have volume ("neutral" volume). (neutral volume is coloured light green here, while up volume is coloured darker green) When we count all green and red volume bars, the result is quite different: (ΔV = -0.35) In total more volume is found when price went downwards, yet price went up in these 5 minutes. -> This is the heart of our publication, when this divergence occurs, you can see a barcolor changement:     • orange: when price went up, but LTF Volume was mainly in a downward direction.     • blue: when price went down, but LTF Volume was mainly in an upwards direction. When we split the green "up volume" into "up" and "neutral", the difference is even higher (here "neutral volume" is colored grey): (ΔV = -12.76; "up" - "down") 🔶 CONCEPTS bullishBear = current bar is  red  but LTF volume is in  upward direction ->   blue bar bearishBull = current bar is green but LTF volume is in downward direction -> orange bar 🔹 Potential positioning - forming of Trigger-line When not in position, the script will wait for a divergence between price and volume direction. When found, a Trigger-line will appear: • at high when a blue bar appears ( bullishBear ). • at   low when an orange bar appears ( bearishBull ). Next step is when the Trigger-line is broken by close or high/low (settings: Trigger ) Here, the closing price went under the grey Trigger-line -> bearish position: 🔹 Trailing Stop-line When the Trigger-line is broken, the Trailing Stop-line (TS-line) will start: • low  when bullish position • high when bearish position You can choose (settings -> Trigger -> Close or H/L ) whether close price or high/low should break the Trigger-line When alerts are enabled ("Any alert() function call"), you'll get the following message: • ' signal up '  when bullish position • ' signal down' when bearish position After that, the TS-line will be adjusted when: • a    blue    bullishBear  bar appears when in bullish position  ->  lowest   of {low , previous blue bar's high or orange bar's low} • an orange bearishBull bar appears when in bearish position -> highest of {high, previous blue bar's high or orange bar's low} When alerts are enabled ("Any alert() function call"), and the TS-line is broken, you'll get the following message: • ' TS-line broken down '  when out bullish  position • ' TS-line broken up '       when out bearish position 🔹 Reference Point Default the direction of price will be evaluated by comparing closing price with opening price. When open and close are the same, you'll get "neutral volume". You can use "previous close" instead (as in built-in volume indicator) to include gaps. If close equals open , but close is lower than previous close , it will be regarded as " down volume ", similar, when close is higher than previous close , it will be regarded as " up volume " Note, the setting applies for the current timeframe AND Lower timeframe: Based on: " open " (close - open) Based on: " previous close " (close - previous close) 🔹 Adjustment When the TS-line changes, this can be adjusted with a percentage of price , or a multiple of " True Range " Default (Δ line -> Adjustment - 0) Δ line -> Adjustment 0.03% (of price) Δ line -> Mult of TR (10) 🔶 SETTINGS 🔹 LTF: choose your Lower TimeFrame: 1S (seconds), 5S, 10S, 15S, 30S, 1 minute) 🔹 Trigger: Choose the trigger for breaking the Trigger-line ; close or H/L (high when bullish position, low when bearish position) 🔹 Δ line ( Trailing Stop-line ): add/subtract an adjustment when the TS-line changes ( default: Adjustment ): • Adjustment ( default: 0 ): add/subtract an extra % of price • Mult of TR                     : add/subtract a multiple of True Range 🔹 Based on: compare closing price against: • open • previous close 🔹 "Neutral-Volume" is considered "Up-Volume" : this setting will dictate whether nV is considered as green 'buy' volume or not. 🔶 CONSIDERATIONS 🔹 The lowest LTF (1S) will give you more detail and will get data close to tick data. However, a maximum of 100,000 intrabars can be used in calculations . This means on the daily chart you won't see anything since 1 day ~ 86400 seconds. (just over 1 bar) -> choose a lower chart timeframe, or choose a higher LTF (5S, 10S, ... 1 minute) 🔹 Always choose a LTF lower than the current chart timeframe. 🔹 Pine Script™ code using this request.security_lower_tf() may calculate differently on historical and real-time bars, leading to repainting .
Pine Script® indicator
by LuxAlgo
16
Volume Profile (Maps) [LuxAlgo]The Pine Script® developers have unleashed "maps"! Volume Profile (Maps) displays volume, associated with price, above and below the latest price, by using maps The largest and second-largest volume is highlighted. 🔶 USAGE The proposed script can highlight more frequent closing prices/prices with the highest volume, potentially highlighting more liquid areas. The prices with the highest associated volume (in red and orange in the indicator) can eventually be used as support/resistance levels. Voids within the volume profile can highlight large price displacements (volatile variations). 🔶 CONCEPTS 🔹 Maps A map object is a collection that consists of key - value pairs Each key is unique and can only appear once. When adding a new value with a key that the map already contains, that value replaces the old value associated with the key . You can change the value of a particular key though, for example adding volume (value) at the same price (key), the latter technique is used in this script. Volume is added to the map, associated with a particular price (default close, can be set at high, low, open,...) When the map already contains the same price (key), the value (volume) is added to the existing volume at the associated price. A map can contain maximum 50K values, which is more than enough to hold 20K bars (Basic 5K - Premium plan 20K), so the whole history can be put into a map. 🔹 Visible line/box limit We can only display maximum 500 line.new() though. The code locates the current (last) close, and displays volume values around this price, using lines, for example 250 lines above and 250 lines below current price. If one side contains fewer values, the other side can show more lines, taking the maximum out of the 500 visible line limitation. Example (max. 500 lines visible) • 100 values below close • 2000 values above close -> 100 values will be displayed below close -> 400 remaining -> 400 values will be displayed above close Pushing the limits even further, when ' Amount of bars ' is set higher than 500, boxes - box.new() - will be used as well. These have a limit of 500 as well, bringing the total limit to 1000. Note that there are visual differences when boxes overlap against lines. If this is confusing, please keep ' Amount of bars ' at max. 500 (then only lines will be used). 🔹 Rounding function This publication contains 2 round functions, which can be used to widen the Volume Profile Round • "Round" set     at    zero -> nothing changes to the source number • "Round" set below zero -> x digit(s)   after the decimal point, starting from the right side, and rounded. • "Round" set above zero -> x digit(s) before the decimal point, starting from the right side, and rounded. Example: 123456.789   0->123456.789   1->123456.79   2->123456.8   3->123457 -1->123460 -2->123500 Step Another option is custom steps. After setting "Round" to "Step", choose the desired steps in price, Examples •     2  -> 1234.00, 1236.00, 1238.00, 1240.00 •     5  -> 1230.00, 1235.00, 1240.00, 1245.00 • 100  -> 1200.00, 1300.00, 1400.00, 1500.00 • 0.05 -> 1234.00, 1234.05, 1234.10, 1234.15 ••• 🔶 FEATURES 🔹 Adjust position & width 🔹 Table The table shows the details: • Size originalMap : amount of elements in original map • # higher: amount of elements, higher than last "close" (source) • index "close" : index of last "close" (source), or # element, lower than source • Size newMap : amount of elements in new map (used for display lines) • # higher : amount of elements in newMap, higher than last "close" (source) • # lower : amount of elements in newMap, lower than last "close" (source) 🔹 Volume * currency Let's take as example BTCUSD, relative to USD, 10 volume at a price of 100 BTCUSD will be very different than 10 volume at a price of 30000 (1K vs. 300K) If you want volume to be associated with USD, enable Volume * currency . Volume will then be multiplied by the price: • 10 volume, 1 BTC = 100 -> 1000 • 10 volume, 1 BTC = 30K -> 300K Disabled Enabled 🔶 DETAILS 🔹 Put When the map doesn't contain a price, it will be added, using map.put(id, key, value) In our code: map.put(originalMap, price, volume) or originalMap.put(price, volume) A key (price) is now associated with a value (volume) -> key : value Since all keys are unique, we don't have to know its position to extract the value, we just need to know the key -> map.get(id, key) We use map.get() when a certain key already exists in the map, and we want to add volume with that value. if originalMap.contains(price) originalMap.put(price, originalMap.get(price) + volume) -> At the last bar, all prices (source) are now associated with volume. 🔹 Copy & sort Next, every key of the map is copied and sorted (array of keys), after which the index (idx) is retrieved of last (current) price. copyK = originalMap.keys().copy() copyK.sort() idx = copyK.binary_search_leftmost(src) Then left and right side of idx is investigated to show a maximum amount of lines at both sides of last price. 🔹 New map & display The keys (from sorted array of copied keys) that will be displayed are put in a new map, with the associated volume values from the original map. newMap = map.new() 🔹 Re-cap • put in original amp (price key, volume value) • copy & sort • find index of last price • fetch relevant keys left/right from that index • put keys in new map and fetch volume associated with these keys (from original map) Simple example (only show 5 lines) bar 0, price = 2, volume = 23 bar 1, price = 4, volume = 3 bar 2, price = 8, volume = 21 bar 3, price = 6, volume = 7 bar 4, price = 9, volume = 13 bar 5, price = 5, volume = 85 bar 6, price = 3, volume = 13 bar 7, price = 1, volume = 4 bar 8, price = 7, volume = 9 Original map:           Copied keys array:     Sorted:                 -> 5 keys around last price (7) are fetched (5, 6, 7, 8, 9) -> keys are placed into new map + volume values from original map                         Lastly, these values are displayed. 🔶 SETTINGS Source : Set source of choice; default close , can be set as high , low , open , ... Volume & currency : Enable to multiply volume with price (see Features ) Amount of bars : Set amount of bars which you want to include in the Volume Profile Max lines : maximum 1000 (if you want to use only lines, and no boxes -> max. 500, see Concepts ) 🔹 Round -> ' Round/Step ' Round -> see Concepts Step    -> see Concepts 🔹 Display Volume Profile Offset: shifts the Volume Profile (max. 500 bars to the right of last bar, see Features ) Max width Volume Profile: largest volume will be x bars wide, the rest is displayed as a ratio against largest volume (see Features ) Show table : Show details (see Features ) 🔶 LIMITATIONS • Lines won't go further than first bar (coded). • The Volume Profile can be placed maximum 500 bar to the right of last price. • Maximum 500 lines/boxes can be displayed
Pine Script® indicator
by LuxAlgo
8
Developing Market Profile / TPO [Honestcowboy]The Developing Market Profile Indicator aims to broaden the horizon of Market Profile / TPO research and trading. While standard Market Profiles aim is to show where PRICE is in relation to TIME on a previous session (usually a day). Developing Market Profile will change bar by bar and display PRICE in relation to TIME for a user specified number of past bars. What is a market profile? "Market Profile is an intra-day charting technique (price vertical, time/activity horizontal) devised by J. Peter Steidlmayer. Steidlmayer was seeking a way to determine and to evaluate market value as it developed in the day time frame. The concept was to display price on a vertical axis against time on the horizontal, and the ensuing graphic generally is a bell shape--fatter at the middle prices, with activity trailing off and volume diminished at the extreme higher and lower prices." For education on market profiles I recommend you search the net and study some profitable traders who use it. Key Differences Does not have a value area but distinguishes each column in relation to the biggest column in percentage terms. Updates bar by bar Does not take sessions into account Shows historical values for each bar While there is an entire education system build around Market Profiles they usually focus on a daily profile and in some cases how the value area develops during the day (there are indicators showing the developing value area). The idea of trading based on a developing value area is what inspired me to build the Developing Market Profile. 🟦 CALCULATION Think of this Developing Market Profile the same way as you would think of a moving average. On each bar it will lookback 200 bars (or as user specified) and calculate a Market Profile from those bars (range). 🔹Market Profile gets calculated using these steps: Get the highest high and lowest low of the price range. Separate that range into user specified amount of price zones (all spaced evenly) Loop through the ranges bars and on each bar check in which price zones price was, then add +1 to the zones price was in (we do this using the OccurenceArray) After it looped through all bars in the range it will draw columns for each price zone (using boxes) and make them as wide as the OccurenceArray dictates in number of bars 🔹Coloring each column: The script will find the biggest column in the Profile and use that as a reference for all other columns. It will then decide for each column individually how big it is in % compared to the biggest column. It will use that percentage to decide which color to give it, top 20% will be red, top 40% purple, top 60% blue, top 80% green and all the rest yellow. The user is able to adjust these numbers for further customisation. The historical display of the profiles uses plotchar() and will not only use the color of the column at that time but the % rating will also decide transparancy for further detail when analysing how the profiles developed over time. Each of those historical profiles is calculated using its own 200 past bars. This makes the script very heavy and that is why it includes optimisation settings, more info below. 🟦 USAGE My general idea of the markets is that they are ever changing and that in studying that changing behaviour a good trader is able to distinguish new behaviour from old behaviour and adapt his approach before losing traders "weak hands" do. A Market Profile can visually show a trader what kind of market environment we currently are in. In training this visual feedback helps traders remember past market environments and how the market behaved during these times. Use the history shown using plotchars in colors to get an idea of how the Market Profile looked at each bar of the chart. This history will help in studying how price moves at different stages of the Market Profile development. I'm in no way an expert in trading Market Profiles so take this information with a grain of salt. Below an idea of how I would trade using this indicator: 🟦 SETTINGS 🔹MARKET PROFILING Lookback: The amount of bars the Market Profile will look in the past to calculate where price has been the most in that range Resolution: This is the amount of columns the Market Profile will have. These columns are calculated using the highest and lowest point price has been for the lookback period Resolution is limited to a maximum of 32 because of pinescript plotting limits (64). Each plotchar() because of using variable colors takes up 2 of these slots 🔹VISUAL SETTINGS Profile Distance From Chart: The amount of bars the market profile will be offset from the current bar Border width (MP): The line thickness of the Market Profile column borders Character: This is the character the history will use to show past profiles, default is a square. Color theme: You can pick 5 colors from biggest column of the Profile to smallest column of the profile. Numbers: these are for % to decide column color. So on default top 20% will be red, top 40% purple... Always use these in descending order Show Market Profile: This setting will enable/disable the current Market Profile (columns on right side of current bar) Show Profile History: This setting will enable/disable the Profile History which are the colored characters you see on each bar 🔹OPTIMISATION AND DEBUGGING Calculate from here: The Market Profile will only start to calculate bar by bar from this point. Setting is needed to optimise loading time and quite frankly without it the script would probably exceed tradingview loading time limits. Min Size: This setting is there to avoid visual bugs in the script. Scaling the chart there can be issues where the Market Profile extends all the way to 0. To avoid this use a minimum size bigger than the bugged bottom box
Pine Script® indicator
by Honestcowboy
20
LNL Scalper ArrowsLNL Scalper Arrows The indicator consist of various different types of candlestick patterns that are truly time tested by multiple veteran traders. These arrows are a combination of short-term scalping strategies taught by Linda Raschke & a trader that goes by name Quant Trade Edge. These strategies/patterns occur regularly within the markets. They offer high probability quick moves during the trending days. These four patterns are based on pure price action, no oscillators, no trend, no momentum indicators involved. Trend (ema) is there just as a simple trend gauge. LNL Scalper Arrows were designed specifically for intra-day trading. Mostly useful for the futures but also stocks as well. These arrows can work anywhere between the fast-moving 512 or 1600 tick charts to a 1min, 2min and up to 5min or 10min charts. Trend Gauge (Exponential Moving Average) Nothing fancy just a classic EMA that can guide the direction of the short-term trend. I have added a custom coloring of the EMA that is based on a simple RSI filter. That should help to visualize the non-directional moments within the trend. Although the length is adjustable, for scalping it is better to focus on smaller periods such as 9, 13 or 20 or 34 but anything above 50 loses its purpose as a short-term trend gauge. Again, this is a scalping tool not a trend tool, you are not going to get rid of the fakeouts by increasing the period of the trend. Tail Arrows (Eat the Tail Pattern) Tail is a candlestick that is either a price rejection spike, or a flag continuation pattern on a lower time frame. A failed action. It is basically a candle with much bigger wick (shadow) of the candle than the actual body. Such candles are usually telling us about strong participation from the other side of the market. Eat the tail pattern occurs whenever the low of the Tail candle is immediately broken on a following candle "the tail is eaten alive". Such a breaks occurs in a most aggressive types of markets with a strong momentum. DO NOT try to trade this in a low volume or a ranging market. Tail Arrows are the most aggressive arrows & should be only used on the highest volume or a parabolic momentum markets. Scalp Arrows (Scallop Pattern) Known as Scallops or minor lows or highs, these patterns are the most common within the all scalper arrows. They occur regularly on 1min & 5min charts - basically everyday. Scallops provide the best possible risk to reward entry within the trend without the need of any indicators or oscillators. The Scallop Up 3 bar pattern consist of a high that is lower that the previous high but also low that is lower than the previous low. Scallop Up or a minor low triggers when the last high is broken, creating a three bar mountain or a peak within the 5 bar span. Hoagie Arrows (Hoagie Pattern) Hoagies occur way less often than any other scalping patterns. Hoagies represent two (or more) inside candles within the shadow of a first candle. Such a formation is creating a small compression or a range that sooner or later breaks out. The hoagie is triggered whenever the high or low of the shadow (first) candle is broken. The great thing about the hoagies is that they can work either way despite the trend direction. Although this indicator is coded for the 2 bar hoagies, there are no limitations on how much inside bars can hoagie include. Umbrella Arrows (Umbrella Pattern) Another really awesome 3 bar pattern that is really fun to trade. Umbrella occurs when the candle before the previous candle is a pin bar or a tail bar and the body of the previous candle is within the shadow or a wick of the candle before. The umbrella is triggered once the high or low of the previous bar is broken. Umbrellas are more frequent than Hoagies but occur much less than the Scallops. Outside Bar Wedges (Outside Bar Pattern) Pretty much self-explanatory candlestick pattern. Outside Bar is basically any bar that peaks outside of the both ends of the previous candle. So the range of the candle is higher & it looked beyond the high and beyond the low of the previous candle. These candles are signalizing the potenial momentum change. Ouside Bars usually occur at the tops or bottoms of the moves. I decided to add them because they can serve as a great addition to these scalping patterns. Signal vs. SignalBreak Mode The trigger can be viewed in two different ways: 1. Signal: Plots the trigger before the trigger bar, basically right when the pattern is formed but NOT YET triggered. The signal is triggered once the next candle break the high or low of the current candle. 2. SignalBrake: Plots the trigger after the break of the high or low of the actual pattern. It is basically a candle after the signal candle. (Signal is better for trading because it gives you time to prepare for the actual break of the high or low = the actual signal. SignalBrake is great for looking back in history only for the patterns that actually traded). Pin Bar BTW Ratio Pin Bar (Body-To-Wick) Ratio represents the size of the body of a pin bar candle for Eat the Tail and Umbrella patterns. Pin Bar BTW Ratio measures the ratio between the wick & the body of the candle. Ref. interval is 2.0 - 5.0 (ideal pin bar is 2.0 - 3.0 = the wick or a shadow is 2x - 3x bigger than the body of the candle) ATR Stop & Target Labels I also created three simple labels (tables) that can show you the ideal target & stop as well as the current ATR. Since LNL Scalper Arrows consist of high probability scalping patterns, a good rule of thumb to follow is to use a half of the current ATR as a target and a current ATR as a stop (or two times the target). So if the current 7 period ATR is 30 the target would be 15 pts. and a stop around 30 pts. With such a risk management you should aim for a win rate 70% or higher. Obviously you can adjust the risk management in the settings to your personal preference. Low Range vs. High Range Markets There are two major downsides with the Scalper Arrows: 1. You need volume and a volatility. These patterns really do struggle in ranging "boring" sideways action. It is absolutely crucial to recognize the current market environment and really stay cautions and (or completely out) in case the chop continues. Adding something like DMI can help you recognize the potential flat markets. 2. Not only do you need volume & momentum, you also need a decent range. This indicator works better on a rangy market such as NQ futures or YM. But are much tougher to trade on lower range markets such as some stocks or ZB futures or basically any other lower range market. Hope it helps.
Pine Script® indicator
by lnlcapital
6
libhs.log.DEMO◼ Overview This is a demonstration of dual logging library I have ported from my personal use for public use. Please start bar replay from Bar#4, and progress automatically slowly or manually.You would need to go through 450+ bars to see the full capability. Logger=A dual logging library for developers. Tradingview lacks logging capability. This library provided logging while developing your scripts and is to be used by developers when developing and debugging their scripts. Using this library would potentially slow down you scripts. Hence, use this for debugging only. Once your code is as you would like it to be, remove the logging code. ◼︎ Usage (Console): Console = A sleek single cell logging with a limit of 4096 characters. When you dont need a large logging capability. //@version=5 indicator("demo.Console", overlay=true) plot(na) import GETpacman/log/2 as logger var console = logger.log.new() console.init() // init() should be called as first line after variable declaration console.FrameColor:=color.green console.log('\n') console.log('\n') console.log('Hello World') console.log('\n') console.log('\n') console.ShowStatusBar:=true console.StatusBarAtBottom:=true console.FrameColor:=color.blue //settings can be changed anytime before show method is called. Even twice. The last call will set the final value console.ShowHeader:=false //this wont throw error but is not used for console console.show(position=position.bottom_right) //this should be the last line of your code, after all methods and settings have been dealt with. ◼︎ Usage (Logx): Logx = Multiple columns logging with a limit of 4096 characters each message. When you need to log large number of messages. //@version=5 indicator("demo.Logx", overlay=true) plot(na) import GETpacman/log/2 as logger var logx = logger.log.new() logx.init() // init() should be called as first line after variable declaration logx.FrameColor:=color.green logx.log('\n') logx.log('\n') logx.log('Hello World') logx.log('\n') logx.log('\n') logx.ShowStatusBar:=true logx.StatusBarAtBottom:=true logx.ShowQ3:=false logx.ShowQ4:=false logx.ShowQ5:=false logx.ShowQ6:=false logx.FrameColor:=color.olive //settings can be changed anytime before show method is called. Even twice. The last call will set the final value logx.show(position=position.top_right) //this should be the last line of your code, after all methods and settings have been dealt with. ◼︎ Fields (with default settings)   ▶︎ IsConsole         = True  Log will act as Console if true, otherwise it will act as Logx      ▶︎ ShowHeader        = True  (Log only) Will show a header at top or bottom of logx.   ▶︎ HeaderAtTop        = True  (Log only) Will show the header at the top, or bottom if false, if ShowHeader is true.   ▶︎ ShowStatusBar       = True  Will show a status bar at the bottom   ▶︎ StatusBarAtBottom     = True  Will show the status bar at the bottom, or top if false, if ShowHeader is true.   ▶︎ ShowMetaStatus      = True  Will show the meta info within status bar (Current Bar, characters left in console, Paging On Every Bar, Console dumped data etc)      ▶︎ ShowBarIndex       = True  Logx will show column for Bar Index when the message was logged. Console will add Bar index at the front of logged messages   ▶︎ ShowDateTime       = True  Logx will show column for Date/Time passed with the logged message logged. Console will add Date/Time at the front of logged messages   ▶︎ ShowLogLevels       = True  Logx will show column for Log levels corresponding to error codes. Console will log levels in the status bar   ▶︎ ReplaceWithErrorCodes   = True  (Log only) Logx will show error codes instead of log levels, if ShowLogLevels is switched on   ▶︎ RestrictLevelsToKey7    = True  Log levels will be restricted to Ley 7 codes - TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL, FATAL   ▶︎ ShowQ1          = True  (Log only) Show the column for Q1   ▶︎ ShowQ2          = True  (Log only) Show the column for Q2   ▶︎ ShowQ3          = True  (Log only) Show the column for Q3   ▶︎ ShowQ4          = True  (Log only) Show the column for Q4   ▶︎ ShowQ5          = True  (Log only) Show the column for Q5   ▶︎ ShowQ6          = True  (Log only) Show the column for Q6      ▶︎ ColorText         = True  Log/Console will color text as per error codes   ▶︎ HighlightText        = True  Log/Console will highlight text (like denoting) as per error codes      ▶︎ AutoMerge        = True  (Log only) Merge the queues towards the right if there is no data in those queues.   ▶︎ PageOnEveryBar      = True  Clear data from previous bars on each new bar, in conjuction with PageHistory setting.   ▶︎ MoveLogUp        = True  Move log in up direction. Setting to false will push logs down.   ▶︎ MarkNewBar       = True  On each change of bar, add a marker to show the bar has changed   ▶︎ PrefixLogLevel      = True  (Console only) Prefix all messages with the log level corresponding to error code.   ▶︎ MinWidth   = 40  Set the minimum width needed to be seen. Prevents logx/console shrinking below these number of characters.   ▶︎ TabSizeQ1      = 0   If set to more than one, the messages on Q1 or Console messages will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ2      = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ3     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ4     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ5     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ6     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ PageHistory     = 0   Used with PageOnEveryBar. Determines how many historial pages to keep.      ▶︎ HeaderQbarIndex    = 'Bar#'  (Logx only) The header to show for Bar Index   ▶︎ HeaderQdateTime    = 'Date'  (Logx only) The header to show for Date/Time   ▶︎ HeaderQerrorCode   = 'eCode'  (Logx only) The header to show for Error Codes   ▶︎ HeaderQlogLevel    = 'State'  (Logx only) The header to show for Log Level   ▶︎ HeaderQ1       = 'h.Q1'   (Logx only) The header to show for Q1   ▶︎ HeaderQ2       = 'h.Q2'   (Logx only) The header to show for Q2   ▶︎ HeaderQ3       = 'h.Q3'   (Logx only) The header to show for Q3   ▶︎ HeaderQ4       = 'h.Q4'   (Logx only) The header to show for Q4   ▶︎ HeaderQ5       = 'h.Q5'   (Logx only) The header to show for Q5   ▶︎ HeaderQ6       = 'h.Q6'   (Logx only) The header to show for Q6   ▶︎ Status         = ''     Set the status to this text.   ▶︎ HeaderColor            Set the color for the header        ▶︎ HeaderColorBG           Set the background color for the header   ▶︎ StatusColor             Set the color for the status bar   ▶︎ StatusColorBG           Set the background color for the status bar   ▶︎ TextColor              Set the color for the text used without error code or code 0.   ▶︎ TextColorBG            Set the background color for the text used without error code or code 0.   ▶︎ FrameColor             Set the color for the frame around Logx/Console   ▶︎ FrameSize       = 1    Set the size of the frame around Logx/Console   ▶︎ CellBorderSize     = 0    Set the size of the border around cells.   ▶︎ CellBorderColor          Set the color for the border around cells within Logx/Console   ▶︎ SeparatorColor         = gray Set the color of separate in between Console/Logx Attachment    ◼︎ Methods (summary)   ● init               ▶︎ Initialise the log   ● log               ▶︎ Log the messages. Use method show to display the messages   ● page              ▶︎ Clear messages from previous bar while logging messages on this bar.   ● show              ▶︎ Shows a table displaying the logged messages   ● clear              ▶︎ Clears the log of all messages   ● resize              ▶︎ Resizes the log. If size is for reduction then oldest messages are lost first.   ● turnPage            ▶︎ When called, all messages marked with previous page, or from start are cleared   ● dateTimeFormat         ▶︎ Sets the date time format to be used when displaying date/time info.   ● resetTextColor          ▶︎ Reset Text Color to library default   ● resetTextBGcolor         ▶︎ Reset Text BG Color to library default   ● resetHeaderColor        ▶︎ Reset Header Color to library default   ● resetHeaderBGcolor       ▶︎ Reset Header BG Color to library default   ● resetStatusColor         ▶︎ Reset Status Color to library default   ● resetStatusBGcolor        ▶︎ Reset Status BG Color to library default   ● setColors            ▶︎ Sets the colors to be used for corresponding error codes   ● setColorsBG           ▶︎ Sets the background colors to be used for corresponding error codes. If not match of error code, then text color used.   ● setColorsHC           ▶︎ Sets the highlight colors to be used for corresponding error codes.If not match of error code, then text bg color used.   ● resetColors           ▶︎ Reset the colors to library default (Total 36, not including error code 0)   ● resetColorsBG          ▶︎ Reset the background colors to library default   ● resetColorsHC          ▶︎ Reset the highlight colors to library default   ● setLevelNames          ▶︎ Set the log level names to be used for corresponding error codes. If not match of error code, then empty string used.   ● resetLevelNames         ▶︎ Reset the log level names to library default. (Total 36) 1=TRACE, 2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=CRITICAL, 7=FATAL   ● attach              ▶︎ Attaches a console to an existing Logx, allowing to have dual logging system independent of each other   ● detach              ▶︎ Detaches an already attached console from Logx
Pine Script® indicator
by GETpacman
1
loggerLibrary "logger" ◼ Overview A dual logging library for developers. Tradingview lacks logging capability. This library provides logging while developing your scripts and is to be used by developers when developing and debugging their scripts. Using this library would potentially slow down you scripts. Hence, use this for debugging only. Once your code is as you would like it to be, remove the logging code. ◼︎ Usage (Console): Console = A sleek single cell logging with a limit of 4096 characters. When you dont need a large logging capability. //@version=5 indicator("demo.Console", overlay=true) plot(na) import GETpacman/logger/1 as logger var console = logger.log.new() console.init() // init() should be called as first line after variable declaration console.FrameColor:=color.green console.log('\n') console.log('\n') console.log('Hello World') console.log('\n') console.log('\n') console.ShowStatusBar:=true console.StatusBarAtBottom:=true console.FrameColor:=color.blue //settings can be changed anytime before show method is called. Even twice. The last call will set the final value console.ShowHeader:=false //this wont throw error but is not used for console console.show(position=position.bottom_right) //this should be the last line of your code, after all methods and settings have been dealt with. ◼︎ Usage (Logx): Logx = Multiple columns logging with a limit of 4096 characters each message. When you need to log large number of messages. //@version=5 indicator("demo.Logx", overlay=true) plot(na) import GETpacman/logger/1 as logger var logx = logger.log.new() logx.init() // init() should be called as first line after variable declaration logx.FrameColor:=color.green logx.log('\n') logx.log('\n') logx.log('Hello World') logx.log('\n') logx.log('\n') logx.ShowStatusBar:=true logx.StatusBarAtBottom:=true logx.ShowQ3:=false logx.ShowQ4:=false logx.ShowQ5:=false logx.ShowQ6:=false logx.FrameColor:=color.olive //settings can be changed anytime before show method is called. Even twice. The last call will set the final value logx.show(position=position.top_right) //this should be the last line of your code, after all methods and settings have been dealt with. ◼︎ Fields (with default settings)   ▶︎ IsConsole         = True  Log will act as Console if true, otherwise it will act as Logx      ▶︎ ShowHeader        = True  (Log only) Will show a header at top or bottom of logx.   ▶︎ HeaderAtTop        = True  (Log only) Will show the header at the top, or bottom if false, if ShowHeader is true.   ▶︎ ShowStatusBar       = True  Will show a status bar at the bottom   ▶︎ StatusBarAtBottom     = True  Will show the status bar at the bottom, or top if false, if ShowHeader is true.   ▶︎ ShowMetaStatus      = True  Will show the meta info within status bar (Current Bar, characters left in console, Paging On Every Bar, Console dumped data etc)      ▶︎ ShowBarIndex       = True  Logx will show column for Bar Index when the message was logged. Console will add Bar index at the front of logged messages   ▶︎ ShowDateTime       = True  Logx will show column for Date/Time passed with the logged message logged. Console will add Date/Time at the front of logged messages   ▶︎ ShowLogLevels       = True  Logx will show column for Log levels corresponding to error codes. Console will log levels in the status bar   ▶︎ ReplaceWithErrorCodes   = True  (Log only) Logx will show error codes instead of log levels, if ShowLogLevels is switched on   ▶︎ RestrictLevelsToKey7    = True  Log levels will be restricted to Ley 7 codes - TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL, FATAL   ▶︎ ShowQ1          = True  (Log only) Show the column for Q1   ▶︎ ShowQ2          = True  (Log only) Show the column for Q2   ▶︎ ShowQ3          = True  (Log only) Show the column for Q3   ▶︎ ShowQ4          = True  (Log only) Show the column for Q4   ▶︎ ShowQ5          = True  (Log only) Show the column for Q5   ▶︎ ShowQ6          = True  (Log only) Show the column for Q6      ▶︎ ColorText         = True  Log/Console will color text as per error codes   ▶︎ HighlightText        = True  Log/Console will highlight text (like denoting) as per error codes      ▶︎ AutoMerge        = True  (Log only) Merge the queues towards the right if there is no data in those queues.   ▶︎ PageOnEveryBar      = True  Clear data from previous bars on each new bar, in conjuction with PageHistory setting.   ▶︎ MoveLogUp        = True  Move log in up direction. Setting to false will push logs down.   ▶︎ MarkNewBar       = True  On each change of bar, add a marker to show the bar has changed   ▶︎ PrefixLogLevel      = True  (Console only) Prefix all messages with the log level corresponding to error code.   ▶︎ MinWidth   = 40  Set the minimum width needed to be seen. Prevents logx/console shrinking below these number of characters.   ▶︎ TabSizeQ1      = 0   If set to more than one, the messages on Q1 or Console messages will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ2      = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ3     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ4     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ5     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ TabSizeQ6     = 0   If set to more than one, the messages on Q2 will indent by this size based on error code (Max 4 used)   ▶︎ PageHistory     = 0   Used with PageOnEveryBar. Determines how many historial pages to keep.      ▶︎ HeaderQbarIndex    = 'Bar#'  (Logx only) The header to show for Bar Index   ▶︎ HeaderQdateTime    = 'Date'  (Logx only) The header to show for Date/Time   ▶︎ HeaderQerrorCode   = 'eCode'  (Logx only) The header to show for Error Codes   ▶︎ HeaderQlogLevel    = 'State'  (Logx only) The header to show for Log Level   ▶︎ HeaderQ1       = 'h.Q1'   (Logx only) The header to show for Q1   ▶︎ HeaderQ2       = 'h.Q2'   (Logx only) The header to show for Q2   ▶︎ HeaderQ3       = 'h.Q3'   (Logx only) The header to show for Q3   ▶︎ HeaderQ4       = 'h.Q4'   (Logx only) The header to show for Q4   ▶︎ HeaderQ5       = 'h.Q5'   (Logx only) The header to show for Q5   ▶︎ HeaderQ6       = 'h.Q6'   (Logx only) The header to show for Q6   ▶︎ Status         = ''     Set the status to this text.   ▶︎ HeaderColor            Set the color for the header        ▶︎ HeaderColorBG           Set the background color for the header   ▶︎ StatusColor             Set the color for the status bar   ▶︎ StatusColorBG           Set the background color for the status bar   ▶︎ TextColor              Set the color for the text used without error code or code 0.   ▶︎ TextColorBG            Set the background color for the text used without error code or code 0.   ▶︎ FrameColor             Set the color for the frame around Logx/Console   ▶︎ FrameSize       = 1    Set the size of the frame around Logx/Console   ▶︎ CellBorderSize     = 0    Set the size of the border around cells.   ▶︎ CellBorderColor          Set the color for the border around cells within Logx/Console   ▶︎ SeparatorColor         = gray Set the color of separate in between Console/Logx Attachment    ◼︎ Methods (summary)   ● init               ▶︎ Initialise the log   ● log               ▶︎ Log the messages. Use method show to display the messages   ● page              ▶︎ Clear messages from previous bar while logging messages on this bar.   ● show              ▶︎ Shows a table displaying the logged messages   ● clear              ▶︎ Clears the log of all messages   ● resize              ▶︎ Resizes the log. If size is for reduction then oldest messages are lost first.   ● turnPage            ▶︎ When called, all messages marked with previous page, or from start are cleared   ● dateTimeFormat         ▶︎ Sets the date time format to be used when displaying date/time info.   ● resetTextColor          ▶︎ Reset Text Color to library default   ● resetTextBGcolor         ▶︎ Reset Text BG Color to library default   ● resetHeaderColor        ▶︎ Reset Header Color to library default   ● resetHeaderBGcolor       ▶︎ Reset Header BG Color to library default   ● resetStatusColor         ▶︎ Reset Status Color to library default   ● resetStatusBGcolor        ▶︎ Reset Status BG Color to library default   ● setColors            ▶︎ Sets the colors to be used for corresponding error codes   ● setColorsBG           ▶︎ Sets the background colors to be used for corresponding error codes. If not match of error code, then text color used.   ● setColorsHC           ▶︎ Sets the highlight colors to be used for corresponding error codes.If not match of error code, then text bg color used.   ● resetColors           ▶︎ Reset the colors to library default (Total 36, not including error code 0)   ● resetColorsBG          ▶︎ Reset the background colors to library default   ● resetColorsHC          ▶︎ Reset the highlight colors to library default   ● setLevelNames          ▶︎ Set the log level names to be used for corresponding error codes. If not match of error code, then empty string used.   ● resetLevelNames         ▶︎ Reset the log level names to library default. (Total 36) 1=TRACE, 2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=CRITICAL, 7=FATAL   ● attach              ▶︎ Attaches a console to an existing Logx, allowing to have dual logging system independent of each other   ● detach              ▶︎ Detaches an already attached console from Logx method clear(this)   Clears all the queue, including bar_index and time queues, of existing messages   Namespace types: log   Parameters:      this (log) method resize(this, rows)   Resizes the message queues. If size is decreased then removes the oldest messages   Namespace types: log   Parameters:      this (log)      rows (int) : The new size needed for the queues. Default value is 40. method dateTimeFormat(this, format)   Re/set the date time format used for displaying date and time. Default resets to dd.MMM.yy HH:mm   Namespace types: log   Parameters:      this (log)      format (string) method resetTextColor(this)   Resets the text color of the log to library default.   Namespace types: log   Parameters:      this (log) method resetTextColorBG(this)   Resets the background color of the log to library default.   Namespace types: log   Parameters:      this (log) method resetHeaderColor(this)   Resets the color used for Headers, to library default.   Namespace types: log   Parameters:      this (log) method resetHeaderColorBG(this)   Resets the background color used for Headers, to library default.   Namespace types: log   Parameters:      this (log) method resetStatusColor(this)   Resets the text color of the status row, to library default.   Namespace types: log   Parameters:      this (log) method resetStatusColorBG(this)   Resets the background color of the status row, to library default.   Namespace types: log   Parameters:      this (log) method resetFrameColor(this)   Resets the color used for the frame around the log table, to library default.   Namespace types: log   Parameters:      this (log) method resetColorsHC(this)   Resets the color used for the highlighting when Highlight Text option is used, to library default   Namespace types: log   Parameters:      this (log) method resetColorsBG(this)   Resets the background color used for setting the background color, when the Color Text option is used, to library default   Namespace types: log   Parameters:      this (log) method resetColors(this)   Resets the color used for respective error codes, when the Color Text option is used, to library default   Namespace types: log   Parameters:      this (log) method setColors(this, c)   Sets the colors corresponding to error codes   Index 0 of input array c is color is reserved for future use.   Index 1 of input array c is color for debug code 1.   Index 2 of input array c is color for debug code 2.   There are 2 modes of coloring     1 . Using the Foreground color     2 . Using the Foreground color as background color and a white/black/gray color as foreground color     This is denoting or highlighting. Which effectively puts the foreground color as background color   Namespace types: log   Parameters:      this (log)      c (color ) : Array of colors to be used for corresponding error codes. If the corresponding code is not found, then text color is used method setColorsHC(this, c)   Sets the highlight colors corresponding to error codes   Index 0 of input array c is color is reserved for future use.   Index 1 of input array c is color for debug code 1.   Index 2 of input array c is color for debug code 2.   There are 2 modes of coloring     1 . Using the Foreground color     2 . Using the Foreground color as background color and a white/black/gray color as foreground color     This is denoting or highlighting. Which effectively puts the foreground color as background color   Namespace types: log   Parameters:      this (log)      c (color ) : Array of highlight colors to be used for corresponding error codes. If the corresponding code is not found, then text color BG is used method setColorsBG(this, c)   Sets the highlight colors corresponding to debug codes   Index 0 of input array c is color is reserved for future use.   Index 1 of input array c is color for debug code 1.   Index 2 of input array c is color for debug code 2.   There are 2 modes of coloring     1 . Using the Foreground color     2 . Using the Foreground color as background color and a white/black/gray color as foreground color     This is denoting or highlighting. Which effectively puts the foreground color as background color   Namespace types: log   Parameters:      this (log)      c (color ) : Array of background colors to be used for corresponding error codes. If the corresponding code is not found, then text color BG is used method resetLevelNames(this, prefix, suffix)   Resets the log level names used for corresponding error codes   With prefix/suffix, the default Level name will be like => prefix + Code + suffix   Namespace types: log   Parameters:      this (log)      prefix (string) : Prefix to use when resetting level names      suffix (string) : Suffix to use when resetting level names method setLevelNames(this, names)   Resets the log level names used for corresponding error codes   Index 0 of input array names is reserved for future use.   Index 1 of input array names is name used for error code 1.   Index 2 of input array names is name used for error code 2.   Namespace types: log   Parameters:      this (log)      names (string ) : Array of log level names be used for corresponding error codes. If the corresponding code is not found, then an empty string is used method init(this, rows, isConsole)   Sets up data for logging. It consists of 6 separate message queues, and 3 additional queues for bar index, time and log level/error code. Do not directly alter the contents, as library could break.   Namespace types: log   Parameters:      this (log)      rows (int) : Log size, excluding the header/status. Default value is 50.      isConsole (bool) : Whether to init the log as console or logx. True= as console, False = as Logx. Default is true, hence init as console. method log(this, ec, m1, m2, m3, m4, m5, m6, tv, log)   Logs messages to the queues , including, time/date, bar_index, and error code   Namespace types: log   Parameters:      this (log)      ec (int) : Error/Code to be assigned.      m1 (string) : Message needed to be logged to Q1, or for console.      m2 (string) : Message needed to be logged to Q2. Not used/ignored when in console mode      m3 (string) : Message needed to be logged to Q3. Not used/ignored when in console mode      m4 (string) : Message needed to be logged to Q4. Not used/ignored when in console mode      m5 (string) : Message needed to be logged to Q5. Not used/ignored when in console mode      m6 (string) : Message needed to be logged to Q6. Not used/ignored when in console mode      tv (int) : Time to be used. Default value is time, which logs the start time of bar.      log (bool) : Whether to log the message or not. Default is true. method page(this, ec, m1, m2, m3, m4, m5, m6, tv, page)   Logs messages to the queues , including, time/date, bar_index, and error code. All messages from previous bars are cleared   Namespace types: log   Parameters:      this (log)      ec (int) : Error/Code to be assigned.      m1 (string) : Message needed to be logged to Q1, or for console.      m2 (string) : Message needed to be logged to Q2. Not used/ignored when in console mode      m3 (string) : Message needed to be logged to Q3. Not used/ignored when in console mode      m4 (string) : Message needed to be logged to Q4. Not used/ignored when in console mode      m5 (string) : Message needed to be logged to Q5. Not used/ignored when in console mode      m6 (string) : Message needed to be logged to Q6. Not used/ignored when in console mode      tv (int) : Time to be used. Default value is time, which logs the start time of bar.      page (bool) : Whether to log the message or not. Default is true. method turnPage(this, turn)   Set the messages to be on a new page, clearing messages from previous page.   This is not dependent on PageHisotry option, as this method simply just clears all the messages, like turning old pages to a new page.   Namespace types: log   Parameters:      this (log)      turn (bool) method show(this, position, hhalign, hvalign, hsize, thalign, tvalign, tsize, show, attach)   Display Message Q, Index Q, Time Q, and Log Levels   All options for postion/alignment accept TV values, such as position.bottom_right, text.align_left, size.auto etc.   Namespace types: log   Parameters:      this (log)      position (string) : Position of the table used for displaying the messages. Default is Bottom Right.      hhalign (string) : Horizontal alignment of Header columns      hvalign (string) : Vertical alignment of Header columns      hsize (string) : Size of Header text Options      thalign (string) : Horizontal alignment of all messages      tvalign (string) : Vertical alignment of all messages      tsize (string) : Size of text across the table      show (bool) : Whether to display the logs or not. Default is true.      attach (log) : Console that has been attached via attach method. If na then console will not be shown method attach(this, attach, position)   Attaches a console to Logx, or moves already attached console around Logx   All options for position/alignment accept TV values, such as position.bottom_right, text.align_left, size.auto etc.   Namespace types: log   Parameters:      this (log)      attach (log) : Console object that has been previously attached.      position (string) : Position of Console in relation to Logx. Can be Top, Right, Bottom, Left. Default is Bottom. If unknown specified then defaults to bottom. method detach(this, attach)   Detaches the attached console from Logx.   All options for position/alignment accept TV values, such as position.bottom_right, text.align_left, size.auto etc.   Namespace types: log   Parameters:      this (log)      attach (log) : Console object that has been previously attached.
Pine Script® library
by GETpacman
Candlestick Pattern Criteria and Analysis Indicator█  OVERVIEW Define, then locate the presence of a candle that fits a specific criteria. Run a basic calculation on what happens after such a candle occurs. Here, I’m not giving you an edge, but I’m giving you a clear way to find one. IMPORTANT NOTE: PLEASE READ: THE INDICATOR WILL ALWAYS INITIALLY LOAD WITH A RUNTIME ERROR. WHEN INITIALLY LOADED THERE NO CRITERIA SELECTED. If you do not select a criteria or run a search for a criteria that doesn’t exist, you will get a runtime error. If you want to force the chart to load anyway, enable the debug panel at the bottom of the settings menu. Who this is for: - People who want to engage in TradingView for tedious and challenging data analysis related to candlestick measurement and occurrence rate and signal bar relationships with subsequent bars. People who don’t know but want to figure out what a strong bullish bar or a strong bearish bar is. Who this is not for: - People who want to be told by an indicator what is good or bad or buy or sell. Also, not for people that don’t have any clear idea on what they think is a strong bullish bar or a strong bearish bar and aren’t willing to put in the work. Recommendation: Use on the candle resolution that accurately reflects your typical holding period. If you typically hold a trade for 3 weeks, use 3W candles. If you hold a trade for 3 minutes, use 3m candles. Tldr; Read the tool tips and everything above this line. Let me know any issues that arise or questions you have. █  CONCEPTS Many trading styles indicate that a certain candle construct implies a bearish or bullish future for price. That said, it is also common to add to that idea that the context matters. Of course, this is how you end up with all manner of candlestick patterns accounting for thousands of pages of literature. No matter the context though, we can distill a discretionary trader's decision to take a trade based on one very basic premise: “A trader decides to take a trade on the basis of the rightmost candle's construction and what he/she believes that candle construct implies about the future price.” This indicator vets that trader’s theory in the most basic way possible. It finds the instances of any candle construction and takes a look at what happens on the next bar. This current bar is our “Signal Bar.” █  GUIDE I said that we vet the theory in the most basic way possible. But, in truth, this indicator is very complex as a result of there being thousands of ways to define a ‘strong’ candle. And you get to define things on a very granular level with this indicator. Features: 1. Candle Highlighting When the user’s criteria is met, the candle is highlighted on the chart. The following candle is highlighted based on whether it breaks out, breaks down, or is an inside bar. 2. User-Defined Criteria Criteria that you define include: Candle Type: Bull bars, Bear bars, or both Candle Attributes Average Size based on Standard Deviation or Average of all potential bars in price history Search within a specific price range Search within a specific time range Clarify time range using defined sessions and with or without weekends 3. Strike Lines on Candle Often you want to know how price reacts when it gets back to a certain candle. Also it might be true that candle types cluster in a price region. This can be identified visually by adding lines that extend right on candles that fit the criteria. 4. User-Defined Context Labeled “Alternative Criteria,” this facet of the script allows the user to take the context provided from another indicator and import it into the indicator to use as a overriding criteria. To account for the fact that the external indicator must be imported as a float value, true (criteria of external indicator is met) must be imported as 1 and false (criteria of external indicator is not met) as 0. Basically a binary Boolean. This can be used to create context, such as in the case of a traditional fractal, or can be used to pair with other signals. If you know how to code in Pinescript, you can save a copy and simply add your own code to the section indicated in the code and set your bull and bear variables accordingly and the code should compile just fine with no further editing needed. Included with the script to maximize out-of-the-box functionality, there is preloaded as alternative criteria a code snippet. The criteria is met on the bull side when the current candle close breaks out above the prior candle high. The bear criteria is met when the close breaks below the prior candle. When Alternate Criteria is run by itself, this is the only criteria set and bars are highlighted when it is true. You can qualify these candles by adding additional attributes that you think would fit well. Using Alternative Criteria, you are essentially setting a filter for the rest of the criteria. 5. Extensive Read Out in the Data Window (right side bar pop out window). As you can see in the thumbnail, there is pasted a copy of the Data Window Dialogue. I am doubtful I can get the thumbnail to load up perfectly aligned. Its hard to get all these data points in here. It may be better suited for a table at this point. Let me know what you think. The primary, but not exclusive, purpose of what is in the Data Window is to talk about how often your criteria happens and what happens on the next bar. There are a lot of pieces to this. Red = Values pertaining to the size of the current bar only Blue = Values pertaining or related to the total number of signals Green = Values pertaining to the signal bars themselves, including their measurements Purple = Values pertaining to bullish bars that happen after the signal bar Fuchsia = Values pertaining to bearish bars that happen after the signal bar Lime = Last four rows which are your percentage occurrence vs total signals percentages The best way I can explain how to understand parts you don’t understand otherwise in the data window is search the title of the row in the code using ‘ctrl+f’ and look at it and see if it makes more sense. █ [b}Available Candle Attributes Candle attributes can be used in any combination. They include: [*}Bodies [*}High/Low Range [*}Upper Wick [*}Lower Wick [*}Average Size [*}Alternative Criteria Criteria will evaluate each attribute independently. If none is set for a particular attribute it is bypassed. Criteria Quantity can be in Ticks, Points, or Percentage. For percentage keep in mind if using anything involving the candle range will not work well with percentage. Criteria Operators are “Greater Than,” “Less Than,” and “Threshold.” Threshold means within a range of two numbers. █ Problems with this methodology and opportunities for future development: #1 This kind of work is hard. If you know what you’re doing you might be able to find success changing out the inputs for loops and logging results in arrays or matrices, but to manually go through and test various criteria is a lot of work. However, it is rewarding. At the time of publication in early Oct 2022, you will quickly find that you get MUCH more follow through on bear bars than bull bars. That should be obvious because we’re in the middle of a bear market, but you can still work with the parameters and contextual inputs to determine what maximizes your probability. I’ve found configurations that yield 70% probability across the full series of bars. That’s an edge. That means that 70% of the time, when this criteria is met, the next bar puts you in profit. #2 The script is VERY heavy. Takes an eternity to load. But, give it a break, it’s doing a heck of a lot! There is 10 unique arrays in here and a loop that is a bit heavy but gives us the debug window. #3 If you don’t have a clear idea its hard to know where to start. There are a lot of levers to pull on in this script. Knowing which ones are useful and meaningful is very challenging. Combine that with long load times… its not great. #4 Your brain is the only thing that can optimize your results because the criteria come from your mind. Machine learning would be much more useful here, but for now, you are the machine. Learn. #5 You can’t save your settings. So, when you find a good combo, you’ll have to write it down elsewhere for future reference. It would be nice if we could save templates on custom indicators like we can on some of the built in drawing tools, but I’ve had no success in that. So, I recommend screenshotting your settings and saving them in Notion.so or some other solid record keeping database. Then you can go back and retrieve those settings. #6 no way to export these results into conditions that can be copy/pasted into another script. Copy/Paste of labels or tables would be the best feature ever at this point. Because you could take the criteria and put it in a label, copy it and drop it into another strategy script or something. But… men can dream. █ Opportunities to PineCoders Learn: 1. In this script I’m importing libraries, showing some of my libraries functionality. Hopefully that gives you some ideas on how to use them too. The price displacement library (which I love!) Creative and conventional ways of using debug() how to display arrays and matrices on charts I didn’t call in the library that holds the backtesting function. But, also demonstrating, you can always pull the library up and just copy/paste the function out of there and into your script. That’s fine to do a lot of the time. 2. I am using REALLY complicated logic in this script (at least for me). I included extensive descriptions of this ? : logic in the text of the script. I also did my best to bracket () my logic groups to demonstrate how they fit together, both for you and my future self. 3. The breakout, built-in, “alternative criteria” is actually a small bit of genius built in there if you want to take the time to understand that block of code and think about some of the larger implications of the method deployed. As always, a big thank you to TradingView and the Pinescript community, the Pinescript pros who have mentored me, and all of you who I am privileged to help in their Pinescripting journey. "Those who stay will become champions" - Bo Schembechler
Pine Script® indicator
by kurtsmock
6
Impactful pattern and candles pattern AlertThe Alertion indicator! impactful pattern: pattern that happen near the zone or in the zone at lower timeframe and give us entry and stop limit price. It is helpful for price action traders and those who want to decrease their risk. There are 3 IP patterns: Quasimodo Head and shoulder whipsaw engulfing These patterns may occur near the zone or may not occur but by them, you can decrease your trading risk for example you can trade with half lot before IP pattern and enter with other half after pattern. how to use? for example: you find zone at 1h timeframe for short position when price enter to your zone you run this indicator and choose your lower timeframe, for example 15m and click on short position. Then make the alert by right-click on your chart and choose the add alert and at condition box choose the impactful pattern and then click on create now wait for message :) Candles pattern: like reversal bar, key reversal bar, exhaustion bar, pin bar, two-bar reversal, tree-bar reversal, inside bar, outside bar these occur when the trend turn, so it is usable when the price enter to your zone or near your zone. This pattern can decrease your risk. Inside bar and outside bar: if this pattern engulf up, it is bullish pattern and if engulf down, it is bearish pattern. what does this indicator do? this indicator is for making alert it helps you to decrease your risk and failure. You optimize it to alert you when IP pattern happen or candle pattern happen or inside bar or outside bar engulfing or all of them. For IP pattern, it will message you entry and stop limit price. It works at 2 different timeframes, so you can make alert for example in 1h TF for candles pattern and 15m TF for IP pattern. Indicator will alert you for candles pattern at your chart timeframe and for IP pattern at timeframe you've chosen when you run the indicator, and it is changeable in setting. setting options TIMEFRAME IP: select the timeframe for IP patterns it means when IP pattern happen at that timeframe the indicator will alert you example = your TF is 1h, you found the supply zone and want to trade, note that IP pattern happen in lower TF, so you select 15m TF or TF lower than 1h. Short position: select it if you want to make short position. BUFFERING indicator send you entry and stop limit price you can change it by amount of percent it is your strategy to change your entry and stop loss or not example= in head and shoulder pattern at short position, the stop limit is high price of head in pattern so the indicator will message you the exact price but if you want to put your stop limit 5 percent upper than exact price you can enter 5 in front of stop loss or you want to enter 5 percent lower than exact high price of shoulder, you can optimize it. ALERTION you choose what alert you want IP alert or candle alert or inside and outside bar alert type your text for alert you can write additional text for your message ADVANCE IP alert frequency option: 1. Once per bar : indicator will alert you for IP pattern once at your chat timeframe bar, and you should wait til next bar for next alert. 2. Once per bar close : alert you when your chart timeframe bar closed and next alert will happen when next bar is closed. 3. All: alert you all the times IP pattern happen pivot left and right bars: lower will find smaller pattern at the END: this indicator is not strategy it is part of your strategy that help you to increase your winning rate. It is helpful for scalping and candle patterns finding. After you make an alert, you can delete the indicator or change your timeframe or make another alert, your previous alert won’t change. Thank you all.
Pine Script® indicator
by erfan_abedi
1