开始

Mtf

MaidongOrderBlockRefinerLibrary "MaidongOrderBlockRefiner" Maidong Order Block Refiner is a Pine Script library designed to refine already-detected order blocks into tighter and more actionable trading zones. This library does not detect market structure, identify order blocks, or draw zones by itself. Instead, it acts as a reusable refinement layer that accepts an externally confirmed order block origin and returns refined distal and proximal boundaries that can be used by drawing, alert, or setup modules. Core features: - Supports both `Demand` and `Supply` order blocks - Supports `On` / `Off` refinement mode - Supports `Defensive` and `Aggressive` refinement styles - Uses ATR-aware width handling to compress oversized zones - Returns distal and proximal coordinates ready for downstream drawing logic This library is useful when: - You already have your own structure or order block detection logic - You want to compress raw order block ranges into cleaner execution zones - You want to reuse the same refinement model across multiple indicators OBRefiner(obType, obRefine, refineMethod, triggerCondition, index)   Parameters:      obType (string)      obRefine (string)      refineMethod (string)      triggerCondition (bool)      index (int)
Pine Script®库
由libai999提供
MaidongOrderBlockDrawingLibrary "MaidongOrderBlockDrawing" Maidong Order Block Drawing is a Pine Script library built to handle the full visual lifecycle of order blocks, including rendering, forward extension, mitigation handling, and optional breaker block conversion. It is designed to work alongside separate detection or refinement modules. Once a script provides the order block type, boundaries, origin index, and mitigation settings, this library takes care of drawing and managing the zone directly on the chart. Core features: - Supports both `Demand` and `Supply` order blocks - Extends active zones forward while they remain valid - Supports mitigation by `Proximal`, `Distal`, or `50 % OB` - Can convert mitigated order blocks into breaker blocks - Returns mitigation events and breaker block metadata for downstream logic This library is useful when: - You already detect order blocks in another script or module - You want a reusable drawing engine for zone lifecycle management - You want consistent order block behavior across multiple indicators OBDrawing(obType, triggerCondition, distalPriceInput, proximalPriceInput, indexInput, obValidGlobal, obValidDistance, mitigationLevel, mitigationLevelBB, showAll, showAllBB, show, showBB, zoneColor, zoneColorBB)   Parameters:      obType (string)      triggerCondition (bool)      distalPriceInput (float)      proximalPriceInput (float)      indexInput (int)      obValidGlobal (bool)      obValidDistance (int)      mitigationLevel (string)      mitigationLevelBB (string)      showAll (bool)      showAllBB (bool)      show (bool)      showBB (bool)      zoneColor (color)      zoneColorBB (color)
Pine Script®库
由libai999提供
MaidongLiquidityLibraryLibrary "MaidongLiquidityLibrary" Maidong Liquidity Library is a Pine Script library built to visualize static and dynamic liquidity structures using pivot relationships. It is designed as a reusable visualization layer for indicators that want to highlight repeated highs, repeated lows, and sloped liquidity lines without embedding all liquidity drawing logic directly in the main script. Core features: - Detects static high-side liquidity - Detects static low-side liquidity - Detects dynamic high-side liquidity - Detects dynamic low-side liquidity - Draws dotted liquidity lines and labels directly on the chart - Extends nearby liquidity structures into three-point formations when applicable This library is useful when: - You want to add a liquidity layer to an SMC-style indicator - You want to track both repeated highs/lows and sloped liquidity structures - You want a reusable liquidity visualization module across scripts LLF(staticPivotPeriod, dynamicPivotPeriod, staticRangeSensitivity, dynamicRangeSensitivity, showStaticHighLiquidity, showStaticLowLiquidity, showDynamicHighLiquidity, showDynamicLowLiquidity)   Parameters:      staticPivotPeriod (int)      dynamicPivotPeriod (int)      staticRangeSensitivity (float)      dynamicRangeSensitivity (float)      showStaticHighLiquidity (bool)      showStaticLowLiquidity (bool)      showDynamicHighLiquidity (bool)      showDynamicLowLiquidity (bool)
Pine Script®库
由libai999提供
MaidongFVGLibrary## Title `Maidong FVG Library` ## Short Description Reusable Pine library for detecting and optionally rendering multi-timeframe imbalance zones with midpoint mitigation and pressure overlays. ## Full Description This library provides a compact API for working with multi-timeframe imbalance zones inside other TradingView indicators. Core capabilities: - Detects bullish and bearish imbalance zones from a selectable source timeframe - Applies a displacement filter using the relationship between candle body size and a smoothed body baseline - Uses confirmed source-timeframe data for stable MTF evaluation - Optionally draws active zones directly from the library - Supports midpoint or full-fill mitigation logic - Can render midpoint guides and directional pressure slices inside each active zone - Returns the latest active bullish and bearish zone levels for downstream logic The library is intended for indicator authors who want reusable imbalance-zone logic without embedding a full standalone chart tool in every script. ## Exported Function ### `scanImbalanceZones(...)` ```pine import username/MaidongFVGLibrary/1 as iz = iz.scanImbalanceZones( sourceTimeframe, displacementFactor, mitigateAtMidpoint, projectionBars, drawBullish, drawBearish, drawMidpoint, drawPressure, bullishPressureColor, bearishPressureColor, zoneColor) ``` ## Parameters - `sourceTimeframe`: Timeframe used to evaluate imbalance conditions. Use `""` to use the chart timeframe. - `displacementFactor`: Minimum body-strength multiplier relative to the smoothed body baseline. - `mitigateAtMidpoint`: When `true`, a zone is cleared after price reaches its midpoint. When `false`, full fill is required. - `projectionBars`: Number of chart bars used to project the rendered zone forward in time. - `drawBullish`: Draw bullish zones. - `drawBearish`: Draw bearish zones. - `drawMidpoint`: Draw a dashed midpoint line inside each rendered zone. - `drawPressure`: Draw directional pressure slices inside each rendered zone. - `bullishPressureColor`: Color used for the upper demand slice. - `bearishPressureColor`: Color used for the lower supply slice. - `zoneColor`: Base fill and border color for the full zone. ## Return Values The function returns 12 values: 1. `newBullish` 2. `bullishStartTime` 3. `bullishUpper` 4. `bullishLower` 5. `bullishMidpoint` 6. `newBearish` 7. `bearishStartTime` 8. `bearishUpper` 9. `bearishLower` 10. `bearishMidpoint` 11. `bullishActiveCount` 12. `bearishActiveCount` These values let the caller build alerts, filters, dashboards, or custom drawings without reimplementing the zone engine. ## Detection Model Bullish zone: - current low is above the high from two source bars back - current close remains above that earlier high - body size is at least `displacementFactor` times the smoothed body baseline - evaluation uses confirmed source-timeframe bars Bearish zone: - current high is below the low from two source bars back - current close remains below that earlier low - body size is at least `displacementFactor` times the smoothed body baseline - evaluation uses confirmed source-timeframe bars ## Publishing Notes - Publish as a `Library` - Add enough `max_boxes_count` and `max_lines_count` in consuming scripts - If your published script uses the drawing options, mention that the library manages visual objects internally ## Suggested Release Notes `v1` - Initial public release - Added reusable multi-timeframe imbalance-zone scanning - Added optional midpoint and pressure rendering - Added active-zone return values for downstream indicators
Pine Script®库
由libai999提供
RSI & MACD MTF Station [v2c_cha]Overview The RSI & MACD MTF Heatmap Station is a comprehensive, all-in-one momentum and trend analysis tool designed to eliminate chart clutter. Traditionally, traders relying on Multi-Timeframe (MTF) analysis must either split their screens into multiple layouts or flood their indicator panels with overlapping "spaghetti" lines. This indicator solves that problem by consolidating the Relative Strength Index (RSI) and Moving Average Convergence Divergence (MACD) across 9 different timeframes into a single, compact visual Heatmap. Core Concepts & Calculations This indicator relies on the standard mathematical formulas for RSI (default 14 periods) and MACD (default 12, 26, 9). However, its core value lies in how it processes and displays this data: Non-Repainting MTF Data: All higher-timeframe data is fetched using barmerge.lookahead_off and barmerge.gaps_off to ensure strict compliance with non-repainting rules. What you see on historical bars is exactly what would have printed in real-time. Visual Anchoring: To display both the current RSI and current MACD lines harmoniously in the same pane without skewing the scale, the MACD line is mathematically anchored to the RSI's 50-level (neutral line). How to Read the Heatmap Dashboard The dashboard is a 9-column by 3-row matrix located in the corner of your screen, covering timeframes from 1-minute to 1-Month. Row 1 (RSI - Extreme Momentum): This row measures whether an asset is mathematically overbought or oversold. 🔴 Red (RSI >= 70): Overbought. The asset is extended to the upside in this specific timeframe. 🟢 Green (RSI <= 30): Oversold. The asset is extended to the downside. ⚫ Dark Gray (31-69): Neutral. The asset is flowing within normal momentum boundaries. Row 2 (MACD - Trend Direction): This row measures the overarching trend control based on the MACD main line crossing the Zero line. 🟢 Green (MACD > 0): Bullish trend control. 🔴 Red (MACD < 0): Bearish trend control. Practical Trading Application (Top-Down Analysis) This tool excels at spotting high-probability continuation setups by aligning the macro-trend with micro-momentum pullbacks. Example Setup (The Buy Dip): A trader observing a 5-minute chart looks at the dashboard. The MACD row shows Green for the 1H and 4H timeframes, indicating a strong macro bullish trend. However, the RSI row shows Green (< 30) for the 5m and 15m timeframes. This tells the trader that while the macro trend is up, there is short-term panic/oversold conditions. This alignment provides a mathematical, rules-based area to look for long entries (buying the dip) in the direction of the macro trend. Key Features & Customization Fully Customizable: You can change the lengths and smoothing periods for both the RSI and MACD. Dashboard Positioning: Move the heatmap to any corner of the screen to fit your layout. Decluttered Charting: By default, only the current timeframe's RSI and MACD lines are plotted, while all MTF data is neatly organized inside the heatmap. Disclaimer: This indicator is for educational and analytical purposes only. It does not provide financial advice or guarantee profitable trades. Always combine momentum and trend indicators with proper risk management and price action analysis.
Pine Script®指标
由v2c_cha提供
Cross-Timeframe Value Overlay [AGPro Series]Cross-Timeframe Value Overlay 🔷 Overview Cross-Timeframe Value Overlay projects up to three independent rolling value bands — one per selected higher timeframe — onto a single chart. Each band marks the region where price has been accepted on that timeframe over a configurable lookback window, built from a volume-weighted or mean-based anchor surrounded by an ATR envelope. A built-in state engine then classifies the relationship between bands in real time as ALIGNED, OVERLAP, CONFLICT or NEUTRAL, so multi-timeframe context becomes readable in a single glance. 🔷 What Makes This Different Most multi-timeframe scripts stack indicators or draw fixed HTF pivots. This tool builds a *rolling* value envelope on each timeframe and then compares them structurally rather than numerically. • Three independent MTF value bands on one chart, each with its own lookback context and ATR-sized width. • Dedicated state engine with four discrete regimes — ALIGNED / OVERLAP / CONFLICT / NEUTRAL — based on pairwise band geometry, not on raw price. • Dynamic z-order rendering that automatically draws the slowest timeframe behind faster ones, and an opacity hierarchy that keeps the slowest band lightest and the fastest band darkest. Larger structures frame smaller ones instead of obscuring them. • Rank-based label placement that prevents collisions when bands overlap in price, so labels remain readable even during OVERLAP or ALIGNED states. • Box width adaptively capped so a Daily band cannot swallow a 1H chart. • Dominant-TF tracking that always reports the highest enabled timeframe and the price position relative to its band. 🔷 Methodology For each enabled timeframe the script computes: • Anchor = VWAP (volume-weighted HLC3) over the rolling window, or HLC3 SMA when volume data is unreliable. • Half = ATR(window) multiplied by the configured band-width factor. • Band = . Values are requested with lookahead disabled, so historical band positions reflect only data that was available at the time. The state engine then evaluates: • Pairwise overlap — do any two bands share a price region? • Alignment — are all enabled band centers clustered within a strictness threshold (Loose 1.2 ATR / Standard 0.8 ATR / Strict 0.4 ATR) of their mean? • Disjoint count — how many pairs are fully separated? These three checks map deterministically to one of four states on every bar. 🔷 Signals and Alerts Three built-in alert conditions cover the most useful MTF transitions: • Value Overlap Detected — a new pairwise overlap forms between any two enabled timeframes. • Higher-Timeframe Value Lost — price leaves the dominant HTF value band after being inside it on the previous bar. • Cross-Timeframe Conflict — the state engine transitions into CONFLICT, indicating that at least one enabled pair of bands has become fully disjoint. All alerts are wired as alertcondition() entries so they can be combined with the standard TradingView alert workflow. 🔷 Key Inputs • Timeframes — enable/disable up to three HTFs and pick any resolution for each (defaults 1H / 4H / Daily). • Rolling Window — 10 to 500 bars for the anchor and ATR. • Band Width — 0.25 to 3.0 ATR half-width. • Anchor Method — VWAP + ATR or HLC3 MA + ATR. • Alignment Strictness — Loose, Standard or Strict threshold for the state engine. • Show Only Overlapping Bands — hides isolated bands to keep confluence zones visible. • Visuals — per-TF color, base opacity, right-edge label toggle, label font size. • Panel — position, font size and master visibility switch. 🔷 How to Use • Read the state first. ALIGNED = all enabled timeframes agree on a common value region; OVERLAP = partial confluence; CONFLICT = disjoint timeframes; NEUTRAL = fewer than two active bands or indeterminate. • Read the Dominant row to see which timeframe currently carries the most structural weight. • Read the per-TF rows to locate price as Above / Inside / Below each band. • Combine the three in a single pass: for example, price Above a dominant HTF band while the state is CONFLICT is a very different context from price Inside an ALIGNED stack. • Pair with your existing entry framework (breakout, mean-reversion, order flow, trend-following) — this tool is a context layer, not an entry signal generator. 🔷 Limitations and Transparency • Box-based rendering is capped at three concurrent bands by design to keep the chart readable. • All values are computed with lookahead disabled. Bands update when the corresponding HTF bar closes, which is the expected behavior for any MTF tool. • Volume-weighted anchoring depends on the quality of the instrument's volume feed; on markets with unreliable volume, switch to the HLC3 MA method. • This script is an analytical overlay. It is not a strategy, does not produce buy/sell signals, and makes no forecasting claim. 🔷 Risk Disclosure Trading involves substantial risk. This indicator is provided for research and educational purposes only and does not constitute financial advice. Past market behavior does not guarantee future results. Always perform your own due diligence and use proper risk management. Open-source under Mozilla Public License 2.0.
Pine Script®指标
由AGProLabs提供
MTF Trend Agreement Map [AGPro Series]MTF Trend Agreement Map 🔹 **Overview** MTF Trend Agreement Map is a multi-timeframe alignment engine that reads the trend across five timeframes at once and distills the result into a single transparent agreement score. Instead of forcing you to flip between charts, the map tells you, on every bar, how many timeframes agree, which side wins, and whether the market is in a locked regime, a forming trend, or a conflict phase. It is built for swing traders, HTF-bias scalpers, position traders, and anyone who uses top-down analysis as part of their process. 🔸 **What Makes It Different** Most MTF indicators show a single method (usually a moving-average cross) repeated across timeframes, which means five rows that all agree with each other by construction. This map does something different: for each timeframe it runs three independent methods — an EMA regime filter, a pivot-based market-structure read (HH/HL vs LH/LL), and a normalized momentum slope — and blends their individual votes into the final score. You see not only the agreement across timeframes but also the agreement across methods, which exposes weak or borderline regimes that a single-method tool would quietly hide. 🔺 **Methodology** • EMA Trend: a timeframe is bullish when EMA50 is above EMA200 and price is above EMA50; bearish on the mirror condition; neutral otherwise. • Market Structure: confirmed pivots are tracked in real time. A timeframe is bullish while the last two confirmed swings form higher highs and higher lows, bearish on lower highs and lower lows. • Momentum Slope: the change in linear regression across a configurable lookback, normalized by ATR so that fast and slow assets are comparable. • Consensus per timeframe: each active method casts a vote; bulls minus bears determines the row's net direction and strength. • Overall alignment: bull and bear votes are summed across all active timeframes; the dominant side's share defines the agreement percentage. ◆ **Three-State Regime Engine** • **LOCKED** — agreement above the strong threshold (default 80%). High-conviction regime, continuation-friendly, background tint activates. • **TRENDING** — agreement between 50% and the strong threshold. Directional bias forming but not yet fully aligned. Trade with reduced size or wait for confirmation. • **SPLIT** — agreement below 50%. Timeframes are in conflict, no majority side. Classic chop phase, favors mean-reversion strategies or standing aside. 🔔 **Signals & Alerts** • Regime Lock (Bull or Bear): fires the first bar agreement crosses above the strong threshold while one side dominates. Designed as a continuation trigger, not a reversal signal. • Chop / Conflict: fires when no side holds the majority, a classic filter for mean-reversion systems or a stand-aside cue for trend traders. • Both generic and directional alertcondition() hooks are exposed so you can wire the map into automations. ⚙️ **Key Inputs** • Core Engine: toggle any of the three methods on or off, and tune the pivot length and momentum lookback independently. • Timeframes: four user-selected timeframes plus an optional Current row that auto-adapts to the chart TF. If the chart TF matches any selected TF, the Current row is hidden automatically to avoid double-counting. • Panel: six location presets, four text sizes (default Normal), dark or light theme, optional per-method breakdown row. • Background Tint: enable or disable, set the strong-alignment threshold (50–95%) and control transparency (70–99) to keep the chart premium. 📖 **How to Use** • Top-down confirmation: take trades on your execution timeframe only when the higher rows in the map agree with your thesis. • Regime filter: enable Regime Lock alerts to catch moments when the full map snaps into alignment — these are typical continuation windows. • Conflict filter: when the map prints SPLIT, widen stops, reduce size, or step aside; trend strategies historically underperform during these phases. • Method debugging: turn on the per-method breakdown to see which methods are driving the score and which are fighting it. ⚠️ **Limitations & Transparency** • All timeframe values are non-repainting at bar close (lookahead is disabled), but intrabar values can update until the parent bar closes — this is expected MTF behavior. • Market Structure requires enough history on each timeframe to confirm two swings; on very young assets or short charts the structure vote may be neutral until pivots print. • The map is a context tool, not a standalone entry system — combine it with your own execution logic, risk management, and bias. 📌 **Risk Disclosure** This script is provided for educational and analytical purposes only. It does not constitute financial advice, a recommendation, or a solicitation to trade any instrument. Markets involve substantial risk and past behavior does not guarantee future results. Always do your own research and manage risk responsibly.
Pine Script®指标
由AGProLabs提供
IndiaVixLibrary "IndiaVix" getPrevDayClose(_symbol, _tf)   Parameters:      _symbol (simple string)      _tf (simple string) getSentientValues(_enable, _vix, _indexInput, _symbol, _sigma, _tredingDays)   Parameters:      _enable (bool)      _vix (float)      _indexInput (float)      _symbol (simple string)      _sigma (simple float)      _tredingDays (simple int) getVix(_tf)   Parameters:      _tf (simple string) method chgVsPrev(this)   Namespace types: Vix   Parameters:      this (Vix) method chgVsPDC(this)   Namespace types: Vix   Parameters:      this (Vix) method dailyMovePts(this, _c)   Namespace types: Vix   Parameters:      this (Vix)      _c (float) method isRising(this)   Namespace types: Vix   Parameters:      this (Vix) method regime(this)   Namespace types: Vix   Parameters:      this (Vix) Vix   Fields:      now (series float)      prev (series float)      eod (series float)
Pine Script®库
由sanjeevrjha提供
WTFTime Library (do not delete)Library "WTFTime" Utilities for measuring time. bar()   Gets the number of milliseconds per bar. date(datetime)   Gets the start of the day for the provided time value.   Parameters:      datetime (int) : The date/time to acquire the date from.   Returns: The number of milliseconds representing the date for the given value. timeOfDay(datetime)   Gets milliseconds from the start of the day.   Parameters:      datetime (int) : The date/time to acquire the time of day from.   Returns: The number of milliseconds representing time of day. spanToLen(timespan, type, sessionMinutes)   Returns the number (float) bars that represents the timespan provided.   Parameters:      timespan (simple float) : The number of units to convert to bar count.      type (simple string) : The type of units to measure. ('Bar', 'Bars', 'Minute', 'Minutes', 'Day' or 'Days')      sessionMinutes (simple int) : Optional override for the number of minutes per session. (Default: Regular = 390, Extended = 1440)   Returns: The number bars that represents the timespan provided. spanToIntLen(timespan, type)   Returns the number (int) bars that represents the timespan provided.   Parameters:      timespan (simple float) : The number of units to convert to bar count.      type (simple string) : The type of units to measure. ('Bar', 'Minute' or 'Day')   Returns: The number bars that represents the timespan provided.
Pine Script®库
由digitlnoize42提供
1
Advanced Fibonacci Confluence Matrix [MarkitTick]💡 The Advanced Fibonacci Confluence Matrix is a sophisticated multi-dimensional analytical tool designed for professional traders who demand precision in identifying high-probability institutional entry zones. By integrating Fibonacci retracement logic with multi-timeframe (MTF) confluence and Fair Value Gap (FVG) detection, this script identifies the "Optimal Trade Entry" (OTE) zones where various technical factors align. It serves as a comprehensive institutional-grade execution engine, providing not just visual zones, but also automated risk calculation and webhook-ready alert payloads for algorithmic execution. ● ✨ Originality and Utility Traditional Fibonacci tools are often static and require manual adjustment, leading to subjective bias and missed opportunities during rapid price action. This indicator revolutionizes the process by: • Dynamic Anchor Selection : It automatically identifies significant swing highs and lows to anchor Fibonacci levels, ensuring that the zones remain relevant to current market structure. • Multi-Timeframe Confluence : It fetches Fibonacci data from higher timeframes (HTF), such as the Daily or 4-hour charts, and overlays them onto the local timeframe. This allows traders to see when a local OTE zone aligns with a major institutional level. • FVG Integration : The script looks for Fair Value Gaps within the OTE zones. The presence of an FVG serves as a "magnet" or "trigger," increasing the probability that price will react within that specific area. • Automated Alert Logic : Unlike simple price alerts, this script generates a structured JSON payload including Entry, Stop Loss, Take Profit, and calculated Position Size based on user-defined risk parameters. ● 🔬 Methodology and Concepts The indicator is built upon the premise of Institutional Order Flow and the "Discount vs. Premium" market theory. • Fibonacci Retracement Engine : The core logic calculates standard ratios (0.236, 0.382, 0.5, 0.618, 0.786). The "Optimal Trade Entry" is specifically defined as the zone between the 0.618 and 0.786 retracement levels. • The Confluence Matrix : The script maintains an internal matrix of "hits." When price enters a zone where a local Fibonacci level, an HTF level, and a Prime FVG all overlap, the confluence score increases, and the visual intensity of the zone changes to alert the trader. • Fair Value Gap (FVG) Logic : The script detects imbalances where the High of Bar N is lower than the Low of Bar N+2 (for bearish) or the Low of Bar N is higher than the High of Bar N+2 (for bullish). It specifically filters for "Prime FVGs" that reside within the OTE retracement area. • Risk-Adjusted Position Sizing : It uses the distance between the Entry (usually the 0.618 level or FVG edge) and the Stop Loss (usually the swing anchor) to calculate how many units should be traded to risk exactly X% of the account balance. ● 🎨 Visual Guide • The OTE Zone (The Golden Box) : A shaded rectangle appearing between the 0.618 and 0.786 Fibonacci levels. A Green box signifies a bullish discount zone, while a Red box signifies a bearish premium zone. • HTF Confluence Lines : Horizontal dashed lines across the chart representing the 0.5 (Equilibrium) and 0.618 levels from a higher timeframe. These are typically colored Orange or Purple to distinguish them from local levels. • Fair Value Gap (FVG) Rectangles : Small, semi-transparent boxes that mark price imbalances. When these appear inside the OTE Zone, they are highlighted with a thicker border to indicate a "High Probability Trigger." • Swing Anchor Labels : Small "H" (High) and "L" (Low) labels appear at the points where the Fibonacci tool is anchored. These labels help the trader verify the current market structure context. • Signal Labels : When a confluence event occurs, a "BUY" or "SELL" label appears above or below the candle. The label includes the calculated "Risk:Reward" ratio for that specific setup. • Dashboard Table : A small UI element in the corner of the chart displaying the current HTF trend status, the distance to the nearest OTE zone, and the calculated position size for the next trade. ● 📖 How to Use • Identifying a Setup : Wait for the script to define a new swing move. Once the "OTE Zone" box is drawn, monitor the price as it retraces toward that box. • Confirming Confluence : The highest quality trades occur when the price enters the OTE zone and simultaneously touches an HTF dashed line or fills a Prime FVG. • Execution : Look for the "Long Entry" or "Short Entry" signal. The script is optimized for "Bar Close" execution to avoid repainting issues. • Automation : If using webhooks, ensure your execution platform is set to receive the JSON format. The "Action," "Ticker," and "Qty" fields are automatically populated based on the signal. • Exit Strategy : The default Take Profit is set to the 0.0 Fibonacci level (the swing high/low), while the Stop Loss is placed just beyond the 1.0 anchor point. ● ⚙️ Inputs and Settings • Fibonacci Sensitivity : Adjust the "Swing Lookback" to determine how significant a high or low must be to act as an anchor. Higher values result in more "Macro" zones. • HTF Resolution : A dropdown allowing you to select which timeframe (e.g., 60m, 240m, Daily) the confluence lines should be pulled from. • Zone Selection : Toggle switches to enable or disable specific levels (e.g., show only the 0.618 and 0.786). • Risk Management : Input your "Account Size" and "Risk Percentage" (e.g., 1% or 0.5%) to calibrate the automated position sizing alerts. • Alert Configuration : Options to enable specific JSON payloads for "Long Only," "Short Only," or "Both." ● 🔍 Deconstruction of the Underlying Scientific and Academic Framework The Advanced Fibonacci Confluence Matrix is grounded in the Golden Ratio Theory and the Efficient Market Hypothesis (EMH), specifically focusing on market inefficiencies. • Mathematical Proportions : The indicator utilizes the irrational number Phi (approximately 1.618) and its inverse (0.618). These ratios are derived from the Fibonacci sequence, where each number is the sum of the two preceding ones. In financial markets, these ratios describe the recursive nature of price retracements and expansions. • Statistical Mean Reversion : The use of the 0.5 level (Equilibrium) is based on the statistical principle of mean reversion, suggesting that price has a natural tendency to return to a central point of value before continuing a trend. • Liquidity & Imbalance Theory : The Fair Value Gap detection is based on the "Information Asymmetry" model in economics. When a large institutional order enters the market, it creates a "gap" or "void" because the liquidity at certain price levels was consumed too quickly. Academically, these gaps represent "Inefficient Pricing" that the market seeks to "fill" to restore equilibrium. • Confluence Probability : By applying the Law of Large Numbers and Multi-Factor Modeling, the script assumes that the intersection of independent variables (Local Fib + HTF Fib + FVG) reduces the "Noise-to-Signal" ratio, thereby increasing the statistical significance of the resulting trade signal. ⚠️ Disclaimer All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion.
Pine Script®指标
由MarkitTick提供
4
MarketStructureLibMarket Structure Library (MSL) A Multi-Timeframe Structural Analysis Toolkit for Pine Script A Developer's Library for Building Advanced Structural Analysis Indicators. 🎓 THEORETICAL FOUNDATION The Market Structure Library (MSL) is a collection of functions and data types designed for Pine Script developers to build custom structural analysis indicators. It provides a framework for analyzing market geometry, liquidity, and order flow across multiple timeframes. The library's functions handle complex calculations related to multi-timeframe data aggregation and analysis. The system is organized around four functional pillars that work together to provide a unified structural context. Pillar 1: Unified Liquidity Context The library's primary function is to create a unified view of market activity. It includes logic to automatically detect if real footprint data is available. With Footprint Data: It utilizes bid-ask volume, delta, and Value Area metrics for analysis. Without Footprint Data: It employs a mathematical OHLCV proxy to model bar dynamics and approximate buy/sell pressure, absorption, and aggressor intent. This dual-mode capability allows indicators built with the library to function consistently regardless of the user's data source. Pillar 2: Multi-Timeframe Structure Aggregation Market structure is fractal, with higher timeframe levels influencing lower timeframe price action. The MSL is designed to manage this by providing a master container (MultiTFStructure) that holds and organizes structural data—including swing points, value areas, and dynamic levels—for up to four user-defined timeframes. This allows a script to query and act on a complete, multi-layered market picture. Pillar 3: Dynamic Structure - The Siege Corridor The MSL introduces ' Siege Corridors ,' which are dynamic trendlines projected from consecutive pivot points. These are data objects that are updated with price interaction statistics, including hit count , energy decay , order flow alignment , and the calculated probability of a break or failure . Pillar 4: High-Probability Confluence Zones Significant price action often occurs where structure from multiple timeframes aligns. The library's find_zones function is a discovery utility that scans all tracked levels across all timeframes. It identifies these Confluence Zones where levels cluster, calculating their combined strength, dominant type (supply/demand), and overall bias. 🔧 COMPREHENSIVE API & DATA TYPES This library provides developers with a set of data structures (types) to utilize in their scripts. A clear understanding of these types is essential for proper implementation. Core Data Types MarketContext: A per-bar snapshot of liquidity, blending Footprint and OHLCV models. Includes unified_delta, absorption, spread_proxy, and vol_quality. LevelLiquidity: A detailed analysis of order flow specifically at a structural level. Provides hold_probability, break_probability, and an action_type classifier ("defending", "absorbing", "attacking"). StructureLevel: Represents a single horizontal level (e.g., POC, VAH, Swing High/Low). Contains its price, level_type, timeframe, strength, age, and its own LevelLiquidity object. SiegeCorridor: The complete object for a dynamic trendline. Contains anchor points, slope, hit_count, decay, and break_prob/fail_prob. Container Types TimeframeStructure: The container for all structural information for a single timeframe. It holds the poc, vah, val_, an array of all StructureLevel objects, and the res_corridor and sup_corridor. MultiTFStructure: The master object that a script will primarily interact with. It holds up to four TimeframeStructure objects, providing the complete multi-timeframe view. Analysis & State Types ConfluenceZone: An object representing a cluster of levels. Contains the zone's average price, width, level_count, and combined_strength. StructureState: A high-level summary for decision-making logic. Provides nearest_support, nearest_resistance, net_bias, and a boolean for whether price is inside_value. IntrabarState: Designed for real-time, tick-level analysis. Indicates if price is currently touching a POC, VAH, Siege Corridor, or Confluence Zone. 🎨 VISUALIZING THE STRUCTURE (IMPLEMENTATION EXAMPLES) The provided images demonstrate visualizations that can be built using the data objects from the MSL. The library supplies the calculated data; the developer controls the visual output. Drawing Confluence Zones (Boxes) Use the find_zones() function to get an array of ConfluenceZone objects. For each zone: The box's vertical position is determined by zone.price. The box's height is determined by zone.width. The box's color can be conditional on zone.dominant_type ("supply" or "demand"). The box's styling (e.g., opacity) can be driven by zone.combined_strength. Drawing Siege Corridors (Channels) Access the res_corridor and sup_corridor from a TimeframeStructure object. The central dashed line is drawn from corr.anchor_bar_a/corr.anchor_price_a to the current bar, extended by corr.slope. Outer boundary lines can be drawn parallel to the central line, offset by an ATR-based value. Drawing Value Area & Swing Levels (Horizontal Lines) Iterate through the levels array within each TimeframeStructure. Use level.price to draw the line. Use get_level_color(level) to apply a consistent color scheme based on the level.level_type. Creating Informative Labels Labels can be generated by combining data from library objects. A label for a resistance level could display: Level Type & Timeframe: level.level_type + level.timeframe Hold/Break Probabilities: Access level.liquidity.hold_probability when price interacts with the level. Siege Stats: For a siege corridor, display corr.hit_count and corr.fail_prob. 📚 DEVELOPER INTEGRATION GUIDE This guide outlines the process for integrating the MSL into a Pine Script indicator. Step 1: Import & Initialization Import the library and initialize the master MultiTFStructure container in the script's global scope. import DskyzInvestments/MarketStructureLib/1 as msl var msl.MultiTFStructure structure = msl.create_structure() Step 2: Define Timeframes & Collect Data Define the timeframes for analysis. Use request.security to retrieve the required OHLCV and pivot data for each timeframe. // --- INPUTS --- tf1 = input.timeframe("15", "Timeframe 1") pivot_len = input.int(15, "Pivot Lookback") // --- DATA COLLECTION --- // Request TF1 data using request.security() // Collect historical arrays of highs, lows, pivots, etc. for TF1 Step 3: Get Unified Market Context Once per bar, generate the fused liquidity context. This object is passed to other functions for liquidity calculations. // --- MAIN LOGIC --- float atr_val = ta.atr(14) footprint fp = request.footprint(100, 70) // Optional: use 'na' if not using footprint msl.MarketContext ctx = msl.get_market_context(open, high, low, close, volume, fp, ta.sma(volume, 20), nz(structure.tf1.poc ), atr_val) Step 4: Update the Structure Container On each bar, update the respective TimeframeStructure object within the master container. // Calculate TF1's Value Area from historical arrays = msl.calc_unified_poc_va(h_arr1, l_arr1, c_arr1, v_arr1, 24, fp) // Update the structure object for TF1 structure.tf1 := msl.update_structure(structure.tf1, poc1, vah1, val1, sh_p1, sh_b1, sl_p1, sl_b1, tf1, atr_val, ctx) // Repeat for structure.tf2, etc. Step 5: Analyze and Use the Data With the structure updated, perform high-level analysis using the state and zone functions. // Find Confluence Zones with a 0.3% price tolerance array zones = msl.find_zones(structure, 0.3) // Get the high-level summary state msl.StructureState state = msl.get_structure_state(structure, close, false) // Use state.net_bias, state.nearest_support, etc. for indicator logic // Get Real-Time Intra-Bar State for precise alerts float alert_tolerance = atr_val * 0.1 msl.IntrabarState ib_state = msl.scan_intrabar_levels(structure, zones, close, alert_tolerance) if ib_state.at_confluence alert("Price is at " + ib_state.active_level_name, alert.freq_once_per_bar) Step 6: Visualization Use the data from the structure, zones, and state objects to implement the script's visual elements (lines, boxes, tables, labels). 🔮 CONCLUSION The Market Structure Library (MSL) library provides a structured set of tools for developers working with multi-timeframe market structure. By encapsulating complex calculations for data aggregation, liquidity modeling, and geometric analysis, it allows developers to focus on the specific logic and visualization of their custom indicators. The library is designed to serve as a foundational component for building detailed and context-aware analysis tools in Pine Script.
Pine Script®库
由DskyzInvestments提供
3
Objective Market Structure FrameworkThis library provides a systematic, rule-based approach to categorize market movements into four objective phases: Compression, Expansion, Distribution, and Consolidation. Instead of subjective chart patterns, this tool uses volatility-relative thresholds (ATR) and momentum filters to identify significant trading ranges and structural breaks. Main Use Cases: Clear & Compact MTF Visualization: Map higher-timeframe (HTF) market structures directly onto your lower-timeframe (LTF) charts. Provides a clean, non-cluttered overview for an intuitive display of key levels without overcomplicating the chart. Automated Setup Classification: Assign specific trading setups to distinct market regimes (Uptrends, Corrections, Sideways Ranges). Enables rapid, objective analysis every trading day, eliminating the need for manual re-evaluation or "hunting" for the current trend state. Core Features: Volatility-Adaptive: Range calculations scale automatically with the market's current ATR, making the analysis relevant across all asset classes. MTF-Optimized Performance: Engineered for professional Multi-Timeframe workflows. Fetch 19 structural variables with a single request.security() call to minimize script load and prevent memory errors. Momentum Validation: Distinguishes between high-conviction structural breaks and low-momentum "noise" using body-to-ATR ratios. Reliability & Stability: Built-in Guard-Clauses protect against "Bar 0" and "NA" runtime errors, even when requesting lower timeframe data from a higher timeframe chart. Key Parameters (Customizable Defaults): Distribution Threshold (e.g. 1.2): Identifies price movement beyond the established range to confirm trend strength. Compression (e.g. 1.5x ATR): Detects low-volatility buildup phases. Expansion (e.g. 4.0x ATR): Flags explosive "Huge Range" impulses. How to use (Educational Example included): The source code contains a fully functional MTF Dashboard example (commented out at the bottom). It demonstrates how to map the library’s output variables into a visual trading interface, showing HTF trend alignment and real-time market phases. Quick Start (Implementation): import arnipoer/PriceActionStructure/1 as pa // Single request for all 19 structural variables = request.security(syminfo.tickerid, "D", pa.get_structure(true, 1.0, close, 14, 1.2, 1.5, 4.0)) // Example: Visualization plot(strHigh, color=color.aqua, title="HTF Structure High") bgcolor(hugeRange ? color.new(color.purple, 80) : na, title="Expansion Alert") Disclaimer: No financial advice. Trading involves significant risk. This is an analytical tool for professional traders to build their own systematic strategies.
Pine Script®库
由arnipoer提供
3
Synapse_VSync_LibV-Sync (Volume Synchronization) is a multi-dimensional macro-confluence engine. It aggregates four objective market truths into a single synchronized bias (0.0 to 1.0) to filter signals and define market regime. The Four Pillars of V-Sync 1. Base Volume (Temporal Flux) Engine: Exponentially weighted volume flow. Logic: up_volume / total_volume with a math.exp(-i/lookback) decay. Utility: Capturing sustained momentum in raw participation. It filters out low-volume "fakeout" moves that lack broad participation. 2. Footprint (Order Flow Delta) Engine: Micro-delta tracking (Institutional Tape). Logic: Normalized ratio of aggressive buy orders vs sell orders, sourced from LTF footprint or synthetic body-to-wick estimation. Utility: Identifying where "Smart Money" is actively committing capital in real-time. 3. TICK Data (Market Internals) Engine: Exchange-wide breadth internals. Index Mapping: SPX/ES: NYSE:TICK NQ/NDX: NASDAQ:TICKQ Fidelity: Processes intrabar HT/LT extremes to capture high-speed institutional sweeps. Commitment Levels: Benchmarked at 800 (MOO alignment), 1000 (Extreme), and 1200 (Climax). 4. Thermal Map (Structural Binning) Engine: Range-based volume distribution (Heatmap). Logic: 30-bin price-range analysis. Identifies if the current price is supported by "Buy Liquidity" below or capped by "Sell Liquidity" above. Utility: Visualizing structural depth and identifying high-probability zones where price is likely to stick or bounce. Interaction & Intelligence Modules 5. Interaction Tooltips Engine: Dynamic string generator. Logic: Aggregates pillars (V-Sync, TICK, Heatmap) and local interaction (Delta, OB Bias) into a human-readable forensic report. Utility: Provides instant clarity on why a level is reacting (e.g., "Institutional Defense" vs "Passive Absorption"). 6. Delta Aggregation (Defense vs Aggression) Engine: Decaying session delta sum. Logic: Tracks footprint delta at discrete price levels. Categorizes bias as: Aggressive (A): Delta moves in the direction of the break (Push). Defensive (D): Delta moves against the local price interaction (Absorption/Soaking). Utility: Standardizing the interpretation of footprint across all Synapse indicators. 7. Universal Plot Auditing Engine: Kinetic flux interaction logic. Logic: Allows auditing of any technical plot line (Moving Averages, VWAP, Anchored Levels) for touches, cross-overs, and structural fidelity. Utility: Enables the entire Synapse forensic suite to be applied to any existing indicator's data lines. Library Architecture: Synapse_VSync_Lib Key Functions f_get_tick_source(): Auto-detects SPX vs NQ for correct internal sourcing. f_calc_tick_extreme(): High-fidelity internal pressure tracking. f_vsync_stack(): Blends all pillars into a weighted consensus. HUD Representation Indicators utilizing the full stack display V-STACK (instead of V-SYNC), signifying that Market Internals and Structural structural depth are being calculated alongside volume flow. License: Open Source (MIT License)
Pine Script®库
由Selfsimilarity提供
Ultimate MTF Trend Dashboard [identityKa]Overview The Ultimate MTF Trend Dashboard is a comprehensive trend-following ecosystem that combines a zero-lag overlay cloud with a strict Multi-Timeframe (MTF) alignment dashboard. Designed for traders who require deep market context, this indicator visually tracks the immediate trend while simultaneously cross-referencing higher timeframes (15m, 1H, 4H, and Daily) to ensure trades are taken in the direction of the dominant macroeconomic flow. Mathematical Engine & Non-Repainting Logic The core trend calculation is built upon the Hull Moving Average (HMA). HMAs are favored for their ability to significantly reduce lag while maintaining a smooth curve. The Cloud: The script calculates a Fast HMA (default 14) and a Slow HMA (default 50). The area between them is filled to create a visual "Cloud." When the Fast HMA is above the Slow HMA, the cloud represents a bullish trend, and vice versa. Non-Repainting MTF Engine: Traditional MTF indicators in Pine Script often suffer from repainting issues by looking ahead into unclosed bars. This script solves that by securely fetching historical offset data ( ) combined with barmerge.lookahead_on across all higher timeframes. This guarantees that the dashboard values are strictly historically accurate and non-repainting. HUD Dashboard & AI State Suggestion The on-chart panel serves as the central intelligence hub, constantly evaluating the HMA state across four distinct timeframes. At the bottom of the dashboard is the rule-based AI Suggestion: LONG: Triggered only when the 15m, 1H, 4H, and 1D timeframes are all simultaneously in a Bullish state (Fast HMA > Slow HMA). SHORT: Triggered only when all four tracked timeframes are simultaneously in a Bearish state (Fast HMA < Slow HMA). Dangerous: Displayed when there is a conflict between timeframes (e.g., 1H is Bullish, but 4H is Bearish). This mathematically indicates market chop or a broader consolidation phase. How to Use It This tool acts as a supreme filter for Price Action trading. Traders should avoid taking trend-continuation setups when the AI Suggestion reads "Dangerous." Instead, patience should be exercised until full MTF alignment occurs. When the dashboard outputs "LONG" or "SHORT," traders can look for pullbacks into the local HMA Cloud on their execution timeframe to find optimal, low-risk entries in the direction of the undeniable macro trend.
Pine Script®指标
由IdentityKa提供
MTF Trend Panel [Dow/SMC]■ 概要 複数の時間足（マルチタイムフレーム：MTF）のトレンド方向をひとつのチャート上で一目で確認できるパネル型インジケーターです。トレンドの判定基準として、「ダウ理論（Dow）」と「スマートマネーコンセプト（SMC）」の2種類のロジックからお好みのものを選択できます。 ■ 主な特徴 2種類のトレンド判定ロジック: Dow（ダウ理論モード）: 直近2つのピボットハイ（高値）とピボットロー（安値）を比較し、高値・安値の切り上げで「上昇トレンド」、切り下げで「下降トレンド」と判定します。 SMC（スマートマネーコンセプトモード）: ローソク足の終値が直近のピボットハイ、またはピボットローをブレイク（BOS / CHoCH）した方向に基づいてトレンドを判定します。 最大6つの時間足を監視: 月足、週足、日足、4時間足、1時間足、15分足など、監視したい時間足を最大6つまで任意に設定可能です。 カスタマイズ可能なUI: パネルの表示位置（四隅）や、文字のサイズをチャート環境に合わせて自由に変更できます。 ■ 設定項目 判定ロジック設定: ロジックの切り替え（Dow / SMC）、ピボット判定に用いる左右のバー数（Left/Right Bars） タイムフレーム設定: パネルに表示する6つの時間足（Timeframe 1 ～ 6） パネル設定: 表示位置（Top Right, Bottom Leftなど）、文字サイズ ---------------------------------------------------------------------------------------- ■ Overview This indicator provides a multi-timeframe (MTF) panel that allows you to check the current trend direction across up to 6 different timeframes at a glance. You can seamlessly switch between two distinct logic modes for trend detection: Dow Theory and Smart Money Concepts (SMC). ■ Key Features Two Trend Detection Logics: Dow Mode: Uses classic Dow Theory. It compares the last two Pivot Highs and Pivot Lows. An uptrend is identified by higher highs and higher lows, while a downtrend is identified by lower highs and lower lows. SMC Mode: Based on Smart Money Concepts. The trend is determined by the closing price breaking the most recent Pivot High or Pivot Low (BOS / CHoCH). Monitor Up to 6 Timeframes: Fully customizable. You can set up to 6 timeframes to monitor simultaneously (e.g., 1M, 1W, D, 4H, 1H, 15m). Customizable UI: Easily adjust the panel's position on the chart (top-right, bottom-left, etc.) and text size to fit your trading setup. ■ Settings Logic Settings: Choose between 'Dow' and 'SMC'. Adjust Left/Right bars for Pivot calculations. Timeframe Settings: Select 6 specific timeframes to display on the panel. Panel Settings: Select screen position and text size.
Pine Script®指标
由MGtrader12358提供
TCD_scoring_lib_v2Scoring engine for TCD (Trade Consistent & Disciplined). Takes data from all library modules across 4 timeframes and produces: - **BUY/SELL scores (0-10):** Multi-timeframe trend alignment scoring - **CT Buy/Sell scores (0-18):** Counter-trend exhaustion scoring with stretched, structural, and completion signals - **Trade recommendations:** Scalp (with-trend and counter-trend) and Swing setups with specific entry, stop loss, T1, and T2 levels - **Validation pipeline:** Direction clamping, SL sanity checks, target hit cascading, proximity filtering, and R:R computation Pure functions only — no `request.security()` calls. All timeframe data is passed in from the main indicator. Used by: TCD - Trade Consistent & Disciplined (indicator)
Pine Script®库
由TradeCandD提供
TCD_scoring_libScoring engine for TCD (Trade Consistent & Disciplined). Takes data from all library modules across 4 timeframes and produces: - **BUY/SELL scores (0-10):** Multi-timeframe trend alignment scoring - **CT Buy/Sell scores (0-18):** Counter-trend exhaustion scoring with stretched, structural, and completion signals - **Trade recommendations:** Scalp (with-trend and counter-trend) and Swing setups with specific entry, stop loss, T1, and T2 levels - **Validation pipeline:** Direction clamping, SL sanity checks, target hit cascading, proximity filtering, and R:R computation Pure functions only — no `request.security()` calls. All timeframe data is passed in from the main indicator. Used by: TCD - Trade Consistent & Disciplined (indicator)
Pine Script®库
由TradeCandD提供
lib_failed_breakdownFailed breakdown/breakout detection with exhaustion support and resistance levels. Identifies swing high/low exhaustion points as support/resistance. Detects when price breaks through a level but fails to hold — a failed breakdown (bullish exhaustion signal) or failed breakout (bearish exhaustion signal). These structural signals are key for counter-trend trade activation. Adapted from Leledc Levels by InSilico: **Exports:** `detect()` — returns failed BD/BO flags, support/resistance levels, and price action failure signals. Used by: TCD - Trade Consistent & Disciplined (indicator)
Pine Script®库
由TradeCandD提供
lib_murrey Murrey Math level calculation and overbought/oversold zone detection. Computes the 8 Murrey Math levels (0/8 through 8/8) plus extended levels (+1/8, -1/8). Returns the current zone (-2 to +2) indicating oversold, neutral, or overbought conditions. Configurable frame size and multiplier. Ported from Murrey Math Lines by Nanda86: **Exports:** `get_murrey_levels()` — returns key Murrey levels (0/8, 4/8, 8/8, +1/8, -1/8), zone value, and increment. Used by: TCD - Trade Consistent & Disciplined (indicator)
Pine Script®库
由TradeCandD提供
lib_trend_modeTarget Trend BUY/SELL mode detection with entry, stop loss, and 3 target levels. Determines whether each timeframe is in BUY or SELL mode using trend direction logic. Provides entry levels, stop loss levels, and up to 3 progressive targets (T1/T2/T3) with hit detection. Also includes a Two Poles momentum filter for trend confirmation. Adapted from Target Trend by BigBeluga: **Exports:** `get_trend()` — returns trend direction, entry, SL, T1-T3, hit status, and Two Poles filter value. Used by: TCD - Trade Consistent & Disciplined (indicator)
Pine Script®库
由TradeCandD提供
lib_bar_strengthBig bar breakout detection for multi-timeframe trading systems. Identifies significant ("big") bars where the range exceeds a configurable ATR multiple. Classifies them as Bull Break, Bear Break, Possible Bull, or Possible Bear. Tracks the most recent strong bar's high, low, midpoint, and ATR multiple for use in key signal notes. **Event types:** 0=None, 1=Bull Break, 2=Bear Break, 3=Possible Bull, 4=Possible Bear **Exports:** `detect()` — returns event type, high, low, midpoint, ATR multiple, and recent strong bar data. Used by: TCD - Trade Consistent & Disciplined (indicator)
Pine Script®库
由TradeCandD提供