Heikin Ashi Oscillator Trend Engine

MYNAMEISBRANDON · study · 2658 行 · 点赞 848 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

// ==============================================================================
//  Heikin Ashi Momentum Pressure
//  Author: © MYNAMEISBRANDON
//  License: Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// ==============================================================================
 
//@version=6
indicator("Heikin Ashi Oscillator Trend Engine ", "HA OSC💥", overlay=false, calc_bars_count=2500)
 
 
//  Heikin ASHI FUNCTION SOURCE
// ------------------------------------------------------------------------------
//  This script incorporates a Heikin Ashi calculation function adapted from
//  open-source work by @SimpleCryptoLife in his indicator "Better Heikin Ashi" (v4).
//  ➡️https://www.tradingview.com/v/Sz73I1P6/
//  ➡️https://simplecrypto.life/free-scripts/
//
//  His work showed how Heikin Ashi values can smooth price structure and make
//  directional shifts easier to read without requiring a full chart-type change.
//
//  In this script, that HA foundation is extended beyond candle visualization
//  and repurposed into a standalone oscillator engine. The resulting output uses
//  Heikin Ashi-derived values as the base for normalization, smoothing, and
//  momentum-style interpretation in a separate pane.
//
//
//  Heikin ASHI NOTES (adapted from @SimpleCryptoLife concepts)
// ------------------------------------------------------------------------------
//  • Heikin Ashi can smooth noisy price behavior and make directional movement
//    easier to read.
//  • HA direction changes can suggest reversal risk, pauses, or continuation,
//    but they are not stand-alone trade signals.
//  • In this script, HA is used as the foundation for a separate oscillator,
//    not as a replacement for the chart's real price.
//  • The oscillator is designed to help visualize momentum, directional pressure,
//    and general trend behavior from HA-derived inputs.
//  • Because these are derived values, they should be used with price structure,
//    support/resistance, volume, and other confirmation tools.
//  • Confirmed historical values do not repaint after bar close.
//    Live bars may still update while they are forming.
//
//  DISCLAIMER
// ------------------------------------------------------------------------------
//  • For educational and informational purposes only.
//  • Not financial advice.
//  • You are fully responsible for your own trading decisions.
//  • Always test and validate before using real money. Bar replay is a great tool 💥
// ==============================================================================
 
// ================================================================================
// 🟢 REGION: Core Imports
// ================================================================================
//
// 📌 Purpose:
//     Loads the SimpleCryptoLife higher-timeframe helper used to stabilize
//     requested HTF oscillator values inside a lower-timeframe pane.
//
// ================================================================================
 
import SimpleCryptoLife/HighTimeframeSampling/4  as SCL_HTF
import SimpleCryptoLife/LibraryTimeframeHelper/1 as TF
 
// ================================================================================
// 🔴 END REGION: Core Imports
// ================================================================================
 
// ==============================================================================================
// 🟢 REGION: Group Names
// ==============================================================================================
 
const string G_ENGINE        = "HA Engine Configuration"
const string G_CROSS         = "Adaptive MA Crossovers (faster)"
const string G_CROSS_SMA     = "SMA 20 / 50 Crossovers (slower)"
const string G_VWA           = "Rolling Volume Weighted Average of HA Engine"
const string G_HTF           = "Higher-Timeframe Plot of HA Engine"
const string G_PIVOT         = "Left/Right Trend Pivot Overlay"
const string G_GUIDE         = "Guide Lines"
const string G_VIS           = "Visuals"
const string G_PRICE_CANDLES = "Price Chart Plotcandles"
const string G_OSC_PRESSURE  = "HA Engine Candle Pressure"
const string G_TABLE         = "Engine Table"
 
// ==============================================================================================
// 🔴 END REGION: Group Names
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Tooltip Strings
// ==============================================================================================
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Main Settings
// ──────────────────────────────────────────────
const string TT_ENGINE_MODE =
     "Chooses which version of the oscillator the script uses.\n\n" +
     "• HA Range Base:\n" +
     "  A more direct and responsive version.\n" +
     "  It can react faster to changes, but may look less smooth.\n\n" +
     "• HA Blend:\n" +
     "  A smoother version built from several blended components.\n" +
     "  It can help reduce noise, but may react a little slower."
 
const string TT_PLOT_LAST =
     "Number of most recent bars shown for the histogram (default is plot.style_line) and any plots still tied to the main history control."
 
const string TT_PLOT_LAST_CANDLES =
     "Number of most recent bars shown for the oscillator candles.\n\n" +
     "Use this to control candle history independently from the histogram."
 
const string TT_DYNAMIC_LOOKBACK =
     "Controls how the script chooses the lookback window used for normalization and the adaptive guide lines.\n\n" +
     "Lookback = the number of bars used as the recent reference window.\n\n" +
     "• Dynamic:\n" +
     "  The script chooses the lookback automatically based on the chart timeframe.\n\n" +
     "• Manual:\n" +
     "  The script uses your Manual Lookback value instead.\n\n" +
     "Lower lookbacks react faster.\n" +
     "Higher lookbacks react more slowly."
 
const string TT_MANUAL_LOOKBACK =
     "Sets the exact number of bars used in the lookback window when Lookback Mode = Manual.\n\n" +
     "Examples:\n" +
     "• 55 = the last 55 bars\n" +
     "• 144 = the last 144 bars\n" +
     "• On a 5-minute chart, 144 bars ≈ 12 hours\n" +
     "• On a 1-hour chart, 144 bars ≈ 6 days\n" +
     "• On a 1-hour chart, 55 bars ≈ 2.3 days\n\n" +
     "Smaller values make the oscillator more reactive.\n" +
     "Larger values make it smoother and slower."
 
const string TT_USE_CLAMP =
     "Limits extreme oscillator spikes after z-score normalization."
 
// const string TT_CLAMP_RANGE =
//      "Maximum absolute value allowed when Clamp is enabled."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Range Base Engine
// ──────────────────────────────────────────────
const string TT_RANGE_LEN =
     "Sets the smoothing length for the HA Range Base engine.\n\n" +
     "Smaller values react faster but can look noisier.\n" +
     "Larger values react more slowly but look smoother."
 
const string TT_RANGE_TYPE =
     "Chooses the moving average type used by the HA Range Base engine.\n\n" +
     "• EMA reacts faster to recent changes\n" +
     "• SMA is steadier and slower"
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Blend Engine
// ──────────────────────────────────────────────
const string TT_BLEND_PAIR_SET =
     "Selects the HA Blend preset used to build the blend engine.\n\n" +
     "• Fast:\n" +
     "  Uses the tighter early Fibonacci-style ladder.\n" +
     "  Pairs: 5/8, 8/13, 13/21, 21/34\n\n" +
     "• Balanced:\n" +
     "  Uses the middle ladder.\n" +
     "  Pairs: 13/21, 21/34, 34/55, 55/89\n\n" +
     "• Slow:\n" +
     "  Uses the slower ladder.\n" +
     "  Pairs: 34/55, 55/89, 89/144, 144/233"
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Final Smoothing
// ──────────────────────────────────────────────
const string TT_FINAL_SMOOTH =
     "Adds one more smoothing step after the selected oscillator engine is built.\n\n" +
     "This can make the oscillator look cleaner and less noisy,\n" +
     "but it may also make signals react a little later."
 
const string TT_FINAL_SMOOTH_LEN =
     "Sets how strong the final smoothing step is.\n\n" +
     "Smaller values keep the oscillator more responsive.\n" +
     "Larger values make it smoother and slower."
 
const string TT_FINAL_SMOOTH_TYPE =
     "Chooses the moving average type used for the final smoothing step.\n\n" +
     "• EMA reacts faster\n" +
     "• SMA is steadier"
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Adaptive Crossovers
// ──────────────────────────────────────────────
const string TT_CROSS_MODE =
     "Shows or hides the main crossover lines.\n\n" +
     "These lines compare a faster oscillator average against a slower one\n" +
     "to help show shifts in momentum."
 
const string TT_CROSS_FILL_MODE =
     "Shows or hides the colored fill between the main fast and slow crossover lines."
 
const string TT_TF_MODE_CROSS =
     "Chooses how the fast and slow crossover lengths are set.\n\n" +
     "• Auto:\n" +
     "  The script adjusts the lengths for the current chart timeframe.\n\n" +
     "• Manual:\n" +
     "  The script uses the Fast Line Length and Slow Line Length values you choose."
 
const string TT_FAST_MA_TYPE =
     "Chooses the moving average type for the faster crossover line.\n\n" +
     "EMA usually reacts faster.\n" +
     "SMA is usually smoother."
 
const string TT_FAST_LEN_MANUAL =
     "Sets the length of the faster crossover line when Signal Crossover Mode = Manual.\n\n" +
     "Smaller values react faster."
 
const string TT_SLOW_MA_TYPE =
     "Chooses the moving average type for the slower crossover line."
 
const string TT_SLOW_LEN_MANUAL =
     "Sets the length of the slower crossover line when Signal Crossover Mode = Manual.\n\n" +
     "Larger values react more slowly and create a steadier baseline."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: SMA 20 / 50 Crossovers
// ──────────────────────────────────────────────
const string TT_SIGNALS_MODE_SMA =
     "Shows or hides the fixed 20 / 50 crossover lines.\n\n" +
     "This is a more traditional crossover view that does not adapt by timeframe."
 
const string TT_FILL_MODE_SMA =
     "Shows or hides the fill between the 20 / 50 crossover lines."
 
const string TT_FAST_MA_TYPE_SMA =
     "Chooses the moving average type for the faster 20-length line."
 
const string TT_FAST_LEN_SMA =
     "Sets the length of the faster line in this fixed crossover pair."
 
const string TT_SLOW_MA_TYPE_SMA =
     "Chooses the moving average type for the slower 50-length line."
 
const string TT_SLOW_LEN_SMA =
     "Sets the length of the slower line in this fixed crossover pair."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Oscillator Volume-Weighted Average
// ──────────────────────────────────────────────
const string TT_SHOW_OSC_VWA =
     "Shows a volume-weighted average of the selected oscillator.\n\n" +
     "Higher-volume bars contribute more heavily to the average, which helps the line respond more to stronger participation."
 
const string TT_OSC_VWA_DISPLAY_MODE =
     "Controls how the oscillator's volume-weighted average is displayed.\n\n" +
     "• Last 'N' Bars → shows only the most recent segment\n" +
     "• None → hides the plot"
 
const string TT_OSC_VWA_SHOW_LAST =
     "Number of most recent bars shown for the oscillator VWA plot."
 
const string TT_OSC_VWA_LEN_MODE =
     "Controls whether the oscillator VWA length is selected automatically by timeframe or manually."
 
const string TT_OSC_VWA_LEN =
     "Lookback length used by the oscillator's volume-weighted average when Length Mode = Manual.\n\n" +
     "Higher values smooth the line more.\n" +
     "Lower values make it more reactive.\n\n" +
     "Auto reference:\n" +
     "• <1m (Seconds) → 55\n" +
     "• 1–3m          → 21\n" +
     "• 5–10m         → 34\n" +
     "• 15–30m        → 48\n" +
     "• 1–2h          → 55\n" +
     "• 4–8h          → 48\n" +
     "• 1D–21D        → 34\n" +
     "• 1W–10W        → 21\n" +
     "• 1M–12M        → 13"
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Higher-Timeframe Oscillator
// ──────────────────────────────────────────────
const string TT_USE_DYNAMIC_HTF =
     "Chooses how the higher-timeframe oscillator reference line is selected.\n\n" +
     "• Dynamic:\n" +
     "  The script automatically steps up to a higher timeframe.\n" +
     "  Example: a 5-minute chart may use a higher reference like 15-minute.\n\n" +
     "• Manual:\n" +
     "  The script uses the exact higher timeframe you choose below."
 
const string TT_MANUAL_HTF_SELECTION =
     "Sets the higher timeframe used when HTF Mode = Manual.\n\n" +
     "Example:\n" +
     "• If your chart is 5m and you choose 60, the blue HTF oscillator line comes from the 1-hour timeframe.\n\n" +
     "Chart = use the current chart timeframe instead."
 
const string TT_HTF_OSC_DISPLAY_MODE =
     "Controls how the higher-timeframe oscillator reference line is displayed.\n\n" +
     "• Last N Bars → shows only the most recent segment\n" +
     "• None → hides the HTF oscillator reference line"
 
const string TT_HTF_OSC_SHOW_LAST =
     "Number of most recent bars shown when HTF Oscillator Display Mode = Last N Bars."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Trend Pivot Overlay
// ──────────────────────────────────────────────
const string TT_SHOW_PIVOT_OVERLAY =
     "Shows a structure line built from confirmed oscillator pivot highs and pivot lows.\n\n" +
     "This can help you see whether the oscillator is currently leaning from a recent high pivot or a recent low pivot."
 
const string TT_SHOW_PIVOT_OVERLAY_OBJ =
     "Shows or hides the horizontal pivot-based line object.\n\n" +
     "This is separate from the plotted Trend Pivot Overlay line, so you can show either one or both."
 
const string TT_PIVOT_MODE =
     "Chooses which confirmed pivot the overlay follows.\n\n" +
     "• Pivot High = always follows confirmed oscillator highs\n" +
     "• Pivot Low = always follows confirmed oscillator lows\n" +
     "• Dynamic = switches between them based on recent structure"
 
const string TT_LEFT_BARS =
     "Sets how many bars to the left are required to confirm a pivot.\n\n" +
     "Higher values usually make pivots stricter and less frequent."
 
const string TT_RIGHT_BARS =
     "Sets how many bars to the right are required before a pivot is confirmed.\n\n" +
     "Higher values delay confirmation, but can reduce false pivots."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Guide Lines
// ──────────────────────────────────────────────
const string TT_GUIDE_SHOW_LAST =
     "Number of most recent bars shown for the guide lines.\n\n" +
     "This lets you control guide-line history separately from the histogram and other plots."
 
const string TT_SHOW_ZERO =
     "Shows the zero line, which is the oscillator's center baseline.\n\n" +
     "Readings above zero are positive relative to the script's current calculation.\n" +
     "Readings below zero are negative."
 
const string TT_SHOW_HALF =
     "Shows the adaptive +50% and -50% guide lines.\n\n" +
     "These are not fixed levels.\n" +
     "They move with the oscillator's recent range and can help show when the oscillator is stretching away from zero."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Visuals
// ──────────────────────────────────────────────
const string TT_SHOW_HIST =
     "Shows or hides the main oscillator plot."
 
const string TT_SHOW_OSC_CANDLES =
     "Shows candle-style bars built from the oscillator instead of price.\n\n" +
     "This can make it easier to see whether the oscillator is expanding, slowing, or reversing from one bar to the next."
 
const string TT_OSC_CANDLE_TRANSP =
     "Controls the body transparency of the oscillator candles.\n\n" +
     "0 = solid\n" +
     "100 = invisible"
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Engine Table
// ──────────────────────────────────────────────
const string TT_SHOW_ENGINE_TABLE =
     "Shows a compact table that summarizes the active oscillator engine.\n\n" +
     "The matching engine-detail row is highlighted so users can quickly see\n" +
     "whether the script is currently running the HA Range Base path or the\n" +
     "HA Blend path."
 
const string TT_ENGINE_TABLE_POS =
     "Controls where the Engine Table appears inside the oscillator pane."
 
const string TT_ENGINE_TABLE_TEXT =
     "Controls the text size used by the Engine Table."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Price Overlay Candles
// ──────────────────────────────────────────────
const string TT_PRICE_CANDLE_MODE =
     "Controls whether the script draws colored candles on the main price chart.\n\n" +
     "• Oscillator Colors:\n" +
     "  Price candles are colored by the oscillator's current color state.\n\n" +
     "• None:\n" +
     "  No overlay candles are drawn."
 
const string TT_PRICE_CANDLE_SHOW_LAST =
     "Sets how many of the most recent chart candles are drawn with the oscillator-color overlay."
 
const string TT_PRICE_CANDLE_BODY_TRANSP =
     "Controls the body transparency of the overlay candles drawn on the main price chart.\n\n" +
     "0 = solid body\n" +
     "100 = invisible body\n\n" +
     "Wicks and borders stay fully visible."
 
// ──────────────────────────────────────────────
// 🟦 Subregion: OSC Candle Pressure Envelope Tooltips
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     These tooltips explain the controls used to build and style the
//     oscillator candle pressure envelope.
//
// 🧠 What these settings control:
//     • Whether the envelope is shown
//     • The upper and lower trigger levels
//     • How thick the envelope is around the oscillator candles
//     • What colors are used when upper or lower pressure is active
//
const string TT_SHOW_OSC_PRESSURE_ENV =
     "Wraps the oscillator candles in a pressure-style background envelope.\n\n" +
     "The envelope is built around each oscillator candle's high/low range,\n" +
     "then only turns on when the candle reaches the trigger levels below."
 
const string TT_OSC_PRESSURE_UPPER =
     "Upper trigger level for the oscillator candle pressure envelope.\n\n" +
     "When the oscillator candle reaches or exceeds this level,\n" +
     "the upper pressure envelope fill turns on."
 
const string TT_OSC_PRESSURE_LOWER =
     "Lower trigger level for the oscillator candle pressure envelope.\n\n" +
     "When the oscillator candle reaches or falls below this level,\n" +
     "the lower pressure envelope fill turns on."
 
const string TT_OSC_PRESSURE_PAD =
     "Extra padding added above and below the oscillator candle range\n" +
     "when drawing the pressure envelope.\n\n" +
     "Higher values make the envelope thicker."
 
const string TT_OSC_PRESSURE_UPPER_COLOR =
     "Fill color used when the oscillator candle reaches the upper trigger."
 
const string TT_OSC_PRESSURE_LOWER_COLOR =
     "Fill color used when the oscillator candle reaches the lower trigger."
 
const string TT_OSC_PRESSURE_FILL_TRANSP =
     "Controls the transparency used by both oscillator pressure-envelope fills.\n\n" +
     "0 = solid fill\n" +
     "100 = invisible fill"
 
// ==============================================================================================
// 🔴 END REGION: Tooltip Strings
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Inputs
// ==============================================================================================
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Engine Configuration
// ──────────────────────────────────────────────
string in_lookbackMode = input.string(
     defval="Dynamic",
     title="Lookback Mode",
     options=["Dynamic", "Manual"],
     group=G_ENGINE,
     tooltip=TT_DYNAMIC_LOOKBACK)
 
bool in_useDynamicLookback =
     in_lookbackMode == "Dynamic"
 
int in_manualLookback = input.int(
     defval=144,
     minval=10,
     title="  ↳ Manual Lookback",
     group=G_ENGINE,
     tooltip=TT_MANUAL_LOOKBACK)
 
bool in_useClamp = true //input.bool(
    //  defval=true,
    //  title="Clamp Output",
    //  group=G_ENGINE,
    //  tooltip=TT_USE_CLAMP)
 
float in_clampRange = 15.0
 
string in_engineMode = input.string(
     defval="HA Blend",
     title="Engine Mode",
     options=["HA Range Base", "HA Blend"],
     group=G_ENGINE,
     tooltip=TT_ENGINE_MODE)
 
int in_rangeLen = input.int(
     defval=55,
     minval=1,
     title="  ↳ HA Range Base Length",
     group=G_ENGINE,
     tooltip=TT_RANGE_LEN)
 
string in_rangeMaType = input.string(
     defval="EMA",
     title="  ↳ HA Range Base MA Type",
     options=["EMA", "SMA"],
     group=G_ENGINE,
     tooltip=TT_RANGE_TYPE)
 
string in_blendPairSet = input.string(
     defval="Balanced",
     title="  ↳ HA Blend Pair Set",
     options=["Fast", "Balanced", "Slow"],
     group=G_ENGINE,
     tooltip=TT_BLEND_PAIR_SET)
 
string in_finalSmoothMode = input.string(
     defval="On",
     title="Final Smoothing (Both Engines)",
     options=["On", "Off"],
     group=G_ENGINE,
     tooltip=TT_FINAL_SMOOTH)
 
bool in_useFinalSmooth =
     in_finalSmoothMode == "On"
 
int in_finalSmoothLen = input.int(
     defval=3,
     minval=1,
     title="  ↳ Final Smoothing Length",
     group=G_ENGINE,
     tooltip=TT_FINAL_SMOOTH_LEN)
 
string in_finalSmoothType = input.string(
     defval="EMA",
     title="  ↳ Final Smoothing Type",
     options=["EMA", "SMA"],
     group=G_ENGINE,
     tooltip=TT_FINAL_SMOOTH_TYPE)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Adaptive Crossovers
// ──────────────────────────────────────────────
string in_crossMode = input.string(
     defval="Show Crossovers",
     title="Adaptive Crossovers",
     options=["Show Crossovers", "None"],
     group=G_CROSS,
     tooltip=TT_CROSS_MODE)
 
bool in_showCrossLines =
     in_crossMode == "Show Crossovers"
 
string in_crossFillMode = input.string(
     defval="Show Fill",
     title="Fill Crossovers",
     options=["Show Fill", "None"],
     group=G_CROSS,
     tooltip=TT_CROSS_FILL_MODE)
 
bool in_showCrossFill =
     in_crossFillMode == "Show Fill"
 
string in_tfMode_Cross = input.string(
     defval="Auto",
     title="Signal Crossover Mode",
     options=["Auto", "Manual"],
     group=G_CROSS,
     tooltip=TT_TF_MODE_CROSS)
 
string in_fastMaType = input.string(
     defval="EMA",
     title="Fast Line Type",
     options=["EMA", "SMA"],
     group=G_CROSS,
     tooltip=TT_FAST_MA_TYPE)
 
int in_fastLen_manual = input.int(
     defval=5,
     minval=1,
     title="Fast Line Length",
     group=G_CROSS,
     tooltip=TT_FAST_LEN_MANUAL)
 
string in_slowMaType = input.string(
     defval="EMA",
     title="Slow Line Type",
     options=["EMA", "SMA"],
     group=G_CROSS,
     tooltip=TT_SLOW_MA_TYPE)
 
int in_slowLen_manual = input.int(
     defval=21,
     minval=1,
     title="Slow Line Length",
     group=G_CROSS,
     tooltip=TT_SLOW_LEN_MANUAL)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: SMA 20 / 50 Crossovers
// ──────────────────────────────────────────────
string in_SignalsMode_sma = input.string(
     defval="Show Crossovers",
     title="SMA 20/50 Crossovers",
     options=["Show Crossovers", "None"],
     group=G_CROSS_SMA,
     tooltip=TT_SIGNALS_MODE_SMA)
 
bool in_showSignals_sma =
     in_SignalsMode_sma == "Show Crossovers"
 
string in_FillMode_sma = input.string(
     defval="Show Fill",
     title="Fill SMA 20/50 Crossovers",
     options=["Show Fill", "None"],
     group=G_CROSS_SMA,
     tooltip=TT_FILL_MODE_SMA)
 
bool in_showFill_sma =
     in_FillMode_sma == "Show Fill"
 
string in_MaType_fast_sma = input.string(
     defval="SMA",
     title="Fast Line Type",
     options=["EMA", "SMA"],
     group=G_CROSS_SMA,
     tooltip=TT_FAST_MA_TYPE_SMA)
 
int in_Len_fast_sma = input.int(
     defval=20,
     minval=1,
     title="Fast Line Length",
     group=G_CROSS_SMA,
     tooltip=TT_FAST_LEN_SMA)
 
string in_MaType_slow_sma = input.string(
     defval="SMA",
     title="Slow Line Type",
     options=["EMA", "SMA"],
     group=G_CROSS_SMA,
     tooltip=TT_SLOW_MA_TYPE_SMA)
 
int in_Len_slow_sma = input.int(
     defval=50,
     minval=1,
     title="Slow Line Length",
     group=G_CROSS_SMA,
     tooltip=TT_SLOW_LEN_SMA)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Oscillator Volume-Weighted Average
// ──────────────────────────────────────────────
string in_showOscVwaMode = input.string(
     defval="Show",
     title="Show Oscillator VWA",
     options=["Show", "Hide"],
     group=G_VWA,
     tooltip=TT_SHOW_OSC_VWA)
 
bool in_showOscVwa =
     in_showOscVwaMode == "Show"
 
string in_oscVwaDisplayMode = input.string(
     defval="Last 'N' Bars",
     title="Oscillator VWA Display Mode",
     options=["Last 'N' Bars", "None"],
     group=G_VWA,
     tooltip=TT_OSC_VWA_DISPLAY_MODE)
 
int in_oscVwaShowLast = input.int(
     defval=55,
     minval=1,
     title="Oscillator VWA - Show Last 'N' Bars",
     group=G_VWA,
     tooltip=TT_OSC_VWA_SHOW_LAST)
 
string in_oscVwaLenMode = input.string(
     defval="Auto",
     title="Oscillator VWA Length Mode",
     options=["Auto", "Manual"],
     group=G_VWA,
     tooltip=TT_OSC_VWA_LEN_MODE)
 
int in_oscVwaLenManual = input.int(
     defval=55,
     minval=1,
     title="Oscillator VWA Length",
     group=G_VWA,
     tooltip=TT_OSC_VWA_LEN)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Higher-Timeframe Oscillator
// ──────────────────────────────────────────────
string in_htfMode = input.string(
     defval="Dynamic",
     title="HTF Mode",
     options=["Dynamic", "Manual"],
     group=G_HTF,
     tooltip=TT_USE_DYNAMIC_HTF)
 
bool in_useDynamicHtf =
     in_htfMode == "Dynamic"
 
string in_manualHtfSelection = input.string(
     defval="Chart",
     title="Manual Higher Timeframe",
     options=["Chart", "30S", "1", "2", "3", "4", "5", "10", "15", "30", "45", "60", "120", "240", "480", "D", "W", "2W", "M", "2M"],
     group=G_HTF,
     tooltip=TT_MANUAL_HTF_SELECTION)
 
string in_htfOscMode = input.string(
     defval="Last N Bars",
     title="HTF Oscillator Display Mode",
     options=["Last N Bars", "None"],
     group=G_HTF,
     tooltip=TT_HTF_OSC_DISPLAY_MODE)
 
int in_htfOscShowLast = input.int(
     defval=55,
     minval=1,
     maxval=1000,
     title="HTF Oscillator - Show Last 'N' Bars",
     group=G_HTF,
     tooltip=TT_HTF_OSC_SHOW_LAST)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Trend Pivot Overlay
// ──────────────────────────────────────────────
string in_trendOverlayMode = input.string(
     defval="Hide",
     title="Trend Pivot Overlay",
     options=["Show", "Hide"],
     group=G_PIVOT,
     tooltip=TT_SHOW_PIVOT_OVERLAY)
 
bool in_showTrendOverlay =
     in_trendOverlayMode == "Show"
 
string in_trendOverlayObjMode = input.string(
     defval="Show",
     title="Trend Pivot Overlay Object Line",
     options=["Show", "Hide"],
     group=G_PIVOT,
     tooltip=TT_SHOW_PIVOT_OVERLAY_OBJ)
 
bool in_showTrendOverlayObj =
     in_trendOverlayObjMode == "Show"
 
string in_pivotMode = input.string(
     defval="Dynamic",
     title="Pivot Anchor Mode",
     options=["Pivot High", "Pivot Low", "Dynamic"],
     group=G_PIVOT,
     tooltip=TT_PIVOT_MODE)
 
int in_leftBars = input.int(
     defval=21,
     minval=1,
     title="Left Bars",
     group=G_PIVOT,
     tooltip=TT_LEFT_BARS)
 
int in_rightBars = input.int(
     defval=5,
     minval=1,
     title="Right Bars",
     group=G_PIVOT,
     tooltip=TT_RIGHT_BARS)
 
color in_overlayBullColor = input.color(
     defval=color.orange,
     title="Trend Overlay Bull Color",
     group=G_PIVOT)
 
color in_overlayBearColor = input.color(
     defval=#f51673,
     title="Trend Overlay Bear Color",
     group=G_PIVOT)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Guide Lines
// ──────────────────────────────────────────────
int in_guideShowLast = input.int(
     defval=233,
     minval=1,
     title="Guide Lines Plot Last N Bars",
     group=G_GUIDE,
     tooltip=TT_GUIDE_SHOW_LAST)
 
string in_zeroLineMode = input.string(
     defval="Show",
     title="Zero Line",
     options=["Show", "Hide"],
     group=G_GUIDE,
     tooltip=TT_SHOW_ZERO)
 
bool in_showZeroLine =
     in_zeroLineMode == "Show"
 
string in_halfLinesMode = input.string(
     defval="Show",
     title="±50% Guide Lines",
     options=["Show", "Hide"],
     group=G_GUIDE,
     tooltip=TT_SHOW_HALF)
 
bool in_showHalfLines =
     in_halfLinesMode == "Show"
 
color in_zeroLineColor = input.color(
     defval=#dbdbdb,
     title="Zero Line Color",
     group=G_GUIDE)
 
color in_upperGuideColor = input.color(
     defval=#ff693b,
     title="+50% Guide Color",
     group=G_GUIDE)
 
color in_lowerGuideColor = input.color(
     defval=#f32753,
     title="-50% Guide Color",
     group=G_GUIDE)
 
/// ──────────────────────────────────────────────
// 🟦 Subregion: Visuals
// ──────────────────────────────────────────────
string in_oscCandlesMode = input.string(
     defval="Show",
     title="Oscillator Candles",
     options=["Show", "Hide"],
     group=G_VIS,
     tooltip=TT_SHOW_OSC_CANDLES)
 
bool in_showOscCandles =
     in_oscCandlesMode == "Show"
 
int in_oscCandleTransp = input.int(
     defval=65,
     minval=0,
     maxval=100,
     title="  ↳Oscillator Candle Body Transparency",
     group=G_VIS,
     tooltip=TT_OSC_CANDLE_TRANSP)
 
int in_plotLastCandles = input.int(
     defval=144,
     minval=1,
     title="  ↳ Oscillator Candle Plot Last N Bars",
     group=G_VIS,
     tooltip=TT_PLOT_LAST_CANDLES)
 
string in_histogramMode = input.string(
     defval="Show",
     title="Histogram",
     options=["Show", "Hide"],
     group=G_VIS,
     tooltip=TT_SHOW_HIST)
 
int in_plotLast = input.int(
     defval=21,
     minval=1,
     title="  ↳ Histogram Plot Last N Bars",
     group=G_VIS,
     tooltip=TT_PLOT_LAST)
 
bool in_showHistogram =
     in_histogramMode == "Show"
 
// string in_colorPriceBarsMode = input.string(
//      defval="Hide",
//      title="Color Price Bars",
//      options=["Show", "Hide"],
//      group=G_VIS,
//      tooltip=TT_COLOR_PRICE_BARS)
 
// bool in_colorPriceBars =
//      in_colorPriceBarsMode == "Show"
 
color in_colAboveRise = input.color(
     defval=color.orange,
     title="Above 0 Rising",
     group=G_VIS)
 
color in_colAboveFall = input.color(
     defval=color.new(#fff177, 0),
     title="Above 0 Falling",
     group=G_VIS)
 
color in_colBelowFall = input.color(
     defval=color.new(#57585c, 0),
     title="Below 0 Falling",
     group=G_VIS)
 
color in_colBelowRise = input.color(
     defval=color.new(#97999e, 0),
     title="Below 0 Rising",
     group=G_VIS)
 
color in_colAbove50Rise = input.color(
     defval=#ff5900,
     title="Above +50 Rising",
     group=G_VIS)
 
color in_colBelow50Fall = input.color(
     defval=#e900ca,
     title="Below -50 Falling",
     group=G_VIS)
 
color in_crossBullColor = input.color(
     defval=color.rgb(44, 161, 190),
     title="Cross Bull Color",
     group=G_VIS)
 
color in_crossBearColor = input.color(
     defval=#f51673,
     title="Cross Bear Color",
     group=G_VIS)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Engine Table
// ──────────────────────────────────────────────
string in_engineTableMode = input.string(
     defval="Show",
     title="Engine Table",
     options=["Show", "Hide"],
     group=G_TABLE,
     tooltip=TT_SHOW_ENGINE_TABLE)
 
bool in_showEngineTable =
     in_engineTableMode == "Show"
 
string in_engineTablePos = input.string(
     defval="Middle Right",
     title="Engine Table Position",
     options=["Top Left", "Top Center", "Top Right", "Middle Left", "Middle Center", "Middle Right", "Bottom Left", "Bottom Center", "Bottom Right"],
     group=G_TABLE,
     tooltip=TT_ENGINE_TABLE_POS)
 
string in_engineTableTextSize = input.string(
     defval="Normal",
     title="Engine Table Text Size",
     options=["Tiny", "Small", "Normal", "Large"],
     group=G_TABLE,
     tooltip=TT_ENGINE_TABLE_TEXT)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Price Chart Plotcandles
// ──────────────────────────────────────────────
string in_priceCandleMode = input.string(
     defval="Oscillator Colors",
     title="Price Chart Plotcandles",
     options=["Oscillator Colors", "None"],
     group=G_PRICE_CANDLES,
     tooltip=TT_PRICE_CANDLE_MODE)
 
bool in_showPriceCandles =
     in_priceCandleMode != "None"
 
bool in_useOscColorForPriceCandles =
     in_priceCandleMode == "Oscillator Colors"
 
int in_priceCandleShowLast = input.int(
     defval=233,
     minval=1,
     title="  ↳ Price Chart Plotcandles - Last N Bars",
     group=G_PRICE_CANDLES,
     tooltip=TT_PRICE_CANDLE_SHOW_LAST)
 
int in_priceCandleBodyTransp = input.int(
     defval=70,
     minval=0,
     maxval=100,
     title="  ↳ Price Chart Plotcandles Transparency",
     group=G_PRICE_CANDLES,
     tooltip=TT_PRICE_CANDLE_BODY_TRANSP)
 
/// ──────────────────────────────────────────────
// 🟦 Subregion: OSC Candle Pressure Envelope
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Controls the pressure-style envelope that wraps the oscillator candles
//     when they reach user-defined upper or lower trigger zones.
//
// 🧠 What these settings control:
//     • Whether the envelope is shown
//     • The upper and lower trigger levels
//     • The padding used to wrap the oscillator candle range
//     • The fill colors used for upper and lower pressure states
//
string in_oscPressureEnvelopeMode = input.string(
     defval="Show",
     title="OSC Candle Pressure Envelope",
     options=["Show", "Hide"],
     group=G_OSC_PRESSURE,
     tooltip=TT_SHOW_OSC_PRESSURE_ENV)
 
bool in_showOscPressureEnvelope =
     in_oscPressureEnvelopeMode == "Show"
 
float in_oscPressureUpperTrigger = input.float(
     defval=0.50,
     step=0.05,
     title="Upper Trigger",
     group=G_OSC_PRESSURE,
     tooltip=TT_OSC_PRESSURE_UPPER)
 
float in_oscPressureLowerTrigger = input.float(
     defval=-0.50,
     step=0.05,
     title="Lower Trigger",
     group=G_OSC_PRESSURE,
     tooltip=TT_OSC_PRESSURE_LOWER)
 
float in_oscPressureEnvelopePad = input.float(
     defval=0.05,
     minval=0.0,
     step=0.01,
     title="Envelope Padding",
     group=G_OSC_PRESSURE,
     tooltip=TT_OSC_PRESSURE_PAD)
 
color in_oscPressureUpperFill = input.color(
     defval=#ff5900,
     title="Upper Envelope Fill",
     group=G_OSC_PRESSURE,
     tooltip=TT_OSC_PRESSURE_UPPER_COLOR)
 
color in_oscPressureLowerFill = input.color(
     defval=#e900ca,
     title="Lower Envelope Fill",
     group=G_OSC_PRESSURE,
     tooltip=TT_OSC_PRESSURE_LOWER_COLOR)
 
int in_oscPressureFillTransp = input.int(
     defval=75,
     minval=0,
     maxval=100,
     title="Fill Transparency",
     group=G_OSC_PRESSURE,
     tooltip=TT_OSC_PRESSURE_FILL_TRANSP)
 
// ==============================================================================================
// 🔴 END REGION: Inputs
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Helpers
// ==============================================================================================
//
// 📌 Purpose:
//     Houses the small reusable utility functions that support the core HA engine,
//     normalization, slope logic, color logic, and Heikin Ashi calculations.
//
// 🧩 Why this matters in this script:
//     These helpers keep the main engine regions cleaner and make shared logic
//     easier to reuse consistently across the script.
//
// ==============================================================================================
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Moving Average Selector
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Returns either an SMA or EMA from the same source and length inputs.
//
// 🧠 Behavior:
//     • Calculates both SMA and EMA each bar
//     • Returns the one selected by `_type`
//     • Keeps TA calls outside the final ternary decision so Pine evaluates
//       them consistently bar to bar
//
// 🧩 Why this matters in this script:
//     This helper is reused anywhere the script lets the user choose between
//     SMA and EMA behavior, such as the Range Base engine and crossover engines.
//
f_ma(float _src, int _len, string _type) =>
    float _sma = ta.sma(_src, _len)
    float _ema = ta.ema(_src, _len)
    _type == "SMA" ? _sma : _ema
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Adaptive Lookback Resolver
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Chooses the lookback window used by normalization and adaptive guide logic.
//
// 🧠 Behavior:
//     • If `_dynamic` is false, the function returns the manual input
//     • If `_dynamic` is true, the function maps the current chart timeframe
//       by timeframe family and multiplier instead of exact string matches
//     • This keeps extended periods like 2D, 3D, 2W, and 6M inside a
//       dynamic bucket instead of falling back to manual
//
// 🧩 Why this matters in this script:
//     This keeps normalization and guide-line behavior more consistent across
//     expanded daily / weekly / monthly chart periods.
//
f_lookback(bool _dynamic, int _manual) =>
    if not _dynamic
        _manual
    else if timeframe.isseconds
        timeframe.multiplier <= 30 ? 377 :
         timeframe.multiplier <= 45 ? 233 :
         _manual
    else if timeframe.isminutes
        timeframe.multiplier <= 3 ? 233 :
         timeframe.multiplier <= 15 ? 144 :
         timeframe.multiplier <= 30 ? 89 :
         timeframe.multiplier <= 120 ? 55 :
         timeframe.multiplier <= 480 ? 34 :
         21
    else if timeframe.isdaily
        timeframe.multiplier <= 34 ? 21 : 13
    else if timeframe.isweekly
        timeframe.multiplier <= 21 ? 13 : 8
    else if timeframe.ismonthly
        timeframe.multiplier <= 12 ? 8 : 5
    else
        _manual
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Z-Score Normalization + Clamp
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Normalizes a source series by its rolling standard deviation, then
//     optionally clamps extreme values.
//
// 🧠 Behavior:
//     • Computes rolling standard deviation over `_len`
//     • Converts the source into a simplified z-score style reading
//     • If `_useClamp` is true, limits the final value to the range
//       `-_clamp` to `+_clamp`
//
// 🧩 Why this matters in this script:
//     This helps keep oscillator values more consistent across tickers and
//     timeframes while preventing a few extreme spikes from distorting the panel.
//
f_zscoreClamp(float _src, int _len, bool _useClamp, float _clamp) =>
    float _stdev = ta.stdev(_src, _len)
    float _z = _stdev != 0 ? _src / _stdev : 0
    _useClamp ? math.max(math.min(_z, _clamp), -_clamp) : _z
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Quadrant Color Resolver
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Assigns one of four colors to the oscillator based on two conditions:
//     • whether the value is above or below zero
//     • whether the value is rising or falling versus the prior bar
//
// 🧠 Behavior:
//     • Above 0 + Rising  → `_upRise`
//     • Above 0 + Falling → `_upFall`
//     • Below 0 + Falling → `_dnFall`
//     • Below 0 + Rising  → `_dnRise`
//
// 🧩 Why this matters in this script:
//     This is the shared color engine that gives the histogram and oscillator
//     candles their four-quadrant momentum look.
//
f_quadrantColor(float _src, color _upRise, color _upFall, color _dnFall, color _dnRise) =>
    bool _rising = _src > _src[1]
    bool _falling = _src < _src[1]
    _src >= 0 and _rising  ? _upRise :
     _src >= 0 and _falling ? _upFall :
     _src < 0 and _falling ? _dnFall :
     _dnRise
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Threshold Visual Color Resolver
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Extends the script's visual color logic to recognize the adaptive +50 / -50
//     guide zones in addition to the zero-line quadrants.
//
// 🧠 Behavior:
//     • Above +50 + Rising  → special dark orange
//     • Above 0  + Falling  → existing yellow
//     • Above 0  + Rising   → existing orange
//     • Below -50 + Falling → special purple
//     • Below 0  + Falling  → existing dark gray
//     • Below 0  + Rising   → existing light gray
//
// 🧩 Why this matters in this script:
//     This lets the histogram, candles, follow line, price-overlay candles,
//     and Engine Table all respond to the same threshold-aware color logic.
//
f_visualThresholdColor(
     float _src,
     float _upperGuide,
     float _lowerGuide,
     color _above50Rise,
     color _above0Rise,
     color _above0Fall,
     color _below0Fall,
     color _below50Fall,
     color _below0Rise) =>
 
    bool _rising =
         _src > _src[1]
 
    bool _falling =
         _src < _src[1]
 
    bool _above50 =
         not na(_upperGuide) and
         _upperGuide > 0 and
         _src >= _upperGuide
 
    bool _below50 =
         not na(_lowerGuide) and
         _lowerGuide < 0 and
         _src <= _lowerGuide
 
    _above50 and _rising ? _above50Rise :
     _src >= 0 and _falling ? _above0Fall :
     _src >= 0 and _rising ? _above0Rise :
     _below50 and _falling ? _below50Fall :
     _src < 0 and _falling ? _below0Fall :
     _below0Rise
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Heiken Ashi Builder
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Calculates the synthetic Heikin Ashi OHLC values used by the script.
//
// 🧠 Behavior:
//     • Computes HA Open from the prior HA Open / HA Close relationship
//     • Computes HA Close from the average of the real OHLC values
//     • Computes HA High and HA Low from the current high/low and HA body
//     • Returns HA direction flags for bullish / bearish state
//
// 🧩 Why this matters in this script:
//     This is the foundation of the entire oscillator. Everything else in the
//     script begins with these HA-derived values rather than raw candle structure.
//
functionHeikinAshi(_open, _close, _high, _low, _haOpen1, _haClose1) =>
    float _iHAOpen = barstate.isfirst ? (_open + _close) / 2 : (_haOpen1 + _haClose1) / 2
    float _iHAClose = (_open + _close + _high + _low) / 4
    float _iHAHigh = barstate.isfirst ? _high : math.max(_high, _iHAOpen, _iHAClose)
    float _iHALow = barstate.isfirst ? _low : math.min(_low, _iHAOpen, _iHAClose)
    bool _iIsHAUp = _iHAClose > _iHAOpen
    bool _iIsHADown = _iHAClose <= _iHAOpen
    [_iHAOpen, _iHAClose, _iHAHigh, _iHALow, _iIsHAUp, _iIsHADown]
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Table Helpers
// ──────────────────────────────────────────────
f_tablePos(string _pos) =>
    _pos == "Top Left" ? position.top_left :
     _pos == "Top Center" ? position.top_center :
     _pos == "Top Right" ? position.top_right :
     _pos == "Middle Left" ? position.middle_left :
     _pos == "Middle Center" ? position.middle_center :
     _pos == "Middle Right" ? position.middle_right :
     _pos == "Bottom Left" ? position.bottom_left :
     _pos == "Bottom Center" ? position.bottom_center : position.bottom_right
 
f_tableTextSize(string _size) =>
    _size == "Tiny" ? size.tiny :
     _size == "Small" ? size.small :
     _size == "Large" ? size.large : size.normal
 
f_onOff(bool _v) =>
    _v ? "On" : "Off"
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Table Contrast Text Helper
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Chooses black or white table text based on the brightness of a cell's
//     background color.
//
// 🧠 Behavior:
//     • Estimates perceived brightness using a simple luma formula
//     • Returns black text for lighter backgrounds
//     • Returns white text for darker backgrounds
//
// 🧩 Why this matters in this script:
//     The Engine Table can now inherit live engine colors from the active
//     oscillator base, so this helper keeps the text readable regardless of
//     whether the row is currently orange, yellow, gray, or another quadrant color.
//
f_tableContrastText(color _bg) =>
    float _luma =
         color.r(_bg) * 0.299 +
         color.g(_bg) * 0.587 +
         color.b(_bg) * 0.114
    _luma >= 150 ? #000000 : color.white
    
// ==============================================================================================
// 🔴 END REGION: Helpers
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Heikin Ashi Foundation
// ==============================================================================================
 
var float HAOpen = 0.0
var float HAClose = 0.0
var float HAHigh = 0.0
var float HALow = 0.0
var bool isHAUp = false
var bool isHADown = false
 
[r_HAOpen, r_HAClose, r_HAHigh, r_HALow, r_isHAUp, r_isHADown] =
     functionHeikinAshi(
         open,
         close,
         high,
         low,
         HAOpen[1],
         HAClose[1])
 
HAOpen := r_HAOpen
HAClose := r_HAClose
HAHigh := r_HAHigh
HALow := r_HALow
isHAUp := r_isHAUp
isHADown := r_isHADown
 
int normPeriod = f_lookback(in_useDynamicLookback, in_manualLookback)
 
float haRangeNormPct =
     r_HAClose != 0 ? ((r_HAHigh - r_HALow) / r_HAClose) * 100 : 0
 
float haRangeSource =
     haRangeNormPct
 
float haSignedBase =
     isHAUp ? haRangeSource : -haRangeSource
 
float haSignedPrepared =
     f_zscoreClamp(
         haSignedBase,
         normPeriod,
         in_useClamp,
         in_clampRange)
 
// ==============================================================================================
// 🔴 END REGION: Heikin Ashi Foundation
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Range Base Engine
// ==============================================================================================
 
float rangeEngineCore =
     f_ma(
         haSignedPrepared,
         in_rangeLen,
         in_rangeMaType)
 
// ==============================================================================================
// 🔴 END REGION: Range Base Engine
// ==============================================================================================
 
/// ==============================================================================================
// 🟢 REGION: Blend Engine
// ==============================================================================================
 
// ──────────────────────────────────────────────
// 🟦 Subregion: HA Blend EMA Ladder
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Builds the EMA ladder used by the preset-driven HA Blend engine.
//
// 🧩 Why this matters in this script:
//     HA Blend now uses one selected Fibonacci-style pair set instead of a
//     manually mixed toggle collection.
//
float ha_5 = ta.ema(haSignedPrepared, 5)
float ha_8 = ta.ema(haSignedPrepared, 8)
float ha_13 = ta.ema(haSignedPrepared, 13)
float ha_21 = ta.ema(haSignedPrepared, 21)
float ha_34 = ta.ema(haSignedPrepared, 34)
float ha_55 = ta.ema(haSignedPrepared, 55)
float ha_89 = ta.ema(haSignedPrepared, 89)
float ha_144 = ta.ema(haSignedPrepared, 144)
float ha_233 = ta.ema(haSignedPrepared, 233)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: HA Blend Pair-Set Resolver
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Resolves which preset pair ladder is active for HA Blend.
//
// 🧠 Presets:
//     • Fast     = 5/8, 8/13, 13/21, 21/34
//     • Balanced = 13/21, 21/34, 34/55, 55/89
//     • Slow     = 34/55, 55/89, 89/144, 144/233
//
float blendPair_1 =
     in_blendPairSet == "Fast" ? (ha_5 + ha_8) / 2 :
     in_blendPairSet == "Balanced" ? (ha_13 + ha_21) / 2 :
     (ha_34 + ha_55) / 2
 
float blendPair_2 =
     in_blendPairSet == "Fast" ? (ha_8 + ha_13) / 2 :
     in_blendPairSet == "Balanced" ? (ha_21 + ha_34) / 2 :
     (ha_55 + ha_89) / 2
 
float blendPair_3 =
     in_blendPairSet == "Fast" ? (ha_13 + ha_21) / 2 :
     in_blendPairSet == "Balanced" ? (ha_34 + ha_55) / 2 :
     (ha_89 + ha_144) / 2
 
float blendPair_4 =
     in_blendPairSet == "Fast" ? (ha_21 + ha_34) / 2 :
     in_blendPairSet == "Balanced" ? (ha_55 + ha_89) / 2 :
     (ha_144 + ha_233) / 2
 
// ──────────────────────────────────────────────
// 🟦 Subregion: HA Blend Pair Averaging
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Averages the active preset's four pair midpoints into one blend engine.
//
float blendEngineCore =
     (blendPair_1 + blendPair_2 + blendPair_3 + blendPair_4) / 4
 
// ==============================================================================================
// 🔴 END REGION: Blend Engine
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Selected Output Engine
// ==============================================================================================
 
float rangeEngine =
     in_useFinalSmooth ? f_ma(rangeEngineCore, in_finalSmoothLen, in_finalSmoothType) : rangeEngineCore
 
float blendEngine =
     in_useFinalSmooth ? f_ma(blendEngineCore, in_finalSmoothLen, in_finalSmoothType) : blendEngineCore
 
 
float osc =
     in_engineMode == "HA Range Base" ? rangeEngine : blendEngine
 
color rangeEngineColor =
     f_quadrantColor(
         rangeEngine,
         in_colAboveRise,
         in_colAboveFall,
         in_colBelowFall,
         in_colBelowRise)
 
color blendEngineColor =
     f_quadrantColor(
         blendEngine,
         in_colAboveRise,
         in_colAboveFall,
         in_colBelowFall,
         in_colBelowRise)
 
color oscColor =
     f_quadrantColor(
         osc,
         in_colAboveRise,
         in_colAboveFall,
         in_colBelowFall,
         in_colBelowRise)
 
// ==============================================================================================
// 🔴 END REGION: Selected Output Engine
// ==============================================================================================
 
 
// ==============================================================================================
// 🟢 REGION: Auxiliary Oscillator Series
// ==============================================================================================
//
// 📌 Purpose:
//     Builds all secondary oscillator-side support series that sit on top of the
//     selected unified HA oscillator (`osc`), but do not change the core engine itself.
//
// 🧠 What lives here:
//     • Adaptive crossover engine
//     • Standalone SMA 20 / 50 crossover engine
//     • Rolling oscillator VWA
//     • Pivot-overlay state + derived baseline
//     • Guide-line reference values
//     • Synthetic oscillator candle OHLC + colors
//
// 🧩 Why this matters in this script:
//     The core HA engine decides what the oscillator is.
//     This region decides how that oscillator is interpreted, smoothed visually,
//     and prepared for plots, fills, and overlays.
//
// ==============================================================================================
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Adaptive Crossovers
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Builds the primary timeframe-aware fast / slow crossover engine.
//
// 🧠 Behavior:
//     • Auto mode picks fast / slow lengths by chart timeframe bucket
//     • Manual mode uses the user's direct fast / slow inputs
//     • Uses the selected oscillator (`osc`) as the source
//     • Maintains a persistent bull / bear crossover state for line and fill color
//
// 🧩 Why this matters in this script:
//     This is the main crossover engine meant to adapt itself across chart speeds,
//     so lower timeframes stay responsive while higher timeframes stay more stable.
//
 
// Adaptive fast-length table by timeframe bucket.
int len_Fast_0 = 8
int len_Fast_1 = 5
int len_Fast_2 = 8
int len_Fast_3 = 13
int len_Fast_4 = 13
int len_Fast_5 = 21
int len_Fast_6 = 13
int len_Fast_7 = 8
int len_Fast_8 = 5
 
// Adaptive slow-length table by timeframe bucket.
int len_Slow_0 = 21
int len_Slow_1 = 13
int len_Slow_2 = 21
int len_Slow_3 = 34
int len_Slow_4 = 48
int len_Slow_5 = 48
int len_Slow_6 = 34
int len_Slow_7 = 21
int len_Slow_8 = 13
 
// Auto-select the adaptive fast length from the current chart timeframe bucket.
int crossFastLen_auto =
     timeframe.isseconds and timeframe.multiplier <= 45 ? len_Fast_0 :
     timeframe.isminutes and timeframe.multiplier <= 3 ? len_Fast_1 :
     timeframe.isminutes and timeframe.multiplier <= 10 ? len_Fast_2 :
     timeframe.isminutes and timeframe.multiplier <= 30 ? len_Fast_3 :
     timeframe.isminutes and timeframe.multiplier <= 120 ? len_Fast_4 :
     timeframe.isminutes and timeframe.multiplier <= 480 ? len_Fast_5 :
     timeframe.isdaily and timeframe.multiplier <= 34 ? len_Fast_6 :
     timeframe.isweekly and timeframe.multiplier <= 21 ? len_Fast_7 :
     timeframe.ismonthly and timeframe.multiplier <= 13 ? len_Fast_8 :
     in_fastLen_manual
 
// Auto-select the adaptive slow length from the current chart timeframe bucket.
int crossSlowLen_auto =
     timeframe.isseconds and timeframe.multiplier <= 45 ? len_Slow_0 :
     timeframe.isminutes and timeframe.multiplier <= 3 ? len_Slow_1 :
     timeframe.isminutes and timeframe.multiplier <= 10 ? len_Slow_2 :
     timeframe.isminutes and timeframe.multiplier <= 30 ? len_Slow_3 :
     timeframe.isminutes and timeframe.multiplier <= 120 ? len_Slow_4 :
     timeframe.isminutes and timeframe.multiplier <= 480 ? len_Slow_5 :
     timeframe.isdaily and timeframe.multiplier <= 34 ? len_Slow_6 :
     timeframe.isweekly and timeframe.multiplier <= 21 ? len_Slow_7 :
     timeframe.ismonthly and timeframe.multiplier <= 13 ? len_Slow_8 :
     in_slowLen_manual
 
// Resolve runtime lengths after the Auto / Manual decision.
int crossFastLen_rt =
     in_tfMode_Cross == "Auto" ? crossFastLen_auto : in_fastLen_manual
 
int crossSlowLen_rt =
     in_tfMode_Cross == "Auto" ? crossSlowLen_auto : in_slowLen_manual
 
// Build the adaptive fast / slow lines from the shared oscillator source.
float fastLine =
     f_ma(
         osc,
         crossFastLen_rt,
         in_fastMaType)
 
float slowLine =
     f_ma(
         osc,
         crossSlowLen_rt,
         in_slowMaType)
 
// Detect actual crossover events.
bool bullCross =
     ta.crossover(fastLine, slowLine)
 
bool bearCross =
     ta.crossunder(fastLine, slowLine)
 
// Persist the active crossover state so color stays stable between events.
var bool crossBullState = false
crossBullState := bullCross ? true : bearCross ? false : crossBullState
 
// Primary adaptive crossover colors.
color crossLineCol =
     crossBullState ? color.new(in_crossBullColor, 27) : color.new(in_crossBearColor, 27)
 
color crossFillCol =
     in_showCrossFill ? (crossBullState ? color.new(in_crossBullColor, 77) : color.new(in_crossBearColor, 77)) : na
 
 
 
// ──────────────────────────────────────────────
// 🟦 Subregion: SMA 20 / 50 Crossovers
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Builds the standalone fixed-length crossover engine.
//
// 🧠 Behavior:
//     • Uses its own MA type inputs and lengths
//     • Runs independently of the adaptive crossover engine
//     • Lets users compare a fixed classic pair against the adaptive pair
//
// 🧩 Why this matters in this script:
//     Some users want a stable reference pair regardless of timeframe.
//     This second engine provides that without interfering with the adaptive one.
//
 
// Build the standalone SMA-engine fast / slow lines from the same oscillator source.
float fastLine_sma =
     f_ma(
         osc,
         in_Len_fast_sma,
         in_MaType_fast_sma)
 
float slowLine_sma =
     f_ma(
         osc,
         in_Len_slow_sma,
         in_MaType_slow_sma)
 
// Detect standalone crossover events.
bool bullCross_sma =
     ta.crossover(fastLine_sma, slowLine_sma)
 
bool bearCross_sma =
     ta.crossunder(fastLine_sma, slowLine_sma)
 
// Persist the fixed-engine crossover state.
var bool crossBullState_sma = false
crossBullState_sma := bullCross_sma ? true : bearCross_sma ? false : crossBullState_sma
 
// Standalone SMA-engine colors.
color crossLineCol_sma =
     crossBullState_sma ? color.new(in_crossBullColor, 25) : color.new(in_crossBearColor, 25)
 
color crossFillCol_sma =
     in_showFill_sma ? (crossBullState_sma ? color.new(in_crossBullColor, 75) : color.new(in_crossBearColor, 75)) : na
 
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Rolling Oscillator VWA
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Builds a volume-weighted average of the selected oscillator using the
//     same adaptive structure as the CE oscillator reference script.
//
// 🧠 Behavior:
//     • Supports Auto or Manual length selection
//     • Uses volume adjusted by its own SMA as the weighting factor
//     • Can later be displayed as Last 'N' Bars or hidden entirely
//
// 🧩 Why this matters in this script:
//     This makes the oscillator VWA more adaptive across timeframes and a bit
//     more participation-aware than the simpler rolling VWA version.
//
 
// Adaptive VWA length table by timeframe bucket.
int len_OscVwa_0 = 55
int len_OscVwa_1 = 21
int len_OscVwa_2 = 34
int len_OscVwa_3 = 48
int len_OscVwa_4 = 55
int len_OscVwa_5 = 48
int len_OscVwa_6 = 34
int len_OscVwa_7 = 21
int len_OscVwa_8 = 13
 
// Auto-select the VWA length from the current chart timeframe bucket.
int oscVwaLen_auto =
     timeframe.isseconds and timeframe.multiplier <= 45 ? len_OscVwa_0 :
     timeframe.isminutes and timeframe.multiplier <= 3 ? len_OscVwa_1 :
     timeframe.isminutes and timeframe.multiplier <= 10 ? len_OscVwa_2 :
     timeframe.isminutes and timeframe.multiplier <= 30 ? len_OscVwa_3 :
     timeframe.isminutes and timeframe.multiplier <= 120 ? len_OscVwa_4 :
     timeframe.isminutes and timeframe.multiplier <= 480 ? len_OscVwa_5 :
     timeframe.isdaily and timeframe.multiplier <= 34 ? len_OscVwa_6 :
     timeframe.isweekly and timeframe.multiplier <= 21 ? len_OscVwa_7 :
     timeframe.ismonthly and timeframe.multiplier <= 13 ? len_OscVwa_8 :
     in_oscVwaLenManual
 
// Resolve runtime length after the Auto / Manual decision.
int oscVwaLen =
     in_oscVwaLenMode == "Auto" ? oscVwaLen_auto : in_oscVwaLenManual
 
// Build a participation-adjusted volume weighting model.
float oscVwaVolAdj =
     volume / ta.sma(volume, oscVwaLen)
 
float oscVwaWeightedSum =
     math.sum(osc * oscVwaVolAdj, oscVwaLen)
 
float oscVwaWeightSum =
     math.sum(oscVwaVolAdj, oscVwaLen)
 
float oscVwa =
     oscVwaWeightSum != 0 ? oscVwaWeightedSum / oscVwaWeightSum : na
 
// CE-style constant VWA color.
color oscVwaColor =
     oscVwa > oscVwa[1] ? color.new(#00e5ff, 0) : color.new(#00e5ff, 0)
 
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Trend Pivot Overlay State
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Tracks confirmed oscillator pivots and derives the pivot-overlay baseline.
//
// 🧠 Behavior:
//     • Confirms pivots using left / right bar logic
//     • Keeps only positive pivots for highs and negative pivots for lows
//     • Stores the most recent confirmed pivot-high and pivot-low anchors
//     • Uses pivot order to infer whether the active structure is downtrend or uptrend
//     • Resolves a single overlay baseline from the chosen pivot mode
//
// 🧩 Why this matters in this script:
//     This gives the oscillator a structural bias line that can behave like a
//     regime baseline rather than just another moving average.
//
 
// Raw pivot detections on the oscillator itself.
float pivotLowRaw =
     ta.pivotlow(osc, in_leftBars, in_rightBars)
 
float pivotHighRaw =
     ta.pivothigh(osc, in_leftBars, in_rightBars)
 
// Keep only below-zero pivot lows and above-zero pivot highs.
// This preserves polarity-aware structure logic.
float pivotLow =
     osc[in_rightBars] < 0 ? pivotLowRaw : na
 
float pivotHigh =
     osc[in_rightBars] > 0 ? pivotHighRaw : na
 
bool isPivotLow =
     not na(pivotLow)
 
bool isPivotHigh =
     not na(pivotHigh)
 
// Persistent storage for the most recent confirmed pivot anchors.
var float overlayPivotHigh = na
var float overlayPivotLow = na
var int highPivotBar = na
var int lowPivotBar = na
 
// Update stored pivot-high anchor when a new oscillator high pivot confirms.
if isPivotHigh
    overlayPivotHigh := pivotHigh
    highPivotBar := bar_index - in_rightBars
 
// Update stored pivot-low anchor when a new oscillator low pivot confirms.
if isPivotLow
    overlayPivotLow := pivotLow
    lowPivotBar := bar_index - in_rightBars
 
// The overlay is ready only after both a confirmed high pivot and low pivot exist.
bool overlayReady =
     not na(overlayPivotHigh) and not na(overlayPivotLow)
 
// Trend direction is inferred from pivot order:
// if the latest stored high pivot is more recent than the low pivot, structure is downtrend.
bool isDowntrend =
     overlayReady ? highPivotBar > lowPivotBar : false
 
bool isDynamicMode =
     in_pivotMode == "Dynamic"
 
bool isPivotLowMode =
     in_pivotMode == "Pivot Low"
 
// Resolve the active overlay baseline.
// • Dynamic     → flips between pivot high / pivot low by structure
// • Pivot Low   → always use pivot low
// • Pivot High  → always use pivot high
float overlayLine =
     isDynamicMode ? (isDowntrend ? overlayPivotHigh : overlayPivotLow) :
     isPivotLowMode ? overlayPivotLow :
     overlayPivotHigh
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Trend Pivot Overlay Line Object
// ──────────────────────────────────────────────
// Draws a true pivot-anchored horizontal segment that uses the same resolved
// baseline as the Trend Pivot Overlay plot, then colors it by oscillator position.
//
// Color model:
// • overlay above 0 = bull color
// • overlay below 0 = bear color
// • overlay exactly 0 = neutral plot color
 
var line overlayLineObj = na
 
int overlayAnchorBar =
     isDowntrend ? highPivotBar : lowPivotBar
 
color overlayObjColor =
     na(overlayLine) ? na :
     overlayLine > 0 ? in_overlayBearColor :
     overlayLine < 0 ? in_overlayBullColor :
     color.gray
 
if in_showTrendOverlayObj and overlayReady and not na(overlayLine) and not na(overlayAnchorBar)
    if na(overlayLineObj)
        overlayLineObj := line.new(
             x1=overlayAnchorBar,
             y1=overlayLine,
             x2=bar_index,
             y2=overlayLine,
             xloc=xloc.bar_index,
             color=overlayObjColor,
             width=1,
             style=line.style_solid)
    else
        line.set_xy1(overlayLineObj, overlayAnchorBar, overlayLine)
        line.set_xy2(overlayLineObj, bar_index, overlayLine)
        line.set_color(overlayLineObj, overlayObjColor)
else
    if not na(overlayLineObj)
        line.delete(overlayLineObj)
        overlayLineObj := na
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Guide-Line Values
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Precomputes the adaptive reference levels used by the oscillator guide plots.
//
// 🧠 How these guide lines are built:
//     • zeroLine is fixed at 0 and acts as the oscillator's neutral baseline
//     • upperGuide is set to 50% of the highest oscillator value seen over the current lookback
//     • lowerGuide is set to 50% of the lowest oscillator value seen over the current lookback
//
//     In other words, the ±50 guide lines are not hardcoded levels.
//     They are recalculated from the oscillator's own recent range:
//
//     • upperGuide = highest(osc, normPeriod) * 0.5
//     • lowerGuide = lowest(osc, normPeriod) * 0.5
//
// 🧩 Practical interpretation:
//     These lines act like adaptive "soft boundary" rails for the oscillator.
//     Because they are based on recent oscillator extremes, they expand when the
//     histogram / oscillator candles become more stretched, and contract when the
//     oscillator compresses.
//
//     This means they can behave similarly to overbought / oversold lines,
//     but only relative to the oscillator's recent behavior, not as fixed thresholds.
//
// 🧩 Why they visually move with the histogram / candles:
//     The guide lines do not read the candle plots directly.
//     They use the same underlying oscillator series (`osc`) that also drives:
//     • the histogram columns
//     • the oscillator candles
//
//     Since all of those visuals come from the same source series, the guide lines
//     naturally adapt along with the histogram and oscillator candles.
//
// 🧩 Why this matters in this script:
//     Keeping these values precomputed here makes the later plot section cleaner,
//     while also giving the script adaptive reference rails instead of static levels.
//
 
float zeroLine = 0.0
 
float upperGuide =
     ta.highest(osc, normPeriod) * 0.5
 
float lowerGuide =
     ta.lowest(osc, normPeriod) * 0.5
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Threshold-Aware Visual Colors
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Builds the shared threshold-aware visual colors used across the histogram,
//     oscillator candles, price-overlay candles, follow line, and Engine Table.
//
color rangeEngineVisualColor =
     f_visualThresholdColor(
         rangeEngine,
         upperGuide,
         lowerGuide,
         in_colAbove50Rise,
         in_colAboveRise,
         in_colAboveFall,
         in_colBelowFall,
         in_colBelow50Fall,
         in_colBelowRise)
 
color blendEngineVisualColor =
     f_visualThresholdColor(
         blendEngine,
         upperGuide,
         lowerGuide,
         in_colAbove50Rise,
         in_colAboveRise,
         in_colAboveFall,
         in_colBelowFall,
         in_colBelow50Fall,
         in_colBelowRise)
 
color oscVisualColor =
     f_visualThresholdColor(
         osc,
         upperGuide,
         lowerGuide,
         in_colAbove50Rise,
         in_colAboveRise,
         in_colAboveFall,
         in_colBelowFall,
         in_colBelow50Fall,
         in_colBelowRise)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Synthetic Oscillator Candle Series
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Converts the oscillator into candle-ready OHLC values for `plotcandle()`.
//
// 🧠 Construction:
//     • open  = prior oscillator value
//     • high  = higher of prior/current oscillator value
//     • low   = lower of prior/current oscillator value
//     • close = current oscillator value
//
// 🧩 Why this matters in this script:
//     This gives the oscillator a candle-style readout, which can make acceleration,
//     deceleration, and bar-to-bar reversals easier to see than a line alone.
//
 
float oscOpen =
     osc[1]
 
float oscHigh =
     math.max(osc[1], osc)
 
float oscLow =
     math.min(osc[1], osc)
 
float oscClose =
     osc
 
color oscBodyColor =
     color.new(oscVisualColor, in_oscCandleTransp)
 
color oscEdgeColor =
     oscVisualColor
 
 
// ==============================================================================================
// 🔴 END REGION: Auxiliary Oscillator Series
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: OSC Pressure Envelope State
// ==============================================================================================
//
// 📌 Purpose:
//     Builds a continuous envelope around the active oscillator and turns
//     the fill on only when the oscillator reaches the user-defined trigger zones.
//
// ==============================================================================================
 
float oscPressureCenter = osc
 
float oscPressureUpper =
     oscPressureCenter + in_oscPressureEnvelopePad
 
float oscPressureLower =
     oscPressureCenter - in_oscPressureEnvelopePad
 
color oscPressureFillColor =
     not in_showOscPressureEnvelope ? na :
     osc >= in_oscPressureUpperTrigger ? color.new(in_oscPressureUpperFill, in_oscPressureFillTransp) :
     osc <= in_oscPressureLowerTrigger ? color.new(in_oscPressureLowerFill, in_oscPressureFillTransp) :
     na
 
// ==============================================================================================
// 🔴 END REGION: OSC Pressure Envelope State
// ==============================================================================================
 
// ================================================================================
// 🟢 REGION: Higher-Timeframe Oscillator Selector
// ================================================================================
//
// 📌 Purpose:
//     Resolves which higher timeframe should be used for the oscillator
//     reference line.
//
// 🧠 Behavior:
//     • Dynamic mode steps up to the next logical chart timeframe
//     • Manual mode uses the exact user-selected timeframe
//
// ================================================================================
f_getNextTf() =>
    string _nextTf = ""
    float _mult = timeframe.multiplier
 
    if timeframe.isseconds
        _nextTf :=
             timeframe.period == "1S"  ? "5S"  :
             timeframe.period == "5S"  ? "10S" :
             timeframe.period == "10S" ? "15S" :
             timeframe.period == "15S" ? "30S" :
             timeframe.period == "30S" ? "45S" :
             timeframe.period == "45S" ? "1"   : "1"
 
    else if timeframe.isminutes
        _nextTf :=
             _mult <= 1   ? "3"   :
             _mult <= 2   ? "4"   :
             _mult <= 3   ? "5"   :
             _mult <= 5   ? "10"  :
             _mult <= 10  ? "15"  :
             _mult <= 15  ? "30"  :
             _mult <= 30  ? "60"  :
             _mult <= 60  ? "120" :
             _mult <= 120 ? "240" :
             _mult <= 240 ? "480" : "D"
 
    else if timeframe.isdaily
        _nextTf := "1W"
    else if timeframe.isweekly
        _nextTf := "2W"
    else if timeframe.ismonthly
        _nextTf := "2M"
    else
        _nextTf := "1D"
 
    _nextTf
 
string selectedHtf =
     in_manualHtfSelection == "Chart" ? timeframe.period : in_manualHtfSelection
 
string htfTimeframe =
     in_useDynamicHtf ? f_getNextTf() : selectedHtf
 
// ================================================================================
// 🔴 END REGION: Higher-Timeframe Oscillator Selector
// ================================================================================
 
// ================================================================================
// 🟢 REGION: Higher-Timeframe Oscillator Sampling
// ================================================================================
//
// 📌 Purpose:
//     Requests the active oscillator from the selected higher timeframe and
//     stabilizes it for lower-timeframe use.
//
// 🧠 Behavior:
//     • Pulls `osc` from the selected HTF using request.security()
//     • Uses SCL_HTF.f_HTF_Float() to stabilize the returned series
//     • Prevents the HTF reference line from visually desyncing while the
//       higher-timeframe bar is still forming
//
// ================================================================================
f_secHtfOsc(_tf) =>
    request.security(
         symbol=syminfo.tickerid,
         timeframe=_tf,
         expression=osc,
         gaps=barmerge.gaps_off,
         lookahead=barmerge.lookahead_off)
 
float htfOscRaw =
     f_secHtfOsc(htfTimeframe)
 
float htfOscFixed =
     SCL_HTF.f_HTF_Float(
         _HTF=htfTimeframe,
         _source=htfOscRaw,
         _arrayHistory=2,
         _HTF_offset=0,
         _useLiveDataOnChartTF=true)
 
// ================================================================================
// 🔴 END REGION: Higher-Timeframe Oscillator Sampling
// ================================================================================
 
// ==============================================================================================
// 🟢 REGION: Histogram Follow Line
// ==============================================================================================
//
// 📌 Purpose:
//     Draws a left and right follow line from the current oscillator value.
//
// 🧠 Behavior:
//     • Right line extends forward from the current bar by X bars
//     • Left line extends backward from the current bar by X bars
//     • Both lines update every bar to stay locked to the live oscillator value
//
// ==============================================================================================
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Inputs
// ──────────────────────────────────────────────
 
int in_histFollowLineWidth = 2 //input.int(
    //  defval=1,
    //  minval=1,
    //  maxval=10,
    //  title="Follow Line Width",
    //  group=G_HIST_LINE,
    //  tooltip=TT_FOLLOW_LINE_WIDTH)
 
int in_histLineLengthRight = 2 //input.int(
    //  defval=2,
    //  minval=0,
    //  maxval=100,
    //  title="Follow Line Length Right",
    //  group=G_HIST_LINE,
    //  tooltip=TT_FOLLOW_LINE_RIGHT)
 
int in_histLineLengthLeft = 1 //input.int(
    //  defval=1,
    //  minval=0,
    //  maxval=500,
    //  title="Follow Line Length Left",
    //  group=G_HIST_LINE,
    //  tooltip=TT_FOLLOW_LINE_LEFT)
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Style Mapping
// ──────────────────────────────────────────────
lineStyle_follow = line.style_solid
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Follow Line State
// ──────────────────────────────────────────────
color followLineColor = oscVisualColor
 
var line followLineRight = na
var line followLineLeft = na
 
int x2_followRight = bar_index + in_histLineLengthRight
int x2_followLeft = bar_index - in_histLineLengthLeft
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Follow Line Updater
// ──────────────────────────────────────────────
f_updateFollowLine(line _line, int _x1, float _y1, int _x2, float _y2, color _col, int _width, _style) =>
    line _out = _line
 
    if na(_out)
        _out := line.new(
             x1=_x1,
             y1=_y1,
             x2=_x2,
             y2=_y2,
             xloc=xloc.bar_index,
             color=_col,
             width=_width,
             style=_style)
    else
        line.set_xy1(_out, _x1, _y1)
        line.set_xy2(_out, _x2, _y2)
        line.set_color(_out, _col)
        line.set_width(_out, _width)
        line.set_style(_out, _style)
 
    _out
 
// ──────────────────────────────────────────────
// 🟦 Subregion: Follow Line Updates
// ──────────────────────────────────────────────
followLineRight := f_updateFollowLine(
     followLineRight,
     bar_index,
     osc,
     x2_followRight,
     osc,
     followLineColor,
     in_histFollowLineWidth,
     lineStyle_follow)
 
followLineLeft := f_updateFollowLine(
     followLineLeft,
     bar_index,
     osc,
     x2_followLeft,
     osc,
     followLineColor,
     in_histFollowLineWidth,
     lineStyle_follow)
 
// ==============================================================================================
// 🔴 END REGION: Histogram Follow Line
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Engine Table State
// ==============================================================================================
 
bool usingRangeEngine =
     in_engineMode == "HA Range Base"
 
bool usingBlendEngine =
     in_engineMode == "HA Blend"
 
string rangeRowLabelTxt =
     "Range Base " + (usingRangeEngine ? "✓" : "✕")
 
string blendRowLabelTxt =
     "HA Blend " + (usingBlendEngine ? "✓" : "✕")
 
string finalSmoothTxt =
     in_useFinalSmooth ?
     " | Smooth " + str.tostring(in_finalSmoothLen) + " " + in_finalSmoothType : ""
 
string rangeEngineInfoTxt =
     str.tostring(in_rangeLen) + " " + in_rangeMaType +
     finalSmoothTxt
 
// ──────────────────────────────────────────────
// 🟦 Subregion: HA Blend Pair-Set Table Text
// ──────────────────────────────────────────────
//
// 📌 Purpose:
//     Builds the HA Blend table text for the selected preset pair set.
//
// 🧠 Behavior:
//     • Top value row shows the selected preset
//     • Bottom value row shows the exact EMA pairs used by that preset
//
// 🧩 Why this matters in this script:
//     The HA Blend section now reflects one clean preset-driven ladder rather
//     than a long mixed list of manually enabled pairs.
//
string blendPairSetTxt =
     "Pair Set > " + in_blendPairSet
 
string blendPairsTxt =
     in_blendPairSet == "Fast" ? "5/8 | 8/13 | 13/21 | 21/34" :
     in_blendPairSet == "Balanced" ? "13/21 | 21/34 | 34/55 | 55/89" :
     "34/55 | 55/89 | 89/144 | 144/233"
 
float oscChange =
     osc - osc[1]
 
string oscValueTxt =
     na(osc) ? "—" : str.tostring(osc, "#.##")
 
string oscChangeTxt =
     na(oscChange) ? "—" :
     (oscChange > 0 ? "+" : "") + str.tostring(oscChange, "#.##")
 
string oscInfoTxt =
     oscValueTxt + " (" + oscChangeTxt + ")"
 
color oscRowBg =
     oscVisualColor
 
color oscRowTxt =
     f_tableContrastText(oscRowBg)
 
color engineHdrBg = color.rgb(0, 0, 0)
color engineHdrTxt = color.white
 
color engineNeutralBg = color.rgb(0, 0, 0)
color engineNeutralTxt = color.white
 
color rangeRowBg =
     usingRangeEngine ? rangeEngineVisualColor : engineNeutralBg
 
color rangeRowTxt =
     usingRangeEngine ? f_tableContrastText(rangeRowBg) : engineNeutralTxt
 
color blendRowBg =
     usingBlendEngine ? blendEngineVisualColor : engineNeutralBg
 
color blendRowTxt =
     usingBlendEngine ? f_tableContrastText(blendRowBg) : engineNeutralTxt
 
string chartTF_Pretty =
     TF.f_prettifyTF(timeframe.period)
 
string engineHdrLabelTxt =
     syminfo.ticker + " | " + chartTF_Pretty
 
var table engineInfoTable =
     table.new(
         f_tablePos(in_engineTablePos),
         2,
         5,
         bgcolor=color.new(color.black, 0),
         frame_color=color.new(color.white, 70),
         border_color=color.new(color.white, 80),
         border_width=1)
 
// ==============================================================================================
// 🔴 END REGION: Engine Table State
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Engine Table Render
// ==============================================================================================
 
if barstate.islast
    _ts = f_tableTextSize(in_engineTableTextSize)
 
    if in_showEngineTable
        table.clear(engineInfoTable, 0, 0, 1, 4)
        table.merge_cells(engineInfoTable, 0, 0, 1, 0)
        table.merge_cells(engineInfoTable, 0, 3, 0, 4)
 
        table.cell(
             engineInfoTable,
             0,
             0,
             engineHdrLabelTxt,
             text_color=engineHdrTxt,
             bgcolor=engineHdrBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             0,
             1,
             "OSC (Hist)",
             text_color=oscRowTxt,
             bgcolor=oscRowBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             1,
             1,
             oscInfoTxt,
             text_color=oscRowTxt,
             bgcolor=oscRowBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             0,
             2,
             rangeRowLabelTxt,
             text_color=rangeRowTxt,
             bgcolor=rangeRowBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             1,
             2,
             rangeEngineInfoTxt,
             text_color=rangeRowTxt,
             bgcolor=rangeRowBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             0,
             3,
             blendRowLabelTxt,
             text_color=blendRowTxt,
             bgcolor=blendRowBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             1,
             3,
             blendPairSetTxt,
             text_color=blendRowTxt,
             bgcolor=blendRowBg,
             text_size=_ts)
 
        table.cell(
             engineInfoTable,
             1,
             4,
             blendPairsTxt,
             text_color=blendRowTxt,
             bgcolor=blendRowBg,
             text_size=_ts)
    else
        table.clear(engineInfoTable, 0, 0, 1, 4)
 
// ==============================================================================================
// 🔴 END REGION: Engine Table Render
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Price Overlay Candle Colors
// ==============================================================================================
//
// 📌 Purpose:
//     Derives the colors used by the optional chart-overlay candles.
//
// ==============================================================================================
 
color priceOverlayBaseCol =
     not in_showPriceCandles ? na :
     in_useOscColorForPriceCandles ? oscVisualColor : na
 
color priceOverlayBodyCol =
     na(priceOverlayBaseCol) ? na : color.new(priceOverlayBaseCol, in_priceCandleBodyTransp)
 
color priceOverlayEdgeCol =
     priceOverlayBaseCol
// ==============================================================================================
// 🔴 END REGION: Price Overlay Candle Colors
// ==============================================================================================
 
// ==============================================================================================
// 🟢 REGION: Plots
// ==============================================================================================
 
// ──────────────────────────────────────────────
// Higher-Timeframe Oscillator
// Plots the stabilized higher-timeframe version of the active oscillator.
// ──────────────────────────────────────────────
plot(
     in_htfOscMode == "Last N Bars" ? htfOscFixed : na,
     title="Higher-Timeframe Oscillator (Last N Bars)",
     color=#0066ff,
     linewidth=1,
     show_last=in_htfOscShowLast)
 
// ──────────────────────────────────────────────
// Price Overlay Candles
// Draws oscillator-colored candles directly on the main chart using force_overlay.
// ──────────────────────────────────────────────
plotcandle(
     in_showPriceCandles ? open : na,
     in_showPriceCandles ? high : na,
     in_showPriceCandles ? low : na,
     in_showPriceCandles ? close : na,
     title="Price Overlay Candles (Last N Bars)",
     color=priceOverlayBodyCol,
     wickcolor=priceOverlayEdgeCol,
     bordercolor=priceOverlayEdgeCol,
     show_last=in_priceCandleShowLast,
     force_overlay=true)
 
// ──────────────────────────────────────────────
// Main Oscillator Histogram / Line
// Plots the active HA oscillator itself using the script's main color engine.
// ──────────────────────────────────────────────
plot(
     in_showHistogram ? osc : na,
     title="Unified HA Oscillator Histogram",
     style=plot.style_line,
     color=oscVisualColor,
     linewidth=2,
     show_last=in_plotLast)
 
// ──────────────────────────────────────────────
// Oscillator Candles
// Draws synthetic candles from oscillator OHLC instead of price OHLC.
// ──────────────────────────────────────────────
plotcandle(
     open=in_showOscCandles ? oscOpen : na,
     high=in_showOscCandles ? oscHigh : na,
     low=in_showOscCandles ? oscLow : na,
     close=in_showOscCandles ? oscClose : na,
     title="Oscillator Candles",
     color=oscBodyColor,
     wickcolor=oscEdgeColor,
     bordercolor=oscEdgeColor,
     show_last=in_plotLastCandles)
 
// ──────────────────────────────────────────────
// OSC Pressure Envelope
// Continuous envelope around osc with state-based fill.
// ──────────────────────────────────────────────
plotOscPressureUpper = plot(
     in_showOscPressureEnvelope ? oscPressureUpper : na,
     title="OSC Pressure Envelope Upper",
     color=color.new(color.white, 100),
     linewidth=1,
     show_last=in_plotLastCandles)
 
plotOscPressureLower = plot(
     in_showOscPressureEnvelope ? oscPressureLower : na,
     title="OSC Pressure Envelope Lower",
     color=color.new(color.white, 100),
     linewidth=1,
     show_last=in_plotLastCandles)
 
fill(
     plotOscPressureUpper,
     plotOscPressureLower,
     color=oscPressureFillColor,
     title="OSC Pressure Background")
 
// ──────────────────────────────────────────────
// Adaptive Fast Line
// Primary fast crossover line built from the adaptive crossover engine.
// ──────────────────────────────────────────────
plotFast = plot(
     in_showCrossLines ? fastLine : na,
     title="Fast Line",
     color=crossLineCol,
     linewidth=1,
     show_last=in_plotLast)
 
// ──────────────────────────────────────────────
// Adaptive Slow Line
// Primary slow crossover line built from the adaptive crossover engine.
// ──────────────────────────────────────────────
plotSlow = plot(
     in_showCrossLines ? slowLine : na,
     title="Slow Line",
     color=crossLineCol,
     linewidth=1,
     show_last=in_plotLast)
 
// ──────────────────────────────────────────────
// Adaptive Cross Fill
// Fills the space between the adaptive fast and slow crossover lines.
// ──────────────────────────────────────────────
fill(
     plotFast,
     plotSlow,
     color=crossFillCol,
     title="Cross Fill")
 
// ──────────────────────────────────────────────
// SMA Engine Fast Line
// Fast line for the standalone SMA 20 / 50 crossover engine.
// ──────────────────────────────────────────────
plotFast_sma = plot(
     in_showSignals_sma ? fastLine_sma : na,
     title="Fast Line (SMA Engine)",
     color=crossLineCol_sma,
     linewidth=1,
     show_last=in_plotLast)
 
// ──────────────────────────────────────────────
// SMA Engine Slow Line
// Slow line for the standalone SMA 20 / 50 crossover engine.
// ──────────────────────────────────────────────
plotSlow_sma = plot(
     in_showSignals_sma ? slowLine_sma : na,
     title="Slow Line (SMA Engine)",
     color=crossLineCol_sma,
     linewidth=1,
     show_last=in_plotLast)
 
// ──────────────────────────────────────────────
// SMA Engine Fill
// Fills the space between the standalone SMA-engine fast and slow lines.
// ──────────────────────────────────────────────
fill(
     plotFast_sma,
     plotSlow_sma,
     color=crossFillCol_sma,
     title="Signal Fill (SMA Engine)")
 
// ──────────────────────────────────────────────
// Oscillator VWA
// Plots the adaptive volume-weighted average of the active oscillator.
// ──────────────────────────────────────────────
plot(
     in_showOscVwa and in_oscVwaDisplayMode == "Last 'N' Bars" ? oscVwa : na,
     title="Oscillator VWA (Last N Bars)",
     color=oscVwaColor,
     linewidth=1,
     style=plot.style_circles,
     show_last=in_oscVwaShowLast)
 
// ──────────────────────────────────────────────
// Trend Overlay Plot Color
// Colors the plotted Trend Pivot Overlay by whether it sits above or below zero.
// ──────────────────────────────────────────────
color overlayPlotColor =
     na(overlayLine) ? na :
     overlayLine > 0 ? in_overlayBearColor :
     overlayLine < 0 ? in_overlayBullColor :
     color.gray
 
// ──────────────────────────────────────────────
// Trend Pivot Overlay
// Plots the active pivot-based baseline derived from confirmed oscillator pivots.
// ──────────────────────────────────────────────
plot(
     in_showTrendOverlay and overlayReady ? overlayLine : na,
     title="Trend Pivot Overlay",
     color=overlayPlotColor,
     linewidth=1,
     style=plot.style_stepline,
     show_last=in_plotLast)
 
// ──────────────────────────────────────────────
// Zero Line
// Fixed neutral baseline for the oscillator.
// ──────────────────────────────────────────────
plot(
     in_showZeroLine ? zeroLine : na,
     title="Zero Line",
     color=in_zeroLineColor,
     linewidth=1,
     style=plot.style_line,
     show_last=in_guideShowLast)
 
// ──────────────────────────────────────────────
// Upper +50% Guide
// Adaptive upper guide set to 50% of the recent positive oscillator extreme.
// ──────────────────────────────────────────────
plot(
     in_showHalfLines ? upperGuide : na,
     title="+50% Guide",
     color=in_upperGuideColor,
     linewidth=1,
     style=plot.style_line,
     show_last=in_guideShowLast)
 
// ──────────────────────────────────────────────
// Lower -50% Guide
// Adaptive lower guide set to 50% of the recent negative oscillator extreme.
// ──────────────────────────────────────────────
plot(
     in_showHalfLines ? lowerGuide : na,
     title="-50% Guide",
     color=in_lowerGuideColor,
     linewidth=1,
     style=plot.style_line,
     show_last=in_guideShowLast)
 
// ==============================================================================================
// 🔴 END REGION: Plots
// ==============================================================================================
 
 
// // ==============================================================================================
// // 🟢 REGION: Price Bar Coloring
// // ==============================================================================================
 
// barcolor(
//      in_colorPriceBars ? oscColor : na,
//      title="Oscillator Price Bar Color")
 
// // ==============================================================================================
// // 🔴 END REGION: Price Bar Coloring
// // ==============================================================================================
 
 
// plotchar(
//      osc >= in_oscPressureUpperTrigger,
//      title="Upper Trigger Active",
//      char="▲",
//      location=location.top,
//      color=color.orange)
 
// plotchar(
//      osc <= in_oscPressureLowerTrigger,
//      title="Lower Trigger Active",
//      char="▼",
//      location=location.bottom,
//      color=color.fuchsia)

← 返回列表