Empiece

Buscar en scripts para "session"

Trading IQ - ICT LibraryLibrary "ICTlibrary" Used to calculate various ICT related price levels and strategies. An ongoing project. Hello Coders! This library is meant for sourcing ICT related concepts. While some functions might generate more output than you require, you can specify "Lite Mode" as "true" in applicable functions to slim down necessary inputs. isLastBar(userTF)   Identifies the last bar on the chart before a timeframe change   Parameters:      userTF (simple int) : the timeframe you wish to calculate the last bar for, must be converted to integer using 'timeframe.in_seconds()'   Returns: bool true if bar on chart is last bar of higher TF, dalse if bar on chart is not last bar of higher TF necessaryData(atrTF)   returns necessaryData UDT for historical data access   Parameters:      atrTF (float) : user-selected timeframe ATR value.   Returns: logZ. log return Z score, used for calculating order blocks. method gradBoxes(gradientBoxes, idColor, timeStart, bottom, top, rightCoordinate)   creates neon like effect for box drawings   Namespace types: array   Parameters:      gradientBoxes (array) : an array.new() to store the gradient boxes      idColor (color)      timeStart (int) : left point of box      bottom (float) : bottom of box price point      top (float) : top of box price point      rightCoordinate (int) : right point of box   Returns: void checkIfTraded(tradeName)   checks if recent trade is of specific name   Parameters:      tradeName (string)   Returns: bool true if recent trade id matches target name, false otherwise checkIfClosed(tradeName)   checks if recent closed trade is of specific name   Parameters:      tradeName (string)   Returns: bool true if recent closed trade id matches target name, false otherwise IQZZ(atrMult, finalTF)   custom ZZ to quickly determine market direction.   Parameters:      atrMult (float) : an atr multiplier used to determine the required price move for a ZZ direction change      finalTF (string) : the timeframe used for the atr calcuation   Returns: dir market direction. Up => 1, down => -1 method drawBos(id, startPoint, getKeyPointTime, getKeyPointPrice, col, showBOS, isUp)   calculates and draws Break Of Structure   Namespace types: array   Parameters:      id (array)      startPoint (chart.point)      getKeyPointTime (int) : the actual time of startPoint, simplystartPoint.time      getKeyPointPrice (float) : the actual time of startPoint, simplystartPoint.price      col (color) : color of the BoS line / label      showBOS (bool) : whether to show label/line. This function still calculates internally for other ICT related concepts even if not drawn.      isUp (bool) : whether BoS happened during price increase or price decrease.   Returns: void method drawMSS(id, startPoint, getKeyPointTime, getKeyPointPrice, col, showMSS, isUp, upRejections, dnRejections, highArr, lowArr, timeArr, closeArr, openArr, atrTFarr, upRejectionsPrices, dnRejectionsPrices)   calculates and draws Market Structure Shift. This data is also used to calculate Rejection Blocks.   Namespace types: array   Parameters:      id (array)      startPoint (chart.point)      getKeyPointTime (int) : the actual time of startPoint, simplystartPoint.time      getKeyPointPrice (float) : the actual time of startPoint, simplystartPoint.price      col (color) : color of the MSS line / label      showMSS (bool) : whether to show label/line. This function still calculates internally for other ICT related concepts even if not drawn.      isUp (bool) : whether MSS happened during price increase or price decrease.      upRejections (array)      dnRejections (array)      highArr (array) : array containing historical highs, should be taken from the UDT "necessaryData" defined above      lowArr (array) : array containing historical lows, should be taken from the UDT "necessaryData" defined above      timeArr (array) : array containing historical times, should be taken from the UDT "necessaryData" defined above      closeArr (array) : array containing historical closes, should be taken from the UDT "necessaryData" defined above      openArr (array) : array containing historical opens, should be taken from the UDT "necessaryData" defined above      atrTFarr (array) : array containing historical atr values (of user-selected TF), should be taken from the UDT "necessaryData" defined above      upRejectionsPrices (array) : array containing up rejections prices. Is sorted and used to determine selective looping for invalidations.      dnRejectionsPrices (array) : array containing down rejections prices. Is sorted and used to determine selective looping for invalidations.   Returns: void method getTime(id, compare, timeArr)   gets time of inputted price (compare) in an array of data this is useful when the user-selected timeframe for ICT concepts is greater than the chart's timeframe   Namespace types: array   Parameters:      id (array) : the array of data to search through, to find which index has the same value as "compare"      compare (float) : the target data point to find in the array      timeArr (array) : array of historical times   Returns: the time that the data point in the array was recorded method OB(id, highArr, signArr, lowArr, timeArr, sign)   store bullish orderblock data   Namespace types: array   Parameters:      id (array)      highArr (array) : array of historical highs      signArr (array) : array of historical price direction "math.sign(close - open)"      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      sign (int) : orderblock direction, -1 => bullish, 1 => bearish   Returns: void OTEstrat(OTEstart, future, closeArr, highArr, lowArr, timeArr, longOTEPT, longOTESL, longOTElevel, shortOTEPT, shortOTESL, shortOTElevel, structureDirection, oteLongs, atrTF, oteShorts)   executes the OTE strategy   Parameters:      OTEstart (chart.point)      future (int) : future time point for drawings      closeArr (array) : array of historical closes      highArr (array) : array of historical highs      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      longOTEPT (string) : user-selected long OTE profit target, please create an input.string() for this using the example below      longOTESL (int) : user-selected long OTE stop loss, please create an input.string() for this using the example below      longOTElevel (float) : long entry price of selected retracement ratio for OTE      shortOTEPT (string) : user-selected short OTE profit target, please create an input.string() for this using the example below      shortOTESL (int) : user-selected short OTE stop loss, please create an input.string() for this using the example below      shortOTElevel (float) : short entry price of selected retracement ratio for OTE      structureDirection (string) : current market structure direction, this should be "Up" or "Down". This is used to cancel pending orders if market structure changes      oteLongs (bool) : input.bool() for whether OTE longs can be executed      atrTF (float) : atr of the user-seleceted TF      oteShorts (bool) : input.bool() for whether OTE shorts can be executed @exampleInputs oteLongs = input.bool(defval = false, title = "OTE Longs", group = "Optimal Trade Entry") longOTElevel = input.float(defval = 0.79, title = "Long Entry Retracement Level", options = , group = "Optimal Trade Entry") longOTEPT = input.string(defval = "-0.5", title = "Long TP", options = , group = "Optimal Trade Entry") longOTESL = input.int(defval = 0, title = "How Many Ticks Below Swing Low For Stop Loss", group = "Optimal Trade Entry") oteShorts = input.bool(defval = false, title = "OTE Shorts", group = "Optimal Trade Entry") shortOTElevel = input.float(defval = 0.79, title = "Short Entry Retracement Level", options = , group = "Optimal Trade Entry") shortOTEPT = input.string(defval = "-0.5", title = "Short TP", options = , group = "Optimal Trade Entry") shortOTESL = input.int(defval = 0, title = "How Many Ticks Above Swing Low For Stop Loss", group = "Optimal Trade Entry")   Returns: void (0) displacement(logZ, atrTFreg, highArr, timeArr, lowArr, upDispShow, dnDispShow, masterCoords, labelLevels, dispUpcol, rightCoordinate, dispDncol, noBorders)   calculates and draws dispacements   Parameters:      logZ (float) : log return of current price, used to determine a "significant price move" for a displacement      atrTFreg (float) : atr of user-seleceted timeframe      highArr (array) : array of historical highs      timeArr (array) : array of historical times      lowArr (array) : array of historical lows      upDispShow (int) : amount of historical upside displacements to show      dnDispShow (int) : amount of historical downside displacements to show      masterCoords (map) : a map to push the most recent displacement prices into, useful for having key levels in one data structure      labelLevels (string) : used to determine label placement for the displacement, can be inside box, outside box, or none, example below      dispUpcol (color) : upside displacement color      rightCoordinate (int) : future time for displacement drawing, best is "last_bar_time"      dispDncol (color) : downside displacement color      noBorders (bool) : input.bool() to remove box borders, example below @exampleInputs labelLevels = input.string(defval = "Inside" , title = "Box Label Placement", options = ) noBorders = input.bool(defval = false, title = "No Borders On Levels")   Returns: void method getStrongLow(id, startIndex, timeArr, lowArr, strongLowPoints)   unshift strong low data to array id   Namespace types: array   Parameters:      id (array)      startIndex (int) : the starting index for the timeArr array of the UDT "necessaryData". this point should start from at least 1 pivot prior to find the low before an upside BoS      timeArr (array) : array of historical times      lowArr (array) : array of historical lows      strongLowPoints (array) : array of strong low prices. Used to retrieve highest strong low price and see if need for removal of invalidated strong lows   Returns: void method getStrongHigh(id, startIndex, timeArr, highArr, strongHighPoints)   unshift strong high data to array id   Namespace types: array   Parameters:      id (array)      startIndex (int) : the starting index for the timeArr array of the UDT "necessaryData". this point should start from at least 1 pivot prior to find the high before a downside BoS      timeArr (array) : array of historical times      highArr (array) : array of historical highs      strongHighPoints (array)   Returns: void equalLevels(highArr, lowArr, timeArr, rightCoordinate, equalHighsCol, equalLowsCol, liteMode)   used to calculate recent equal highs or equal lows   Parameters:      highArr (array) : array of historical highs      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      rightCoordinate (int) : a future time (right for boxes, x2 for lines)      equalHighsCol (color) : user-selected color for equal highs drawings      equalLowsCol (color) : user-selected color for equal lows drawings      liteMode (bool) : optional for a lite mode version of an ICT strategy. For more control over drawings leave as "True", "False" will apply neon effects   Returns: void quickTime(timeString)   used to quickly determine if a user-inputted time range is currently active in NYT time   Parameters:      timeString (string) : a time range   Returns: true if session is active, false if session is inactive macros(showMacros, noBorders)   used to calculate and draw session macros   Parameters:      showMacros (bool) : an input.bool() or simple bool to determine whether to activate the function      noBorders (bool) : an input.bool() to determine whether the box anchored to the session should have borders   Returns: void po3(tf, left, right, show)   use to calculate HTF po3 candle @tip only call this function on "barstate.islast"   Parameters:      tf (simple string)      left (int) : the left point of the candle, calculated as bar_index + left,      right (int) : :the right point of the candle, calculated as bar_index + right,      show (bool) : input.bool() whether to show the po3 candle or not   Returns: void silverBullet(silverBulletStratLong, silverBulletStratShort, future, userTF, H, L, H2, L2, noBorders, silverBulletLongTP, historicalPoints, historicalData, silverBulletLongSL, silverBulletShortTP, silverBulletShortSL)   used to execute the Silver Bullet Strategy   Parameters:      silverBulletStratLong (simple bool)      silverBulletStratShort (simple bool)      future (int) : a future time, used for drawings, example "last_bar_time"      userTF (simple int)      H (float) : the high price of the user-selected TF      L (float) : the low price of the user-selected TF      H2 (float) : the high price of the user-selected TF      L2 (float) : the low price of the user-selected TF      noBorders (bool) : an input.bool() used to remove the borders from box drawings      silverBulletLongTP (series silverBulletLevels)      historicalPoints (array)      historicalData (necessaryData)      silverBulletLongSL (series silverBulletLevels)      silverBulletShortTP (series silverBulletLevels)      silverBulletShortSL (series silverBulletLevels)   Returns: void method invalidFVGcheck(FVGarr, upFVGpricesSorted, dnFVGpricesSorted)   check if existing FVGs are still valid   Namespace types: array   Parameters:      FVGarr (array)      upFVGpricesSorted (array) : an array of bullish FVG prices, used to selective search through FVG array to remove invalidated levels      dnFVGpricesSorted (array) : an array of bearish FVG prices, used to selective search through FVG array to remove invalidated levels   Returns: void (0) method drawFVG(counter, FVGshow, FVGname, FVGcol, data, masterCoords, labelLevels, borderTransp, liteMode, rightCoordinate)   draws FVGs on last bar   Namespace types: map   Parameters:      counter (map) : a counter, as map, keeping count of the number of FVGs drawn, makes sure that there aren't more FVGs drawn than int FVGshow      FVGshow (int) : the number of FVGs to show. There should be a bullish FVG show and bearish FVG show. This function "drawFVG" is used separately for bearish FVG and bullish FVG.      FVGname (string) : the name of the FVG, "FVG Up" or "FVG Down"      FVGcol (color) : desired FVG color      data (FVG)      masterCoords (map) : a map containing the names and price points of key levels. Used to define price ranges.      labelLevels (string) : an input.string with options "Inside", "Outside", "Remove". Determines whether FVG labels should be inside box, outside, or na.      borderTransp (int)      liteMode (bool)      rightCoordinate (int) : the right coordinate of any drawings. Must be a time point.   Returns: void invalidBlockCheck(bullishOBbox, bearishOBbox, userTF)   check if existing order blocks are still valid   Parameters:      bullishOBbox (array) : an array declared using the UDT orderBlock that contains bullish order block related data      bearishOBbox (array) : an array declared using the UDT orderBlock that contains bearish order block related data      userTF (simple int)   Returns: void (0) method lastBarRejections(id, rejectionColor, idShow, rejectionString, labelLevels, borderTransp, liteMode, rightCoordinate, masterCoords)   draws rejectionBlocks on last bar   Namespace types: array   Parameters:      id (array) : the array, an array of rejection block data declared using the UDT rejection block      rejectionColor (color) : the desired color of the rejection box      idShow (int)      rejectionString (string) : the desired name of the rejection blocks      labelLevels (string) : an input.string() to determine if labels for the block should be inside the box, outside, or none.      borderTransp (int)      liteMode (bool) : an input.bool(). True = neon effect, false = no neon.      rightCoordinate (int) : atime for the right coordinate of the box      masterCoords (map) : a map that stores the price of key levels and assigns them a name, used to determine price ranges   Returns: void method OBdraw(id, OBshow, BBshow, OBcol, BBcol, bullishString, bearishString, isBullish, labelLevels, borderTransp, liteMode, rightCoordinate, masterCoords)   draws orderblocks and breaker blocks for data stored in UDT array()   Namespace types: array   Parameters:      id (array) : the array, an array of order block data declared using the UDT orderblock      OBshow (int) : the number of order blocks to show      BBshow (int) : the number of breaker blocks to show      OBcol (color) : color of order blocks      BBcol (color) : color of breaker blocks      bullishString (string) : the title of bullish blocks, which is a regular bullish orderblock or a bearish orderblock that's converted to breakerblock      bearishString (string) : the title of bearish blocks, which is a regular bearish orderblock or a bullish orderblock that's converted to breakerblock      isBullish (bool) : whether the array contains bullish orderblocks or bearish orderblocks. If bullish orderblocks, the array will naturally contain bearish BB, and if bearish OB, the array will naturally contain bullish BB      labelLevels (string) : an input.string() to determine if labels for the block should be inside the box, outside, or none.      borderTransp (int)      liteMode (bool) : an input.bool(). True = neon effect, false = no neon.      rightCoordinate (int) : atime for the right coordinate of the box      masterCoords (map) : a map that stores the price of key levels and assigns them a name, used to determine price ranges   Returns: void FVG   UDT for FVG calcualtions   Fields:      H (series float) : high price of user-selected timeframe      L (series float) : low price of user-selected timeframe      direction (series string) : FVG direction => "Up" or "Down"      T (series int) : => time of bar on user-selected timeframe where FVG was created      fvgLabel (series label) : optional label for FVG      fvgLineTop (series line) : optional line for top of FVG      fvgLineBot (series line) : optional line for bottom of FVG      fvgBox (series box) : optional box for FVG labelLine   quickly pair a line and label together as UDT   Fields:      lin (series line) : Line you wish to pair with label      lab (series label) : Label you wish to pair with line orderBlock   UDT for order block calculations   Fields:      orderBlockData (array) : array containing order block x and y points      orderBlockBox (series box) : optional order block box      vioCount (series int) : = 0 violation count of the order block. 0 = Order Block, 1 = Breaker Block      traded (series bool)      status (series string) : = "OB" status == "OB" => Level is order block. status == "BB" => Level is breaker block.      orderBlockLab (series label) : options label for the order block / breaker block. strongPoints   UDT for strong highs and strong lows   Fields:      price (series float) : price of the strong high or strong low      timeAtprice (series int) : time of the strong high or strong low      strongPointLabel (series label) : optional label for strong point      strongPointLine (series line) : optional line for strong point      overlayLine (series line) : optional lines for strong point to enhance visibility      overlayLine2 (series line) : optional lines for strong point to enhance visibility displacement   UDT for dispacements   Fields:      highPrice (series float) : high price of displacement      lowPrice (series float) : low price of displacement      timeAtPrice (series int) : time of bar where displacement occurred      displacementBox (series box) : optional box to draw displacement      displacementLab (series label) : optional label for displacement po3data   UDT for po3 calculations   Fields:      dHigh (series float) : higher timeframe high price      dLow (series float) : higher timeframe low price      dOpen (series float) : higher timeframe open price      dClose (series float) : higher timeframe close price      po3box (series box) : box to draw po3 candle body      po3line (array) : line array to draw po3 wicks      po3Labels (array) : label array to label price points of po3 candle macros   UDT for session macros   Fields:      sessions (array) : Array of sessions, you can populate this array using the "quickTime" function located above "export macros".      prices (matrix) : Matrix of session data -> open, high, low, close, time      sessionTimes (array) : Array of session names. Pairs with array sessions.      sessionLines (matrix) : Optional array for sesion drawings. OTEtimes   UDT for data storage and drawings associated with OTE strategy   Fields:      upTimes (array) : time of highest point before trade is taken      dnTimes (array) : time of lowest point before trade is taken      tpLineLong (series line) : line to mark tp level long      tpLabelLong (series label) : label to mark tp level long      slLineLong (series line) : line to mark sl level long      slLabelLong (series label) : label to mark sl level long      tpLineShort (series line) : line to mark tp level short      tpLabelShort (series label) : label to mark tp level short      slLineShort (series line) : line to mark sl level short      slLabelShort (series label) : label to mark sl level short sweeps   UDT for data storage and drawings associated with liquidity sweeps   Fields:      upSweeps (matrix) : matrix containing liquidity sweep price points and time points for up sweeps      dnSweeps (matrix) : matrix containing liquidity sweep price points and time points for down sweeps      upSweepDrawings (array) : optional up sweep box array. Pair the size of this array with the rows or columns,      dnSweepDrawings (array) : optional up sweep box array. Pair the size of this array with the rows or columns, raidExitDrawings   UDT for drawings associated with the Liquidity Raid Strategy   Fields:      tpLine (series line) : tp line for the liquidity raid entry      tpLabel (series label) : tp label for the liquidity raid entry      slLine (series line) : sl line for the liquidity raid entry      slLabel (series label) : sl label for the liquidity raid entry m2022   UDT for data storage and drawings associated with the Model 2022 Strategy   Fields:      mTime (series int) : time of the FVG where entry limit order is placed      mIndex (series int) : array index of FVG where entry limit order is placed. This requires an array of FVG data, which is defined above.      mEntryDistance (series float) : the distance of the FVG to the 50% range. M2022 looks for the fvg closest to 50% mark of range.      mEntry (series float) : the entry price for the most eligible fvg      fvgHigh (series float) : the high point of the eligible fvg      fvgLow (series float) : the low point of the eligible fvg      longFVGentryBox (series box) : long FVG box, used to draw the eligible FVG      shortFVGentryBox (series box) : short FVG box, used to draw the eligible FVG      line50P (series line) : line used to mark 50% of the range      line100P (series line) : line used to mark 100% (top) of the range      line0P (series line) : line used to mark 0% (bottom) of the range      label50P (series label) : label used to mark 50% of the range      label100P (series label) : label used to mark 100% (top) of the range      label0P (series label) : label used to mark 0% (bottom) of the range      sweepData (array) silverBullet   UDT for data storage and drawings associated with the Silver Bullet Strategy   Fields:      session (series bool)      sessionStr (series string) : name of the session for silver bullet      sessionBias (series string)      sessionHigh (series float) : = high high of session // use math.max(silverBullet.sessionHigh, high)      sessionLow (series float) : = low low of session // use math.min(silverBullet.sessionLow, low)      sessionFVG (series float) : if applicable, the FVG created during the session      sessionFVGdraw (series box) : if applicable, draw the FVG created during the session      traded (series bool)      tp (series float) : tp of trade entered at the session FVG      sl (series float) : sl of trade entered at the session FVG      sessionDraw (series box) : optional draw session with box      sessionDrawLabel (series label) : optional label session with label silverBulletDrawings   UDT for trade exit drawings associated with the Silver Bullet Strategy   Fields:      tpLine (series line) : tp line drawing for strategy      tpLabel (series label) : tp label drawing for strategy      slLine (series line) : sl line drawing for strategy      slLabel (series label) : sl label drawing for strategy unicornModel   UDT for data storage and drawings associated with the Unicorn Model Strategy   Fields:      hPoint (chart.point)      hPoint2 (chart.point)      hPoint3 (chart.point)      breakerBlock (series box) : used to draw the breaker block required for the Unicorn Model      FVG (series box) : used to draw the FVG required for the Unicorn model      topBlock (series float) : price of top of breaker block, can be used to detail trade entry      botBlock (series float) : price of bottom of breaker block, can be used to detail trade entry      startBlock (series int) : start time of the breaker block, used to set the "left = " param for the box      includes (array) : used to store the time of the breaker block, or FVG, or the chart point sequence that setup the Unicorn Model.      entry (series float) : // eligible entry price, for longs"math.max(topBlock, FVG.get_top())",      tpLine (series line) : optional line to mark PT      tpLabel (series label) : optional label to mark PT      slLine (series line) : optional line to mark SL      slLabel (series label) : optional label to mark SL rejectionBlocks   UDT for data storage and drawings associated with rejection blocks   Fields:      rejectionPoint (chart.point)      bodyPrice (series float) : candle body price closest to the rejection point, for "Up" rejections => math.max(open, close),      rejectionBox (series box) : optional box drawing of the rejection block      rejectionLabel (series label) : optional label for the rejection block equalLevelsDraw   UDT for data storage and drawings associated with equal highs / equal lows   Fields:      connector (series line) : single line placed at the first high or low, y = avgerage of distinguished equal highs/lows      connectorLab (series label) : optional label to be placed at the highs or lows      levels (array) : array containing the equal highs or lows prices      times (array) : array containing the equal highs or lows individual times      startTime (series int) : the time of the first high or low that forms a sequence of equal highs or lows      radiate (array) : options label to "radiate" the label in connector lab. Can be used for anything necessaryData   UDT for data storage of historical price points.   Fields:      highArr (array) : array containing historical high points      lowArr (array) : array containing historical low points      timeArr (array) : array containing historical time points      logArr (array) : array containing historical log returns      signArr (array) : array containing historical price directions      closeArr (array) : array containing historical close points      binaryTimeArr (array) : array containing historical time points, uses "push" instead of "unshift" to allow for binary search      binaryCloseArr (array) : array containing historical close points, uses "push" instead of "unshift" to allow the correct      binaryOpenArr (array) : array containing historical optn points, uses "push" instead of "unshift" to allow the correct      atrTFarr (array) : array containing historical user-selected TF atr points      openArr (array) : array containing historical open points
Biblioteca Pine Script®
por Trading-IQ
1
Casa_VolumeProfileSessionLibrary "Casa_VolumeProfileSession" Analyzes price and volume during regular trading hours to provide a session volume profile, including Point of Control (POC), Value Area High (VAH), and Value Area Low (VAL). Calculates and displays these levels historically and for the developing session. Offers customizable visualization options for the Value Area, POC, histogram, and labels. Uses lower timeframe data for increased accuracy and supports futures sessions. The number of rows used for the volume profile can be fixed or dynamically calculated based on the session's price range and the instrument's minimum tick increment, providing optimal resolution. calculateEffectiveRows(configuredRows, dayHigh, dayLow)   Determines the optimal number of rows for the volume profile, either using the configured value or calculating dynamically based on price range and tick size   Parameters:      configuredRows (int) : User-specified number of rows (0 means auto-calculate)      dayHigh (float) : Highest price of the session      dayLow (float) : Lowest price of the session   Returns: The number of rows to use for the volume profile debug(vp, position)   Helper function to write some information about the supplied SVP object to the screen in a table.   Parameters:      vp (Object) : The SVP object to debug      position (string) : The position.* to place the table. Defaults to position.bottom_center getLowerTimeframe()   Depending on the timeframe of the chart, determines a lower timeframe to grab volume data from for the analysis   Returns: The timeframe string to fetch volume for get(volumeProfile, lowerTimeframeHigh, lowerTimeframeLow, lowerTimeframeVolume, lowerTimeframeTime, lowerTimeframeSessionIsMarket)   Populated the provided SessionVolumeProfile object with vp data on the session.   Parameters:      volumeProfile (Object) : The SessionVolumeProfile object to populate      lowerTimeframeHigh (array) : The lower timeframe high values      lowerTimeframeLow (array) : The lower timeframe low values      lowerTimeframeVolume (array) : The lower timeframe volume values      lowerTimeframeTime (array) : The lower timeframe time values      lowerTimeframeSessionIsMarket (array) : The lower timeframe session.ismarket values (that are futures-friendly) drawPriorValueAreas(todaySessionVolumeProfile, extendYesterdayOverToday, showLabels, labelSize, pocColor, pocStyle, pocWidth, vahlColor, vahlStyle, vahlWidth, vaColor)   Given a SessionVolumeProfile Object, will render the historical value areas for that object.   Parameters:      todaySessionVolumeProfile (Object) : The SessionVolumeProfile Object to draw      extendYesterdayOverToday (bool) : Defaults to true      showLabels (bool) : Defaults to true      labelSize (string) : Defaults to size.small      pocColor (color) : Defaults to #e500a4      pocStyle (string) : Defaults to line.style_solid      pocWidth (int) : Defaults to 1      vahlColor (color) : The color of the value area high/low lines. Defaults to #1592e6      vahlStyle (string) : The style of the value area high/low lines. Defaults to line.style_solid      vahlWidth (int) : The width of the value area high/low lines. Defaults to 1      vaColor (color) : The color of the value area background. Defaults to #00bbf911) drawHistogram(volumeProfile, bgColor, showVolumeOnHistogram)   Given a SessionVolumeProfile object, will render the histogram for that object.   Parameters:      volumeProfile (Object) : The SessionVolumeProfile object to draw      bgColor (color) : The baseline color to use for the histogram. Defaults to #00bbf9      showVolumeOnHistogram (bool) : Show the volume amount on the histogram bars. Defaults to false. Object   Object Contains all settings and calculated values for a Volume Profile Session analysis   Fields:      numberOfRows (series int) : Number of price levels to divide the range into. If set to 0, auto-calculates based on price range and tick size      valueAreaCoverage (series int) : Percentage of total volume to include in the Value Area (default 70%)      trackDevelopingVa (series bool) : Whether to calculate and display the Value Area as it develops during the session      valueAreaHigh (series float) : Upper boundary of the Value Area - price level containing specified % of volume      pointOfControl (series float) : Price level with the highest volume concentration      valueAreaLow (series float) : Lower boundary of the Value Area      startTime (series int) : Session start time in Unix timestamp format      endTime (series int) : Session end time in Unix timestamp format      dayHigh (series float) : Highest price of the session      dayLow (series float) : Lowest price of the session      step (series float) : Size of each price row (calculated as price range divided by number of rows)      pointOfControlLevel (series int) : Index of the row containing the Point of Control      valueAreaHighLevel (series int) : Index of the row containing the Value Area High      valueAreaLowLevel (series int) : Index of the row containing the Value Area Low      lastTime (series int) : Tracks the most recent timestamp processed      volumeRows (map) : Stores volume data for each price level row (key=row number, value=volume)      ltfSessionHighs (array) : Stores high prices from lower timeframe data      ltfSessionLows (array) : Stores low prices from lower timeframe data      ltfSessionVols (array) : Stores volume data from lower timeframe data
Biblioteca Pine Script®
por Mupsje
5
Scalp Precision Matrix [BullByte]SCALP PRECISION MATRIX (SPM) OVERVIEW Scalp Precision Matrix (SPM) is a comprehensive decision-support framework designed specifically for scalpers and short-term traders. This indicator synthesizes five distinct analytical layers into a unified system that helps identify high-quality setups while avoiding common pitfalls that trap traders. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ THE CORE PROBLEM THIS INDICATOR ADDRESSES Scalping demands rapid decision-making while simultaneously processing multiple data points. Traders constantly ask themselves: Is momentum still alive? Am I entering near a potential reversal zone? Is this the right session to trade? What is my actual risk-to-reward? Most traders either overwhelm themselves with too many separate indicators (creating analysis paralysis) or use too few (missing crucial context). SPM was developed to consolidate these essential checks into one cohesive framework. Rather than overlaying disconnected indicators, each component in SPM directly informs and adjusts the others, creating an integrated analytical system. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ WHY THESE SPECIFIC COMPONENTS AND HOW THEY WORK TOGETHER The five analytical layers in SPM are not arbitrarily combined. Each addresses a specific question in the scalping decision process, and together they form a logical workflow: LAYER 1: MOMENTUM FUEL GAUGE This answers the question: "Does the current move still have energy?" After any impulse move (a significant directional price movement), momentum naturally decays over time. The Fuel Gauge estimates remaining momentum by analyzing four factors: Body Strength (30% weight): Compares recent candle body sizes against the historical average. Strong momentum produces candles with large bodies relative to their wicks. The calculation takes the 3-bar average body size divided by the 20-bar average body size, then scales it to a 0-100 range. Wick Rejection (25% weight): Measures the wick-to-body ratio. When wicks are large relative to bodies, it suggests rejection and weakening momentum. A ratio of 2.0 or higher (wicks twice the body size) scores low; smaller ratios score higher. Volume Consistency (20% weight): Compares recent 3-bar average volume against the lookback period average. Sustained moves require consistent volume support. Volume dropping off suggests the move may be losing participation. Time Decay (25% weight): Tracks how many bars have passed since the last detected impulse. Momentum naturally fades over time. The typical impulse duration is adjusted based on the current volatility regime. These components are weighted and combined, then smoothed with a 3-period EMA to reduce noise. The result is a 0-100% gauge where: - Above 70% = Strong momentum (green) - 40-70% = Moderate momentum (amber) - Below 40% = Weak momentum (red) - Below 20% = Exhausted (triggers EXIT warning) The Fuel Gauge also estimates how many bars of momentum remain based on the current burn rate. IMPORTANT DISCLAIMER : The Fuel Gauge is NOT order flow, volume profile, or depth of market data. It is a technical proxy calculated entirely from standard OHLCV (Open, High, Low, Close, Volume) data. The term "Fuel" is used metaphorically to represent estimated remaining momentum energy. LAYER 2: TRAP ZONE DETECTION This answers the question: "Am I walking into a potential reversal area?" Price tends to reverse at levels where it has reversed before. SPM identifies these zones by detecting clusters of historical swing points: How it works: 1. The indicator detects swing highs and swing lows using the Swing Detection Length setting (default 5 bars on each side required to confirm a pivot). 2. Recent swing points are stored (up to 10 of each type). 3. For each potential zone, the algorithm counts how many swing points cluster within a tolerance of 0.5 ATR. 4. Zones with 2 or more clustered swing points, positioned between 0.3 and 4.0 ATR from current price, are marked as Trap Zones. 5. A Confluence Score is calculated based on cluster density and proximity to current price. The percentage displayed (e.g., "TRAP 85%") is a CONFLUENCE SCORE, not a probability. Higher percentages mean more swing points cluster at that level and price is closer to it. This indicates stronger historical significance, not a prediction of future reversal. CRITICAL DISCLAIMER : Trap Zones are NOT institutional order flow, liquidity pools, smart money footprints, or any proprietary data feed. They are calculated purely from historical swing point clustering using standard technical analysis. The term "trap" describes how price action has historically reversed at these levels, potentially trapping traders who enter prematurely. This is pattern recognition, not market structure data. LAYER 3: VELOCITY ANALYSIS This answers the question: "Is price moving favorably right now?" Velocity measures how fast price is currently moving compared to its recent average: Calculation: - Current velocity = Absolute price change from previous bar divided by ATR - Average velocity = Simple moving average of velocity over the lookback period - Velocity ratio = Current velocity divided by average velocity Classification: - FAST (ratio above 1.5 ): Price is moving significantly faster than normal. Good for momentum continuation plays. - NORMAL (ratio 0.5 to 1.5) : Typical price movement speed. - SLOW (ratio below 0.5 ): Price is moving sluggishly. Often indicates ranging or choppy conditions where scalping becomes difficult. The velocity score contributes 18% to the overall quality score calculation. LAYER 4: SESSION AWARENESS This answers the question: "Is this a good time to trade?" Different trading sessions have different characteristics. SPM automatically detects which major session is active and adjusts its quality assessment: Session Times (all in UTC): - A sia Session : 00:00 - 08:00 UTC - London Session : 08:00 - 16:00 UTC - New York Session : 13:00 - 21:00 UTC - London/NY Overlap : 13:00 - 16:00 UTC - Off-Peak : Outside major sessions Session Quality Weighting: - Overlap : 100 points (highest liquidity, best movement) - London : 85 points - New York : 80 points - Asia : 50 points (tends to range more) - Off-Peak : 30 points (lower liquidity, more false signals) The session score contributes 17% to the overall quality calculation. Signals are also filtered to prevent firing during off-peak hours. Note : These are fixed UTC times and may not perfectly match your broker's session boundaries. Use them as general guidance rather than precise timing. LAYER 5: VOLATILITY REGIME ADAPTATION This answers the question: "How should I adjust for current market conditions?" SPM compares current volatility (14-period ATR) against historical volatility (50-period ATR) to categorize the market: HIGH Volatility (ratio above 1.3): Current ATR is 30%+ above normal. SPM widens thresholds to filter noise and extends target projections. NORMAL Volatility (ratio 0.7 to 1.3): Typical conditions. Standard parameters apply. LOW Volatility (ratio below 0.7): Current ATR is 30%+ below normal. SPM tightens thresholds for sensitivity and reduces target expectations. The market state may show AVOID during prolonged low volatility. This adaptation prevents false signals during erratic markets and missed signals during quiet markets. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ THE SYNERGY: WHY THIS COMBINATION MATTERS These five layers are not independent indicators placed on one chart. They form an interconnected system: - A signal only fires when momentum exists (Fuel above 40%), price is away from danger zones (Trap Zones factored into quality score), movement is favorable (Velocity contributes to score), timing is appropriate (Session is not off-peak), and volatility is accounted for (thresholds adapt to regime). - The Trap Zones directly influence Entry Zone placement. Entry zones are positioned beyond trap zones to avoid getting caught in reversals. - Target projections automatically adjust to avoid placing take-profit levels inside detected trap zones. - The Fuel Gauge affects which signal tier fires. Insufficient fuel prevents all signals. - Session quality is weighted into the overall score, reducing signal quality during less favorable trading hours. This integration is the core originality of SPM. Each component makes the others more useful than they would be in isolation. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ HOW THE QUALITY SCORE IS CALCULATED The Quality Score (0-100) synthesizes all layers into a single number for each direction (long and short): For Long Quality Score: - Fuel Component (28% weight) : Full fuel value if impulse direction is bullish; 60% of fuel value otherwise - Trap Avoidance (22% weight) : 75 points if no trap zone below; otherwise 100 minus the trap confluence score (minimum 20) - Velocity Component (18% weight) : Direct velocity score - Session Component (17% weight) : Current session quality score - Trend Alignment (15% bonus) : Adds 12 points if price is above the 20-period SMA For Short Quality Score: - Same structure but reversed (bearish impulse direction, trap zone above, price below SMA) The direction with the higher score becomes the current Bias. A 12-point difference is required to switch bias, preventing flip-flopping in neutral conditions. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SIGNAL TYPES AND WHAT THEY MEAN SPM generates four types of signals, each with specific visual representation: PRIME SIGNALS (Cyan Diamond) These represent the highest quality confluence. Requirements: - Quality score crosses above the Prime threshold (default 80) - Bias aligns with signal direction - Fuel is sufficient (above 40%) - Session is active (not off-peak) - Cooldown period has passed Prime signals appear as cyan-colored diamond shapes. Long signals appear below the bar; short signals appear above. STANDARD SIGNALS (Green Triangle Up / Red Triangle Down) These represent good quality setups. Requirements: - Quality score crosses above the Standard threshold (default 75) but below Prime - Same bias, fuel, and cooldown requirements as Prime Standard signals appear as small triangles in green (long) or red (short). CAUTION SIGNALS (Small Faded Circle) These represent minimum threshold setups. Requirements: - Quality score crosses above the Caution threshold (default 65) but below Standard - Same additional requirements Caution signals appear as small, faded circles. These suggest the setup exists but with weaker confluence. Consider these only when broader market context supports them, or skip them entirely during uncertain conditions. EXHAUSTION SIGNAL (Purple X with "EXIT" text) This warning appears when the Fuel Gauge drops below 20% from above, indicating momentum has depleted. This is not a trade signal but a warning to: - Consider exiting existing positions - Avoid entering new trades in the current direction - Wait for new momentum to develop All signals use CONFIRMED bar data only (referencing the previous closed bar) to prevent repainting. Once a signal appears, it will never disappear or change position on historical bars. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ READING THE CHART ELEMENTS TRAP ZONES (Red Dashed Box with "TRAP XX%" Label) These mark price levels where multiple historical swing points cluster. The red dashed box shows the zone boundaries. The percentage is the confluence score indicating cluster strength and proximity. How to use: When price approaches a trap zone, be cautious about entering in that direction. If your bias is LONG and there's a strong trap zone above, consider taking partial profits before price reaches it or adjusting your target below it. ENTRY ZONES (Green Solid Box with "ENTRY" Label) These show suggested entry areas based on the current bias direction. For LONG bias, the entry zone appears below the trap zone (buying the dip beyond support). For SHORT bias, it appears above the trap zone (selling the rally beyond resistance). How to use: Rather than entering at current price, consider placing limit orders within the entry zone. This positions you beyond where typical trap reversals occur. TARGET ZONES (Blue Dotted Box with "TARGET" Label) These project potential take-profit areas based on ATR multiples, adjusted for: - Current volatility regime (wider in high volatility, tighter in low) - Impulse direction (larger targets when aligned with impulse) - Nearby trap zones (targets adjust to avoid placing TP inside trap zones) How to use: These are suggestions, not guarantees. Consider taking partial profits before the target or using trailing stops once price moves favorably. STOP LEVEL (Orange Dashed Line with "STOP" Label) This shows suggested stop-loss placement, calculated as 0.8 ATR beyond the trap zone (or 2.0 ATR from current price if no trap zone exists). How to use: This provides a reference for risk calculation. The dashboard R:R ratio is calculated using this stop level. Chart Example: Scalp Precision Matrix displays real-time market analysis through dynamic zones and quality scores. ENTRY/TARGET/STOP zones show potential price levels based on current market structure - they appear continuously as reference points, NOT as trade instructions. Actual trade signals (diamonds, triangles, circles) fire only when multiple conditions align: quality score thresholds are crossed, fuel gauge is sufficient, session is active, and cooldown period has passed. The zones help you understand market context; the signals tell you when to act. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ UNDERSTANDING THE DASHBOARD (Top Right Panel) The main dashboard provides comprehensive market context: Row 1 - Header: - "SPM " : Indicator name - Market State : Current overall condition Market States Explained: - PRIME : Excellent conditions. Quality score meets prime threshold, session is active. Best opportunities. - READY : Good conditions. Quality score meets standard threshold. Solid setups available. - WAIT : Mixed conditions. Some factors favorable, others not. Patience recommended. - AVOID : Poor conditions. Off-peak session or very low volatility. High risk of false signals. - EXIT : Fuel exhausted. Momentum depleted. Consider closing positions or waiting. Row 2-3 - Quality Bars: - " UP ########## " : Visual meter for long quality (each # = 10 points, . = empty) - " DN ########## " : Visual meter for short quality - The number on the right shows the exact quality score Row 4 - Bias: - Shows current directional lean: LONG, SHORT, or NEUTRAL - Color-coded: Green for long, red for short, gray for neutral Rows 5-7 (Full Mode Only) - Trade Levels: - Entry : Suggested entry price for current bias direction - Stop : Suggested stop-loss price - Target : Projected take-profit price Row 8 - Risk:Reward Ratio: - Format : "1:X.X" where X.X is the reward multiple - Color-coded : Green if 2:1 or better, amber if 1.5:1 to 2:1, red if below 1.5:1 Row 9 - Fuel: - Shows percentage and estimated bars remaining in parentheses - Example : "72% (8)" means 72% fuel with approximately 8 bars remaining - Color-coded : Green above 70%, amber 40-70%, red below 40% Row 10-11 (Full Mode Only) - Market Conditions: - Vol : Current volatility regime (HIGH/NORMAL/LOW) - Speed : Current velocity zone (FAST/NORMAL/SLOW) Row 12 - Session: - Shows active trading session - Color-coded by session type Row 13 (Full Mode Only) - Remaining: - Time remaining in current session (hours and minutes) Row 14 (Conditional) - Trap Warning: - Appears when a significant trap zone exists in your bias direction - Shows direction (ABOVE/BELOW) and confluence percentage ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ UNDERSTANDING THE QUICK PANEL (Bottom Left) The Quick Panel provides essential information at a glance without looking away from price action: Row 1: Current Bias and Quality Score (large text for quick reading) Row 2: Market State Row 3: Fuel Percentage Row 4: Estimated Bars Remaining Row 5: Risk:Reward Ratio Row 6: Current Session Both panels can be repositioned using the settings, and each can be toggled on/off independently. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SETTINGS EXPLAINED CORE SETTINGS: Analysis Lookback (Default: 20) Number of bars used for statistical calculations including average volume and average body size. Higher values create smoother but slower-reacting analysis. Lower values are more responsive but may include more noise. Swing Detection Length (Default: 5) Bars required on each side to confirm a swing high or low. A setting of 5 means a swing high must have 5 lower highs on each side. Lower values detect more swings (more trap zones, more sensitivity). Higher values find only major pivots (fewer but more significant zones). Impulse Sensitivity (Default: 1.5) Multiplier for ATR when detecting impulse moves. Lower values (like 1.0) detect smaller price movements as impulses, refreshing the fuel gauge more frequently. Higher values (like 2.5) require larger moves, making impulse detection less frequent but more significant. SIGNAL SETTINGS: Prime/Standard/Caution Thresholds (Defaults: 80/75/65) These control the quality score required for each signal tier. You can adjust these based on your preference: - More conservative : Raise thresholds (e.g., 85/80/70) for fewer but higher-quality signals - More aggressive : Lower thresholds (e.g., 75/70/60) for more signals with slightly lower quality Signal Cooldown (Default: 8 bars) Minimum bars between signals to prevent signal spam. After any signal fires, no new signals can appear until this many bars pass. Increase for fewer signals in choppy markets; decrease if you want faster signal refresh. Show Prime/Standard/Caution/Exhaustion Signals Toggle each signal type on or off based on your preference. ZONE DISPLAY: Show Trap Zones / Entry Zones / Target Zones / Stop Levels Toggle each zone type on or off. Turning off zones you don't use reduces chart clutter. Zone Transparency (Default: 88) Controls how transparent zone boxes appear. Higher values (closer to 95) make zones barely visible; lower values (closer to 75) make them more prominent. Zone History (Default: 25 bars) How far back zone boxes extend on the chart. Purely visual preference. BACKGROUND: Background Mode (Options: Off, Subtle, Normal) Controls whether and how intensely the chart background is colored. Subtle is barely noticeable; Normal is more visible; Off disables background coloring entirely. Background Type (Options: Bias, Fuel) - Bias : Colors background based on current directional lean (green for long, red for short) - Fuel : Colors background based on momentum level (green for high fuel, amber for moderate, red for low) DASHBOARD / QUICK PANEL: Show Dashboard / Show Quick Panel Toggle each panel on or off. Compact Mode When enabled, the main dashboard shows only essential rows (quality bars, bias, R:R, fuel, session) without entry/stop/target levels, volatility, velocity, or time remaining. Position Settings Choose where each panel appears on your chart from six options: Top Right, Top Left, Bottom Right, Bottom Left, Middle Right, Middle Left. ALERTS: Alert Prime Signals / Standard Signals / Fuel Exhaustion Enable or disable TradingView alerts for each condition. When enabled, you can set up alerts in TradingView that will notify you when these conditions occur. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ RECOMMENDED TIMEFRAMES AND USAGE OPTIMAL TIMEFRAMES: - 1-minute to 5-minute : Best for active scalping with quick entries and exits - 5-minute to 15-minute : Balanced scalping with slightly more confirmation - 15-minute to 1-hour : Short-term swing entries, fewer but more significant signals Zone visualizations only appear on intraday timeframes to prevent chart clutter on higher timeframes. BEST PRACTICES: 1. Trade primarily during LONDON, NEW YORK, or OVERLAP sessions. The indicator weights these sessions higher for good reason - liquidity and movement are typically better. 2. Prioritize PRIME signals. These represent the highest confluence and have proven most reliable. Use STANDARD signals as secondary opportunities. Treat CAUTION signals with extra scrutiny. 3. Respect the Fuel Gauge. Avoid entering new positions when fuel is below 40%. When the EXIT signal appears, seriously consider closing or reducing positions. 4. Pay attention to TRAP warnings. When the dashboard shows a trap zone in your bias direction, be cautious about holding through that level. 5. Verify R:R before entry. The dashboard shows the risk-to-reward ratio. Ensure it meets your minimum requirements (many traders require at least 1.5:1 or 2:1). 6. When state shows AVOID or EXIT, step back. These conditions typically produce poor results. 7. Combine with your own analysis. SPM is a decision-support tool, not a standalone system. Use it alongside your understanding of market structure, news events, and overall context. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ PRACTICAL EXAMPLE Scenario : You're watching a 5-minute chart during London session. A cyan diamond (Prime Long signal) appears below the bar. Before entering, you check the dashboard: - State shows "PRIME" - conditions are favorable - Fuel shows "72% (8)" - plenty of momentum remaining (approximately 8 bars) - R:R shows "1:2.3" - acceptable risk-to-reward ratio - Session shows "LONDON" - active session with good liquidity - No TRAP warning in dashboard - no immediate resistance cluster in your way - Entry zone visible on chart at a lower price level - Stop and Target zones clearly marked With this confluence of factors, you have context for a more informed decision. The signal indicates quality, the fuel suggests momentum remains, the R:R is favorable, and no immediate trap threatens your trade. However, you also notice the target zone sits just below where a trap zone would be if there were one. This is by design - SPM adjusts targets to avoid placing them inside reversal zones. This multi-factor confirmation delivered in a single glance is what SPM provides. Chart Example :This chart demonstrates how the Scalp Precision Matrix identifies key market transitions. After a strong bullish impulse (cyan PRIME signal at ~08:30), price reached a historical reversal cluster (TRAP ZONE at 92,300). The indicator detected momentum exhaustion (purple EXIT signal) as fuel dropped below 20%, warning traders to exit longs. Now showing a SHORT bias with entry/stop/target zones clearly marked. The 92% trap zone confluence indicates a strong cluster of previous swing highs where price historically reversed. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ DATA WINDOW VALUES For detailed analysis and strategy development, SPM exports the following values to TradingView's Data Window (visible when you hover over the chart with the indicator selected): - Long Quality Score (0-100) - Short Quality Score (0-100) - Fuel Gauge (0-100%) - Risk:Reward Ratio These values can be useful for understanding how the indicator behaves over time and for developing your own insights about when it works best for your trading style. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ NON-REPAINTING CONFIRMATION All signals in SPM are generated using CONFIRMED bar data only. The signal logic references the previous closed bar's values ( and in Pine Script terms). This means: - Signals appear at the OPEN of the new bar (after the previous bar closes) - Signals will NEVER disappear once they appear - Signals will NEVER change position on historical bars - What you see in backtesting is what you would have seen in real-time The dashboard and zones update in real-time to provide current market context, but the trading signals themselves are non-repainting. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ IMPORTANT DISCLAIMERS TERMINOLOGY CLARIFICATION: This indicator uses terms that might imply access to data it does not have. To be completely transparent: - "Trap Zones" are calculated from historical swing point clustering. They are NOT institutional liquidity pools, order blocks, smart money footprints, or any form of order flow data. The term "trap" is metaphorical, describing how price has historically reversed at these levels. - "Fuel Gauge" is a technical momentum proxy. It is NOT order flow, volume profile, depth of market, or bid/ask data. It estimates momentum remaining based entirely on standard OHLCV price and volume data. - "Quality Scores" are weighted combinations of the technical factors described above. A high score indicates multiple conditions align favorably according to the indicator's logic. It does NOT predict or guarantee trade success. - The percentages shown on trap zones are CONFLUENCE SCORES measuring cluster density and proximity. They are NOT probability predictions of reversal. TRADING RISK WARNING: Trading involves substantial risk of loss and is not suitable for all investors. This indicator is a technical analysis tool designed to assist with decision-making. It does not constitute financial advice, trading advice, or any other sort of advice. Past performance of any signal or pattern does not guarantee future results. Markets are inherently unpredictable. Always use proper risk management. Define your risk before entering any trade. Never risk more than you can afford to lose. Consider consulting with a licensed financial advisor before making trading decisions. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ORIGINALITY STATEMENT - NOT A MASHUP Scalp Precision Matrix is an original work that combines several analytical concepts into a purpose-built scalping framework. While individual components like ATR calculations, pivot detection, session timing, and trend alignment exist in various forms elsewhere, the specific implementation here represents original synthesis: - The Fuel Gauge decay model with its four-component weighted calculation - The Trap Zone cluster detection with confluence scoring - The multi-factor quality scoring system that integrates all layers - The trap-aware entry and target zone placement logic - The volatility regime adaptation across all components - The session weighting is integrated into the quality assessment The indicator does not simply overlay separate indicators on one chart. It creates interconnected layers where each component informs and adjusts the others. This integration is the core originality of SPM. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ For best results, combine SPM with your own market understanding and always practice proper risk management. -BullByte
Indicador Pine Script®
por BullByte
20
Volume Profile (Simple)Simple Volume Profile (Simple) Master the Market's Structure with a Clear View of Volume by mercaderoaurum The Simple Volume Profile (Simple) indicator removes the guesswork by showing you exactly where the most significant trading activity has occurred. By visualizing the Point of Control (POC) and Value Area (VA) for today and yesterday, you can instantly identify the price levels that matter most, giving you a critical edge in your intraday trading. This tool is specifically optimized for day trading SPY on a 1-minute chart, but it's fully customizable for any symbol or timeframe. Key Features Multi-Day Analysis: Automatically plots the volume profiles for the current and previous trading sessions, allowing you to see how today's market is reacting to yesterday's key levels. Automatic Key Level Plotting: Instantly see the most important levels from each session: Point of Control (POC): The single price level with the highest traded volume, acting as a powerful magnet for price. Value Area High (VAH): The upper boundary of the area where 50% of the volume was traded. It often acts as resistance. Value Area Low (VAL): The lower boundary of the 50% value area, often acting as support. Extended Levels: The POC, VAH, and VAL from previous sessions are automatically extended into the current day, providing a clear map of potential support and resistance zones. Customizable Sessions: While optimized for the US stock market, you can define any session time and time zone, making it a versatile tool for forex, crypto, and futures traders. Core Trading Strategies The Simple Volume Profile helps you understand market context. Instead of trading blind, you can now make decisions based on where the market has shown the most interest. 1. Identifying Support and Resistance This is the most direct way to use the indicator. The extended lines from the previous day are your roadmap for the current session. Previous Day's POC (pPOC): This is the most significant level. Watch for price to react strongly here. It can act as powerful support if approached from above or strong resistance if approached from below. Previous Day's VAH (pVAH): Expect this level to act as initial resistance. A clean break above pVAH can signal a strong bullish trend. Previous Day's VAL (pVAL): Expect this level to act as initial support. A firm break below pVAL can indicate a strong bearish trend. Example Strategy: If SPY opens and rallies up to the previous day's VAH and stalls, this is a high-probability area to look for a short entry, with a stop loss just above the level. 2. The "Open-Drive" Rejection How the market opens in relation to the previous day's value area is a powerful tell. Open Above Yesterday's Value Area: If the market opens above the pVAH, it signals strength. The first pullback to test the pVAH is often a key long entry point. The level is expected to flip from resistance to support. Open Below Yesterday's Value Area: If the market opens below the pVAL, it signals weakness. The first rally to test the pVAL is a potential short entry, as the level is likely to act as new resistance. 3. Fading the Extremes When price pushes far outside the previous day's value area, it can become overextended. Reversal at Highs: If price rallies significantly above the pVAH and then starts to lose momentum (e.g., forming bearish divergence on RSI or a topping pattern), it could be an opportunity to short the market, targeting a move back toward the pVAH or pPOC. Reversal at Lows: Conversely, if price drops far below the pVAL and shows signs of bottoming, it can be a good opportunity to look for a long entry, targeting a reversion back to the value area. Recommended Settings (SPY Intraday) These settings are the default and are optimized for scalping or day trading SPY on a 1-minute chart. Value Area (%): 50%. This creates a tighter, more sensitive value area, perfect for identifying the most critical intraday zones. Number of Rows: 1000. This high resolution is essential for a low-volatility instrument like SPY, ensuring that the profile is detailed and the levels are precise. Session Time: 0400-1800 in America/New_York. This captures the full pre-market and core session, which is crucial for understanding the day's complete volume story. Ready to trade with an edge? Add the Simple Volume Profile (Multi-Day) to your chart now and see the market in a new light!
Indicador Pine Script®
por MercaderoAurum
Time-Based VWAP (TVWAP)(TVWAP) Indicator The Time-Based Volume Weighted Average Price (TVWAP) indicator is a customized version of VWAP designed for intraday trading sessions with defined start and end times. Unlike the traditional VWAP, which calculates the volume-weighted average price over an entire trading day, this indicator allows you to focus on specific time periods, such as ICT kill zones (e.g., London Open, New York Open, Power Hour). It helps crypto scalpers and advanced traders identify price deviations relative to volume during key trading windows. Key Features: Custom Time Interval: You can set the exact start and end times for the VWAP calculation using input settings for hours and minutes (24-hour format). Ideal for analyzing short, high-liquidity periods. Dynamic Accumulation of Price and Volume: The indicator resets at the beginning of the specified session and accumulates price-volume data until the end of the session. Ensures that the TVWAP reflects the weighted average price specific to the chosen session. Visual Representation: The indicator plots the TVWAP line only during the specified time window, providing a clear visual reference for price action during that period. Outside the session, the TVWAP line is hidden (na). Use Cases: ICT Scalp Trading: Monitor price rebalances or potential liquidity sweeps near TVWAP during important trading sessions. Mean Reversion Strategies: Detect pullbacks toward the session’s average price for potential entry points. Breakout Confirmation: Confirm price direction relative to TVWAP during kill zones or high-volume times to determine if a breakout is supported by volume. Inputs: Start Hour/Minute: The time when the TVWAP calculation starts. End Hour/Minute: The time when the TVWAP calculation ends. Technical Explanation: The indicator uses the timestamp function to create time markers for the session start and end. During the session, the price-volume (close * volume) is accumulated along with the total volume. TVWAP is calculated as: TVWAP = (Sum of (Price × Volume)) ÷ (Sum of Volume) ​ Once the session ends, the TVWAP resets for the next trading period. Customization Ideas: Alerts: Add notifications when the price touches or deviates significantly from TVWAP. Different Colors: Use different line colors based on upward or downward trends. Multiple Sessions: Add support for multiple TVWAP lines for different time periods (e.g., London + New York).
Indicador Pine Script®
por JaydenUnplugged
1
Initial Balance Breakout Signals [LuxAlgo]The Initial Balance Breakout Signals help traders identify breakouts of the Initial Balance (IB) range. The indicator includes automatic detection of IB or can use custom sessions, highlights top and bottom IB extensions, custom Fibonacci levels, and goes further with an IB forecast with two different modes. 🔶 USAGE The initial balance is the price range made within the first hour of the trading session. It is an intraday concept based on the idea that high volume and volatility enter the market through institutional trading at the start of the session, setting the tone for the rest of the day. The initial balance is useful for gauging market sentiment, or, in other words, the relationship between buyers and sellers. Bullish sentiment: Price trades above the IB range. Mixed sentiment: Price trades within the IB range. Bearish sentiment: Price trades below the IB range. The initial balance high and low are important levels that many traders use to gauge sentiment. There are two main ideas behind trading around the IB range. IB Extreme Breakout: When the price breaks and holds the IB high or low, there is a high probability that the price will continue in that direction. IB Extreme Rejection: When the price tries to break those levels but fails, there is a high probability that it will reach the opposite IB extreme. This indicator is a complete Initial Balance toolset with custom sessions, breakout signals, IB extensions, Fibonacci retracements, and an IB forecast. All of these features will be explained in the following sections. 🔹 Custom Sessions and Signals By default, sessions for Initial Balance and breakout signals are in Auto mode. This means that Initial Balance takes the first hour of the trading session and shows breakout signals for the rest of the session. With this option, traders can use the tool for open range trading, making it highly versatile. The concept behind open range (OR) is the same as that of initial balance (IB), but in OR, the range is determined by the first minute, three or five minutes, or up to the first 30 minutes of the trading session. As shown in the image above, the top chart uses the Auto feature for the IB and Breakouts sessions. The bottom chart has the Auto feature disabled to use custom sessions for both parameters. In this case, the first three minutes of the trading session are used, turning the tool into an Open Range trading indicator. This chart shows another example of using custom sessions to display overnight NASDAQ futures sessions. The left chart shows a custom session from the Tokyo open to the London open, and the right chart shows a custom session from the London open to the New York open. The chart shows both the Asian and European sessions, their top and bottom extremes, and the breakout signals from those extremes. 🔹 Initial Balance Extensions Traders can easily extend both extremes of the Initial Balance to display their preferred targets for breakouts. Enable or disable any of them and set the IB percentage to use for the extension. As the chart shows, the percentage selected on the settings panel directly affects the displayed levels. Setting 25 means the tool will use a quarter of the detected initial balance range for extensions beyond the IB extremes. Setting 100 means the full IB range will be used. Traders can use these extensions as targets for breakout signals. 🔹 Fibonacci Levels Traders can display default or custom Fibonacci levels on the IB range to trade retracements and assess the strength of market movements. Each level can be enabled or disabled and customized by level, color, and line style. As we can see on the chart, after the IB was completed, prices were unable to fall below the 0.236 Fibonacci level. This indicates significant bullish pressure, so it is expected that prices will rise. Traders can use these levels as guidelines to assess the strength of the side trying to penetrate the IB. In this case, the sellers were unable to move the market beyond the first level. 🔹 Initial Balance Forecast The tool features two different forecasting methods for the current IB. By default, it takes the average of the last ten values and applies a multiplier of one. IB Against Previous Open: averages the difference between IB extremes and the open of the previous session. Filter by current day of the week: averages the difference between IB extremes and the open of the current session for the same day of the week. This feature allows traders to see the difference between the current IB and the average of the last IBs. It makes it very easy to interpret: if the current IB is higher than the average, buyers are in control; if it is lower than the average, sellers are in control. For example, on the left side of the chart, we can see that the last day was very bullish because the IB was completely above the forecasted value. This is the IB mean of the last ten trading days. On the right, we can see that on Monday, September 15, the IB traded slightly higher but within the forecasted value of the IB mean of the last ten Mondays. In this case, it is within expectations. 🔶 SETTINGS Display Last X IBs: Select how many IBs to display. Initial Balance: Choose a custom session or enable the Auto feature. Breakouts: Enable or disable breakouts. Choose custom session or enable the Auto feature. 🔹 Extensions Top Extension: Enable or disable the top extension and choose the percentage of IB to use. Bottom extension: Enable or disable the bottom extension and choose the percentage of IB to use. 🔹 Fibonacci Levels Display Fibonacci: Enable or disable Fibonacci levels. Reverse: Reverse Fibonacci levels. Levels, Colors & Style Display Labels: Enable or disable labels and choose text size. 🔹 Forecast Display Forecast: Select the forecast method. - IB Against Previous Open: Calculates the average difference between the IB high and low and the previous day's IB open price. - Filter by Current Day of Week: Calculates the average difference between the IB high and low and the IB open price for the same day of the week. Forecast Memory: The number of data points used to calculate the average. Forecast Multiplier: This multiplier will be applied to the average. Bigger numbers will result in wider predicted ranges. Forecast Colors: Choose from a variety of colors. Forecast Style: Choose a line style. 🔹 Style Initial Balance Colors Extension Transparency: Choose the extension's transparency. 0 is solid, and 100 is fully transparent.
Indicador Pine Script®
por LuxAlgo
17
Global Market Clock Pro🌍✨ Global Market Clock Pro is a market session visualizer that combines utility and fun on your charts! 📊⏰ This indicator includes three analog clocks representing the Tokyo, London, and New York sessions, added in an entertaining way to make analysis more enjoyable and dynamic. 😊 Each clock clearly shows the session start and end times through arcs and distinctive markers, making it easier to identify active market periods. 💡 Also, a statistics table is added offering detailed information for each session: 📊 Percentage Change : Displays the price variation between sessions. 💰 Price Range : Highlights volatility within each session. 📈 Session Volume : Evaluates market activity based on traded volume. 📊 Average Volatility : Helps measure price fluctuations over time. 📌 Mean (Average Close) : Calculated by dividing the sum of closing prices of each bar by the total number of bars recorded during the session. This value gives you a reference for average price behavior, helping you detect general trends and key support/resistance levels. 📉 📌 Max Range (Maximum Range) : Represents the largest difference recorded between the highest and lowest prices during the session. This indicator is crucial for identifying volatility peaks, as it shows how far the market moved during its most active moments. 🔥 ⚠️ VERY IMPORTANT : This tool works best only in timeframes under 4 hours ! ⏳ By integrating these data points directly into your chart, this indicator becomes a powerful tool to align your strategies with market activity in each session. Whether you're a day trader or a long-term investor, Global Market Clock Pro provides clear, data-driven insights to enhance decision-making. 💻📈 Español: 🌍✨ Global Market Clock Pro es un visualizador de sesiones de mercado que combina utilidad y diversión en tus gráficos. 📊⏰ Este indicador incluye tres relojes analógicos que representan las sesiones de Tokio, Londres y Nueva York, agregados de manera entretenida para hacer el análisis más ameno y dinámico. 😊 Cada reloj muestra con claridad los horarios de inicio y cierre de sesión mediante arcos y marcadores distintivos, facilitando la identificación de los periodos activos del mercado. 💡 Además, se añade una tabla de estadísticas que ofrece información detallada de cada sesión: 📊 Cambio porcentual : Muestra la variación de precio entre sesiones. 💰 Rango de precios : Destaca la volatilidad dentro de cada sesión. 📈 Volumen de sesión : Evalúa la actividad del mercado mediante el volumen negociado. 📊 Volatilidad promedio : Ayuda a medir las fluctuaciones del precio a lo largo del tiempo. 📌 Mean (Promedio de Cierre) : Se calcula dividiendo la suma de los precios de cierre de cada barra entre el número total de barras registradas durante la sesión. Este valor te brinda una referencia del comportamiento medio del precio, permitiéndote detectar tendencias generales y niveles clave de soporte o resistencia. 📉 📌 Max Range (Rango Máximo) : Representa la mayor diferencia registrada entre el precio más alto y el más bajo durante la sesión. Este indicador es fundamental para identificar los picos de volatilidad, ya que muestra hasta qué punto el mercado se movió en sus momentos de mayor actividad. 🔥 ⚠️ ¡MUY IMPORTANTE! : Esta herramienta funciona mejor solo en temporalidades menores a 4 horas . ⏳ Al integrar estos datos directamente en el gráfico, este indicador se convierte en una herramienta poderosa para sincronizar tus estrategias con la actividad del mercado en cada sesión. Ya seas un trader intradía o un inversor a largo plazo, Global Market Clock Pro proporciona claridad basada en datos para mejorar la toma de decisiones. 💻📈 🚀 ¡No dejes pasar la oportunidad de optimizar tu experiencia de trading con esta innovadora herramienta! ✨
Indicador Pine Script®
por PINE_LABS
Advanced Time Dividers & Killzones IndicatorOverview A comprehensive Pine Script v6 indicator that displays customizable time period dividers and trading session killzones on your chart. Perfect for intraday traders who need clear visual separation of time periods and want to identify key trading sessions. ✨ Features Time Period Dividers Weekly Lines: Vertical lines marking the start of each week Monthly Lines: Vertical lines marking the start of each month Quarterly Lines: Vertical lines marking the start of each quarter (Q1, Q2, Q3, Q4) Yearly Lines: Vertical lines marking the start of each year Trading Session Killzones London Session: 2:00-5:00 GMT (Blue shaded box) New York Session: 7:00-10:00 GMT (Green shaded box) London Close: 10:00-12:00 GMT (Orange shaded box) Asia Session: 20:00-00:00 GMT (Pink shaded box) 🎨 Customization Options Display Controls Toggle each time divider type individually Toggle each killzone individually Adjust historical and future display range Show/hide labels on dividers and killzones Style Customization Line Styles: Choose between Solid, Dashed, or Dotted lines Line Width: Adjustable from 1 to 5 pixels Colors: Fully customizable colors for each element with transparency control Label Size: Choose from Tiny, Small, Normal, or Large Period Settings Control how many bars to display in the past (0-5000) Control how many bars to display in the future (0-1000) 📋 Usage Instructions Add to Chart: Add the indicator to any chart Select Timeframe: Works best on intraday timeframes (1H, 15min, 5min) for killzones Customize: Open settings to enable/disable features and customize colors Trading: Use the dividers to identify time periods and killzones to spot high-liquidity sessions 💡 Trading Applications Time Dividers Weekly/Monthly Analysis: Identify major time period transitions Market Structure: Analyze how price behaves at period boundaries Event Correlation: Align with economic calendar events Killzones High Liquidity Periods: Trade during peak market activity ICT Strategy: Follows Inner Circle Trader killzone concepts Session-Based Trading: Focus on specific trading sessions Volatility Windows: Identify when major moves typically occur ⚙️ Technical Details Version: Pine Script v6 Type: Overlay indicator Max Lines: 500 (optimized performance) Max Boxes: 500 (for killzone visualization) Timezone: GMT/UTC for killzones Memory Efficient: Automatic cleanup of old objects 🎯 Best Practices Combine with Price Action: Use dividers to frame your analysis Focus on Killzones: Most significant price moves occur during these sessions Adjust Transparency: Find the right balance between visibility and chart clarity Use Labels Wisely: Toggle labels on/off based on your needs Timeframe Selection: Use lower timeframes (≤1H) to see killzones clearly 📝 Notes Killzone times are in GMT/UTC timezone Works on all instruments (Forex, Crypto, Stocks, Futures) Optimized for performance with automatic memory management Fully compatible with other indicators 🔄 Updates & Support This indicator is actively maintained. Feel free to suggest improvements or report issues in the comments.
Indicador Pine Script®
por Zemsty
JK_Traders_Reality_LibLibrary "JK_Traders_Reality_Lib" This library contains common elements used in Traders Reality scripts calcPvsra(pvsraVolume, pvsraHigh, pvsraLow, pvsraClose, pvsraOpen, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor, darkGreyCandleColor, lightGrayCandleColor)   calculate the pvsra candle color and return the color as well as an alert if a vector candle has apperared. Situation "Climax" Bars with volume >= 200% of the average volume of the 10 previous chart TFs, or bars where the product of candle spread x candle volume is >= the highest for the 10 previous chart time TFs. Default Colors: Bull bars are green and bear bars are red. Situation "Volume Rising Above Average" Bars with volume >= 150% of the average volume of the 10 previous chart TFs. Default Colors: Bull bars are blue and bear are violet.   Parameters:      pvsraVolume (float) : the instrument volume series (obtained from request.sequrity)      pvsraHigh (float) : the instrument high series (obtained from request.sequrity)      pvsraLow (float) : the instrument low series (obtained from request.sequrity)      pvsraClose (float) : the instrument close series (obtained from request.sequrity)      pvsraOpen (float) : the instrument open series (obtained from request.sequrity)      redVectorColor (simple color) : red vector candle color      greenVectorColor (simple color) : green vector candle color      violetVectorColor (simple color) : violet/pink vector candle color      blueVectorColor (simple color) : blue vector candle color      darkGreyCandleColor (simple color) : regular volume candle down candle color - not a vector      lightGrayCandleColor (simple color) : regular volume candle up candle color - not a vector @return adr(length, barsBack)   Parameters:      length (simple int) : how many elements of the series to calculate on      barsBack (simple int) : starting possition for the length calculation - current bar or some other value eg last bar @return adr the adr for the specified lenght adrHigh(adr, fromDo)   Calculate the ADR high given an ADR   Parameters:      adr (float) : the adr      fromDo (simple bool) : boolean flag, if false calculate traditional adr from high low of today, if true calcualte from exchange midnight @return adrHigh the position of the adr high in price adrLow(adr, fromDo)   Parameters:      adr (float) : the adr      fromDo (simple bool) : boolean flag, if false calculate traditional adr from high low of today, if true calcualte from exchange midnight @return adrLow the position of the adr low in price splitSessionString(sessXTime)   given a session in the format 0000-0100:23456 split out the hours and minutes   Parameters:      sessXTime (simple string) : the session time string usually in the format 0000-0100:23456 @return calcSessionStartEnd(sessXTime, gmt)   calculate the start and end timestamps of the session   Parameters:      sessXTime (simple string) : the session time string usually in the format 0000-0100:23456      gmt (simple string) : the gmt offset string usually in the format GMT+1 or GMT+2 etc @return drawOpenRange(sessXTime, sessXcol, showOrX, gmt)   draw open range for a session   Parameters:      sessXTime (simple string) : session string in the format 0000-0100:23456      sessXcol (simple color) : the color to be used for the opening range box shading      showOrX (simple bool) : boolean flag to toggle displaying the opening range      gmt (simple string) : the gmt offset string usually in the format GMT+1 or GMT+2 etc @return void drawSessionHiLo(sessXTime, showRectangleX, showLabelX, sessXcolLabel, sessXLabel, gmt, sessionLineStyle)   Parameters:      sessXTime (simple string) : session string in the format 0000-0100:23456      showRectangleX (simple bool)      showLabelX (simple bool)      sessXcolLabel (simple color) : the color to be used for the hi/low lines and label      sessXLabel (simple string) : the session label text      gmt (simple string) : the gmt offset string usually in the format GMT+1 or GMT+2 etc      sessionLineStyle (simple string) : the line stile for the session high low lines @return void calcDst()   calculate market session dst on/off flags @return indicating if DST is on or off for a particular region timestampPreviousDayOfWeek(previousDayOfWeek, hourOfDay, gmtOffset, oneWeekMillis)   Timestamp any of the 6 previous days in the week (such as last Wednesday at 21 hours GMT)   Parameters:      previousDayOfWeek (simple string) : Monday or Satruday      hourOfDay (simple int) : the hour of the day when psy calc is to start      gmtOffset (simple string) : the gmt offset string usually in the format GMT+1 or GMT+2 etc      oneWeekMillis (simple int) : the amount if time for a week in milliseconds @return the timestamp of the psy level calculation start time getdayOpen()   get the daily open - basically exchange midnight @return the daily open value which is float price newBar(res)   new_bar: check if we're on a new bar within the session in a given resolution   Parameters:      res (simple string) : the desired resolution @return true/false is a new bar for the session has started toPips(val)   to_pips Convert value to pips   Parameters:      val (float) : the value to convert to pips @return the value in pips rLabel(ry, rtext, rstyle, rcolor, valid, labelXOffset)   a function that draws a right aligned lable for a series during the current bar   Parameters:      ry (float) : series float the y coordinate of the lable      rtext (simple string) : the text of the label      rstyle (simple string) : the style for the lable      rcolor (simple color) : the color for the label      valid (simple bool) : a boolean flag that allows for turning on or off a lable      labelXOffset (int) : how much to offset the label from the current position rLabelOffset(ry, rtext, rstyle, rcolor, valid, labelOffset)   a function that draws a right aligned lable for a series during the current bar   Parameters:      ry (float) : series float the y coordinate of the lable      rtext (string) : the text of the label      rstyle (simple string) : the style for the lable      rcolor (simple color) : the color for the label      valid (simple bool) : a boolean flag that allows for turning on or off a lable      labelOffset (int) rLabelLastBar(ry, rtext, rstyle, rcolor, valid, labelXOffset)   a function that draws a right aligned lable for a series only on the last bar   Parameters:      ry (float) : series float the y coordinate of the lable      rtext (string) : the text of the label      rstyle (simple string) : the style for the lable      rcolor (simple color) : the color for the label      valid (simple bool) : a boolean flag that allows for turning on or off a lable      labelXOffset (int) : how much to offset the label from the current position drawLine(xSeries, res, tag, xColor, xStyle, xWidth, xExtend, isLabelValid, xLabelOffset, validTimeFrame)   a function that draws a line and a label for a series   Parameters:      xSeries (float) : series float the y coordinate of the line/label      res (simple string) : the desired resolution controlling when a new line will start      tag (simple string) : the text for the lable      xColor (simple color) : the color for the label      xStyle (simple string) : the style for the line      xWidth (simple int) : the width of the line      xExtend (simple string) : extend the line      isLabelValid (simple bool) : a boolean flag that allows for turning on or off a label      xLabelOffset (int)      validTimeFrame (simple bool) : a boolean flag that allows for turning on or off a line drawn drawLineDO(xSeries, res, tag, xColor, xStyle, xWidth, xExtend, isLabelValid, xLabelOffset, validTimeFrame)   a function that draws a line and a label for the daily open series   Parameters:      xSeries (float) : series float the y coordinate of the line/label      res (simple string) : the desired resolution controlling when a new line will start      tag (simple string) : the text for the lable      xColor (simple color) : the color for the label      xStyle (simple string) : the style for the line      xWidth (simple int) : the width of the line      xExtend (simple string) : extend the line      isLabelValid (simple bool) : a boolean flag that allows for turning on or off a label      xLabelOffset (int)      validTimeFrame (simple bool) : a boolean flag that allows for turning on or off a line drawn drawPivot(pivotLevel, res, tag, pivotColor, pivotLabelColor, pivotStyle, pivotWidth, pivotExtend, isLabelValid, validTimeFrame, levelStart, pivotLabelXOffset)   draw a pivot line - the line starts one day into the past   Parameters:      pivotLevel (float) : series of the pivot point      res (simple string) : the desired resolution      tag (simple string) : the text to appear      pivotColor (simple color) : the color of the line      pivotLabelColor (simple color) : the color of the label      pivotStyle (simple string) : the line style      pivotWidth (simple int) : the line width      pivotExtend (simple string) : extend the line      isLabelValid (simple bool) : boolean param allows to turn label on and off      validTimeFrame (simple bool) : only draw the line and label at a valid timeframe      levelStart (int) : basically when to start drawing the levels      pivotLabelXOffset (int) : how much to offset the label from its current postion @return the pivot line series getPvsraFlagByColor(pvsraColor, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor, lightGrayCandleColor)   convert the pvsra color to an internal code   Parameters:      pvsraColor (color) : the calculated pvsra color      redVectorColor (simple color) : the user defined red vector color      greenVectorColor (simple color) : the user defined green vector color      violetVectorColor (simple color) : the user defined violet vector color      blueVectorColor (simple color) : the user defined blue vector color      lightGrayCandleColor (simple color) : the user defined regular up candle color @return pvsra internal code updateZones(pvsra, direction, boxArr, maxlevels, pvsraHigh, pvsraLow, pvsraOpen, pvsraClose, transperancy, zoneupdatetype, zonecolor, zonetype, borderwidth, coloroverride, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor)   a function that draws the unrecovered vector candle zones   Parameters:      pvsra (int) : internal code      direction (simple int) : above or below the current pa      boxArr (array) : the array containing the boxes that need to be updated      maxlevels (simple int) : the maximum number of boxes to draw      pvsraHigh (float) : the pvsra high value series      pvsraLow (float) : the pvsra low value series      pvsraOpen (float) : the pvsra open value series      pvsraClose (float) : the pvsra close value series      transperancy (simple int) : the transparencfy of the vecor candle zones      zoneupdatetype (simple string) : the zone update type      zonecolor (simple color) : the zone color if overriden      zonetype (simple string) : the zone type      borderwidth (simple int) : the width of the border      coloroverride (simple bool) : if the color overriden      redVectorColor (simple color) : the user defined red vector color      greenVectorColor (simple color) : the user defined green vector color      violetVectorColor (simple color) : the user defined violet vector color      blueVectorColor (simple color) : the user defined blue vector color cleanarr(arr)   clean an array from na values   Parameters:      arr (array) : the array to clean @return if the array was cleaned calcPsyLevels(oneWeekMillis, showPsylevels, psyType, sydDST)   calculate the psy levels 4 hour res based on how mt4 does it mt4 code int Li_4 = iBarShift(NULL, PERIOD_H4, iTime(NULL, PERIOD_W1, Li_0)) - 2 - Offset; ObjectCreate("PsychHi", OBJ_TREND, 0, Time , iHigh(NULL, PERIOD_H4, iHighest(NULL, PERIOD_H4, MODE_HIGH, 2, Li_4)), iTime(NULL, PERIOD_W1, 0), iHigh(NULL, PERIOD_H4, iHighest(NULL, PERIOD_H4, MODE_HIGH, 2, Li_4))); so basically because the session is 8 hours and we are looking at a 4 hour resolution we only need to take the highest high an lowest low of 2 bars we use the gmt offset to adjust the 0000-0800 session to Sydney open which is at 2100 during dst and at 2200 otherwize. (dst - spring foward, fall back) keep in mind sydney is in the souther hemisphere so dst is oposite of when london and new york go into dst   Parameters:      oneWeekMillis (simple int) : a constant value      showPsylevels (simple bool) : should psy levels be calculated      psyType (simple string) : the type of Psylevels - crypto or forex      sydDST (bool) : is Sydney in DST @return adrHiLo(length, barsBack, fromDO)   Parameters:      length (simple int) : how many elements of the series to calculate on      barsBack (simple int) : starting possition for the length calculation - current bar or some other value eg last bar      fromDO (simple bool) : boolean flag, if false calculate traditional adr from high low of today, if true calcualte from exchange midnight @return adr, adrLow and adrHigh - the adr, the position of the adr High and adr Low with respect to price drawSessionHiloLite(sessXTime, showRectangleX, showLabelX, sessXcolLabel, sessXLabel, gmt, sessionLineStyle, sessXcol)   Parameters:      sessXTime (simple string) : session string in the format 0000-0100:23456      showRectangleX (simple bool)      showLabelX (simple bool)      sessXcolLabel (simple color) : the color to be used for the hi/low lines and label      sessXLabel (simple string) : the session label text      gmt (simple string) : the gmt offset string usually in the format GMT+1 or GMT+2 etc      sessionLineStyle (simple string) : the line stile for the session high low lines      sessXcol (simple color) : - the color for the box color that will color the session @return void msToHmsString(ms)   converts milliseconds into an hh:mm string. For example, 61000 ms to '0:01:01'   Parameters:      ms (int) : - the milliseconds to convert to hh:mm @return string - the converted hh:mm string countdownString(openToday, closeToday, showMarketsWeekends, oneDay)   that calculates how much time is left until the next session taking the session start and end times into account. Note this function does not work on intraday sessions.   Parameters:      openToday (int) : - timestamps of when the session opens in general - note its a series because the timestamp was created using the dst flag which is a series itself thus producing a timestamp series      closeToday (int) : - timestamp of when the session closes in general - note its a series because the timestamp was created using the dst flag which is a series itself thus producing a timestamp series @return a countdown of when next the session opens or 'Open' if the session is open now      showMarketsWeekends (simple bool)      oneDay (simple int) countdownStringSyd(sydOpenToday, sydCloseToday, showMarketsWeekends, oneDay)   that calculates how much time is left until the next session taking the session start and end times into account. special case of intraday sessions like sydney   Parameters:      sydOpenToday (int)      sydCloseToday (int)      showMarketsWeekends (simple bool)      oneDay (simple int)
Biblioteca Pine Script®
por Justas123
2
My auto dual avwap with Auto swing low/pivot low finderWelcome to My Auto Dual AVWAP with Auto Swing Low/Pivot Low Finder – an open-source TradingView indicator designed to enhance your technical analysis toolbox. This indicator is published under the Mozilla Public License 2.0 and is available for anyone to study, modify, and distribute. Key Features Auto Pivot/Swing Low Finder: In addition to VWAP lines, the indicator incorporates an automatic detection mechanism for swing lows/pivot lows. This feature assists in identifying potential support areas and price reversals, further enhancing your trading strategy. Dual VWAP Calculation with high/low range: The indicator calculates two separate volume-weighted average price (VWAP) lines based on different price inputs (low and high prices) and defined time sessions. This allows traders to gain a more nuanced view of market activity during specific trading periods. Customizable Time Sessions: You can specify distinct start and end times for each VWAP calculation session. This flexibility helps you align the indicator with your preferred trading hours or market sessions, making it adaptable to various time zones and trading styles. Easy to Customize: With clear code structure and detailed comments, the script is designed to be accessible even for traders who want to customize or extend its functionality. Whether you're a seasoned coder or just starting out, the code is written with transparency in mind. How It Works Session Initialization: The script sets up two distinct time sessions using user-defined start and end times. For each session, it detects the beginning of the trading period to reset cumulative values. Cumulative Calculations: During each session, the indicator accumulates the product of price and volume as well as the total volume. The VWAP is then computed as the ratio of these cumulative values. Dual Data Sources: Two separate data inputs (using low and high prices) are used to calculate two VWAP lines. This dual approach provides a broader perspective on market trends and can help in identifying dynamic support and resistance levels. Visualization: The calculated VWAP lines are plotted directly on your chart with distinct colors and thickness settings for easy visualization. This makes it simple to interpret the data at a glance. Why Use This Indicator? Whether you are a day trader, swing trader, or simply looking to refine your market analysis, My Auto Dual AVWAP with Auto Swing Low/Pivot Low Finder offers a robust set of features that can help you identify key price levels and improve your decision-making process. Its open-source nature invites collaboration and customization, ensuring that you can tailor it to fit your unique trading style. Feel free to explore, modify, and share this indicator. Happy trading!
Indicador Pine Script®
por doqkhanh
2
Overnight High/LowThe script identifies the Overnight High (the highest price) and Overnight Low (the lowest price) for a trading instrument during a specified overnight session. It then plots these levels on the chart for reference in subsequent trading sessions. Key Features: Time Settings: The script defines the start (startHour) and end (endHour + endMinute) times for the overnight session. The session spans across two calendar days, such as 5:00 PM (17:00) to 9:30 AM (09:30). Tracking High and Low: During the overnight session, the script dynamically tracks: Overnight High: The highest price reached during the session. Overnight Low: The lowest price reached during the session. Reset Mechanism: After the overnight session ends (at the specified end time), the script resets the overnightHigh and overnightLow variables, preparing for the next session. Visual Representation: The script uses horizontal dotted lines to plot: A green line for the Overnight High. A red line for the Overnight Low. These lines extend to the right of the chart, providing visual reference points for traders. How It Works: Session Detection: The script checks whether the current time falls within the overnight session: If the hour is greater than or equal to the start hour (e.g., 17:00). Or if the hour is less than or equal to the end hour (e.g., 09:30), considering the next day. The end minute (e.g., 30 minutes past the hour) is also considered for precision. High and Low Calculation: During the overnight session: If the overnightHigh is not yet defined, it initializes with the current candle's high. If already defined, it updates by comparing the current candle's high to the existing overnightHigh using the math.max function. Similarly, overnightLow is initialized or updated using the math.min function. Post-Session Reset: After the session ends, the script clears the overnightHigh and overnightLow variables by setting them to na (not available). Line Drawing: The script draws horizontal dotted lines for the Overnight High and Low during and after the session. The lines extend indefinitely to the right of the chart. Benefits: Visual Aid: Helps traders quickly identify overnight support and resistance levels, which are critical for intraday trading. Automation: Removes the need for manually plotting these levels each day. Customizable: Time settings can be adjusted to match different markets or trading strategies. This script is ideal for traders who use the overnight range as part of their analysis for breakouts, reversals, or trend continuation strategies.
Indicador Pine Script®
por Ramos_Sanchez
1
chrono_utilsLibrary "chrono_utils" Collection of objects and common functions that are related to datetime windows session days and time ranges. The main purpose of this library is to handle time-related functionality and make it easy to reason about a future bar checking if it will be part of a predefined session and/or inside a datetime window. All existing session functionality I found in the documentation e.g. "not na(time(timeframe, session, timezone))" are not suitable for strategy scripts, since the execution of the orders is delayed by one bar, due to the script execution happening at the bar close. Moreover, a history operator with a negative value that looks forward is not allowed in any pinescript expression. So, a prediction for the next bar using the bars_back argument of "time()"" and "time_close()" was necessary. Thus, I created this library to overcome this small but very important limitation. In the meantime, I added useful functionality to handle session-based behavior. An interesting utility that emerged from this development is the data anomaly detection where a comparison between the prediction and the actual value is happening. If those two values are different then a data inconsistency happened between the prediction bar and the actual bar (probably due to a holiday, half session day, a timezone change etc..) exTimezone(timezone)   exTimezone - Convert extended timezone to timezone string   Parameters:      timezone (simple string) : - The timezone or a special string   Returns: string representing the timezone nameOfDay(day)   nameOfDay - Convert the day id into a short nameOfDay   Parameters:      day (int) : - The day id to convert   Returns: - The short name of the day today()   today - Get the day id of this day   Returns: - The day id nthDayAfter(day, n)   nthDayAfter - Get the day id of n days after the given day   Parameters:      day (int) : - The day id of the reference day      n (int) : - The number of days to go forward   Returns: - The day id of the day that is n days after the reference day nextDayAfter(day)   nextDayAfter - Get the day id of next day after the given day   Parameters:      day (int) : - The day id of the reference day   Returns: - The day id of the next day after the reference day nthDayBefore(day, n)   nthDayBefore - Get the day id of n days before the given day   Parameters:      day (int) : - The day id of the reference day      n (int) : - The number of days to go forward   Returns: - The day id of the day that is n days before the reference day prevDayBefore(day)   prevDayBefore - Get the day id of previous day before the given day   Parameters:      day (int) : - The day id of the reference day   Returns: - The day id of the previous day before the reference day tomorrow()   tomorrow - Get the day id of the next day   Returns: - The next day day id normalize(num, min, max)   normalizeHour - Check if number is inthe range of   Parameters:      num (int)      min (int)      max (int)   Returns: - The normalized number normalizeHour(hourInDay)   normalizeHour - Check if hour is valid and return a noralized hour range from   Parameters:      hourInDay (int)   Returns: - The normalized hour normalizeMinute(minuteInHour)   normalizeMinute - Check if minute is valid and return a noralized minute from   Parameters:      minuteInHour (int)   Returns: - The normalized minute monthInMilliseconds(mon)   monthInMilliseconds - Calculate the miliseconds in one bar of the timeframe   Parameters:      mon (int) : - The month of reference to get the miliseconds   Returns: - The number of milliseconds of the month barInMilliseconds()   barInMilliseconds - Calculate the miliseconds in one bar of the timeframe   Returns: - The number of milliseconds in one bar method to_string(this)   to_string - Formats the time window into a human-readable string   Namespace types: DateTimeWindow   Parameters:      this (DateTimeWindow) : - The time window object with the from and to datetimes   Returns: - The string of the time window method to_string(this)   to_string - Formats the session days into a human-readable string with short day names   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object with the day selection   Returns: - The string of the session day short names method to_string(this)   to_string - Formats the session time into a human-readable string   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day   Returns: - The string of the session time method to_string(this)   to_string - Formats the session time into a human-readable string   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object with the start and end time of the daily session   Returns: - The string of the session time method to_string(this)   to_string - Formats the session into a human-readable string   Namespace types: Session   Parameters:      this (Session) : - The session object with the day and the time range selection   Returns: - The string of the session method init(this, fromDateTime, toDateTime)   init - Initialize the time window object from boolean values of each session day   Namespace types: DateTimeWindow   Parameters:      this (DateTimeWindow) : - The time window object that will hold the from and to datetimes      fromDateTime (int) : - The starting datetime of the time window      toDateTime (int) : - The ending datetime of the time window   Returns: - The time window object method init(this, refTimezone, chTimezone, fromDateTime, toDateTime)   init - Initialize the time window object from boolean values of each session day   Namespace types: DateTimeWindow   Parameters:      this (DateTimeWindow) : - The time window object that will hold the from and to datetimes      refTimezone (simple string) : - The timezone of reference of the 'from' and 'to' dates      chTimezone (simple string) : - The target timezone to convert the 'from' and 'to' dates      fromDateTime (int) : - The starting datetime of the time window      toDateTime (int) : - The ending datetime of the time window   Returns: - The time window object method init(this, sun, mon, tue, wed, thu, fri, sat)   init - Initialize the session days object from boolean values of each session day   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object that will hold the day selection      sun (bool) : - Is Sunday a trading day?      mon (bool) : - Is Monday a trading day?      tue (bool) : - Is Tuesday a trading day?      wed (bool) : - Is Wednesday a trading day?      thu (bool) : - Is Thursday a trading day?      fri (bool) : - Is Friday a trading day?      sat (bool) : - Is Saturday a trading day?   Returns: - The session days object method init(this, unixTime)   init - Initialize the object from the hour and minute of the session time in exchange timezone (syminfo.timezone)   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day      unixTime (int) : - The unix time   Returns: - The session time object method init(this, hourInDay, minuteInHour)   init - Initialize the object from the hour and minute of the session time in exchange timezone (syminfo.timezone)   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day      hourInDay (int) : - The hour of the time      minuteInHour (int) : - The minute of the time   Returns: - The session time object method init(this, hourInDay, minuteInHour, refTimezone)   init - Initialize the object from the hour and minute of the session time   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day      hourInDay (int) : - The hour of the time      minuteInHour (int) : - The minute of the time      refTimezone (string) : - The timezone of reference of the 'hour' and 'minute'   Returns: - The session time object method init(this, startTime, endTime)   init - Initialize the object from the start and end session time in exchange timezone (syminfo.timezone)   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session      startTime (SessionTime) : - The time the session begins      endTime (SessionTime) : - The time the session ends   Returns: - The session time range object method init(this, startTimeHour, startTimeMinute, endTimeHour, endTimeMinute, refTimezone)   init - Initialize the object from the start and end session time   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session      startTimeHour (int) : - The time hour the session begins      startTimeMinute (int) : - The time minute the session begins      endTimeHour (int) : - The time hour the session ends      endTimeMinute (int) : - The time minute the session ends      refTimezone (string)   Returns: - The session time range object method init(this, days, timeRanges)   init - Initialize the session object from session days and time range   Namespace types: Session   Parameters:      this (Session) : - The session object that will hold the day and the time range selection      days (SessionDays) : - The session days object that defines the days the session is happening      timeRanges (array) : - The array of all the session time ranges during a session day   Returns: - The session object method init(this, days, timeRanges, names, colors)   init - Initialize the session object from session days and time range   Namespace types: SessionView   Parameters:      this (SessionView) : - The session view object that will hold the session, the names and the color selections      days (SessionDays) : - The session days object that defines the days the session is happening      timeRanges (array) : - The array of all the session time ranges during a session day      names (array) : - The array of the names of the sessions      colors (array) : - The array of the colors of the sessions   Returns: - The session object method get_size_in_secs(this)   get_size_in_secs - Count the seconds from start to end in the given timeframe   Namespace types: DateTimeWindow   Parameters:      this (DateTimeWindow) : - The time window object with the from and to datetimes   Returns: - The number of seconds inside the time widow for the given timeframe method get_size_in_secs(this)   get_size_in_secs - Calculate the seconds inside the session   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object with the start and end time of the daily session   Returns: - The number of seconds inside the session method get_size_in_bars(this)   get_size_in_bars - Count the bars from start to end in the given timeframe   Namespace types: DateTimeWindow   Parameters:      this (DateTimeWindow) : - The time window object with the from and to datetimes   Returns: - The number of bars inside the time widow for the given timeframe method get_size_in_bars(this)   get_size_in_bars - Calculate the bars inside the session   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object with the start and end time of the daily session   Returns: - The number of bars inside the session for the given timeframe method is_bar_included(this, offset_forward)   is_bar_included - Check if the given bar is between the start and end dates of the window   Namespace types: DateTimeWindow   Parameters:      this (DateTimeWindow) : - The time window object with the from and to datetimes      offset_forward (simple int) : - The number of bars forward. Default is 1   Returns: - Whether the current bar is inside the datetime window method is_bar_included(this, offset_forward)   is_bar_included - Check if the given bar is inside the session as defined by the input params (what "not na(time(timeframe.period, this.to_sess_string()) )" should return if you could write it   Namespace types: Session   Parameters:      this (Session) : - The session with the day and the time range selection      offset_forward (simple int) : - The bar forward to check if it is between the from and to datetimes. Default is 1   Returns: - Whether the current time is inside the session method to_sess_string(this)   to_sess_string - Formats the session days into a session string with day ids   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object   Returns: - The string of the session day ids method to_sess_string(this)   to_sess_string - Formats the session time into a session string   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day   Returns: - The string of the session time method to_sess_string(this)   to_sess_string - Formats the session time into a session string   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object with the start and end time of the daily session   Returns: - The string of the session time method to_sess_string(this)   to_sess_string - Formats the session into a session string   Namespace types: Session   Parameters:      this (Session) : - The session object with the day and the time range selection   Returns: - The string of the session method from_sess_string(this, sess)   from_sess_string - Initialize the session days object from the session string   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object that will hold the day selection      sess (string) : - The session string part that represents the days   Returns: - The session days object method from_sess_string(this, sess)   from_sess_string - Initialize the session time object from the session string in exchange timezone (syminfo.timezone)   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object that will hold the hour and minute of the time      sess (string) : - The session string part that represents the time HHmm   Returns: - The session time object method from_sess_string(this, sess, refTimezone)   from_sess_string - Initialize the session time object from the session string   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object that will hold the hour and minute of the time      sess (string) : - The session string part that represents the time HHmm      refTimezone (simple string) : - The timezone of reference of the 'hour' and 'minute'   Returns: - The session time object method from_sess_string(this, sess)   from_sess_string - Initialize the session time range object from the session string in exchange timezone (syminfo.timezone)   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session      sess (string) : - The session string part that represents the time range HHmm-HHmm   Returns: - The session time range object method from_sess_string(this, sess, refTimezone)   from_sess_string - Initialize the session time range object from the session string   Namespace types: SessionTimeRange   Parameters:      this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session      sess (string) : - The session string part that represents the time range HHmm-HHmm      refTimezone (simple string) : - The timezone of reference of the time ranges   Returns: - The session time range object method from_sess_string(this, sess)   from_sess_string - Initialize the session object from the session string in exchange timezone (syminfo.timezone)   Namespace types: Session   Parameters:      this (Session) : - The session object that will hold the day and the time range selection      sess (string) : - The session string that represents the session HHmm-HHmm,HHmm-HHmm:ddddddd   Returns: - The session time range object method from_sess_string(this, sess, refTimezone)   from_sess_string - Initialize the session object from the session string   Namespace types: Session   Parameters:      this (Session) : - The session object that will hold the day and the time range selection      sess (string) : - The session string that represents the session HHmm-HHmm,HHmm-HHmm:ddddddd      refTimezone (simple string) : - The timezone of reference of the time ranges   Returns: - The session time range object method nth_day_after(this, day, n)   nth_day_after - The nth day after the given day that is a session day (true) in the object   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object with the day selection      day (int) : - The day id of the reference day      n (int) : - The number of days after   Returns: - The day id of the nth session day of the week after the given day method nth_day_before(this, day, n)   nth_day_before - The nth day before the given day that is a session day (true) in the object   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object with the day selection      day (int) : - The day id of the reference day      n (int) : - The number of days after   Returns: - The day id of the nth session day of the week before the given day method next_day(this)   next_day - The next day that is a session day (true) in the object   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object with the day selection   Returns: - The day id of the next session day of the week method previous_day(this)   previous_day - The previous day that is session day (true) in the object   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object with the day selection   Returns: - The day id of the previous session day of the week method get_sec_in_day(this)   get_sec_in_day - Count the seconds since the start of the day this session time represents   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day   Returns: - The number of seconds passed from the start of the day until that session time method get_ms_in_day(this)   get_ms_in_day - Count the milliseconds since the start of the day this session time represents   Namespace types: SessionTime   Parameters:      this (SessionTime) : - The session time object with the hour and minute of the time of the day   Returns: - The number of milliseconds passed from the start of the day until that session time method is_day_included(this, day)   is_day_included - Check if the given day is inside the session days   Namespace types: SessionDays   Parameters:      this (SessionDays) : - The session days object with the day selection      day (int) : - The day to check if it is a trading day   Returns: - Whether the current day is included in the session days DateTimeWindow   DateTimeWindow - Object that represents a datetime window with a beginning and an end   Fields:      fromDateTime (series int) : - The beginning of the datetime window      toDateTime (series int) : - The end of the datetime window SessionDays   SessionDays - Object that represent the trading days of the week   Fields:      days (map) : - The map that contains all days of the week and their session flag SessionTime   SessionTime - Object that represents the time (hour and minutes)   Fields:      hourInDay (series int) : - The hour of the day that ranges from 0 to 24      minuteInHour (series int) : - The minute of the hour that ranges from 0 to 59      minuteInDay (series int) : - The minute of the day that ranges from 0 to 1440. They will be calculated based on hourInDay and minuteInHour when method is called SessionTimeRange   SessionTimeRange - Object that represents a range that extends from the start to the end time   Fields:      startTime (SessionTime) : - The beginning of the time range      endTime (SessionTime) : - The end of the time range      isOvernight (series bool) : - Whether or not this is an overnight time range Session   Session - Object that represents a session   Fields:      days (SessionDays) : - The map of the trading days      timeRanges (array) : - The array with all time ranges of the session during the trading days SessionView   SessionView - Object that visualize a session   Fields:      sess (Session) : - The Session object to be visualized      names (array) : - The names of the session time ranges      colors (array) : - The colors of the session time ranges
Biblioteca Pine Script®
por progjonner77
ICT Kill Zones PanelICT Kill Zones Panel - Clean & Simple Trading Sessions Indicator A simple, objective indicator to identify ICT Kill Zones with real-time status and smart visual highlighting based on New York timezone. WHAT MAKES IT DIFFERENT: Traditional indicators clutter charts with dozens of colored boxes from past sessions. This tool provides a clean alternative: - Real-time information panel showing current active session - Smart dual-transparency painting: ACTIVE session displays stronger (more visible), historical sessions display softer (less clutter) - Accurate session timing: Only shows active when session is actually happening - Mobile-optimized size for phone trading - Professional interface that doesn't interfere with price action FEATURES: - Real-Time Detection: Panel uses actual NYC time (timenow) to show which session is active NOW - Precise Timing: Sessions activate ONLY during their specific time windows - all zones show inactive outside trading hours - Smart Visual System: Currently active session has stronger background color, past sessions are softer - Color Synchronization: Active session color in panel matches chart background color automatically - Clean Highlighting: Optional background painting with adjustable transparency levels - Full Customization: 9 panel positions, 4 sizes (Mobile/Small/Normal/Large), fully customizable colors - All Sessions: Asian (20:00-01:00), London (02:00-05:00), NY AM (08:00-11:00), London Close (10:00-12:00), NY PM (13:00-16:00) KILL ZONE SCHEDULE (NYC TIME): 1. Asian: 20:00 - 01:00 (5 hours) 2. INACTIVE: 01:00 - 02:00 3. London: 02:00 - 05:00 (3 hours) 4. INACTIVE: 05:00 - 08:00 5. NY AM: 08:00 - 11:00 (3 hours) - overlaps with London Close 6. London Close: 10:00 - 12:00 (2 hours) - overlaps with NY AM 7. INACTIVE: 12:00 - 13:00 8. NY PM: 13:00 - 16:00 (3 hours) 9. INACTIVE: 16:00 - 20:00 During INACTIVE periods, all sessions show as inactive in the panel. COLOR SYSTEM: ALL COLORS ARE FULLY CUSTOMIZABLE: - Each Kill Zone has its own color setting (Asian, London, NY AM, London Close, NY PM) - Default colors shown in screenshots are just examples - Active session in panel: displays with its assigned color (e.g., green for NY AM by default) - Same color appears on chart background with adjustable transparency - Inactive sessions in panel: display with gray (also customizable) - Panel background and text colors: fully customizable - Choose colors that match your chart theme The green color shown for active sessions in examples is the DEFAULT color for NY AM - you can change it to any color you prefer. TRANSPARENCY SYSTEM EXPLAINED: ACTIVE SESSION (happening right now): - Default 70% transparency = STRONGER/MORE VISIBLE background - Instantly shows which Kill Zone is unfolding - Panel row highlights with the session's assigned color - Chart background displays same color stronger HISTORICAL SESSIONS (already passed): - Default 90% transparency = SOFTER/LESS VISIBLE background - Provides context without visual clutter - Panel rows show gray (inactive color) - Both transparency levels fully adjustable in settings MOBILE OPTIMIZED: Select "Mobile" panel size for optimal viewing on phone screens - compact layout perfect for smaller displays. REPAINTING BEHAVIOR: Panel Status & Colors: Update in real-time as sessions change - panel color switches to match the new active session (intentional for current awareness) Active Session Highlighting: Adjusts in real-time to show current session stronger on chart Historical Background Colors: Do NOT repaint - accurately mark when sessions occurred Session Activation: Sessions activate and deactivate precisely at their scheduled times CUSTOMIZATION: - Panel: 9 positions, 4 sizes including Mobile - Colors: Individual customizable color for each Kill Zone - Panel Colors: Customizable background, text, and inactive zone colors - Transparency: Separate controls for active (default 70%) and historical (default 90%) sessions - Toggle: Show/hide individual zones - Chart Painting: On/off HOW TO USE: 1. Add to chart - panel appears top-right 2. Active session displays with its assigned color in panel and stronger on chart 3. Panel shows all zones as inactive during non-trading hours (accurate timing) 4. Panel color automatically changes when new session begins 5. Adjust all colors in settings to match your preferences 6. Adjust transparency settings for optimal visibility 7. Use "Mobile" size for phone trading BEST FOR: - ICT traders timing entries during high-liquidity periods - Smart money concepts (FVG, Order Blocks, Liquidity) - Traders who want clean charts with essential information - Traders needing accurate session timing without false signals - Mobile traders needing compact, clear displays - Traders who want to customize colors to match their chart theme TECHNICAL: - Works on all timeframes - Built with Pine Script v6 - NYC timezone with automatic DST adjustment - Precise hour-based session detection - Lightweight and optimized - Open source FEEDBACK WELCOME: All comments, critiques, and suggestions are welcome! Your input helps improve this tool for the trading community. Created by ivrank13 for traders who value simplicity, accuracy, and clean charts. © 2026 ivrank13. All Rights Reserved. #ICT #KillZones #SmartMoney #ForexSessions #CleanCharts #MobileTrading #CustomColors #AccurateTiming
Indicador Pine Script®
por ivrank13
[Statistics] killzone SFPSFP Statistics (ICT Sessions) This indicator automatically finds and draws the high and low of the Asia, London, and New York trading sessions. It then hunts for Swing Failure Patterns (SFPs) that sweep these key session levels. The main purpose of this script is to gather statistics on when these high-probability SFPs occur, allowing you to map out and identify the times of day when they are most frequent. How to Use This Indicator Set Your SFP Timeframe: In the settings, choose the timeframe you want to hunt for SFPs on (e.g., 1H, 15m). Important: You must also set your main chart to this exact same timeframe for the statistics to be collected correctly. Define Your Sessions: Go to the "Session Definitions" tab. Set the Global Timezone to your preferred trading timezone (e.g., "America/New_York"). This controls all session times and table times. Adjust the start and end times for Asia, London, and NY AM sessions. You can turn off sessions you don't want to track (like NY Lunch or NY PM). You can also change the colors and text style for the session boxes here. Set Confirmation Bars: In "SFP Engine Settings," the "Confirmation Bars" (default is 2) defines how many bars must close after the SFP bar without invalidating the level. An SFP is only "confirmed" and drawn after this period. 0 = Confirms immediately on the SFP candle's close. 2 = Confirms 2 bars after the SFP candle's close. Read the Statistics: The "Custom SFP Statistics" table will appear on your chart. This table logs every confirmed SFP and tells you: Which time of day they happen most. How many were Bearish (swept a high) vs. Bullish (swept a low). It's set by default to show the "Top 20" most frequent times, sorted chronologically. Filter Your Chart (Optional): If your chart feels cluttered, go to "Visual Time Filter" and turn it ON. Set a time window (e.g., "09:30-11:00"). The indicator will now only draw SFP signals that occurred within that specific time window. This is perfect for focusing on a single killzone. How to Set Up Alerts You can set up server-side alerts to be notified every time a new SFP is confirmed. Check the "Enable SFP Alerts" box at the top of the indicator's settings. Click the "Alert" button (alarm clock icon) on the TradingView toolbar. In the "Condition" dropdown, select "SFP Statistics (ICT Sessions)". In the second dropdown, choose "Any alert() function call". Most Important Step: In the "Message" box, delete any default text and type in this exact placeholder: {{alert_message}} Set the trigger to "Once Per Bar Close". Click "Create". How Alerts Work (Triggers & Filtering) Trigger: Alerts are tied to the confirmed signal. An alert will only fire after your "Confirmation Bars" have passed and the SFP is locked in. This prevents you from getting alerts on fake-outs. Alert Filtering: The alerts are linked to the "Visual Time Filter". If you turn on the Visual Time Filter (e.g., to 09:30-11:00), you will only receive alerts for SFPs that are confirmed within that time window. If an SFP happens at 14:00, the script will ignore it, it will not be drawn, and it will not send you an alert. This allows you to get alerts only for the session you are actively trading. Note: This is a first draft of this indicator. I will continue to work on it and improve it over time, as it may still contain small bugs. Acknowledgements: A big thank you to TFO (tradeforopp). The session detection logic and the visual style for the session boxes were adapted from his excellent "ICT Killzones & Pivots " indicator.
Indicador Pine Script®
por nickbonenkamp
1
Globex Trap w/ percentage [SLICKRICK]Globex Trap w/ Percentage Overview The Globex Trap w/ Percentage indicator is a powerful tool designed to help traders identify high-probability trading opportunities by analyzing price action during the Globex (overnight) session and regular trading hours. By combining Globex session ranges with Supply & Demand zones, this indicator highlights potential "trap" areas where significant price reactions may occur. Additionally, it calculates the Globex session range as a percentage of the daily Average True Range (ATR), providing valuable context for assessing market volatility. This indicator is ideal for traders in futures markets or other instruments traded during Globex sessions, offering a visual and analytical edge for spotting key price levels and potential reversals or breakouts. Key Features Globex Session Tracking: Visualizes the high and low of the Globex session (default: 3:00 PM to 6:30 AM PST) with customizable time settings. Displays a semi-transparent box to mark the Globex range, with labels for "Globex High" and "Globex Low." Calculates the Globex range as a percentage of the daily ATR, displayed as a label for quick reference. Supply & Demand Zones: Identifies Supply & Demand zones during regular trading hours (default: 6:00 AM to 8:00 AM PST) with customizable time settings. Draws semi-transparent boxes to highlight these zones, aiding in the identification of key support and resistance areas. Trap Area Identification: Highlights potential trap zones where Globex ranges and Supply & Demand zones overlap, indicating areas where price may reverse or consolidate due to trapped traders. Customizable Settings: Adjust Globex and Supply & Demand session times to suit your trading preferences. Toggle visibility of Globex and Supply & Demand zones independently. Customize box colors for better chart readability. Set the lookback period (default: 10 days) to control how many historical zones are displayed. Configure the ATR length (default: 14) for the percentage calculation. PST Timezone Default: All times are based on Pacific Standard Time (PST) by default, ensuring accurate session tracking for users in this timezone or those aligning with U.S. West Coast market hours. Recommended Usage Timeframes: Best used on 1-hour charts or lower (e.g., 15-minute, 5-minute) for precise entry and exit points. Markets: Optimized for futures (e.g., ES, NQ, CL) and other instruments traded during Globex sessions. Historical Data: Ensure at least 10 days of historical data for optimal visualization of zones. Strategy Integration: Use the indicator to identify potential reversals or breakouts at Globex highs/lows or Supply & Demand zones. The ATR percentage provides context for whether the Globex range is significant relative to typical daily volatility. How It Works Globex Session: Tracks the high and low prices during the user-defined Globex session (default: 3:00 PM to 6:30 AM PST). When the session ends, a box is drawn from the start to the end of the session, capturing the high and low prices. Labels are placed at the midpoint of the session, showing "Globex High," "Globex Low," and the range as a percentage of the daily ATR (e.g., "75.23% of Daily ATR"). Supply & Demand Zones: Tracks the high and low prices during the user-defined regular trading hours (default: 6:00 AM to 8:00 AM PST). Draws a box to mark these zones, which often act as key support or resistance levels. ATR Percentage: Calculates the Globex range (high minus low) and divides it by the daily ATR to express it as a percentage. This metric helps traders gauge whether the overnight price movement is significant compared to the instrument’s typical volatility. Time Handling: Uses PST (UTC-8) for all time calculations, ensuring accurate session timing for users aligning with this timezone. Properly handles overnight sessions that cross midnight, ensuring seamless tracking. Input Settings Globex Session Settings: Show Globex Session: Enable/disable Globex session visualization (default: true). Globex Start/End Time: Set the start and end times for the Globex session (default: 3:00 PM to 6:30 AM PST). Globex Box Color: Customize the color of the Globex session box (default: semi-transparent gray). Supply & Demand Zone Settings: Show Supply & Demand Zone: Enable/disable zone visualization (default: true). Zone Start/End Time: Set the start and end times for Supply & Demand zones (default: 6:00 AM to 8:00 AM PST). Zone Box Color: Customize the color of the zone box (default: semi-transparent aqua). General Settings: Days to Look Back: Number of historical days to display zones (default: 10). ATR Length: Period for calculating the daily ATR (default: 14). Notes All times are in Pacific Standard Time (PST). Adjust the start and end times if your market operates in a different timezone or if you prefer different session windows. The indicator is optimized for instruments with active Globex sessions, such as futures. Results may vary for non-24/5 markets. A typo in the label "Globe Low" (should be "Globex Low") will be corrected in future updates. Ensure your TradingView chart is set to display sufficient historical data to view the full lookback period. Why Use This Indicator? The Globex Trap w/ Percentage indicator provides a unique combination of session-based range analysis, Supply & Demand zone identification, and volatility context via the ATR percentage. Whether you’re a day trader, swing trader, or scalper, this tool helps you: Pinpoint key price levels where institutional traders may act. Assess the significance of overnight price movements relative to daily volatility. Identify potential trap zones for high-probability setups. Customize the indicator to fit your trading style and market preferences.
Indicador Pine Script®
por slickrick570
STOCK EXCHANGE + SILVER BULLET FRAMESThis script is an updated version of the " NY/LDN/TOK Stock Exchange Opening Hours " script. Objective Displays global stock exchange sessions (New York, London, Tokyo) with session frames, highs/lows, and opening lines. Includes ICT Silver Bullet windows (NY, London, Tokyo) with configurable shading. Past sessions are frozen at close, ongoing sessions update dynamically until closure, and upcoming sessions are pre-drawn. Fully customizable with options for weekends, labels, padding, opacity, and individual session toggles. It is designed to help traders quickly interpret market context, liquidity zones, and session-based price behavior. Main Features Past sessions (historical data) • Session Frames: • Each box is frozen at the session’s close. • The left edge aligns with the opening time, while the right edge is fixed at the closing time. • The top and bottom reflect the highest and lowest prices during the session. • Session Labels: • Names (NY, LDN, TOK) displayed above the frame, aligned left, in the same color as the frame. • Opening Lines: • Vertical dotted lines mark the start of each session. Ongoing and upcoming sessions (live market) • Dynamic Session Frames: • The right edge is locked at the future close time. • The top and bottom update in real time as new highs and lows form. • Labels and Lines: • The session label is visible above the active frame. • Opening lines are drawn as soon as the session begins. Silver Bullet Time Windows (ICT concept) • Highlights key liquidity windows within sessions: • New York: 10:00–11:00 and 14:00–15:00 • London: 08:00–09:00 • Tokyo: 09:00–10:00 • Silver Bullet zones are shaded with configurable opacity (default 5%). Customization and Options • Enable or disable individual sessions (NY, London, Tokyo). • Toggle weekend display (frames and Silver Bullets). • Adjust label size, padding, and text visibility. • Control frame opacity (default 0%). • Optimized memory management with automatic pruning of old graphical objects.
Indicador Pine Script®
por julbbnj