Get started

Indicators and strategies

Adaptive AI SuperTrend [AlgoPoint]🚀 Adaptive AI SuperTrend Adaptive AI SuperTrend is a high-performance trading terminal that redefines trend-following by integrating Machine Learning (ML) principles with advanced market regime detection. Unlike static indicators, this system dynamically recalibrates its internal parameters to match the ever-changing volatility of the financial markets. Equipped with a custom "Wizard Engine," it filters out market noise during consolidation and identifies high-probability trend continuation points, making it an essential tool for scalpers, day traders, and swing traders alike. 🧠 What Makes it "AI"? While traditional indicators use fixed rules, Adaptive AI SuperTrend utilizes Algorithmic Intelligence to make real-time decisions: KNN-Inspired Adaptation: The engine analyzes the last 150 bars of volatility and trend strength to automatically adjust its sensitivity. Market Regime Intelligence: It distinguishes between "Trending" and "Ranging" states using a sophisticated Squeeze Momentum module, preventing "whipsaws" during low-volume periods. Self-Backtesting Logic: The indicator continuously calculates its own historical Win-Rate. If the probability of success falls below a certain threshold, it suppresses lower-quality signals. 🛠 Key Features Dynamic Consolidation Boxes: Automatically identifies and wraps "choppy" price action in professional gray boxes. It waits for 3+ bars of consolidation before marking the zone, helping you spot breakout opportunities early. Multi-Strategy Aggression: - Conservative: Filtered signals for long-term trend following. - Balanced: Optimized for daily volatility. - Aggressive: High-frequency signals for capturing micro-trends. Dual-Exit Risk Management: - ATR TP-SL Mode: Sets mathematical targets based on market volatility with persistent on-screen lines. - Smart Trailing Mode: Rides the trend to its exhaustion point. Includes intelligent labeling (🎯 TP or 🛑 SL) based on the trade's net profitability. - RSI Pullback Confirmation: Beyond simple trend flips, it detects "buy the dip" or "sell the rip" opportunities within an existing trend using RSI 50-level crossovers. 📊 Real-Time Analytics Dashboard The integrated AlgoPoint Dashboard provides a surgical view of the market: - Market State: Instant "Trending" vs. "Ranging" (Consolidation) detection. - Trend Strength: ADX-based momentum tracking. - Strategy Status: Real-time feedback on your active aggression and exit modes. 🎨 Clean Charting & Customization Built for professional clarity, you have total control over the UI: Toggle Consolidation Boxes on/off. Toggle ATR Target Lines and Exit Labels. Customize background filters and dashboard visibility.
Pine Script® indicator
by Iamalala
ES Gamma LevelsES Gamma Levels - Dynamic Options Flow Visualization This indicator displays gamma exposure levels from SPY options data, automatically scaled to ES/MES futures prices. Simply copy gamma data from your dashboard and paste it into the indicator to see key support and resistance levels based on dealer positioning. Features: - Automatic SPY to ES price conversion using live 1-minute ratios - Visual strength indicators - thicker/longer lines show stronger gamma concentrations - Customizable colors for positive and negative gamma levels - Dotted reference lines extending across the chart for easy price tracking - Updates every minute to prevent chart clutter and jumping levels - Filters to show only significant levels above your threshold - Strongest positive and negative levels are automatically highlighted The solid colored lines represent gamma strength - longer lines indicate higher concentration at that price level. Dotted lines provide continuous reference points across your chart. Green levels typically act as support (dealers long gamma), while red levels often act as resistance (dealers short gamma). Best used on 1-5 minute timeframes for intraday trading. Paste fresh data from your options flow dashboard whenever you want updated levels.
Pine Script® indicator
by cryptocake
Dealing Range Auto-Zone v2.1Dealing Range Auto-Zone v2.1 - Summary Purpose: Automatically creates zone-based support/resistance levels within a dealing range using percentage-based spacing with ATR-driven recommendations. How It Works: Click two points to define dealing range (high and low) Set step % (e.g., 0.25% = one zone every 0.25% move) Indicator calculates exact zone count and draws upper/lower zone boundaries Optional center lines show midpoint of each zone Key Features: Zone-based S/R - Upper and lower boundaries instead of single lines (creates "price zones" rather than precise levels) Auto-calculated spacing - Uses exact % steps with math.round() for optimal coverage (minimizes gaps near boundaries) Adjustable zone width - Default 50% of step (e.g., 0.25% step = 0.125% zone width on each side) Ghost zones - Extends zones above/below range for anticipating breakouts ATR-based recommendations - Calculates Daily ATR and suggests Tight/Balanced/Wide step % based on current volatility Smart validation - Compares your step % to ATR recommendations and shows if it's appropriate for current market conditions Use Case: Converts dealing ranges into tradeable S/R zones for 15s-5m intraday scalping. Makes it clear when price is "in a zone" vs "at a precise line." Ideal for MNQ, MGC, and other liquid futures/crypto. Version 2.1 Changes: New Features: Daily ATR calculation with automatic Tight/Balanced/Wide step % recommendations Volatility-based auto-recommendations (compares ATR(14) vs ATR(50)) Smart validation system that evaluates your step % choice and provides feedback Info table shows all three ATR recommendations (Tight/Balanced/Wide) Improvements: Changed from math.floor() to math.round() for zone count calculation (eliminates gaps near boundaries) Streamlined info table (removed redundant rows: Range points, Step %, Total Lines) Added color-coded validation (green checkmark for appropriate settings, orange warning for extreme values) Bug Fixes: Fixed tooltip compilation error (moved dynamic ATR data to info table only) Corrected validation logic to properly categorize step % ranges Info Table Now Shows: Range % (dealing range size as %) Exact Zones (calculated, including fractional) Zones Drawn (rounded to nearest whole number) Zone Width (in price points and % of step) Daily ATR (value and %) Auto Rec (all three recommendations: T/B/W) Your Step (with validation: ✓ Tight/Balanced/Wide or ⚠️ Very Tight/Wide)
Pine Script® indicator
by dcardona1
FLOW DEPTH Price BreathingFLOW DEPTH is a visual, psychology-based indicator designed to reveal how the market breathes through phases of compression and expansion. Instead of relying on traditional trend lines or lagging indicators, it focuses on the depth of price movement around its natural balance, allowing traders to feel market rhythm rather than chase signals. The indicator paints a smooth flow line and subtle background shading to highlight whether the market is exhaling (expansion) or inhaling (compression). This creates a calm, premium chart experience while still delivering meaningful insight into momentum and price behavior. FLOW DEPTH is ideal for traders who prefer clean charts, visual clarity, and market structure awareness without clutter. It works especially well on XAUUSD, BTC, and major forex pairs, across intraday and swing timeframes. 🔍 How to Use Green flow → Market is expanding (momentum phase) Red flow → Market is compressing (rest phase) Flow shift dots → Transition between market phases Use FLOW DEPTH as a context tool, not a signal generator. Combine it with price action, structure, or session logic for best results.
Pine Script® indicator
by XAU_EMPIRE
Daily Bias Panel (with MTF Toggle)Daily Bias Panel Documentation Overview The Daily Bias Panel is a TradingView indicator designed to provide a structured, multi factor assessment of market direction for intraday and swing traders. It consolidates several key bias components—Prior Day levels, VWAP, Overnight High/Low, Multi Timeframe Market Structure, and an Overall Bias—into a clean, compact table. A confidence meter summarizes the combined strength of all signals. This document explains each line item, the rules behind it, and how to interpret the panel. 1. Prior Day Bias Definition Compares the current price to the previous day’s high and low. Rules • Bullish (1): Close > Prior Day High • Bearish (-1): Close < Prior Day Low • Neutral (0): Price is between the prior high and low Interpretation This bias reflects whether the market is breaking out above or below the previous day’s range. It is a foundational directional signal. 2. VWAP Bias Definition Measures whether price is trading above or below the Volume Weighted Average Price. Rules • Bullish (1): Close > VWAP • Bearish (-1): Close < VWAP • Neutral (0): Price is at VWAP Interpretation VWAP is a widely used institutional benchmark. Trading above VWAP suggests buyers are in control; below VWAP suggests sellers dominate. 3. ONH / ONL Bias (Overnight High / Low) Definition Tracks the overnight session’s high and low (18:00–09:30 ET) and compares current price to those levels. Rules • Bullish (1): Close > Overnight High • Bearish (-1): Close < Overnight Low • Neutral (0): Price is inside the overnight range Interpretation ONH/ONL is extremely important for index futures (ES/NQ). Breaking ONH/ONL often signals strong directional intent at the RTH open. 4. Struct MTF (Market Structure Bias) Definition A weighted blend of market structure trends across multiple timeframes. Modes Swing Mode • 4H (50%) • 1H (30%) • 15M (20%) Intraday Mode • 1H (40%) • 15M (35%) • 5M (25%) Rules Each timeframe is classified as: • Bullish (1): Higher High + Higher Low • Bearish (-1): Lower High + Lower Low • Neutral (0): No clear structure The weighted average produces a final structure score. Interpretation This is your trend engine. It smooths noise and provides a stable directional backbone. 5. Overall Bias Definition A strict agreement filter between Prior Day Bias and VWAP Bias. Rules • Bullish (1): Both Prior Day and VWAP are bullish • Bearish (-1): Both are bearish • Neutral (0): Any disagreement Interpretation This prevents false positives by requiring alignment between two major bias components. 6. Confidence Score Definition A weighted blend of all bias components: • Prior Day (25%) • VWAP (25%) • ONH/ONL (20%) • MTF Structure (30%) Output A normalized score between -1.00 and +1.00. Interpretation • +1.00: Strong bullish alignment across all systems • -1.00: Strong bearish alignment • 0.00: Mixed or unclear conditions 7. Confidence Meter (10 Square Visual) Definition A visual representation of the confidence score. Rules • 0–10 squares filled based on absolute confidence • Color reflects direction (green/red/yellow) Interpretation A quick glance gauge of trend strength. 8. Debug Mode (Optional) Purpose Displays all underlying levels and bias markers directly on the chart. Includes • Prior High / Low • VWAP • ONH / ONL • Confidence Score line • Bias markers (P, V, O, M) Use Case Great for verifying logic, backtesting visually, and understanding how each component behaves. 9. Panel Layout & Spacing Top Left Spacer System When the panel is placed in the top left corner, a 3 row spacer pushes it below the chart header and indicator dropdown. Panel Size Options • Small • Medium • Large These adjust font sizes and meter padding. ______________________________________________________________________________ Summary The Daily Bias Panel is a compact, multi factor decision tool that blends: • Prior Day context • VWAP positioning • Overnight session dynamics • Multi timeframe trend structure • A strict overall bias filter • A confidence scoring engine Together, these components give traders a clear, structured view of market direction and strength. This documentation should serve as a complete reference for understanding, using, and publishing the indicator.
Pine Script® indicator
by WaveWalker1
Williams %R with Head & Shoulders Pattern DetectionWhat makes this indicator special? This indicator merges two proven trading concepts into one powerful tool: 1️⃣ Smoothed Williams %R The classic Williams %R momentum oscillator is smoothed by an EMA to reduce market noise and deliver cleaner signals. The result: fewer false signals, better readability. 2️⃣ Automatic Pattern Recognition The indicator continuously scans for the two most powerful reversal formations in technical analysis: 🔴 Head & Shoulders (Bearish) → Short signals 🟢 Inverse Head & Shoulders (Bullish) → Long signals Why detect patterns in the oscillator instead of the chart? Pattern formations in Williams %R often emerge earlier than in the price chart itself. The momentum oscillator reveals weakness or strength before it manifests in price – a crucial timing advantage. Features at a Glance 📊Dual Signal SystemCombines pattern-based entries with classic crossover signals 🎨 Full VisualizationShoulders, head, neckline, and entry levels are automatically drawn⚙️ Customizable ParametersSymmetry tolerance, pattern size, and visualization individually adjustable 🔔 Alert-ReadyPre-configured alerts for all signal types 📋 Live Status TableDisplays detected patterns and current %R value in real-time Signal Logic Pattern Entries: SHORT: H&S detected + Williams %R crosses neckline downward LONG: Inverse H&S detected + Williams %R crosses neckline upward Simple Entries (additional): Crossover at -80 (oversold → Long) Crossunder at -23 (overbought → Short) Recommended Settings Default values are optimized for most timeframes. For higher timeframes (4H+), consider increasing shoulder tolerance to 20%. ⚠️ Disclaimer: This indicator is an analysis tool and not financial advice. Always combine signals with your own risk management and additional analysis.
Pine Script® indicator
by ThePipsMaker_
Market Waves [Smart Trend & Signals]Market Waves Overview Market Waves is a comprehensive technical analysis tool designed to identify market trends with minimal lag while filtering out noise. By combining a modified Hull Moving Average (HMA) with Volatility Bands (ATR), this indicator provides a clear visual representation of market direction, entry signals, and automated Take Profit targets. Key Features 1. Low-Lag Trend Detection The core of this indicator uses a custom HMA variation to smooth out price action without the delay common in standard moving averages. • Bullish Trend: The trend ribbon turns Teal when price breaks above the lower volatility band. • Bearish Trend: The trend ribbon turns Red when price breaks below the upper volatility band. 2. Smart Signals & Power Filter The indicator generates two types of signals to help you gauge entry quality: • Standard Signals (BUY / SELL): Generated purely on trend reversals. Good for early entries. • Power Signals (BUY+ / SELL+): These are high-probability setups that pass a multi-factor filter: • Trend Confirmation: The primary trend must flip. • RSI Momentum: RSI must be above 50 (for Buy) or below 50 (for Sell). • Volume Spike: Volume must exceed the 20-period average (optional in settings). 3. Automated Take Profit Targets Upon every new signal, the indicator automatically projects three Take Profit levels based on market volatility (ATR) at the moment of entry: • TP1: Conservative target (1x Risk). • TP2: Moderate target (2x Risk). • MAX PROFIT: Aggressive target (4x Risk). 4. Accumulation Bar Coloring Candles are colored to reflect the true strength of the move: • Teal/Red: Strong trend active. • Gray: Accumulation or consolidation phase. This helps traders avoid chopping markets or weak signals. 5. Confidence Score A dynamic percentage (50% - 99%) is displayed above signals, calculated based on the steepness and momentum of the wave change, giving you an instant metric of the trend's initial strength. How to Use 1. Identify Trend: Look at the colored ribbon. Do not trade against the ribbon color. 2. Wait for Signals: Look for "BUY" or "SELL" labels. For higher accuracy, wait for the "+" signals (e.g., "BUY+"). 3. Confirm with Color: Ensure the bar color is not Gray (Weak/Accumulation). A Teal bar confirms a Buy; a Red bar confirms a Sell. 4. Manage Trade: Use the trend ribbon as a trailing stop-loss and the projected TP lines for exiting positions. Settings • Wave Length: Adjusts the smoothness of the trend (Default: 24). • Sensitivity Factor: Multiplier for the ATR bands. Higher values reduce false signals but may delay entry (Default: 2.0). • Show Signals/TP: Toggles for visual elements to keep the chart clean.
Pine Script® indicator
by hakmaldabagh0
Iceberg strategy 2.0🇬🇧 Iceberg Strategy — Description (EN) Iceberg Strategy is a multi-timeframe trend-following and liquidity-based trading indicator designed for crypto markets. It combines H4 trend structure, MACD momentum, volume analysis, correlation filtering, and retest logic to identify high-probability entries aligned with institutional activity. The indicator focuses on filtering out low-quality signals by using 24H USD volume, BTC correlation, and buyer/seller dominance (Volume Fight), while providing clear risk management visualization with automatic Stop Loss and Take Profit levels. 🔍 Core Logic H4 MACD Trend Detection Identifies bullish and bearish market regimes Uses both standard and fast MACD to detect trend continuation and gray (transition) zones Gray Zone Trend Re-entry Detects pullbacks inside an active trend Generates continuation entries when momentum resumes Volume Fight (Liquidity Analysis) Compares bullish vs bearish volume using VWMA Detects accumulation and distribution zones Optional background highlighting 24H USD Volume Filter Ensures trading only high-liquidity assets Filters out low-volume and manipulated markets Correlation Filter Filters signals when correlation with BTC (or selected symbol) is too high Allows excluding specific symbols from correlation checks H1 Retest Entries Detects retests of key price levels after breakout Confirms entries only after successful retest 📈 Signals & Visuals BUY / SELL labels for main trend entries Triangle signals for retest entries Colored H4 candles Green — bullish trend Red — bearish trend Gray — transition / pullback zone Volume Fight background zones (optional) Information table with: H4 Trend direction Fast MACD value Correlation value 24H USD volume 🛡 Risk Management Automatic Stop Loss Based on ATR with configurable multiplier Multiple Take Profit levels RR-based targets (TP1–TP5) SL and TP lines can be enabled or disabled from settings ⚙️ Fully Configurable Enable / disable: Correlation filter Volume filter Volume Fight background Stop Loss / Take Profit lines Adjustable parameters for: ATR Correlation Volume thresholds Retest logic ⚠️ This indicator does not repaint signals and is intended for educational and analytical purposes only. Always use proper risk management.
Pine Script® indicator
by Alex8181999
Dealing Range Auto-Zone v2.0Dealing Range Auto-Zone v2.0 - Summary Purpose: Automatically creates zone-based S/R levels within a dealing range using percentage-based spacing. How It Works: Click two points (DR high and DR low) Set step % (e.g., 0.25% = one line every 0.25% move) Indicator calculates exact line count and draws zones Key Features: Zone-based S/R - Upper/lower boundaries with optional center line Auto-calculated spacing - Uses exact % steps (no rounding) Zone width - Adjustable (default 10% of step = half-step on each side) Ghost zones - Extends zones above/below DR Consistent zones - All zones same width throughout range Use Case: Converts dealing ranges into tradeable S/R zones instead of precise lines. Makes it clear when price is "in a zone" vs "at a line." Settings: Step %: 0.25% (for MNQ, creates ~15-20 zones in 4% DR) Zone Width: 50% of step Center Line: Off (toggle on to show middle)
Pine Script® indicator
by dcardona1
golden zone indicator by tltradeInstallation Instructions - Golden Zone Indicator Step 1: Open TradingView Go to TradingView.com Create a free account (or log in). Open the chart for XAUUSD (Gold). Step 2: Open Pine Script Editor At the bottom of the chart, click "Pine Editor." If you don't see it, click the three dots at the bottom and select "Pine Editor." Step 3: Add the Indicator Delete all existing code in the editor (Ctrl+A, then Delete). Open the file GoldenZone_Indicator.pine. Copy ALL the code (Ctrl+A, then Ctrl+C). Paste it into the Pine Editor (Ctrl+V). Click "Add to chart" (or press Ctrl+Enter). Step 4: Finished! The indicator will now display: Colored backgrounds (Green = Uptrend, Red = Downtrend) Colored boxes (Green = Buy Zones, Red = Sell Zones) Arrows (Blue up = Buy, Red down = Sell) Info panel in the top right corner. How to Read the Chart +----------------------------------+ | GOLDEN ZONE | | Trend: BULLISH | <- Follow this! | Session: ACTIVE | <- Good time to trade | Zone: BUY ZONE | <- Wait for a signal | ATR: 15.50 | +----------------------------------+ Setting Up Alerts Right-click on the chart. Select "Add alert..." Under "Condition," select "Golden Zone Strategy." Choose the alert type: Buy Signal Sell Signal New Buy Zone New Sell Zone Click "Create." Customizing Settings Click the gear icon next to the indicator name: Setting Function Default EMA Length Trend sensitivity 20 Zone Strength More/fewer zones 1.5 Require Trend Alignment Stricter signals ON Recommended Timeframes Timeframe Best For M15 (15-min) Day trading (Beginners) H1 (1-hour) Swing trading H4 (4-hour) Position trading Troubleshooting Indicator not appearing? Ensure you clicked "Add to chart." Check if the indicator is visible (eye icon). Zones not showing up? Zoom out to see more price action. Zones only form after strong price movements. No signals? Wait for the price to enter a zone. Check if "Show Signals" is enabled in settings. Files in This Package File Description GoldenZone_Indicator.pine Indicator code for TradingView GoldenZone_Strategy.md Full strategy explanation INSTALL_GUIDE.md These installation instructions Next Steps Read GoldenZone_Strategy.md for all the trading rules. Practice on a demo account first. Start with the M15 timeframe. Trade during the London or New York sessions. Always use a stop loss. Good luck!
Pine Script® indicator
by lipovsektin
Footprint OverlayFootprint Overlay Visualize order flow at individual price levels with real-time Bid x Ask, Delta, or Total Volume data Overview Footprint Overlay is an order flow indicator that displays volume information at each price level within a candle, directly on your chart. Choose between Delta (buying pressure minus selling pressure), Bid x Ask (sell volume vs. buy volume), or Total Volume per level. This granular, level-by-level view reveals where institutional activity is concentrated, helping you identify key support and resistance zones based on actual order flow. Key Features Multiple Display Modes: Choose how you want to see the data: Delta: Shows net buying or selling pressure at each level (Buy Volume - Sell Volume). Bid x Ask: Displays sell volume vs. buy volume side-by-side (e.g., "150 x 230"). Total Volume: Shows the combined buy and sell volume at each level. Native Footprint Support (v6): For supported symbols, enable TradingView's native footprint data for accurate bid/ask volume attribution. Intrabar Delta Calculation: When native footprint data is unavailable, the indicator uses lower timeframe intrabar data to estimate delta at each price level using proprietary logic that considers candle body, wicks, and price action. Adaptive Tick Sizing: Automatically calculates an appropriate tick size (row height) based on asset type (crypto, forex, futures, etc.) and chart timeframe. Manual override is also available. Gradient Mode: Optionally scale box opacity relative to the maximum value in the candle, making it easy to spot the most significant levels at a glance. Customizable Colors: Set distinct colors for bullish (positive delta) and bearish (negative delta) levels. Value Filtering: Hide levels where the displayed value is below a specified magnitude to reduce noise. Label Display: Show delta or volume values directly on each level with K/M formatting for readability. How It Works Level Creation: For each confirmed candle, the indicator divides the price range into multiple levels. The number and size of levels are determined by ATR or adaptive tick calculations. Data Collection: If native footprint data is enabled, the indicator uses TradingView's footprint API to get accurate bid/ask volumes per row. Otherwise, it requests lower timeframe intrabar data (OHLCV) to analyze price action within the main candle. Delta Calculation: For intrabar mode, delta is calculated using proprietary logic that considers body size, wicks, and price action characteristics. Volume is distributed proportionally across all price levels the intrabar crosses. Visualization: Each price level is rendered as a colored box. The color indicates direction (bullish/bearish), and the text shows the value based on your selected display mode. Use Cases Support and Resistance Identification: Large delta or volume concentrations at specific price levels often indicate significant support or resistance zones where institutional traders are active. Order Flow Analysis: Understand where buying and selling pressure is concentrated within each candle, helping identify potential reversal or continuation zones. Entry and Exit Timing: Use footprint data to identify optimal entry and exit points based on actual order flow, not just price action. Confirmation Tool: Combine with other technical analysis tools. For example, a strong bullish delta at a support level can confirm a potential bounce. Settings Display Mode: Choose between Delta, Bid x Ask, or Total Volume. Show Delta Labels: Toggle to show/hide value labels on each level. Gradient Mode: Scale box opacity relative to the max value in the candle. Max Opacity: Control the maximum opacity for level boxes. Font Size: Adjust the text size for labels. Min Value to Show: Filter out levels with values below this magnitude. Max Bars to Draw: Limit drawing to the last N bars to prevent object limits. Bullish/Bearish Delta Color: Customize colors for bullish and bearish levels. Text Color: Customize the text color for labels. Use Footprint Data (v6): Enable TradingView's native footprint data for supported symbols. Tick Size Mode: Choose between Auto or Manual tick sizing. Tick Density Multiplier: Adjust the density of price levels. Manual Footprint Ticks: Set a fixed tick size when in Manual mode. Technical Notes The indicator updates in real-time as new intrabar data comes in, providing a live view of order flow on the current candle. Drawing is limited to the last N bars (configurable) to avoid exceeding TradingView's object limits. Adaptive tick sizing considers asset type and timeframe for optimal granularity. Native footprint mode provides the most accurate bid/ask attribution; intrabar mode is a best-effort estimate. Level size in intrabar mode is calculated using ATR(14) divided by 10, adapting to current market volatility.
Pine Script® indicator
by mindyourbuisness
TheStrat Suite: Price Action Signals & AlertsWhether you're new to Price Action trading or an old vet, you're used to marking up charts. Switching between timeframes. Manually setting alerts. And then doing it all again. TheStrat Suite gives you everything you need to analyze and act on setups across multiple timeframes, all in one place. Full Analysis in a Single View: see candle combos, timeframe continuity, and actionable signals across six timeframes, no chart-hopping required Your Charts, Fully Marked Up: automatically mark entries, targets (magnitude and exhaustion levels), and take action windows Automatically Adapts as the Market Changes: see when targets are hit, setups invalidate, or new setups form Alerts That Are All Signal, No Noise: filter by timeframe continuity, actionable signals, Domino setups, and more TheStrat Suite is based on TheStrat, a price action trading methodology developed by Rob Smith. Whether you're familiar with the methodology or not, it's easy to pick up. FEATURES Combos across six configurable timeframes Entries and targets (magnitude and exhaustion levels) Failed 2s / Range reclaims Take action windows Domino setup detection Full Timeframe Continuity (FTFC) status Multi-condition alert filtering All multi-timeframe. All with alerts. KEY CONCEPTS Combo: The relationship between the current candle and the prior candle, expressed as two numbers (e.g., 2-1, 3-2). The first number is the prior candle type, the second is the current candle type. Candle Types: 1 (Inside) = high and low within prior candle's range; 2 (Directional) = took out one side of prior candle; 3 (Outside) = took out both sides of prior candle. Directional Bias (u/d): Indicates whether a candle closed up (u) or down (d) relative to its open. Shown alongside candle type (e.g., 2u, 2d, 3u, 3d). CC (Current Candle): The candle currently forming on the chart. C1 (Candle 1): The most recently closed candle, one bar back from the current candle. C2 (Candle 2): The candle two bars back from the current candle. HAM (Hammer): A candle where the low broke below the prior candle's low but closed back inside. Indicates potential bullish reversal. SHO (Shooter): A candle where the high broke above the prior candle's high but closed back inside. Indicates potential bearish reversal. Failed 2 / Range Reclaim: When a 2 candle takes out one side of a 1 (inside bar) but fails to continue and reverses back through the opposite side. This "failure" often triggers momentum in the opposite direction. Magnitude (MAG): The measured move target based on the range of the broadening formation or prior candle structure. Exhaustion Level: A level derived from extended price action that may indicate a potential reversal or pause zone. Take Action Window: The period during which a lower timeframe entry aligns with a higher timeframe signal. When this window is active, your entry is "in sync" with the larger structure. Domino Setup: Multiple consecutive timeframes showing inside bars (1s). When one breaks, it can trigger a cascade of setups across timeframes. Full Timeframe Continuity (FTFC): When all selected timeframes align in the same directional bias (all bullish or all bearish). Often used as a filter for higher-probability setups. Signal: Any combo that matches the criteria you have defined in your settings and filters. Signals represent the setups you want to see based on your trading preferences. Actionable Signal: Traditionally, a hammer, shooter, or inside bar. These setups have a defined trigger level and are considered "ready to trade" when that level is approached or broken. Potential Signal: A setup that is not yet confirmed but may become a signal if certain conditions are met. Potential signals are noted with a * before them in the indicator display. KNOWN LIMITATIONS (v1.0) Timeframe Hierarchy: TradingView does not allow requesting data from a timeframe lower than your chart's timeframe. If your chart is set to 1 hour, you cannot display data from the 15-minute or 5-minute timeframes. Always set your chart timeframe equal to or lower than your lowest configured indicator timeframe. Bar Replay Mode: Performance is unreliable in bar replay mode, especially when involving smaller timeframes. This is a known TradingView limitation, not a bug in the indicator. Historical Depth: To optimize performance, certain calculations (such as exhaustion levels) are limited to recent bars. This ensures fast load times without impacting real-time functionality. Label Overlap: When two or more levels are close together, labels may overlap on the chart. This is a TradingView limitation. Users can adjust label display settings to mitigate this issue. COMMON ISSUES & SOLUTIONS "I'm seeing too much on my chart." Use the indicator settings to toggle off features you don't need. Alternatively, rely on alerts to notify you when specific conditions are met rather than displaying everything visually. "I'm getting alerts at the wrong times, or too few, or too many." Check your alert interval setting in TradingView. The alert interval should be set to less than or equal to your lowest configured indicator timeframe. For example, if your lowest timeframe is 5 minutes, set alerts to trigger every 1 minute or "Once Per Bar Close" on a chart timeframe of 5 minutes or lower. "Levels aren't showing for a timeframe." Confirm your chart timeframe is equal to or lower than the timeframe you're trying to display. A 1-hour chart cannot show 15-minute data. "Labels or levels disappeared unexpectedly." The indicator automatically hides levels that are no longer relevant based on your selected filters and current market conditions. Check your settings to verify which filters are enabled. If a level was hit, invalidated, or is now duplicated by another timeframe, it may be hidden intentionally to keep your chart clean. Trading and investing involves risk of financial loss. TheStrat Suite is a charting tool, not financial advice. Past performance does not guarantee future results. You are solely responsible for your trading decisions. 345 Strategies assumes no responsibility for any losses (or gains) incurred.
Pine Script® indicator
by SpinTrades
1
Ticker DataTicker Data is a high-efficiency dashboard designed for traders and analysts who need immediate context on a ticker without cluttering their chart. This script aggregates fundamental data, price performance, and key institutional support levels into a single, customizable table. It allows you to assess the "character" of a stock in seconds by overlaying essential metrics directly onto your chart. Key Features 1. Institutional Anchors (Auto-VWAPs) Instead of manually drawing Anchored VWAPs for every ticker, this script automatically calculates and displays the three most important levels for trend management: VWAP IPO: The volume-weighted average price since the stock's inception. VWAP YTD: The volume-weighted average price starting from Jan 1st of the current year. VWAP Earnings: The volume-weighted average price since the most recent earnings report. Visual Logic: Text turns Green if price is above the VWAP, and Red if below. 2. Trend & Momentum 5-Day MA: Displays the 5-day Simple Moving Average based on Daily data. This serves as a "momentum guardrail"—if the price is above the 5DMA, short-term momentum is bullish. Timeframe Independence: The 5DMA and performance stats are forced to the Daily timeframe, ensuring consistent data even if you view the chart on 15m or 1H intervals. 3. Fundamental Context Market Cap: Current market capitalization. Float & Float %: Displays the number of floating shares and the percentage of total shares they represent. Vital for gauging volatility potential (low float = higher volatility). 4. Price Performance & Range Performance: % change over the last Week (1W), Month (1M), and Quarter (3M). 52-Week High/Low: Off 52W High: The % drawdown from the 52-week high. Above 52W Low: The % extension from the 52-week low. 5. Event & History Awareness Earnings Countdown: Displays the number of days until the next earnings report. Text turns Red inside the "Danger Zone" (less than 7 days). IPO Timer: Calculates exactly how many years have passed since the stock's public listing, allowing you to quickly filter for fresh merchandise vs. mature assets. Settings & Customization This script is built for "Chart Real Estate" management. You have full control over the visual layout via the inputs tab: Display Toggles: Every metric (Float %, Dist from High/Low, IPO Timer, VWAPs, etc.) has its own checkbox. Uncheck what you don't need to keep the table compact. Table Positioning: Location: Pin the table to any corner (Top/Bottom, Left/Right). Size: Scale the table from Tiny to Large to fit your resolution. Push Down: A unique feature that adds empty transparent rows to the top of the table. This pushes the data down so it does not obscure the most recent price candles or the ticker header. Visual Styling: Alignment: Independently control the text alignment (Left, Center, Right) for both the Labels and the Data columns. Colors: Fully customizable Background and Text colors. Note: The default text color is Black (optimized for Light Mode charts). If you use Dark Mode, simply switch the "Text Color" input to White. Technical Notes Data Source: Moving averages and VWAP anchors are calculated using Daily ('D') data to ensure institutional relevance.
Pine Script® indicator
by JTTC
ELMEHDI VIP (v4.0)ABO SALTAN //@version=5 indicator(title = 'ELMEHDI VIP (v4.0)', shorttitle = 'EL MEHDI KHEYI(v4.0)', overlay = true, max_boxes_count = 500, max_labels_count = 500, max_lines_count = 500, max_bars_back = 500, max_polylines_count = 100) bullcolor = #339b44 bearcolor = #af3232 ema150 = ta.ema(close, 150) ema250 = ta.ema(close, 250) gr_customalert = "Custom Alerts" gr_signal = "General Configurations" gr_PullBacksignal = "Trading Assistants" gr_RiskManage = "Risk Management" gr_dash = "Dashboard Configurations" //symbol info symInfoCheck = false symInfo = syminfo.ticker + ' | ' + timeframe.period + (timeframe.isminutes ? 'M' : na) date = str.tostring(dayofmonth(time_close)) + '/' + str.tostring(month(time_close)) + '/' + str.tostring(year(time_close)) //text positioning textVPosition = 'middle' textHPosition = 'center' //symbol info positioning symVPosition = 'top' symHPosition = 'left' //cell size width = 0 height1 = 0 //title settings c_title = #b2b5be80 s_title = 'large' a_title = 'center' //subtitle settings c_subtitle = #b2b5be80 s_subtitle = 'normal' a_subtitle = 'center' c_bg = color.new(color.blue, 100) // Get user input showSignals = input(true, "Show Signal's", group=gr_signal) //showSignals = true sensitivity = input.float(2.4, "Sensitivity", 0.1, step=0.1, group=gr_signal) STuner = input.int(10, "Signal Tuner(1-25)", minval = 1, maxval = 25, group=gr_signal) Presets = "All Signals" //Presets = input.string("All Signals", "Presets", , group=gr_signal) filterstyle = input.string("Trending Signals ", "Signal Mode / Filters", ["Trending Signals ", "Contrarian Signals ", "High Volume ", "Strong ", "Swing ", "Smooth ", "Scalping ", "Scalping+ "], group=gr_signal) //TextStyle = input.string("Minimal", "Signal Style", , group=gr_signal) //periodTrendCloud = input.string("Smooth", "Trend Cloud Style", , group=gr_Other_Settings) TextStyle = "Minimal" consSignalsFilter = filterstyle == "Trending Signals " ? true : false StrongSignalsOnly = filterstyle == "Strong " ? true : false highVolSignals = filterstyle == "High Volume " ? true : false signalsTrendCloud = (filterstyle == "Smooth ") ? true : (filterstyle == "Scalping ") ? true : (filterstyle == "Scalping+ ") ? true : (filterstyle == "Swing ") ? true : false ContrarianOnly = filterstyle == "Contrarian Signals " ? true : false TrendMap = 'Trend Gradient' momentumCandles = false assistantenable = input(true,'', group=gr_PullBacksignal, inline = 'sexyshit') assistantmode = input.string('Trend Assistant', 'Assistant | Mode', , group = gr_PullBacksignal, inline = 'sexyshit') Show_PR = input.bool(true, title="", group = gr_PullBacksignal , inline = "Features1") MSTuner = input.int(8, "Reversal Dot | Tuner(2-30)", minval = 2, maxval = 30, group=gr_PullBacksignal, inline = "Features1") LongTrendAverage = assistantmode == 'Trend Tracker' and assistantenable == true ? true : false analyscloud = assistantmode == 'Trend Assistant' and assistantenable == true ? true : false showTrendCloud = (filterstyle == "Smooth ") ? true : (filterstyle == "Scalping ") ? true : (filterstyle == "Scalping+ ") ? true : (filterstyle == "Swing ") ? true : false periodTrendCloud = (filterstyle == "Smooth ") ? "Smooth" : (filterstyle == "Scalping ") ? "Scalping" : (filterstyle == "Scalping+ ") ? "Scalping+" : (filterstyle == "Swing ") ? "Swing" : na //ScalpingPlus = input(false, "Fast trend cloud", group=gr_Other_Settings) //fastTrendCloudLen = input.int(55, "Fast trend cloud", 2, group=gr_Other_Settings) fill(plot(showTrendCloud and periodTrendCloud == "Smooth" ? na : assistantenable == true and assistantmode == 'Trend Tracker' ? ema150 : na, "", na, editable=false), plot(showTrendCloud and periodTrendCloud == "Smooth" ? na : assistantenable == true and assistantmode == 'Trend Tracker' ? ema250 : na, "", na, editable=false), ema150 > ema250 ? color.new(bullcolor, 70) : ema150 < ema250 ? color.new(bearcolor, 70) : na) showDashboard = input(true, "Smart Panel", group = gr_dash , inline = "Features1") locationDashboard = input.string("Bottom Right", "Dashboard Location", , group = gr_dash , tooltip="Smart Panel") sizeDashboard = input.string("Small", "Dashboard Size", , group = gr_dash , tooltip="Smart Panel") tpLabels = input(true, "Dynamic Take Profit Lables", group=gr_RiskManage) ShowTpSlAreas = input(true, "Show take Profit/Stop-loss Area", group=gr_RiskManage) ShowTrailingSL = input(false, "Show trailing Stop-loss", group=gr_RiskManage) usePercSL = input(false, "SL/TRAILING", inline="1", group=gr_RiskManage) percTrailingSL = input.float(1, "", 0, step=0.1, inline="1", group=gr_RiskManage) useTP1 = input(true, "", inline="1", group=gr_RiskManage) multTP1 = input.float(1, "TP 1", 0, inline="1", group=gr_RiskManage) useTP2 = input(true, "", inline="4", group=gr_RiskManage) multTP2 = input.float(2, "TP 2", 0, inline="4", group=gr_RiskManage) useTP3 = input(true, "", inline="4", group=gr_RiskManage) multTP3 = input.float(3, "TP 3", 0, inline="4", group=gr_RiskManage) ShowSwings = input(false, "Show Market Structure", inline="3", group=gr_RiskManage) periodSwings = input.int(10, "", 2, inline="3", group=gr_RiskManage) //showTS = input(title='Show Trend Shifter', defval=false, group='Contrarian SIGNALS') // showsignals = input(title='Show Signals', defval=false, group='Contrarian SIGNALS') // Alerts Managemnt Normalbuy_alert = input.bool(title='Buy Signal', defval=false, inline = "NB", group=gr_customalert) Strongbuy_alert = input.bool(title='Strong Buy', defval=true, inline = "NB", group=gr_customalert) Normalsell_alert = input.bool(title='Sell Signal', defval=false , inline = "NS", group=gr_customalert) Strongsell_alert = input.bool(title='Strong Sell', defval=true , inline = "NS", group=gr_customalert) slalert = input.bool(title='Stop-Loss', defval=true , inline = "SLTP1", group=gr_customalert) tp1alert = input.bool(title='Target 1', defval=true , inline = "SLTP1", group=gr_customalert) tp2alert = input.bool(title='Target 2', defval=true , inline = "TP2TP3", group=gr_customalert) tp3alert = input.bool(title='Target 3', defval=true , inline = "TP2TP3", group=gr_customalert) bullcrosscloud_alert = input.bool(title='Bullish Cloud', defval=false, inline = "CD", group=gr_customalert) bearcrosscloud_alert = input.bool(title='Bearish Cloud', defval=false, inline = "CD", group=gr_customalert) showCons = false paintCons = false // Signal Text SimpleBuy = "Buy" StrongB = "Strong Buy" SimpleSell = "Sell" StrongS = "Strong Sell" if TextStyle == "Normal" SimpleBuy := "Buy" StrongB := "BUY" SimpleSell:= "Sell" StrongS := "Strong Sell" if TextStyle == "Minimal" SimpleBuy := "⬆" StrongB := "⬆⬆" SimpleSell:= "⬇" StrongS := "⬇⬇" // Signal Text Color // bullsignalcolor = #ffffff // bearsignalcolor = color.rgb(255, 255, 255) // if TextStyle == "Normal" // bullsignalcolor := color.rgb(255, 255, 255) // bearsignalcolor := color.rgb(255, 255, 255) // if TextStyle == "Minimal" // bullsignalcolor := color.rgb(255, 255, 255) // bearsignalcolor := color.rgb(255, 255, 255) src = close RSII = ta.ema(ta.rsi(src, 50), 30) TR = math.abs(RSII - RSII ) wwalpha = 1 / 50 WWMA = 0.0 WWMA := wwalpha * TR + (1 - wwalpha) * nz(WWMA ) ATRRSI = 0.0 ATRRSI := wwalpha * WWMA + (1 - wwalpha) * nz(ATRRSI ) TsFast = ta.ema(ta.rsi(src, 50), 30) TsUP = TsFast + ATRRSI * 4.236 TsDN = TsFast - ATRRSI * 4.236 textWatermark = table.new(textVPosition + '_' + textHPosition, 1, 3) TsSlow = 0.0 TsSlow := TsUP < nz(TsSlow ) ? TsUP : TsFast > nz(TsSlow ) and TsFast < nz(TsSlow ) ? TsDN : TsDN > nz(TsSlow ) ? TsDN : TsDN < nz(TsSlow ) and TsFast > nz(TsSlow ) ? TsUP : nz(TsSlow ) Colorh = TsFast > 55 ? color.rgb(255, 0, 0) : TsFast < 45 ? color.rgb(0, 255, 8) : #ffffff //QQF = plot(TsFast, 'TS FAST', color=color.new(color.maroon, 100), linewidth=2, display=display.none, editable = false) //QQS = plot(TsSlow, 'TS SLOW', color=color.new(color.white, 100), linewidth=2, display=display.none , editable = false) //plot(TsFast, color=Colorh, linewidth=2, style=plot.style_area, histbase=50) //BearLimit = hline(60, color=color.gray, linestyle=hline.style_dashed) //BullLimt = hline(40, color=color.gray, linestyle=hline.style_dashed) bulllim = 45 bearlim = 55 BullSignalr = ta.crossover(TsFast, TsSlow) and TsFast < bulllim BearSignallr = ta.crossunder(TsFast, TsSlow) and TsFast > bearlim ///////////////////////////////////////////////////////// // Trap Detector //////////////////////////////////////////////////////// // Functions wavetrend(src, chlLen, avgLen) => esa = ta.ema(src, chlLen) d = ta.ema(math.abs(src - esa), chlLen) ci = (src - esa) / (0.015 * d) wt1 = ta.ema(ci, avgLen) wt2 = ta.sma(wt1, 3) f_top_fractal(src) => src < src and src < src and src > src and src > src f_bot_fractal(src) => src > src and src > src and src < src and src < src f_fractalize (src) => f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0 f_findDivs(src, topLimit, botLimit) => fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na highPrev = ta.valuewhen(fractalTop, src , 0) highPrice = ta.valuewhen(fractalTop, high , 0) lowPrev = ta.valuewhen(fractalBot, src , 0) lowPrice = ta.valuewhen(fractalBot, low , 0) bearSignal = fractalTop and high > highPrice and src < highPrev bullSignal = fractalBot and low < lowPrice and src > lowPrev // Get components = wavetrend(close, 5*MSTuner, 10*MSTuner) = f_findDivs(wt2, 10, -35) = f_findDivs(wt2, 40, -70) wtDivBull = wtDivBull1 or wtDivBull2 wtDivBear = wtDivBear1 or wtDivBear2 plotshape(ta.crossover(wt1, wt2) and Show_PR and wt2 <= -60) plotshape(ta.crossunder(wt1, wt2) and Show_PR and wt2 >= 60) rsi = ta.rsi(close ,14) // Functions f_chartTfInMinutes() => float _resInMinutes = timeframe.multiplier * ( timeframe.isseconds ? 1. / 60 : timeframe.isminutes ? 1. : timeframe.isdaily ? 60. * 24 : timeframe.isweekly ? 60. * 24 * 7 : timeframe.ismonthly ? 60. * 24 * 30.4375 : na) atr(len) => tr = ta.tr atr = 0.0 atr := nz(atr + (tr - atr ) / len, tr) supertrend(src, factor, len) => atr = ta.atr(len) upperBand = src + factor * atr lowerBand = src - factor * atr prevLowerBand = nz(lowerBand ) prevUpperBand = nz(upperBand ) lowerBand := lowerBand > prevLowerBand or close < prevLowerBand ? lowerBand : prevLowerBand upperBand := upperBand < prevUpperBand or close > prevUpperBand ? upperBand : prevUpperBand int direction = na float superTrend = na prevSuperTrend = superTrend if prevSuperTrend == prevUpperBand direction := close > upperBand ? 1 : -1 else direction := close < lowerBand ? -1 : 1 superTrend := direction == 1 ? lowerBand : direction == -1 ? upperBand : na dchannel(len)=> hh = ta.highest(len) ll = ta.lowest (len) trend = 0 trend := close > hh ? 1 : close < ll ? -1 : nz(trend ) trendScalper(show, len1, len2, len3, colorBull, colorBear, colorBarBull, colorBarBear) => avgOC = math.avg(open, close) ha_o = 0.0, ha_o := na(ha_o ) ? avgOC : (ha_o + ohlc4 ) / 2 ema1 = ta.ema(ha_o, len1), ema2 = ta.ema(ha_o, len2), ema3 = ta.ema(ha_o, len3) ris1 = ema1 > ema1 , ris2 = ema2 > ema2 , ris3 = ema3 > ema3 fal1 = ema1 < ema1 , fal2 = ema2 < ema2 , fal3 = ema3 < ema3 colorEma1 = ris1 ? colorBull : fal1 ? colorBear : na, colorEma2 = ris2 ? colorBull : fal2 ? colorBear : na, colorEma3 = ris3 ? colorBull : fal3 ? colorBear : na fillEma1 = avgOC > ema1 ? colorBull : avgOC < ema1 ? colorBear : na, fillEma2 = ema1 > ema2 ? colorBull : ema1 < ema2 ? colorBear : na, fillEma3 = ema2 > ema3 ? colorBull : ema2 < ema3 ? colorBear : na colorBar = close < ema1 and close < ema2 ? colorBarBear : colorBarBull candlesMom() => = ta.macd(close, 2, 4, 3) (macd > 10 and macd > macd ) or (macd < 10 and macd < macd ) trailingSL(buy, sell, factor, len, usePerc, perc) => atr = atr(len) upperBand = high + (usePerc ? high * (perc / 100) : factor * atr) lowerBand = low - (usePerc ? low * (perc / 100) : factor * atr) prevLowerBand = nz(lowerBand ) prevUpperBand = nz(upperBand ) lowerBand := lowerBand > prevLowerBand or buy ? lowerBand : prevLowerBand upperBand := upperBand < prevUpperBand or sell ? upperBand : prevUpperBand int direction = na float stop = na prevSuperTrend = stop if prevSuperTrend == prevUpperBand direction := buy ? 1 : -1 else direction := sell ? -1 : 1 stop := direction == 1 ? lowerBand : direction == -1 ? upperBand : na add_to_zz(zz, val, bi) => array.unshift(zz, bi) array.unshift(zz, val) if array.size(zz) > 12 array.pop(zz) update_zz(zz, val, bi, dir) => if array.size(zz) == 0 add_to_zz(zz, val, bi) else if dir == 1 and val > array.get(zz, 0) or dir == -1 and val < array.get(zz, 0) array.set(zz, 0, val) array.set(zz, 1, bi) 0 // Get components vosc = ta.obv - ta.ema(ta.obv, 20) bs = ta.ema(nz(math.abs((open - close) / (high - low) * 100)), 3) ema = ta.ema(close, 200) emaBull = close > ema equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes() higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes() too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10) securityNoRep(sym, res, src) => bool bull = na bull := equal_tf(res) ? src : bull bull := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_off) : bull bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src) if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res) bull := array.pop(bull_array) array.clear(bull_array) bull //TF1Bull = securityNoRep(syminfo.tickerid, "1" , emaBull) //TF3Bull = securityNoRep(syminfo.tickerid, "3" , emaBull) TF5Bull = securityNoRep(syminfo.tickerid, "5" , emaBull) //TF10Bull = securityNoRep(syminfo.tickerid, "10" , emaBull) TF15Bull = securityNoRep(syminfo.tickerid, "15" , emaBull) TF30Bull = securityNoRep(syminfo.tickerid, "30" , emaBull) TF60Bull = securityNoRep(syminfo.tickerid, "60" , emaBull) //TF120Bull = securityNoRep(syminfo.tickerid, "120" , emaBull) TF240Bull = securityNoRep(syminfo.tickerid, "240" , emaBull) //TF720Bull = securityNoRep(syminfo.tickerid, "720" , emaBull) //TFDBull = securityNoRep(syminfo.tickerid, "1440", emaBull) hma55 = ta.hma(close, 55 ) = ta.macd(close, 12, 26, 9) supertrend = supertrend(close, sensitivity, STuner) maintrend = dchannel(30) confBull = (ta.crossover (close, supertrend) or (ta.crossover (close, supertrend) and maintrend < 0)) and macd > 0 and macd > macd and ema150 > ema250 and hma55 > hma55 and maintrend > 0 confBear = (ta.crossunder(close, supertrend) or (ta.crossunder(close, supertrend) and maintrend > 0)) and macd < 0 and macd < macd and ema150 < ema250 and hma55 < hma55 and maintrend < 0 trendcloud = supertrend(ohlc4, periodTrendCloud == "Swing" ? 7 : 4, 10) hma = periodTrendCloud == "Scalping+" ? ta.hma(close, 55) : na none = close > 0 = ta.dmi(14, 14) consFilter = adx > 20 ContBear = TsFast > 65 ContBull = TsFast < 35 StrongFilter = ta.ema(close, 200) //volFilter = (ta.ema(volume, 25) - ta.ema(volume, 26)) / ta.ema(volume, 26) > 0 volFilter = (ta.ema(volume, 15) - ta.ema(volume, 20)) / ta.ema(volume, 25) > 0 trendFilter = trendcloud bull = (Presets == "All Signals" ? ta.crossover (close, supertrend) : confBull and not confBull ) and Presets != "Trend Scalper" and (StrongSignalsOnly ? close > StrongFilter : none) and (ContrarianOnly ? ContBull : none) and (consSignalsFilter ? consFilter : none) and (highVolSignals ? volFilter : none) and (signalsTrendCloud ? (periodTrendCloud == "Smooth" ? ema150 > ema250 : close > trendFilter) : none) bear = (Presets == "All Signals" ? ta.crossunder(close, supertrend) : confBear and not confBear ) and Presets != "Trend Scalper" and (StrongSignalsOnly ? close < StrongFilter : none) and (ContrarianOnly ? ContBear : none) and (consSignalsFilter ? consFilter : none) and (highVolSignals ? volFilter : none) and (signalsTrendCloud ? (periodTrendCloud == "Smooth" ? ema150 < ema250 : close < trendFilter) : none) countBull = ta.barssince(bull) countBear = ta.barssince(bear) trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0 = trendScalper(Presets == "Trend Scalper" ? true : false, 5, 9, 21, bullcolor, bearcolor, bullcolor, bearcolor) trailingStop = trailingSL(bull, bear, 2.2, 14, usePercSL, percTrailingSL) float _ph = ta.highestbars(high, periodSwings) == 0 ? high : na float _pl = ta.lowestbars (low, periodSwings) == 0 ? low : na var _dir = 0, dir_ = _pl and na(_ph) ? -1 : _dir, _dir := _ph and na(_pl) ? 1 : dir_, dirChg = ta.change(_dir) var zz = array.new_float(0), zzOld = array.copy(zz) float zzLive = _ph or _pl ? (dirChg ? add_to_zz(zz, _dir == 1 ? _ph : _pl, bar_index) : update_zz(zz, _dir == 1 ? _ph : _pl, bar_index, _dir)) : na float hb_ = ta.highestbars(10) == 0 ? high : na float lb_ = ta.lowestbars (10) == 0 ? low : na var int dir = 0 float zz_ = na float pp = na var int consCnt = 0 var float condHi = na var float condLo = na float H_ = ta.highest(5) float L_ = ta.lowest (5) var line lineUp = na var line lineDn = na bool breakUp = false bool breakDn = false var float pvh1_price = array.new_float(1000, na) var int pvh1_time = array.new_int (1000, na) var float pvl1_price = array.new_float(1000, na) var int pvl1_time = array.new_int (1000, na) var float pvh2_price = array.new_float(1000, na) var int pvh2_time = array.new_int (1000, na) var float pvl2_price = array.new_float(1000, na) var int pvl2_time = array.new_int (1000, na) var float htcmrll_price = na var int htcmrll_time = na var float ltcmrhh_price = na var int ltcmrhh_time = na var box long_boxes = array.new_box() var box short_boxes = array.new_box() var float temp_pv_0 = na var float temp_pv_1 = na var float temp_pv_2 = na bool pvh = high < high and high > high bool pvl = low > low and low < low int pv1_time = bar_index float pv1_high = high float pv1_low = low var buyBars = array.new_box(365, na) for i = 0 to 364 box.delete(array.get(buyBars, i)) var sellBars = array.new_box(365, na) for i = 0 to 364 box.delete(array.get(sellBars, i)) // Colors green = bullcolor, green50 = color.new(green, 50), green20 = color.new(green, 80) red = bearcolor, red50 = color.new(red, 50), red20 = color.new(red, 80) silver = #B2B5BE, silver50 = color.new(silver, 50), silver20 = color.new(silver, 80) // Plots atrBand = usePercSL ? (trigger ? low : high) * (percTrailingSL / 100) : ta.atr(14) * 2.2 atrStop = trigger ? low - atrBand : high + atrBand lastTrade(src) => ta.valuewhen(bull or bear, src, 0) entry_y = lastTrade(close) stop_y = lastTrade(atrStop) tp1_y = (entry_y-lastTrade(atrStop))*multTP1 + entry_y tp2_y = (entry_y-lastTrade(atrStop))*multTP2 + entry_y tp3_y = (entry_y-lastTrade(atrStop))*multTP3 + entry_y labelTpSl(cond, y, txt, color) => label labelTpSl = ShowTpSlAreas and cond ? label.new(bar_index + 1, y, txt, xloc.bar_index, yloc.price, color, label.style_label_left, color.white, size.normal) : na label.delete(labelTpSl ) labelTpSl(none, entry_y, "Entry : " + str.tostring(math.round_to_mintick(entry_y)), #089981) labelTpSl(none, stop_y , "Stop loss : " + str.tostring(math.round_to_mintick(atrStop)), bearcolor) labelTpSl(useTP1 and multTP1 != 0, tp1_y, "TP 1 : " + str.tostring(math.round_to_mintick(tp1_y)), #089981) labelTpSl(useTP2 and multTP2 != 0, tp2_y, "TP 2 : " + str.tostring(math.round_to_mintick(tp2_y)), #089981) labelTpSl(useTP3 and multTP3 != 0, tp3_y, "TP 3 : " + str.tostring(math.round_to_mintick(tp3_y)), #089981) lineTpSl(cond, y, color, style) => line lineTpSl = ShowTpSlAreas and cond ? line.new(bar_index - (trigger ? countBull : countBear), y, bar_index + 1, y, xloc.bar_index, extend.none, color, style) : na line.delete(lineTpSl ) lineTpSl(none, entry_y, #089981, line.style_dashed) lineTpSl(none, stop_y , bearcolor , line.style_solid ) lineTpSl(useTP1 and multTP1 != 0, tp1_y, bullcolor, line.style_dotted) lineTpSl(useTP2 and multTP2 != 0, tp2_y, bullcolor, line.style_dotted) lineTpSl(useTP3 and multTP3 != 0, tp3_y, bullcolor, line.style_dotted) //buy = showSignals and bull ? label.new(bar_index, low , close > StrongFilter ? StrongB : SimpleBuy , xloc.bar_index, yloc.belowbar, bullcolor, label.style_label_up , color.rgb(255, 255, 255), size.normal) : na //sell = showSignals and bear ? label.new(bar_index, high, close < StrongFilter ? StrongS : SimpleSell , xloc.bar_index, yloc.abovebar, bearcolor , label.style_label_down, color.rgb(255, 255, 255), size.normal) : na buy = (showSignals and bull ? label.new(bar_index, low , close > StrongFilter ? StrongB : SimpleBuy , xloc.bar_index, yloc.belowbar, bullcolor, label.style_label_up , color.rgb(255, 255, 255), size.normal) : na) sell = showSignals and bear ? label.new(bar_index, high, close < StrongFilter ? StrongS : SimpleSell , xloc.bar_index, yloc.abovebar, bearcolor , label.style_label_down, color.rgb(255, 255, 255), size.normal) : na tpLabels(tp) => tp1Bull = ta.crossover (rsi, 70), tp2Bull = ta.crossover (rsi, 75), tp3Bull = ta.crossover (rsi, 80) tp1Bull := tp1Bull and (nz(ta.barssince(tp1Bull) , 9999) > countBull), tp2Bull := tp2Bull and (ta.barssince(tp1Bull) <= countBull), tp2Bull := tp2Bull and (nz(ta.barssince(tp2Bull) , 9999) > countBull), tp3Bull := tp3Bull and (ta.barssince(tp2Bull) <= countBull), tp3Bull := tp3Bull and (nz(ta.barssince(tp3Bull) , 9999) > countBull) tp1Bear = ta.crossunder(rsi, 30), tp2Bear = ta.crossunder(rsi, 25), tp3Bear = ta.crossunder(rsi, 20) tp1Bear := tp1Bear and (nz(ta.barssince(tp1Bear) , 9999) > countBear), tp2Bear := tp2Bear and (ta.barssince(tp1Bear) <= countBear), tp2Bear := tp2Bear and (nz(ta.barssince(tp2Bear) , 9999) > countBear), tp3Bear := tp3Bear and (ta.barssince(tp2Bear) <= countBear), tp3Bear := tp3Bear and (nz(ta.barssince(tp3Bear) , 9999) > countBear) if Presets != "Trend Scalper" and tpLabels trigger ? (tp == 1 ? tp1Bull : tp == 2 ? tp2Bull : tp3Bull) : (tp == 1 ? tp1Bear : tp == 2 ? tp2Bear : tp3Bear) plotshape(tpLabels(1), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 1", trigger ? green : na , true) plotshape(tpLabels(2), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 2", trigger ? green : na , false) plotshape(tpLabels(3), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 3", trigger ? green : na , false) plotshape(tpLabels(1), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 1", trigger ? na : red, true) plotshape(tpLabels(2), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 2", trigger ? na : red, false) plotshape(tpLabels(3), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 3", trigger ? na : red, false) var label zzLabel = na if array.size(zz) > 12 and ShowSwings if array.get(zz, 0) != array.get(zzOld, 0) or array.get(zz, 1) != array.get(zzOld, 1) if array.get(zz, 2) == array.get(zzOld, 2) and array.get(zz, 3) == array.get(zzOld, 3) label.delete(zzLabel) zzLabel := label.new(math.round(array.get(zz, 1)), array.get(zz, 0), _dir == 1 ? array.get(zz, 0) > array.get(zz, 4) ? ((array.get(zz, 4) < array.get(zz, 8)) ? "High" : "HH") : "LH" : array.get(zz, 0) < array.get(zz, 4) ? ((array.get(zz, 4) > array.get(zz, 8)) ? "Low" : "LL") : "HL", xloc.bar_index, yloc.price, color.new(color.white, 100), _dir == 1 ? label.style_label_down : label.style_label_up, _dir == 1 ? bullcolor : bearcolor) if showCons and barstate.isconfirmed dir := hb_ and na(lb_) ? 1 : lb_ and na(hb_) ? -1 : dir if hb_ and lb_ if dir == 1 zz_ := hb_ else zz_ := lb_ else zz_ := hb_ ? hb_ : lb_ ? lb_ : na for x = 0 to 1000 if na(close) or dir != dir break if zz_ if na(pp) pp := zz_ else if dir == 1 and zz_ > pp pp := zz_ if dir == -1 and zz_ < pp pp := zz_ if pp != pp if consCnt > 5 if pp > condHi breakUp := true if pp < condLo breakDn := true if consCnt > 0 and pp <= condHi and pp >= condLo consCnt += 1 else consCnt := 0 else consCnt += 1 if consCnt >= 5 if consCnt == 5 condHi := H_ condLo := L_ else line.delete(lineUp) line.delete(lineDn) condHi := math.max(condHi, high) condLo := math.min(condLo, low ) lineUp := line.new(bar_index, condHi , bar_index - consCnt, condHi , color=bearcolor , style=line.style_dashed) lineDn := line.new(bar_index, condLo , bar_index - consCnt, condLo , color=color.lime, style=line.style_dashed) fill(plot(condHi, "", na, 1, plot.style_stepline, editable=false), plot(condLo, "", na, 1, plot.style_stepline, editable=false), paintCons and consCnt > 5 ? color.white : na, "", false) //buy_col = color.new(#0ac20a,0) //sell_col = color.new(#fd1605,0) //text_col = color.new(#FFFFFF,0) // -------- Bearish trend (blue) color selection -------- // getSellColor(count) => // if count == 1 // color.new(#11e7f2,0) // else // if count == 2 // color.new(#11d9f2,0) // else // if count == 3 // color.new(#11cbf2,0) // else // if count == 4 // color.new(#11aff2,0) // else // if count == 5 // color.new(#1193f2,0) // else // if count == 6 // color.new(#1176f2,0) // else // if count == 7 // color.new(#105df4,0) // else // if count == 8 // color.new(#1051f5,0) // else // if count == 9 // color.new(#0f44f5,0) // else // if count == 10 // color.new(#0c3de0,0) // else // if count == 11 // color.new(#0935ca,0) // else // if count == 12 // color.new(#062eb4,0) // else // if count == 13 // color.new(#02269e,0) // -------- Bullish trend (blue) color selection -------- // getBuyColor(count) => // if count == 1 // color.new(#eef211,0) // else // if count == 2 // color.new(#efdc11,0) // else // if count == 3 // color.new(#f0c511,0) // else // if count == 4 // color.new(#f1af11,0) // else // if count == 5 // color.new(#f29811,0) // else // if count == 6 // color.new(#f28811,0) // else // if count == 7 // color.new(#f27811,0) // else // if count == 8 // color.new(#f26811,0) // else // if count == 9 // color.new(#f25811,0) // else // if count == 10 // color.new(#ea420d,0) // else // if count == 11 // color.new(#e12c09,0) // else // if count == 12 // color.new(#d81605,0) // else // if count == 13 // color.new(#cf0000,0) // -------- Calculate bearish trend sequence -------- buySetup = 0 buySetup := close < close ? buySetup == 13 ? 1 : buySetup + 1 : 0 // -------- Calculate bullish trend sequence -------- sellSetup = 0 sellSetup := close > close ? sellSetup == 13 ? 1 : sellSetup + 1 : 0 // -------- Paint bars -------- //barColour = buySetup >= 1 ? getBuyColor(buySetup) : sellSetup >= 1 ? getSellColor(sellSetup) : na // Candle Coloring // Input FastteyLength = 12 SjlowLeyLength = 26 srrrc = close signalXLength = 9 // Data reference = ta.macd(srrrc, FastteyLength, SjlowLeyLength, signalXLength) // 4 level of green greenHigh = #7bff00 greenMidHigh = #7bff00 greenMidLow = #7bff00 greenLow = #7bff00 // Yellow yellowLow = #693d8e // 4 level of red redHigh = #ff0000 redMidHigh = #ff0000 redMidLow = #ff0000 redLow = #ff0000 // Default color candleBody = yellowLow // Ranging trend if histX > 0 if histX > histX and histX > 0 candleBody := greenLow if histX < 0 if histX < histX and histX < 0 candleBody := redLow // Bullish trend if MacdX > 0 and histX > 0 candleBody := greenMidLow if histX > histX and MacdX > 0 and histX > 0 candleBody := greenMidHigh if histX > histX and MacdX > 0 and histX > 0 candleBody := greenHigh // Bearish trend if MacdX < 0 and histX < 0 candleBody := redMidLow if histX < histX and MacdX < 0 and histX < 0 candleBody := redMidHigh if histX < histX and MacdX < 0 and histX < 0 candleBody := redHigh barcolor(candleBody) //barcolor(TrendMap == 'RSI Gradient' ? barColour : na, title='Bar colors (heatmap)',editable=false) //barcolor(momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false) //plotcandle(open, high, low, close , color = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , wickcolor = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , bordercolor = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , editable = false) fill(plot(showTrendCloud and periodTrendCloud == "Smooth" ? ema150 : na, "", na, editable=false), plot(showTrendCloud and periodTrendCloud == "Smooth" ? ema250 : na, "", na, editable=false), ema150 > ema250 ? color.new(bullcolor, 70) : ema150 < ema250 ? color.new(bearcolor, 70) : na) plot(ShowTrailingSL and trigger and nz(ta.barssince(low < trailingStop), bar_index) > countBull ? trailingStop : na, "", green, 1, plot.style_linebr, editable=false) plot(ShowTrailingSL and not trigger and nz(ta.barssince(high > trailingStop), bar_index) > countBear ? trailingStop : na, "", red , 1, plot.style_linebr, editable=false) p0 = plot(avgOC, "", na , editable=false) p1 = plot(ema5 , "", colorEma5 , editable=false) p2 = plot(ema9 , "", colorEma9 , editable=false) p3 = plot(ema21, "", colorEma21, editable=false) plot(LongTrendAverage ? ta.ema(close, 250) : na, 'Trend Tracer', linewidth=2, color=close > ta.ema(close, 250) ? color.new(bullcolor, 45) : color.new(bearcolor, 45)) fill(p0, p1, fillEma5 ) fill(p1, p2, fillEma9 ) fill(p2, p3, fillEma21) fill(plot(showTrendCloud and periodTrendCloud != "Smooth" and periodTrendCloud != "Scalping+" and trendcloud != 0 and close > trendcloud ? trendcloud : na, "", bullcolor, 1, plot.style_linebr, editable=false), p0, color.new(bullcolor, 90)) fill(plot(showTrendCloud and periodTrendCloud != "Smooth" and periodTrendCloud != "Scalping+" and trendcloud != 0 and close < trendcloud ? trendcloud : na, "", bearcolor , 1, plot.style_linebr, editable=false), p0, color.new(bearcolor , 90)) //fill(plot(hma, "", hma > hma ? green : hma < hma ? red : na, editable=false), plot(hma , "", hma > hma ? green : hma < hma ? red : na, editable=false), hma > hma ? green : hma < hma ? red : na) //////////////////////////////////////////////////////////////////////////////////////////////// // Get user input indicatorTF = "Chart" // Functions sqz(bbLen, bbMult, kcLen, kcMult, source) => upperBB = ta.sma(source, bbLen) + ta.stdev(source, bbLen) * bbMult lowerBB = ta.sma(source, bbLen) - ta.stdev(source, bbLen) * bbMult upperKC = ta.sma(source, kcLen) + ta.sma(ta.tr, kcLen) * kcMult lowerKC = ta.sma(source, kcLen) - ta.sma(ta.tr, kcLen) * kcMult sqzOn = lowerBB > lowerKC and upperBB < upperKC sqzOff = lowerBB < lowerKC and upperBB > upperKC qqe(rsiLen, rsiSmooth, factor, source, bbLen, bbMult) => rsiMa = ta.ema(ta.rsi(source, rsiLen), rsiSmooth) delta = ta.ema(ta.ema(math.abs(ta.mom(rsiMa, 1)), rsiLen * 2 - 1), rsiLen * 2 - 1) * factor longBand = 0.0, longBand := rsiMa > longBand and rsiMa > longBand ? math.max(longBand , rsiMa - delta) : rsiMa - delta shortBand = 0.0, shortBand := rsiMa < shortBand and rsiMa < shortBand ? math.min(shortBand , rsiMa + delta) : rsiMa + delta cross1 = ta.cross(rsiMa, shortBand ) cross2 = ta.cross(rsiMa, longBand ) trend = 0.0, trend := cross1 ? 1 : cross2 ? -1 : nz(trend , 1) fastDelta = trend == 1 ? longBand : shortBand _hist = rsiMa - 50 _line = fastDelta - 50 = ta.bb(_line, bbLen, bbMult) // Get components cond(_offset) => top = ta.highest(high, 10) bot = ta.lowest(low, 10) osc = ta.ema(hlc3, 5) - ta.ema(ohlc4, 20) oscRis = osc > osc oscFal = osc < osc oscA0 = osc > 0 oscB0 = osc < 0 oscTop = oscFal and oscRis oscBot = oscRis and oscFal bullR = oscB0 and oscBot and ((osc > ta.valuewhen(oscB0 and oscBot, osc, 1) and bot < ta.valuewhen(oscB0 and oscBot, bot, 1))) bearR = oscA0 and oscTop and ((osc < ta.valuewhen(oscA0 and oscTop, osc, 1) and top > ta.valuewhen(oscA0 and oscTop, top, 1))) bullH = oscB0 and oscBot and ((osc < ta.valuewhen(oscB0 and oscBot, osc, 1) and bot > ta.valuewhen(oscB0 and oscBot, bot, 1))) bearH = oscA0 and oscTop and ((osc > ta.valuewhen(oscA0 and oscTop, osc, 1) and top < ta.valuewhen(oscA0 and oscTop, top, 1))) = sqz(20, 2, 20, 2, close) = qqe(6, 6, 3, close, 50, 0.001) = qqe(6, 5, 1.618, close, 50, 1) = ta.dmi(14, 14) [osc , oscRis , oscFal , oscA0 , oscB0 , oscTop , oscBot , bullR , bearR , bullH , bearH , sqzOn , sqzOff , _hist1 , upper1 , lower1 , _hist2 , _line2 , tvr ] tf = indicatorTF == "Chart" ? timeframe.period : indicatorTF == "1 minute" ? "1" : indicatorTF == "3 minutes" ? "3" : indicatorTF == "5 minutes" ? "5" : indicatorTF == "10 minutes" ? "10" : indicatorTF == "15 minutes" ? "15" : indicatorTF == "30 minutes" ? "30" : indicatorTF == "45 minutes" ? "45" : indicatorTF == "1 hour" ? "60" : indicatorTF == "2 hours" ? "120" : indicatorTF == "3 hours" ? "180" : indicatorTF == "4 hours" ? "240" : indicatorTF == "12 hours" ? "720" : indicatorTF == "1 day" ? "1D" : indicatorTF == "1 week" ? "1W" : indicatorTF == "1 month" ? "1M" : na = request.security(syminfo.tickerid, tf, cond(indicatorTF != "Chart" and barstate.isrealtime ? 1 : 0)) //colorTVR = tvr < 15 ? #F6525F : tvr > 15 and tvr < 25 ? #B2B5BE : #66BB6A // Plots //plot(Presets == "Money Moves TrendVR" ? tvr : na, "", colorTVR, editable=false) TrendText = "Trending" if tvr < 15 and tvr < 25 TrendText := "No trend" if tvr > 15 and tvr < 25 TrendText := "Ranging" //------------------------------------------------------------------------------------------------------- Volatitiry //Calculates Volatility for Dashboard atrr = 3 * ta.atr(10) stdAtr = 2 * ta.stdev(atrr, 20) smaAtr = ta.sma(atrr, 20) topAtrDev = smaAtr + stdAtr bottomAtrDev = smaAtr - stdAtr calcDev = (atrr - bottomAtrDev) / (topAtrDev - bottomAtrDev) percentVol = 40 * calcDev + 30 AvrLength = 21 PercentFilter = 144 xAavrVolume = ta.rma(volume, AvrLength) nResLess = volume * 100 / xAavrVolume < PercentFilter ? 0 : volume nRes = nResLess clr = close < open ? #b2b5be : #00dbff //plot(nRes, color=clr, style=plot.style_columns, title='Volume Filter', transp=20) VolitiText = "Inactive" if nRes VolitiText := "Active" ////////////////////////////////////////// ema69 = ta.ema(close, 9) totalSentTxt = ema69 > ema69 ? 'Bullish' : ema69 < ema69 ? 'Bearish' : 'Flat' // INputs //Timezones tz_incr = 0 use_exchange = false //------------------------------------------------------------------------------ //Settings //-----------------------------------------------------------------------------{ //Session A NYSes = true NYTxt = 'New York' NYTime = '1300-2200' //Session B LDSes = true sesb_txt = 'London' sesb_ses = '0700-1600' //Session C show_sesc = true sesc_txt = 'Tokyo' sesc_ses = '0000-0900' //Session D show_sesd = true sesd_txt = 'Sydney' sesd_ses = '2100-0600' //-----------------------------------------------------------------------------} //Sessions //-----------------------------------------------------------------------------{ tff = timeframe.period var tz = use_exchange ? syminfo.timezone : str.format('UTC{0}{1}', tz_incr >= 0 ? '+' : '-', math.abs(tz_incr)) is_sesa = math.sign(nz(time(tff, NYTime, tz))) is_sesb = math.sign(nz(time(tff, sesb_ses, tz))) is_sesc = math.sign(nz(time(tff, sesc_ses, tz))) is_sesd = math.sign(nz(time(tff, sesd_ses, tz))) //////////////////////////////////////////// SessionText = "Default" if is_sesd SessionText := sesd_txt if is_sesc SessionText := sesc_txt if is_sesb SessionText := sesb_txt if is_sesa SessionText := NYTxt if is_sesd and is_sesc SessionText := "Sydney/Tokyo" if is_sesb and is_sesc SessionText := "Tokyo/London" if is_sesb and is_sesa SessionText := "London/Newyork" if is_sesa and is_sesd SessionText := "Newyork/Sydney" //-----------------------------------------------------------------------------} //Overlays color.green : color.red // var dashboard_loc = locationDashboard == "Top Right" ? position.top_right : locationDashboard == "Middle Right" ? position.middle_right : locationDashboard == "Bottom Right" ? position.bottom_right : locationDashboard == "Top Center" ? position.top_center : locationDashboard == "Middle Center" ? position.middle_center : locationDashboard == "Bottom Center" ? position.bottom_center : locationDashboard == "Top Left" ? position.top_left : locationDashboard == "Middle Left" ? position.middle_left : position.bottom_left var dashboard_size = sizeDashboard == "Large" ? size.large : sizeDashboard == "Normal" ? size.normal : sizeDashboard == "Small" ? size.small : size.tiny var dashboard = showDashboard ? table.new(dashboard_loc, 3, 7, color.rgb(0, 0, 0, 60), #3d384300, 2, color.rgb(30, 34, 45 , 60), 1) : na dashboard_cell(column, row, txt, signal=false) => table.cell(dashboard, column, row, txt, 0, 0, signal ? #000000 : color.white, text_size=dashboard_size) dashboard_cell_bg(column, row, col) => table.cell_set_bgcolor(dashboard, column, row, col) if barstate.islast and showDashboard // MTF Trend dashboard_cell(0, 0 , "MTF") dashboard_cell(0, 2 , "M5") , dashboard_cell_bg(0, 2 , TF5Bull ? color.rgb(70, 153, 67) : #880000) dashboard_cell(0, 3 , "M15") , dashboard_cell_bg(0, 3 , TF15Bull ? color.rgb(70, 153, 67) : #880000) dashboard_cell(0, 4 , "M30") , dashboard_cell_bg(0, 4 , TF30Bull ? color.rgb(70, 153, 67) : #880000) dashboard_cell(0, 5 , "1H") , dashboard_cell_bg(0, 5 , TF60Bull ? color.rgb(70, 153, 67) : #880000) dashboard_cell(0, 6 , "4H") , dashboard_cell_bg(0, 6 , TF240Bull ? color.rgb(70, 153, 67) : #880000) // Middel part dashboard_cell(1, 0 , "PoseidonPips") dashboard_cell(1, 2 , "Market State") dashboard_cell(1, 3 , "Volatility") dashboard_cell(1, 4 , "Institutional Activity") dashboard_cell(1, 5 , "Current Session (UTC)") dashboard_cell(1, 6 , "Trend Pressure") // End part dashboard_cell(2, 0 , "") dashboard_cell(2, 2 , TrendText) dashboard_cell(2, 3 , str.tostring(percentVol, '##.##') + '%') dashboard_cell(2, 4 , VolitiText) dashboard_cell(2, 5 , SessionText) dashboard_cell(2, 6 , totalSentTxt) // Alerts // Cross Functions for SL and TP f_sl_crossed() => ret = false crossBull = low >= ta.lowest(low, 5) and low < ta.lowest(low, 5) crossBear = high <= ta.highest(high, 5) and high > ta.highest(high, 5) ret := trigger ? crossBull : crossBear ret f_tp_crossed(tp) => ret = false crossBull = high <= tp and high > tp crossBear = low >= tp and low < tp ret := trigger ? crossBull : crossBear ret // Alert Conditions alert04 = bull and close <= StrongFilter alert07 = bull and close > StrongFilter alert09 = f_sl_crossed() alert11 = f_tp_crossed(60.0) alert12 = f_tp_crossed(80.0) alert13 = f_tp_crossed(100.0) alert14 = periodTrendCloud == "Smooth" ? ta.crossunder(ema150, ema250) : (close < trendcloud) and (close > trendcloud ) alert15 = periodTrendCloud == "Smooth" ? ta.crossover(ema150, ema250) : (close > trendcloud) and (close < trendcloud ) // Signal Alerts if alert04 and Normalbuy_alert alert('Buy Signal Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if alert07 and Strongbuy_alert alert('Strong Buy Signal Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if (bear and close >= StrongFilter) and Normalsell_alert alert('Sell Signal Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if (bear and close < StrongFilter) and Strongsell_alert alert('Strong Sell Signal Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) // Risk Management Alerts if alert09 and slalert alert('SL Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if alert11 and tp1alert alert('Target 1 Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if alert12 and tp2alert alert('Target 2 Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if alert13 and tp3alert alert('Target 3 Alert !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) // Cloud Alerts if alert15 and bullcrosscloud_alert alert('Cloud Turned Bullish !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) if alert14 and bearcrosscloud_alert alert('Cloud Turned Bearish !!!', alert.freq_once_per_bar_close) alert(syminfo.tickerid) // Alert Conditions for TradingView alertcondition(alert04, "Normal Buy Alert", "Normal Buy Signal") alertcondition(alert07, "Strong Buy Alert", "Strong Buy Signal") alertcondition((bear and close >= StrongFilter), "Normal Sell Alert", "Normal Sell Signal") alertcondition((bear and close < StrongFilter), "Strong Sell Alert", "Strong Sell Signal") alertcondition(alert09, "SL Crossed Alert", "Stop Loss Crossed") alertcondition(alert11, "TP1 Crossed Alert", "Target 1 Crossed") alertcondition(alert12, "TP2 Crossed Alert", "Target 2 Crossed") alertcondition(alert13, "TP3 Crossed Alert", "Target 3 Crossed") // Input fastLength = 12 slowLength = 26 srcceed = close signalLength = 9 // Data reference = ta.macd(srcceed, fastLength, slowLength, signalLength) // 4 level of green greenHighh = #7bff00 greenMidHighh = #7bff00 greenMidLowh = #7bff00 greenLowh = #7bff00 // Yellow yellowLowh = #693d8e // 4 level of red redHighh = #ff0000 redMidHighh = #ff0000 redMidLowh = #ff0000 redLowh = #ff0000 // Default color candleBodyd = yellowLowh // Ranging trend if hist > 0 if hist > hist and hist > 0 candleBodyd := greenLowh if hist < 0 if hist < hist and hist < 0 candleBodyd := redLowh // Bullish trend if macdda > 0 and hist > 0 candleBodyd := greenMidLowh if hist > hist and macd > 0 and hist > 0 candleBodyd := greenMidHighh if hist > hist and macd > 0 and hist > 0 candleBodyd := greenHighh // Bearish trend if macdda < 0 and hist < 0 candleBodyd := redMidLowh if hist < hist and macd < 0 and hist < 0 candleBodyd := redMidHighh if hist < hist and macd < 0 and hist < 0 candleBodyd := redHighh barcolor(candleBodyd) // Include suggestion by Shaheen204 // tenkan_len = 365 tenkan_mult = 3 kijun_len = 365 kijun_mult = 7 spanB_len = 365 spanB_mult = 10 offset = 1 //------------------------------------------------------------------------------ avg(src,length,mult)=> atr = ta.atr(50)*mult up = hl2 + atr dn = hl2 - atr upper = 0.,lower = 0. upper := src < upper ? math.min(up,upper ) : up lower := src > lower ? math.max(dn,lower ) : dn os = 0,max = 0.,min = 0. os := src > upper ? 1 : src < lower ? 0 : os spt = os == 1 ? lower : upper max := ta.cross(src,spt) ? math.max(src,max ) : os == 1 ? math.max(src,max ) : spt min := ta.cross(src,spt) ? math.min(src,min ) : os == 0 ? math.min(src,min ) : spt math.avg(max,min) //------------------------------------------------------------------------------ tenkan = avg(close,tenkan_len,tenkan_mult) kijun = avg(close,kijun_len,kijun_mult) senkouA = math.avg(kijun,tenkan) senkouB = avg(close,spanB_len,spanB_mult) /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Smart Money Concept settings = "Settings" zigzag_len = input.int(9, "ZigZag Length", group=settings) show_zigzag = input.bool(false, "Show Zigzag", group=settings) fib_factor = input.float(0.33, "Fib Factor for breakout confirmation", 0, 1, 0.01, group=settings) text_size = input.string(size.tiny, "Text Size", , group=settings) delete_boxes = input.bool(true, "Delete Old/Broken Boxes", group=settings) bu_ob_inline_color = "Bu-OB Colors" be_ob_inline_color = "Be-OB Colors" bu_bb_inline_color = "Bu-BB Colors" be_bb_inline_color = "Be-BB Colors" bu_ob_display_settings = "Bu-OB Display Settings" bu_ob_color = input.color(color.new(color.green, 70), "Color", group=bu_ob_display_settings, inline=bu_ob_inline_color) bu_ob_border_color = input.color(color.green, "Border Color", group=bu_ob_display_settings, inline=bu_ob_inline_color) bu_ob_text_color = input.color(color.green, "Text Color", group=bu_ob_display_settings, inline=bu_ob_inline_color) be_ob_display_settings = "Be-OB Display Settings" be_ob_color = input.color(color.new(color.red, 70), "Color", group=be_ob_display_settings, inline=be_ob_inline_color) be_ob_border_color = input.color(color.red, "Border Color", group=be_ob_display_settings, inline=be_ob_inline_color) be_ob_text_color = input.color(color.red, "Text Color", group=be_ob_display_settings, inline=be_ob_inline_color) bu_bb_display_settings = "Bu-BB & Bu-MB Display Settings" bu_bb_color = input.color(color.new(color.green, 70), "Color", group=bu_bb_display_settings, inline=bu_bb_inline_color) bu_bb_border_color = input.color(color.green, "Border Color", group=bu_bb_display_settings, inline=bu_bb_inline_color) bu_bb_text_color = input.color(color.green, "Text Color", group=bu_bb_display_settings, inline=bu_bb_inline_color) be_bb_display_settings = "Be-BB & Be-MB Display Settings" be_bb_color = input.color(color.new(color.red, 70), "Color", group=be_bb_display_settings, inline=be_bb_inline_color) be_bb_border_color = input.color(color.red, "Border Color", group=be_bb_display_settings, inline=be_bb_inline_color) be_bb_text_color = input.color(color.red, "Text Color", group=be_bb_display_settings, inline=be_bb_inline_color) var float high_points_arr = array.new_float(5) var int high_index_arr = array.new_int(5) var float low_points_arr = array.new_float(5) var int low_index_arr = array.new_int(5) var box bu_ob_boxes = array.new_box(5) var box be_ob_boxes = array.new_box(5) var box bu_bb_boxes = array.new_box(5) var box be_bb_boxes = array.new_box(5) to_up = high >= ta.highest(zigzag_len) to_down = low <= ta.lowest(zigzag_len) trend = 1 trend := nz(trend , 1) trend := trend == 1 and to_down ? -1 : trend == -1 and to_up ? 1 : trend last_trend_up_since = ta.barssince(to_up ) low_val = ta.lowest(nz(last_trend_up_since > 0 ? last_trend_up_since : 1, 1)) low_index = bar_index - ta.barssince(low_val == low) last_trend_down_since = ta.barssince(to_down ) high_val = ta.highest(nz(last_trend_down_since > 0 ? last_trend_down_since : 1, 1)) high_index = bar_index - ta.barssince(high_val == high) if ta.change(trend) != 0 if trend == 1 array.push(low_points_arr, low_val) array.push(low_index_arr, low_index) if trend == -1 array.push(high_points_arr, high_val) array.push(high_index_arr, high_index) f_get_high(ind) => f_get_low(ind) => f_delete_box(box_arr) => if delete_boxes box.delete(array.shift(box_arr)) else array.shift(box_arr) 0 = f_get_high(0) = f_get_high(1) = f_get_low(0) = f_get_low(1) if ta.change(trend) != 0 and show_zigzag if trend == 1 line.new(h0i, h0, l0i, l0) if trend == -1 line.new(l0i, l0, h0i, h0) market = 1 market := nz(market , 1) // market := market == 1 and close < l0 and low < l0 - math.abs(h0 - l0) * fib_factor ? -1 : market == -1 and close > h0 and high > h0 + math.abs(h0 - l0) * fib_factor ? 1 : market last_l0 = ta.valuewhen(ta.change(market) != 0, l0, 0) last_h0 = ta.valuewhen(ta.change(market) != 0, h0, 0) market := last_l0 == l0 or last_h0 == h0 ? market : market == 1 and l0 < l1 and l0 < l1 - math.abs(h0 - l1) * fib_factor ? -1 : market == -1 and h0 > h1 and h0 > h1 + math.abs(h1 - l0) * fib_factor ? 1 : market bu_ob_index = bar_index bu_ob_index := nz(bu_ob_index , bar_index) for i=h1i to l0i index = bar_index - i if open > close bu_ob_index := bar_index bu_ob_since = bar_index - bu_ob_index be_ob_index = bar_index be_ob_index := nz(be_ob_index , bar_index) for i=l1i to h0i index = bar_index - i if open < close be_ob_index := bar_index be_ob_since = bar_index - be_ob_index be_bb_index = bar_index be_bb_index := nz(be_bb_index , bar_index) for i=h1i - zigzag_len to l1i index = bar_index - i if open > close be_bb_index := bar_index be_bb_since = bar_index - be_bb_index bu_bb_index = bar_index bu_bb_index := nz(bu_bb_index , bar_index) for i=l1i - zigzag_len to h1i index = bar_index - i if open < close bu_bb_index := bar_index bu_bb_since = bar_index - bu_bb_index if ta.change(market) != 0 if market == 1 line.new(h1i, h1, h0i, h1, color=color.green, width=1) label.new(int(math.avg(h1i, l0i)), h1, "BoS", color=color.new(color.black, 100), style=label.style_label_down, textcolor=color.green, size=size.small) bu_ob = box.new(bu_ob_index, high , bar_index + 10, low , bgcolor=bu_ob_color, border_color=bu_ob_border_color, text="Bu-OB", text_color=bu_ob_text_color, text_halign=text.align_right, text_size=text_size) bu_bb = box.new(bu_bb_index, high , bar_index + 10, low , bgcolor=bu_bb_color, border_color=bu_bb_border_color, text=l0 < l1 ? "Bu-BB" : "Bu-MB", text_color=bu_bb_text_color, text_halign=text.align_right, text_size=text_size) array.push(bu_ob_boxes, bu_ob) array.push(bu_bb_boxes, bu_bb) if market == -1 line.new(l1i, l1, l0i, l1, color=color.red, width=1) label.new(int(math.avg(l1i, h0i)), l1, "BoS", color=color.new(color.black, 100), style=label.style_label_up, textcolor=color.red, size=size.small) be_ob = box.new(be_ob_index, high , bar_index + 10, low , bgcolor=be_ob_color, border_color=be_ob_border_color, text="Be-OB", text_color=be_ob_text_color, text_halign=text.align_right, text_size=text_size) be_bb = box.new(be_bb_index, high , bar_index + 10, low , bgcolor=be_bb_color, border_color=be_bb_border_color, text=h0 > h1 ? "Be-BB" : "Be-MB", text_color=be_bb_text_color, text_halign=text.align_right, text_size=text_size) array.push(be_ob_boxes, be_ob) array.push(be_bb_boxes, be_bb) for bull_ob in bu_ob_boxes bottom = box.get_bottom(bull_ob) top = box.get_top(bull_ob) if close < bottom f_delete_box(bu_ob_boxes) else if close < top alert("Price in the BU-OB zone") else box.set_right(bull_ob, bar_index + 10) for bear_ob in be_ob_boxes top = box.get_top(bear_ob) bottom = box.get_bottom((bear_ob)) if close > top f_delete_box(be_ob_boxes) if close > bottom alert("Price in the BE-OB zone") else box.set_right(bear_ob, bar_index + 10) for bear_bb in be_bb_boxes top = box.get_top(bear_bb) bottom = box.get_bottom(bear_bb) if close > top f_delete_box(be_bb_boxes) else if close > bottom alert("Price in the BE-BB zone") else box.set_right(bear_bb, bar_index + 10) for bull_bb in bu_bb_boxes bottom = box.get_bottom(bull_bb) top = box.get_top(bull_bb) if close < bottom f_delete_box(bu_bb_boxes) else if close < top alert("Price in the BU-BB zone") else box.set_right(bull_bb, bar_index + 10) alertcondition(ta.change(market) != 0, "MSB", "MSB") enableAutoTrend = input(true, "Enable Auto Trendlines", group="AUTO TRENDLINES SETTINGS") srcTrendChannel = input(close, "Trend channel source", group="AUTO TRENDLINES SETTINGS") lenTrendChannel = input.int(50, "Trend channel loopback", 2, group="AUTO TRENDLINES SETTINGS") a = ta.wma(srcTrendChannel, lenTrendChannel), b = ta.sma(srcTrendChannel, lenTrendChannel) A = 4 * b - 3 * a, B = 3 * a - 2 * b m = (A - B) / (lenTrendChannel - 1) d = 0., for i = 0 to lenTrendChannel - 1 by 1 l = B + m * i d += math.pow(srcTrendChannel - l, 2) rmse = math.sqrt(d / (lenTrendChannel - 1)) * 2 l(css, k) => line lr = enableAutoTrend ? line.new(bar_index - lenTrendChannel + 1, A + k, bar_index, B + k, extend=extend.right, color=css) : na line.delete(lr ) l(#808080, rmse), l(#808080, 0), l(#808080,-rmse) // ========================================================================================== // === Dashboard with Telegram Link === var table myTable = table.new(position.top_center, 1, 1, border_width=1, frame_color=color.black, bgcolor=color.white) table.cell(myTable, 0, 0, "", bgcolor=color.blue, text_color=color.white, text_size=size.normal)
Pine Script® indicator
by KSA_963
Iceberg strategy 2.0🇬🇧 Iceberg Strategy — Description (EN) Iceberg Strategy is a multi-timeframe trend-following and liquidity-based trading indicator designed for crypto markets. It combines H4 trend structure, MACD momentum, volume analysis, correlation filtering, and retest logic to identify high-probability entries aligned with institutional activity. The indicator focuses on filtering out low-quality signals by using 24H USD volume, BTC correlation, and buyer/seller dominance (Volume Fight), while providing clear risk management visualization with automatic Stop Loss and Take Profit levels. 🔍 Core Logic H4 MACD Trend Detection Identifies bullish and bearish market regimes Uses both standard and fast MACD to detect trend continuation and gray (transition) zones Gray Zone Trend Re-entry Detects pullbacks inside an active trend Generates continuation entries when momentum resumes Volume Fight (Liquidity Analysis) Compares bullish vs bearish volume using VWMA Detects accumulation and distribution zones Optional background highlighting 24H USD Volume Filter Ensures trading only high-liquidity assets Filters out low-volume and manipulated markets Correlation Filter Filters signals when correlation with BTC (or selected symbol) is too high Allows excluding specific symbols from correlation checks H1 Retest Entries Detects retests of key price levels after breakout Confirms entries only after successful retest 📈 Signals & Visuals BUY / SELL labels for main trend entries Triangle signals for retest entries Colored H4 candles Green — bullish trend Red — bearish trend Gray — transition / pullback zone Volume Fight background zones (optional) Information table with: H4 Trend direction Fast MACD value Correlation value 24H USD volume 🛡 Risk Management Automatic Stop Loss Based on ATR with configurable multiplier Multiple Take Profit levels RR-based targets (TP1–TP5) SL and TP lines can be enabled or disabled from settings ⚙️ Fully Configurable Enable / disable: Correlation filter Volume filter Volume Fight background Stop Loss / Take Profit lines Adjustable parameters for: ATR Correlation Volume thresholds Retest logic ⚠️ This indicator does not repaint signals and is intended for educational and analytical purposes only. Always use proper risk management.
Pine Script® indicator
by Alex8181999
2