지금 시작

피봇 포인트와 레벨

PDH/PDL + PWH/PWL + ICT Bias FilterThis TradingView indicator displays **Previous Day High/Low (PDH/PDL)** and **Previous Week High/Low (PWH/PWL)** as black horizontal rays that start from the exact candle wick where each level was formed and extend to the right edge of the chart. It calculates an **ICT-style daily bias** based on whether the previous day swept the prior day's high/low and where it closed relative to that range - showing bullish if it swept low and closed inside (reversal) or closed above range (continuation), and bearish for the opposite conditions. The script also tracks **structure-based bias** for 4H, 1H, and 15M timeframes by detecting when price breaks above the last swing high (bullish) or below the last swing low (bearish), using pivot points to identify changes of character. All bias readings are displayed in a **color-coded table** in the top-right corner with green for bullish, red for bearish, and gray for neutral conditions.
Pine Script® 인디케이터
Aurelius1027의
2
PyraTime 9 [Context Aware]PyraTime 9 is a highly customizable, noise-reduced mean-reversion indicator. While traditional sequential counting indicators are "blind" printing signals purely based on candle counts regardless of market conditions PyraTime 9 is Context Aware. It was built to solve the common problem of "catching falling knives" by filtering signals through sophisticated trend and momentum checks. Why use this over standard sequential counters? Significantly Less Noise: The "Context Aware" logic filters out low-probability signals that occur against the dominant trend. Intelligent Filtering: Unlike basic tools, you can choose how you validate trades. Filter signals using the 200 EMA, the "Master Angle" (Linear Regression Slope), or RSI Momentum. Cleaner Visuals: The chart only displays valid, high-probability 9s, keeping your workspace clean and focused. Key Features 1. Context-Aware Filtering Select how you want to validate your signals using the settings menu: EMA Trend: Filters signals based on price relation to the 200 EMA (e.g., only show Buy 9s if price is above the EMA). Master Angle: Filters signals based on the slope of Linear Regression. Both (Strict): Requires both the EMA trend and the Master Angle to align with the trade direction for maximum safety. 2. RSI Momentum Check An optional quality control filter. If enabled, the indicator ensures momentum is not already overextended against you before signaling (e.g., a Buy 9 is only valid if RSI < 50). 3. Live Performance Dashboard A premium, on-chart dashboard tracks the historical strike rate of the signals on your current timeframe. Real-Time Feedback: Instantly see if the current settings are profitable on the asset you are trading. Reaction Period: Customizable setting to define what constitutes a "Win." By default, it checks 5 bars after a signal to see if price moved in your favor. How to Use Select your Filter Mode: For trending markets, use "EMA Trend." For volatile/choppy markets, use "Master Angle." Wait for a 9: A green "9" indicates a potential buy setup; a red "9" indicates a potential sell setup. Check the Dashboard: Ensure the current asset/timeframe has a historically high strike rate (green text) before taking action. Disclaimer: This tool is for informational purposes only and does not constitute financial advice. Past performance is not indicative of future results.
Pine Script® 인디케이터
PyraTime의
SOFT V2PV_Pivot _Validation FAST_SLOWSOFT V2PV is a market structure indicator based on confirmed price pivots, combining two independent detection engines: • FAST engine: early detection (more signals, lower reliability) • SLOW engine: delayed detection (fewer signals, higher reliability) • CONFIRMED signals: validated when FAST and SLOW agree within a confirmation window Main features: - Pivot labels marking structural turning points - Validation labels displayed on the confirmation candle (not on the pivot bar) - Configurable vertical stacking for FAST / SLOW / CONFIRMED labels - Reliability score table (LOW / MED / HIGH) - Built-in TradingView alerts (FAST, SLOW, CONFIRMED, ANY signal) Signal interpretation: LOW (FAST) → aggressive / early signal MED (SLOW) → more reliable structural signal HIGH (CONFIRMED) → high-probability setup (FAST + SLOW) The indicator is designed for intraday and swing trading. It works on all markets: indices, forex, crypto, commodities, and metals. ⚠️ Important notes: - Pivot points are confirmed only after a defined number of bars (ZigZag-like logic). - Signals are plotted only after confirmation. - No intentional repainting: once a signal is displayed, it does not move or disappear.
Pine Script® 인디케이터
st_serreau의
Daily Trend Scanner Plus█ DAILY TREND SCANNER PLUS A professional-grade trading indicator designed to help traders quickly identify intraday trend bias across multiple symbols by tracking price relationships to key technical levels: Prior Day High/Low (PDH/PDL) and Pre-Market High/Low (PMH/PML). █ FEATURES ► Single Symbol Table Compact 5-column table displaying PDH, PMH, PDL, PML, and Trend status for the current chart symbol. Shows green dot (🟢) when price breaks above high levels and red dot (🔴) when price breaks below low levels. Progress bars visualize how close price is to breaking key levels. ► Multi Symbol Table Monitor up to 20 tickers simultaneously in a single table. Each row displays ticker name, price, change %, breakout dots, progress bars, and trend status. Optional columns for actual PMH/PML and PDH/PDL price values. Real-time updates for all symbols with color-coded change percentages. ► Table Sorting - None - Displays tickers in input order - Chg % - Sorts by daily change percentage (highest to lowest) - Bullish - Prioritizes bullish setups at top - Bearish - Prioritizes bearish setups at top ► PMH/PML Lines (Pre-Market High/Low) Horizontal lines at pre-market high and low levels (4:00 AM - 9:29 AM ET). Customizable line styles, colors, labels, and optional price display. ► PDH/PDL Lines (Prior Day High/Low) Horizontal lines at previous trading day's high and low. Uses RTH only for stocks (9:30 AM - 4:00 PM ET) and full 24-hour day for non equities. ► ORB Lines (Opening Range Breakout) Captures high and low during the opening period with 5-minute, 10-minute, or 30-minute options. Lines persist from market open until next pre-market session. ► EMA Overlays Three independent EMAs with customizable periods (default: 8, 20, 200). Third EMA can be switched to SMA. Multiple line styles available. ► VWAP Overlay Volume Weighted Average Price with customizable line style, width, and color. █ TREND LOGIC - BULLISH: Price above BOTH Prior Day High AND Pre-Market High Indicates strong upward momentum breaking through two resistance levels - BEARISH: Price below BOTH Prior Day Low AND Pre-Market Low Indicates strong downward momentum breaking through two support levels - NEUTRAL: Price not above both highs or below both lows Price is consolidating between key levels █ PROGRESS BARS Visual 5-block meter showing progress from midpoint toward target level: ▓▓▓▓▓ (80-100%) → ▓▓▓▓▒ (60-80%) → ▓▓▓▒▒ (40-60%) → ▓▓▒▒▒ (20-40%) → ▓▒▒▒▒ (0-20%) Replaced with 🟢 or 🔴 when level is actually broken. █ ASSET TYPE HANDLING STOCKS: - Pre-Market: 4:00 AM - 9:29 AM Eastern - Prior Day: RTH only (9:30 AM - 4:00 PM Eastern) NON-EQUITIES: - Prior Day: Full 24-hour trading day - Automatically detected via symbol type █ RECOMMENDED SETTINGS - Chart Timeframe: 10-minute recommended for multi-table accuracy - Timeframes 60 minutes or less required for ORB functionality - Enable extended hours on chart for accurate PMH/PML on stocks █ USAGE TIPS - Use Bullish sort to find strongest breakout candidates for long trades - Use Bearish sort to find weakest stocks for short/put candidates - Progress bars help anticipate upcoming breakouts before they happen - Combine with ORB lines to confirm trend direction after market open - Watch for alignment: Price above all key levels = strongest bullish signal - PDH/PDL breaks often signal continuation of prior day's trend - PMH/PML breaks can indicate gap-fill or trend reversal setups █ INDICATOR SETTINGS █ EXAMPLE OF FULL MULTI TABLE AND SINGLE TABLE █ MULTI-TABLE SORTING █ PMH/PML, PDH/PDL, ORB LINES █ EMA AND VWAP OVERLAYS █ CUSTOMIZATION
Pine Script® 인디케이터
rogman의
11
Level to level Multi-TF + ATRLevel to level Multi-Timeframe + ATR/ADR Daily Progress This indicator is a complete multi-timeframe market structure and volatility toolkit, designed primarily for active forex traders. It combines Williams Fractals on five higher timeframes (Weekly, Daily, H4, H1, M5) with a live ATR/ADR dashboard, allowing you to see at a glance how much of the typical daily move has already been completed and how much “room” the market realistically has left to run. Fractals are drawn as arrows and colored zones that clearly mark swing highs and lows, supply/demand pockets, and key reaction areas. These zones can be used as dynamic support/resistance, liquidity pools, and target/stop regions. The multi‑TF design lets you read higher‑timeframe structure while executing on lower timeframes, which is ideal for scalping and intraday trading. The built‑in volatility table shows: ATR Progress (%) with green / yellow / red status to indicate whether the current session is still developing, mature, or potentially exhausted. Daily ATR & ADR values in pips, so you always know the typical and current range of the day. Done / Left range, highlighting how many pips have already been travelled from low to high, and how many are statistically left. ATR and ADR projection lines are also plotted from the daily open, giving you clear intraday reference levels for take profit, stop placement, and expected session extremes. This tool works especially well when combined with Smart Money Concepts (SMC) such as: Break of Structure (BOS) and Change of Character (CHoCH) using fractal highs/lows. Liquidity grabs and stop hunts around fractal zones. Order blocks and fair value gaps that overlap with higher‑TF fractals and ATR/ADR levels. Use it on majors like EUR/USD, GBP/USD, XAU/USD or indices, on anything from fast M1–M5 scalping to H1–H4 swing trading. All colors, timeframes, sensitivities and volatility settings are fully customizable so you can adapt it to your own style and template.
Pine Script® 인디케이터
alessia1973f의
Institutional Scanner FixHere is a professional Pine Script (Version 5) for TradingView. It is optimized to precisely identify the "Absorption" and "Reversal" signals. What this script does for you: Auto-Fibonacci: It automatically calculates the 0.618 Golden Ratio of the last 50 candles. Volume Delta Check: It calculates the delta (buy volume minus sell volume) per candle. Signal: It marks a "Buy Absorption" when the price touches the 0.618 level but the delta turns positive (green arrow). The Volume Multiplier is your scanner's "sensitivity knob." It determines how much more volume compared to the average must flow for a signal to be classified as institutionally relevant. Here is the bank standard for calibration, based on your trading strategy and the asset's liquidity: The rule-of-thumb values for the multiplier Strategy Type | Recommended Value | Logic Conservative (High Conviction) | 2.0 to 2.5 | Only extreme volume spikes are marked. Good for swing trades on a daily basis. Standard (Day Trading) | 1.5 to 1.8 | The "sweet spot." Marks volume that is approximately 50-80% above average. Aggressive (Scalping) | 1.2 to 1.3 | Reacts very quickly to small order flow changes but produces more "noise" (false signals).
Pine Script® 인디케이터
karakrypto의
1
ICT Algo: Sweep + MSS + High Prob FVG/IFVGThis script is a comprehensive execution tool based on Inner Circle Trader (ICT) concepts, specifically designed to identify high-probability entries by combining Liquidity Sweeps, Market Structure Shifts (MSS), and Fair Value Gaps (FVG/IFVG). Unlike standard FVG indicators that highlight every gap on the chart, this "Algo" version filters for gaps that occur specifically after a liquidity purge and a shift in structure, ensuring you are only looking at setups with institutional backing. How It Works The script follows a strict 3-step validation process before plotting a signal: Liquidity Sweep (The Context): The script tracks Higher Timeframe (HTF) levels including Previous Day High/Low, Weekly High/Low, and Monthly High/Low. A setup is only considered valid if price has recently "swept" one of these levels, indicating a hunt for liquidity. Market Structure Shift (The Confirmation): Once a sweep occurs, the script looks for a displacement in the opposite direction. It identifies a "Pivot High/Low" (customizable length) and waits for a candle body to close beyond it (MSS). Filtered Entry (The Trigger): * FVG: Plots a standard Fair Value Gap if it forms within a "Deep Value" zone (Discount for longs, Premium for shorts). IFVG (Inversion FVG): Highlights failed FVGs that have been reclaimed by price to act as support or resistance. Key Features Multi-Timeframe Liquidity Filters: Automatically plots PDH/L, PWH/L, PMH/L, and PYH/L. You can toggle which levels act as your sweep triggers. Deep Value Logic: The script uses built-in logic to ensure Bullish FVGs are only highlighted when price is below a key liquidity level (Discount), and Bearish FVGs when price is above (Premium). Dynamic Box Management: To keep your chart clean, boxes for FVGs and IFVGs are automatically shortened ("cut") once they are mitigated by price. Inversion Logic: Includes a specialized toggle for Inversion Fair Value Gaps, allowing you to trade "failed" gaps that flip their polarity. Settings & Customization Entry Setup Bias: Choose to see only Bullish, only Bearish, or Both setups. MSS Pivot Length: Adjust how "sensitive" the Market Structure Shift detection is. A higher number requires a more significant swing to be broken. Sweep Lookback: Defines how many bars back the script looks for a liquidity sweep to remain "active" for a setup. Include Opens: Optional toggle to include Previous Day/Week/Month Opens as liquidity points. Usage Tips The Golden Setup: Look for a sweep of a Previous Day High, followed by a Bearish MSS, and an entry at the Red FVG box. Risk Management: This indicator is designed for entry identification. Always use stop losses (usually placed above/below the candle that created the FVG or the MSS swing point). Timeframes: Best used on execution timeframes (1m, 5m, 15m) while the script handles the HTF levels automatically. Disclaimer: This script is an educational tool and does not constitute financial advice. Trading involves significant risk. Past performance of a strategy does not guarantee future results. Credits: Concepts based on the teachings of Michael J. Huddleston (ICT).
Pine Script® 인디케이터
DivergentTrades의
18
Alg0 Hal0 Peekab00 WindowDescription: Alg0 Hal0 Peekaboo Window The Alg0 Hal0 Peekaboo Window is a specialized volatility and breakout tracking tool designed to isolate price action within a specific rolling time window. By defining a custom lookback period (defaulting to 4.5 hours), this indicator identifies the "Peekaboo Window"—the high and low range established during that time—and provides real-time visual alerts when price "peeks" outside of that established zone. This tool is particularly effective for intraday traders who look for volatility contraction (ranges) followed by expansion (breakouts). How It Works The indicator dynamically calculates the highest high and lowest low over a user-defined hourly duration. Unlike static daily ranges, the Peekaboo Window moves with the price, providing a "rolling" zone of support and resistance based on recent market history. Key Features Rolling Lookback Window: Define your duration in hours (e.g., 4.5h) to capture specific session cycles. Dynamic Visual Range: High and low levels are automatically plotted and filled with a background color for instant visual recognition of the "value area." Peak Markers: Small diamond markers identify exactly where the local peaks and valleys were formed within your window. Breakout Signals: Triangle markers trigger the moment price closes outside the window, signaling a potential trend continuation or reversal. Unified Alerting: Integrated alert logic notifies you the second a breakout occurs, including the exact price level of the breach. How to Use the Peekaboo Window 1. Identify the "Squeeze" When the Peekaboo Window (the shaded area) begins to narrow or "flatten," it indicates the market is entering a period of consolidation. During this time, price is contained within the green (High) and red (Low) lines. 2. Trading Breakouts The primary signal occurs when a Breakout Triangle appears: Green Triangle Up: Price has closed above the window's resistance. Look for long entries or a continuation of bullish momentum. Red Triangle Down: Price has closed below the window's support. Look for short entries or a continuation of bearish momentum. 3. Support & Resistance Rejections The yellow diamond Peak Markers show you where the market has previously struggled to move further. If the price approaches these levels again without a breakout signal, they can serve as high-probability areas for mean-reversion trades (trading back toward the center of the window). 4. Customizing Your Strategy Scalping: Lower the Lookback Duration (e.g., 1.5 hours) to catch micro-breakouts. Swing/Intraday: Keep the default 4.5 hours or increase it to 8+ hours to capture major session ranges (like the London or New York opens). Settings Overview Lookback Duration: Set the "width" of your window in hours. Window Area Fill: Customize the color and transparency of the range background. Line Customization: Adjust the thickness and style (Solid/Dashed/Dotted) of the boundary lines. Breakout Markers: Toggle the visibility of the triangles and diamonds to keep your chart clean.
Pine Script® 인디케이터
inspyr24의
TrendlinesTrendline S&R This indicator is an automated technical analysis tool designed to identify the most relevant Support and Resistance (S&R) zones based on market pivots. Unlike standard pivot indicators that clutter the chart with historic lines, this script uses a "Closest-to-Price" algorithm to display only the single most relevant Support (Green) and Resistance (Red) zone currently interacting with price action. It solves common frustrations with automated trendlines—specifically the issue of lines disappearing immediately upon a breakout—by introducing a Stability Buffer. Key Features & Importance The script scans hundreds of potential trendlines but only draws the one geographically closest to the current price. Importance: This ensures you are looking at the zone that matters right now. It filters out distant or irrelevant historic lines, keeping your chart clean and focused on immediate price action. 🛡️ 5-Bar Stability Buffer (Anti-Flicker) Feature: A hardcoded 5-bar "memory" prevents the zone from disappearing the moment price touches or breaks it. Importance: This is critical for trading breakouts. It allows you to see the zone persist while price breaches it, helping you distinguish between a true breakout, a fakeout, or a retest, without the reference level vanishing from your screen. 🔍 Dynamic Pivot Filtering Feature: Uses a restricted Pivot Strength (5-15) and Minimum Confirmation (2-8 touches). Importance: By enforcing these limits, the indicator ignores insignificant market noise and micro-swings, ensuring that drawn zones represent structural market levels with genuine liquidity. 🔔 Integrated Alert System Feature: Built-in alerts for "Zone Breakout" (candle close crossing the zone) and "Zone Touch" (wick entering the zone). Importance: Allows you to set the indicator and walk away. You will be notified instantly when price interacts with these key levels, removing the need to stare at the chart. 📉 Adaptive Tolerance (Fixed ATR) Feature: Uses a fixed ATR multiplier internally to determine the width of the zone. Importance: This automatically adjusts the thickness of the support/resistance zone based on the asset's volatility. Settings Guide Bars to Apply: How far back in history the script looks for pivots (Default: 300). Pivot Source: Choose between calculating from "High/Low" (wicks) or "Close" (bodies). Pivot Strength: The number of bars required on each side to define a swing point (Range: 5–15). Min Pivot Confirmation: The minimum number of touches required to validate a trendline (Range: 2–8). How to Use Add the indicator to your chart. Adjust Pivot Strength if you want to catch smaller swings (lower number) or major structures (higher number). Set an alert in TradingView by clicking the "Clock" icon, selecting this indicator, and choosing "Zone Breakout" or "Zone Touch".
Pine Script® 인디케이터
ebecihalil의
10
Wickless Unvisited Levels (by TheActualSnail)Wickless Unvisited Levels (by TheActualSnail) Description: This indicator identifies “wickless” candles—candles without upper or lower shadows—and plots the corresponding unvisited price levels on your chart. Bullish wickless candles (where open = low) mark potential support levels, while bearish wickless candles (where open = high) mark potential resistance levels. These levels are dynamic: once price revisits them, the lines are automatically removed. How to Use: Wickless levels are often revisited and “repaired” by the market, meaning they act as temporary support or resistance. Use these levels in confluence with other technical tools, such as trendlines, moving averages, or oscillators, for higher probability setups. You can visually track unvisited areas of the chart where price may react in the future. Important: This indicator is for educational purposes only and is not financial advice. Always combine it with your own analysis and risk management. Trading solely based on wickless levels is not recommended; they should be part of a broader strategy. Inputs: Bullish Wickless Color: green Bearish Wickless Color: red Line Width: adjustable Show Price Label: toggle on/off
Pine Script® 인디케이터
TAS1TheActualSnail의
Range Indicator Golden Pocket, Liquidity, FairValueGapOverview This indicator is a comprehensive institutional market structure toolkit. It is designed to identify high-probability reversal zones by merging three powerful technical analysis concepts: Fibonacci Golden Pockets (61.8% - 65%), Liquidity Pool Analysis (Swing Failure Patterns), and Fair Value Gaps (FVG). By automating the detection of price inefficiencies and "stop runs," it helps traders navigate complex price action with objective, rule-based confirmation. What the Script Does The script continuously monitors a user-defined lookback period to define a trading range. Within this range, it dynamically plots: Golden Pockets: High-confluence retracement zones (calculated as 0.35 - 0.382 internal range levels). Liquidity Zones: Highlighted regions at the absolute high and low (Top/Bottom 5%) where institutional orders and retail stops are typically concentrated. Swing Failure Patterns (SFP): Real-time detection of liquidity grabs where price breaches a range extreme but fails to close outside, signaling a potential trap. Fair Value Gaps (FVG): Visualizes 3-candle price imbalances, showing areas of aggressive buying or selling that often act as future magnets or support/resistance. 2-Candle Confirmation: A momentum-based filter requiring a candle-close confirmation before a reversal signal is generated. For Whom is it? Smart Money Concepts (SMC) & ICT Students: Traders looking for automated liquidity sweeps and market inefficiencies. Fibonacci & Mean Reversion Traders: Those seeking a clean, professional visualization of the Golden Pocket across multiple timeframes. Systematic Day Traders: Who require strict price-action confirmation (SFP and 2-candle rules) to remove emotional bias from their entries. Functions and Input Options 1. Market Structure & Visuals Lookback Period (Default: 100): Defines the window for calculating the range extremes. Box Offset Right (Default: 50): Extends all zones into the future for better anticipatory trading. Show Price Lines & Labels: Displays the exact price for every zone boundary on the right axis for precise execution. 2. Fair Value Gap (FVG) Settings Show Fair Value Gaps: A toggle to enable/disable the plotting of price imbalances. FVG Extension (Default: 10): Determines how many bars into the future the FVG box remains visible. Custom Colors: Separate color inputs for Bullish (Gap Up) and Bearish (Gap Down) inefficiencies. 3. Professional Alert System The script includes five specific alert conditions: GP Touch: Early warning when price enters a Golden Pocket. 2-Candle Pattern: Confirmed momentum shift within a Golden Pocket. SFP Long/Short: Alerts when a Liquidity Grab (Swing Failure) is confirmed at the range high or low. Transparency and Compliance (Moderator Info) Non-Repainting Logic: All signals (SFP, 2-Candle, and FVG) are calculated and triggered based on confirmed candle closes. Drawings use barstate.islast purely for visual efficiency without altering historical data integrity. Educational Context: The script visualizes well-known market principles (Fibonacci, SFPs, and FVGs) to aid traders in their analysis; it does not provide automated financial advice or "black-box" buy/sell signals. Resource Management: Optimized for Pine Script v5, using efficient array and box handling to ensure smooth performance even on lower timeframes.
Pine Script® 인디케이터
realmacgyver77의
20
Hyperfork Matrix🔱 Hyperfork Matrix 🔱 A manual Andrews Pitchfork tool with action/reaction propagation lines and lattice matrix functionality. This indicator extends Dr. Alan Andrews' and Patrick Mikula's median line methodology by automating the projection of reaction and action lines at equidistant intervals, creating a time-price grid that highlights where pivot levels intersect the matrix. Three pitchfork variants are supported: Original, Schiff, and Modified Schiff. Each variant adjusts the anchor point position to accommodate different trend angles. ═══════════════════════════════════════════════════════════════ █ THE METHOD Andrews Pitchfork Dr. Alan Andrews developed the pitchfork as a trend channel tool. The core principle: price tends to return to the median line roughly 80% of the time. When it fails to reach the median, a reversal may be developing. A pitchfork requires three pivot points: • Point A — The anchor (starting pivot) • Point B — First swing in the opposite direction • Point C — Second swing, same direction as A The median line runs from Point A through the midpoint of B-C. Parallel lines through B and C form the channel boundaries. Action/Reaction Principle Based on Newton's third law ("action and reaction are equal and opposite"), this principle suggests that price movements elicit proportional reactions in the future. By projecting lines at equal intervals along the pitchfork's slope, we anticipate where these reactions may occur. Lattice Matrix The lattice squares pivot price levels to the matrix structure. A horizontal from your selected pivot intersects the pitchfork and propagation lines, with verticals drawn at each intersection. These verticals mark time points where price-time geometry converges—potential areas to watch for trend changes. ═══════════════════════════════════════════════════════════════ █ HOW THE INDICATOR WORKS This section explains the calculation flow from your inputs to the final drawing. Step 1 — Pivot Selection You click on the chart to select three timestamps. The indicator retrieves the high or low price at each timestamp based on your starting pivot type selection: • Starting with "Low" creates a Low-High-Low pattern • Starting with "High" creates a High-Low-High pattern Step 2 — Anchor Calculation The anchor position depends on your pitchfork variant: • Original — Anchor stays at Point A • Schiff — Anchor shifts 50% toward B in price (Y-axis only) • Modified Schiff — Anchor shifts 50% toward B in both time and price Step 3 — Median Line A line is drawn from the anchor through the midpoint of the B-C segment. This median line defines the channel's slope and center. Step 4 — Parallel Tines Parallel lines are drawn through Points B and C, maintaining the median line's slope. These form the upper and lower channel boundaries. Step 5 — Extra Parallels If configured, additional parallel lines are drawn at equal spacing beyond B and C. The spacing equals the distance from the median to each tine. Step 6 — Handle Length The "handle" is the segment from the anchor to the B-C midpoint. This length becomes the unit of measurement for propagation. Step 7 — Propagation Points Points are placed along the median line at handle-length intervals: • Forward points extend into the future • Backward points extend into the past Step 8 — Reaction Lines Through each propagation point, a line is drawn parallel to B-C (the transversal slope). These reaction lines mark time-price zones based on the original swing rhythm, where trend changes may occur. Step 9 — Action Lines Through each propagation point, a line is drawn parallel to A-B (the initial move slope). These action lines project the original momentum into future price zones. Step 10 — Lattice Grid If enabled, a horizontal line is drawn at the price level of your selected pivot. Vertical lines are then drawn at every intersection between this horizontal and the selected line type (pitchfork, reaction, or action lines). Step 11 — Alert Monitoring On each bar, the indicator checks if the price has crossed any of the drawn lines. Crossings trigger alerts based on your configuration. ═══════════════════════════════════════════════════════════════ █ PITCHFORK VARIANTS Original (Andrews) The classic pitchfork. The anchor remains at Point A. Best suited for strong trending markets where price respects steep channels. Schiff Named after Jerome Schiff, a student of Andrews. The anchor shifts halfway toward Point B in price only—same time position as A, but price is the midpoint of A and B. This produces a less steep channel, better suited for: • Shallow trends • Corrective phases • Markets where the original pitchfork angle is too aggressive Modified Schiff The anchor shifts halfway toward Point B in both time and price—positioned at the midpoint of the A-B segment. This creates an even gentler slope than the standard Schiff variant. Use when: • Trends are weak or ranging • Price doesn't respect steeper channel angles • You need a middle ground between Original and Schiff ═══════════════════════════════════════════════════════════════ █ ACTION & REACTION LINES Reaction Lines These run parallel to the B-C segment (the "transversal"). They represent the market's response rhythm—the swing from B to C sets a pattern that may repeat at predictable intervals. Action Lines These run parallel to the A-B segment (the initial impulse). They project the original momentum forward, suggesting where similar price movements may begin or end. Forward vs Backward • Forward Lines — Project into the future beyond the B-C midpoint • Backward Lines — Project into the past before Point A Most analysis focuses on forward lines, but backward lines can reveal historical confluence with past pivots. Propagation Spacing Lines are spaced at equal intervals defined by the handle length (anchor to B-C midpoint). This creates a rhythmic structure where each segment equals the original pitchfork's core measurement. Action Lines Reaction Lines Extra Parallels with/ both Action & Reactions Line extended within the grid ═══════════════════════════════════════════════════════════════ █ LATTICE MATRIX The lattice creates a grid overlay within the pitchfork structure. Horizontal Line A horizontal line is drawn at the price level of your selected pivot (A, B, or C). This squares the pivot's price level to find where it aligns with the matrix structure. These confluences may represent higher-probability reaction points in time. Vertical Lines Vertical lines are drawn at every point where the horizontal intersects your selected line source. These verticals mark time points—potential areas to watch for trend changes. • Pitchfork & Parallels — Intersections with median and all parallel tines • Action Lines — Intersections with action transversals • Reaction Lines — Intersections with reaction transversals • Action & Reaction — Both types combined Envelope Clamping Lattice lines are automatically clamped to stay within the pitchfork's channel envelope (bounded by the outermost parallels). This keeps the grid visually clean and focused on relevant areas. ═══════════════════════════════════════════════════════════════ █ ALERTS The indicator monitors price crossings and triggers alerts when the price moves through any drawn line type. Available Alert Types • Pitchfork Lines — Crossing the median or any parallel • Action Lines — Crossing any action transversal (when action lines are drawn) • Reaction Lines — Crossing any reaction transversal (when reaction lines are drawn) • Lattice Horizontal — Crossing the horizontal price level (when lattice is enabled) • Any Line Crossing — Combined alert for all of the above Setting Up Alerts 1. Right-click on the indicator or use the alert menu 2. Select "Create Alert." 3. Choose the desired condition from the dropdown 4. Configure notification preferences (pop-up, email, webhook, etc.) Alert Timing Alerts trigger once per bar close when a crossing is detected between the previous and current bar's close prices. ═══════════════════════════════════════════════════════════════ █ HOW TO USE Basic Setup 1. Add the indicator to your chart 2. When prompted, click on three pivot points in sequence: A, B, C 3. Choose starting pivot type: Auto (detects pattern), Low (LHL), or High (HLH) 4. The pitchfork draws automatically Adjusting the Pitchfork • Change the variant (Original/Schiff/Modified Schiff) if the angle doesn't suit your trend • Add extra parallel levels to see where price might react beyond the main channel • Disable or Adjust price range min/max to hide parallels outside your focus area Adding Propagation Lines • Adjust forward offset to add/remove lines beyond auto-extend (0 = to current bar) • Choose which line types to display: Reaction Only, Action Only, or Both • Customize colors to distinguish line types visually Using the Lattice • Enable "Draw Lattice" in the Lattice settings group • Select which pivot's price level to use for the horizontal • Choose the intersection source that matches your analysis style • Look for time zones where verticals cluster—these may be significant dates Log Scale Charts If your chart uses logarithmic scale, enable "Logarithmic Scale" in Pitchfork Settings. This ensures all calculations transform correctly for log price axes. ═══════════════════════════════════════════════════════════════ █ SETTINGS REFERENCE 1. Pivot Points • Starting Pivot Type — Auto (detect pattern), Low (force LHL), or High (force HLH) • Pivot A/B/C Time — Timestamps for your three pivots (click to select) • Show Pivot Labels — Display A, B, C labels at pivot locations • Pivot Colors — Customize high/low label colors • Label Size — Tiny, Small, Normal, or Large 2. Pitchfork Settings • Logarithmic Scale — Enable for log charts • Pitchfork Type — Original, Schiff, or Modified Schiff • Extra Parallel Levels — Additional parallels beyond B and C • Line styling (color, width, style) • Extend Direction — Right only or Both directions • Enable Price Range Filter — Toggle filtering of extra parallels • Price Range Min/Max — Hide extra parallels outside this range 3. Action / Reaction Lines • Draw Type — None, Reaction Only, Action Only, or Both • Forward Lines Offset — Adjust from auto-extend (0 = to current bar, positive adds more) • Backward Lines Count — Number of lines projected before Point A • Separate styling for reaction and action lines 4. Lattice • Draw Lattice — Master toggle • Select Pivot for Horizontal — A, B, or C price level • Intersection Source — Which lines to use for vertical placement • Lattice styling ═══════════════════════════════════════════════════════════════ █ LIMITATIONS • Maximum 500 lines — TradingView limits line objects; complex setups with many parallels and propagation lines may approach this limit • Manual pivot selection — Pivots must be selected manually via timestamp inputs; no auto-detection • Log scale requires toggle — You must enable "Logarithmic Scale" manually if your chart uses log axes • Minor visual drift — Action/Reaction lines may shift slightly when toggling between odd and even extra parallel counts (cosmetic only) • Backward lines visibility — When adding backward propagation lines, you may need to scroll the chart left for them to render ═══════════════════════════════════════════════════════════════ █ FURTHER READING For deeper study of pitchfork analysis and action/reaction methodology: • Patrick Mikula's "The Best Trendline Methods of Alan Andrews and Five New Trendline Techniques" No affiliation implied. Referenced for educational context only. ═══════════════════════════════════════════════════════════════ █ RELATED For a video walkthrough of the Super Pitchfork methodology that inspired this indicator: How to Build a Super Pitchfork with Reaction & Trigger Lines This tutorial covers manual pitchfork construction, reaction line projection, and timing techniques.
Pine Script® 인디케이터
BlueprintResearch의
5
SVE Pivot Points v5//@version=6 indicator(title="SVE Pivot Points", overlay=true, max_lines_count=500) // Input Parameters agg_period = input.timeframe("D", title="Aggregation period") show_labels = input.bool(true, title="Show Labels") line_width = input.int(1, title="Line Width", minval=1, maxval=4) // Detect new aggregation period bool new_agg_bar = bool(ta.change(time(agg_period))) // Calculate how many chart bars fit in one aggregation period get_bars_in_period(string tf) => tf_secs = timeframe.in_seconds(tf) chart_secs = timeframe.in_seconds(timeframe.period) // If aggregation period is smaller than or equal to chart timeframe, use 1 bar // Otherwise calculate how many chart bars fit math.max(1, int(math.ceil(tf_secs / chart_secs))) bars_in_period = get_bars_in_period(agg_period) // Fetch previous period's high, low, close ph = request.security(syminfo.tickerid, agg_period, high , barmerge.gaps_off, barmerge.lookahead_on) pl = request.security(syminfo.tickerid, agg_period, low , barmerge.gaps_off, barmerge.lookahead_on) pc = request.security(syminfo.tickerid, agg_period, close , barmerge.gaps_off, barmerge.lookahead_on) // Calculate pivot points pp = (ph + pl + pc) / 3 r1 = 2 * pp - pl r2 = pp + (ph - pl) r3 = 2 * pp + (ph - 2 * pl) s1 = 2 * pp - ph s2 = pp - (ph - pl) s3 = 2 * pp - (2 * ph - pl) // Calculate mean levels r1m = (pp + r1) / 2 r2m = (r1 + r2) / 2 r3m = (r2 + r3) / 2 s1m = (pp + s1) / 2 s2m = (s1 + s2) / 2 s3m = (s2 + s3) / 2 // Previous high and low hh = ph ll = pl // Colors color_r = color.red color_s = color.green color_pp = color.blue color_hl = color.gray // Arrays to store historical lines (for showing past periods) var line lines_r3 = array.new_line() var line lines_r3m = array.new_line() var line lines_r2 = array.new_line() var line lines_r2m = array.new_line() var line lines_r1 = array.new_line() var line lines_r1m = array.new_line() var line lines_hh = array.new_line() var line lines_pp = array.new_line() var line lines_ll = array.new_line() var line lines_s1m = array.new_line() var line lines_s1 = array.new_line() var line lines_s2m = array.new_line() var line lines_s2 = array.new_line() var line lines_s3m = array.new_line() var line lines_s3 = array.new_line() // Current period labels (only show for current period) var label lbl_r3 = na var label lbl_r3m = na var label lbl_r2 = na var label lbl_r2m = na var label lbl_r1 = na var label lbl_r1m = na var label lbl_hh = na var label lbl_pp = na var label lbl_ll = na var label lbl_s1m = na var label lbl_s1 = na var label lbl_s2m = na var label lbl_s2 = na var label lbl_s3m = na var label lbl_s3 = na // Track current period start var int current_period_start = 0 // On new aggregation period, create new lines if new_agg_bar current_period_start := bar_index // Create lines for this period - they start here and will be extended array.push(lines_r3, line.new(bar_index, r3, bar_index + bars_in_period, r3, color=color_r, width=line_width)) array.push(lines_r3m, line.new(bar_index, r3m, bar_index + bars_in_period, r3m, color=color_r, width=line_width)) array.push(lines_r2, line.new(bar_index, r2, bar_index + bars_in_period, r2, color=color_r, width=line_width)) array.push(lines_r2m, line.new(bar_index, r2m, bar_index + bars_in_period, r2m, color=color_r, width=line_width)) array.push(lines_r1, line.new(bar_index, r1, bar_index + bars_in_period, r1, color=color_r, width=line_width)) array.push(lines_r1m, line.new(bar_index, r1m, bar_index + bars_in_period, r1m, color=color_r, width=line_width)) array.push(lines_hh, line.new(bar_index, hh, bar_index + bars_in_period, hh, color=color_hl, width=line_width)) array.push(lines_pp, line.new(bar_index, pp, bar_index + bars_in_period, pp, color=color_pp, width=line_width)) array.push(lines_ll, line.new(bar_index, ll, bar_index + bars_in_period, ll, color=color_hl, width=line_width)) array.push(lines_s1m, line.new(bar_index, s1m, bar_index + bars_in_period, s1m, color=color_s, width=line_width)) array.push(lines_s1, line.new(bar_index, s1, bar_index + bars_in_period, s1, color=color_s, width=line_width)) array.push(lines_s2m, line.new(bar_index, s2m, bar_index + bars_in_period, s2m, color=color_s, width=line_width)) array.push(lines_s2, line.new(bar_index, s2, bar_index + bars_in_period, s2, color=color_s, width=line_width)) array.push(lines_s3m, line.new(bar_index, s3m, bar_index + bars_in_period, s3m, color=color_s, width=line_width)) array.push(lines_s3, line.new(bar_index, s3, bar_index + bars_in_period, s3, color=color_s, width=line_width)) // Delete old labels and create new ones if show_labels label.delete(lbl_r3) label.delete(lbl_r3m) label.delete(lbl_r2) label.delete(lbl_r2m) label.delete(lbl_r1) label.delete(lbl_r1m) label.delete(lbl_hh) label.delete(lbl_pp) label.delete(lbl_ll) label.delete(lbl_s1m) label.delete(lbl_s1) label.delete(lbl_s2m) label.delete(lbl_s2) label.delete(lbl_s3m) label.delete(lbl_s3) lbl_r3 := label.new(bar_index + bars_in_period, r3, "R3", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r3m := label.new(bar_index + bars_in_period, r3m, "R3M", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r2 := label.new(bar_index + bars_in_period, r2, "R2", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r2m := label.new(bar_index + bars_in_period, r2m, "R2M", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r1 := label.new(bar_index + bars_in_period, r1, "R1", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r1m := label.new(bar_index + bars_in_period, r1m, "R1M", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_hh := label.new(bar_index + bars_in_period, hh, "HH", style=label.style_label_left, color=color.new(color_hl, 100), textcolor=color_hl, size=size.small) lbl_pp := label.new(bar_index + bars_in_period, pp, "PP", style=label.style_label_left, color=color.new(color_pp, 100), textcolor=color_pp, size=size.small) lbl_ll := label.new(bar_index + bars_in_period, ll, "LL", style=label.style_label_left, color=color.new(color_hl, 100), textcolor=color_hl, size=size.small) lbl_s1m := label.new(bar_index + bars_in_period, s1m, "S1M", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s1 := label.new(bar_index + bars_in_period, s1, "S1", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s2m := label.new(bar_index + bars_in_period, s2m, "S2M", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s2 := label.new(bar_index + bars_in_period, s2, "S2", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s3m := label.new(bar_index + bars_in_period, s3m, "S3M", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s3 := label.new(bar_index + bars_in_period, s3, "S3", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) // On the last bar, update the current period's lines to extend properly into the future if barstate.islast and array.size(lines_pp) > 0 // Get the most recent lines line last_r3 = array.get(lines_r3, array.size(lines_r3) - 1) line last_r3m = array.get(lines_r3m, array.size(lines_r3m) - 1) line last_r2 = array.get(lines_r2, array.size(lines_r2) - 1) line last_r2m = array.get(lines_r2m, array.size(lines_r2m) - 1) line last_r1 = array.get(lines_r1, array.size(lines_r1) - 1) line last_r1m = array.get(lines_r1m, array.size(lines_r1m) - 1) line last_hh = array.get(lines_hh, array.size(lines_hh) - 1) line last_pp = array.get(lines_pp, array.size(lines_pp) - 1) line last_ll = array.get(lines_ll, array.size(lines_ll) - 1) line last_s1m = array.get(lines_s1m, array.size(lines_s1m) - 1) line last_s1 = array.get(lines_s1, array.size(lines_s1) - 1) line last_s2m = array.get(lines_s2m, array.size(lines_s2m) - 1) line last_s2 = array.get(lines_s2, array.size(lines_s2) - 1) line last_s3m = array.get(lines_s3m, array.size(lines_s3m) - 1) line last_s3 = array.get(lines_s3, array.size(lines_s3) - 1) // Calculate end point: period start + bars in period int end_bar = current_period_start + bars_in_period // Update line endpoints line.set_x2(last_r3, end_bar) line.set_x2(last_r3m, end_bar) line.set_x2(last_r2, end_bar) line.set_x2(last_r2m, end_bar) line.set_x2(last_r1, end_bar) line.set_x2(last_r1m, end_bar) line.set_x2(last_hh, end_bar) line.set_x2(last_pp, end_bar) line.set_x2(last_ll, end_bar) line.set_x2(last_s1m, end_bar) line.set_x2(last_s1, end_bar) line.set_x2(last_s2m, end_bar) line.set_x2(last_s2, end_bar) line.set_x2(last_s3m, end_bar) line.set_x2(last_s3, end_bar) // Update label positions if show_labels label.set_x(lbl_r3, end_bar) label.set_x(lbl_r3m, end_bar) label.set_x(lbl_r2, end_bar) label.set_x(lbl_r2m, end_bar) label.set_x(lbl_r1, end_bar) label.set_x(lbl_r1m, end_bar) label.set_x(lbl_hh, end_bar) label.set_x(lbl_pp, end_bar) label.set_x(lbl_ll, end_bar) label.set_x(lbl_s1m, end_bar) label.set_x(lbl_s1, end_bar) label.set_x(lbl_s2m, end_bar) label.set_x(lbl_s2, end_bar) label.set_x(lbl_s3m, end_bar) label.set_x(lbl_s3, end_bar) // Limit array sizes to prevent memory issues (keep last 100 periods) max_lines = 100 if array.size(lines_pp) > max_lines line.delete(array.shift(lines_r3)) line.delete(array.shift(lines_r3m)) line.delete(array.shift(lines_r2)) line.delete(array.shift(lines_r2m)) line.delete(array.shift(lines_r1)) line.delete(array.shift(lines_r1m)) line.delete(array.shift(lines_hh)) line.delete(array.shift(lines_pp)) line.delete(array.shift(lines_ll)) line.delete(array.shift(lines_s1m)) line.delete(array.shift(lines_s1)) line.delete(array.shift(lines_s2m)) line.delete(array.shift(lines_s2)) line.delete(array.shift(lines_s3m)) line.delete(array.shift(lines_s3))
Pine Script® 인디케이터
Louisx8a의
SVE Pivot Points (v2) //@version=6 indicator(title="SVE Pivot Points", overlay=true, max_lines_count=500) // Input Parameters agg_period = input.timeframe("D", title="Aggregation period") extend_bars = input.int(50, title="Bars to extend into future", minval=1, maxval=500) show_labels = input.bool(true, title="Show Labels") // Line width line_width = input.int(1, title="Line Width", minval=1, maxval=4) // Detect new aggregation period bool new_agg_bar = bool(ta.change(time(agg_period))) // Fetch previous period's high, low, close ph = request.security(syminfo.tickerid, agg_period, high , barmerge.gaps_off, barmerge.lookahead_on) pl = request.security(syminfo.tickerid, agg_period, low , barmerge.gaps_off, barmerge.lookahead_on) pc = request.security(syminfo.tickerid, agg_period, close , barmerge.gaps_off, barmerge.lookahead_on) // Calculate pivot points pp = (ph + pl + pc) / 3 r1 = 2 * pp - pl r2 = pp + (ph - pl) r3 = 2 * pp + (ph - 2 * pl) s1 = 2 * pp - ph s2 = pp - (ph - pl) s3 = 2 * pp - (2 * ph - pl) // Calculate mean levels r1m = (pp + r1) / 2 r2m = (r1 + r2) / 2 r3m = (r2 + r3) / 2 s1m = (pp + s1) / 2 s2m = (s1 + s2) / 2 s3m = (s2 + s3) / 2 // Previous high and low hh = ph ll = pl // Colors color_r = color.red color_s = color.green color_pp = color.blue color_hl = color.gray // Persistent line variables var line line_r3 = na var line line_r3m = na var line line_r2 = na var line line_r2m = na var line line_r1 = na var line line_r1m = na var line line_hh = na var line line_pp = na var line line_ll = na var line line_s1m = na var line line_s1 = na var line line_s2m = na var line line_s2 = na var line line_s3m = na var line line_s3 = na // Persistent label variables var label lbl_r3 = na var label lbl_r3m = na var label lbl_r2 = na var label lbl_r2m = na var label lbl_r1 = na var label lbl_r1m = na var label lbl_hh = na var label lbl_pp = na var label lbl_ll = na var label lbl_s1m = na var label lbl_s1 = na var label lbl_s2m = na var label lbl_s2 = na var label lbl_s3m = na var label lbl_s3 = na // Function to create or update line create_line(line ln, float price, color col) => line.new(bar_index, price, bar_index + extend_bars, price, color=col, width=line_width) // Function to create label create_label(float price, string txt, color col) => label.new(bar_index + extend_bars, price, txt, style=label.style_label_left, color=color.new(col, 90), textcolor=col, size=size.small) // On new aggregation period, delete old lines and create new ones if new_agg_bar // Delete old lines line.delete(line_r3) line.delete(line_r3m) line.delete(line_r2) line.delete(line_r2m) line.delete(line_r1) line.delete(line_r1m) line.delete(line_hh) line.delete(line_pp) line.delete(line_ll) line.delete(line_s1m) line.delete(line_s1) line.delete(line_s2m) line.delete(line_s2) line.delete(line_s3m) line.delete(line_s3) // Delete old labels if show_labels label.delete(lbl_r3) label.delete(lbl_r3m) label.delete(lbl_r2) label.delete(lbl_r2m) label.delete(lbl_r1) label.delete(lbl_r1m) label.delete(lbl_hh) l
Pine Script® 인디케이터
Louisx8a의
Support & Resistance with MA Ribbons LITE Support & Resistance with MA Ribbon LITE Overview Support & Resistance with MA Ribbon LITE is a technical analysis indicator for TradingView that combines a flexible Moving Average (MA) Ribbon with a dynamic Support & Resistance (S/R) system. The indicator is designed as a visual decision-support tool, allowing traders to evaluate trend structure, momentum context, and key price reaction zones within a single, uncluttered chart overlay. This script is published as open source under the Mozilla Public License 2.0 , encouraging transparency, learning, and community-driven development. Core Components 1. Moving Average Ribbon System The MA Ribbon consists of two configurable moving averages (Fast and Slow) with multiple calculation and smoothing options, including: EMA, SMA, WMA, VWMA DEMA, TEMA, Zero-Lag EMA Hull MA, Linear Regression MA Super Smoother, Smoothed MA, Laguerre MA Key features include: Trend-aware ribbon fill (bullish / bearish) Optional candle coloring aligned with ribbon state Minute-based anchor timeframe logic for consistent trend structure Optional MA cross, swing, and continuation markers Alert support for MA-related events The MA Ribbon is intended to provide trend context , not standalone trade signals. 2. Support & Resistance Engine The Support & Resistance system is based on pivot structure analysis and dynamically adapts to new price data. Features include: Main and strong support/resistance levels Up to 12 active levels displayed on the chart Preset sensitivities (Scalp, Intraday, Swing) and custom configuration Optional multi-timeframe (MTF) level detection Adaptive labels with automatic contrast handling Optional strength filtering based on historical interactions Optional heat map visualization reflecting level interaction frequency All levels are plotted directly on the price chart for immediate contextual reference. Alert System The script includes a configurable alert framework covering: Main and strong level touches Breakouts and breakdowns Retests of broken levels Optional rejection detection (wick beyond a level with close back inside) Cooldown logic to limit repeated alerts in consolidation phases Alerts are informational only and should always be confirmed visually. Customization & Performance Unified color presets (Classic, Aqua, Cosmic, Ember, Neon, Custom) Independent opacity control for MA Ribbon and candles Modular on/off controls for MA Ribbon and S/R components Optimized plotting to remain within TradingView limits Designed for stable performance across lower and higher timeframes Intended Use This indicator is designed to assist with chart interpretation and market structure analysis. It may help users: Identify prevailing trend conditions Observe price behavior around structurally relevant levels Combine trend context with horizontal market structure Reduce chart clutter by consolidating multiple concepts into one script This indicator is not a trading strategy, does not provide financial advice, and should be used alongside independent analysis and appropriate risk management. How to Use 1. Chart Setup Add the indicator to any chart and timeframe. Both the MA Ribbon and Support & Resistance systems are enabled by default and can be managed independently via the Master Controls section. General guidance: Higher timeframes for structural context Lower timeframes for execution and refinement Applicable across different markets and instruments 2. Using the MA Ribbon The MA Ribbon visualizes trend direction and momentum context. General interpretation: Price above both MAs → bullish bias Price below both MAs → bearish bias Ribbon color reflects trend alignment Ribbon compression may indicate consolidation or transition Optional features include candle coloring, MA cross markers, and filtered continuation arrows. Best practice: Use the MA Ribbon to identify the market regime before reacting to support or resistance levels. MA Ribbon – Minute-Based Timeframe Logic Anchor Timeframe (Minutes) Anchors MA calculations to a fixed timeframe expressed in minutes. Examples: 60 = 1 hour 240 = 4 hours 0 = use current chart timeframe How It Works The anchor automatically scales MA lengths so that the same trend structure is preserved across different chart timeframes. Example (Anchor = 60): 5-minute chart → follows 1-hour structure 15-minute chart → follows the same 1-hour structure 1-hour chart → standard calculation Show Ribbon Only If Chart TF > Anchor Optionally hides the MA Ribbon on chart timeframes lower than the anchor to reduce visual noise. 3. Using Support & Resistance Levels Support and resistance levels are derived from pivot structures and update dynamically. Level types: Main Support / Resistance (most recent and relevant) Strong Support / Resistance (confirmed pivots) Additional historical levels (up to 12 total) Usage guidelines: Focus on price behavior around levels rather than exact prices Combine level reactions with MA Ribbon trend context Use strength filtering to reduce weaker levels Heat map mode highlights frequently interacted zones 4. Combining Trend and Structure The indicator is most effective when both systems are used together: In uptrends, focus on reactions near support In downtrends, focus on reactions near resistance Breakouts are more relevant when aligned with trend context Retests gain importance when structure and trend agree Customization Tips Use preset sensitivities (Scalp / Intraday / Swing) for quick setup Enable MTF S/R to reference higher-timeframe structure Adjust label size, offset, and precision for readability Disable unused components to improve performance on lower-end systems This combined view helps improve contextual clarity and reduce noise. 5. Alerts Usage Alerts are optional and fully configurable. Cooldown settings can be used to limit repeated notifications during ranging conditions. All alerts are informational and should be visually validated. Open Source & Credits This script is released as open source under the Mozilla Public License 2.0. Parts of the MA Ribbon logic and conceptual inspiration are derived from publicly shared work by JustUncleL on TradingView. Respect and thanks are extended for these contributions. You are free to: Study the code Modify it for personal use Share improvements under the same license terms Disclaimer This indicator is provided for educational and informational purposes only. No guarantees are made regarding accuracy, performance, or outcomes. Use at your own discretion.
Pine Script® 인디케이터
alpprofitmax의
5