Key Opens & LevelsThis indicator plots key market reference levels used by active traders, including:
- Previous day high, previous day low, and previous day equilibrium
- Higher-timeframe opens (daily, weekly, monthly)
- Custom intraday opening prices (e.g. 06:00, 8:30, 9:30, 10:00, etc)
All levels are session-aware, candle-anchored, and non-repainting, designed to stay aligned with real market structure across timeframes.
📈 Available Opens and Levels
PDH / PDL / PD-EQ
- PDH/PDL aren’t placed at the midnight candle or the daily bar open. They’re anchored to the actual intraday candle that made the previous day’s high or low.
- Choose when your daily open starts: it can be 15:00 for forex, 18:00 for futures, midnight for ICT traders, etc.
Higher-Timeframe Opens (D / W / M)
- Daily Open
- Weekly Open
- Monthly Open
Custom Intraday Opening Prices (Up to 6)
Plot up to six customizable intraday opens, such as 6:00, 08:30, 09:30, etc.
🔥 Features
Dynamic Line Extension
All levels extend only as far as price prints, keeping the chart clean and context-aware.
Unified Styling & Clean UI
- Shared style and width controls where appropriate
- Inline inputs for fast configuration
- Label offset and font size controlled globally for consistency
⚙️ Inputs Overview
SETTINGS (Global)
Label Offset (bars to the right)
Label Font Size
PDH / PDL / PD-EQ
Show / Hide Levels
Show / Hide Labels
Daily Session Open
Line Style & Width
Individual colors for PDH, PDL, and PD-EQ
D / W / M Opens
Toggle Daily / Weekly / Monthly opens
Individual colors
Shared line style & width
Intraday Opens
Up to 6 custom opening times
Custom label text (defaults to time)
Individual colors per opening
Shared line style & width
🛡️ Non-Repainting
The indicator does not repaint.
Levels are locked in once the new session begins.
Motif-Motif Chart
MACD 12-26-9 with Slope, Convergence & Divergence1. Core Indicator: MACD (12-26-9)
The script uses the standard MACD:
Fast EMA: 12
Slow EMA: 26
Signal EMA: 9
It plots:
MACD Line → short-term vs long-term momentum
Signal Line → smoothed MACD
Histogram → distance between MACD and Signal
2. Histogram Slope (Momentum Acceleration)
What it is
The slope measures how fast the MACD histogram is changing.
histSlope = hist - hist
What it tells you
Positive slope → momentum accelerating
Negative slope → momentum slowing
Slope flip → early momentum shift (often before MACD cross)
Why it matters
MACD crosses are lagging.
Histogram slope gives early warning of momentum changes.
3. Convergence & Divergence (MACD vs Signal)
How it’s calculated
The script measures the distance between the MACD and Signal lines:
distance = abs(macdLine - signalLine)
Convergence → distance is shrinking
Divergence → distance is expanding
Interpretation
Convergence = compression / energy building
Divergence = expansion / trend strength or exhaustion
This is not price divergence, but internal momentum structure.
4. MACD Perimeter Threshold (Momentum Filter)
What it is
Horizontal bands above and below zero that define a “noise zone”.
Inside perimeter → weak / choppy momentum
Outside perimeter → strong momentum
Why it’s useful
Filters low-quality MACD crosses
Identifies compression → expansion
Helps spot trend exhaustion when momentum fades outside the band
5. Visual Encoding (What you see)
Histogram colors
Bright green / red → strong acceleration
Dull green / maroon → weakening momentum
Gray → indecision
MACD line color
Yellow → converging (compression)
Orange → diverging (expansion)
Blue → neutral
Markers
Up triangle → bullish convergence
Down triangle → bearish divergence
6. How traders use this indicator
Trend continuation
MACD above zero
Histogram positive
Slope rising
Divergence expanding
➡ Strong trend continuation
Pullback entries
Trend intact
Histogram pulls back toward zero
Slope turns up again
➡ High-probability re-entry
Breakout anticipation
Long convergence
Histogram flattening
Sudden slope expansion
➡ Breakout likely
Exhaustion warning
Large divergence
Histogram slope weakens
Momentum fails to expand
➡ Trend may stall or reverse
7. Best use cases
Works best as a momentum confirmation tool
Combine with:
Market structure
Support / resistance
Moving averages
Volume or Force Index
Session OpensThis Indicator Draws Session open labels for Asia Session-New York Session-London Session with Optional Alerts.
Buy and Sell Signals (Heiken Ashi)This indicator displays Buy And Sell Signals With Alerts based on custom conditions derived from Heiken Ashi candles.
Week High/LowThis indicator plots the Previous Week High and Low as two horizontal dashed lines.
It is designed to appear only on the Daily (D) and Weekly (W) timeframes, ensuring a clean higher-timeframe context without lower-timeframe noise.
The levels are calculated from the completed weekly candle and automatically update at the start of each new week.
These levels serve as weekly liquidity references, commonly used to assess premium/discount zones, potential stop-run areas, and higher-timeframe market reactions.
SmartCapitalInvest🧠 SmartCapitalInvest – Market Structure, FVG, EMA & Fibonacci
The SmartCapitalInvest Indicator combines several professional analysis tools into one clean and structured layout — perfect for traders who value precision and clarity.
🔍 Key Features:
Highs & Lows: Automatically detects major structure points in the market. Small arrows mark new highs and lows for quick visual orientation.
Fair Value Gaps (FVG): Highlights market inefficiencies. FVGs are automatically detected and removed once they are partially or fully filled.
EMA (Exponential Moving Average): A dynamic trend indicator that helps identify potential reversal zones and confirms market direction.
Fibonacci Tool: Automatically draws a structure-based Fibonacci retracement (Levels 0, 0.75, 1.0) between the latest valid high–low structures — ideal for analyzing retracements in trending markets.
⚙️ Benefits:
Clean, minimalistic visualization without unnecessary labels or lines.
Detects only relevant external structure points (no internal swings).
Designed for Smart Money Concepts traders who prefer a structured, market-based approach to analysis.
Smart Scalper Pro Template + VWAP
📌 Author
Garry Evans
Independent system developer focused on:
Risk-first automation
Market structure & liquidity behavior
Discipline, consistency, and capital preservation
“The edge isn’t the market — it’s the man who survives it.”
⚙️ Risk Management & Position Sizing
The script is built around capital protection, not signal frequency.
Risk logic includes:
Fixed or dynamic risk per trade
Market-adaptive position sizing
Session-based trade limits
Daily trade caps and auto-lockout protection
Volatility-aware sizing (futures & crypto)
⚠️ Profit is pursued only after risk is controlled.
📊 Track Record
Backtested across multiple market environments
Forward-tested and actively used by the author
Real-account trades are logged where platform rules allow
Results vary by market, timeframe, and user-defined risk settings.
🌍 Supported Markets
Designed to work across all liquid markets, including:
Stocks
Crypto (spot & futures)
Options (signal-based framework)
Futures (indices, metals, crypto futures)
The system adapts to volatility and structure — it is not market-specific.
⚖️ Leverage
Leverage is not required
If used, leverage is fully user-controlled
Risk logic scales exposure conservatively
No martingale.
No revenge sizing.
No over-exposure logic.
🧪 Backtesting
✔ Yes
Strategy logic has been backtested
Filters reduce chop, noise, and forced trades
Focus on drawdown control over curve-fitting
🛠 Support
✔ Yes
Direct author support
Ongoing improvements and updates
Feature refinement based on real usage and feedback
👥 Community
✔ Yes
Private user access
High-quality feedback environment
No public signal spam or hype-driven chat rooms
⏳ Trial Period
✔ Yes
Limited trial access available
Designed for evaluation only
Trial users do not receive full feature access
🚫 Who This Script Is NOT For
This system is not for:
Traders looking for guaranteed profits
Users expecting copy-paste “signal calls”
Over-leveraged gamblers
Those unwilling to follow risk rules
Anyone seeking overnight results
This is a discipline and automation tool, not a shortcut.
🧠 Final Positioning
This is not a signal service.
This is a risk-controlled execution framework designed to:
Enforce discipline
Reduce emotional trading
Protect capital during bad market conditions
Scale responsibly during favorable ones
NY Open Edge (NQ only)📊 NY Open Edge - Session Direction Predictor
Predict NY session direction using backtested Asia-London pattern analysis
Based on 5 years of data (2021-2025, 1,283 trading days), this indicator analyzes overnight session relationships to predict
which direction the New York session will likely move first.
🎯 What It Does
Tracks Asia (8pm-2am ET) and London (2am-8am ET) session ranges, then at NY open (8am ET) it:
1. Classifies the pattern - How London interacted with Asia range
2. Checks NY open position - Above or below London midpoint
3. Displays probabilities - Statistical edge for high/low sweeps based on historical data
4 Pattern Types
- P1 - London Engulfs Asia: London range contains Asia range
- P2 - Asia Engulfs London: Asia range contains London range
- P3 - Partial Up (Bullish): London breaks above Asia high only
- P4 - Partial Down (Bearish): London breaks below Asia low only
💡 How To Use
Reading the Dashboard
The indicator displays:
- Pattern - Which of the 4 patterns occurred
- NY Open Position - ABOVE or BELOW London midpoint
- First High Sweep % - Probability of taking highs first
- First Low Sweep % - Probability of taking lows first
- Median Penetration - Typical point movement
- Failure Rate - How often both sides get swept (choppy sessions)
- Tier Classification - Reliability (Tier 1 = Best, Tier 3 = Risky)
- Sample Size - Historical occurrences
⚙️ Settings
- Display Options - Toggle session boxes, midlines, and dashboard
- Colors - Customize session colors and transparency
- Dashboard Theme - Dark (for dark charts) or Light (for light charts)
- Max Sessions - Memory management (10-150 sessions)
- Timezone - Default America/New_York (DST-aware)
---
📋 Best Practices
✅ Is designed for NQ only!
✅ Use 5m-15m timeframes for clear session definitions
✅ Combine with your own analysis - this is a probability tool
✅ Focus on Tier 1 setups for highest win rates
✅ Respect the failure rate - high percentages suggest choppy sessions
---
⚠️ RISK DISCLAIMER
THIS INDICATOR IS FOR EDUCATIONAL AND INFORMATIONAL PURPOSES ONLY
- NOT financial advice - Do not trade based solely on this indicator
- Past performance does not guarantee future results - Historical statistics may not reflect future market behavior
- Trading involves substantial risk of loss - Only trade with capital you can afford to lose
- Use proper risk management - Always use stop losses and appropriate position sizing
- Backtest limitations - Results based on historical data that may not repeat
- No guarantees - Probabilities are not certainties; markets can behave unpredictably
You are solely responsible for your trading decisions and outcomes.
DayTradeMind Combined High Win Rate StrategyThe DayTradeMind Combined High Win Rate Strategy is a trend-following system that relies on confluence—the idea that a trade signal is stronger when multiple independent indicators agree. Instead of entering on a single indicator's whim, it uses a "voting" system to qualify entries and a strict risk-to-reward ratio to manage exits.Here is a breakdown of the three main layers of this strategy:1. The Voting Engine (Confluence Model)The strategy tracks four indicators and assigns a "point" for a bullish or bearish bias. It requires a minimum number of points (set by minConfirmations, usually 2/4) before it even considers a trade.IndicatorBullish Condition (1 point)Bearish Condition (1 point)PurposeMACDMACD Line > Signal LineMACD Line < Signal LineMeasures short-term momentum.DonchianPrice > 20-period MedianPrice < 20-period MedianIdentifies price relative to recent range.SuperTrendPrice above trend linePrice below trend lineFilters for the "Macro" trend direction.%B (Bollinger)Price in lower-mid range (0.2–0.5)Price in upper-mid range (0.5–0.8)Prevents buying when overextended.2. The Entry TriggerHaving enough "votes" (confirmations) isn't enough to enter. The strategy waits for a trigger event to ensure you aren't entering a stale trend. An entry only occurs if the minimum confirmations are met AND one of the following happens on the current bar:MACD Cross: The MACD line crosses over the signal line.Structural Break: The price crosses over the Donchian Middle (Median) line.This "Confirmation + Trigger" approach is designed to catch the start of a momentum push rather than buying a flat market.3. Mathematical Risk ManagementThe performance you see in your backtest (like the 46.86% return) is largely driven by the 2:1 Reward-to-Risk (RR) Ratio.Stop Loss (SL): Fixed at 2% below entry.Take Profit (TP): Fixed at 4% above entry.By aiming for a target twice as large as the risk, the strategy can remain profitable even with a win rate as low as 35%–40%. Mathematically, your winning trades compensate for more than two losing trades.Visualizing the SystemTriangles: Small green (up) and red (down) triangles appear on your chart only when the Votes + Trigger align perfectly.Background Shading: Faint green or red bands show you exactly when the "Confluence" is active. If the background is gray, the indicators are in conflict.Dashboard: The table in the top-right summarizes the current "score" for each indicator, letting you know how close you are to a potential trade signal.
Finlu Momentum PROFinlu Momentum PRO is a momentum oscillator designed to detect exhaustion zones and potential short-term reversals.
The indicator calculates a smoothed momentum from price changes and normalizes it around 0. On top of that momentum, it builds:
Overbought and oversold levels: when the main line enters these zones, it highlights extreme momentum conditions.
Central neutral zone: helps distinguish strong momentum phases from consolidation phases.
Signal line: a moving average of the momentum itself, used to confirm crossovers and exits from extreme zones.
Repetition filters: limit the number of consecutive signals to reduce noise when the market is ranging.
Reversal detection: additional conditions that require momentum to turn from extreme zones before enabling a signal.
Divergences: compares price highs and lows with the momentum line to highlight potential exhaustion of the move.
Basic usage:
Sell signals when momentum comes from overbought, loses strength and crosses below the signal line, while passing the reversal and repetition filters.
Buy signals when the opposite occurs from oversold levels.
Bearish divergences appear when price makes a higher high, but momentum makes a lower high.
Bullish divergences appear when price makes lower lows, but momentum makes higher lows.
This indicator is designed to be combined with your own price-action and market structure analysis. It is not a buy/sell recommendation or a standalone automated system. The user remains fully responsible for risk management, instrument selection and timeframe choice.
WatchmenThe Watchmen Indicator tracks potential market maker breakeven zones using dynamic open/close ranges (no wicks in Fib calc). It expands the range until the 50% level is breached by the full candle range, then resets. Green = long/down setups (buy retrace), Red = short/up setups (sell retrace). Uses only open/close for levels, high/low for breaches. Ideal for mean-reversion in trends.
JSRM NEO 1.00+Educational analysis for reviewing short and long pivots while focussing on the intra bar volatility to gain a specific data function to discern the longevity of the microtrends that are constructing the macro long short trends based on a regression model.
HoneG_CCIv17HoneG_CCIv17
This is a signal tool capable of both counter-trend and trend-following trading. Apply it to 1-minute charts.
For trend-following, it features a rapid-fire mode. When conditions align, rapid-fire mode activates, and two indicators signaling the rapid-fire timing will turn ON/OFF in sync with price extension moments.
逆張りも順張りも出来るサインツールです。１分足チャートに適用してください。
順張りには連打モードがあり、条件が揃うと連打モードが発動し、連打タイミングを知らせる二か所の表示が、価格が伸びるタイミングに合わせてON/OFFします。
BIAS+KeyLevels - R.AlvaradoBIAS+KeyLevels – R. Alvarado
This indicator identifies the institutional market bias (BIAS) on Monthly, Weekly, and Daily timeframes using confirmed Turtle Soup–style candle closes.
It also automatically plots the Key Levels (high / low) from the Monthly, Weekly, Daily, and 4H timeframes, along with the 50% level of the previous candle for each higher timeframe.
It is designed for traders who operate on lower timeframes and require clear, clean, and structural market context to anticipate potential reaction zones without cluttering the chart.
Major S/R Levels Filtered v.1 BETA
This indicator automatically identifies and plots major support and resistance (S/R) levels on your chart based on swing highs and swing lows across multiple timeframes. It also intelligently merges nearby levels to avoid clutter and displays price labels to the right of the levels.
Features:
Detects monthly, weekly, and daily swing highs and lows.
Merges nearby levels automatically based on a customizable minimum distance (%), producing cleaner and more meaningful S/R zones.
Daily levels can be filtered by the number of touches to ensure significance.
Lines are drawn fully extended to the right, providing a clear view of historical S/R.
Price labels are displayed to the right of each level, stacked to prevent overlapping. Labels include the timeframe and price, with customizable text templates.
Transparent label backgrounds improve visibility without cluttering the chart.
Customizable parameters: pivot length, minimum touches, label offset, minimum distance for merging, and label text template.
Usage:
Select which timeframes to display: Monthly, Weekly, Daily.
Adjust pivot length and filter settings to match your trading style.
Observe merged S/R levels with clearly labeled prices on the right side of the chart.
This indicator is perfect for traders who want a clean, historical S/R framework for intraday, swing, and long-term analysis.
Futures Sizing Calculator (Greg.Trading)📐 Futures Sizing Calculator
by Greg.Trading
🔍 Overview
The Futures Sizing Calculator is a visual risk-management tool built for futures traders who demand precision.
It allows you to define your entry, stop-loss, and maximum dollar risk, then instantly calculates optimal contract sizing—directly on the chart.
No spreadsheets. No mental math. Just clear, actionable risk data.
🎯 What This Indicator Does
This indicator combines trade visualization with dynamic position sizing:
✔ Draws Entry and Stop-Loss levels on the chart
✔ Highlights the risk area between entry and stop
✔ Automatically detects LONG or SHORT direction
✔ Calculates stop distance in points
✔ Determines contract size for multiple futures
✔ Displays exact dollar risk per contract size
✔ Updates instantly as prices change
📊 Supported Contracts
The calculator currently supports the most commonly traded CME micro futures:
MNQ – Micro Nasdaq
MES – Micro S&P 500
MGC – Micro Gold
Each contract is calculated using its true point value for accurate risk sizing.
🧮 How the Calculations Work (Conceptually)
The script uses a fixed-risk position sizing model, commonly used by professional traders:
1️⃣ You define a maximum dollar risk per trade
2️⃣ The script measures the distance between Entry and Stop
3️⃣ That distance is multiplied by each contract’s point value
4️⃣ Contract size is calculated to stay within your risk limit
You are shown two sizing options:
Conservative → rounded down (risk stays below limit)
Aggressive → rounded up (risk slightly exceeds limit)
This lets you choose the exposure that best fits your trading plan.
🧭 Visual Trade Mapping
To improve clarity and execution speed, the indicator provides:
🟩 Green / Red dotted lines for Entry and Stop
📦 A transparent risk box between those levels
🔁 A centered LONG or SHORT label inside the risk area
📌 A floating panel displaying all sizing calculations
Everything is placed where your eyes already are—on the chart.
⚙️ How to Use
Add the indicator to any futures chart
Set your Account Size and Risk Amount
Enter your Entry price
Enter your Stop-Loss price
Review:
Trade direction
Risk box
Contract sizing panel
Adjust entry or stop at any time and the calculations update instantly.
⭐ Why This Indicator Is Different
Unlike basic sizing calculators or static tools, this indicator:
✅ Is fully chart-based
✅ Shows real dollar risk, not estimates
✅ Supports multiple contracts at once
✅ Combines numbers with visual confirmation
✅ Is built for live execution and planning
It’s designed to be used during real trades, not just before them.
⚠️ Important Notes
• This is a risk-management tool, not a trading strategy
• It does not generate buy or sell signals
• Always confirm calculations align with your broker’s specifications
BK AK-King Quazi🦁👑 BK AK–KING QUAZI — MEASURED HAND, CLEAN BLADE. 👑🦁
All glory to Gd — the true source of wisdom, restraint, and endurance.
AK is honor — my mentor’s standard: clarity, patience, no shortcuts, no gambling.
Update / Record: A previous version of this publication was hidden by PineCoders moderation due to insufficient description. This republish includes a fully self-contained explanation of what the script does, how it works, and how to use it.
1) What this script does (outputs)
BK AK–King Quazi is a Quasimodo (QM) structure manager that turns the pattern into a permissioned process:
PROTO → BOS proof → RETEST → CONFIRM → resolve or invalidate
On-chart you get:
Stage labels: P↑ / P↓ (PROTO), R↑ / R↓ (RETEST), C↑ / C↓ (CONFIRM), X (INVALIDATED), ✓ (TARGET HIT)
Execution map lines: QM, BOS, INV (invalidation)
Optional projection extension forward (QM/BOS/INV + optional T1/T2)
Optional entry zone around QM (ATR buffer)
MTF “War Room” table: 5 timeframes showing STATE and NOW (recent events)
This is not a “pattern sticker.” It’s a workflow + object lifecycle so outcomes are visible and charts stay clean.
2) Definitions (what each stage means)
PROTO (P): “Sweep + BOS candidate.” Early awareness that a QM setup is forming.
BOS (Break of Structure): requires a body displacement vs ATR (proof filter).
RETEST (R): price returns to the QM level and holds it (permission test).
CONFIRM (C): full QM geometry is complete (structure + proof + timing aligned).
INV: invalidation level. If breached, the pattern is failed and marked X.
Targets: optional T1/T2 mapped from selected target mode.
3) How it works (actual logic in plain English)
A) Swing engine (how structure is built)
The script uses a ZigZag-style swing detector based on lookbacks:
A “to_up” swing trigger occurs when high reaches the highest high over zz_len
A “to_down” swing trigger occurs when low reaches the lowest low over zz_len
Trend flips on those triggers and the script stores the last 3 swing points:
Highs: h2 → h1 → h0
Lows: l2 → l1 → l0
This creates repeatable swing structure without manual drawing.
B) BOS displacement filter (proof of intent)
A BOS is only accepted if the candle body displacement is large enough:
Displacement condition: abs(close - open) ≥ disp_used * ATR(atr_len)
disp_used can be:
Manual, or
Auto (TF Map), or
Auto (ATR%)
This is the “no wick theater” filter.
C) PROTO detection (sweep + BOS)
Bull PROTO fires when:
structure suggests a sweep (higher swing high behavior) and
price sweeps below a prior swing low, then BOS closes above h1 with displacement
Bear PROTO is the mirror:
sweep above a prior swing high, then BOS closes below l1 with displacement
On PROTO, the script defines the key levels:
Bull: QM = l1, BOS = h1, INV = current low
Bear: QM = h1, BOS = l1, INV = current high
D) RETEST + CONFIRM
RETEST checks the return to QM with a hold:
Bull retest: low ≤ QM and close ≥ QM
Bear retest: high ≥ QM and close ≤ QM
CONFIRM triggers only when the full swing sequence meets the “QM complete” rules (the script’s bu_conf / be_conf conditions).
E) Targets / projection math (if enabled)
Targets are optional:
Measured (1.0 / 1.618): uses the distance |BOS − QM| times multipliers
BOS + prior swing: uses BOS + prior swing extreme
Neck→Head (H&S projection): projects neck/head distance from BOS
F) Object lifecycle (keeps chart honest and readable)
If opposite PROTO appears, you can:
do nothing, or
clear projections, or
mark X + clear the prior campaign
On invalidation, the script replaces the existing P/C label with X (no overlapping junk)
On target hit, it can resolve the campaign and optionally remove projections/tags
4) MTF War Room (what the table means)
The table shows 5 user-selectable timeframes (TF1–TF5) with:
STATE: current posture on that TF (P↑, C↑, P↓, C↓, —)
NOW: highlights recent PROTO/CONFIRM events on that TF
Implementation note (what’s original here):
It computes zigzag + displacement inside each TF context
“NOW” flash timing is measured in that TF (not chart TF)
It packs NOW + RECENT + STAGE into one request.security() call per TF (performance-aware)
5) How to use it (clean execution workflow)
Suggested workflow (AK standard):
Use MTF first: don’t fight higher court structure
Treat PROTO as awareness, not permission
Require BOS displacement (proof)
Execute only on RETEST of QM or on your CONFIRM rules
Stop is INV (if INV breaks, mark X and stand down)
Use mapped T1/T2 for planning + resolution (no improvising mid-trade)
Label key:
P = Proto (sweep + BOS)
R = Retest (QM hold)
C = Confirm (full QM)
X = Invalidated (broke INV)
✓ = Target hit (T1/T2 resolution)
6) What’s original (why it’s not “another QM clone”)
Quasimodo is public. The originality here is the system around it:
staged sequencing (PROTO → BOS proof → RETEST → CONFIRM) instead of “shape = signal”
ATR displacement proof filter to cut fake BOS
standardized level mapping (QM/BOS/INV + targets + entry zone)
object lifecycle management (replace labels with X, clear/gray projections, remove on target)
MTF packed engine (one call per TF; “NOW” measured on that TF)
controlled alert routing by event type (PROTO vs CONFIRM)
7) Limitations (important)
This is bar-based structure logic; it can change during an unclosed realtime candle.
ZigZag swings are lookback-based, not a broker “official” swing definition.
It’s a structure/permission tool, not a guarantee engine.
🧑🏫 BK / AK / Faith
BK is the mark I’m building.
AK is honor — discipline, patience, clean execution.
All glory to Gd — the true source of wisdom and endurance.
🗡️ King David Lens (Deep — Discipline Under Fire)
David’s power wasn’t impulse. It was governed force — strength that answers to law.
He learned early that the most dangerous trap is moving before you’re sent.
That’s why his life is full of the same pattern traders ignore:
He was anointed long before he was crowned.
Meaning: truth can be real before it’s allowed to manifest.
He fought Goliath with a weapon people mocked — not because it was flashy, but because it was mastered.
Meaning: edge isn’t what looks impressive — it’s what’s trained and repeatable.
He had Saul in his hands and still refused the shortcut.
Meaning: opportunity is not permission; proximity is not assignment.
He waited through wilderness seasons where nothing “looked like progress.”
Meaning: silence isn’t rejection — sometimes it’s preparation.
That is the trader’s war.
Price will always offer motion.
But motion without permission is bait.
David didn’t survive by chasing what was available.
He survived by waiting until the moment was proved, the ground was chosen, and the strike was clean.
That’s what King Quazi enforces:
PROTO is the rumor.
BOS displacement is the proof.
Retest is the test of legitimacy.
Confirm is permission to strike.
Invalidation is humility — stand down immediately.
A lion doesn’t chase every shadow.
A lion waits until the prey is committed — then ends it.
🦁👑 BK AK–KING QUAZI — execute with proof. 👑🦁
Gd bless. 🙏
Fibonacci Stochastic + HMA + EMA Fibonacci Stochastic + HMA + EMA
This indicator is designed to help identify trends and entry timing by combining three main indicators.
It filters out false signals and increases the accuracy of decision-making.
Key Components of the Indicator:
Hull Moving Average (HMA)
Shows the main price trend.
Green = Uptrend
Red = Downtrend
Used to confirm that the trade is following the market direction (Trend Following).
Fibonacci Stochastic
Measures the buying and selling pressure of the market.
Uses Fibonacci levels:
0.236 / 0.382 / 0.5 / 0.618 / 0.786
The system will interpret this as a Bullish/Bearish signal.
Used to find "entry points," not to predict highs or lows.
Display Results:
Green candlestick → Buy momentum
Red candlestick → Sell momentum
EMA Short/Long (Multi-Timeframe)
Uses EMA values from a smaller timeframe (e.g., 1 minute).
Compares short-term and long-term EMAs.
Used to confirm trend strength and short-term reversals.
EMA values are hidden by default for a cleaner chart.
Signal Conditions
BUY Signal
The system will give a BUY signal when:
The HMA trend is upward.
The short-term EMA is above the EMA average.
The Stochastic is in the bullish zone.
Display:
The word BUY is below the candlestick.
SELL Signal
The system will give a SELL signal when:
The HMA trend is downward.
The short-term EMA is below the EMA average.
The Stochastic is in the bearish zone.
Display:
The word SELL is above the candlestick.
Recommended Usage Approach
Suitable Timeframe
Scalping: 1m – 5m
Intraday: 5m – 15m
Trend Trade: 15m – 1h
Notes
Should be used in conjunction with:
Support / Resistance
Price Action
Risk Management
Magnitude of MovementThie calculase the ratio between Mod of Open Price-Current Price and Mod of Open Volume and current volume
Chip Distribution Pro// This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// Enhanced Position Cost Distribution - Auto-adaptive with improved visualization
// Works with ETFs, commodities, forex, crypto, stocks - any instrument
// @version=5
indicator('Chip Distribution Pro', overlay = true, max_lines_count = 500, max_bars_back = 500)
//#region Inputs
string GRP_GENERAL = "General Settings"
int LOOKBACK = input.int(1000, 'Lookback Bars', maxval = 20000, minval = 500, step = 250, group = GRP_GENERAL)
int CHART_X_OFFSET = input.int(100, 'Chart Offset', step = 10, group = GRP_GENERAL)
int LABEL_X_OFFSET = CHART_X_OFFSET + 4
int CHART_MAX_WIDTH = input.int(80, 'Max Width', maxval = 500, minval = 10, step = 10, group = GRP_GENERAL)
int NUM_BUCKETS = input.int(400, 'Price Buckets', maxval = 500, minval = 50, step = 50, group = GRP_GENERAL)
string GRP_AUTO = "Auto-Tuning"
bool AUTO_TUNE = input.bool(true, 'Enable Auto-Tuning', group = GRP_AUTO,
tooltip = 'Automatically adjusts turnover rate based on volatility and volume characteristics')
float MANUAL_DECAY = input.float(0.1, 'Manual Turnover Rate', minval = 0.01, maxval = 0.5, step = 0.01, group = GRP_AUTO,
tooltip = 'Only used when Auto-Tuning is disabled')
int VOLATILITY_PERIOD = input.int(20, 'Volatility Period', minval = 5, maxval = 100, group = GRP_AUTO)
string GRP_VISUAL = "Visualization"
string COLOR_SCHEME = input.string("Rainbow", "Color Scheme", options = , group = GRP_VISUAL)
color PROFIT_COLOR_LIGHT = input.color(#26a69a, 'Profit Light', group = GRP_VISUAL)
color PROFIT_COLOR_DARK = input.color(#004d40, 'Profit Dark', group = GRP_VISUAL)
color LOSS_COLOR_LIGHT = input.color(#ef5350, 'Loss Light', group = GRP_VISUAL)
color LOSS_COLOR_DARK = input.color(#b71c1c, 'Loss Dark', group = GRP_VISUAL)
color CURRENT_PRICE_COLOR = input.color(color.yellow, 'Current Price', group = GRP_VISUAL)
color AVG_PRICE_COLOR = input.color(#2196F3, 'Average Cost', group = GRP_VISUAL)
color PEAK_COLOR = input.color(#FF9800, 'Peak Concentration', group = GRP_VISUAL)
color STATS_COLOR = input.color(#434651, 'Stats Background', group = GRP_VISUAL)
string GRP_LEVELS = "Key Levels"
bool SHOW_SUPPORT_RESISTANCE = input.bool(true, 'Show Support/Resistance Zones', group = GRP_LEVELS)
bool SHOW_PEAK = input.bool(true, 'Show Peak Concentration', group = GRP_LEVELS)
float SR_THRESHOLD = input.float(0.7, 'S/R Detection Threshold', minval = 0.3, maxval = 0.95, step = 0.05, group = GRP_LEVELS,
tooltip = 'Minimum concentration (relative to peak) to mark as support/resistance')
string GRP_SIGNALS = "Signals Panel"
bool SHOW_SIGNALS = input.bool(true, 'Show Signal Panel', group = GRP_SIGNALS)
bool SHOW_KEY_LEVELS = input.bool(true, 'Show Key Price Levels', group = GRP_SIGNALS)
bool SHOW_TREND_ARROW = input.bool(true, 'Show Trend Arrow', group = GRP_SIGNALS)
bool SHOW_PRESSURE_BAR = input.bool(true, 'Show Pressure Bar', group = GRP_SIGNALS)
// Colors for key levels
color SUPPORT_COLOR = input.color(#00E676, 'Support Level', group = GRP_LEVELS)
color RESISTANCE_COLOR = input.color(#FF5252, 'Resistance Level', group = GRP_LEVELS)
color BREAKOUT_COLOR = input.color(#FFD600, 'Breakout Level', group = GRP_LEVELS)
//#endregion
//#region Candle Type
type Candle
int idx
float hi
float lo
float vol
float relativeVol
float atrPct
//#endregion
//#region PCD Type
type PCD
array candles
float minPrice
float maxPrice
float priceStep
array lines
label currentPriceLabel
label avgPriceLabel
label peakLabel
label statsLabel
label signalLabel
array srZones
float calculatedTurnover
// New visualization elements
line supportLine
line resistanceLine
line avgCostLine
label trendArrow
box pressureBar
box pressureFill
label pressureLabel
// Create a new price label
newPriceLabel(color bg, color txtColor) =>
label.new(0, 0, '', style = label.style_label_left, color = bg, textcolor = txtColor, size = size.small)
// Create a new PCD instance
newPCD() =>
array lns = array.new(NUM_BUCKETS)
for i = 0 to NUM_BUCKETS - 1
array.set(lns, i, line.new(0, 0, 0, 0))
PCD.new(
candles = array.new(0),
lines = lns,
currentPriceLabel = newPriceLabel(color.new(#00BCD4, 0), color.white),
avgPriceLabel = newPriceLabel(AVG_PRICE_COLOR, color.white),
peakLabel = newPriceLabel(PEAK_COLOR, color.white),
statsLabel = label.new(0, 0, '', style = label.style_label_up, size = size.small,
textalign = text.align_left, color = color.new(STATS_COLOR, 20), textcolor = color.white),
signalLabel = label.new(0, 0, '', style = label.style_label_left, size = size.small,
textalign = text.align_left, color = color.new(#1a1a2e, 20), textcolor = color.white),
srZones = array.new(0),
calculatedTurnover = 0.1,
minPrice = na,
maxPrice = na,
priceStep = na,
supportLine = line.new(0, 0, 0, 0, color = SUPPORT_COLOR, width = 2, style = line.style_dashed),
resistanceLine = line.new(0, 0, 0, 0, color = RESISTANCE_COLOR, width = 2, style = line.style_dashed),
avgCostLine = line.new(0, 0, 0, 0, color = AVG_PRICE_COLOR, width = 2, style = line.style_dotted),
trendArrow = label.new(0, 0, '', style = label.style_label_center, size = size.large, textcolor = color.white),
pressureBar = box.new(0, 0, 0, 0, bgcolor = color.new(#424242, 50), border_color = color.gray),
pressureFill = box.new(0, 0, 0, 0, bgcolor = color.green, border_color = na),
pressureLabel = label.new(0, 0, '', style = label.style_label_right, size = size.tiny, color = color.new(#000000, 100), textcolor = color.white))
// Auto-calculate turnover rate based on instrument characteristics
calcAdaptiveTurnover(float atrPct, float volRatio) =>
float safeAtrPct = na(atrPct) or atrPct <= 0 ? 0.02 : atrPct
float safeVolRatio = na(volRatio) or volRatio <= 0 ? 1.0 : volRatio
float volBasedTurnover = math.max(0.03, math.min(0.3, safeAtrPct * 3))
float volAdjustment = math.max(0.5, math.min(2.0, safeVolRatio))
float turnover = volBasedTurnover * volAdjustment
math.max(0.02, math.min(0.4, turnover))
// Store candle method
method storeCandle(PCD this, int barIdx, float hiPrice, float loPrice, float volVal, float avgVol, float atrPct) =>
if not na(hiPrice) and not na(loPrice) and not na(volVal) and volVal > 0
float safeAvgVol = na(avgVol) or avgVol <= 0 ? volVal : avgVol
float relVol = volVal / safeAvgVol
float safeAtrPct = na(atrPct) ? 0.02 : atrPct
bool modified = false
int candleSize = array.size(this.candles)
if candleSize > 0
Candle c = array.get(this.candles, candleSize - 1)
if c.idx == barIdx
c.hi := hiPrice
c.lo := loPrice
c.vol := volVal
c.relativeVol := relVol
c.atrPct := safeAtrPct
modified := true
if not modified
Candle c = Candle.new(barIdx, hiPrice, loPrice, volVal, relVol, safeAtrPct)
array.push(this.candles, c)
this.minPrice := na(this.minPrice) ? loPrice : math.min(this.minPrice, loPrice)
this.maxPrice := na(this.maxPrice) ? hiPrice : math.max(this.maxPrice, hiPrice)
float priceRange = this.maxPrice - this.minPrice
this.priceStep := priceRange > 0 ? priceRange / NUM_BUCKETS : 0.0001
// Get bucket index for price
method getBucketIndex(PCD this, float price) =>
if na(this.priceStep) or this.priceStep <= 0 or na(this.minPrice)
0
else
int idx = int(math.floor((price - this.minPrice) / this.priceStep))
math.max(0, math.min(idx, NUM_BUCKETS - 1))
// Get price for bucket index
method getBucketedPrice(PCD this, int bucketIdx) =>
int safeIndex = math.max(0, math.min(bucketIdx, NUM_BUCKETS - 1))
float safeStep = na(this.priceStep) or this.priceStep <= 0 ? 0.0001 : this.priceStep
float safeMin = na(this.minPrice) ? 0.0 : this.minPrice
(safeIndex + 0.5) * safeStep + safeMin
// Get rainbow color based on position (0.0 = bottom/red, 1.0 = top/violet)
getRainbowColor(float position, float intensityRatio) =>
float pos = math.max(0.0, math.min(1.0, position))
int transparency = int(math.round((1.0 - intensityRatio) * 50))
// Rainbow spectrum: red -> orange -> yellow -> green -> cyan -> blue -> violet
if pos < 0.166
color.new(color.from_gradient(pos, 0.0, 0.166, #FF0000, #FF7F00), transparency)
else if pos < 0.333
color.new(color.from_gradient(pos, 0.166, 0.333, #FF7F00, #FFFF00), transparency)
else if pos < 0.5
color.new(color.from_gradient(pos, 0.333, 0.5, #FFFF00, #00FF00), transparency)
else if pos < 0.666
color.new(color.from_gradient(pos, 0.5, 0.666, #00FF00, #00FFFF), transparency)
else if pos < 0.833
color.new(color.from_gradient(pos, 0.666, 0.833, #00FFFF, #0000FF), transparency)
else
color.new(color.from_gradient(pos, 0.833, 1.0, #0000FF, #8B00FF), transparency)
// Get color based on scheme and intensity
getColor(bool isProfitable, float intensity, float maxIntensity, int bucketIdx) =>
float safeMax = maxIntensity > 0 ? maxIntensity : 1.0
float ratio = math.max(0.0, math.min(1.0, intensity / safeMax))
float positionRatio = bucketIdx / math.max(1.0, NUM_BUCKETS - 1.0)
if COLOR_SCHEME == "Rainbow"
getRainbowColor(positionRatio, ratio)
else if COLOR_SCHEME == "Gradient"
if isProfitable
color.from_gradient(ratio, 0.0, 1.0, PROFIT_COLOR_DARK, PROFIT_COLOR_LIGHT)
else
color.from_gradient(ratio, 0.0, 1.0, LOSS_COLOR_DARK, LOSS_COLOR_LIGHT)
else if COLOR_SCHEME == "Heatmap"
color.from_gradient(ratio, 0.0, 1.0, #1a237e, #f44336)
else
if isProfitable
color.new(#5d606b, int(math.round((1.0 - ratio) * 70)))
else
color.new(#e91e63, int(math.round((1.0 - ratio) * 70)))
// Update method
method update(PCD this) =>
int candleCount = array.size(this.candles)
if candleCount > 0 and not na(this.priceStep) and this.priceStep > 0
// Create distribution array
array dist = array.new_float(NUM_BUCKETS, 0.0)
// Process each candle
for candleIdx = 0 to candleCount - 1
Candle candle = array.get(this.candles, candleIdx)
bool isFirstCandle = candleIdx == 0
float turnover = AUTO_TUNE ? calcAdaptiveTurnover(candle.atrPct, candle.relativeVol) : MANUAL_DECAY * candle.relativeVol
turnover := math.min(turnover, 0.95)
this.calculatedTurnover := turnover
int startIdx = this.getBucketIndex(candle.lo)
int endIdx = this.getBucketIndex(candle.hi)
int buckets = math.max(1, endIdx - startIdx + 1)
if isFirstCandle
float initialWeight = 1.0 / buckets
for i = startIdx to endIdx
array.set(dist, i, initialWeight)
else
float decayedAmount = 0.0
for i = 0 to NUM_BUCKETS - 1
float oldVal = array.get(dist, i)
float newVal = oldVal * (1.0 - turnover)
array.set(dist, i, newVal)
decayedAmount += oldVal - newVal
float addPerBucket = decayedAmount / buckets
for i = startIdx to endIdx
array.set(dist, i, array.get(dist, i) + addPerBucket)
// Normalize distribution
float totalWeight = 0.0
for i = 0 to NUM_BUCKETS - 1
totalWeight += array.get(dist, i)
if totalWeight > 0
for i = 0 to NUM_BUCKETS - 1
array.set(dist, i, array.get(dist, i) / totalWeight)
// Find peak
float maxWeight = array.max(dist)
if na(maxWeight) or maxWeight <= 0
maxWeight := 0.001
int peakIndex = array.indexof(dist, maxWeight)
if peakIndex < 0
peakIndex := 0
float peakPrice = this.getBucketedPrice(peakIndex)
// Find support/resistance zones
array srIndices = array.new(0)
if SHOW_SUPPORT_RESISTANCE
bool inZone = false
int zoneStart = 0
for i = 0 to NUM_BUCKETS - 1
bool isHighConcentration = array.get(dist, i) >= maxWeight * SR_THRESHOLD
if isHighConcentration and not inZone
inZone := true
zoneStart := i
else if not isHighConcentration and inZone
inZone := false
array.push(srIndices, int(math.floor((zoneStart + i) / 2)))
if inZone
array.push(srIndices, int(math.floor((zoneStart + NUM_BUCKETS - 1) / 2)))
// Clear old SR zones
int srZoneSize = array.size(this.srZones)
if srZoneSize > 0
for i = 0 to srZoneSize - 1
box b = array.get(this.srZones, i)
box.set_lefttop(b, 0, 0)
box.set_rightbottom(b, 0, 0)
// Draw the distribution
float lowestDisplayedPrice = na
float highestDisplayedPrice = na
for i = 0 to NUM_BUCKETS - 1
float weight = array.get(dist, i)
float price = (i + 0.5) * this.priceStep + this.minPrice
int width = int(math.round(weight / maxWeight * CHART_MAX_WIDTH))
line ln = array.get(this.lines, i)
if width > 0
if na(lowestDisplayedPrice)
lowestDisplayedPrice := price
highestDisplayedPrice := price
int x1 = bar_index + CHART_X_OFFSET
int x2 = x1 - width
bool isProfitable = price < close
color c = getColor(isProfitable, weight, maxWeight, i)
line.set_xy1(ln, x1, price)
line.set_xy2(ln, x2, price)
line.set_color(ln, c)
else
line.set_xy1(ln, 0, 0)
line.set_xy2(ln, 0, 0)
// Draw S/R zones
if SHOW_SUPPORT_RESISTANCE
int srCount = array.size(srIndices)
int leftBar = math.max(0, bar_index - LOOKBACK)
if srCount > 0
for i = 0 to srCount - 1
int idx = array.get(srIndices, i)
float zonePrice = this.getBucketedPrice(idx)
float zoneHalfHeight = this.priceStep * 3
box b = na
if i < array.size(this.srZones)
b := array.get(this.srZones, i)
box.set_lefttop(b, leftBar, zonePrice + zoneHalfHeight)
box.set_rightbottom(b, bar_index, zonePrice - zoneHalfHeight)
else
b := box.new(leftBar, zonePrice + zoneHalfHeight, bar_index, zonePrice - zoneHalfHeight, bgcolor = color.new(PEAK_COLOR, 85), border_color = color.new(PEAK_COLOR, 60))
array.push(this.srZones, b)
// Calculate cumulative distribution
array cumdist = array.copy(dist)
for i = 1 to NUM_BUCKETS - 1
array.set(cumdist, i, array.get(cumdist, i - 1) + array.get(cumdist, i))
// Highlight current price
int closeIndex = this.getBucketIndex(close)
if closeIndex >= 0 and closeIndex < NUM_BUCKETS
line.set_color(array.get(this.lines, closeIndex), CURRENT_PRICE_COLOR)
// Calculate stats
float totalShares = array.get(cumdist, NUM_BUCKETS - 1)
int profitIndex = math.min(closeIndex + 1, NUM_BUCKETS - 1)
float profitRatio = totalShares > 0 ? array.get(cumdist, profitIndex) / totalShares : 0.0
// Calculate average price
float avg = 0.0
for i = 0 to NUM_BUCKETS - 1
float weight = array.get(dist, i)
float price = this.getBucketedPrice(i)
avg += price * weight
int avgIndex = this.getBucketIndex(avg)
if avgIndex >= 0 and avgIndex < NUM_BUCKETS
line.set_color(array.get(this.lines, avgIndex), AVG_PRICE_COLOR)
// Peak concentration - highlight line
if SHOW_PEAK and peakIndex >= 0 and peakIndex < NUM_BUCKETS
line.set_color(array.get(this.lines, peakIndex), PEAK_COLOR)
// Smart label positioning - avoid overlaps
float priceRange = na(highestDisplayedPrice) or na(lowestDisplayedPrice) ? close * 0.01 : (highestDisplayedPrice - lowestDisplayedPrice)
float minLabelSpacing = priceRange * 0.025
// Sort prices and assign staggered X offsets
float currentY = close
float avgY = avg
float peakY = peakPrice
// Adjust avg label if too close to current
if math.abs(avgY - currentY) < minLabelSpacing
avgY := currentY > avgY ? avgY - minLabelSpacing : avgY + minLabelSpacing
// Adjust peak label if too close to current or avg
if SHOW_PEAK
if math.abs(peakY - currentY) < minLabelSpacing
peakY := currentY > peakY ? peakY - minLabelSpacing : peakY + minLabelSpacing
if math.abs(peakY - avgY) < minLabelSpacing
peakY := avgY > peakY ? peakY - minLabelSpacing : peakY + minLabelSpacing
// Position price labels - compact format, right side of distribution
label.set_text(this.currentPriceLabel, str.format('{0,number,#.##}', close))
label.set_xy(this.currentPriceLabel, bar_index + LABEL_X_OFFSET + 2, close)
label.set_style(this.currentPriceLabel, label.style_label_left)
label.set_size(this.currentPriceLabel, size.tiny)
label.set_text(this.avgPriceLabel, str.format('{0,number,#.##} AVG', avg))
label.set_xy(this.avgPriceLabel, bar_index + LABEL_X_OFFSET + 2, avgY)
label.set_style(this.avgPriceLabel, label.style_label_left)
label.set_size(this.avgPriceLabel, size.tiny)
if SHOW_PEAK
label.set_text(this.peakLabel, str.format('{0,number,#.##} PEAK', peakPrice))
label.set_xy(this.peakLabel, bar_index + LABEL_X_OFFSET + 2, peakY)
label.set_style(this.peakLabel, label.style_label_left)
label.set_size(this.peakLabel, size.tiny)
// Calculate ranges safely
float safeTotalShares = totalShares > 0 ? totalShares : 1.0
int idx05 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.05)
int idx95 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.95)
int idx15 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.15)
int idx85 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.85)
float ninetyPctLow = this.getBucketedPrice(idx05)
float ninetyPctHigh = this.getBucketedPrice(idx95)
float seventyPctLow = this.getBucketedPrice(idx15)
float seventyPctHigh = this.getBucketedPrice(idx85)
float rangeDenom = ninetyPctHigh - ninetyPctLow
float rangeOverlap = rangeDenom != 0 ? (seventyPctHigh - seventyPctLow) / rangeDenom : 0.0
// Calculate chip concentration
float concentration = rangeOverlap * 100
string concentrationDesc = concentration < 50 ? "High" : concentration < 70 ? "Medium" : "Dispersed"
// Pressure analysis
float safeAvg = avg > 0 ? avg : close
float priceVsAvg = ((close - safeAvg) / safeAvg) * 100
string pressure = priceVsAvg > 5 ? "Strong Bullish" : priceVsAvg > 1 ? "Bullish" :
priceVsAvg < -5 ? "Strong Bearish" : priceVsAvg < -1 ? "Bearish" : "Neutral"
// Price vs Peak
float safePeak = peakPrice > 0 ? peakPrice : close
float priceVsPeak = ((close - safePeak) / safePeak) * 100
string peakRelation = close > peakPrice ? "Above Peak" : close < peakPrice ? "Below Peak" : "At Peak"
// Stats panel - positioned at bottom, compact
float displayedRange = na(highestDisplayedPrice) or na(lowestDisplayedPrice) ? close * 0.02 : highestDisplayedPrice - lowestDisplayedPrice
label.set_text(this.statsLabel, str.format(
'90%: {0,number,#.##} - {1,number,#.##} | 70%: {2,number,#.##} - {3,number,#.##}',
ninetyPctLow, ninetyPctHigh, seventyPctLow, seventyPctHigh))
if not na(lowestDisplayedPrice) and displayedRange > 0
label.set_y(this.statsLabel, lowestDisplayedPrice - displayedRange * 0.05)
label.set_style(this.statsLabel, label.style_label_up)
label.set_x(this.statsLabel, bar_index + CHART_X_OFFSET - 30)
label.set_size(this.statsLabel, size.tiny)
// Signal panel - hidden (info moved to trend arrow and pressure bar)
label.set_text(this.signalLabel, "")
label.set_xy(this.signalLabel, bar_index, close)
// === NEW PROFESSIONAL VISUALIZATIONS ===
// 1. Key Level Lines - Support, Resistance, and Average Cost extending across chart
if SHOW_KEY_LEVELS
int chartLeft = math.max(0, bar_index - LOOKBACK)
int chartRight = bar_index + CHART_X_OFFSET - 5
// Average cost line (horizontal dotted blue line)
line.set_xy1(this.avgCostLine, chartLeft, avg)
line.set_xy2(this.avgCostLine, chartRight, avg)
line.set_color(this.avgCostLine, AVG_PRICE_COLOR)
// Find strongest support (highest concentration below current price)
float strongestSupport = na
float strongestSupportWeight = 0.0
float strongestResistance = na
float strongestResistanceWeight = 0.0
for i = 0 to NUM_BUCKETS - 1
float bucketPrice = this.getBucketedPrice(i)
float bucketWeight = array.get(dist, i)
if bucketPrice < close and bucketWeight > strongestSupportWeight
strongestSupport := bucketPrice
strongestSupportWeight := bucketWeight
if bucketPrice > close and bucketWeight > strongestResistanceWeight
strongestResistance := bucketPrice
strongestResistanceWeight := bucketWeight
// Support line (green dashed)
if not na(strongestSupport)
line.set_xy1(this.supportLine, chartLeft, strongestSupport)
line.set_xy2(this.supportLine, chartRight, strongestSupport)
line.set_color(this.supportLine, SUPPORT_COLOR)
else
line.set_xy1(this.supportLine, bar_index, close)
line.set_xy2(this.supportLine, bar_index, close)
line.set_color(this.supportLine, color.new(SUPPORT_COLOR, 100))
// Resistance line (red dashed)
if not na(strongestResistance)
line.set_xy1(this.resistanceLine, chartLeft, strongestResistance)
line.set_xy2(this.resistanceLine, chartRight, strongestResistance)
line.set_color(this.resistanceLine, RESISTANCE_COLOR)
else
line.set_xy1(this.resistanceLine, bar_index, close)
line.set_xy2(this.resistanceLine, bar_index, close)
line.set_color(this.resistanceLine, color.new(RESISTANCE_COLOR, 100))
// 2. Trend Direction Arrow
if SHOW_TREND_ARROW
string trendSymbol = priceVsAvg > 5 ? "▲▲" : priceVsAvg > 1 ? "▲" :
priceVsAvg < -5 ? "▼▼" : priceVsAvg < -1 ? "▼" : "◆"
color trendColor = priceVsAvg > 5 ? color.new(#00E676, 0) : priceVsAvg > 1 ? color.new(#4CAF50, 0) :
priceVsAvg < -5 ? color.new(#FF1744, 0) : priceVsAvg < -1 ? color.new(#EF5350, 0) : color.new(#9E9E9E, 0)
string trendText = trendSymbol + " " + pressure
label.set_text(this.trendArrow, trendText)
float arrowY = na(highestDisplayedPrice) ? close : highestDisplayedPrice + displayedRange * 0.12
label.set_xy(this.trendArrow, bar_index + CHART_X_OFFSET - 40, arrowY)
label.set_color(this.trendArrow, color.new(trendColor, 70))
label.set_textcolor(this.trendArrow, trendColor)
label.set_size(this.trendArrow, size.large)
// 3. Pressure Bar (Profit/Loss ratio visualization)
if SHOW_PRESSURE_BAR
float barWidth = 8.0
float barHeight = displayedRange * 0.25
float barX = bar_index + CHART_X_OFFSET + 5
float barTop = na(highestDisplayedPrice) ? close + barHeight/2 : highestDisplayedPrice - displayedRange * 0.02
float barBottom = barTop - barHeight
// Background bar
box.set_lefttop(this.pressureBar, int(barX), barTop)
box.set_rightbottom(this.pressureBar, int(barX + barWidth), barBottom)
box.set_bgcolor(this.pressureBar, color.new(#424242, 60))
// Fill based on profit ratio (green from bottom)
float fillHeight = barHeight * profitRatio
float fillTop = barBottom + fillHeight
color fillColor = profitRatio > 0.7 ? color.new(#00E676, 30) :
profitRatio > 0.5 ? color.new(#4CAF50, 30) :
profitRatio > 0.3 ? color.new(#FFC107, 30) : color.new(#FF5252, 30)
box.set_lefttop(this.pressureFill, int(barX), fillTop)
box.set_rightbottom(this.pressureFill, int(barX + barWidth), barBottom)
box.set_bgcolor(this.pressureFill, fillColor)
// Pressure label
string pressureText = str.format('{0,number,#}%', profitRatio * 100)
label.set_text(this.pressureLabel, pressureText)
label.set_xy(this.pressureLabel, int(barX - 1), barTop + displayedRange * 0.01)
label.set_textcolor(this.pressureLabel, fillColor)
//#endregion
//#region Main
= request.security(syminfo.tickerid, 'D', , lookahead = barmerge.lookahead_off)
float atrPercent = dailyClose > 0 ? dailyATR / dailyClose : 0.02
if timeframe.in_seconds(timeframe.period) <= timeframe.in_seconds('D')
var PCD pcd = newPCD()
if last_bar_index - bar_index < LOOKBACK
pcd.storeCandle(dailyBarIdx, dailyHigh, dailyLow, dailyVolume, avgVolume, atrPercent)
if barstate.islast
pcd.update()
//#endregion
