Candle wicks body and HL sizeThis indicator calculates the size of each candlestick in pips and displays all key values of the candle in a single vertical label directly on the chart
Each label shows four values, one per line, in this order:
Upper wick → high - max(open, close)
The distance from the top of the candle body to the high.
OC (open-close) → abs(open - close)
The body size of the candle in pips.
HL (high-low) → abs(high - low)
Total candle range in pips.
Bottom wick → min(open, close) - low
The distance from the bottom of the candle body to the low.
All four values are displayed vertically in a single label.
Labels are transparent, showing only the text.
Candlestick analysis
Finlu CONTINUACION PROFinlu CONTINUACIÓN PRO is an oscillator designed to detect trend continuation signals after a pullback.
The logic is based on:
A normalized momentum similar to Finlu Momentum PRO.
A central neutral zone: when momentum pulls back into this zone without fully changing direction, it is treated as a pullback within the trend.
Internal impulse levels (1, 2 and 3) to distinguish mild pullbacks from strong impulses.
A signal line used to confirm crossovers or separation between the main line and the signal.
An optional directional filter (DMI/ADX-style) that checks trend strength before allowing a signal.
Typical usage conditions:
Bullish continuation signals when there is prior upside momentum, the oscillator pulls back into the neutral zone and then turns up again, meeting the crossover/separation condition and the directional filter.
Bearish continuation signals in the opposite scenario.
The colored background shows the dominant side of momentum and helps visualize which sections of the chart favor long or short setups.
This indicator is intended as a support tool for traders already working with market structure and supply/demand zones. It does not guarantee results and does not replace risk management or the trader’s own judgement.
Candle OC and HL size in pipsThis script calculates and displays candle sizes in pips
Shows both the Open-Close and the High-Low size in a single label
Configurable minimal and maximal size
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.
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.
NASDAQ PREDICTION RANGE ADR projection for the US session based on previous Price Action and session
Blockcircle Heikin-Ashi Multi-TimeframeThe BLOCKCIRCLE HEIKIN-ASHI MULTI-TIMEFRAME indicator displays Heikin-Ashi price data across multiple timeframes simultaneously, giving you a clear picture of trend direction from your current chart all the way up to monthly views.
Instead of flipping between charts to check if higher timeframes agree with your trade idea, everything sits right in front of you on a single unified view.
The core concept is simple: when multiple timeframes show the same trend direction, the probability of a successful trade increases. When they disagree, you might want to wait for better alignment or reduce your position size.
WHAT MAKES THIS INDICATOR ORIGINAL AND DIFFERENT
While Heikin-Ashi candles and multi-timeframe analysis are established concepts, this indicator extends beyond simple HA plotting in several ways that justify its protected source status.
First, the summary scoring algorithm calculates a directional score from 0 to 100 that quantifies trend alignment across all enabled timeframes. This is not simply counting bullish versus bearish readings. The score incorporates the current timeframe alongside higher timeframes, weights each contribution, and produces a single metric that represents overall market structure bias.
Second, the indicator includes an intelligent auto-timeframe system that dynamically selects appropriate higher timeframes based on your current chart. Rather than requiring manual configuration, the algorithm maps each chart timeframe to a logical hierarchy of higher timeframes. A 15-minute chart automatically receives 30-minute, 1-hour, 2-hour, 4-hour, and 8-hour references. A daily chart receives 3-day, weekly, 2-week, monthly, and quarterly references. This mapping logic ensures meaningful timeframe relationships regardless of where you trade.
Third, the alignment quality calculation measures how decisive the current trend reading is, regardless of direction. A score where 80 percent of timeframes agree in either direction produces a high alignment quality rating, while a 50/50 split produces low quality. This helps traders distinguish between strong conviction setups and ambiguous market conditions.
Fourth, the stability factor tracks how many timeframes have recently changed direction. Markets where multiple timeframes are actively flipping carry different risk characteristics than markets where all timeframes have maintained their direction for extended periods. The stability calculation converts recent change counts into a percentage that feeds into the overall assessment.
Fifth, the confidence rating system interprets the raw data and translates it into actionable guidance. High confidence requires near-complete alignment across timeframes. Medium confidence requires majority agreement. Low confidence indicates mixed conditions. This interpretation layer helps traders who prefer clear guidance over raw numbers.
These proprietary elements, particularly the auto-timeframe mapping, the multi-factor scoring system, and the stability tracking, represent original development work that extends meaningfully beyond standard Heikin-Ashi MTF implementations available elsewhere.
KEY FEATURES
Multi-Timeframe Heikin-Ashi Display: View up to five higher timeframes plotted directly on your chart alongside the current timeframe
Each timeframe shows both the open and close values as separate lines, with optional fill between them
Heikin-Ashi smoothing filters out market noise better than standard candlesticks, making trend direction easier to identify
All timeframe data updates in real-time as new bars form
Professional Dashboard Panel
Summary score from 0 to 100 that quantifies overall trend alignment at a glance
Individual timeframe breakdown showing exact open and close prices, trend direction, and whether a change just occurred
Statistics section with trend strength percentage, timeframe alignment count, and recent change tracking
Signal status that interprets the data and suggests whether conditions favour buying, selling, or staying neutral
Confidence rating based on how many timeframes agree with each other
Compact mode option for traders who prefer a smaller footprint on their charts
Visual Customisation Options
Three display modes: lines only for a clean look, lines with fill for easier trend visualisation, or cloud style for a more distinct separation between levels
Full colour control for each timeframe so you can match your existing chart theme
Adjustable line widths and optional midline display showing the average of open and close
Background colour shading that changes based on overall trend alignment
Trend change arrows that appear automatically when a timeframe flips direction
Practical Alert System
Individual alerts for each timeframe when it switches from bullish to bearish or vice versa
Combined alert when all enabled timeframes align in the same direction
Single master alert that fires whenever any timeframe changes, useful for staying informed without setting up multiple notifications
Strong trend detection alert when alignment score crosses above key thresholds
HOW TO USE
Setting Up Your Timeframes
Start by choosing timeframes that match your trading style. If you trade the 15-minute chart, enable the 1-hour, 4-hour, and daily timeframes. If you swing trade on the daily, consider the 3-day, weekly, and monthly timeframes.
Give each timeframe a custom label that makes sense to you. The dashboard will display these labels, so use whatever helps you read the information quickly.
You do not need to enable all five timeframes. Many traders find that three or four provide enough context without cluttering the chart.
How to Read the Dashboard
Check the summary row first. A score above 70 with a clear bullish or bearish bias suggests strong alignment. Scores between 40 and 70 indicate mixed conditions where caution is warranted.
Look at the alignment count to see exactly how many timeframes agree. Four out of five being bullish is more convincing than two out of five.
Pay attention to the change indicator, shown as a yellow dot next to any timeframe that just flipped. Recent changes often signal the start of a new move but can also be false signals that reverse quickly.
The confidence rating helps newer traders interpret the data. High confidence means most or all timeframes agree, while low confidence suggests waiting for better conditions.
Identifying Trade Opportunities
The strongest signals occur when all enabled timeframes show the same direction. If you see all green across the board, bullish setups are more likely to succeed. The opposite applies when everything points to bearishness.
When the current timeframe flips to match the higher timeframes, this often marks a good entry point. The lower timeframe is now in agreement with the bigger picture.
Avoid trading against multiple higher timeframes. If the 4-hour, daily, and weekly are all bearish, taking long positions on the 15-minute chart is fighting the overall trend.
Use divergences between timeframes as warning signs. If lower timeframes turn bullish but higher timeframes remain bearish, the rally may be a pullback within a larger downtrend rather than a true reversal.
Managing Risk with Timeframe Analysis
Consider position sizing based on alignment. Full positions when alignment is strong, reduced size when conditions are mixed.
Place stops beyond the higher timeframe structure. If the daily Heikin-Ashi open sits at a certain level, that level often acts as support or resistance.
When higher timeframes start changing direction one by one, this often signals a larger trend shift developing. Take profits or tighten stops on existing positions.
The trend strength percentage gives you a quick read on momentum. Above 80 percent suggests strong conviction in one direction. Below 40 percent suggests the opposite direction dominates.
Combining with Other Analysis
This indicator works well alongside volume analysis. Strong trend alignment with increasing volume adds confidence to the signal.
You can see use the trend change arrows as added confluence towards a trend break as you see below
Support and resistance levels from higher timeframes carry more weight. Use the higher timeframe Heikin-Ashi values as dynamic support and resistance zones.
Combine with momentum oscillators for timing. When the indicator shows alignment and an oscillator shows oversold or overbought conditions, the setup becomes more compelling.
Price action patterns that form in the direction of multi-timeframe alignment have better follow-through than those forming against it.
LIMITATIONS
This indicator uses Heikin-Ashi calculations, which by design lag behind standard price action. Signals confirm trends rather than predict them, and early entries require additional confirmation from other methods.
The auto-timeframe feature selects higher timeframes based on predefined mappings. These mappings work well for most trading styles but may not suit every specific use case. Manual override is available for traders who prefer custom timeframe combinations.
During extended consolidation periods, the summary score may oscillate around 50 percent and produce mixed readings. The indicator performs best when markets exhibit clear directional movement.
Multi-timeframe alignment does not guarantee trade success. Markets can and do reverse even when multiple timeframes agree. Proper risk management and position sizing remain essential regardless of alignment score.
This indicator should be used as part of a complete trading approach. It provides trend context and alignment analysis but does not replace fundamental analysis, risk management, or trading discipline.
Hazmeed HTF Candles Aligned)HTF Candles Overlay (v6, Aligned + Accurate Wicks)
This indicator overlays higher timeframe candles on your current chart.
It allows you to visually compare HTF price action directly on your lower timeframe chart without switching timeframes.
⭐ Features
Displays Higher Timeframe (HTF) candles on the current chart
Fully aligned to HTF candle start time
Option to show accurate wicks
Supports configurable:
HTF timeframe (e.g., 1D, 4H, 1W)
Number of HTF candles displayed
Candle width (in bars)
Bull/Bear colors and wick color
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. 🙏
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
Wickless indicator, Kunno wick strategy indicator
shows 9 candle validity line, and all wickless candles that show up for visual ease
Analyze**Smart Money & OB Finder (MTF)** is a professional trading indicator designed to help traders identify high-probability **Buy Zones and Sell Zones** based on **Smart Money Concepts (SMC)** and **Order Blocks (OB)** across multiple timeframes.
This indicator automatically marks **institutional Order Blocks**, allowing traders to see where **big players enter the market**, instead of chasing price in the middle of nowhere.
### 🔍 Key Features
• Automatic **Buy & Sell Order Block detection**
• **Multi-Timeframe (MTF)** analysis for higher-timeframe confirmation
• Clear **zone marking** (no late signals, no repaint)
• Works on **all markets** (Forex, Gold, Indices, Crypto)
• Suitable for **scalping, intraday, and swing trading**
### 🎯 How to Use
• Mark zones on higher timeframe (H1 / H4)
• Execute entries on lower timeframe (M5 / M15)
• Use Order Blocks as **reaction areas**, not ins
Support & Resistance Detector [PRO]Professional Support & Resistance Detector 🟠
Executive Summary 🟠
The **Professional Support & Resistance Detector ** is an institutional-grade technical analysis instrument built for precision traders. It automates the complex task of identifying significant market structure by detecting valid Swing Highs (Resistance) and Swing Lows (Support) using a customizable dynamic lookback algorithm. Unlike basic indicators that clutter the chart with irrelevant lines, this tool employs smart filtration and FIFO (First-In, First-Out) logic to present only the most actionable price levels.
Whether you are a scalper needing real-time feedback or a swing trader looking for confirmed structural levels, this indicator adapts to your workflow with "Confirmed Only" and "Realtime" calculation modes.
Why Standard Indicators Fail 🟠
Most Support & Resistance indicators suffer from two major problems:
1. **Noise**: They identify too many insignificant levels, making the chart unreadable.
2. **Rigidity**: They fail to account for "Role Reversal" (where old Resistance becomes new Support).
The Solution: Advanced Feature Set 🟠
This script addresses these issues with a suite of advanced features designed for the modern market environment:
1. **Dynamic Algorithmic Detection**:
* The core engine uses a user-defined `Left` and `Right` bar lookback system. This allows you to differentiate between "Major" structural pivots (high lookback) and "Minor" intraday levels (low lookback).
* **Zone Visualization**: Prices rarely turn at an exact micro-level. The indicator draws a transparent "Zone" around the key level to visualize the area of liquidity, helping you avoid premature entries during wick tests.
2. **Smart Breakout Logic (The "Brain" of the Indicator)**:
* **History Mode (Faded)**: When a level is broken, it doesn't just vanish. It stays on the chart but fades out. This is critical for backtesting to see how price reacted to past levels.
* **Role Reversal (Flip) Mode**: This is for active trading. When price breaks Resistance, the line automatically flips color to Support (and vice versa). This allows you to trade the "Break & Retest" strategy effortlessly.
3. **Active Chart Management**:
* Markets evolve. Old levels become irrelevant. The built-in **FIFO Memory System** ensures that you never have more than your specified limit (e.g., 25 lines) on the chart. As new structure forms, the oldest irrelevant data is recycled, keeping your workspace pristine.
4. **Multi-Mode Calculation Engine**:
* **Confirmed Only (Default)**: The professional standard. Levels are only drawn/updated when the candle closes. This guarantees zero repainting and reliable signals.
* **Realtime (Tick-by-Tick)**: Designed for aggressive scalpers who need to see potential pivots forming before the candle closes.
Comprehensive Settings & Customization 🟠
Every aspect of the indicator is customizable to fit your trading style.
Logic & Calculation 🟠
* **Max Active Lines**: Set the buffer size for active levels. Recommended: 20-30 for clean analysis.
* **Line Extension**: Choose "Right" (standard), "Both" (chart-wide context), or "Segment Only" (local structure).
Pivot Identification 🟠
* **Lookback Left/Right**: The sensitivity dial.
* *Scalping Setup*: Left 10 / Right 5.
* *Swing Setup*: Left 50 / Right 25.
* **Zone Width**: Controls the vertical thickness of the S/R zone.
Visual Aesthetics 🟠
* **Markers**: Select from a library of professionally designed Unicode symbols (Diamonds ◈, Arrows ⯅/⯆, Stars ★, etc.) to mark the exact pivot candle.
* **Breakout Markers**: Visual confirmation icons (Crosses ✖, Checks ✔) appear exactly where the breakout occurred.
Professional Trading Strategies 🟠
**Strategy 1: The S/R Flip (Break & Retest)**
1. Set **Breakout Behavior** to "Role Reversal (Flip)".
2. Wait for price to break a **Red Resistance Zone**.
3. Watch the Zone turn **Blue (Support)**.
4. **Entry**: Wait for price to pull back and touch the new Blue Support zone. Look for a rejection wick.
5. **Stop Loss**: Just below the zone.
Strategy 2: Range Containment
1. Identify a market moving sideways between a parallel Blue Support and Red Resistance.
2. **Sell** at the Red Zone touch (Resistance).
3. **Buy** at the Blue Zone touch (Support).
4. **Filter**: Use the "Confirmed Only" mode to ensure the candle closes inside the range before taking a trade.
Alert System 🟠
Never miss a move. The indicator offers fully integrated alerts for automation:
* **New Level Found**: Instant notification when fresh structure is identified.
* **Breakout Alert**: When a level is breached.
* **Flip Alert**: Specific notification when Resistance becomes Support (or vice versa).
Disclaimer 🟠
This tool is provided for educational and analytical purposes. Financial trading carries a high level of risk. Past performance of any trading system is not indicative of future results. Please trade responsibly.
High-volume buy and sell signals with OB and FVGBuy and sell signals on ob
Pivot Point Usage: Instead of detecting each candle of an opposite color, the script uses `ta.pivothigh/low`. This means it only marks a Pivot Point if the price has actually made a significant high or low relative to the 10 preceding and following candles.
Dynamic Cleanup (Mitigation): As soon as the price returns to "fill" the area (depending on your choice: simple contact or close), the box disappears from the chart. This keeps your view clean and focused on the remaining untouched areas.
Period Setting: You can increase the "Detection Period" (e.g., from 10 to 20) in the settings to filter out even more noise and keep only the major areas.
How to use it?
Pattern Pro [Josh]1. Overview
Pattern Pro is a hybrid technical analysis suite designed to bridge the gap between Classic Chart Patterns and Smart Money Concepts (SMC). Reimagined with a high-contrast "Alien HUD" visual style, this script helps traders identify structural breaks, reversal patterns, and institutional zones with clarity.
2. How it Works (Methodology & Calculations)
The core engine of this script relies on identifying significant market swings using ta.pivothigh and ta.pivotlow functions. These pivot points are stored in dynamic arrays to perform geometric calculations:
Geometric Pattern Recognition:
The script calculates the slope between historical pivots using linear regression logic.
Double Tops/Bottoms: Detects equal highs/lows within a user-defined tolerance (default 0.25%) and validates them with RSI Divergence logic.
Head & Shoulders: Validates the structural hierarchy (Left Shoulder < Head > Right Shoulder) relative to the neckline.
Wedges & Flags: Analyzes trendlines connecting multiple pivots. Converging slopes indicate Wedges, while parallel slopes indicate Flags.
Smart Money Concepts (SMC):
BOS (Break of Structure): Automatically draws lines where price closes beyond a key pivot, signaling trend continuation.
FVG (Fair Value Gaps): Scans for 3-candle price imbalances and projects the 50% equilibrium level.
Supply & Demand Zones: Highlights order blocks derived from the specific candles that formed a confirmed pivot.
Confidence Score: An internal algorithm assigns a percentage score based on pattern clarity and momentum divergence (RSI).
3. Visual Features (Alien HUD)
Neon & Glow Effects: Lines are rendered with multi-layered transparency to create a "glowing" effect, ensuring visibility on dark themes.
Fog/Smoke FX: Adds depth to critical levels without cluttering the chart.
Customization: Users can toggle specific patterns, adjust pivot sensitivity (Lookback), and customize colors.
Disclaimer: This indicator is developed strictly for educational purposes regarding chart behavior and algorithmic pattern recognition.
The signals and patterns generated do not guarantee profitability or future accuracy.
Past performance is not indicative of future results.
Trading involves significant risk. Users should always practice proper risk management and use their own judgment.
