Şimdi başlat

Fvg

FvgPanel█ OVERVIEW This library provides functionalities for creating and managing a display panel within a Pine Script™ indicator. Its primary purpose is to offer a structured way to present Fair Value Gap (FVG) information, specifically the nearest bullish and bearish FVG levels across different timeframes (Current, MTF, HTF), directly on the chart. The library handles the table's structure, header initialization, and dynamic cell content updates. █ CONCEPTS The core of this library revolves around presenting summarized FVG data in a clear, tabular format. Key concepts include: FVG Data Aggregation and Display The panel is designed to show at-a-glance information about the closest active FVG mitigation levels. It doesn't calculate these FVGs itself but relies on the main script to provide this data. The panel is structured with columns for timeframes (TF), Bullish FVGs, and Bearish FVGs, and rows for "Current" (LTF), "MTF" (Medium Timeframe), and "HTF" (High Timeframe). The `panelData` User-Defined Type (UDT) To facilitate the transfer of information to be displayed, the library defines a UDT named `panelData`. This structure is central to the library's operation and is designed to hold all necessary values for populating the panel's data cells for each relevant FVG. Its fields include: Price levels for the nearest bullish and bearish FVGs for LTF, MTF, and HTF (e.g., `nearestBullMitLvl`, `nearestMtfBearMitLvl`). Boolean flags to indicate if these FVGs are classified as "Large Volume" (LV) (e.g., `isNearestBullLV`, `isNearestMtfBearLV`). Color information for the background and text of each data cell, allowing for conditional styling based on the FVG's status or proximity (e.g., `ltfBullBgColor`, `mtfBearTextColor`). The design of `panelData` allows the main script to prepare all display-related data and styling cues in one object, which is then passed to the `updatePanel` function for rendering. This separation of data preparation and display logic keeps the library focused on its presentation task. Visual Cues and Formatting Price Formatting: Price levels are formatted to match the instrument's minimum tick size using an internal `formatPrice` helper function, ensuring consistent and accurate display. Large FVG Icon: If an FVG is marked as a "Large Volume" FVG in the `panelData` object, a user-specified icon (e.g., an emoji) is prepended to its price level in the panel, providing an immediate visual distinction. Conditional Styling: The background and text colors for each FVG level displayed in the panel can be individually controlled via the `panelData` object, enabling the main script to implement custom styling rules (e.g., highlighting the overall nearest FVG across all timeframes). Handling Missing Data: If no FVG data is available for a particular cell (i.e., the corresponding level in `panelData` is `na`), the panel displays "---" and uses a specified background color for "Not Available" cells. █ CALCULATIONS AND USE Using the `FvgPanel` typically involves a two-stage process: initialization and dynamic updates. Step 1: Panel Creation First, an instance of the panel table is created once, usually during the script's initial setup. This is done using the `createPanel` function. Call `createPanel()` with parameters defining its position on the chart, border color, border width, header background color, header text color, and header text size. This function initializes the table with three columns ("TF", "Bull FVG", "Bear FVG") and three data rows labeled "Current", "MTF", and "HTF", plus a header row. Store the returned `table` object in a `var` variable to persist it across bars. // Example: var table infoPanel = na if barstate.isfirst infoPanel := panel.createPanel( position.top_right, color.gray, 1, color.new(color.gray, 50), color.white, size.small ) Step 2: Panel Updates On each bar, or whenever the FVG data changes (typically on `barstate.islast` or `barstate.isrealtime` for efficiency), the panel's content needs to be refreshed. This is done using the `updatePanel` function. Populate an instance of the `panelData` UDT with the latest FVG information. This includes setting the nearest bullish/bearish mitigation levels for LTF, MTF, and HTF, their LV status, and their desired background and text colors. Call `updatePanel()`, passing the persistent `table` object (from Step 1), the populated `panelData` object, the icon string for LV FVGs, the default text color for FVG levels, the background color for "N/A" cells, and the general text size for the data cells. The `updatePanel` function will then clear previous data and fill the table cells with the new values and styles provided in the `panelData` object. // Example (inside a conditional block like 'if barstate.islast'): var panelData fvgDisplayData = panelData.new() // ... (logic to populate fvgDisplayData fields) ... // fvgDisplayData.nearestBullMitLvl = ... // fvgDisplayData.ltfBullBgColor = ... // ... etc. if not na(infoPanel) panel.updatePanel( infoPanel, fvgDisplayData, "🔥", // LV FVG Icon color.white, color.new(color.gray, 70), // NA Cell Color size.small ) This workflow ensures that the panel is drawn only once and its cells are efficiently updated as new data becomes available. █ NOTES Data Source: This library is solely responsible for the visual presentation of FVG data in a table. It does not perform any FVG detection or calculation. The calling script must compute or retrieve the FVG levels, LV status, and desired styling to populate the `panelData` object. Styling Responsibility: While `updatePanel` applies colors passed via the `panelData` object, the logic for *determining* those colors (e.g., highlighting the closest FVG to the current price) resides in the calling script. Performance: The library uses `table.cell()` to update individual cells, which is generally more efficient than deleting and recreating the table on each update. However, the frequency of `updatePanel` calls should be managed by the main script (e.g., using `barstate.islast` or `barstate.isrealtime`) to avoid excessive processing on historical bars. `series float` Handling: The price level fields within the `panelData` UDT (e.g., `nearestBullMitLvl`) can accept `series float` values, as these are typically derived from price data. The internal `formatPrice` function correctly handles `series float` for display. Dependencies: The `FvgPanel` itself is self-contained and does not import other user libraries. It uses standard Pine Script™ table and string functionalities. █ EXPORTED TYPES panelData   Represents the data structure for populating the FVG information panel.   Fields:      nearestBullMitLvl (series float) : The price level of the nearest bullish FVG's mitigation point (bottom for bull) on the LTF.      isNearestBullLV (series bool) : True if the nearest bullish FVG on the LTF is a Large Volume FVG.      ltfBullBgColor (series color) : Background color for the LTF bullish FVG cell in the panel.      ltfBullTextColor (series color) : Text color for the LTF bullish FVG cell in the panel.      nearestBearMitLvl (series float) : The price level of the nearest bearish FVG's mitigation point (top for bear) on the LTF.      isNearestBearLV (series bool) : True if the nearest bearish FVG on the LTF is a Large Volume FVG.      ltfBearBgColor (series color) : Background color for the LTF bearish FVG cell in the panel.      ltfBearTextColor (series color) : Text color for the LTF bearish FVG cell in the panel.      nearestMtfBullMitLvl (series float) : The price level of the nearest bullish FVG's mitigation point on the MTF.      isNearestMtfBullLV (series bool) : True if the nearest bullish FVG on the MTF is a Large Volume FVG.      mtfBullBgColor (series color) : Background color for the MTF bullish FVG cell.      mtfBullTextColor (series color) : Text color for the MTF bullish FVG cell.      nearestMtfBearMitLvl (series float) : The price level of the nearest bearish FVG's mitigation point on the MTF.      isNearestMtfBearLV (series bool) : True if the nearest bearish FVG on the MTF is a Large Volume FVG.      mtfBearBgColor (series color) : Background color for the MTF bearish FVG cell.      mtfBearTextColor (series color) : Text color for the MTF bearish FVG cell.      nearestHtfBullMitLvl (series float) : The price level of the nearest bullish FVG's mitigation point on the HTF.      isNearestHtfBullLV (series bool) : True if the nearest bullish FVG on the HTF is a Large Volume FVG.      htfBullBgColor (series color) : Background color for the HTF bullish FVG cell.      htfBullTextColor (series color) : Text color for the HTF bullish FVG cell.      nearestHtfBearMitLvl (series float) : The price level of the nearest bearish FVG's mitigation point on the HTF.      isNearestHtfBearLV (series bool) : True if the nearest bearish FVG on the HTF is a Large Volume FVG.      htfBearBgColor (series color) : Background color for the HTF bearish FVG cell.      htfBearTextColor (series color) : Text color for the HTF bearish FVG cell. █ EXPORTED FUNCTIONS createPanel(position, borderColor, borderWidth, headerBgColor, headerTextColor, headerTextSize)   Creates and initializes the FVG information panel (table). Sets up the header rows and timeframe labels.   Parameters:      position (simple string) : The position of the panel on the chart (e.g., position.top_right). Uses position.* constants.      borderColor (simple color) : The color of the panel's border.      borderWidth (simple int) : The width of the panel's border.      headerBgColor (simple color) : The background color for the header cells.      headerTextColor (simple color) : The text color for the header cells.      headerTextSize (simple string) : The text size for the header cells (e.g., size.small). Uses size.* constants.   Returns: The newly created table object representing the panel. updatePanel(panelTable, data, lvIcon, defaultTextColor, naCellColor, textSize)   Updates the content of the FVG information panel with the latest FVG data.   Parameters:      panelTable (table) : The table object representing the panel to be updated.      data (panelData) : An object containing the FVG data to display.      lvIcon (simple string) : The icon (e.g., emoji) to display next to Large Volume FVGs.      defaultTextColor (simple color) : The default text color for FVG levels if not highlighted.      naCellColor (simple color) : The background color for cells where no FVG data is available ("---").      textSize (simple string) : The text size for the FVG level data (e.g., size.small).   Returns: _void
Pine Script® kütüphanesi
no1x tarafından
FvgCalculations█ OVERVIEW This library provides the core calculation engine for identifying Fair Value Gaps (FVGs) across different timeframes and for processing their interaction with price. It includes functions to detect FVGs on both the current chart and higher timeframes, as well as to check for their full or partial mitigation. █ CONCEPTS The library's primary functions revolve around the concept of Fair Value Gaps and their lifecycle. Fair Value Gap (FVG) Identification An FVG, or imbalance, represents a price range where buying or selling pressure was significant enough to cause a rapid price movement, leaving an "inefficiency" in the market. This library identifies FVGs based on three-bar patterns: Bullish FVG: Forms when the low of the current bar (bar 3) is higher than the high of the bar two periods prior (bar 1). The FVG is the space between the high of bar 1 and the low of bar 3. Bearish FVG: Forms when the high of the current bar (bar 3) is lower than the low of the bar two periods prior (bar 1). The FVG is the space between the low of bar 1 and the high of bar 3. The library provides distinct functions for detecting FVGs on the current (Low Timeframe - LTF) and specified higher timeframes (Medium Timeframe - MTF / High Timeframe - HTF). FVG Mitigation Mitigation refers to price revisiting an FVG. Full Mitigation: An FVG is considered fully mitigated when price completely closes the gap. For a bullish FVG, this occurs if the current low price moves below or touches the FVG's bottom. For a bearish FVG, it occurs if the current high price moves above or touches the FVG's top. Partial Mitigation (Entry/Fill): An FVG is partially mitigated when price enters the FVG's range but does not fully close it. The library tracks the extent of this fill. For a bullish FVG, if the current low price enters the FVG from above, that low becomes the new effective top of the remaining FVG. For a bearish FVG, if the current high price enters the FVG from below, that high becomes the new effective bottom of the remaining FVG. FVG Interaction This refers to any instance where the current bar's price range (high to low) touches or crosses into the currently unfilled portion of an active (visible and not fully mitigated) FVG. Multi-Timeframe Data Acquisition To detect FVGs on higher timeframes, specific historical bar data (high, low, and time of bars at indices and relative to the higher timeframe's last completed bar) is required. The requestMultiTFBarData function is designed to fetch this data efficiently. █ CALCULATIONS AND USE The functions in this library are typically used in a sequence to manage FVGs: 1. Data Retrieval (for MTF/HTF FVGs): Call requestMultiTFBarData() with the desired higher timeframe string (e.g., "60", "D"). This returns a tuple of htfHigh1, htfLow1, htfTime1, htfHigh3, htfLow3, htfTime3. 2. FVG Detection: For LTF FVGs: Call detectFvg() on each confirmed bar. It uses high , low, low , and high along with barstate.isconfirmed. For MTF/HTF FVGs: Call detectMultiTFFvg() using the data obtained from requestMultiTFBarData(). Both detection functions return an fvgObject (defined in FvgTypes) if an FVG is found, otherwise na. They also can classify FVGs as "Large Volume" (LV) if classifyLV is true and the FVG size (top - bottom) relative to the tfAtr (Average True Range of the respective timeframe) meets the lvAtrMultiplier. 3. FVG State Updates (on each new bar for existing FVGs): First, check for overall price interaction using fvgInteractionCheck(). This function determines if the current bar's high/low has touched or entered the FVG's currentTop or currentBottom. If interaction occurs and the FVG is not already mitigated: Call checkMitigation() to determine if the FVG has been fully mitigated by the current bar's currentHigh and currentLow. If true, the FVG's isMitigated status is updated. If not fully mitigated, call checkPartialMitigation() to see if the price has further entered the FVG. This function returns the newLevel to which the FVG has been filled (e.g., currentLow for a bullish FVG, currentHigh for bearish). This newLevel is then used to update the FVG's currentTop or currentBottom. The calling script (e.g., fvgMain.c) is responsible for storing and managing the array of fvgObject instances and passing them to these update functions. █ NOTES Bar State for LTF Detection: The detectFvg() function relies on barstate.isconfirmed to ensure FVG detection is based on closed bars, preventing FVGs from being detected prematurely on the currently forming bar. Higher Timeframe Data (lookahead): The requestMultiTFBarData() function uses lookahead = barmerge.lookahead_on. This means it can access historical data from the higher timeframe that corresponds to the current bar on the chart, even if the higher timeframe bar has not officially closed. This is standard for multi-timeframe analysis aiming to plot historical HTF data accurately on a lower timeframe chart. Parameter Typing: Functions like detectMultiTFFvg and detectFvg infer the type for boolean (classifyLV) and numeric (lvAtrMultiplier) parameters passed from the main script, while explicitly typed series parameters (like htfHigh1, currentAtr) expect series data. fvgObject Dependency: The FVG detection functions return fvgObject instances, and fvgInteractionCheck takes an fvgObject as a parameter. This UDT is defined in the FvgTypes library, making it a dependency for using FvgCalculations. ATR for LV Classification: The tfAtr (for MTF/HTF) and currentAtr (for LTF) parameters are expected to be the Average True Range values for the respective timeframes. These are used, if classifyLV is enabled, to determine if an FVG's size qualifies it as a "Large Volume" FVG based on the lvAtrMultiplier. MTF/HTF FVG Appearance Timing: When displaying FVGs from a higher timeframe (MTF/HTF) on a lower timeframe (LTF) chart, users might observe that the most recent MTF/HTF FVG appears one LTF bar later compared to its appearance on a native MTF/HTF chart. This is an expected behavior due to the detection mechanism in `detectMultiTFFvg`. This function uses historical bar data from the MTF/HTF (specifically, data equivalent to `HTF_bar ` and `HTF_bar `) to identify an FVG. Therefore, all three bars forming the FVG on the MTF/HTF must be fully closed and have shifted into these historical index positions relative to the `request.security` call from the LTF chart before the FVG can be detected and displayed on the LTF. This ensures that the MTF/HTF FVG is identified based on confirmed, closed bars from the higher timeframe. █ EXPORTED FUNCTIONS requestMultiTFBarData(timeframe)   Requests historical bar data for specific previous bars from a specified higher timeframe.   It fetches H , L , T (for the bar before last) and H , L , T (for the bar three periods prior) from the requested timeframe.   This is typically used to identify FVG patterns on MTF/HTF.   Parameters:      timeframe (simple string) : The higher timeframe to request data from (e.g., "60" for 1-hour, "D" for Daily).   Returns: A tuple containing: .   - htfHigh1 (series float): High of the bar at index 1 (one bar before the last completed bar on timeframe).   - htfLow1 (series float): Low of the bar at index 1.   - htfTime1 (series int) : Time of the bar at index 1.   - htfHigh3 (series float): High of the bar at index 3 (three bars before the last completed bar on timeframe).   - htfLow3 (series float): Low of the bar at index 3.   - htfTime3 (series int) : Time of the bar at index 3. detectMultiTFFvg(htfHigh1, htfLow1, htfTime1, htfHigh3, htfLow3, htfTime3, tfAtr, classifyLV, lvAtrMultiplier, tfType)   Detects a Fair Value Gap (FVG) on a higher timeframe (MTF/HTF) using pre-fetched bar data.   Parameters:      htfHigh1 (float) : High of the first relevant bar (typically high ) from the higher timeframe.      htfLow1 (float) : Low of the first relevant bar (typically low ) from the higher timeframe.      htfTime1 (int) : Time of the first relevant bar (typically time ) from the higher timeframe.      htfHigh3 (float) : High of the third relevant bar (typically high ) from the higher timeframe.      htfLow3 (float) : Low of the third relevant bar (typically low ) from the higher timeframe.      htfTime3 (int) : Time of the third relevant bar (typically time ) from the higher timeframe.      tfAtr (float) : ATR value for the higher timeframe, used for Large Volume (LV) FVG classification.      classifyLV (bool) : If true, FVGs will be assessed to see if they qualify as Large Volume.      lvAtrMultiplier (float) : The ATR multiplier used to define if an FVG is Large Volume.      tfType (series tfType enum from no1x/FvgTypes/1) : The timeframe type (e.g., types.tfType.MTF, types.tfType.HTF) of the FVG being detected.   Returns: An fvgObject instance if an FVG is detected, otherwise na. detectFvg(classifyLV, lvAtrMultiplier, currentAtr)   Detects a Fair Value Gap (FVG) on the current (LTF - Low Timeframe) chart.   Parameters:      classifyLV (bool) : If true, FVGs will be assessed to see if they qualify as Large Volume.      lvAtrMultiplier (float) : The ATR multiplier used to define if an FVG is Large Volume.      currentAtr (float) : ATR value for the current timeframe, used for LV FVG classification.   Returns: An fvgObject instance if an FVG is detected, otherwise na. checkMitigation(isBullish, fvgTop, fvgBottom, currentHigh, currentLow)   Checks if an FVG has been fully mitigated by the current bar's price action.   Parameters:      isBullish (bool) : True if the FVG being checked is bullish, false if bearish.      fvgTop (float) : The top price level of the FVG.      fvgBottom (float) : The bottom price level of the FVG.      currentHigh (float) : The high price of the current bar.      currentLow (float) : The low price of the current bar.   Returns: True if the FVG is considered fully mitigated, false otherwise. checkPartialMitigation(isBullish, currentBoxTop, currentBoxBottom, currentHigh, currentLow)   Checks for partial mitigation of an FVG by the current bar's price action.   It determines if the price has entered the FVG and returns the new fill level.   Parameters:      isBullish (bool) : True if the FVG being checked is bullish, false if bearish.      currentBoxTop (float) : The current top of the FVG box (this might have been adjusted by previous partial fills).      currentBoxBottom (float) : The current bottom of the FVG box (similarly, might be adjusted).      currentHigh (float) : The high price of the current bar.      currentLow (float) : The low price of the current bar.   Returns: The new price level to which the FVG has been filled (e.g., currentLow for a bullish FVG).   Returns na if no new partial fill occurred on this bar. fvgInteractionCheck(fvg, highVal, lowVal)   Checks if the current bar's price interacts with the given FVG.   Interaction means the price touches or crosses into the FVG's current (possibly partially filled) range.   Parameters:      fvg (fvgObject type from no1x/FvgTypes/1) : The FVG object to check.     Its isMitigated, isVisible, isBullish, currentTop, and currentBottom fields are used.      highVal (float) : The high price of the current bar.      lowVal (float) : The low price of the current bar.   Returns: True if price interacts with the FVG, false otherwise.
Pine Script® kütüphanesi
no1x tarafından
FvgTypes█ OVERVIEW This library serves as a foundational module for Pine Script™ projects focused on Fair Value Gaps (FVGs). Its primary purpose is to define and centralize custom data structures (User-Defined Types - UDTs) and enumerations that are utilized across various components of an FVG analysis system. By providing standardized types for FVG characteristics and drawing configurations, it promotes code consistency, readability, and easier maintenance within a larger FVG indicator or strategy. █ CONCEPTS The library introduces several key data structures (User-Defined Types - UDTs) and an enumeration to organize Fair Value Gap (FVG) related data logically. These types are central to the functioning of FVG analysis tools built upon this library. Timeframe Categorization (`tfType` Enum) To manage and differentiate FVGs based on their timeframe of origin, the `tfType` enumeration is defined. It includes: `LTF`: Low Timeframe (typically the current chart). `MTF`: Medium Timeframe. `HTF`: High Timeframe. This allows for distinct logic and visual settings to be applied depending on the FVG's source timeframe. FVG Data Encapsulation (`fvgObject` UDT) The `fvgObject` is a comprehensive UDT designed to encapsulate all pertinent information and state for an individual Fair Value Gap throughout its lifecycle. Instead of listing every field, its conceptual structure can be understood as holding: Core Definition: The FVG's fundamental price levels (top, bottom) and its formation time (`startTime`). Classification Attributes: Characteristics such as its direction (`isBullish`) and whether it qualifies as a Large Volume FVG (`isLV`), along with its originating timeframe category (`tfType`). Lifecycle State: Current status indicators including full mitigation (`isMitigated`, `mitigationTime`), partial fill levels (`currentTop`, `currentBottom`), midline interaction (`isMidlineTouched`), and overall visibility (`isVisible`). Drawing Identifiers: References (`boxId`, `midLineId`, `mitLineLabelId`, etc.) to the actual graphical objects drawn on the chart to represent the FVG and its components. Optimization Cache: Previous-bar state values (`prevIsMitigated`, `prevCurrentTop`, etc.) crucial for optimizing drawing updates by avoiding redundant operations. This comprehensive structure facilitates easy access to all FVG-related information through a single object, reducing code complexity and improving manageability. Drawing Configuration (`drawSettings` UDT) The `drawSettings` UDT centralizes all user-configurable parameters that dictate the visual appearance of FVGs across different timeframes. It's typically populated from script inputs and conceptually groups settings for: General Behavior: Global FVG classification toggles (e.g., `shouldClassifyLV`) and general display rules (e.g., `shouldHideMitigated`). FVG Type Specific Colors: Colors for standard and Large Volume FVGs, both active and mitigated (e.g., `lvBullColor`, `mitigatedBearBoxColor`). Timeframe-Specific Visuals (LTF, MTF, HTF): Detailed parameters for each timeframe category, covering FVG boxes (visibility, colors, extension, borders, labels), midlines (visibility, style, color), and mitigation lines (visibility, style, color, labels, persistence after mitigation). Contextual Information: The current bar's time (`currentTime`) for accurate positioning of time-dependent drawing elements and timeframe display strings (`tfString`, `mtfTfString`, `htfTfString`). This centralized approach allows for extensive customization of FVG visuals and simplifies the management of drawing parameters within the main script. Such centralization also enhances the maintainability of the visual aspects of the FVG system. █ NOTES User-Defined Types (UDTs): This library extensively uses UDTs (`fvgObject`, `drawSettings`) to group related data. This improves code organization and makes it easier to pass complex data between functions and libraries. Mutability and Reference Behavior of UDTs: When UDT instances are passed to functions or methods in other libraries (like `fvgObjectLib`), those functions might modify the fields of the passed object if they are not explicitly designed to return new instances. This is because UDTs are passed by reference and are mutable in Pine Script™. Users should be aware of this standard behavior to prevent unintended side effects. Optimization Fields: The `prev_*` fields in `fvgObject` are crucial for performance optimization in the drawing logic. They help avoid unnecessary redrawing of FVG elements if their state or relevant settings haven't changed. No Direct Drawing Logic: `FvgTypes` itself does not contain any drawing logic. It solely defines the data structures. The actual drawing and manipulation of these objects are handled by other libraries (e.g., `fvgObjectLib`). Centralized Definitions: By defining these types in a separate library, any changes to the structure of FVG data or settings can be made in one place, ensuring consistency across all dependent scripts and libraries. █ EXPORTED TYPES fvgObject   fvgObject Represents a Fair Value Gap (FVG) object. Fields:      top (series float) : The top price level of the FVG.      bottom (series float) : The bottom price level of the FVG.      startTime (series int) : The start time (timestamp) of the bar where the FVG formed.      isBullish (series bool) : Indicates if the FVG is bullish (true) or bearish (false).      isLV (series bool) : Indicates if the FVG is a Large Volume FVG.      tfType (series tfType) : The timeframe type (LTF, MTF, HTF) to which this FVG belongs.      isMitigated (series bool) : Indicates if the FVG has been fully mitigated.      mitigationTime (series int) : The time (timestamp) when the FVG was mitigated.      isVisible (series bool) : The current visibility status of the FVG, typically managed by drawing logic based on filters.      isMidlineTouched (series bool) : Indicates if the price has touched the FVG's midline (50% level).      currentTop (series float) : The current top level of the FVG after partial fills.      currentBottom (series float) : The current bottom level of the FVG after partial fills.      boxId (series box) : The drawing ID for the main FVG box.      mitigatedBoxId (series box) : The drawing ID for the box representing the partially filled (mitigated) area.      midLineId (series line) : The drawing ID for the FVG's midline.      mitLineId (series line) : The drawing ID for the FVG's mitigation line.      boxLabelId (series label) : The drawing ID for the FVG box label.      mitLineLabelId (series label) : The drawing ID for the mitigation line label.      testedBoxId (series box) : The drawing ID for the box of a fully mitigated (tested) FVG, if kept visible.      keptMitLineId (series line) : The drawing ID for a mitigation line that is kept after full mitigation.      prevIsMitigated (series bool) : Stores the isMitigated state from the previous bar for optimization.      prevCurrentTop (series float) : Stores the currentTop value from the previous bar for optimization.      prevCurrentBottom (series float) : Stores the currentBottom value from the previous bar for optimization.      prevIsVisible (series bool) : Stores the visibility status from the previous bar for optimization (derived from isVisibleNow passed to updateDrawings).      prevIsMidlineTouched (series bool) : Stores the isMidlineTouched status from the previous bar for optimization. drawSettings   drawSettings A structure containing settings for drawing FVGs. Fields:      shouldClassifyLV (series bool) : Whether to classify FVGs as Large Volume (LV) based on ATR.      shouldHideMitigated (series bool) : Whether to hide FVG boxes once they are fully mitigated.      currentTime (series int) : The current bar's time, used for extending drawings.      lvBullColor (series color) : Color for Large Volume Bullish FVGs.      mitigatedLvBullColor (series color) : Color for mitigated Large Volume Bullish FVGs.      lvBearColor (series color) : Color for Large Volume Bearish FVGs.      mitigatedLvBearColor (series color) : Color for mitigated Large Volume Bearish FVGs.      shouldShowBoxes (series bool) : Whether to show FVG boxes for the LTF.      bullBoxColor (series color) : Color for LTF Bullish FVG boxes.      mitigatedBullBoxColor (series color) : Color for mitigated LTF Bullish FVG boxes.      bearBoxColor (series color) : Color for LTF Bearish FVG boxes.      mitigatedBearBoxColor (series color) : Color for mitigated LTF Bearish FVG boxes.      boxLengthBars (series int) : Length of LTF FVG boxes in bars (if not extended).      shouldExtendBoxes (series bool) : Whether to extend LTF FVG boxes to the right.      shouldShowCurrentTfBoxLabels (series bool) : Whether to show labels on LTF FVG boxes.      shouldShowBoxBorder (series bool) : Whether to show a border for LTF FVG boxes.      boxBorderWidth (series int) : Border width for LTF FVG boxes.      boxBorderStyle (series string) : Border style for LTF FVG boxes (e.g., line.style_solid).      boxBorderColor (series color) : Border color for LTF FVG boxes.      shouldShowMidpoint (series bool) : Whether to show the midline (50% level) for LTF FVGs.      midLineWidthInput (series int) : Width of the LTF FVG midline.      midpointLineStyleInput (series string) : Style of the LTF FVG midline.      midpointColorInput (series color) : Color of the LTF FVG midline.      shouldShowMitigationLine (series bool) : Whether to show the mitigation line for LTF FVGs. (Line always extends if shown)      mitLineWidthInput (series int) : Width of the LTF FVG mitigation line.      mitigationLineStyleInput (series string) : Style of the LTF FVG mitigation line.      mitigationLineColorInput (series color) : Color of the LTF FVG mitigation line.      shouldShowCurrentTfMitLineLabels (series bool) : Whether to show labels on LTF FVG mitigation lines.      currentTfMitLineLabelOffsetX (series float) : The horizontal offset value for the LTF mitigation line's label.      shouldKeepMitigatedLines (series bool) : Whether to keep showing mitigation lines of fully mitigated LTF FVGs.      mitigatedMitLineColor (series color) : Color for kept mitigation lines of mitigated LTF FVGs.      tfString (series string) : Display string for the LTF (e.g., "Current TF").      shouldShowMtfBoxes (series bool) : Whether to show FVG boxes for the MTF.      mtfBullBoxColor (series color) : Color for MTF Bullish FVG boxes.      mtfMitigatedBullBoxColor (series color) : Color for mitigated MTF Bullish FVG boxes.      mtfBearBoxColor (series color) : Color for MTF Bearish FVG boxes.      mtfMitigatedBearBoxColor (series color) : Color for mitigated MTF Bearish FVG boxes.      mtfBoxLengthBars (series int) : Length of MTF FVG boxes in bars (if not extended).      shouldExtendMtfBoxes (series bool) : Whether to extend MTF FVG boxes to the right.      shouldShowMtfBoxLabels (series bool) : Whether to show labels on MTF FVG boxes.      shouldShowMtfBoxBorder (series bool) : Whether to show a border for MTF FVG boxes.      mtfBoxBorderWidth (series int) : Border width for MTF FVG boxes.      mtfBoxBorderStyle (series string) : Border style for MTF FVG boxes.      mtfBoxBorderColor (series color) : Border color for MTF FVG boxes.      shouldShowMtfMidpoint (series bool) : Whether to show the midline for MTF FVGs.      mtfMidLineWidthInput (series int) : Width of the MTF FVG midline.      mtfMidpointLineStyleInput (series string) : Style of the MTF FVG midline.      mtfMidpointColorInput (series color) : Color of the MTF FVG midline.      shouldShowMtfMitigationLine (series bool) : Whether to show the mitigation line for MTF FVGs. (Line always extends if shown)      mtfMitLineWidthInput (series int) : Width of the MTF FVG mitigation line.      mtfMitigationLineStyleInput (series string) : Style of the MTF FVG mitigation line.      mtfMitigationLineColorInput (series color) : Color of the MTF FVG mitigation line.      shouldShowMtfMitLineLabels (series bool) : Whether to show labels on MTF FVG mitigation lines.      mtfMitLineLabelOffsetX (series float) : The horizontal offset value for the MTF mitigation line's label.      shouldKeepMtfMitigatedLines (series bool) : Whether to keep showing mitigation lines of fully mitigated MTF FVGs.      mtfMitigatedMitLineColor (series color) : Color for kept mitigation lines of mitigated MTF FVGs.      mtfTfString (series string) : Display string for the MTF (e.g., "MTF").      shouldShowHtfBoxes (series bool) : Whether to show FVG boxes for the HTF.      htfBullBoxColor (series color) : Color for HTF Bullish FVG boxes.      htfMitigatedBullBoxColor (series color) : Color for mitigated HTF Bullish FVG boxes.      htfBearBoxColor (series color) : Color for HTF Bearish FVG boxes.      htfMitigatedBearBoxColor (series color) : Color for mitigated HTF Bearish FVG boxes.      htfBoxLengthBars (series int) : Length of HTF FVG boxes in bars (if not extended).      shouldExtendHtfBoxes (series bool) : Whether to extend HTF FVG boxes to the right.      shouldShowHtfBoxLabels (series bool) : Whether to show labels on HTF FVG boxes.      shouldShowHtfBoxBorder (series bool) : Whether to show a border for HTF FVG boxes.      htfBoxBorderWidth (series int) : Border width for HTF FVG boxes.      htfBoxBorderStyle (series string) : Border style for HTF FVG boxes.      htfBoxBorderColor (series color) : Border color for HTF FVG boxes.      shouldShowHtfMidpoint (series bool) : Whether to show the midline for HTF FVGs.      htfMidLineWidthInput (series int) : Width of the HTF FVG midline.      htfMidpointLineStyleInput (series string) : Style of the HTF FVG midline.      htfMidpointColorInput (series color) : Color of the HTF FVG midline.      shouldShowHtfMitigationLine (series bool) : Whether to show the mitigation line for HTF FVGs. (Line always extends if shown)      htfMitLineWidthInput (series int) : Width of the HTF FVG mitigation line.      htfMitigationLineStyleInput (series string) : Style of the HTF FVG mitigation line.      htfMitigationLineColorInput (series color) : Color of the HTF FVG mitigation line.      shouldShowHtfMitLineLabels (series bool) : Whether to show labels on HTF FVG mitigation lines.      htfMitLineLabelOffsetX (series float) : The horizontal offset value for the HTF mitigation line's label.      shouldKeepHtfMitigatedLines (series bool) : Whether to keep showing mitigation lines of fully mitigated HTF FVGs.      htfMitigatedMitLineColor (series color) : Color for kept mitigation lines of mitigated HTF FVGs.      htfTfString (series string) : Display string for the HTF (e.g., "HTF").
Pine Script® kütüphanesi
no1x tarafından
Order Block Overlapping Drawing [TradingFinder]🔵 Introduction Technical analysis is a fundamental tool in financial markets, helping traders identify key areas on price charts to make informed trading decisions. The ICT (Inner Circle Trader) style, developed by Michael Huddleston, is one of the most advanced methods in this field. It enables traders to precisely identify and exploit critical zones such as Order Blocks, Breaker Blocks, Fair Value Gaps (FVGs), and Inversion Fair Value Gaps (IFVGs). To streamline and simplify the use of these key areas, a library has been developed in Pine Script, the scripting language for the TradingView platform. This library allows you to automatically detect overlapping zones between Order Blocks and other similar areas, and visually display them on your chart. This tool is particularly useful for creating indicators like Balanced Price Range (BPR) and ICT Unicorn Model. 🔵 How to Use This section explains how to use the Pine Script library. This library assists you in easily identifying and analyzing overlapping areas between Order Blocks and other zones, such as Breaker Blocks and Fair Value Gaps. To add "Order Block Overlapping Drawing", you must first add the following code to your script. import TFlab/OrderBlockOverlappingDrawing/1 🟣 Inputs The library includes the "OBOverlappingDrawing" function, which you can use to detect and display overlapping zones. This function identifies and draws overlapping zones based on the Order Block type, trigger conditions, previous and current prices, and other relevant parameters. 🟣 Parameters OBOverlappingDrawing(OBType , TriggerConditionOrigin, distalPrice_Pre, proximalPrice_Pre , distalPrice_Curr, proximalPrice_Curr, Index_Curr , OBValidGlobal, OBValidDis, MitigationLvL, ShowAll, Show, ColorZone) => OBType (string) TriggerConditionOrigin (bool) distalPrice_Pre (float) proximalPrice_Pre (float) distalPrice_Curr (float) proximalPrice_Curr (float) Index_Curr (int) OBValidGlobal (bool) OBValidDis (int) MitigationLvL (string) ShowAll (bool) Show (bool) ColorZone (color) In this example, various parameters are defined to detect overlapping zones and draw them on the chart. Based on these settings, the overlapping areas will be automatically drawn on the chart. OBType : All order blocks are summarized into two types: "Supply" and "Demand." You should input your Current order block type in this parameter. Enter "Demand" for drawing demand zones and "Supply" for drawing supply zones. TriggerConditionOrigin : Input the condition under which you want the Current order block to be drawn in this parameter. distalPrice_Pre : Generally, if each zone is formed by two lines, the farthest line from the price is termed Pervious "Distal." This input receives the price of the "Distal" line. proximalPrice_Pre : Generally, if each zone is formed by two lines, the nearest line to the price is termed Previous "Proximal" line. distalPrice_Curr : Generally, if each zone is formed by two lines, the farthest line from the price is termed Current "Distal." This input receives the price of the "Distal" line. proximalPrice_Curr : Generally, if each zone is formed by two lines, the nearest line to the price is termed Current "Proximal" line. Index_Curr : This input receives the value of the "bar_index" at the beginning of the order block. You should store the "bar_index" value at the occurrence of the condition for the Current order block to be drawn and input it here. OBValidGlobal : This parameter is a boolean in which you can enter the condition that you want to execute to stop drawing the block order. If you do not have a special condition, you should set it to True. OBValidDis : Order blocks continue to be drawn until a new order block is drawn or the order block is "Mitigate." You can specify how many candles after their initiation order blocks should continue. If you want no limitation, enter the number 4998. MitigationLvL : This parameter is a string. Its inputs are one of "Proximal", "Distal" or "50 % OB" modes, which you can enter according to your needs. The "50 % OB" line is the middle line between distal and proximal. ShowAll : This is a boolean parameter, if it is "true" the entire order of blocks will be displayed, and if it is "false" only the last block order will be displayed. Show : You may need to manage whether to display or hide order blocks. When this input is "On", order blocks are displayed, and when it's "Off", order blocks are not displayed. ColorZone : You can input your preferred color for drawing order blocks. 🟣 Output Mitigation Alerts : This library allows you to leverage Mitigation Alerts to detect specific conditions that could lead to trend reversals. These alerts help you react promptly in your trades, ensuring better management of market shifts. 🔵 Conclusion The Pine Script library provided is a powerful tool for technical analysis, especially in the ICT style. It enables you to detect overlapping zones between Order Blocks and other significant areas like Breaker Blocks and Fair Value Gaps, improving your trading strategies. By utilizing this tool, you can perform more precise analysis and manage risks effectively in your trades.
Pine Script® kütüphanesi
TFlab tarafından
2
FVG Detector LibraryLibrary "FVG Detector Library" 🔵 Introduction To save time and improve accuracy in your scripts for identifying Fair Value Gaps (FVGs), you can utilize this library. Apart from detecting and plotting FVGs, one of the most significant advantages of this script is the ability to filter FVGs, which you'll learn more about below. Additionally, the plotting of each FVG continues until either a new FVG occurs or the current FVG is mitigated. 🔵 Definition Fair Value Gap (FVG) refers to a situation where three consecutive candlesticks do not overlap. Based on this definition, the minimum conditions for detecting a fair gap in the ascending scenario are that the minimum price of the last candlestick should be greater than the maximum price of the third candlestick, and in the descending scenario, the maximum price of the last candlestick should be smaller than the minimum price of the third candlestick. If the filter is turned off, all FVGs that meet at least the minimum conditions are identified. This mode is simplistic and results in a high number of identified FVGs. If the filter is turned on, you have four options to filter FVGs : 1. Very Aggressive : In addition to the initial condition, another condition is added. For ascending FVGs, the maximum price of the last candlestick should be greater than the maximum price of the middle candlestick. Similarly, for descending FVGs, the minimum price of the last candlestick should be smaller than the minimum price of the middle candlestick. In this mode, a very small number of FVGs are eliminated. 2. Aggressive : In addition to the conditions of the Very Aggressive mode, in this mode, the size of the middle candlestick should not be small. This mode eliminates more FVGs compared to the Very Aggressive mode. 3. Defensive : In addition to the conditions of the Very Aggressive mode, in this mode, the size of the middle candlestick should be relatively large, and most of it should consist of the body. Also, for identifying ascending FVGs, the second and third candlesticks must be positive, and for identifying descending FVGs, the second and third candlesticks must be negative. In this mode, a significant number of FVGs are eliminated, and the remaining FVGs have a decent quality. 4. Very Defensive : In addition to the conditions of the Defensive mode, the first and third candlesticks should not resemble very small-bodied doji candlesticks. In this mode, the majority of FVGs are filtered out, and the remaining ones are of higher quality. By default, we recommend using the Defensive mode. 🔵 How to Use 🟣 Parameters To utilize this library, you need to provide four input parameters to the function. "FVGFilter" determines whether you wish to apply a filter on FVGs or not. The possible inputs for this parameter are "On" and "Off", provided as strings. "FVGFilterType" determines the type of filter to be applied to the found FVGs. These filters include four modes: "Very Defensive", "Defensive", "Aggressive", and "Very Aggressive", respectively exhibiting decreasing sensitivity and indicating a higher number of Fair Value Gaps (FVG). The parameter "ShowDeFVG" is a Boolean value defined as either "true" or "false". If this value is "true", FVGs are shown during the Bullish Trend; however, if it is "false", they are not displayed. The parameter "ShowSuFVG" is a Boolean value defined as either "true" or "false". If this value is "true", FVGs are displayed during the Bearish Trend; however, if it is "false", they are not displayed. FVGDetector(FVGFilter, FVGFilterType, ShowDeFVG, ShowSuFVG)   Parameters:      FVGFilter (string)      FVGFilterType (string)      ShowDeFVG (bool)      ShowSuFVG (bool) 🟣 Import Library You can use the "FVG Detector" library in your script using the following expression: import TFlab/FVGDetectorLibrary/1 as FVG 🟣 Input Parameters The descriptions related to the input parameters were provided in the "Parameter" section. In this section, for your convenience, the code related to the inputs is also included, and you can copy and paste it into your script. PFVGFilter = input.string('On', 'FVG Filter', ) PFVGFilterType = input.string('Defensive', 'FVG Filter Type', ) PShowDeFVG = input.bool(true, ' Show Demand FVG') PShowSuFVG = input.bool(true, ' Show Supply FVG') 🟣 Call Function You can copy the following code into your script to call the FVG function. This code is based on the naming conventions provided in the "Input Parameter" section, so if you want to use exactly this code, you should have similar parameter names or have copied the "Input Parameter" values. FVG.FVGDetector(PFVGFilter, PFVGFilterType, PShowDeFVG, PShowSuFVG)
Pine Script® kütüphanesi
TFlab tarafından
4
lib_fvgLibrary "lib_fvg" further expansion of my object oriented library toolkit. This lib detects Fair Value Gaps and returns them as objects. Drawing them is a separate step so the lib can be used with securities. It also allows for usage of current/close price to detect fill/invalidation of a gap and to adjust the fill level dynamically. FVGs can be detected while forming and extended indefinitely while they're unfilled. method draw(this)   Namespace types: FVG   Parameters:      this (FVG) method draw(fvgs)   Namespace types: FVG   Parameters:      fvgs (FVG ) is_fvg(mode, precondition, filter_insignificant, filter_insignificant_atr_factor, live)   Parameters:      mode (int) : switch for detection 1 for bullish FVGs, -1 for bearish FVGs      precondition (bool) : allows for other confluences to block/enable detection      filter_insignificant (bool) : allows to ignore small gaps      filter_insignificant_atr_factor (float) : allows to adjust how small (compared to a 50 period ATR)      live (bool) : allows to detect FVGs while the third bar is forming -> will cause repainting   Returns: a tuple of (bar_index of gap bar, gap top, gap bottom) create_fvg(mode, idx, top, btm, filled_at_pc, config)   Parameters:      mode (int) : switch for detection 1 for bullish FVGs, -1 for bearish FVGs      idx (int) : the bar_index of the FVG gap bar      top (float) : the top level of the FVG      btm (float) : the bottom level of the FVG      filled_at_pc (float) : the ratio (0-1) that the fill source needs to retrace into the gap to consider it filled/invalidated/ready for removal      config (FVGConfig) : the plot configuration/styles for the FVG   Returns: a new FVG object if there was a new FVG, else na detect_fvg(mode, filled_at_pc, precondition, filter_insignificant, filter_insignificant_atr_factor, live, config)   Parameters:      mode (int) : switch for detection 1 for bullish FVGs, -1 for bearish FVGs      filled_at_pc (float)      precondition (bool) : allows for other confluences to block/enable detection      filter_insignificant (bool) : allows to ignore small gaps      filter_insignificant_atr_factor (float) : allows to adjust how small (compared to a 50 period ATR)      live (bool) : allows to detect FVGs while the third bar is forming -> will cause repainting      config (FVGConfig)   Returns: a new FVG object if there was a new FVG, else na method update(this, fill_src)   Namespace types: FVG   Parameters:      this (FVG)      fill_src (float) : allows for usage of different fill source series, e.g. high for bearish FVGs, low vor bullish FVGs or close for both method update(all, fill_src)   Namespace types: FVG   Parameters:      all (FVG )      fill_src (float) method remove_filled(unfilled_fvgs)   Namespace types: FVG   Parameters:      unfilled_fvgs (FVG ) method delete(this)   Namespace types: FVG   Parameters:      this (FVG) method delete_filled_fvgs_buffered(filled_fvgs, max_keep)   Namespace types: FVG   Parameters:      filled_fvgs (FVG )      max_keep (int) : the number of filled, latest FVGs to retain on the chart. FVGConfig   Fields:      box_args (|robbatt/lib_plot_objects/36;BoxArgs|#OBJ)      line_args (|robbatt/lib_plot_objects/36;LineArgs|#OBJ)      box_show (series__bool)      line_show (series__bool)      keep_filled (series__bool)      extend (series__bool) FVG   Fields:      config (|FVGConfig|#OBJ)      startbar (series__integer)      mode (series__integer)      top (series__float)      btm (series__float)      center (series__float)      size (series__float)      fill_size (series__float)      fill_lvl_target (series__float)      fill_lvl_current (series__float)      fillbar (series__integer)      filled (series__bool)      _fvg_box (|robbatt/lib_plot_objects/36;Box|#OBJ)      _fill_line (|robbatt/lib_plot_objects/36;Line|#OBJ)
Pine Script® kütüphanesi
robbatt tarafından
4