Kaspareit VCP + TTM Squeeze ProKaspareit VCP + TTM Squeeze Pro
A combined tool for identifying volatility contractions and breakout setups. The VCP module (Volatility Contraction Pattern) detects contraction phases under trend filters, while the TTM Squeeze module evaluates compression via Bollinger Bands vs. Keltner Channels and adds a momentum oscillator. The result: clearly marked setup phases, pivot zones, and breakout signals.
What the indicator does
Detects potential VCP setups through falling ATR/True Range relative to the recent minimum, combined with a 3-step EMA trend filter.
Fixes a pivot zone above price to act as breakout reference.
Classifies TTM Squeeze compression levels in 4 colors and checks momentum.
Plots VCP potential (yellow dots), active breakouts (green dots), EMAs, pivot level, momentum histogram, and squeeze status.
Logic explained (simplified)
EMA trend filter (3-step): Close must be above EMA 50/100/200, and EMAs must be properly aligned. Only then VCP signals are valid.
VCP contraction: Current ATR compared to the lowest ATR over VCP period with tolerance factor. If volatility is sufficiently low, contraction is valid.
VCP timer: After a valid VCP, a window ( Max days after VCP ) remains active for breakout evaluation.
Pivot zone: Highest high of last Pivot lookback bars is fixed as Pivot level (red line).
Squeeze classification: Bollinger Band width vs. Keltner Channels gives 4 states: Green = no squeeze, Black = low, Red = mid, Orange = high.
Momentum: Regression-based oscillator evaluates directional impulse relative to smoothed price range.
Breakout: Valid if within active VCP window, close > pivot, EMA filter true, squeeze green, volume > previous bar, momentum > 0. Then Breakout active is marked.
Exit logic: Breakout state ends if volume < short-term average and True Range < short-term average.
Visualization & legend
EMA Short/Mid/Long: 3 lines for trend filter.
Pivot level: Red line, breakout threshold.
VCP potential: Yellow dots below candles when VCP criteria + (Momentum < 0 or Squeeze ≠ green).
Breakout active: Green dots below candles while breakout conditions hold.
Momentum histogram: Columns above chart edge if momentum > 0.
Squeeze status: Colored dots at 0-line: Orange = high, Red = mid, Black = low, Green = no squeeze.
Inputs (settings) and meaning
VCP inputs
VCP period (default 30): Window to detect ATR minimum. Larger = stricter, fewer signals.
Pivot resistance (lookback) (default 10): Bars used to fix pivot high. Lower = earlier, more sensitive levels.
Volatility tolerance (default 1.1): Factor above ATR minimum still considered “contraction.” Lower = stricter.
Volume comparison (Exit) (default 5): Length of average volume for breakout exit.
True Range comparison (Exit) (default 5): Length of TR average for breakout exit.
Max days after VCP (default 50): Time window for breakout after VCP.
EMA short/mid/long (default 50/100/200): Trend filter. Longer = smoother, fewer signals.
TTM Squeeze inputs
TTM Squeeze length (default 20): Base length for BB/KC.
Bollinger Band STD Multiplier (default 2.0): Width of BB. Higher = wider, fewer squeezes.
Keltner Channel #1/#2/#3 (default 1.5/2.0/3.0): Channel widths for low/mid/high squeeze classification.
Practical usage
Setup phase: Watch for aligned EMAs with price above all EMAs. Yellow dots = VCP potential, especially valuable if squeeze is red/orange.
Pivot observation: Red pivot level = breakout threshold.
Breakout trigger: Close above pivot, squeeze green, positive momentum, volume > previous bar → Breakout active .
Monitoring: Breakout state ends if volume and TR fall below short-term averages. This is a signal of weakening momentum , not an order exit rule.
Timeframes & markets: Works on all TFs with reliable data. Daily and H4 work well for trending stocks. For FX/CFDs, volume is tick volume.
Important notes & limitations
This is an indicator , not a strategy. It does not place orders or backtest results.
Pivot level and VCP state recalculate per bar. Pivot may move if new highs form.
Momentum histogram is scaled relative to recent range, not comparable across markets.
Squeeze colors are state labels, not trade signals. Always combine with trend filter.
No alerts included. You may add alertcondition if needed. Logic provides clear states (VCP potential, breakout active, squeeze status).
Tuning tips
See more contractions: Lower TTM length (e.g. 14–18), increase BB Mult slightly, or reduce KC Mult .
Stricter filter: Increase VCP period , lower Volatility tolerance , use longer EMAs.
Earlier breakouts: Reduce Pivot lookback , but risk more false signals.
Credits & license
VCP components: © Kaspareit-Trading.
TTM Squeeze components based on “Beardy Squeeze Pro” © Beardy_Fred.
TTM Squeeze code licensed under Mozilla Public License 2.0. License: mozilla.org
Disclaimer
This indicator is for educational and informational purposes only. It is not investment advice. Trading involves significant risk. Always test on demo accounts and use proper risk management.
Author’s notes
For questions or feedback, please send a private TradingView message with your username.
Cerca negli script per "摩根纳斯达克100基金风险大吗"
INFLECTION NEXUS - SPAINFLECTION NEXUS - SPA (Shadow Portfolio Adaptive)
Foreword: The Living Algorithm
For decades, technical analysis has been a conversation between a trader and a static chart. We apply our indicators with their fixed-length inputs, and we hope that our rigid tools can somehow capture the essence of a market that is fluid, chaotic, and perpetually evolving. When our tools fail, we are told to "adapt." But what if the tools themselves could learn that lesson? What if our indicators could adapt not just for us, but with us?
This script, INFLECTION NEXUS - SPA, is the realization of that vision. It is an advanced analytical framework built around a revolutionary core: the Shadow Portfolio Adaptive (SPA) Engine . The buy and sell signals you see on the chart are an evolution of the logic from my previous work, "Turning Point." However, this is not a simple combination of two scripts. The SPA engine so fundamentally transforms the nature of the analysis that it creates an entirely new class of indicator. This publication is a showcase of that groundbreaking, self-learning engine.
This system is undeniably complex. When you first load it, the sheer volume of information may feel overwhelming. That is a testament to the depth of its analysis. This guide is designed to be your comprehensive manual, to break down every single component, every color, every number, into simple, understandable concepts. By the end of this document, you will not only master its functions but will also possess a deeper understanding of the market dynamics it is designed to reveal.
Chapter 1: The Paradigm Shift - Why the SPA Engine is a Leap Forward
To grasp the innovation here, we must first deconstruct the severe limitations of traditional "adaptive" indicators.
Part A: The Traditional Model - Driving by the Rear-View Mirror
Conventional "adaptive" systems are fundamentally reactive. They operate on a slow, inefficient loop: they wait for their own specific, biased signal to fire, wait for that trade to close, and only after a long and statistically significant "warm-up" period of 50-100 trades do they finally make a small, retrospective adjustment. They are always adapting to a market that no longer exists.
Part B: The SPA Model - The Proactive Co-Pilot
The Shadow Portfolio Adaptive (SPA) engine is a complete re-imagining of this process. It is not reactive; it is proactive, data-saturated, and instantly aware.
Continuous, Unbiased Learning: The SPA engine does not wait for a signal to learn. Its Shadow Portfolio is constantly running 5-bar long and short trades in the background. It learns from every single 5-bar slice of market action , giving it a continuous, unbiased stream of performance data. It is the difference between reading a textbook chapter and having a live sparring partner in the ring 24/7.
Instantaneous Market Awareness - The End of the "Warm-Up": This is the critical innovation. The SPA engine does not require a 100-trade warm-up period. The learning does not start after 50 trades; it begins on the 6th bar of the chart when the first shadow trade closes. From that moment on, the system is market-aware, analyzing data, and capable of making intelligent adjustments. The SPA engine is not adapting to old wins and losses. It is adapting, in near real-time, to the market's ever-shifting character, volatility, and personality.
Chapter 2: The Anatomy of the SPA Engine - A Granular Deep Dive
The engine is composed of three primary systems that work in a sophisticated, interconnected symphony.
Section 1: The Shadow Portfolio (The Information Harvester)
What it is, Simply: Think of this as the script's eyes and ears. It's a team of 10 virtual traders (5 long, 5 short) who are constantly taking small, quick trades to feel out the market.
How it Works, Simply: On every new bar, a new "long" trader and a new "short" trader enter the market. Exactly 5 bars later, they close their positions. This cycle is perpetual and relentless.
The Critical 'Why': Because these virtual traders enter and exit based on a fixed time (5 bars), not on a "good" or "bad" signal, their results are completely unbiased . They are simply measuring: "What happened to price over the last 5 bars?" This provides the raw, untainted truth about the market's behavior that the rest of the system needs to learn effectively.
The Golden Metric (ATR Normalization): The engine doesn't just look at dollar P&L. It's smarter than that. It asks a more intelligent question: "How much did this trade make relative to the current volatility?"
Analogy: Imagine a flea and an elephant. If they both jump 1 inch, who is more impressive? The flea. The SPA engine understands this. A $10 profit when the market is dead quiet is far more significant than a $10 profit during a wild, volatile swing.
The Formula: realized_atr = (close - trade.entry) / trade.atr_entry. It takes the raw profit and divides it by the Average True Range (a measure of volatility) at the moment of entry. This gives a pure, "apples-to-apples" score for every single trade, which is the foundational data point for all learning.
Section 2: The Cognitive Map (The Long-Term Brain)
What it is, Simply: This is the engine's deep memory, its library of experiences. Imagine a giant, 64-square chessboard (8x8 grid). Each square on the board represents a very specific type of market environment.
The Two Dimensions of Thought (The 'How'): How does it know which square we are on? It looks at two things:
The Market's Personality (X-Axis): Is the market behaving like a disciplined soldier, marching in a clear trend? Or is it like a chaotic, unpredictable child, running all over the place? The engine calculates a "Regime" score to figure this out.
The Market's Energy Level (Y-Axis): Is the market sleepy and quiet, or is it wide-awake and hyperactive? The engine measures "Normalized Volatility" to determine this.
The Power of Generalization (The 'Why'): When a Shadow Portfolio trade closes, its result is recorded in the corresponding square on the chessboard. But here's the clever part: it also shares a little bit of that lesson with the squares immediately next to it (using a Gaussian Kernel).
Analogy: If you touch a hot stove and learn "don't touch," your brain is smart enough to know you probably shouldn't touch the hot oven door next to it either, even if you haven't touched it directly. The Cognitive Map does the same thing, allowing it to make intelligent inferences even in market conditions it has seen less frequently. Each square remembers what indicator settings worked best in that specific environment.
Section 3: The Adaptive Engine (The Central Nervous System)
What it is, Simply: This is the conductor of the orchestra. It takes information from all other parts of the system and decides exactly what to do.
The Symphony of Inputs: It listens to three distinct sources of information before making a decision:
The Short-Term Memory (Rolling Stats): It looks at the performance of the last rollN shadow trades. This is its immediate, recent experience.
The Long-Term Wisdom (Cognitive Map): It consults the grand library of the Cognitive Map to see what has worked best in the current market type over the long haul.
The Gut Instinct (Bin Learning): It keeps a small "mini-batch" of the most recent trades. If this batch shows a very strong, sudden pattern, it can trigger a rapid, reflexive adjustment, like pulling your hand away from a flame.
The Fusion Process: It then blends these three opinions together in a sophisticated way. It gives more weight to the opinions it's more confident in (e.g., a Cognitive Map square with hundreds of trades of experience) and uses your Adaptation Intensity (dialK) input to decide how much to listen to its "gut instinct." The final decision is then smoothed to ensure the indicator's parameters change in a stable, intelligent way.
Chapter 3: The Control Panel - A Novice's Guide to Every Input
This is the most important chapter. Let's break down what these confusing settings actually do in the simplest terms possible.
--- SECTION 1: THE DRIVER'S SEAT (SIGNAL ENGINE & BASE SETTINGS) ---
🧾 Signal Engine (Turning Point):
What it is: These are the rules for the final BUY and SELL signs.
Think of it like this: The SPA engine is the smart robot that tunes your race car. These settings are you, the driver, telling the robot what kind of race you're in.
Enable Reversal Mode: You tell the robot, "I want to race on a curvy track with lots of turns." The robot will tune the car to be agile for catching tops and bottoms.
Enable Breakout Mode: You tell the robot, "I want to race on a long, straight track." The robot will tune the car for pure speed to follow the trend.
Require New Extreme: This is a quality filter. It tells the driver, "Don't look for a turn unless we've just hit a new top speed on the straightaway." It makes sure the reversal is from a real extreme.
Min Bars Between Signals: This is the "pit stop" rule. You're telling the robot, "After you show me a sign, wait at least 10 bars before showing another one, so I don't get confused."
⚡ ATR Bands (Base Inputs):
What they are: These are the starting settings for your car before the robot starts tuning it. These are your factory defaults.
Sensitivity: This is the "Bump Detector." A low number means the car feels every tiny pebble on the road. A high number means it only notices the big speed bumps. You want to set it so it notices the important bumps (real market structure) but ignores the pebbles (noise).
ATR Period & Multiplier: These set the starting size of the "safety lane" (the green and blue bands) around your car. The robot's main job is to constantly adjust the size of this safety lane to perfectly fit the current road conditions.
📊 & 📈 Filter Settings (RSI & Volume):
What they are: These are your co-pilot's confirmation checks.
Enable RSI Filter: Your co-pilot will check the "Engine Temperature" (RSI). He won't let you hit the gas (BUY) if the engine is already overheating (overbought).
RSI Length & Lookbacks: These tune how your co-pilot's temperature gauge works. The defaults are standard.
Require Volume Spike: Your co-pilot will check the "Crowd Noise" (Volume). He won't give you a signal unless he hears the crowd roar, confirming that a lot of people are interested in this move.
🎯 Signal Quality Control:
Enable Major Levels Only: This tells your co-pilot to be extra picky. He will only confirm signals that happen after a huge, powerful move, ignoring all the small stuff.
--- SECTION 2: THE ROBOT'S BRAIN (ENGINE & LEARNING CONTROLS) ---
🎛️ Master Control:
Adaptation Intensity (dialK): THIS IS THE ROBOT'S PERSONALITY DIAL.
Turn it DOWN (1-5): The robot becomes a "Wise Old Professor." It thinks very slowly and carefully, gathers lots of data, and only makes a change when it is 100% sure. Its advice is very reliable but might come a little late.
Turn it UP (15-20): The robot becomes a "Hyper-Reactive Teenager." It has a short attention span, reacts instantly to everything it sees, and changes its mind constantly. It's super-fast to new information but might get faked out a lot.
The Default (10): A "Skilled Professional." The perfect balance of thoughtful and responsive. Start here.
🧠 Adaptive Engine:
Enable Adaptive System: This is the main power button for your robot. Turn it off, and you're driving a normal, non-smart car. Turn it on, and the robot takes over the tuning.
Use Shadow Cycle: This turns on the robot's "practice laps." The robot can't learn without practicing. This must be on for the robot to work.
Lock ATR Bands: This is a visual choice. "Locked" means the safety lanes on your screen stay where your factory defaults put them (the robot still makes changes to the signals in the background). "Unlocked" means you see the safety lanes moving and changing shape in real-time as the robot tunes them.
🎯 Learning (Global + Risk):
What they are: These are the deep-level settings for how your robot's brain processes information.
Rolling Window Size: This is the robot's "Short-Term Memory." How many of the last few practice laps should it remember? A small number means it only cares about what just happened. A big number means it remembers the last hour of practice.
Learn Rate & Smooth Alpha: This is "How big of a change should the robot make?" and "How smoothly should it make the change?" Think of it as turning the steering wheel. A high learn rate is like yanking the wheel; a low one is like a gentle turn. The smoothing makes sure the turn is graceful.
WinRate Thresholds & PnL Cap: These are rules for the robot's learning. They tell it what a "good" or "bad" outcome looks like and tell it to ignore crazy, once-in-a-lifetime events so its memory doesn't get corrupted.
--- SECTION 3: THE GARAGE (RISK, MEMORY & VISUALS) ---
⚠️ Risk Management:
What they are: These are safety rules you can give to your co-pilot for your own awareness. They appear on the dashboard.
The settings: You can set a max number of trades, a max loss for the day, and a "time out" period after a few losses.
Apply Risk to Shadow: This is an important switch. If you turn this ON, your safety rules also apply to the robot's practice laps. If you hit your max loss, the robot stops practicing and learning. It's recommended to leave this OFF so the robot can learn 24/7, even if you have stopped trading.
🗺️ Cognitive Map, STM & Checkpoints:
What it is: The robot's "Long-Term Memory" or its entire library of racing experience.
Use Cognitive Map & STM: These switches turn on the long-term and short-term memory banks. You want these on for the smartest robot.
Map Settings (Grid, Sigma, Half-Life): These are very advanced settings for neuroscientists. They control how the robot's brain is structured and how it forgets old information. The defaults are expertly tuned.
The Checkpoint System: This is the "Save Your Game" button for the robot.
To Save: Check Emit Checkpoint Now. Go to your alert log, and you will see a very long password. Copy this password.
To Load: Paste that password into the Memory Checkpoint box. Then, check Apply Checkpoint On Next Bar. The robot will instantly download all of its saved memories and experience.
🎨 Visuals & 🧩 Display Params:
What they are: These are all about how your screen looks.
You can control everything: The size and shape of the little diamonds (Entry Orbs), whether you see the purple Adapt Pulse, and where the Dashboards appear on your screen. You can change the Theme to Dark, Light, or Neon. These settings don't change how the robot thinks, only how it presents its information to you.
Chapter 4: The Command Center - Decoding the Dashboard
PANEL A (INFLECTION NEXUS): Your high-level mission control, showing the engine's classification of the current Market Context and the performance summary of the Shadow Portfolio.
PANEL B (SHADOW PORTFOLIO ADAPTIVE): Your deep diagnostic screen.
Performance Metrics: View advanced risk-adjusted stats like the Sharpe Ratio to understand the quality of the market movements the engine is learning from.
Adaptive Parameters (Live vs Base): THIS IS THE MOST CRITICAL SECTION. It shows the engine's Live parameters right next to your (Base) inputs. When the Live values deviate, the engine is communicating its learned wisdom to you. For example, a Live ATR Multiplier of 2.5 versus your Base of 1.4 is the engine telling you: "Caution. The market is currently experiencing high fake-outs and requires giving positions more room to breathe." This section is a direct translation of the engine's learning into actionable insight.
Chapter 5: Reading the Canvas - On-Chart Visuals
The Bands (Green/Blue Lines): These are not static Supertrend lines. They are the physical manifestation of the engine's current thinking. As the engine learns and adapts its ATR Period and Multiplier, you will see these bands widen, tighten, and adjust their distance from price. They are alive.
The Labels (BUY/SELL): These are the final output of the "Turning Point" logic, now supercharged and informed by the fully adaptive SPA engine.
The Purple Pulse (Dot and Background Glow): This is your visual cue that the engine is "thinking." Every time you see this pulse, it means the SPA has just completed a learning cycle and updated its parameters. It is actively recalibrating itself to the market.
Chapter 6: A Manifesto on Innovation and Community
I want to conclude with a personal note on why I dedicate countless hours to building systems like this and sharing them openly.
My purpose is to drive innovation, period. I am not in this space to follow the crowd or to re-package old ideas. The world does not need a 100th version of a slightly modified MACD. Real progress, real breakthroughs, come from venturing into the wilderness, from asking "what if?" and from pursuing concepts that lie at the very edge of possibility.
I am not afraid of being wrong. I am not afraid of being bested by my peers. In fact, I welcome it. If another developer takes an idea from this engine, improves it, and builds something even more magnificent, that is a profound win for our entire community. The only failure I recognize is the failure to try. The only trap I fear is the creative complacency of producing sterile, recycled work just to appease the status quo.
I love this community, and I believe with every fiber of my being that we have barely scratched the surface of what can be discovered and created. This script is my contribution to that shared journey. It is a tool, an idea, and a challenge to all of us: let's keep pushing.
DISCLAIMER: This script is an advanced analytical tool provided for educational and research purposes ONLY. It does not constitute financial advice. All trading involves substantial risk of loss. Past performance is not indicative of future results. Please use this tool responsibly and as part of a comprehensive trading plan.
As the great computer scientist Herbert A. Simon, a pioneer of artificial intelligence, famously said:
"Learning is any process by which a system improves performance from experience."
*Tooltips were updated with a comprehensive guide
May this engine enhance your experience.
— Dskyz, for DAFE Trading Systems
Momentum Shift Oscillator (MSO) [SharpStrat]Momentum Shift Oscillator (MSO)
The Momentum Shift Oscillator (MSO) is a custom-built oscillator that combines the best parts of RSI, ROC, and MACD into one clean, powerful indicator. Its goal is to identify when momentum shifts are happening in the market, filtering out noise that a single momentum tool might miss.
Why MSO?
Most traders rely on just one momentum indicator like RSI, MACD, or ROC. Each has strengths, but also weaknesses:
RSI → great for overbought/oversold, but often lags in strong trends.
ROC (Rate of Change) → captures price velocity, but can be too noisy.
MACD Histogram → shows trend strength shifts, but reacts slowly at times.
By blending all three (with adjustable weights), MSO gives a balanced view of momentum. It captures trend strength, velocity, and exhaustion in one oscillator.
How MSO Works
Inputs:
RSI, ROC, and MACD Histogram are calculated with user-defined lengths.
Each is normalized (so they share the same scale of -100 to +100).
You can set weights for RSI, ROC, and MACD to emphasize different components.
The components are blended into a single oscillator value.
Smoothing (SMA, EMA, or WMA) is applied.
MSO plots as a smooth line, color-coded by slope (green rising, red falling).
Overbought and oversold levels are plotted (default: +60 / -60).
A zero line helps identify bullish vs bearish momentum shifts.
How to trade with MSO
Zero line crossovers → crossing above zero suggests bullish momentum; crossing below zero suggests bearish momentum.
Overbought and oversold zones → values above +60 may indicate exhaustion in bullish moves; values below -60 may signal exhaustion in bearish moves.
Slope of the line → a rising line shows strengthening momentum, while a falling line signals fading momentum.
Divergences → if price makes new highs or lows but MSO does not, it can point to a possible reversal.
Why MSO is Unique
Combines trend + momentum + velocity into one view.
Filters noise better than standalone RSI/MACD.
Adapts to both trend-following and mean-reversion styles.
Can be used across any timeframe for confirmation.
Japan Yen Carry Trade to Risk Ratio Sharpe Ratio By UncleBFMStep-by-Step Calculation in the ScriptFetch Rates:Pulls rates dynamically using request.security() from user-specified symbols (e.g., TVC:JP10Y for yen, TVC:US10Y for target). If unavailable (NA), uses fallback inputs (e.g., 0.25% for yen, 4.50% for target).
Converts rates to decimals: (target_rate - yen_rate) / 100.
Calculate Carry:Carry = (Target Rate - Yen Rate) / 100
Example: If US 10Y yield is 4.50% and Japan 10Y is 0.25%, carry = (4.50 - 0.25) / 100 = 0.0425 (4.25% annual yield).
Calculate Daily Log Returns:Log Returns = ln(Close / Close ), where Close is the current price of the pair (e.g., USDJPY) and Close is the previous day's price.
This measures daily percentage changes in a way suitable for volatility calculations.
Calculate Annualized Volatility:Volatility = Standard Deviation of Log Returns over a lookback period (default 63 days, ~3 months) × √252.
Example: If the standard deviation of USDJPY log returns is 0.005 (0.5% daily), annualized volatility = 0.005 × √252 ≈ 0.0794 (7.94%).
Compute the Ratio:Ratio = Carry / Volatility
Example: Using above, 0.0425 / 0.0794 ≈ 0.535.
If volatility is zero, the ratio is set to NA to avoid division errors.
Plot:Plots the ratio as a line, with optional thresholds (e.g., 0.2 for "high attractiveness") to guide interpretation.
NotesDynamic Rates: Using bond yields (e.g., TVC:JP10Y) or policy rates (e.g., ECONOMICS:JPINTR) makes the indicator responsive to historical and current rate changes, unlike static inputs.
Context: BIS reports use similar ratios to assess carry trade viability. For USDJPY in 2025, with Fed rates around 4.5% and BoJ at 0.25–0.5%, the carry is positive but sensitive to volatility spikes (e.g., during 2024 unwind events).
Usage: Apply to a yen pair chart (e.g., USDJPY, AUDJPY). Adjust symbols for the target currency (e.g., TVC:AU10Y for AUD). The ratio helps compare carry trade profitability across pairs or over time.
ORB + Session VWAP Pro (London & NY) — fixedORB + Session VWAP Pro (London & NY) — Listing copy (EN)
What it is
A clean, non-repainting intraday tool that fuses the classic Opening Range Breakout (ORB) with a session-anchored VWAP filter for London and New York. It highlights only the higher-quality breakouts (above/below session VWAP), adds an optional retest confirmation, and scores each signal with an intuitive Confidence metric (0–100).
Why it works
• ORB provides the day’s first actionable structure (range high/low).
• Session VWAP filters “cheap” breaks and favors flows aligned with session value.
• Optional retest reduces first-tick whipsaws.
• Confidence blends breakout depth (vs ATR), VWAP slope and band distance.
Key visuals
• LDN/NY OR High/Low (line break style) + optional OR boxes.
• Active Session VWAP (resets per signal window; falls back to daily VWAP outside).
• Optional VWAP bands (stdev or %).
• Session shading (London/NY windows).
• Signal markers (LDN BUY/SELL, NY BUY/SELL) fired with cooldown.
Signals
• London Long / Short: Break of LDN OR High/Low ± ATR buffer, aligned with VWAP side.
• NY Long / Short: Same logic during NY window.
• Retest (optional): Requires a tag back to the OR level ± tolerance before confirmation.
• Confidence: 0–100; gate via Min Confidence (default 55).
Inputs that matter
• Open Range Length (min): Default 15.
• London/NY times & timezones.
• ATR buffer & retest tolerance.
• Bands mode: Stdev (with lookback) or % (e.g., 1%).
• Signal cooldown: Avoids clutter on fast moves.
Non-repaint policy
• OR lines build within fixed time windows using the current bar’s timestamp.
• VWAP is cumulative within the session window; no lookahead.
• All ta.crossover/ta.crossunder are precomputed every bar (no conditional execution).
• Signals are based on live bar values, not future bars.
⸻
Quick start (examples)
1) EURUSD, London momentum
• Chart: 5m or 15m.
• OR: 15 min starting 08:00 Europe/London.
• Signals: Use defaults; keep ATR buffer = 0.2 and Retest = ON, Min Confidence ≥ 55.
• Play:
• BUY when price breaks LDN OR High + buffer and stays above VWAP; retest confirms.
• Trail behind VWAP or band #1; partials into band #2.
2) NAS100, New York breakout & run
• Chart: 5m.
• NY window: 09:30 America/New_York, OR = 15 min.
• Retest OFF on high momentum days; Min Confidence ≥ 60.
• Use band mode Stdev, bandLen=50, show ±1/±2.
• Momentum continuation: add on pullbacks that hold above VWAP after the breakout.
3) XAUUSD, London fake & VWAP fade
• Chart: 5m.
• Keep Retest ON; accept only shorts that break OR Low but retest fails back under VWAP.
• Confidence gate ≥ 50 to allow more mean-reversion setups.
⸻
Pro tips
• Adjust ATR buffer to the instrument: FX 0.15–0.25, indices 0.20–0.35, metals 0.20–0.30.
• Retest ON for choppy conditions; OFF for news momentum.
• Use VWAP bands: take partials at ±1; stretch targets at ±2/±3.
• Session timezones are explicit (London/New York). Ensure they match your instrument’s behavior.
• Pair with a higher-TF bias (e.g., 1H/4H trend) for directional filtering.
⸻
Alerts (ready to use)
• ORB+SVWAP — LDN Long, LDN Short, NY Long, NY Short
(Respect your cooldown; alerts fire only after confirmation and confidence gate.)
⸻
Known limits & notes
• Designed for intraday. On 1D+ charts, session windows compress.
• If your broker session differs from London/NY clocks on a holiday, adjust input times.
• Session-anchored VWAP uses the script’s signal window, not exchange sessions, by design.
DynamoSent DynamoSent Pro+ — Professional Listing (Preview)
— Adaptive Macro Sentiment (v6)
— Export, Adaptive Lookback, Confidence, Boxes, Heatmap + Dynamic OB/OS
Preview / Experimental build. I’m actively refining this tool—your feedback is gold.
If you spot edge cases, want new presets, or have market-specific ideas, please comment or DM me on TradingView.
⸻
What it is
DynamoSent Pro+ is an adaptive, non-repainting macro sentiment engine that compresses VIX, DXY and a price-based activity proxy (e.g., SPX/sector ETF/your symbol) into a 0–100 sentiment line. It scales context by volatility (ATR%) and can self-calibrate with rolling quantile OB/OS. On top of that, it adds confidence scoring, a plain-English Context Coach, MTF agreement, exportable sentiment for other indicators, and a clean Light/Dark UI.
Why it’s different
• Adaptive lookback tracks regime changes: when volatility rises, we lengthen context; when it falls, we shorten—less whipsaw, more relevance.
• Dynamic OB/OS (quantiles) self-calibrates to each instrument’s distribution—no arbitrary 30/70 lines.
• MTF agreement + Confidence gate reduce false positives by highlighting alignment across timeframes.
• Exportable output: hidden plot “DynamoSent Export” can be selected as input.source in your other Pine scripts.
• Non-repainting rigor: all request.security() calls use lookahead_off + gaps_on; signals wait for bar close.
Key visuals
• Sentiment line (0–100), OB/OS zones (static or dynamic), optional TF1/TF2 overlays.
• Regime boxes (Overbought / Oversold / Neutral) that update live without repaint.
• Info Panel with confidence heat, regime, trend arrow, MTF readout, and Coach sentence.
• Session heat (Asia/EU/US) to match intraday behavior.
• Light/Dark theme switch in Inputs (auto-contrasted labels & headers).
⸻
How to use (examples & recipes)
1) EURUSD (swing / intraday blend)
• Preset: EURUSD 1H Swing
• Chart: 1H; TF1=1H, TF2=4H (default).
• Proxies: Defaults work (VIX=D, DXY=60, Proxy=D).
• Dynamic OB/OS: ON at 20/80; Confidence ≥ 55–60.
• Playbook:
• When sentiment crosses above 50 + margin with Δ ≥ signalK and MTF agreement ≥ 0.5, treat as trend breakout.
• In Oversold with rising Coach & TF agreement, take fade longs back toward mid-range.
• Alerts: Enable Breakout Long/Short and Fade; keep cooldown 8–12 bars.
2) SPY (daytrading)
• Preset: SPY 15m Daytrade; Chart: 15m.
• VIX (D) matters more; preset weights already favor it.
• Start with static 30/70; later try dynamic 25/75 for adaptive thresholds.
• Use Coach: in US session, when it says “Overbought + MTF agree → sell rallies / chase breakouts”, lean momentum-continuation after pullbacks.
3) BTCUSD (crypto, 24/7)
• Preset: BTCUSD 1H; Chart: 1H.
• DXY and BTC.D inform macro tone; keep Carry-forward ON to bridge sparse ticks.
• Prefer Dynamic OB/OS (15/85) for wider swings.
• Fade signals on weekend chop; Breakout when Confidence > 60 and MTF ≥ 1.0.
4) XAUUSD (gold, macro blend)
• Preset: XAUUSD 4H; Chart: 4H.
• Weights tilt to DXY and US10Y (handled by preset).
• Coach + MTF helps separate trend legs from news pops.
⸻
Best practices
• Theme: Switch Light/Dark in Inputs; the panel adapts contrast automatically.
• Export: In another script → Source → DynamoSent Pro+ → DynamoSent Export. Build your own filters/strategies atop the same sentiment.
• Dynamic vs Static OB/OS:
• Static 30/70: fast, universal baseline.
• Dynamic (quantiles): instrument-aware; use 20/80 (default) or 15/85 for choppy markets.
• Confidence gate: Start at 50–60% to filter noise; raise when you want only A-grade setups.
• Adaptive Lookback: Keep ON. For ultra-liquid indices, you can switch it OFF and set a fixed lookback.
⸻
Non-repainting & safety notes
• All request.security() calls use lookahead=barmerge.lookahead_off and gaps=barmerge.gaps_on.
• No forward references; signals & regime flips are confirmed on bar close.
• History-dependent funcs (ta.change, ta.percentile_linear_interpolation, etc.) are computed each bar (not conditionally).
• Adaptive lookback is clamped ≥ 1 to avoid lowest/highest errors.
• Missing-data warning triggers only when all proxies are NA for a streak; carry-forward can bridge small gaps without repaint.
⸻
Known limits & tips
• If a proxy symbol isn’t available on your plan/exchange, you’ll see the NA warning: choose a different symbol via Symbol Search, or keep Carry-forward ON (it defaults to neutral where needed).
• Intraday VIX is sparse—using Daily is intentional.
• Dynamic OB/OS needs enough history (see dynLenFloor). On short histories it gracefully falls back to static levels.
Thanks for trying the preview. Your comments drive the roadmap—presets, new proxies, extra alerts, and integrations.
EMA50 + SR Boxes + VP Right + ATR + SL% + Entries + SentimentThis indicator combines several pro-grade building blocks to read the market at a glance:
EMA50 as a trend filter.
Smart Support/Resistance zones (rectangles) detected where price has touched multiple times.
“U / Inverted U” markers (confirmed pivots).
Optional Buy/Sell signals: only when a U appears inside a support zone with price above the EMA50 (buy), or an inverted U inside a resistance zone with price below the EMA50 (sell).
Simplified right-side Volume Profile (with a special Forex fallback if volume isn’t usable).
ATR & SL%: displays current ATR and an SL% based on ATR(100) Daily / Close × 100, attached to the latest candle.
Trinity Multi-Timeframe MA TrendOriginal script can be found here: {Multi-Timeframe Trend Analysis } www.tradingview.com
1. all credit the original author www.tradingview.com
2. why change this script:
- added full transparency function to each EMA
- changed to up and down arrows
- change the dashboard to be able to resize and reposition
How to Use This Indicator
This indicator, "Trinity Multi-Timeframe MA Trend," is designed for TradingView and helps visualize Exponential Moving Average (EMA) trends across multiple timeframes. It plots EMAs on your chart, fills areas between them with directional colors (up or down), shows crossover/crossunder labels, and displays a dashboard table summarizing EMA directions (bullish ↑ or bearish ↓) for selected timeframes. It's useful for multi-timeframe analysis in trading strategies, like confirming trends before entries.
Configure Settings (via the Gear Icon on the Indicator Title):
Timeframes Group: Set up to 5 custom timeframes (e.g., "5" for 5 minutes, "60" for 1 hour). These determine the multi-timeframe analysis in the dashboard. Defaults: 5m, 15m, 1h, 4h, 5h.
EMA Group: Adjust the lengths of the 5 EMAs (defaults: 5, 10, 20, 50, 200). These are the moving averages plotted on the chart.
Colors (Inline "c"): Choose uptrend color (default: lime/green) and downtrend color (default: purple). These apply to plots, fills, labels, and dashboard cells.
Transparencies Group: Set transparency levels (0-100) for each EMA's plot and fill (0 = opaque, 100 = fully transparent). Defaults decrease from EMA1 (80) to EMA5 (0) for a gradient effect.
Dashboard Settings Group (newly added):
Dashboard Position: Select where the table appears (Top Right, Top Left, Bottom Right, Bottom Left).
Dashboard Size: Choose text size (Tiny, Small, Normal, Large, Huge) to scale the table for better visibility on crowded charts.
Understanding the Visuals:
EMA Plots: Five colored lines on the chart (EMA1 shortest, EMA5 longest). Color changes based on direction: uptrend (your selected up color) if rising, downtrend (down color) if falling.
Fills Between EMAs: Shaded areas between consecutive EMAs, colored and transparent based on the faster EMA's direction and your transparency settings.
Crossover Labels: Arrow labels (↑ for crossover/uptrend start, ↓ for crossunder/downtrend start) appear on the chart at EMA direction changes, with tooltips like "EMA1".
Dashboard Table (top-right by default):
Rows: EMA1 to EMA5 (with lengths shown).
Columns: Selected timeframes (converted to readable format, e.g., "5m", "1h").
Cells: ↑ (bullish/up) or ↓ (bearish/down) arrows, colored green/lime or purple based on trend, with fading transparency for visual hierarchy.
Use this to quickly check alignment across timeframes (e.g., all ↑ in multiple TFs might signal a strong uptrend).
Trading Tips:
Trend Confirmation: Look for alignment where most EMAs in higher timeframes are ↑ (bullish) or ↓ (bearish).
Entries/Exits: Use crossovers on the chart EMAs as signals, confirmed by the dashboard (e.g., enter long if lower TF EMA crosses up and higher TFs are aligned).
Customization: On lower timeframe charts, set dashboard timeframes to higher ones for top-down analysis. Adjust transparencies to avoid chart clutter.
Limitations: This is a trend-following tool; combine with volume, support/resistance, or other indicators. Backtest on historical data before live use.
Performance: Works best on trending markets; may whipsaw in sideways conditions.
Multi-Indicator Panel (RSI, Stoch, MACD, VIX Fix, MFI)A versatile single-pane oscillator panel combining RSI, Stochastic, MACD (scaled to 0–100), Williams VIX Fix (normalized & inverted: low value = high fear), and MFI. Each module is toggleable, with reference levels, background highlights, and ready-made alerts.
Key features
Per-indicator toggles: RSI, Stoch %K/%D, MACD (lines + optional histogram), inverted 0–100 VIX Fix, and MFI.
Standard levels & center line at 50; adjustable overbought/oversold thresholds.
Contextual background coloring (optional) for extreme conditions.
Built-in alerts: RSI/Stoch OB/OS, MACD–Signal cross, VIX Fix “High Fear/Low Fear,” and MFI OB/OS.
Unified scale: MACD mapped around 50 to align with other oscillators; VIX Fix normalized to 0–100.
How to use (quick)
Add the indicator → enable needed modules via “Indicator Toggles.”
Tune periods & levels (e.g., RSI 14, Stoch 14/3, MACD 12-26-9, VIX Fix 22/252, MFI 14).
(Optional) Turn on MACD histogram.
Create alerts from “Add alert on…” using the provided conditions.
Interpretation notes
Inverted VIX Fix: low values ⇒ high fear/volatility (potential bounces); high values ⇒ complacency.
Scaled MACD: lines around 50 ≈ MACD zero; line crosses remain valid despite scaling.
Disclaimer
Analysis tool, not financial advice. Test across timeframes/instruments and pair with risk management.
Flux Power Dashboard (Updated and Renamed)Flux Power Dashboard is a compact market-state heads-up display for TradingView. It blends trend, momentum, and volume-flow into a single on-chart panel with color-coded cues and minimal lag. You get:
Clean visual trend via fast/slow MA with slope/debounce filters
MACD state and most recent cross (with “freshness” tint)
OBV confirmation and gating to reduce noise
Session awareness (Asia/London/New York + pre-sessions + overlap)
Optional HTF Regime row and regime gate to align signals to higher-timeframe bias
Context from VIX/VXN (volatility regime)
A single Flux Score (0–100) as a top-level read
It is deliberately “dashboard-first”: fast to read, consistent between symbols/timeframes, and designed to limit overtrading in chop.
What it can do (capabilities)
Signal gating: You can require multiple pillars to agree (Trend, MACD, OBV) before a “strong” bias is shown.
Debounced trend: Uses slope + confirmation bars to avoid flip-flopping.
Session presets: Auto-adjust the minimum confirmation bars by session (e.g., NY vs London vs Asia) to better match liquidity/volatility.
MACD presets: Quick switch between Scalp / Classic / Slow or roll your own custom speeds.
OBV confirmation: Volume flow must agree for trend/entries to “count” (optional).
HTF Regime awareness: Shows the higher-timeframe backdrop and (optionally) gates signals so you don’t fight the dominant trend.
Volatility context: VIX/VXN auto-colored cells based on your thresholds.
Top-center Session Title: Broadcasts the active session (or Overlap) with a matched background color.
Customizable UI: Column fonts, params font, transparency, dashboard corner, marker styles, colors, widths—tune it to your chart.
Practical use: Start with Flux Score + Summary for a snapshot, confirm with Trend & MACD, check OBV agreement (implicit in signal strength), glance at Regime to avoid counter-trend trades, and use Session + VIX/VXN for timing and risk context.
How it avoids common pitfalls
Repaint-aware: “Confirm on Close” can be enabled to read prior bar states, reducing intrabar noise.
Auto MA sanity: If fast ≥ slow length, it auto-swaps under the hood to keep calculations valid.
Debounce & confirm: Trend flips only after X bars satisfy conditions, cutting false flips in chop.
Freshness tint: New Cross/Signal rows tint slightly brighter for a few bars, so you can spot recency at a glance.
Every line of the dashboard (what it shows, how it’s colored)
Flux Score
What: Composite 0–100 built from three pillars: Trend (40%), MACD (30%), OBV (30%).
Read: ≥70 Bullish, ≤30 Bearish, else Neutral.
Use: Quick “state of play” gauge—stronger alignment pushes the score toward extremes.
Regime (optional row)
What: Higher-timeframe (your Regime TF) backdrop using the same MA pair with HTF slope/ATR buffer.
Values: Bull / Bear / Range.
Gate (optional): If Regime Gate is ON, Trend/Signals only go directional when HTF agrees.
Summary
What: One-line narrative combining the three pillars: MACD (up/down/flat), OBV (up/down/flat), Trend (up/down/flat).
Use: Human-readable cross-check; should rhyme with Flux Score.
Trend
What: Debounced MA relationship on the current chart.
Strict: needs fast > slow and slow rising (mirror for down) + slope debounce + confirmation bars.
Lenient: allows fast > slow or slow rising (mirror for down) with the same debounce/confirm.
Color: Green = UP, Red = DOWN, Gray = FLAT.
Use: Your structural bias on the trading timeframe.
MACD
What: Current MACD line vs signal, using your selected preset (or custom).
Values: Bull (line above), Bear (below), Flat (equal/indeterminate).
Color: Green/Red/Gray.
Cross
What: Most recent MACD cross and how many bars ago it occurred (e.g., “MACD XUP | 3 bars”).
Freshness: If the cross happened within Fresh Signal Tint bars, the cell brightens slightly.
Use: Timing helper for inflection points.
Signal
What: Latest directional shift (from short-bias to long-bias or vice versa) and age in bars.
Strength:
Strong = Trend + MACD + OBV all align
Weak = partial alignment (e.g., Trend + MACD, or Trend + OBV)
Color: Green for long bias, Red for short bias; fresh signals tint brighter.
Use: Action cue—treat Strong as higher quality; Weak as situational.
MA
What: Your slow MA type and length, plus slope direction (“up”/“down”).
Use: Context even when Trend is FLAT; slope often turns before full trend flips.
Session
What: Current market session by Eastern Time: New York / London / Asia, Pre- windows, Overlap, or Off-hours.
Logic: If ≥2 main sessions are active, shows Overlap (and grays the top title background).
Use: Timing and expectations for liquidity/volatility; also drives session-based confirmation presets if enabled.
VIX
What: Real-time CBOE:VIX on your chosen TF.
Auto-color (if on):
Calm (< Calm) → Green
Watch (< Watch) → Yellow
Elevated (< Elevated) → Orange
Very High (≥ Elevated) → Red
Use: Equity market–wide risk mood; higher = bigger moves, lower = quieter.
VXN
What: CBOE:VXN (Nasdaq volatility index) on your chosen TF.
Auto-color thresholds like VIX.
Use: Tech-heavy risk mood; helpful for growth/QQQ/NDX names.
Footer (params row, bottom-right)
What: Key live settings so you always know the context:
P= Trend Confirmation Bars
O= OBV Confirmation Bars
Strict/Lenient (trend mode)
MACD preset (or “Custom”)
swap if MA lengths were auto-swapped for validity
Regime gate if enabled
Candles for clarity
Use: Quick integrity check when comparing charts/screenshots or changing presets.
Recommended workflow
Start at Flux Score & Summary → snapshot of alignment.
Check Trend (color) and MACD (Bull/Bear).
Look at Signal (Strong vs Weak, and age).
Glance at Regime (and use gate if you’re trend-following).
Use Session + VIX/VXN to adjust expectations (breakout vs mean-revert, risk sizing, patience).
Keep Confirm on Close ON when you want stability; turn it OFF for faster (but noisier) reads.
Notes & limitations
Not advice: This is an informational tool; always combine with your own risk rules.
Repaint vs responsiveness: With “Confirm on Close” OFF you’ll see faster state changes but may get more churn intrabar.
Presets matter: Scalp MACD reacts fastest; Slow reduces whipsaw. Choose for your timeframe.
Session windows depend on the strings you set; adjust if your broker’s feed or DST handling needs tweaks.
维加斯双通道策略Vegas Channel Comprehensive Strategy Description
Strategy Overview
A comprehensive trading strategy based on the Vegas Dual Channel indicator, supporting dynamic position sizing and fund management. The strategy employs a multi-signal fusion mechanism including classic price crossover signals, breakout signals, and retest signals, combined with trend filtering, RSI+MACD filtering, and volume filtering to ensure signal reliability.
Core Features
Dynamic Position Sizing: Continue adding positions on same-direction signals, close all positions on opposite signals
Smart Take Profit/Stop Loss: ATR-based dynamic TP/SL, updated with each new signal
Fund Management: Supports dynamic total amount management for compound growth
Time Filtering: Configurable trading time ranges
Risk Control: Maximum order limit to prevent over-leveraging
Leverage Usage Instructions
Important: This strategy does not use TradingView's margin functionality
Setup Method
Total Amount = Actual Funds × Leverage Multiplier
Example: Have 100U actual funds, want to use 10x leverage → Set total amount to 100 × 10 = 1000U
Trading Amount Calculation
Each trade percentage is calculated based on leveraged amount
Example: Set 10% → Actually trade 100U margin × 10x leverage = 1000U trading amount
Maximum Orders Configuration
Must be used in conjunction with leveraged amount
Example: 1000U total amount, 10% per trade, maximum 10 orders = maximum use of 1000U
Note: Do not exceed 100% of total amount to avoid over-leveraging
Parameter Configuration Recommendations
Leverage Configuration Examples
Actual funds 100U, 5x leverage, total amount setting 500U, 10% per trade, 50U per trade, recommended maximum orders 10
Actual funds 100U, 10x leverage, total amount setting 1000U, 10% per trade, 100U per trade, recommended maximum orders 10
Actual funds 100U, 20x leverage, total amount setting 2000U, 5% per trade, 100U per trade, recommended maximum orders 20
Risk Control
Conservative: 5-10x leverage, 10% per trade, maximum 5-8 orders
Aggressive: 10-20x leverage, 5-10% per trade, maximum 10-15 orders
Extreme: 20x+ leverage, 2-5% per trade, maximum 20+ orders
Strategy Advantages
Signal Reliability: Multiple filtering mechanisms reduce false signals
Capital Efficiency: Dynamic fund management for compound growth
Risk Controllable: Maximum order limits prevent liquidation
Flexible Configuration: Supports various leverage and fund allocation schemes
Time Control: Configurable trading hours to avoid high-risk periods
Usage Notes
Ensure total amount is set correctly (actual funds × leverage multiplier)
Maximum orders should not exceed the range allowed by total funds
Recommend starting with conservative configuration and gradually adjusting parameters
Regularly monitor strategy performance and adjust parameters timely
维加斯通道综合策略说明
策略概述
基于维加斯双通道指标的综合交易策略，支持动态加仓和资金管理。策略采用多信号融合机制，包括经典价穿信号、突破信号和回踩信号，结合趋势过滤、RSI+MACD过滤和成交量过滤，确保信号的可靠性。
核心功能
动态加仓：同向信号继续加仓，反向信号全部平仓
智能止盈止损：基于ATR的动态止盈止损，每次新信号更新
资金管理：支持动态总金额管理，实现复利增长
时间过滤：可设置交易时间范围
风险控制：最大订单数限制，防止过度加仓
杠杆使用说明
重要：本策略不使用TradingView的保证金功能
设置方法
总资金 = 实际资金 × 杠杆倍数
示例：实际有100U，想使用10倍杠杆 → 总资金设置为 100 × 10 = 1000U
交易金额计算
每笔交易百分比基于杠杆后的金额计算
示例：设置10% → 实际交易 100U保证金 × 10倍杠杆 = 1000U交易金额
最大订单数配置
必须配合杠杆后的金额使用
示例：1000U总资金，10%单笔，最大10单 = 最多使用1000U
注意：不要超过总资金的100%，避免过度杠杆
参数配置建议
杠杆配置示例
实际资金100U，5倍杠杆，总资金设置500U，单笔百分比10%，单笔金额50U，建议最大订单数10单
实际资金100U，10倍杠杆，总资金设置1000U，单笔百分比10%，单笔金额100U，建议最大订单数10单
实际资金100U，20倍杠杆，总资金设置2000U，单笔百分比5%，单笔金额100U，建议最大订单数20单
风险控制
保守型：5-10倍杠杆，10%单笔，最大5-8单
激进型：10-20倍杠杆，5-10%单笔，最大10-15单
极限型：20倍以上杠杆，2-5%单笔，最大20单以上
策略优势
信号可靠性：多重过滤机制，减少假信号
资金效率：动态资金管理，实现复利增长
风险可控：最大订单数限制，防止爆仓
灵活配置：支持多种杠杆和资金配置方案
时间控制：可设置交易时间，避开高风险时段
使用注意事项
确保总资金设置正确（实际资金×杠杆倍数）
最大订单数不要超过总资金允许的范围
建议从保守配置开始，逐步调整参数
定期监控策略表现，及时调整参数
My script//@version=6
strategy("Elite Option Signal Strategy", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10)
// === INPUTS ===
fastLength = input.int(9, title="Fast MA Length")
slowLength = input.int(21, title="Slow MA Length")
trendLength = input.int(50, title="Trend MA Length")
rsiLength = input.int(14, title="RSI Length")
rsiOversold = input.int(30, title="RSI Oversold Level")
rsiOverbought = input.int(70, title="RSI Overbought Level")
useStopLoss = input.bool(true, title="Use Stop Loss?")
stopLossPercent = input.float(2.0, title="Stop Loss %", minval=0.1, maxval=10.0)
// === INDICATORS ===
fastMA = ta.sma(close, fastLength)
slowMA = ta.sma(close, slowLength)
trendMA = ta.sma(close, trendLength)
rsi = ta.rsi(close, rsiLength)
// === CONDITIONS ===
bullishTrend = close > trendMA
bearishTrend = close < trendMA
longCondition = ta.crossover(fastMA, slowMA) and bullishTrend and rsi < rsiOverbought
shortCondition = ta.crossunder(fastMA, slowMA) and bearishTrend and rsi > rsiOversold
// === EXECUTION ===
if longCondition
strategy.entry("Long", strategy.long)
if useStopLoss
strategy.exit("Exit Long", "Long", stop=close * (1 - stopLossPercent / 100))
if shortCondition
strategy.entry("Short", strategy.short)
if useStopLoss
strategy.exit("Exit Short", "Short", stop=close * (1 + stopLossPercent / 100))
// === PLOTS ===
plot(fastMA, color=color.green, title="Fast MA")
plot(slowMA, color=color.red, title="Slow MA")
plot(trendMA, color=color.blue, title="Trend MA")
plotshape(longCondition, title="Buy Signal", location=location.belowbar, color=color.green, style=shape.triangleup)
plotshape(shortCondition, title="Sell Signal", location=location.abovebar, color=color.red, style=shape.triangledown)
（VIX Spread-BTC Cycle Timing Strategy）A multi-asset cycle timing strategy that constructs a 0-100 oscillator using the absolute 10Y-2Y U.S. Treasury yield spread multiplied by the inverse of VIX squared. It integrates BTC’s deviation from its 100-day MA and 10Y Treasury’s MA position as dual filters, with clear entry rules: enter bond markets when the oscillator exceeds 80 (hiking cycles) and enter BTC when it drops below 20 (easing cycles).
Weis Wave Candle█Overview
The Weis Wave Candle indicator is a technical tool designed for the TradingView platform, enabling traders to analyze market dynamics by identifying price waves. The indicator relies solely on candlestick data, making it functional on markets where volume data is unavailable. It employs two trend detection methods, dynamic color gradients, trend change alerts, and clear visualization to assist in identifying trend strength and potential reversal points.
█Concept
The Weis Wave Candle indicator was developed to overcome limitations associated with the lack of volume data in certain markets, offering an alternative to traditional volume-based indicators like Weis Wave. Instead of volume, it measures candle size (body or body plus half the candle range) and accumulates it within a price wave. The indicator includes two trend calculation methods:
-LazyBear Style: Based on the popular Weis Wave adaptation by LazyBear, likely the most recognized version of this tool, it uses closing price comparisons and trend confirmation via trend functions. Results may differ from the original Weis Wave, as candle size does not always align with volume.
-Impulse Trend: A method that evaluates trend strength by summing price movements over a specified period, where each candle with a higher close than the previous adds +1, a lower close subtracts -1, and no change adds 0. The trend strength is determined by the sum: positive indicates an uptrend, negative a downtrend, and zero a continuation of the prior trend.
Results are visualized using dynamic color gradients, and alerts notify users of trend direction changes, facilitating quick decision-making.
█Why Use It?
-Volume-Free Operation: Ideal for markets without volume data.
-Flexibility: Two trend detection methods allow adaptation to various trading strategies.
-Dynamic Visualization: Color gradients and semi-transparent backgrounds simplify quick interpretation of trend strength.
-Alerts: Notifications for trend changes (from uptrend to downtrend and vice versa) support active trading.
-Customization: Options to adjust colors, analysis periods, and candle shadow inclusion.
█How It Works?
-Candle Size Calculation: Depending on the setting, candle size includes only the body (difference between close and open) or the body plus half the candle range (calculated as 0.5 * (high - low)) (setting Include candle shadows).
-Trend Detection:
LazyBear Style: Compares closing prices of adjacent candles to determine direction (uptrend, downtrend, or neutral) and confirms the trend using ta.rising or ta.falling functions over the specified period.
Impulse Trend: Sums price movements over the analysis period (+1 for a candle with a higher close than the previous, -1 for a lower close, 0 for no change). A positive sum indicates an uptrend, a negative sum a downtrend, and zero a continuation of the prior trend.
-Wave Accumulation: Candle sizes are accumulated within a single wave until the trend changes.
-Normalization and Gradients: Wave values are normalized to a 0-100 scale solely for color gradient purposes, enabling dynamic color changes from base to intense, reflecting wave strength relative to historical values. The height of columns (representing waves) is not normalized and corresponds to the accumulated candle size.
-Alerts: The indicator generates notifications when the wave direction changes (from uptrend to downtrend or vice versa), enabling quick responses to trend shifts.
-Visualization: Upward and downward waves are plotted as columns with dynamic colors, and the chart background changes color for better visibility.
█Settings and Customization
-Trend Detection Method: Choose between LazyBear Style (default) and Impulse Trend.
-Trend Analysis Period: Number of candles for trend analysis (default: 4).
-Include Candle Shadows: Determines whether to include half the candle range (high - low) in addition to the body (default: enabled).
-Lookback Period for Dynamic Thresholds: Number of candles to calculate the maximum and minimum wave values for color gradient normalization (default: 70).
-Gradient Minimum/Maximum Value: Threshold values defining the normalization range for color gradients (default: 0/100). A lower minimum value reduces the threshold for lighter colors, while a higher maximum value increases the threshold for more intense colors.
-Wave Colors: Options to select base and intense colors for upward and downward waves.
-Alerts: Enable alerts in TradingView settings (Upward Trend Change and Downward Trend Change) for trend change notifications.
█Usage Examples
-Trend Analysis: Upward waves (green columns) indicate buying pressure, while downward waves (red columns) indicate selling pressure. The more intense the color, the stronger the wave relative to historical values.
-Comparing Timeframes: Analyze trends across multiple timeframes (e.g., 1H, 4H, 1D) for broader context. For example, enter a position on the 4H timeframe after confirming trend alignment on 1H, 4H, and 1D, along with validation from a key level, such as a Fibonacci level or a Break of Structure (BOS).
-Using Alerts: Configure alerts in TradingView to receive notifications of trend changes, useful for active trading.
█Notes for Users
-Experiment with the Trend Analysis Period and Include Candle Shadows settings to tailor the indicator to your market and timeframe.
-Combine the indicator with other tools, such as support/resistance levels or RSI, to enhance signal accuracy.
-The Impulse Trend method may be more sensitive to short-term price changes, while LazyBear Style performs better in clear trends. Results from LazyBear Style may differ from the original Weis Wave, as candle size does not always align with volume.
8 EMA BundleThis indicator plots 8 key Exponential Moving Averages (EMAs) — 5, 8, 13, 20, 34, 50, 100, and 200 — in one script. These EMAs help traders analyze short, medium, and long-term market trends at a glance.
📌 Features:
Short-term EMAs (5, 8, 13, 20) highlight momentum and quick trend changes.
Medium-term EMAs (34, 50) confirm ongoing trends.
Long-term EMAs (100, 200) define the primary trend and major support/resistance.
Suitable for both intraday and swing trading.
This tool simplifies multi-EMA analysis, making it easier to spot crossovers, trend shifts, and pullback opportunities.
[delta2win] ShockSentinel Early Warnings🚀 ShockSentinel Early Warnings — Advanced Multi-Symbol Shock Detection System
📊 UNIQUE METHODOLOGY:
This indicator implements a proprietary concordance-based shock detection system that goes beyond simple price movement analysis. Unlike basic pump/dump detectors, it uses a sophisticated multi-symbol correlation algorithm to validate signals across multiple assets simultaneously, significantly reducing false positives while maintaining sensitivity to genuine market shocks.
🔬 TECHNICAL APPROACH:
• Adaptive Threshold System: Automatically adjusts detection sensitivity based on timeframe using proprietary scaling algorithms:
- 1m: 0.5% threshold (ultra-sensitive for scalping)
- 3m: 1.0% threshold (high-frequency trading)
- 5m: 2.0% threshold (short-term momentum)
- 15m: 3.0% threshold (intraday swings)
- 1h: 6.0% threshold (daily moves)
- 4h+: 10.0% threshold (swing trading)
• Dual Detection Modes:
- Percent Mode: Calculates maximum percentage change within configurable lookback window (1-6 bars) using the formula: max(|(close - close ) / close * 100|) for i = 1 to window
- ATR-Normalized Mode: Uses Average True Range for volatility-adjusted detection across different market regimes: max(|close - close | / ATR) for i = 1 to window
• Concordance Algorithm: Proprietary multi-symbol validation system that requires minimum correlation count across up to 4 additional symbols, ensuring signals are validated by market-wide participation rather than isolated price movements
• Non-Repainting Architecture: Optional bar-close confirmation prevents false signals from intraday noise while maintaining real-time alert capability for immediate response
🎯 MATHEMATICAL FOUNDATION:
The core algorithm implements a sliding window maximum change detection:
Percent Change Calculation:
For each bar, the system calculates the maximum absolute percentage change over the specified window:
- PctChange = (close - close ) / close * 100
- MaxPct = max(|PctChange |) for i = 1 to window
- Signal triggers when MaxPct >= threshold
ATR-Normalized Calculation:
For volatility-adjusted detection:
- ATRChange = (close - close ) / ATR
- MaxATR = max(|ATRChange |) for i = 1 to window
- Signal triggers when MaxATR >= ATR_multiplier
Concordance Validation:
- Requires minimum N symbols showing same directional movement
- Validates signal strength through market participation
- Reduces false signals from isolated price movements
- Improves signal quality through correlation analysis
⚙️ ADVANCED FEATURES:
• Preset System: 7 pre-configured strategies with optimized parameters:
- Scalp (Ultra-Fast): 0.6x scaling, 2-bar window, real-time alerts
- Aggressive: 0.7x scaling, 2-bar window, real-time alerts
- Balanced: 1.0x scaling, 3-bar window, confirmed signals
- Conservative: 1.3x scaling, 4-bar window, confirmed signals
- Volatility-Adaptive: ATR mode, 7-period ATR, 2.5x multiplier
- Momentum (Intraday): ATR mode, 10-period ATR, 2.0x multiplier
- Swing (Slow): ATR mode, 14-period ATR, 2.8x multiplier
• Real-time vs Confirmed: Choose between immediate alerts or bar-close confirmation
• Visual Analytics: Integrated signal history table with concordance gauges and performance metrics
• Professional Alerts: Multi-format alert system (Compact, Extended, Plain, CSV) with Telegram integration and customizable messaging
💡 UNIQUE VALUE PROPOSITION:
Unlike simple price change detectors, this system provides:
1. Multi-Symbol Validation: Validates signals across multiple correlated assets, ensuring market-wide participation
2. Adaptive Thresholds: Automatically adjusts sensitivity based on timeframe and market conditions
3. Dual Signal Types: Provides both real-time and confirmed signal options for different trading styles
4. Comprehensive Analytics: Includes signal history, concordance gauges, and performance tracking
5. Advanced Concordance: Uses sophisticated correlation algorithms for signal validation
6. Professional Integration: Built-in Telegram support with customizable message formats
🔧 USAGE INSTRUCTIONS:
1. Select Preset: Choose appropriate strategy for your trading style and timeframe
2. Configure Symbols: Add up to 4 additional symbols for concordance validation
3. Set Concordance: Adjust minimum count (higher = more selective, lower = more sensitive)
4. Choose Mode: Select between real-time or confirmed signals based on your risk tolerance
5. Enable Alerts: Configure notification preferences and message formats
6. Monitor Performance: Use integrated tables to track signal quality and concordance
📈 PERFORMANCE CHARACTERISTICS:
• Optimized for Crypto: Designed specifically for high-volatility cryptocurrency markets
• Multi-Timeframe: Effective across all timeframes from 1-minute to 4-hour charts
• False Signal Reduction: Multi-symbol validation significantly reduces false positives
• Flexible Sensitivity: Adjustable thresholds allow customization for different market conditions
• Real-time Capability: Provides immediate alerts for fast-moving markets
• Confirmation Option: Bar-close confirmation for conservative trading approaches
⚠️ TECHNICAL CONSIDERATIONS:
• Real-time Mode: May generate multiple alerts per bar; use cooldown settings to manage frequency
• Data Dependencies: Concordance requires data availability for all configured symbols
• Market Regimes: ATR mode provides better performance in varying volatility conditions
• Signal Quality: Higher concordance requirements reduce false signals but may miss opportunities
• Latency: request.security calls depend on data provider latency and availability
🎯 TARGET MARKETS:
• Cryptocurrency Trading: High-volatility crypto markets with frequent shock events
• Scalping: Short-term trading strategies requiring immediate signal detection
• Swing Trading: Medium-term strategies benefiting from confirmed signals
• Portfolio Management: Multi-asset correlation analysis for risk management
• Algorithmic Trading: Systematic strategies requiring reliable signal validation
📊 SIGNAL INTERPRETATION:
• Green Arrows (Pump): Upward price shock with sufficient concordance
• Red Arrows (Dump): Downward price shock with sufficient concordance
• Large Markers: Confirmed signals with high concordance
• Small Markers: Early signals with lower concordance
• Background Colors: Visual intensity based on concordance strength
• Tables: Historical signal tracking with performance metrics
Simple Technicals Table📊 Simple Technicals Table
🎯 A comprehensive technical analysis dashboard displaying key pivot points and moving averages across multiple timeframes
📋 OVERVIEW
The Simple Technicals Table is a powerful indicator that organizes essential trading data into a clean, customizable table format. It combines Fibonacci-based pivot points with critical moving averages for both daily and weekly timeframes, giving traders instant access to key support/resistance levels and trend information.
Perfect for:
Technical analysts studying multi-timeframe data
Chart readers needing quick reference levels
Market researchers analyzing price patterns
Educational purposes and data visualization
🚀 KEY FEATURES
📊 Dual Timeframe Analysis
Daily (D1) and Weekly (W1) data side-by-side
Real-time updates as market conditions change
Seamless comparison between timeframes
🎯 Fibonacci Pivot Points
R3, R2, R1 : Resistance levels using Fibonacci ratios (38.2%, 61.8%, 100%)
PP : Central pivot point from previous period's data
S1, S2, S3 : Support levels with same methodology
📈 Complete EMA Suite
EMA 10 : Short-term trend identification
EMA 20 : Popular swing trading reference
EMA 50 : Medium-term trend confirmation
EMA 100 : Institutional support/resistance
EMA 200 : Long-term trend determination
📊 Essential Indicators
RSI 14 : Momentum for overbought/oversold conditions
ATR 14 : Volatility measurement for risk management
🎨 Full Customization
9 table positions : Place anywhere on your chart
5 text sizes : Tiny to huge for optimal visibility
Custom colors : Background, headers, and text
Optional pivot lines : Visual weekly levels on chart
⚙️ HOW IT WORKS
Fibonacci Pivot Calculation:
Pivot Point (PP) = (High + Low + Close) / 3
Range = High - Low
Resistance Levels:
R1 = PP + (Range × 0.382)
R2 = PP + (Range × 0.618)
R3 = PP + (Range × 1.000)
Support Levels:
S1 = PP - (Range × 0.382)
S2 = PP - (Range × 0.618)
S3 = PP - (Range × 1.000)
Smart Price Formatting:
< $1: 5 decimal places (crypto-friendly)
$1-$10: 4 decimal places
$10-$100: 3 decimal places
> $100: 2 decimal places
📊 TECHNICAL ANALYSIS APPLICATIONS
⚠️ EDUCATIONAL PURPOSE ONLY
This indicator is designed solely for technical analysis and educational purposes . It provides data visualization to help understand market structure and price relationships.
📈 Data Analysis Uses
Support & Resistance Identification : Visualize Fibonacci-based pivot levels
Trend Analysis : Study EMA relationships and price positioning
Multi-Timeframe Study : Compare daily and weekly technical data
Market Structure : Understand key technical levels and indicators
📚 Educational Benefits
Learn about Fibonacci pivot point calculations
Understand moving average relationships
Study RSI and ATR indicator values
Practice multi-timeframe technical analysis
🔍 Data Visualization Features
Organized table format for easy data reading
Color-coded levels for quick identification
Real-time technical indicator values
Historical data integrity maintained
🛠️ SETUP GUIDE
1. Installation
Search "Simple Technicals Table" in indicators
Add to chart (appears in middle-left by default)
Table displays automatically on any timeframe
2. Customization
Table Position : Choose from 9 locations
Text Size : Adjust for screen resolution
Colors : Match your chart theme
Pivot Lines : Toggle weekly level visualization
3. Optimization Tips
Use larger text on mobile devices
Dark backgrounds work well with light text
Enable pivot lines for visual reference
✅ BEST PRACTICES
Recommended Usage:
Use for technical analysis and educational study only
Combine with other analytical methods for comprehensive analysis
Study multi-timeframe data relationships
Practice understanding technical indicator values
Important Notes:
Levels based on previous period's data
Most effective in trending markets
No repainting - uses confirmed data only
Works on all instruments and timeframes
🔧 TECHNICAL SPECS
Performance:
Pine Script v5 optimized code
Minimal CPU/memory usage
Real-time data updates
No lookahead bias
Compatibility:
All chart types (Candlestick, Bar, Line)
Any instrument (Stocks, Forex, Crypto, etc.)
All timeframes supported
Mobile and desktop friendly
Data Accuracy:
Precise floating-point calculations
Historical data integrity maintained
No future data leakage
📱 DEVICE SUPPORT
✅ Desktop browsers (Chrome, Firefox, Safari, Edge)
✅ TradingView mobile app (iOS/Android)
✅ TradingView desktop application
✅ Light and dark themes
✅ All screen resolutions
📋 VERSION INFO
Version 1.0 - Initial Release
Fibonacci-based pivot calculations
Dual timeframe support (Daily/Weekly)
Complete EMA suite (10, 20, 50, 100, 200)
RSI and ATR indicators
Fully customizable interface
Optional pivot line visualization
Smart price formatting
Mobile-optimized display
⚠️ DISCLAIMER
This indicator is designed for technical analysis, educational and informational purposes ONLY . It provides data visualization and technical calculations to help users understand market structure and price relationships.
⚠️ NOT FOR TRADING DECISIONS
This tool does NOT provide trading signals or investment advice
All data is for analytical and educational purposes only
Users should not base trading decisions solely on this indicator
Always conduct thorough research and analysis before making any financial decisions
📚 Educational Use Only
Use for learning technical analysis concepts
Study market data and indicator relationships
Practice chart reading and data interpretation
Understand mathematical calculations behind technical indicators
The Simple Technicals Table provides technical data visualization to assist in market analysis education. It does not constitute financial advice, trading recommendations, or investment guidance. Users are solely responsible for their own research and decisions.
Author: ToTrieu
Version: 1.0
Category: Technical Analysis / Support & Resistance
License: Open source for educational use
💬 Questions? Comments? Feel free to reach out!
Volume Pressure Arrows[Blk0ut]Volume Pressure Arrows are an innovative (I think) market pressure tool designed to cut through noise and provide traders with a realistic, but quick insight into buying vs selling pressure and which has real control. Rather than relying on any single classic indicator, this script blends five complementary measures of price–volume dynamics—Cumulative Volume Delta (CVD), VWAP distance, OBV slope, ATR expansion, and the DMI ratio—into a unified “pressure score.”
Each component is normalized, weighted, and combined into a single metric that can be read at a glance through intuitive up and down arrows plotted directly on the chart. By transforming multiple complex data streams into a single aggregated signal, Volume Pressure Arrows help traders answer some of the hardest questions we can face: is the current move backed by conviction? is there true momentum? Is price action about to reverse?
Why It’s Different
Traditional oscillators often create conflicting signals, forcing traders to guess which one to trust. This indicator integrates five perspectives on volume and momentum pressure into a single framework, balancing raw flow (CVD), relative positioning (VWAP), trend conviction (OBV slope), volatility expansion (ATR), and directional bias (DMI). The result is a weighted, probability-minded score capped between -100 and +100 for consistency and clarity.
Important note : Inspiration for the use of directly plotted arrows came from dgtrd "https://www.tradingview.com/u/dgtrd/" and their brilliant work on LazyBear's Squeeze Indicator "https://www.tradingview.com/script/Dsr7B2xE-Squeeze-Momentum-Indicator-LazyBear-vX-by-DGT/"
How to Read It
Bullish Arrows appear below the candles when the pressure score pushes above the neutral threshold, signaling meaningful buyer dominance.
Bearish Arrows appear above the candles when pressure drops below the negative threshold, indicating strong selling pressure.
Neutral Arrows (smaller, faded) mark conditions where pressure exists but is not decisive—useful for spotting early rotations or fading momentum.
Color Gradients dynamically adjust with score intensity, making stronger signals visually brighter and weaker ones softer.
How to Use It Effectively
This tool is best applied as a confirmation and timing layer. It is not meant to replace your core strategy, but to validate whether momentum pressure supports your trade thesis.
Combine with trendlines, chart patterns, or breakouts to gauge conviction.
Use bullish or bearish arrows as filters, only take trades when price action aligns with strong directional pressure.
Watch neutral arrows near key levels; they often foreshadow balance breaking into directional moves.
Adjust the weightings to emphasize the components that matter most to your style (e.g., more weight on CVD for scalpers, or ATR expansion for volatility traders).
As with any indicator, this is not a magic ball and does not guarantee success. But it does allow you to increase the probability odds to your favor if you align it with your edge. Happy trading!
Structural Liquidity Signals [BullByte]Structural Liquidity Signals (SFP, FVG, BOS, AVWAP)
Short description
Detects liquidity sweeps (SFPs) at pivots and PD/W levels, highlights the latest FVG, tracks AVWAP stretch, arms percentile extremes, and triggers after confirmed micro BOS.
Full description
What this tool does
Structural Liquidity Signals shows where price likely tapped liquidity (stop clusters), then waits for structure to actually change before it prints a trigger. It spots:
Liquidity sweeps (SFPs) at recent pivots and at prior day/week highs/lows.
The latest Fair Value Gap (FVG) that often “pulls” price or serves as a reaction zone.
How far price is stretched from two VWAP anchors (one from the latest impulse, one from today’s session), scaled by ATR so it adapts to volatility.
A “percentile” extreme of an internal score. At extremes the script “arms” a setup; it only triggers after a small break of structure (BOS) on a closed bar.
Originality and design rationale, why it’s not “just a mashup”
This is not a mashup for its own sake. It’s a purpose-built flow that links where liquidity is likely to rest with how structure actually changes:
- Liquidity location: We focus on areas where stops commonly cluster—recent pivots and prior day/week highs/lows—then detect sweeps (SFPs) when price wicks beyond and closes back inside.
- Displacement context: We track the last Fair Value Gap (FVG) to account for recent inefficiency that often acts as a magnet or reaction zone.
- Stretch measurement: We anchor VWAP to the latest N-bar impulse and to the Daily session, then normalize stretch by ATR to assess dislocation consistently across assets/timeframes.
- Composite exhaustion: We combine stretch, wick skew, and volume surprise, then bend the result with a tanh transform so extremes are bounded and comparable.
- Dynamic extremes and discipline: Rather than triggering on every sweep, we “arm” at statistical extremes via percent-rank and only fire after a confirmed micro Break of Structure (BOS). This separates “interesting” from “actionable.”
Key concepts
SFP (liquidity sweep): A candle briefly trades beyond a level (where stops sit) and closes back inside. We detect these at:
Pivots (recent swing highs/lows confirmed by “left/right” bars).
Prior Day/Week High/Low (PDH/PDL/PWH/PWL).
FVG (Fair Value Gap): A small 3‑bar gap (bar2 high vs bar1 low, or vice versa). The latest gap often acts like a magnet or reaction zone. We track the most recent Up/Down gap and whether price is inside it.
AVWAP stretch: Distance from an Anchored VWAP divided by ATR (volatility). We use:
Impulse AVWAP: resets on each new N‑bar high/low.
Daily AVWAP: resets each new session.
PR (Percentile Rank): Where the current internal score sits versus its own recent history (0..100). We arm shorts at high PR, longs at low PR.
Micro BOS: A small break of the recent high (for longs) or low (for shorts). This is the “go/no‑go” confirmation.
How the parts work together
Find likely liquidity grabs (SFPs) at pivots and PD/W levels.
Add context from the latest FVG and AVWAP stretch (how far price is from “fair”).
Build a bounded score (so different markets/timeframes are comparable) and compute its percentile (PR).
Arm at extremes (high PR → short candidate; low PR → long candidate).
Only print a trigger after a micro BOS, on a closed bar, with spacing/cooldown rules.
What you see on the chart (legend)
Lines:
Teal line = Impulse AVWAP (resets on new N‑bar extreme).
Aqua line = Daily AVWAP (resets each session).
PDH/PDL/PWH/PWL = prior day/week levels (toggle on/off).
Zones:
Greenish box = latest Up FVG; Reddish box = latest Down FVG.
The shading/border changes after price trades back through it.
SFP labels:
SFP‑P = SFP at Pivot (dotted line marks that pivot’s price).
SFP‑L = SFP at Level (at PDH/PDL/PWH/PWL).
Throttle: To reduce clutter, SFPs are rate‑limited per direction.
Triggers:
Triangle up = long trigger after BOS; triangle down = short trigger after BOS.
Optional badge shows direction and PR at the moment of trigger.
Optional Trigger Zone is an ATR‑sized box around the trigger bar’s close (for visualization only).
Background:
Light green/red shading = a long/short setup is “armed” (not a trigger).
Dashboard (Mini/Pro) — what each item means
PR: Percentile of the internal score (0..100). Near 0 = bullish extreme, near 100 = bearish extreme.
Gauge: Text bar that mirrors PR.
State: Idle, Armed Long (with a countdown), or Armed Short.
Cooldown: Bars remaining before a new setup can arm after a trigger.
Bars Since / Last Px: How long since last trigger and its price.
FVG: Whether price is in the latest Up/Down FVG.
Imp/Day VWAP Dist, PD Dist(ATR): Distance from those references in ATR units.
ATR% (Gate), Trend(HTF): Status of optional regime filters (volatility/trend).
How to use it (step‑by‑step)
Keep the Safety toggles ON (default): triggers/visuals on bar‑close, optional confirmed HTF for trend slope.
Choose timeframe:
Intraday (5m–1h) or Swing (1h–4h). On very fast/thin charts, enable Performance mode and raise spacing/cooldown.
Watch the dashboard:
When PR reaches an extreme and an SFP context is present, the background shades (armed).
Wait for the trigger triangle:
It prints only after a micro BOS on a closed bar and after spacing/cooldown checks.
Use the Trigger Zone box as a visual reference only:
This script never tells you to buy/sell. Apply your own plan for entry, stop, and sizing.
Example:
Bullish: Sweep under PDL (SFP‑L) and reclaim; PR in lower tail arms long; BOS up confirms → long trigger on bar close (ATR-sized trigger zone shown).
Bearish: Sweep above PDH/pivot (SFP‑L/P) and reject; PR in upper tail arms short; BOS down confirms → short trigger on bar close (ATR-sized trigger zone shown).
Settings guide (with “when to adjust”)
Safety & Stability (defaults ON)
Confirm triggers at bar close, Draw visuals at bar close: Keep ON for clean, stable prints.
Use confirmed HTF values: Applies to HTF trend slope only; keeps it from changing until the HTF bar closes.
Performance mode: Turn ON if your chart is busy or laggy.
Core & Context
ATR Length: Bigger = smoother distances; smaller = more reactive.
Impulse AVWAP Anchor: Larger = fewer resets; smaller = resets more often.
Show Daily AVWAP: ON if you want session context.
Use last FVG in logic: ON to include FVG context in arming/score.
Show PDH/PDL/PWH/PWL: ON to see prior day/week levels that often attract sweeps.
Liquidity & Microstructure
Pivot Left/Right: Higher values = stronger/rarer pivots.
Min Wick Ratio (0..1): Higher = only more pronounced SFP wicks qualify.
BOS length: Larger = stricter BOS; smaller = quicker confirmations.
Signal persistence: Keeps SFP context alive for a few bars to avoid flicker.
Signal Gating
Percent‑Rank Lookback: Larger = more stable extremes; smaller = more reactive extremes.
Arm thresholds (qHi/qLo): Move closer to 0.5 to see more arms; move toward 0/1 to see fewer arms.
TTL, Cooldown, Min bars and Min ATR distance: Space out triggers so you’re not reacting to minor noise.
Regime Filters (optional)
ATR percentile gate: Only allow triggers when volatility is at/above a set percentile.
HTF trend gate: Only allow longs when the HTF slope is up (and shorts when it’s down), above a minimum slope.
Visuals & UX
Only show “important” SFPs: Filters pivot SFPs by Volume Z and |Impulse stretch|.
Trigger badges/history and Max badge count: Control label clutter.
Compact labels: Toggle SFP‑P/L vs full names.
Dashboard mode and position; Dark theme.
Reading PR (the built‑in “oscillator”)
PR ~ 0–10: Potential bullish extreme (long side can arm).
PR ~ 90–100: Potential bearish extreme (short side can arm).
Important: “Armed” ≠ “Enter.” A trigger still needs a micro BOS on a closed bar and spacing/cooldown to pass.
Repainting, confirmations, and HTF notes
By default, prints wait for the bar to close; this reduces repaint‑like effects.
Pivot SFPs only appear after the pivot confirms (after the chosen “right” bars).
PD/W levels come from the prior completed candles and do not change intraday.
If you enable confirmed HTF values, the HTF slope will not change until its higher‑timeframe bar completes (safer but slightly delayed).
Performance tips
If labels/zones clutter or the chart lags:
Turn ON Performance mode.
Hide FVG or the Trigger Zone.
Reduce badge history or turn badge history off.
If price scaling looks compressed:
Keep optional “score”/“PR” plots OFF (they overlay price and can affect scaling).
Alerts (neutral)
Structural Liquidity: LONG TRIGGER
Structural Liquidity: SHORT TRIGGER
These fire when a trigger condition is met on a confirmed bar (with defaults).
Limitations and risk
Not every sweep/extreme reverses; false triggers occur, especially on thin markets and low timeframes.
This indicator does not provide entries, exits, or position sizing—use your own plan and risk control.
Educational/informational only; no financial advice.
License and credits
© BullByte - MPL 2.0. Open‑source for learning and research.
Built from repeated observations of how liquidity runs, imbalance (FVG), and distance from “fair” (AVWAPs) combine, and how a small BOS often marks the moment structure actually shifts.
EMA Cross By Crypto collective Xეს ინდიკატორი გაძლევთ საშუალებას ნახოთ ყველაზე პოპულარული EMA წყვილები ერთ გრაფიკზე:
EMA 9/21
EMA 20/50
EMA 50/200
EMA 100/200
და საკუთარი, მომხმარებლის მიერ შერჩეული Custom წყვილი.
👉 თითოეულ წყვილს შეგიძლია ჩართო/გამორთო ინდიკატორის პარამეტრებიდან.
👉 შესაძლებელია ფერების შეცვლა, ასევე სურვილის შემთხვევაში EMA-ების higher timeframe-ზე გამოტანა (მაგ. 1D EMA 4H გრაფიკზე).
ეს ინსტრუმენტი განსაკუთრებით გამოსადეგია:
ტრენდების დადგენისთვის
გრძელვადიანი და მოკლევადიანი გადაკვეთების შესადარებლად
საკუთარი სტრატეგიის ტესტირებისთვის
This indicator lets you plot and compare the most commonly used EMA pairs on a single chart:
EMA 9/21
EMA 20/50
EMA 50/200
EMA 100/200
plus a fully customizable user-defined EMA pair.
👉 Each pair can be toggled on/off from the settings.
👉 Colors are customizable, and you can optionally display EMAs from a higher timeframe (e.g., show Daily EMAs on a 4H chart).
This tool is especially useful for:
Trend confirmation
Comparing short-term vs. long-term crosses
Backtesting your own strategies
Mayfair FX Scalper V-10 Price Action + SMC//@version=5
indicator("Mayfair FX Scalper V-10 Price Action + SMC", overlay=true)
// === INPUTS ===
rsiLength = input.int(14, title="RSI Length")
overbought = input.float(73, title="SELL Level")
oversold = input.float(31, title="BUY Level")
rsiSrc = input.source(open, title="RSI Source")
// === Color Inputs ===
entryLineColor = input.color(color.white, title="entry Label Color")
entryLabelColor = input.color(color.white, title="entry Lable Color")
slLineColor = input.color(color.red, title="Stop Loss Line Color")
slLabelColor = input.color(color.red, title="Stop Loss Label Color")
tpLineColor = input.color(color.blue, title="Take Profit Line Color")
tpLabelColor = input.color(color.blue, title="Take Profit Color")
entryTextColor = input.color(color.rgb(0, 0, 0) , title="entry Text Color")
slTextColor = input.color(color.white, title="Stop Lose Color")
tpTextColor = input.color(color.white, title="Take Profit Text Color")
//indicator("Author Info Display"
// Create table
var table infoTable = table.new(position.top_right, 2, 6, bgcolor=color.new(#000000, 1), border_width=1)
if barstate.islast
table.cell(infoTable, 0, 0, "Author:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 0, "MR WOW", text_color=color.rgb(255, 251, 0), text_size=size.large)
table.cell(infoTable, 0, 1, "YouTube:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 1, "www.youtube.com/@iammrwow", text_color=color.rgb(255, 251, 0), text_size=size.small)
table.cell(infoTable, 0, 3, "Website:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 3, "www.mrwowea.com", text_color=color.rgb(255, 251, 0), text_size=size.small)
// === RSI CALCULATION ===
rsi = ta.rsi(rsiSrc, rsiLength)
rawBuySignal = rsi < oversold
rawSellSignal = rsi > overbought
// === Confirmed Signals ===
isBullish = close > open
isBearish = close < open
newBuy = rawBuySignal and isBullish and close > open == false
newSell = rawSellSignal and isBearish and close < open == false
// === Trade State Variables ===
var bool inPosition = false
var bool isBuy = false
var float entryPrice = na
var float slPrice = na
var float tp1Price = na
var float tp2Price = na
var float tp3Price = na
var int entryBarIndex = na
var label labels = array.new()
var line lines = array.new()
// === Instrument & Timeframe SL/TP Setup ===
isGold = str.contains(syminfo.ticker, "XAU") or str.contains(syminfo.ticker, "GOLD")
instrumentType = syminfo.type == "crypto" ? "Crypto" : isGold ? "Gold" : syminfo.currency == "JPY" ? "JPY" : "Forex"
tf = timeframe.period
slPipsGold = tf == "1" ? 30 : tf == "3" ? 45 : tf == "5" ? 50 : tf == "15" ? 60 : 70
slPipsCrypto = tf == "1" ? 5 : tf == "3" ? 8 : tf == "5" ? 12 : tf == "15" ? 15 : 10
slPipsForex = tf == "1" ? 6 : tf == "3" ? 9 : tf == "5" ? 11 : tf == "15" ? 15 : 15
gold_slDist = 0.1 * slPipsGold
gold_tp1Dist = gold_slDist
gold_tp2Dist = gold_slDist * 2
gold_tp3Dist = gold_slDist * 3
pipSize = instrumentType == "Crypto" ? 1.0 : instrumentType == "Gold" or instrumentType == "JPY" ? 0.01 : 0.0001
slPips = instrumentType == "Crypto" ? slPipsCrypto : instrumentType == "Gold" ? slPipsGold : slPipsForex
slDist = slPips * pipSize
tp1Dist = slDist
tp2Dist = slDist * 2
tp3Dist = slDist * 3
// === Draw Line & Label ===
drawLine(y, txt, col, lblCol, extendToCurrent) =>
int lineEnd = extendToCurrent ? bar_index : entryBarIndex + 2
array.push(lines, line.new(entryBarIndex, y, lineEnd, y, color=col, width=2, extend=extend.none))
textCol = str.contains(txt, "Entry") ? entryTextColor : str.contains(txt, "Stop") ? slTextColor : tpTextColor
array.push(labels, label.new(lineEnd, y, txt, style=label.style_label_left, color=color.new(lblCol, 0), textcolor=textCol, size=size.small))
// === Check Exit ===
slHit = inPosition and ((isBuy and low <= slPrice) or (not isBuy and high >= slPrice))
tp3Hit = inPosition and ((isBuy and high >= tp3Price) or (not isBuy and low <= tp3Price))
shouldExit = slHit or tp3Hit
if shouldExit
for l in labels
label.delete(l)
array.clear(labels)
for ln in lines
line.delete(ln)
array.clear(lines)
inPosition := false
entryPrice := na
slPrice := na
tp1Price := na
tp2Price := na
tp3Price := na
entryBarIndex := na
// === Confirmed Signal with No Position ===
confirmedBuy = not inPosition and newBuy
confirmedSell = not inPosition and newSell
// === Signal Markers ===
plotshape(series=confirmedBuy, location=location.belowbar, color=color.rgb(33, 150, 243), style=shape.triangleup, text="BUY", textcolor=color.rgb(33, 150, 243))
plotshape(series=confirmedSell, location=location.abovebar, color=color.rgb(254, 254, 255), style=shape.triangledown, text="SELL", textcolor=color.rgb(239, 238, 247))
// === Entry Execution ===
if confirmedBuy or confirmedSell
entryPrice := close
entryBarIndex := bar_index
isBuy := confirmedBuy
inPosition := true
if isGold
slPrice := isBuy ? entryPrice - gold_slDist : entryPrice + gold_slDist
tp1Price := isBuy ? entryPrice + gold_tp1Dist : entryPrice - gold_tp1Dist
tp2Price := isBuy ? entryPrice + gold_tp2Dist : entryPrice - gold_tp2Dist
tp3Price := isBuy ? entryPrice + gold_tp3Dist : entryPrice - gold_tp3Dist
else
slPrice := isBuy ? entryPrice - slDist : entryPrice + slDist
tp1Price := isBuy ? entryPrice + tp1Dist : entryPrice - tp1Dist
tp2Price := isBuy ? entryPrice + tp2Dist : entryPrice - tp2Dist
tp3Price := isBuy ? entryPrice + tp3Dist : entryPrice - tp3Dist
drawLine(entryPrice, "Entry Price - After Candle Above Entry Price Then Place Trade: " + str.tostring(entryPrice), entryLineColor, entryLabelColor, false)
drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, false)
drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, false)
drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, false)
drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, false)
// === Update TP/SL Lines if Still in Trade ===
if inPosition and not (confirmedBuy or confirmedSell)
for ln in lines
line.delete(ln)
array.clear(lines)
for l in labels
label.delete(l)
array.clear(labels)
drawLine(entryPrice, "After Candle Closed Above Entry Line Buy & Below Sell :Entry Price-" + str.tostring(entryPrice), entryLineColor, entryLabelColor, true)
drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, true)
drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, true)
drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, true)
drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, true)
// === Bollinger Bands Inputs ===
bb_length = input.int(20, title="SMA & StdDev Length")
src = input.source(close, title="Source")
// === Bollinger Band Colors ===
color_upper_2_3 = input.color(color.new(#0db107, 64), title="Upper Band 2–3 Color")
color_upper_3_4 = input.color(color.new(#05c41f, 58), title="Upper Band 3–4 Color")
color_lower_2_3 = input.color(color.new(#bdbc9d, 80), title="Lower Band 2–3 Color")
color_lower_3_4 = input.color(color.new(#e9e6bf, 63), title="Lower Band 3–4 Color")
// === Bollinger Band Calculations ===
sma = ta.sma(src, bb_length)
stdev = ta.stdev(src, bb_length)
bb2_upper = sma + 2 * stdev
bb2_lower = sma - 2 * stdev
bb3_upper = sma + 3 * stdev
bb3_lower = sma - 3 * stdev
bb4_upper = sma + 4 * stdev
bb4_lower = sma - 4 * stdev
// === Hidden Plots for Fill ===
p_bb2_upper = plot(bb2_upper, color=na)
p_bb3_upper = plot(bb3_upper, color=na)
p_bb4_upper = plot(bb4_upper, color=na)
p_bb2_lower = plot(bb2_lower, color=na)
p_bb3_lower = plot(bb3_lower, color=na)
p_bb4_lower = plot(bb4_lower, color=na)
// === Band Zone Fills ===
fill(p_bb2_upper, p_bb3_upper, color=color_upper_2_3)
fill(p_bb3_upper, p_bb4_upper, color=color_upper_3_4)
fill(p_bb2_lower, p_bb3_lower, color=color_lower_2_3)
fill(p_bb3_lower, p_bb4_lower, color=color_lower_3_4)
//SMc
BULLISH_LEG = 1
BEARISH_LEG = 0
BULLISH = +1
BEARISH = -1
GREEN = #9c9c9c
RED = #9c9c9c
BLUE = #9c9c9c
GRAY = #ffffff
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b
HISTORICAL = 'Historical'
PRESENT = 'Present'
COLORED = 'Colored'
MONOCHROME = 'Monochrome'
ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'
TINY = size.tiny
SMALL = size.small
NORMAL = size.normal
ATR = 'Atr'
RANGE = 'Cumulative Mean Range'
CLOSE = 'Close'
HIGHLOW = 'High/Low'
SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'
SMART_GROUP = 'Smart Money Concepts'
INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'
modeTooltip = 'Allows to display historical Structure or only the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart'
modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = )
styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = )
showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip)
showInternalsInput = input( true, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = )
internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = )
internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = )
showStructureInput = input( true, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = )
swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = )
swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = )
showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( true, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)
showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob')
internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( false, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = )
internalBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Bullish OB', group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Bearish OB', group = BLOCKS_GROUP)
showEqualHighsLowsInput = input( true, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = )
showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = )
dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = )
weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = )
monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly')
showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP)
//---------------------------------------------------------------------------------------------------------------------}
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------------------------------------------{
// @type UDT representing alerts as bool fields
// @field internalBullishBOS internal structure custom alert
// @field internalBearishBOS internal structure custom alert
// @field internalBullishCHoCH internal structure custom alert
// @field internalBearishCHoCH internal structure custom alert
// @field swingBullishBOS swing structure custom alert
// @field swingBearishBOS swing structure custom alert
// @field swingBullishCHoCH swing structure custom alert
// @field swingBearishCHoCH swing structure custom alert
// @field internalBullishOrderBlock internal order block custom alert
// @field internalBearishOrderBlock internal order block custom alert
// @field swingBullishOrderBlock swing order block custom alert
// @field swingBearishOrderBlock swing order block custom alert
// @field equalHighs equal high low custom alert
// @field equalLows equal high low custom alert
// @field bullishFairValueGap fair value gap custom alert
// @field bearishFairValueGap fair value gap custom alert
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false
// @type UDT representing last swing extremes (top & bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
// @type UDT representing Fair Value Gaps
// @field top top price
// @field bottom bottom price
// @field bias bias (BULLISH or BEARISH)
// @field topBox top box
// @field bottomBox bottom box
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox
// @type UDT representing trend bias
// @field bias BULLISH or BEARISH
type trend
int bias
// @type UDT representing Equal Highs Lows display
// @field l_ine displayed line
// @field l_abel displayed label
type equalDisplay
line l_ine = na
label l_abel = na
// @type UDT representing a pivot point (swing point)
// @field currentLevel current price level
// @field lastLevel last price level
// @field crossed true if price level is crossed
// @field barTime bar time
// @field barIndex bar index
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
// @type UDT representing an order block
// @field barHigh bar high
// @field barLow bar low
// @field barTime bar time
// @field bias BULLISH or BEARISH
type orderBlock
float barHigh
float barLow
int barTime
int bias
// @variable current swing pivot high
var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array fairValueGaps = array.new()
// @variable storage for parsed highs
var array parsedHighs = array.new()
// @variable storage for parsed lows
var array parsedLows = array.new()
// @variable storage for raw highs
var array highs = array.new()
// @variable storage for raw lows
var array lows = array.new()
// @variable storage for bar time values
var array times = array.new()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing order blocks)
var array swingOrderBlocks = array.new()
// @variable storage for orderBlock UDTs (internal order blocks)
var array internalOrderBlocks = array.new()
// @variable storage for swing order blocks boxes
var array swingOrderBlocksBoxes = array.new()
// @variable storage for internal order blocks boxes
var array internalOrderBlocksBoxes = array.new()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time
// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
// @variable source to use in bearish order blocks mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high
// @variable source to use in bullish order blocks mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)
//---------------------------------------------------------------------------------------------------------------------}
//USER-DEFINED FUNCTIONS
//---------------------------------------------------------------------------------------------------------------------{
// @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish)
// @returns int
leg(int size) =>
var leg = 0
newLegHigh = high > ta.highest( size)
newLegLow = low < ta.lowest( size)
if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg
// @function Identify whether the current value is the start of a new leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0
// @function Identify whether the current level is the start of a new bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1
// @function Identify whether the current level is the start of a new bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1
// @function create a new label
// @param labelTime bar time coordinate
// @param labelPrice price coordinate
// @param tag text to display
// @param labelColor text color
// @param labelStyle label style
// @returns label ID
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) =>
var label l_abel = na
if modeInput == PRESENT
l_abel.delete()
l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small)
// @function create a new line and label representing an EQH or EQL
// @param p_ivot starting pivot
// @param level price level of current pivot
// @param size how many bars ago was the current pivot detected
// @param equalHigh true for EQH, false for EQL
// @returns label ID
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay
string tag = 'EQL'
color equalColor = swingBullishColor
string labelStyle = label.style_label_up
if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down
if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)
e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput)
// @function store current structure and trailing swing points, and also display swing points and equal highs/lows
// @param size (int) structure size
// @param equalHighLow (bool) true for displaying current highs/lows
// @param internal (bool) true for getting internal structures
// @returns label ID
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)
if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow
if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low , size, false)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh
if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high ,size,true)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)
// @function draw line and label representing a structure
// @param p_ivot base pivot point
// @param tag test to display
// @param structureColor base color
// @param lineStyle line style
// @param labelStyle label style
// @param labelSize text size
// @returns label ID
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)
if modeInput == PRESENT
l_ine.delete()
l_abel.delete()
l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle)
l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize)
// @function delete order blocks
// @param internal true for internal order blocks
// @returns orderBlock ID
deleteOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
for in orderBlocks
bool crossedOderBlock = false
if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)
// @function fetch and store order blocks
// @param p_ivot base pivot point
// @param internal true for internal order blocks
// @param bias BULLISH or BEARISH
// @returns void
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput)
array a_rray = na
int parsedIndex = na
if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())
orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias)
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
if orderBlocks.size() >= 100
orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)
// @function draw order blocks as boxes
// @param internal true for internal order blocks
// @returns void
drawOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
orderBlocksSize = orderBlocks.size()
if orderBlocksSize > 0
maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize))
array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes
for in parsedOrdeBlocks
orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor)
box b_ox = b_oxes.get(index)
b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow))
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)
// @function detect and draw structures, also detect and store order blocks
// @param internal true for internal structures or order blocks
// @returns void
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true
if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)
pivot p_ivot = internal ? internalHigh : swingHigh
trend t_rend = internal ? internalTrend : swingTrend
lineStyle = internal ? line.style_dashed : line.style_solid
labelSize = internal ? internalStructureSize : swingStructureSize
extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput
if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS
if internal
currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BULLISH
displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)
p_ivot := internal ? internalLow : swingLow
extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput
if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS
if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BEARISH
displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)
// @function draw one fair value gap box (each fair value gap has two boxes)
// @param leftTime left time coordinate
// @param rightTime right time coordinate
// @param topPrice top price level
// @param bottomPrice bottom price level
// @param boxColor box color
// @returns box ID
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor)
// @function delete fair value gaps
// @returns fairValueGap ID
deleteFairValueGaps() =>
for in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)
// @function draw fair value gaps
// @returns fairValueGap ID
drawFairValueGaps() =>
= request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on)
barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)
newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0
bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe
if bullishFairValueGap
currentAlerts.bullishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor)))
// @function get line style from string
// @param style line style
// @returns string
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
// @function draw MultiTimeFrame levels
// @param timeframe base timeframe
// @param sameTimeframe true if chart timeframe is same as base timeframe
// @param style line style
// @param levelColor line and text color
// @returns void
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
= request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on)
float parsedTop = sameTimeframe ? high : topLevel
float parsedBottom = sameTimeframe ? low : bottomLevel
int parsedLeftTime = sameTimeframe ? time : leftTime
int parsedRightTime = sameTimeframe ? time : rightTime
int parsedTopTime = time
int parsedBottomTime = time
if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex = times.binary_search_rightmost(parsedRightTime)
array timeArray = times.slice(leftIndex,rightIndex)
array topArray = highs.slice(leftIndex,rightIndex)
array bottomArray = lows.slice(leftIndex,rightIndex)
parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime
var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
// @function true if chart timeframe is higher than provided timeframe
// @param timeframe timeframe to check
// @returns bool
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
// @function update trailing swing points
// @returns int
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime
// @function draw trailing swing points
// @returns void
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny)
rightTimeBar = last_bar_time + 20 * (time - time )
topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High')
bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low')
// @function draw a zone with a label and a box
// @param labelLevel price level for label
// @param labelIndex bar index for label
// @param top top price level for box
// @param bottom bottom price level for box
// @param tag text to display
// @param zoneColor base color
// @param style label style
// @returns void
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)
b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))
l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))
// @function draw premium/discount zones
// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down)
equilibriumLevel = math.avg(trailing.top, trailing.bottom)
drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left)
drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up)
//---------------------------------------------------------------------------------------------------------------------}
//MUTABLE VARIABLES & EXECUTION
//---------------------------------------------------------------------------------------------------------------------{
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor)
if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()
if showHighLowSwingsInput
drawHighLowSwings()
if showPremiumDiscountZonesInput
drawPremiumDiscountZones()
if showFairValueGapsInput
deleteFairValueGaps()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showInternalOrderBlocksInput or showTrendInput
displayStructure(true)
if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput
displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)
if showSwingOrderBlocksInput
deleteOrderBlocks()
if showFairValueGapsInput
drawFairValueGaps()
if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)
if showSwingOrderBlocksInput
drawOrderBlocks()
lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex
if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)
if showDailyLevelsInput and not higherTimeframe('D')
drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)
if showWeeklyLevelsInput and not higherTimeframe('W')
drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)
if showMonthlyLevelsInput and not higherTimeframe('M')
drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)
//---------------------------------------------------------------------------------------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed')
alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed')
//---------------------------------------------------------------------------------------------------------------------}
Percentage Change per 5 Candles
🔎 What this indicator does
This indicator calculates and displays the percentage change of each candlestick directly on the chart.
• If a candle closed higher than it opened (bullish candle), it shows a positive % change (green).
• If a candle closed lower than it opened (bearish candle), it shows a negative % change (red).
• Small moves below your chosen threshold (e.g., 0.1%) are ignored to avoid clutter.
• The labels are placed above, below, or in the center of the candle (you choose).
So essentially, every candle “tells you in numbers” exactly how much it changed relative to its opening price.
________________________________________
⚙️ How it operates (the logic inside)
1. Calculate the change
o Formula:
\text{% Change} = \frac{(\text{Close} - \text{Open})}{\text{Open}} \times 100
o Example: If a candle opens at 100 and closes at 105, that’s a +5% change.
2. Round it nicely
o You can control decimals (e.g., show 2 decimals → +5.23%).
3. Filter out noise
o If a candle barely moved (say 0.02%), the label won’t appear unless you reduce the threshold.
4. Style the labels
o Bullish = green text, slightly transparent green background.
o Bearish = red text, slightly transparent red background.
o Neutral (0%) = gray.
5. Place the labels
o Options: above the candle, below the candle, or centered.
o Small vertical offset is applied so labels don’t overlap the candle itself.
________________________________________
📊 How this helps traders
This indicator turns visual candles into quantifiable numbers at a glance. Instead of guessing whether a move was “big” or “small,” you see it clearly.
Key Benefits:
1. Quick volatility analysis
o You can instantly see if candles are making big % swings or just small moves.
o This is especially useful on higher timeframes (daily/weekly) where moves can be large.
2. Pattern confirmation
o For example, you might spot a strong bullish engulfing candle — the % change label helps confirm whether it was truly significant (e.g., +4.5%) or just modest (+0.7%).
3. Noise filtering
o By setting a minimum % threshold, you only see labels when moves are meaningful (say > 0.5%). This keeps focus on important candles.
4. Backtesting & comparison
o You can compare moves across time:
“How strong was this breakout candle compared to the last one?”
“Are today’s bearish candles weaker or stronger than yesterday’s bullish candles?”
5. Better decision-making
o If you’re trading breakouts, reversals, or trend-following, knowing the % size of each candle helps confirm if the move has enough momentum.
________________________________________
✅ In short:
This indicator quantifies price action. Instead of just seeing “green” or “red” candles, you now know exactly how much the price changed in percentage terms, directly on the chart, in real time. It helps you distinguish between strong and weak moves and makes your analysis more precise.
________________________________________
VIX Stoch RSI Oscillator [HUD Box + Compression]vix stoch rsi Oscillator
watch volatility without switching charts,
gives signal based off fib levels 0-100 / volatility,
emoji box to show signal,
HUD Box: emoji-coded tactical feedback
bounce 100 "💥 Expansion" :
bounce 0.8 "🔴 Overbought" :
bounce 0.618 "📉 Distribution" :
bounce 0.5 "🧠 Midline" :
bounce 0.382 "📈 Accumulation" :
bounce 0.2 "🟢 Oversold" :
bounce0.0 "💣 Expansion" : "⚪ Neutral"
Tiger EMA/STOCH
This logic checks if the oscillator is trending above or below its 48-period EMA,
If above, it paints the line GREEN🟢 (bullish),
If below, it paints it RED🔴 (bearish),
If compression is active, it overrides both with purple🟣 to highlight tactical squeeze conditions,
⚠️WARNING⚠️
ALWAYS REMEMBER THIS CHART IS VIX/USD
IN MOST CASES SPY MOVES VICE VERSA
I AM NOT RESPOSIBLE FOR YOUR OWN ACTIONS/TRADE IDEAS
AMEX:USD
TVC:VIX
SP:SPX
