Sessions [Plug&Play]This indicator automatically highlights the three major FX trading sessions—Asia, London, and New York—on your chart and, at the close of each session, draws right-extended horizontal rays at that session’s high and low. It’s designed to help you visually identify when price is trading within each session’s range and to quickly see where the highest and lowest prices occurred before the next major session begins.
Key Features:
Session Boxes
Draws a semi-transparent box around each session’s timeframe (Asia, London, New York) based on your local UTC offset.
Each box dynamically expands in real time: as new candles form during the session, the box’s top and bottom edges update to match the highest high and lowest low seen so far in that session.
When the session ends, the box remains on your chart, anchored to the exact candles that formed its boundaries.
High/Low Rays
As soon as a session closes (e.g., London session ends at 17:00 UTC+0 by default), two horizontal rays are drawn at that session’s final high and low.
These rays are “pinned” to the exact candles where the high/low occurred, so they stay in place when you scroll or zoom.
Each ray extends indefinitely to the right, providing a clear reference of the key supply/demand levels created during that session.
Session Labels
Optionally places a small “London,” “New York,” or “Asia” label at the top edge of each completed session’s box.
Labels are horizontally centered within the session’s box and use a contrasting, easy-to-read font color.
Customizable Appearance
Show/Hide Each Session: Toggle display of London, New York, and Asia sessions separately.
Time Ranges: By default, London is 08:00–17:00 (UTC), New York is 13:00–22:00 (UTC), and Asia is 00:00–07:00 (UTC). You can override each session’s start/end times using the “Time Range” picker.
Color & Opacity: Assign custom colors to each session. Choose a global “Dark,” “Medium,” or “Light” opacity preset to adjust box fill transparency and border shading.
Show/Hide Labels & Outlines: Turn the text labels and the box borders on or off independently.
UTC Offset Support
If your local broker feed or price data is not in UTC, simply adjust the “UTC Offset (+/–)” input. The indicator will recalculate session start/end times relative to your chosen offset.
How to Use:
Add the Indicator:
Open TradingView’s Pine Editor, paste in this script, and click “Add to Chart.”
By default, you’ll see three translucent boxes appear once each session begins (Asia, London, New York).
Watch in Real Time:
As soon as a session starts, its box will appear anchored to the first candle. The top and bottom of the box expand if new extremes occur.
When the session closes, the final box remains visible and two horizontal rays mark that session’s high and low.
Analyze Key Levels:
Use the high- and low-level rays to gauge session liquidity zones—areas where stop orders, breakouts, or reversals often occur.
For example, if London’s high is significantly above current price, it may act as resistance in the New York session.
Customize to Your Needs:
Toggle specific sessions on/off (e.g., if you only care about London and New York).
Change each session’s color to match your chart theme.
Adjust the “UTC Offset” so sessions align with your local time.
Disable labels or box borders if you prefer a cleaner look.
Inputs Overview:
Show London/New York/Asia Session (bool): Show or hide each session’s box and its high/low rays.
Time Range (session): Defines the start/end of each session in “HHMM–HHMM” (24h) format.
Colour (color): Custom color for each session’s box fill, border, and high/low rays.
Show Session Labels (bool): Toggle the “London,” “New York,” “Asia” text that appears at the top of each completed box.
Show Range Outline (bool): Toggle the box border (if off, only a translucent fill is drawn).
Opacity Preset (Dark/Medium/Light): Controls transparency of box fill and border.
UTC Offset (+/–) (int): Adjusts session times for different time zones (e.g., +1 for UTC+1).
Why It’s Useful:
Quickly Identify Session Activity: Visually distinguish when each major trading session is active, then compare price action across sessions.
Pinpoint High/Low Liquidity Levels: Drawn rays highlight where the market hit its extremes—critical zones for stop orders or breakout entries.
Multi-Timeframe Context: By seeing historical session boxes and rays, you can locate recurring supply/demand areas, overlap zones, or session re-tests.
Fully Automated Workflow: Once added to your chart, the script does all the work of tracking session boundaries and drawing high/low lines—no manual box or line drawing necessary.
Example Use Cases:
London Breakout Traders: See where London’s high/low formed, then wait for price to revisit those levels during the New York session.
Range Breakout Strategies: If price consolidates inside the London box, use the boxed extremes as immediate targets for breakout entries.
Intraday Liquidity Swings: During quieter hours, watch Asia’s high/low to identify potential support/resistance before London’s opening.
Overlap Zones: Compare London’s range with Asia’s range to find areas of confluence—high-probability reversal or continuation zones.
Komut dosyalarını "top" için ara
MirPapa_Library_ICTLibrary "MirPapa_Library_ICT"
GetHTFoffsetToLTFoffset(_offset, _chartTf, _htfTf)
GetHTFoffsetToLTFoffset
@description Adjust an HTF offset to an LTF offset by calculating the ratio of timeframes.
Parameters:
_offset (int) : int The HTF bar offset (0 means current HTF bar).
_chartTf (string) : string The current chart’s timeframe (e.g., "5", "15", "1D").
_htfTf (string) : string The High Time Frame string (e.g., "60", "1D").
@return int The corresponding LTF bar index. Returns 0 if the result is negative.
IsConditionState(_type, _isBull, _level, _open, _close, _open1, _close1, _low1, _low2, _low3, _low4, _high1, _high2, _high3, _high4)
IsConditionState
@description Evaluate a condition state based on type for COB, FVG, or FOB.
Overloaded: first signature handles COB, second handles FVG/FOB.
Parameters:
_type (string) : string Condition type ("cob", "fvg", "fob").
_isBull (bool) : bool Direction flag: true for bullish, false for bearish.
_level (int) : int Swing level (only used for COB).
_open (float) : float Current bar open price (only for COB).
_close (float) : float Current bar close price (only for COB).
_open1 (float) : float Previous bar open price (only for COB).
_close1 (float) : float Previous bar close price (only for COB).
_low1 (float) : float Low 1 bar ago (only for COB).
_low2 (float) : float Low 2 bars ago (only for COB).
_low3 (float) : float Low 3 bars ago (only for COB).
_low4 (float) : float Low 4 bars ago (only for COB).
_high1 (float) : float High 1 bar ago (only for COB).
_high2 (float) : float High 2 bars ago (only for COB).
_high3 (float) : float High 3 bars ago (only for COB).
_high4 (float) : float High 4 bars ago (only for COB).
@return bool True if the specified condition is met, false otherwise.
IsConditionState(_type, _isBull, _pricePrev, _priceNow)
IsConditionState
@description Evaluate FVG or FOB condition based on price movement.
Parameters:
_type (string) : string Condition type ("fvg", "fob").
_isBull (bool) : bool Direction flag: true for bullish, false for bearish.
_pricePrev (float) : float Previous price (for FVG/FOB).
_priceNow (float) : float Current price (for FVG/FOB).
@return bool True if the specified condition is met, false otherwise.
IsSwingHighLow(_isBull, _level, _open, _close, _open1, _close1, _low1, _low2, _low3, _low4, _high1, _high2, _high3, _high4)
IsSwingHighLow
@description Public wrapper for isSwingHighLow.
Parameters:
_isBull (bool) : bool Direction flag: true for bullish, false for bearish.
_level (int) : int Swing level (1 or 2).
_open (float) : float Current bar open price.
_close (float) : float Current bar close price.
_open1 (float) : float Previous bar open price.
_close1 (float) : float Previous bar close price.
_low1 (float) : float Low 1 bar ago.
_low2 (float) : float Low 2 bars ago.
_low3 (float) : float Low 3 bars ago.
_low4 (float) : float Low 4 bars ago.
_high1 (float) : float High 1 bar ago.
_high2 (float) : float High 2 bars ago.
_high3 (float) : float High 3 bars ago.
_high4 (float) : float High 4 bars ago.
@return bool True if swing condition is met, false otherwise.
AddBox(_left, _right, _top, _bot, _xloc, _colorBG, _colorBD)
AddBox
@description Draw a rectangular box on the chart with specified coordinates and colors.
Parameters:
_left (int) : int Left bar index for the box.
_right (int) : int Right bar index for the box.
_top (float) : float Top price coordinate for the box.
_bot (float) : float Bottom price coordinate for the box.
_xloc (string) : string X-axis location type (e.g., xloc.bar_index).
_colorBG (color) : color Background color for the box.
_colorBD (color) : color Border color for the box.
@return box Returns the created box object.
Addline(_x, _y, _xloc, _color, _width)
Addline
@description Draw a vertical or horizontal line at specified coordinates.
Parameters:
_x (int) : int X-coordinate for start (bar index).
_y (int) : float Y-coordinate for start (price).
_xloc (string) : string X-axis location type (e.g., xloc.bar_index).
_color (color) : color Line color.
_width (int) : int Line width.
@return line Returns the created line object.
Addline(_x, _y, _xloc, _color, _width)
Parameters:
_x (int)
_y (float)
_xloc (string)
_color (color)
_width (int)
Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)
Parameters:
_x1 (int)
_y1 (int)
_x2 (int)
_y2 (int)
_xloc (string)
_color (color)
_width (int)
Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)
Parameters:
_x1 (int)
_y1 (int)
_x2 (int)
_y2 (float)
_xloc (string)
_color (color)
_width (int)
Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)
Parameters:
_x1 (int)
_y1 (float)
_x2 (int)
_y2 (int)
_xloc (string)
_color (color)
_width (int)
Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)
Parameters:
_x1 (int)
_y1 (float)
_x2 (int)
_y2 (float)
_xloc (string)
_color (color)
_width (int)
AddlineMid(_type, _left, _right, _top, _bot, _xloc, _color, _width)
AddlineMid
@description Draw a midline between top and bottom for FVG or FOB types.
Parameters:
_type (string) : string Type identifier: "fvg" or "fob".
_left (int) : int Left bar index for midline start.
_right (int) : int Right bar index for midline end.
_top (float) : float Top price of the region.
_bot (float) : float Bottom price of the region.
_xloc (string) : string X-axis location type (e.g., xloc.bar_index).
_color (color) : color Line color.
_width (int) : int Line width.
@return line or na Returns the created line or na if type is not recognized.
GetHtfFromLabel(_label)
GetHtfFromLabel
@description Convert a Korean HTF label into a Pine Script timeframe string via handler library.
Parameters:
_label (string) : string The Korean label (e.g., "5분", "1시간").
@return string Returns the corresponding Pine Script timeframe (e.g., "5", "60").
IsChartTFcomparisonHTF(_chartTf, _htfTf)
IsChartTFcomparisonHTF
@description Determine whether a given HTF is greater than or equal to the current chart timeframe.
Parameters:
_chartTf (string) : string Current chart timeframe (e.g., "5", "15", "1D").
_htfTf (string) : string HTF timeframe (e.g., "60", "1D").
@return bool True if HTF ≥ chartTF, false otherwise.
CreateBoxData(_type, _isBull, _useLine, _top, _bot, _xloc, _colorBG, _colorBD, _offset, _htfTf, htfBarIdx, _basePoint)
CreateBoxData
@description Create and draw a box and optional midline for given type and parameters. Returns success flag and BoxData.
Parameters:
_type (string) : string Type identifier: "fvg", "fob", "cob", or "sweep".
_isBull (bool) : bool Direction flag: true for bullish, false for bearish.
_useLine (bool) : bool Whether to draw a midline inside the box.
_top (float) : float Top price of the box region.
_bot (float) : float Bottom price of the box region.
_xloc (string) : string X-axis location type (e.g., xloc.bar_index).
_colorBG (color) : color Background color for the box.
_colorBD (color) : color Border color for the box.
_offset (int) : int HTF bar offset (0 means current HTF bar).
_htfTf (string) : string HTF timeframe string (e.g., "60", "1D").
htfBarIdx (int) : int HTF bar_index (passed from HTF request).
_basePoint (float) : float Base point for breakout checks.
@return tuple(bool, BoxData) Returns a boolean indicating success and the created BoxData struct.
ProcessBoxDatas(_datas, _useMidLine, _closeCount, _colorClose)
ProcessBoxDatas
@description Process an array of BoxData structs: extend, record volume, update stage, and finalize boxes.
Parameters:
_datas (array) : array Array of BoxData objects to process.
_useMidLine (bool) : bool Whether to update the midline endpoint.
_closeCount (int) : int Number of touches required to close the box.
_colorClose (color) : color Color to apply when a box closes.
@return void No return value; updates are in-place.
BoxData
Fields:
_isActive (series bool)
_isBull (series bool)
_box (series box)
_line (series line)
_basePoint (series float)
_boxTop (series float)
_boxBot (series float)
_stage (series int)
_isStay (series bool)
_volBuy (series float)
_volSell (series float)
_result (series string)
LineData
Fields:
_isActive (series bool)
_isBull (series bool)
_line (series line)
_basePoint (series float)
_stage (series int)
_isStay (series bool)
_result (series string)
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.
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").
Candle Breakout Oscillator [LuxAlgo]The Candle Breakout Oscillator tool allows traders to identify the strength and weakness of the three main market states: bullish, bearish, and choppy.
Know who controls the market at any given moment with an oscillator display with values ranging from 0 to 100 for the three main plots and upper and lower thresholds of 80 and 20 by default.
🔶 USAGE
The Candle Breakout Oscillator represents the three main market states, with values ranging from 0 to 100. By default, the upper and lower thresholds are set at 80 and 20, and when a value exceeds these thresholds, a colored area is displayed for the trader's convenience.
This tool is based on pure price action breakouts. In this context, we understand a breakout as a close above the last candle's high or low, which is representative of market strength. All other close positions in relation to the last candle's limits are considered weakness.
So, when the bullish plot (in green) is at the top of the oscillator (values above 80), it means that the bullish breakouts (close below the last candle low) are at their maximum value over the calculation window, indicating an uptrend. The same interpretation can be made for the bearish plot (in red), indicating a downtrend when high.
On the other hand, weakness is indicated when values are below the lower threshold (20), indicating that breakouts are at their minimum over the last 100 candles. Below are some examples of the possible main interpretations:
There are three main things to look for in this oscillator:
Value reaches extreme
Value leaves extreme
Bullish/Bearish crossovers
As we can see on the chart, before the first crossover happens the bears come out of strength (top) and the bulls come out of weakness (bottom), then after the crossover the bulls reach strength (top) and the bears weakness (bottom), this process is repeated in reverse for the second crossover.
The other main feature of the oscillator is its ability to identify periods of sideways trends when the sideways values have upper readings above 80, and trending behavior when the sideways values have lower readings below 20. As we just saw in the case of bullish vs. bearish, sideways values signal a change in behavior when reaching or leaving the extremes of the oscillator.
🔶 DETAILS
🔹 Data Smoothing
The tool offers up to 10 different smoothing methods. In the chart above, we can see the raw data (smoothing: None) and the RMA, TEMA, or Hull moving averages.
🔹 Data Weighting
Users can add different weighting methods to the data. As we can see in the image above, users can choose between None, Volume, or Price (as in Price Delta for each breakout).
🔶 SETTINGS
Window: Execution window, 100 candles by default
🔹 Data
Smoothing Method: Choose between none or ten moving averages
Smoothing Length: Length for the moving average
Weighting Method: Choose between None, Volume, or Price
🔹 Thresholds
Top: 80 by default
Bottom: 20 by default
Zero Lag Multi Timeframe MACDCommon parts of the Multi Time Frame MACD
Why This MACD is Special
Traditional MACD (Moving Average Convergence Divergence) is a powerful trend-following indicator, but it has a key limitation: it only reflects price action on a single timeframe. Traders who rely on top-down analysis—analyzing higher timeframes first before moving to lower ones—often face a frustrating delay.
The Problem with Traditional Multi-Timeframe MACD with top down analysis:
If you’re on a 5-minute chart and want to see the 1-hour MACD, you must wait for 12 candles (1 hour) to close before the MACD updates.
This lag means you miss real-time signals and react too late to trend changes.
The Zero Lag Multi-Timeframe MACD solves this by using a custom time-adjusted formula (developed by CoffeeShopCrypto) that projects higher timeframe MACD values onto lower timeframe charts in real time.
How Traders Normally Use MACD
Single-Timeframe MACD (Traditional Approach)
Used for trend identification (bullish/bearish).
Crossovers (MACD line crossing signal line) signal potential entries.
Divergences (price vs. MACD direction) warn of trend exhaustion.
Top-Down Analysis with Standard MACD (Manual Switching)
1. Check higher timeframe (e.g., 1-hour) for trend direction.
2. Switch to lower timeframe (e.g., 5-minute) for entries.
Problem: You must constantly switch charts and wait for higher timeframe candles to close.
This MACD Eliminates the Need for Switching
Higher timeframe MACD is plotted in real time on your lower timeframe chart.
No waiting for candle closes—instant trend confirmation.
Single-chart top-down analysis without switching timeframes.
How to Use This MACD for Trading
Since the MACD is an averaging indicator, it works best when trading with the trend. This version enhances that by showing two trends at once:
Lower Timeframe (LTF) MACD – Your current chart’s trend.
Higher Timeframe (HTF) MACD – The dominant trend.
Key Trading Rules
1. Strong Uptrend Setup (Best for Long Entries)
HTF MACD line is rising & above zero (strong bullish momentum).
LTF MACD line is also rising (confirms alignment).
Entry: Look for LTF MACD to cross above signal line.
Long Entry Confirmation:
When both the High Timeframe and Low Timeframe MACD Lines are moving in the same direction, this is a confirmation that both the HTF is matching the direction of the LTF.
In this example both MACD Lines are moving long so we are only looking to take long entries at this point forward.
Short Entry Confirmation:
When both the High Timeframe and Low Timeframe MACD Lines are moving in the same direction, this is a confirmation that both the HTF is matching the direction of the LTF.
In this example both MACD Lines are moving short so we are only looking to take long entries at this point forward.
2. Potential Reversal or Weak Uptrend
Trend Divergence Confirmation
This example shows you a confirmation of divergence between the trends. Its best to watch for a continuation of the previous major trend. In this example, we just came off a downtrend with a GAP DOWN.
How to see it: (Trend Divergence)
Two things will help you confirm this divergence
1.Notice the LTF and HTF MACD are moving away from each other.
2. Both the HTF and LTF Histogram are shrinking.
This is an expression of lack of trend.
What to do:
High Timeframe Trends are always the lead so wait for the Low Timeframe to catch up to the High Timeframe trend.
Limitations:
The Exponential Moving Average calculation can only be applied to the Low Timeframe MACD because of the way its weighted against more recent price action and closing values.
This same EMA calculation can not be applied to the High Timeframe MACD as its being recalculated and the result means you can not weigh values against its current plot point.
Low Timeframe MACD can use EMA / SMA
High Timeframe MACD can only use SMA
BBands Channels with EMAs# **BBands Channels with EMAs Indicator Explanation**
---
## **📌 Feature Overview**
### **1. Bollinger Bands**
- **Basis Line**: 160-period SMA (adjustable)
- **Inner Bands**:
- **Upper**: Basis + 2× Standard Deviation
- **Lower**: Basis - 2× Standard Deviation
- **Outer Bands**:
- **Upper Top**: Basis + 3× Standard Deviation
- **Lower Low**: Basis - 3× Standard Deviation
- **Fill Effect**: Semi-transparent black fill between inner and outer bands
### **2. Exponential Moving Averages (EMAs)**
| Period | Purpose | Line Style |
|--------------|-----------------------------|------------------|
| **EMA 27** | Short-term trend | Thin line |
| **EMA 120** | Short-to-medium-term trend | Medium line |
| **EMA 200** | Medium-term trend | Medium line |
| **EMA 1120** | Ultra-long-term trend | Thick line |
---
## **⚙️ Parameter Settings**
### **Bollinger Bands**
| Parameter | Default | Description |
|---------------|---------|--------------------------------------|
| `length` | 160 | SMA calculation period |
| `mult` | 2.0 | Standard deviation multiplier (inner bands) |
| `multOuter` | 3.0 | Standard deviation multiplier (outer bands) |
| `offset` | 0 | Time offset for plots (±500 bars) |
### **Exponential Moving Averages (EMAs)**
| Parameter | Default | Description |
|-----------------|---------|---------------------------|
| `ema1Length` | 27 | EMA 1 period |
| `ema2Length` | 120 | EMA 2 period |
| `ema3Length` | 200 | EMA 3 period |
| `ema4Length` | 1120 | EMA 4 period |
---
## **📊 Use Cases**
### **1. Trend Confirmation**
- **Bullish Trend**: Price above EMA200 + Bollinger Band expansion
- **Bearish Trend**: Price below EMA200 + Bollinger Band expansion
### **2. Overbought/Oversold Signals**
- **Upper Band Touch**: Price reaches Upper Top → Potential overbought
- **Lower Band Touch**: Price reaches Lower Low → Potential oversold
### **3. Volatility Strategies**
- **Band Squeeze**: Narrowing gap between bands → Breakout warning
- **Band Expansion**: Price breaks outer band → Trend acceleration
---
**✅ Summary**
This indicator combines **Bollinger Bands + Multi-period EMAs** for:
- Trend tracking
- Volatility analysis
- Multi-timeframe strategies
---
# **BBands Channels with EMAs 指標說明**
---
## **📌 功能概述**
### **1. 布林通道 (Bollinger Bands)**
- **基礎線 (Basis Line)**: 160週期SMA（可調整）
- **內通道 (Inner Bands)**:
- 上軌 (Upper): 基礎線 + 2倍標準差
- 下軌 (Lower): 基礎線 - 2倍標準差
- **外通道 (Outer Bands)**:
- 上外軌 (Upper Top): 基礎線 + 3倍標準差
- 下外軌 (Lower Low): 基礎線 - 3倍標準差
- **填充效果**: 內外通道間半透明黑色填充
### **2. 指數移動平均線 (EMAs)**
| 週期 | 用途 | 線條樣式 |
|-------------|-------------------|-----------------|
| **EMA 27** | 短期趨勢 | 細線 |
| **EMA 120** | 中短期趨勢 | 中等線 |
| **EMA 200** | 中期趨勢 | 中等線 |
| **EMA 1120**| 超長期趨勢 | 粗線 |
---
## **⚙️ 參數設定**
### **布林通道 (Bollinger Bands)**
| 參數名 | 預設值 | 說明 |
|-------------|--------|---------------------------|
| `length` | 160 | SMA計算週期 |
| `mult` | 2.0 | 內通道標準差倍數 |
| `multOuter` | 3.0 | 外通道標準差倍數 |
| `offset` | 0 | 線圖時間偏移（±500根K棒） |
### **指數移動平均線 (EMAs)**
| 參數名 | 預設值 | 說明 |
|----------------|---------|-------------------|
| `ema1Length` | 27 | 第一條EMA週期 |
| `ema2Length` | 120 | 第二條EMA週期 |
| `ema3Length` | 200 | 第三條EMA週期 |
| `ema4Length` | 1120 | 第四條EMA週期 |
---
## **📊 應用場景**
### **1. 趨勢確認**
- **多頭趨勢**: 價格在EMA200上方 + 布林通道擴張
- **空頭趨勢**: 價格在EMA200下方 + 布林通道擴張
### **2. 超買超賣信號**
- **觸及外軌**: 價格觸碰Upper Top → 可能超買
- **觸及下軌**: 價格觸碰Lower Low → 可能超賣
### **3. 波動率策略**
- **通道收窄**: 內外通道間距縮小 → 突破預警
- **通道擴張**: 價格突破外軌 → 趨勢加速
---
**✅ 總結**
本指標透過**布林通道+多週期EMA**的組合，適用於：
- 趨勢跟蹤
- 波動率分析
- 多時間框架策略
MyBoxMyBox - Display Text with Customizable Position and Size
This indicator allows you to display a customizable message on your chart, with adjustable font size, position, and background color. You can input your desired message, choose the font size (small, normal, large, huge), and place it in various positions on the chart (top-left, top-center, top-right, etc.). Additionally, you can customize the background color of the box where the text is displayed.
Features:
Display a custom message on your chart (e.g., "FOMO Incoming!!").
Adjustable font size (small, normal, large, huge).
Choose from multiple position options for text placement (e.g., top-left, middle-center, bottom-right).
Customize the box background color for better visibility.
Perfect for displaying personal notes, reminders, or trading signals while analyzing the market!
CyberCandle SwiftEdgeCyberCandle SwiftEdge
Overview
CyberCandle SwiftEdge is a cutting-edge, AI-inspired trading indicator designed for traders seeking precision and clarity in trend-following and swing trading. Powered by SwiftEdge, it combines Heikin Ashi candles, a gradient-colored Exponential Moving Average (EMA), and a Relative Strength Index (RSI) to deliver clear buy and sell signals. Featuring glowing visuals, dynamic signal icons, and a customizable RSI dashboard in the top-right corner, this script offers a futuristic interface for identifying high-probability trade setups on various timeframes (e.g., 1H, 4H).
What It Does
CyberCandle SwiftEdge integrates three powerful components to generate actionable trading signals:
Heikin Ashi Candles: Smooths price action to highlight trends, reducing market noise and making reversals easier to spot.
Gradient EMA: A 100-period EMA with dynamic color transitions (blue/cyan for uptrends, red/pink for downtrends) to confirm market direction.
RSI Dashboard: A neon-lit display showing RSI levels, indicating overbought (>70), oversold (<30), or neutral (30-70) conditions.
Buy and sell signals are marked with prominent, glowing icons (triangles and arrows) based on trend direction, momentum, and specific Heikin Ashi patterns. The script’s customizable parameters allow traders to tailor the strategy to their preferences, balancing signal frequency and precision.
How It Works
The strategy leverages the synergy of Heikin Ashi, EMA, and RSI to filter trades and highlight opportunities:
Trend Direction: The price must be above the EMA for buy signals (bullish trend) or below for sell signals (bearish trend). The EMA’s gradient color shifts based on its slope, visually reinforcing trend strength.
Momentum Confirmation: RSI must exceed a user-defined threshold (default: 50) for buy signals or fall below it for sell signals, ensuring momentum supports the trade.
Candle Patterns: Buy signals require a green Heikin Ashi candle (close > open), with the two prior candles having minimal upper wicks (≤5% of candle body) and being red (indicating a retracement). Sell signals require a red candle, minimal lower wicks, and two prior green candles.
RSI Dashboard: Positioned in the top-right corner, it features a glowing circle (red for overbought, green for oversold, blue for neutral), the current RSI value, and a status indicator (triangle for extremes, square for neutral). This provides instant momentum insights without cluttering the chart.
By combining Heikin Ashi’s trend clarity, EMA’s directional filter, and RSI’s momentum validation, CyberCandle SwiftEdge minimizes false signals and highlights trades with strong potential. Its vibrant, AI-like visuals make it easy to interpret at a glance.
How to Use It
Add to Chart: In TradingView, search for "CyberCandle SwiftEdge" and add it to your chart. Set the chart to Heikin Ashi candles for optimal compatibility.
Interpret Signals:
Buy Signal: Large green triangles and arrows appear below candles when the price is above the EMA, RSI is above the buy threshold (default: 50), and conditions for a bullish retracement are met. Consider entering a long position with a 1:2 risk/reward ratio.
Sell Signal: Large red triangles and arrows appear above candles when the price is below the EMA, RSI is below the sell threshold (default: 50), and conditions for a bearish retracement are met. Consider entering a short position.
RSI Dashboard: Monitor the top-right dashboard. A red circle (RSI > 70) suggests caution for buys, a green circle (RSI < 30) indicates potential buying opportunities, and a blue circle (RSI 30-70) signals neutrality.
Customize Parameters: Open the indicator’s settings to adjust:
EMA Length (default: 100): Increase (e.g., 200) for longer-term trends or decrease (e.g., 50) for shorter-term sensitivity.
RSI Length (default: 14): Adjust for more (e.g., 7) or less (e.g., 21) responsive momentum signals.
RSI Buy/Sell Thresholds (default: 50): Set higher (e.g., 55) for buys or lower (e.g., 45) for sells to require stronger momentum.
Wick Tolerance (default: 0.05): Increase (e.g., 0.1) to allow larger wicks, generating more signals, or decrease (e.g., 0.02) for stricter conditions.
Require Retracement (default: true): Disable to remove the two-candle retracement requirement, increasing signal frequency.
Trading: Use signals in conjunction with the RSI dashboard and market context. For example, avoid buy signals if the RSI dashboard is red (overbought). Always apply proper risk management, such as setting stop-losses based on recent lows/highs.
What Makes It Original
CyberCandle SwiftEdge stands out due to its futuristic, AI-inspired visual design and user-friendly customization:
Neon Aesthetics: Glowing Heikin Ashi candles, gradient EMA, and dynamic signal icons (triangles and arrows) with RSI-driven transparency create a high-tech, immersive experience.
RSI Dashboard: A compact, top-right display with a neon circle, RSI value, and adaptive status indicator (triangle/square) provides instant momentum insights without cluttering the chart.
Customizability: Users can fine-tune EMA length, RSI parameters, wick tolerance, and retracement requirements via TradingView’s settings, balancing signal frequency and precision.
Integrated Approach: The synergy of Heikin Ashi’s trend clarity, EMA’s directional strength, and RSI’s momentum validation offers a cohesive strategy that reduces false signals.
Why This Combination?
The script combines Heikin Ashi, EMA, and RSI for a complementary effect:
Heikin Ashi smooths price fluctuations, making it ideal for identifying sustained trends and retracements, which are critical for the strategy’s signal logic.
EMA provides a reliable trend filter, ensuring signals align with the broader market direction. Its gradient color enhances visual trend recognition.
RSI adds momentum context, confirming that signals occur during favorable conditions (e.g., RSI > 50 for buys). The dashboard makes RSI intuitive, even for non-technical users.
Together, these components create a balanced system that captures trend reversals after retracements, validated by momentum, with a visually engaging interface that simplifies decision-making.
Tips
Best used on volatile assets (e.g., BTC/USD, EUR/USD) and higher timeframes (1H, 4H) for clearer trends.
Experiment with parameters in the settings to match your trading style (e.g., increase wick tolerance for more signals).
Combine with other analysis (e.g., support/resistance) for higher-confidence trades.
Note
This indicator is for informational purposes and does not guarantee profits. Always backtest and use proper risk management before trading.
FA_PA_LIBLibrary "FA_PA_LIB"
A collection of custom tools & utility functions commonly used for coding Dr Al Brooks, Price Action System with my scripts
getBodySize()
Gets the current candle's body size (in POINTS, divide by 10 to get pips)
Returns: The current candle's body size in POINTS
getTopWickSize()
Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's top wick size in POINTS
getTopWickPercent()
Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: Percent of total candle width that is occupied by the upper wick
getBottomWickSize()
Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's bottom wick size in POINTS
getBottomWickPercent()
Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: Percent of total candle width that is occupied by the lower wick
getBarMidPoint()
Gets the current candle's midpoint wick to wick
Returns: The current candle's mid point
getBodyPercent()
Gets the current candle's body size as a percentage of its entire size including its wicks
Returns: The current candle's body size percentage (00.00)
bullFib(priceLow, priceHigh, fibRatio)
Calculates a bullish fibonacci value
Parameters:
priceLow (float) : The lowest price point
priceHigh (float) : The highest price point
fibRatio (float) : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
bearFib(priceLow, priceHigh, fibRatio)
Calculates a bearish fibonacci value
Parameters:
priceLow (float) : The lowest price point
priceHigh (float) : The highest price point
fibRatio (float) : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
isBr()
Checks if the current bar is a Bear Bar
Returns: A boolean - true if the current bar is bear candle
isBl()
Checks if the current bar is a Bull Bar
Returns: A boolean - true if the current bar is Bull candle
isTrendBar()
Checks if the current bar is a Trend Bar. Candle that its body size is greater than 50% of entire candle size
Returns: A boolean - true if the current bar is Trend candle
isBlTrendBar()
Checks if the current bar is a Bull Trend Bar. Bullish candle that its body size is greater than 50% of entire candle size
Returns: A boolean - true if the current bar is Bull Trend candle
isBrTrendBar()
Checks if the current bar is a Bull Trend Bar. Bullish candle that its body size is greater than 50% of entire candle size
Returns: A boolean - true if the current bar is Bull Trend candle
isBlRevB()
Checks if the current bar is a Bull Reversal Bar. Bullish candle that closes on upper half of candle body
Returns: A boolean - true if the current bar is Bull Reversal candle
isBrRevB()
Checks if the current bar is a Bear Reversal Bar. BulBearish candle that closes on lower half of candle body
Returns: A boolean - true if the current bar is Bear Reversal candle
isDoji(wickSize, bodySize)
Checks if the current bar is a doji candle based on the given parameters
Parameters:
wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)
bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size
Returns: A boolean - true if the current bar matches the requirements of a doji candle
isHammer(fib, colorMatch)
Checks if the current bar is a hammer candle based on the given parameters
Parameters:
fib (float) : (default=0.382) The fib to base candle body on
colorMatch (bool) : (default=true) Does the candle need to be green? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a hammer candle
isStar(fib, colorMatch)
Checks if the current bar is a shooting star candle based on the given parameters
Parameters:
fib (float) : (default=0.382) The fib to base candle body on
colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a shooting star candle
isBlOB()
Detects Bullish outside bars(OB)
Returns: Returns true if the current bar is a bull outside bar
isBrOB()
Detects Bearish outside bars(OB)
Returns: Returns true if the current bar is a bear outside bar
Psych Level ScreenerThis Script is intended for Pine Screener and is not designed as a indicator!!!
Pine Screener is something TradingView has recently added and is still only a Beta version.
Pine Screener itself is currently only available to members that are Premium and above.
What it does:
This screener will actively look for tickers that are close to Pysch level in your watchlist.
Psych level here refers to price levels that are round numbers such as 50,100,1000.
Users can specify the offset from a psych level (in %) and scanner will scan for tickers that are within the offset. For example if offset is set at 5% then it will scan for tickers that are within +/-5% of a ticker. (for $100 psych level it will scan for ticker in $95-105 range)
Once scan is completed you will be able to see:
- Current price of ticker
- Closest psych level for that ticker
- % and $ move required for it to hit that psych level
- Ticker's day range and Average range (with % of average range completed for the day)
- Ticker volume and average volume
Setting up:
www.tradingview.com
Above link will help you guide how to setup Pine screener.
Use steps below to guide you the setup for this specific screener:
1. Open Pine Screener (open new tab, select screener the "Pine")
2. At the top, click on "Choose Indicator" and select "Psych Level Screener"
3. At the top again, click "Indicator Psych Level Screener" and select settings.
4. Change setting to your needs. Hit Apply when done.
a)"% offset from Psych Level" will scan for any stocks in your watchlist which are +/- from the offset you chose for any given psych level. Default is 5. (e.g. If offset is 5%, it will scan for stocks that are between $95-$105 vs $100 psych level, $190-$210 for $200 psych level and so on)
b) ATR length is number of previous trading days you want to include in your calculation. Moving Average Type is calculation method.
c) Rvol length is number of previous trading days you want to include in your calculation.
5. On top left, click "Price within specified offset of Psych. Level" and select true. Then select "Scan" which is located at the top next to "Indicator Psych Level Screener". This will filter out all the stock that meets the condition.
6. At the end of the column on the right there is a "+" symbol. From there you can add/remove columns. 30min/1hr/4hr/1D Trend are disabled by default so if this is needed please enable them.
7. You can change the order of ticker by ascending and descending order of each column label if needed. Just click on the arrow that comes up when you move the cursor to any of the column items.
8. You can specify advanced filter settings based on the variables in the column. (e.g., set price range of stock to filter out further) To do so, click on the column variable name in interest, located above the screener table (or right below "scan") and select "manual setup".
How to read the column:
Current Price: Shows current price of the ticker when scan was done. Currently Pine Screener does NOT support pre/post-hours data so no PM and AH price.
Psych Level: Psych level the current price is near to.
% to Psych Level: Price movement in % necessary to get to the Psych level.
$ to Psych Level: Price movement in $ necessary to get to the Psych level.
DTR: Daily True Range of the stock. i.e. High - Low of the ticker on the day.
ATR: Average True Range of stock in the last x days, where x is a value selected in the setting. (See step 3 in Previous section)
DTR vs ATR: Amount of DTR a ticker has done in % with respect to ATR. (e.g., 90% means DTR is 90% of ATR)
Vol.: Volume of a ticker for the day. Currently Pine Screener does NOT support pre/post-hours data so no PM and AH volume.
Avg. Vol: Average volume of a ticker in the last x days, where x is a value selected in the setting. (See step 3 in Previous section)
Rvol: Relative volume in percentage, measured by the ratio of day's volume and average volume.
30min/1hr/4hr/1D Trend: Trend status to see if the chart is Bullish or Bearish on each of the time frame. Bullishness or Bearishness is defined by the price being over or under the 34/50 cloud on each of the time frame. Output of 1 is Bullish, -1 is Bearish. 0 means price is sitting inside the 34/50 cloud. Currently Pine Screener does NOT support pre/post-hours data so 34/50 cloud is based on regular trading hours data ONLY.
Some things user should be aware of:
- Pine Screener itself is currently only available to TradingView members with Premium Subscription and above. (I can't to anything about this as this is NOT set by me, I have no control) For more info: www.tradingview.com
- The Pine Screener itself is a Beta version and this screener can stop working anytime depending on changes made by TradingView themselves. (Again I cannot control this)
- Pine Screener can only run on Watchlists for now. (as of 03/31/2025) You will have to prepare your own watchlists. In a Watchlist no more than 1000 tickers may be added. (This is TradingView rules)
- Psych level included are currently 50 to 1500 in steps of 50. If you need a specific number please let me know. Will add accordingly.
- Unfortunately this screener does not update automatically, so please hit "scan" to get latest screener result.
- I cannot add 10min trend to the column as Pine Screener does NOT support 10min timeframe as of now. (03/31/2025)
- This code is only meant for Pine Screener. I do NOT recommend using this as an indicator.
- Currently Pine Screener does NOT support pre/post-hours data. So data such as Price, Volume and EMA values are based on market hours data ONLY! (If I'm wrong about this please correct me / let me know and will make look into and make changes to the code)
Other useful links about Pine Screener:
Quick overview of the Screener’s functionality: www.tradingview.com
what do you need to know before you start working? : www.tradingview.com
These links will go over the setting up with GIFs so is easier to understand.
-----------------------------------------------------------------------------------------------------------------
If there are other column variables that you think is worth adding please let me know! Will try add it to the screener!
If you have any questions let me know as well, will reply soon as I can!
Have a good trading day and hope it helps!
LinearRegressionLibrary "LinearRegression"
Calculates a variety of linear regression and deviation types, with optional emphasis weighting. Additionally, multiple of slope and Pearson’s R calculations.
calcSlope(_src, _len, _condition)
Calculates the slope of a linear regression over the specified length.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The length of the lookback period for the linear regression.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast for efficiency.
Returns: (float) The slope of the linear regression.
calcReg(_src, _len, _condition)
Calculates a basic linear regression, returning y1, y2, slope, and average.
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) An array of 4 values: .
calcRegStandard(_src, _len, _emphasis, _condition)
Calculates an Standard linear regression with optional emphasis.
Parameters:
_src (float) : (series float) The source data series.
_len (int) : (int) The length of the lookback period.
_emphasis (float) : (float) The emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcRegRidge(_src, _len, lambda, _emphasis, _condition)
Calculates a ridge regression with optional emphasis.
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
lambda (float) : (float) The ridge regularization parameter.
_emphasis (float) : (float) The emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcRegLasso(_src, _len, lambda, _emphasis, _condition)
Calculates a Lasso regression with optional emphasis.
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
lambda (float) : (float) The Lasso regularization parameter.
_emphasis (float) : (float) The emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcElasticNetLinReg(_src, _len, lambda1, lambda2, _emphasis, _condition)
Calculates an Elastic Net regression with optional emphasis.
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
lambda1 (float) : (float) L1 regularization parameter (Lasso).
lambda2 (float) : (float) L2 regularization parameter (Ridge).
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcRegHuber(_src, _len, delta, iterations, _emphasis, _condition)
Calculates a Huber regression using Iteratively Reweighted Least Squares (IRLS).
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
delta (float) : (float) Huber threshold parameter.
iterations (int) : (int) Number of IRLS iterations.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcRegLAD(_src, _len, iterations, _emphasis, _condition)
Calculates a Least Absolute Deviations (LAD) regression via IRLS.
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
iterations (int) : (int) Number of IRLS iterations for LAD.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcRegBayesian(_src, _len, priorMean, priorSpan, sigma, _emphasis, _condition)
Calculates a Bayesian linear regression with optional emphasis.
Parameters:
_src (float) : (float) The source data series.
_len (int) : (int) The length of the lookback period.
priorMean (float) : (float) The prior mean for the slope.
priorSpan (float) : (float) The prior variance (or span) for the slope.
sigma (float) : (float) The assumed standard deviation of residuals.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: (float ) .
calcRFromLinReg(_src, _len, _slope, _average, _y1, _condition)
Calculates the Pearson correlation coefficient (R) based on linear regression parameters.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_average (float) : (float) The average value of the source data series.
_y1 (float) : (float) The starting point (y-intercept of the oldest bar) for the linear regression.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast for efficiency.
Returns: (float) The Pearson correlation coefficient (R) adjusted for the direction of the slope.
calcRFromSource(_src, _len, _condition)
Calculates the correlation coefficient (R) using a specified length and source data.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The length of the lookback period.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast for efficiency.
Returns: (float) The correlation coefficient (R).
calcSlopeLengthZero(_src, _len, _minLen, _step, _condition)
Identifies the length at which the slope is flattest (closest to zero).
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length to consider (minimum of 2).
_minLen (int) : (int) The minimum length to start from (cannot exceed the max length).
_step (int) : (int) The increment step for lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length at which the slope is flattest.
calcSlopeLengthHighest(_src, _len, _minLen, _step, _condition)
Identifies the length at which the slope is highest.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length at which the slope is highest.
calcSlopeLengthLowest(_src, _len, _minLen, _step, _condition)
Identifies the length at which the slope is lowest.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length at which the slope is lowest.
calcSlopeLengthAbsolute(_src, _len, _minLen, _step, _condition)
Identifies the length at which the absolute slope value is highest.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length at which the absolute slope value is highest.
calcRLengthZero(_src, _len, _minLen, _step, _condition)
Identifies the length with the lowest absolute R value.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length with the lowest absolute R value.
calcRLengthHighest(_src, _len, _minLen, _step, _condition)
Identifies the length with the highest R value.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length with the highest R value.
calcRLengthLowest(_src, _len, _minLen, _step, _condition)
Identifies the length with the lowest R value.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length with the lowest R value.
calcRLengthAbsolute(_src, _len, _minLen, _step, _condition)
Identifies the length with the highest absolute R value.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The maximum lookback length (minimum of 2).
_minLen (int) : (int) The minimum length to start from.
_step (int) : (int) The step for incrementing lengths.
_condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.
Returns: (int) The length with the highest absolute R value.
calcDevReverse(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)
Calculates the regressive linear deviation in reverse order, with optional emphasis on recent data.
Parameters:
_src (float) : (float) The source data.
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The y-intercept (oldest bar) of the linear regression.
_inputDev (float) : (float) The input deviation multiplier.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcDevForward(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)
Calculates the progressive linear deviation in forward order (oldest to most recent bar), with optional emphasis.
Parameters:
_src (float) : (float) The source data array, where _src is oldest and _src is most recent.
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The y-intercept of the linear regression (value at the most recent bar, adjusted by slope).
_inputDev (float) : (float) The input deviation multiplier.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcDevBalanced(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)
Calculates the balanced linear deviation with optional emphasis on recent or older data.
Parameters:
_src (float) : (float) Source data array, where _src is the most recent and _src is the oldest.
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The y-intercept of the linear regression (value at the oldest bar).
_inputDev (float) : (float) The input deviation multiplier.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcDevMean(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)
Calculates the mean absolute deviation from a forward-applied linear trend (oldest to most recent), with optional emphasis.
Parameters:
_src (float) : (float) The source data array, where _src is the most recent and _src is the oldest.
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The y-intercept (oldest bar) of the linear regression.
_inputDev (float) : (float) The input deviation multiplier.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcDevMedian(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)
Calculates the median absolute deviation with optional emphasis on recent data.
Parameters:
_src (float) : (float) The source data array (index 0 = oldest, index _len - 1 = most recent).
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The y-intercept (oldest bar) of the linear regression.
_inputDev (float) : (float) The deviation multiplier.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns:
calcDevPercent(_y1, _inputDev, _condition)
Calculates the percent deviation from a given value and a specified percentage.
Parameters:
_y1 (float) : (float) The base value from which to calculate deviation.
_inputDev (float) : (float) The deviation percentage.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcDevFitted(_len, _slope, _y1, _emphasis, _condition)
Calculates the weighted fitted deviation based on high and low series data, showing max deviation, with optional emphasis.
Parameters:
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The Y-intercept (oldest bar) of the linear regression.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcDevATR(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)
Calculates an ATR-style deviation with optional emphasis on recent data.
Parameters:
_src (float) : (float) The source data (typically close).
_len (int) : (int) The length of the lookback period.
_slope (float) : (float) The slope of the linear regression.
_y1 (float) : (float) The Y-intercept (oldest bar) of the linear regression.
_inputDev (float) : (float) The input deviation multiplier.
_emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.
_condition (bool) : (bool) Flag to enable calculation (true = calculate).
Returns: A 2-element tuple: .
calcPricePositionPercent(_top, _bot, _src)
Calculates the percent position of a price within a linear regression channel. Top=100%, Bottom=0%.
Parameters:
_top (float) : (float) The top (positive) deviation, corresponding to 100%.
_bot (float) : (float) The bottom (negative) deviation, corresponding to 0%.
_src (float) : (float) The source price.
Returns: (float) The percent position within the channel.
plotLinReg(_len, _y1, _y2, _slope, _devTop, _devBot, _scaleTypeLog, _lineWidth, _extendLines, _channelStyle, _colorFill, _colUpLine, _colDnLine, _colUpFill, _colDnFill)
Plots the linear regression line and its deviations, with configurable styles and fill.
Parameters:
_len (int) : (int) The lookback period for the linear regression.
_y1 (float) : (float) The starting y-value of the regression line.
_y2 (float) : (float) The ending y-value of the regression line.
_slope (float) : (float) The slope of the regression line (used to determine line color).
_devTop (float) : (float) The top deviation to add to the line.
_devBot (float) : (float) The bottom deviation to subtract from the line.
_scaleTypeLog (bool) : (bool) Use a log scale if true; otherwise, linear scale.
_lineWidth (int) : (int) The width of the plotted lines.
_extendLines (string) : (string) How lines should extend (none, left, right, both).
_channelStyle (string) : (string) The style of the channel lines (solid, dashed, dotted).
_colorFill (bool) : (bool) Whether to fill the space between the top and bottom deviation lines.
_colUpLine (color) : (color) Line color when slope is positive.
_colDnLine (color) : (color) Line color when slope is negative.
_colUpFill (color) : (color) Fill color when slope is positive.
_colDnFill (color) : (color) Fill color when slope is negative.
MFI Nexus Pro [trade_lexx]📈 MFI Nexus Pro is your reliable trading assistant!
📊 What is MFI Nexus Pro ?
MFI Nexus Pro is a trading indicator that analyzes cash flows in the market. It shows where money is moving — into or out of an asset, and based on this, generates buy or sell signals.
💡 The main components of the indicator
📊 The MFI Cash Flow Index (MFI)
shows the strength of cash flow into an asset. Values above 70 indicate overbought (an early sale is possible), and values below 30 indicate oversold (an early purchase is possible).
📈 Moving Averages (MA)
The indicator uses 10 different types of moving averages to smooth the MFI line.:
- SMA: Simple moving average
- EMA: Exponential moving average
- WMA: Weighted moving average
And other more complex types (HMA, KAMA, VWMA, ALMA, TEMA, ZLEMA, DEMA)
The choice of the type of moving average affects the speed of the indicator's response to market changes.
🎯 Bollinger Bands (BB)
Bands around the moving average that widen and narrow depending on volatility. They help determine when the MFI is out of the normal range.
🔄 Divergences
Divergences show discrepancies between price and MFI:
- Bullish divergence: the price is falling and the MFI is rising — an upward reversal is possible
- Bearish divergence: the price is rising and the MFI is falling — a downward reversal is possible
🔍 Indicator signals
1️⃣ Moving average signals (MA)
Buy signal
- What happens: MFI crosses its moving average from bottom to top
- What does it look like: the green triangle labeled "MA" under the chart
- What does it mean: money begins to actively flow into the asset, price growth is possible
Sell signal
- What happens: the MFI crosses the moving average from top to bottom
- What does it look like: a red triangle with the label "MA" above the chart
- What does it mean: money starts to leave the asset, the price may fall
2️⃣ Bollinger Band Signals (BB)
Buy signal
- What's happening: The MFI crosses the lower Bollinger band from bottom to top
- What it looks like: the green triangle marked "BB"
- What it means: The MFI was too low and is now starting to recover
Sell Signal
- What's going on: MFI crosses the upper Bollinger band from top to bottom
- What it looks like: a red triangle marked "BB"
- What it means: The MFI was too high and is now starting to decline
3️⃣ Divergence Signals (Div)
Buy Signal (Bullish Divergence)
- What's going on: the price is falling more than the MFI
- What it looks like: a green triangle marked "Div"
- What it means: despite the fall in price, money is already starting to return to the asset
Sell signal (bearish divergence)
- What is happening: the price is rising more strongly than the MFI
- What does it look like: the red triangle with the label "Div"
- What does it mean: despite the price increase, money is already starting to leave the asset
🛠️ Filters to filter out false signals
1️⃣ Minimum distance between the signals
- What it does: sets the minimum number of candles between signals
- Why it is needed: prevents signals from being too frequent during strong market fluctuations
- How to set it up: Set the number from 0 and above (default: 5)
2️⃣ "Waiting for the opposite signal" mode
- What it does: waits for a signal in the opposite direction before generating a new signal
- Why you need it: it helps you not to miss important trend reversals
- How to set up: just turn the function on or off
3️⃣ Filter by MFI levels
- What it does: generates signals only when the MFI is in the specified ranges
- Why it is needed: it helps to catch the moments when the market is oversold or overbought
- How to set up:
- For buy signals: set a range for oversold (e.g. 1-30)
- For sell signals: set a range for overbought (e.g. 70-100)
4️⃣ The RSI filter
- What it does: additionally checks the RSI values to confirm the signals
- Why it is needed: adds additional confirmation from another popular indicator
- How to set up: Similar to the MFI filter, set ranges for buying and selling
🔄 Signal combination modes
1️⃣ Normal mode ("None")
- How it works: all signals (MA, BB, Div) work independently of each other
- When to use it: for general market analysis or when learning how to work with the indicator
2️⃣ "And" mode ("MA and BB and Div")
- How it works: the alarm appears only when several conditions are triggered simultaneously
- Combination options:
- MA+BB: signals from the moving average and Bollinger bands
- MA+Div: signals from the moving average and divergence
- BB+Div: signals from the Bollinger bands and divergence
- MA+BB+Div: all three signals simultaneously
- When to use: for more reliable but rare signals
3️⃣ "OR" mode ("MA or BB or Div")
- How it works: the alarm appears when any of the conditions are triggered
- When to use: for frequent signals when you don't want to miss any opportunity.
🔌 Connecting to trading strategies
The indicator can be connected to your trading strategies using 5 different channels.:
1. Channel for MA signals: connects only signals from moving averages
2. BB signal channel: connects only the signals from the Bollinger bands
3. Channel for divergence signals: connects only divergence signals
4. Channel for "And" mode: connects only combined signals
5. Channel for "OR" mode: connects signals from any source
🔔 Setting up alerts
The indicator can send alerts when alarms appear.:
- Alerts for MA: when the MFI crosses the moving average
- Alerts for BB: when the MFI crosses the Bollinger bands
- Divergence alerts: when a divergence is detected
- Combined alerts: for "AND" and "OR" modes
🎭 What does the indicator look like on the chart ?
- MFI main line: purple line
- Overbought/oversold levels: horizontal lines at levels 30 and 70
- Middle line: dotted line at level 50
- MFI Moving Average: yellow line
- Bollinger bands: green lines around the moving average
- Signals: green and red triangles with corresponding labels
📚 How to start using MFI Nexus Pro
1️⃣ Initial setup
- Add an indicator to your chart
- Select the type of moving average and the period (you can leave it as the default)
- Activate the desired signal types (MA, BB, Div)
2️⃣ Filter settings
- Set the distance between the signals to get rid of unnecessary noise
- Adjust the MFI and RSI levels depending on how volatile your asset is
- If you need more reliable signals, turn on the "Waiting for the opposite signal" mode.
3️⃣ Operation mode selection
- First, use the standard mode to see all possible signals.
- When you get comfortable, try the "And" mode for more reliable signals.
- For active trading, you can use the "OR" mode
4️⃣ Setting up Alerts
- Select the types of signals you want to be notified about
- Set up alerts for "AND" or "OR" modes if you use them
5️⃣ Verification and adaptation
- Check the operation of the indicator on historical data
- Adjust the parameters for a specific asset
- Adapt the settings to your trading style
🌟 Usage examples
For trend trading
- Use MA signals in the direction of the main trend
- Turn on the "Waiting for the opposite signal" mode
- Set stricter levels for filters
For trading in a sideways range
- Use BB signals to detect bounces from the range boundaries
- Use the MFI level filter to confirm overbought/oversold conditions
- Adjust the Bollinger bands according to the width of the range
To determine the pivot points
- Pay attention to the divergence signals
- Use the "And" mode by combining divergences with other signals
- Check the RSI filter for additional confirmation
Custom TABI Model with LayersCustom Top and Bottom Indicator (TABI) (Is a Trend Adaptive Blow-Off Indicator) -
User Guide & Description
Introduction
The TABI (Trend Adaptive Blow-Off Indicator) is a refined, multi-layered RSI tool designed to enhance trend analysis, detect momentum shifts, and highlight overbought/oversold conditions with a more nuanced, color-coded approach. This indicator is useful for traders seeking to identify key reversal points, confirm trend strength, and filter trade setups more effectively than traditional RSI.
By incorporating volume-based confirmation and divergence detection, TABI aims to reduce false signals and improve trade timing.
How It Works
TABI builds on the Relative Strength Index (RSI) by introducing:
A smoothed RSI calculation for better trend readability.
11 color-coded RSI levels, allowing traders to visually distinguish weak, neutral, and extreme conditions.
Volume-based confirmation to detect high-conviction moves.
Bearish & Bullish Divergence Detection, inspired by Market Cipher methods, to spot potential reversals early.
Overbought & Oversold alerts, with optional candlestick color changes to highlight trade signals.
Key Features
✅ Color-Coded RSI for Better Readability
The RSI is divided into multi-layered color zones:
🔵 Light Blue: Extremely oversold
🟢 Lime Green: Mild oversold, potential trend reversal
🟡 Yellow & Orange: Neutral, momentum consolidation
🟠 Dark Orange: Caution, overbought conditions developing
🔴 Red: Extreme overbought, possible exhaustion
✅ Divergence Detection
Bearish Divergence: Price makes higher highs, RSI makes lower highs → Potential top signal
Bullish Divergence: Price makes lower lows, RSI makes higher lows → Potential bottom signal
✅ Volume Confirmation Filter
Requires a 50% above-average volume spike for strong buy/sell signals, reducing false breakouts.
✅ Dynamic Labels & Alerts
🚨 Blow-Off Top Warning: If RSI is overbought + volume spikes + divergence detected
🟢 Oversold Bottom Alert: If RSI is oversold + bullish divergence
Candlestick color changes when extreme conditions are met.
How to Use
📌 Entry & Exit Signals
Buy Consideration:
RSI enters Green Zone (oversold)
Bullish divergence detected
Volume confirms the move
Sell Consideration:
RSI enters Red Zone (overbought)
Bearish divergence detected
Volume confirms exhaustion
📌 Trend Confirmation
Use the yellow/orange levels to confirm strong trends before entering counter-trend trades.
📌 Filtering Trade Noise
The RSI smoothing helps reduce false whipsaws, making it easier to read true momentum shifts.
Customization Options
🔧 User-Defined RSI Thresholds
Adjust the overbought/oversold levels to match your trading style.
🔧 Divergence Sensitivity
Modify the lookback period to fine-tune divergence detection accuracy.
🔧 Volume Thresholds
Set custom volume multipliers to control confirmation requirements.
Why This is Unique
🔹 Unlike traditional RSI, TABI visually maps RSI zones into layered gradients, making it easy to spot momentum shifts.
🔹 The multi-layered color scheme adds an intuitive, heatmap-like effect to RSI, helping traders quickly gauge conditions.
🔹 Incorporates CCF-inspired divergence detection and volume filtering, making signals more robust.
🔹 Dynamic labeling system ensures clarity without cluttering the chart.
Alerts & Notifications
🔔 TradingView Alerts Included
🚨 Blow-Off Top Detected → RSI overbought + volume spike + bearish divergence.
🟢 Oversold Bottom Detected → RSI oversold + bullish divergence.
Set alerts to receive notifications without watching the charts 24/7.
Final Thoughts
TABI is designed to simplify RSI analysis, provide better trade signals, and improve decision-making. Whether you're day trading, swing trading, or long-term investing, this tool helps you navigate market conditions with confidence.
🔥 Use it to detect high-probability reversals, confirm trends, and improve trade entries/exits! 🚀
Bitcoin Total VolumeThis Pine Script indicator, titled "Bitcoin Top 16 Volume," is designed to provide traders with an aggregate view of Bitcoin (BTC) spot trading volume across leading cryptocurrency exchanges. Unlike traditional volume indicators that focus on a single exchange, this tool compiles data from a selection of the top exchanges as ranked by CoinMarketCap, offering a broader perspective on overall market activity.
The indicator works by fetching real-time volume data for specific BTC trading pairs on various exchanges. It currently incorporates data from prominent platforms such as Binance (BTCUSDT), Coinbase (BTCUSD), OKX (BTCUSDT), Bybit (BTCUSDT), Kraken (BTCUSD), Bitfinex (BTCUSD), Bitstamp (BTCUSD), Gemini (BTCUSD), Upbit (BTCKRW), Bithumb (BTCKRW), KuCoin (BTCUSDT), Gate.io (BTCUSDT), MEXC (BTCUSDT), Crypto.com (BTCUSD), Poloniex (BTCUSDT), and BitMart (BTCUSDT). It's important to note that while the indicator aims to represent the "Top 16" exchanges, the actual number included may vary due to data availability within TradingView and the dynamic nature of exchange rankings.
The script then calculates the total volume by summing up the volume data retrieved from each of these exchanges. This aggregated volume is visually represented as a histogram directly on your TradingView chart, displayed in white by default. By observing the height of the histogram bars, traders can quickly assess the total trading volume for Bitcoin spot markets over different time periods, corresponding to the chart's timeframe.
This indicator is valuable for traders seeking to understand the overall market depth and liquidity of Bitcoin. Increased total volume can often signal heightened market interest and potential trend strength or reversals. Conversely, low volume might suggest consolidation or reduced market participation. Traders can use this indicator to confirm trends, identify potential breakouts, and gauge the general level of activity in the Bitcoin spot market across major exchanges. Keep in mind that the list of exchanges included may need periodic updates to accurately reflect the top exchanges as rankings on CoinMarketCap evolve.
Half-Trend Channel [BigBeluga]Half Trend Channel is a powerful trend-following indicator designed to identify trend direction, fakeouts, and potential reversal points. The combination of upper/lower bands, midline coloring, and specific signals makes it ideal for spotting trend continuation and market reversals.
The base of the channel is calculated using smoothed half-trend logic.
// Initialize half trend on the first bar
if barstate.isfirst
hl_t := close
// Update half trend value based on conditions
switch
closeMA < hl_t and highestHigh < hl_t => hl_t := highestHigh
closeMA > hl_t and lowestLow > hl_t => hl_t := lowestLow
=> hl_t := hl_t
// Smooth
float s_hlt = ta.hma(hl_t, len)
🔵 Key Features:
Upper and Lower Bands:
The bands adapt dynamically to market volatility.
Price movements toward the bands help identify areas of overextension and potential reversal points.
Midline Trend Signal:
The midline changes color to reflect the current trend:
Green Midline: Indicates an uptrend.
Purple Midline: Signals a downtrend.
Fakeout Signals ("X"):
"X" markers appear when price briefly breaches the outer bands but fails to sustain the move.
Fakeouts help traders identify areas where price momentum weakens.
Reversal Signals (Triangles):
Triangles (▲ and ▼) mark potential tops and bottoms:
▲ Up Triangles: Suggest a potential bottom and a reversal to the upside.
▼ Down Triangles: Indicate a potential top and a reversal to the downside.
Dynamic Trend Labels:
At the last bar, the indicator displays labels like "Trend Up" or "Trend Dn" , reflecting the current trend direction.
🔵 Usage:
Use the colored midline to determine the overall trend direction.
Monitor "X" fakeout signals to spot failed breakouts or momentum exhaustion near the bands.
Watch for reversal triangles (▲ and ▼) to identify potential trend reversals at tops or bottoms.
Combine the bands and midline signals to confirm trade entries and exits:
Enter long trades when price bounces off the lower band with a green midline.
Consider short trades when price reverses from the upper band with a purple midline.
Use the trend label (e.g., "Trend Up" or "Trend Dn") for quick confirmation of the current market state.
The Half Trend Channel is an essential tool for traders who want to follow trends, avoid fakeouts, and identify reliable tops and bottoms to optimize their trading decisions.
[blackcat] L2 BullBear OscillatorOVERVIEW
The " L2 BullBear Oscillator" is a custom trading indicator for TradingView that helps traders identify market trends, potential tops and bottoms, and the strength of trends using various moving averages and price relationships.
FEATURES
Calculates a base oscillator based on the close price relative to the highest and lowest prices over the past 60 periods.
Smoothes the oscillator using exponential moving averages (EMAs).
Determines market strength through relative strength indicators and moving averages.
Identifies potential tops and strong support levels based on specific conditions involving oscillators and price actions.
Plots several signals to help traders make informed decisions.
HOW TO USE
Install the script on your TradingView chart.
Customize the settings in the "Inputs" section:
Set the periods for the short-term and long-term EMAs.
Set the periods for the three SMAs used in calculations.
Interpret the plots:
BullBear Signal (Fuchsia Line): Indicates the overall market trend. Uptrends suggest buying opportunities, while downtrends suggest selling.
Decreasing BullBear Signal (Aqua Line): Highlights periods when the trend is weakening or turning bearish, signaling possible selling opportunities.
Potential Top Condition (Yellow Plot): Signals possible trend reversals from bullish to bearish, indicating times to consider taking profits or preparing for a downtrend.
High Price Condition (Yellow Plot): Indicates strong bullish momentum but also potentially overbought conditions, which might precede a correction.
Earning Condition (Red Line): Possibly signifies strong bullish signals, indicating good times to enter long positions.
Strong Support Condition (White Arrows): Signals potential bottoms or support levels, indicating buying opportunities.
Start Hiding Condition (Fuchsia Plot): Might indicate times to exit positions or reduce exposure due to unfavorable market conditions.
ALGORITHMS
Moving Averages:
Simple Moving Averages (SMAs): Used to calculate averages of price data over specified periods.
Exponential Moving Averages (EMAs): Used to give more weight to recent prices, making the moving averages more responsive to new data.
Oscillator Calculation:
The base oscillator is calculated based on the close price's position within the highest and lowest prices over 60 periods, normalized to a 0-100 scale.
This oscillator is then smoothed using EMAs to reduce noise and make trends more visible.
Relative Strength Indicator:
Calculated based on the close price's position within the highest and lowest prices over 20 periods, also normalized to a 0-100 scale.
This is smoothed using SMAs to get a more stable signal.
Condition Checks:
Various conditions are checked to identify potential tops, strong support, and other market states based on the relationships between these indicators and price actions.
LIMITATIONS
The script is based on historical data and does not guarantee future performance.
It is recommended to use the script in conjunction with other analysis tools.
The effectiveness of the strategy may vary depending on the market conditions and asset being traded.
NOTES
The script is designed for educational purposes and should not be considered financial advice.
Users are encouraged to backtest the strategy on a demo account before applying it to live trades.
THANKS
Special thanks to the TradingView community for their support and feedback.
Bitcoin Reversal PredictorOverview
This indicator displays two lines that, when they cross, signal a potential reversal in Bitcoin's price trend. Historically, the high or low of a bull market cycle often occurs near the moment these lines intersect. The lines consist of an Exponential Moving Average (EMA) and a logarithmic regression line fitted to all of Bitcoin's historical data.
Inspiration
The inspiration for this indicator came from the PI Cycle Top indicator, which has accurately predicted past bull market peaks. However, I believe the PI Cycle Top indicator may not be as effective in the future. In that indicator, two lines cross to mark the top, but the extent of the cross has been diminishing over time. This was especially noticeable in the 2021 cycle, where the lines barely crossed. Because of this, I created a new indicator that I think will continue to provide reliable reversal signals in the future.
How It Works
The logarithmic regression line is fitted to the Bitcoin (BTCUSD) chart using two key factors: the 'a' factor (slope) and the 'b' factor (intercept). This results in a steadily decreasing line. The EMA oscillates above and below this regression line. Each time the two lines cross, a vertical colored bar appears, indicating that Bitcoin's price momentum is likely to reverse.
Use Cases
- Price Bottoming:
Bitcoin often bottoms out when the EMA crosses below the logarithmic regression line.
- Price Topping:
In contrast, Bitcoin often peaks when the EMA crosses above the logarithmic regression line.
- Profitable Strategy:
Trading at the crossovers of these lines can be a profitable strategy, as these moments often signal significant price reversals.
Pi Cycle MACD Inverse OscillatorPi Cycle MACD Inverse Oscillator with Gradient and Days Since Last Top
This indicator is ideal for Bitcoin traders seeking a robust tool to visualize long-term and short-term trends with enhanced clarity and actionable insights.
This script combines the concept of the Pi Cycle indicator with a unique MACD-based inverse oscillator to analyze Bitcoin market trends. It introduces several features to help traders understand market conditions better:
Inverse Oscillator:
- Oscillator ranges between 1 and -1.
- A value of 1 indicates the two moving averages (350 MA and 111 MA) are equal.
- A value of -1 indicates the maximum observed distance between the moving averages during the selected lookback period.
- The oscillator dynamically adjusts to price changes using a configurable scaling factor.
Gradient Visualization:
The oscillator line transitions smoothly from green (closer to -1) to yellow (at 0) and red (closer to 1).
The color gradient provides a quick visual cue for market momentum.
Days Since Last Pi Cycle Top:
Calculates and displays the number of days since the last "Pi Cycle Top" (defined as a crossover between the two moving averages).
The label updates dynamically and appears only on the most recent bar.
Conditional Fill:
Highlights the area between 0 and 1 with a green gradient when the price is above the long moving average.
Enhances visual understanding of the oscillator's position relative to key thresholds.
Inputs:
- Long Moving Average (350 default): Determines the primary trend.
- Short Moving Average (111 default): Measures shorter-term momentum.
- Oscillator Lookback Period (100 default): Defines the range for normalizing the oscillator.
- Price Scaling Factor (0.01 default): Adjusts the normalization to account for large price fluctuations.
How to Use:
- Use the oscillator to identify potential reversal points and trend momentum.
- Look for transitions in the gradient color and the position relative to 0.
- Monitor the "Days Since Last Top" label for insights into the market's cycle timing.
- Utilize the conditional fill to quickly assess when the market is in a favorable position above the long moving average.
True Amplitude Envelopes (TAE)The True Envelopes indicator is an adaptation of the True Amplitude Envelope (TAE) method, based on the research paper " Improved Estimation of the Amplitude Envelope of Time Domain Signals Using True Envelope Cepstral Smoothing " by Caetano and Rodet. This indicator aims to create an asymmetric price envelope with strong predictive power, closely following the methodology outlined in the paper.
Due to the inherent limitations of Pine Script, the indicator utilizes a Kernel Density Estimator (KDE) in place of the original Cepstral Smoothing technique described in the paper. While this approach was chosen out of necessity rather than superiority, the resulting method is designed to be as effective as possible within the constraints of the Pine environment.
This indicator is ideal for traders seeking an advanced tool to analyze price dynamics, offering insights into potential price movements while working within the practical constraints of Pine Script. Whether used in dynamic mode or with a static setting, the True Envelopes indicator helps in identifying key support and resistance levels, making it a valuable asset in any trading strategy.
Key Features:
Dynamic Mode: The indicator dynamically estimates the fundamental frequency of the price, optimizing the envelope generation process in real-time to capture critical price movements.
High-Pass Filtering: Uses a high-pass filtered signal to identify and smoothly interpolate price peaks, ensuring that the envelope accurately reflects significant price changes.
Kernel Density Estimation: Although implemented as a workaround, the KDE technique allows for flexible and adaptive smoothing of the envelope, aimed at achieving results comparable to the more sophisticated methods described in the original research.
Symmetric and Asymmetric Envelopes: Provides options to select between symmetric and asymmetric envelopes, accommodating various trading strategies and market conditions.
Smoothness Control: Features adjustable smoothness settings, enabling users to balance between responsiveness and the overall smoothness of the envelopes.
The True Envelopes indicator comes with a variety of input settings that allow traders to customize the behavior of the envelopes to match their specific trading needs and market conditions. Understanding each of these settings is crucial for optimizing the indicator's performance.
Main Settings
Source: This is the data series on which the indicator is applied, typically the closing price (close). You can select other price data like open, high, low, or a custom series to base the envelope calculations.
History: This setting determines how much historical data the indicator should consider when calculating the envelopes. A value of 0 will make the indicator process all available data, while a higher value restricts it to the most recent n bars. This can be useful for reducing the computational load or focusing the analysis on recent market behavior.
Iterations: This parameter controls the number of iterations used in the envelope generation algorithm. More iterations will typically result in a smoother envelope, but can also increase computation time. The optimal number of iterations depends on the desired balance between smoothness and responsiveness.
Kernel Style: The smoothing kernel used in the Kernel Density Estimator (KDE). Available options include Sinc, Gaussian, Epanechnikov, Logistic, and Triangular. Each kernel has different properties, affecting how the smoothing is applied. For example, Gaussian provides a smooth, bell-shaped curve, while Epanechnikov is more efficient computationally with a parabolic shape.
Envelope Style: This setting determines whether the envelope should be Static or Dynamic. The Static mode applies a fixed period for the envelope, while the Dynamic mode automatically adjusts the period based on the fundamental frequency of the price data. Dynamic mode is typically more responsive to changing market conditions.
High Q: This option controls the quality factor (Q) of the high-pass filter. Enabling this will increase the Q factor, leading to a sharper cutoff and more precise isolation of high-frequency components, which can help in better identifying significant price peaks.
Symmetric: This setting allows you to choose between symmetric and asymmetric envelopes. Symmetric envelopes maintain an equal distance from the central price line on both sides, while asymmetric envelopes can adjust differently above and below the price line, which might better capture market conditions where upside and downside volatility are not equal.
Smooth Envelopes: When enabled, this setting applies additional smoothing to the envelopes. While this can reduce noise and make the envelopes more visually appealing, it may also decrease their responsiveness to sudden market changes.
Dynamic Settings
Extra Detrend: This setting toggles an additional high-pass filter that can be applied when using a long filter period. The purpose is to further detrend the data, ensuring that the envelope focuses solely on the most recent price oscillations.
Filter Period Multiplier: This multiplier adjusts the period of the high-pass filter dynamically based on the detected fundamental frequency. Increasing this multiplier will lengthen the period, making the filter less sensitive to short-term price fluctuations.
Filter Period (Min) and Filter Period (Max): These settings define the minimum and maximum bounds for the high-pass filter period. They ensure that the filter period stays within a reasonable range, preventing it from becoming too short (and overly sensitive) or too long (and too sluggish).
Envelope Period Multiplier: Similar to the filter period multiplier, this adjusts the period for the envelope generation. It scales the period dynamically to match the detected price cycles, allowing for more precise envelope adjustments.
Envelope Period (Min) and Envelope Period (Max): These settings establish the minimum and maximum bounds for the envelope period, ensuring the envelopes remain adaptive without becoming too reactive or too slow.
Static Settings
Filter Period: In static mode, this setting determines the fixed period for the high-pass filter. A shorter period will make the filter more responsive to price changes, while a longer period will smooth out more of the price data.
Envelope Period: This setting specifies the fixed period used for generating the envelopes in static mode. It directly influences how tightly or loosely the envelopes follow the price action.
TAE Smoothing: This controls the degree of smoothing applied during the TAE process in static mode. Higher smoothing values result in more gradual envelope curves, which can be useful in reducing noise but may also delay the envelope’s response to rapid price movements.
Visual Settings
Top Band Color: This setting allows you to choose the color for the upper band of the envelope. This band represents the resistance level in the price action.
Bottom Band Color: Similar to the top band color, this setting controls the color of the lower band, which represents the support level.
Center Line Color: This is the color of the central price line, often referred to as the carrier. It represents the detrended price around which the envelopes are constructed.
Line Width: This determines the thickness of the plotted lines for the top band, bottom band, and center line. Thicker lines can make the envelopes more visible, especially when overlaid on price data.
Fill Alpha: This controls the transparency level of the shaded area between the top and bottom bands. A lower alpha value will make the fill more transparent, while a higher value will make it more opaque, helping to highlight the envelope more clearly.
The envelopes generated by the True Envelopes indicator are designed to provide a more precise and responsive representation of price action compared to traditional methods like Bollinger Bands or Keltner Channels. The core idea behind this indicator is to create a price envelope that smoothly interpolates the significant peaks in price action, offering a more accurate depiction of support and resistance levels.
One of the critical aspects of this approach is the use of a high-pass filtered signal to identify these peaks. The high-pass filter serves as an effective method of detrending the price data, isolating the rapid fluctuations in price that are often lost in standard trend-following indicators. By filtering out the lower frequency components (i.e., the trend), the high-pass filter reveals the underlying oscillations in the price, which correspond to significant peaks and troughs. These oscillations are crucial for accurately constructing the envelope, as they represent the most responsive elements of the price movement.
The algorithm works by first applying the high-pass filter to the source price data, effectively detrending the series and isolating the high-frequency price changes. This filtered signal is then used to estimate the fundamental frequency of the price movement, which is essential for dynamically adjusting the envelope to current market conditions. By focusing on the peaks identified in the high-pass filtered signal, the algorithm generates an envelope that is both smooth and adaptive, closely following the most significant price changes without overfitting to transient noise.
Compared to traditional envelopes and bands, such as Bollinger Bands and Keltner Channels, the True Envelopes indicator offers several advantages. Bollinger Bands, which are based on standard deviations, and Keltner Channels, which use the average true range (ATR), both tend to react to price volatility but do not necessarily follow the peaks and troughs of the price with precision. As a result, these traditional methods can sometimes lag behind or fail to capture sudden shifts in price momentum, leading to either false signals or missed opportunities.
In contrast, the True Envelopes indicator, by using a high-pass filtered signal and a dynamic period estimation, adapts more quickly to changes in price behavior. The envelopes generated by this method are less prone to the lag that often affects standard deviation or ATR-based bands, and they provide a more accurate representation of the price's immediate oscillations. This can result in better predictive power and more reliable identification of support and resistance levels, making the True Envelopes indicator a valuable tool for traders looking for a more responsive and precise approach to market analysis.
In conclusion, the True Envelopes indicator is a powerful tool that blends advanced theoretical concepts with practical implementation, offering traders a precise and responsive way to analyze price dynamics. By adapting the True Amplitude Envelope (TAE) method through the use of a Kernel Density Estimator (KDE) and high-pass filtering, this indicator effectively captures the most significant price movements, providing a more accurate depiction of support and resistance levels compared to traditional methods like Bollinger Bands and Keltner Channels. The flexible settings allow for extensive customization, ensuring the indicator can be tailored to suit various trading strategies and market conditions.
Enigma UnlockedENIGMA Indicator: A Comprehensive Market Bias & Success Tracker
The ENIGMA Indicator is a powerful tool designed for traders who aim to identify market bias, track price movements, and evaluate trade performance using multiple timeframes. It combines multiple indicators and advanced logic to provide real-time insights into market trends, helping traders make more informed decisions.
Key Features
1. Multi-Timeframe Bias Calculation:
The ENIGMA Indicator tracks the market bias across multiple timeframes—Daily (D), 4-Hour (H4), 1-Hour (H1), 30-Minute (30M), 15-Minute (15M), 5-Minute (5M), and 1-Minute (1M).
How the Bias is Created:
The Bias is a key feature of the ENIGMA Indicator and is determined by comparing the current price with previous price levels for each timeframe.
- Bullish Bias (1): The market is considered **bullish** if the **current closing price** is higher than the **previous timeframe’s high**. This suggests that the market is trending upwards, and buyers are in control.
- Bearish Bias (-1): The market is considered **bearish** if the **current closing price** is lower than the **previous timeframe’s low**. This suggests that the market is trending downwards, and sellers are in control.
- Neutral Bias (0): The market is considered **neutral** if the price is between the **previous high** and **previous low**, indicating indecision or a range-bound market.
This bias calculation is performed independently for each timeframe. The **Bias** for each timeframe is then displayed in the **Bias Table** on your chart, providing a clear view of market direction across multiple timeframes.
2. **Customizable Table Display:**
- The indicator provides a table that displays the bias for each selected timeframe, clearly marking whether the market is **Bullish**, **Bearish**, or **Neutral**.
- Users can choose where to place the table on the chart: top-left, top-right, bottom-left, bottom-right, or center positions, allowing for easy and personalized chart management.
3. **Win/Loss Tracker:**
- The table also tracks the **success rate** of **buy** and **sell** trades based on price retests of key bias levels.
- For each period (Day, Week, Month), it tracks how often the price has moved in the direction of the initial bias, counting **Buy Wins**, **Sell Wins**, **Buy Losses**, and **Sell Losses**.
- This helps traders assess the effectiveness of the market bias over time and adjust their strategies accordingly.
#### **How the Success Calculation Determines the Success Rate:**
The **Success Calculation** is designed to track how often the price follows the direction of the market bias. It does this by evaluating how the price retests key levels associated with the identified market bias:
1. **Buy Success Calculation**:
- The success of a **Buy Trade** is determined when the price breaks above the **previous high** after a **bullish bias** has been identified.
- If the price continues to move higher (i.e., makes a new high) after breaking the previous high, the **buy trade is considered successful**.
- The indicator tracks how many times this condition is met and counts it as a **Buy Win**.
2. **Sell Success Calculation**:
- The success of a **Sell Trade** is determined when the price breaks below the **previous low** after a **bearish bias** has been identified.
- If the price continues to move lower (i.e., makes a new low) after breaking the previous low, the **sell trade is considered successful**.
- The indicator tracks how many times this condition is met and counts it as a **Sell Win**.
3. **Failure Calculations**:
- If the price does not move as expected (i.e., it does not continue in the direction of the identified bias), the trade is considered a **loss** and is tracked as **Buy Loss** or **Sell Loss**, depending on whether it was a bullish or bearish trade.
The ENIGMA Indicator keeps a running tally of **Buy Wins**, **Sell Wins**, **Buy Losses**, and **Sell Losses** over a set period (which can be customized to Days, Weeks, or Months). These statistics are updated dynamically in the **Bias Table**, allowing you to track your success rate in real-time and gain insights into the effectiveness of the market bias.
#### **Customizable Period Tracking:**
- The ENIGMA Indicator allows you to set custom tracking periods (e.g., 30 days, 2 weeks, etc.). The performance metrics reset after each tracking period, helping you monitor your success in different market conditions.
5. **Interactive Settings:**
- **Lookback Period**: Define how many bars the indicator should consider for bias calculations.
- **Success Tracking**: Set the number of candles to track for calculating the win/loss performance.
- **Time Threshold**: Set a time threshold to help define the period during which price retests are considered valid.
- **Info Tooltip**: You can enable the information tool in the settings to view detailed explanations of how wins and losses are calculated, ensuring you understand how the indicator works and how the results are derived.
#### **How to Use the ENIGMA Indicator:**
1. **Install the Indicator**:
- Add the ENIGMA Indicator to your chart. It will automatically calculate and display the bias for multiple timeframes.
2. **Interpret the Bias Table**:
- The bias table will show whether the market is **Bullish**, **Bearish**, or **Neutral** across different timeframes.
- Look for alignment between the timeframes—when multiple timeframes show the same bias, it may indicate a stronger trend.
3. **Use the Win/Loss Tracker**:
- Track how well your trades align with the bias using the **Win/Loss Tracker**. This helps you refine your strategy by understanding which timeframes and biases lead to higher success rates.
- For example, if you see a high number of **Buy Wins** and a low number of **Sell Wins**, you may decide to focus more on buying during bullish trends and avoid selling during bearish retracements.
4. **Track Your Period Performance**:
- The indicator will automatically track your performance over the set period (Days, Weeks, Months). Use this data to adjust your approach and evaluate the effectiveness of your trading strategy.
5. **Position the Table**:
- Customize the placement of the table on your chart based on your preferences. You can choose from options like **Top Left**, **Top Right**, **Bottom Left**, **Bottom Right**, or **Center** to keep the chart uncluttered.
6. **Adjust Settings**:
- Modify the indicator settings according to your trading style. You can adjust the **Lookback Period**, **Number of Candles to Track**, and **Time Threshold** to match the pace of your trading.
7. **Use the Info Tooltip**:
- Enable the **Info Tool** in the settings to understand how the Buy/Sell Wins and Losses are calculated. The tooltip provides a breakdown of how the indicator tracks price movements and calculates the success rate.
**Conclusion:**
The **ENIGMA Indicator** is designed to help traders make informed decisions by providing a clear view of the market bias and performance data. With the ability to track bias across multiple timeframes and evaluate your trading success, it can be a powerful tool for refining your trading strategies.
Whether you're looking to focus on a single timeframe or analyze multiple timeframes for a stronger bias, the ENIGMA Indicator adapts to your needs, providing both real-time market insights and performance feedback.
Jackson Volume breaker Indication# Jackson Volume Breaker Beta
### Advanced Volume Analysis Indicator
## Description
The Jackson Volume Breaker Beta is a sophisticated volume analysis tool that helps traders identify buying and selling pressure by analyzing price action and volume distribution. This indicator separates and visualizes buying and selling volume based on where the price closes within each candle's range, providing clear insights into market participation and potential trend strength.
## Key Features
1. **Smart Volume Distribution**
- Automatically separates buying and selling volume
- Color-coded volume bars (Green for buying, Red for selling)
- Winning volume always displayed on top for quick visual reference
2. **Real-time Volume Analysis**
- Shows current candle's buy/sell ratio
- Displays total volume with smart number formatting (K, M, B)
- Percentage-based volume distribution
3. **Technical Overlays**
- 20-period Volume Moving Average
- Dynamic scaling relative to price action
- Clean, uncluttered visual design
## How to Use
### Installation
1. Add the indicator to your chart
2. Adjust the Volume Scale input based on your preference (default: 0.08)
3. Toggle the Moving Average display if desired
### Reading the Indicator
#### Volume Bars
- **Green Bars**: Represent buying volume
- **Red Bars**: Represent selling volume
- **Stacking**: The larger volume (winning side) is always displayed on top
- **Height**: Relative to the actual volume, scaled for chart visibility
#### Information Table
The top-right table shows three key pieces of information:
1. **Left Percentage**: Winning side's volume percentage
2. **Middle Percentage**: Losing side's volume percentage
3. **Right Number**: Total volume (abbreviated)
### Trading Applications
1. **Trend Confirmation**
- Strong buying volume in uptrends confirms bullish pressure
- High selling volume in downtrends confirms bearish pressure
- Volume divergence from price can signal potential reversals
2. **Support/Resistance Breaks**
- High volume on breakouts suggests stronger moves
- Low volume on breaks might indicate false breakouts
- Monitor volume distribution for break direction confirmation
3. **Reversal Identification**
- Volume shift from selling to buying can signal potential bottoms
- Shift from buying to selling can indicate potential tops
- Use with price action for better entry/exit points
## Input Parameters
1. **Volume Scale (0.01 to 1.0)**
- Controls the height of volume bars
- Default: 0.08
- Adjust based on your chart size and preference
2. **Show MA (True/False)**
- Toggles 20-period volume moving average
- Useful for identifying volume trends
- Default: True
3. **MA Length (1+)**
- Changes the moving average period
- Default: 20
- Higher values for longer-term volume trends
## Best Practices
1. **Multiple Timeframe Analysis**
- Compare volume patterns across different timeframes
- Look for volume convergence/divergence
- Use higher timeframes for major trend confirmation
2. **Combine with Other Indicators**
- Price action patterns
- Support/resistance levels
- Momentum indicators
- Trend indicators
3. **Volume Pattern Recognition**
- Monitor for unusual volume spikes
- Watch for volume climax patterns
- Identify volume dry-ups
## Tips for Optimization
1. Adjust the Volume Scale based on your chart size
2. Use smaller timeframes for detailed volume analysis
3. Compare current volume bars to historical patterns
4. Watch for volume/price divergences
5. Monitor volume distribution changes near key price levels
## Note
This indicator works best when combined with proper price action analysis and risk management strategies. It should not be used as a standalone trading system but rather as part of a comprehensive trading approach.
## Version History
- Beta Release: Initial public version
- Features buy/sell volume separation, moving average, and real-time analysis
- Optimized for both intraday and swing trading timeframes
## Credits
Developed by Jackson based on other script creators
Special thanks to the trading community for feedback and suggestions
All Chart Patterns [theEccentricTrader]█ OVERVIEW
This indicator automatically draws and sends alerts for all of the chart patterns in my public library as they occur. The patterns included are as follows:
• Ascending Broadening
• Broadening
• Descending Broadening
• Double Bottom
• Double Top
• Triple Bottom
• Triple Top
• Bearish Elliot Wave
• Bullish Elliot Wave
• Bearish Alternate Flag
• Bullish Alternate Flag
• Bearish Flag
• Bullish Flag
• Bearish Ascending Head and Shoulders
• Bullish Ascending Head and Shoulders
• Bearish Descending Head and Shoulders
• Bullish Descending Head and Shoulders
• Bearish Head and Shoulders
• Bullish Head and Shoulders
• Bearish Pennant
• Bullish Pennant
• Ascending Wedge
• Descending Wedge
• Wedge
█ CONCEPTS
Green and Red Candles
• A green candle is one that closes with a close price equal to or above the price it opened.
• A red candle is one that closes with a close price that is lower than the price it opened.
Swing Highs and Swing Lows
• A swing high is a green candle or series of consecutive green candles followed by a single red candle to complete the swing and form the peak.
• A swing low is a red candle or series of consecutive red candles followed by a single green candle to complete the swing and form the trough.
Peak and Trough Prices
• The peak price of a complete swing high is the high price of either the red candle that completes the swing high or the high price of the preceding green candle, depending on which is higher.
• The trough price of a complete swing low is the low price of either the green candle that completes the swing low or the low price of the preceding red candle, depending on which is lower.
Historic Peaks and Troughs
The current, or most recent, peak and trough occurrences are referred to as occurrence zero. Previous peak and trough occurrences are referred to as historic and ordered numerically from right to left, with the most recent historic peak and trough occurrences being occurrence one.
Upper Trends
• A return line uptrend is formed when the current peak price is higher than the preceding peak price.
• A downtrend is formed when the current peak price is lower than the preceding peak price.
• A double-top is formed when the current peak price is equal to the preceding peak price.
Lower Trends
• An uptrend is formed when the current trough price is higher than the preceding trough price.
• A return line downtrend is formed when the current trough price is lower than the preceding trough price.
• A double-bottom is formed when the current trough price is equal to the preceding trough price.
Range
The range is simply the difference between the current peak and current trough prices, generally expressed in terms of points or pips.
Retracement and Extension Ratios
Retracement and extension ratios are calculated by dividing the current range by the preceding range and multiplying the answer by 100. Retracement ratios are those that are equal to or below 100% of the preceding range and extension ratios are those that are above 100% of the preceding range.
Measurement Tolerances
Tolerance refers to the allowable variation or deviation from a specific value or dimension. It is the range within which a particular measurement is considered to be acceptable or accurate. I have applied this concept in my pattern detection logic and have set default tolerances where applicable, as perfect patterns are, needless to say, very rare.
Chart Patterns
Generally speaking price charts are nothing more than a series of swing highs and swing lows. When demand outweighs supply over a period of time prices swing higher and when supply outweighs demand over a period of time prices swing lower. These swing highs and swing lows can form patterns that offer insight into the prevailing supply and demand dynamics at play at the relevant moment in time.
‘Let us assume… that you the reader, are not a member of that mysterious inner circle known to the boardrooms as “the insiders”… But it is fairly certain that there are not nearly so many “insiders” as amateur trader supposes and… It is even more certain that insiders can be wrong… Any success they have, however, can be accomplished only by buying and selling… hey can do neither without altering the delicate poise of supply and demand that governs prices. Whatever they do is sooner or later reflected on the charts where you… can detect it. Or detect, at least, the way in which the supply-demand equation is being affected… So, you do not need to be an insider to ride with them frequently… prices move in trends. Some of those trends are straight, some are curved; some are brief and some are long and continued… produced in a series of action and reaction waves of great uniformity. Sooner or later, these trends change direction; they may reverse (as from up to down), or they may be interrupted by some sort of sideways movement and then, after a time, proceed again in their former direction… when a price trend is in the process of reversal… a characteristic area or pattern takes shape on the chart, which becomes recognisable as a reversal formation… Needless to say, the first and most important task of the technical chart analyst is to learn to know the important reversal formations and to judge what they may signify in terms of trading opportunities’ (Edwards & Magee, 1948).
This is as true today as it was when Edwards and Magee were writing in the first half of the last Century, study your patterns and make judgements for yourself about what their implications truly are on the markets and timeframes you are interested in trading.
Over the years, traders have come to discover a multitude of chart and candlestick patterns that are supposed to pertain information on future price movements. However, it is never so clear cut in practice and patterns that where once considered to be reversal patterns are now considered to be continuation patterns and vice versa. Bullish patterns can have bearish implications and bearish patterns can have bullish implications. As such, I would highly encourage you to do your own backtesting.
There is no denying that chart patterns exist, but their implications will vary from market to market and timeframe to timeframe. So it is down to you as an individual to study them and make decisions about how they may be used in a strategic sense.
█ INPUTS
• Change pattern and label colours
• Show or hide patterns individually
• Adjust pattern ratios and tolerances
• Set or remove alerts for individual patterns
█ NOTES
I have decided to rename some of my previously published patterns based on the way in which the pattern completes. If the pattern completes on a swing high then the pattern is considered bearish, if the pattern completes on a swing low then it is considered bullish. This may seem confusing but it makes sense when you come to backtesting the patterns and want to use the most recent peak or trough prices as stop losses. Patterns that can complete on both a swing high and swing low are for such reasons treated as neutral, namely all broadening and wedge variations. I trust that it is quite self-evident that double and triple bottom patterns are considered bullish while double and triple top patterns are considered bearish, so I did not feel the need to rename those.
The patterns that have been renamed and what they have been renamed to, are as follows:
• Ascending Elliot Waves to Bearish Elliot Waves
• Descending Elliot Waves to Bullish Elliot Waves
• Ascending Head and Shoulders to Bearish Ascending Head and Shoulders
• Descending Head and Shoulders to Bearish Descending Head and Shoulders
• Head and Shoulders to Bearish Head and Shoulders
• Ascending Inverse Head and Shoulders to Bullish Ascending Head and Shoulders
• Descending Inverse Head and Shoulders to Bullish Descending Head and Shoulders
• Inverse Head and Shoulders to Bullish Head and Shoulders
You can test the patterns with your own strategies manually by applying the indicator to your chart while in bar replay mode and playing through the history. You could also automate this process with PineScript by using the conditions from my swing and pattern libraries as entry conditions in the strategy tester or your own custom made strategy screener.
█ LIMITATIONS
All green and red candle calculations are based on differences between open and close prices, as such I have made no attempt to account for green candles that gap lower and close below the close price of the preceding candle, or red candles that gap higher and close above the close price of the preceding candle. This may cause some unexpected behaviour on some markets and timeframes. I can only recommend using 24-hour markets, if and where possible, as there are far fewer gaps and, generally, more data to work with.
█ SOURCES
Edwards, R., & Magee, J. (1948) Technical Analysis of Stock Trends (10th edn). Reprint, Boca Raton, Florida: Taylor and Francis Group, CRC Press: 2013.
