← К каталогу
Исходный код · ID 4859

Strong Pressure Signals

indicator strong pressure signals for tradingview.pine

Похожие материалы по тегам

ea12sd.mq4MQL4 / MetaTrader 4 · 1 общих теговindicator market map for tradingview.pineTradingView · 1 общих теговconfluenceforge_pro.mq5TradingView · 1 общих теговvolatility_gold_master.mq5MQL5 / MetaTrader 5 · 1 общих теговhamster scalping v 21.0.mq5MQL5 / MetaTrader 5 · 1 общих теговqqe of rsi(oma)(on chart).mq5MQL5 / MetaTrader 5 · 1 общих тегов
Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

Strong Pressure Signals — индикатор анализа для TradingView, который обнаруживает импульсы цены (burst), выходящие за пределы скользящей базы + множитель ATR, и отслеживает ликвидационные кластеры поддержки и сопротивления. Индикатор визуализирует кластеры в виде пузырей с оценкой силы, линии уровней и графические отметки касаний, пробоев и реклаймов.

Индикатор включает систему взвешенной оценки качества сигнала (0–10) с несколькими факторами: экстеншен, высота стека, исчерпание по RSI, реекшен-вик, соответствие тренду и давление кластеров. Дополнительно реализованы сессионные диапазоны с уровнями Cap/Floor/Equilibrium для внутридневного контекста, а также фильтры и гейты сигналов (RSI, кластерная близость, подтверждение на закрытой свече).

Встроенная информационная панель отображает текущее состояние импульса, качество текущей установки в реальном времени, статистику по закрытым сделкам (процент побед, профит-фактор, стрик), результаты по уровням TP/SL, а также мультитаймфреймную полосу импульсов. Индикатор поддерживает условные оповещения TradingView для различных событий: сигналы, кластерные события, достижение TP3, экстремальные импульсы и пробои диапазонов.

Настройки программы

НастройкаОписание
srcIn Источник данных для расчёта базовой линии и импульсов.
basisType Тип базовой скользящей средней: EMA, SMA, HMA, WMA, VWMA или RMA.
basisLen Период расчёта базовой скользящей средней.
atrLen Период расчёта ATR для определения ширины полосы импульса.
bandMult Множитель ATR сверх базы, при превышении которого свеча считается импульсом (burst).
stepATR Прирост ATR для каждого уровня стека импульса.
maxLevels Максимальная высота стека (количество уровней) для импульса.
heatSat Значение ATR сверх полосы, при котором интенсивность импульса достигает максимума (насыщение).
needClose При включении импульс подтверждается только если закрытие свечи находится за пределами полосы.
confirmBar При включении пики импульсов определяются только на закрытых свечах, что предотвращает перерисовку.
clSide Сторона кластеров: Both — оба, Longs Only (below) — только поддержка, Shorts Only (above) — только сопротивление.
leftBars Количество баров слева для определения пивота при поиске кластеров.
rightBars Количество баров справа для определения пивота при поиске кластеров.
lookbackW Глубина поиска кластеров в барах (0 — все).
maxZones Максимальное количество активных кластеров на графике.
maxLife Максимальный возраст кластера в барах после которого он удаляется.
clMinMag Минимальная нормализованная сила кластера для отображения (0–1).
hideOverlap При включении перекрывающиеся кластеры объединяются и не отображаются дублирующе.
overlapThr Порог перекрытия в процентах для определения двух кластеров как пересекающихся.
clAtrLen Период ATR для расчёта силы и ширины кластера (включая просчёты).
bandATR Высота невидимой полосы вокруг кластера для обнаружения касаний и просчётов (множитель ATR).
minDepth Минимальная глубина просчёта (ATR) для признания события просчётом кластера.
reclaimWin Максимальное количество баров для признания реклайма кластера после просчёта.
breakAtr Множитель ATR для признания пробоя кластера решительным (close за пределами порога).
flipBroken При включении пробитые кластеры переворачиваются на противоположную сторону вместо удаления.
magWeight Вес нормализованной силы кластера в формуле общей оценки кластера.
weightLB Глубина истории (в барах) для расчёта нормализованного веса ликвидности кластеров.
magContrast Контраст нормализованной силы кластера при расчёте оценки.
volLen Период скользящей средней для базы объёма при расчёте веса кластеров.
useBinance Для BTC: агрегирование объёма с Binance. Для остальных рынков используется собственный объём.
useCoinbase Для BTC: агрегирование объёма с Coinbase.
useBitstamp Для BTC: агрегирование объёма с Bitstamp.
useRange Включение модулей сессионных диапазонов (только для внутридневных таймфреймов).
tzInput Часовой пояс для расчёта сессионных диапазонов.
w1On Включение первой торговой сессии.
w1Name Название первой торговой сессии (отображается на графике).
w1Range Диапазон (окно) первой торговой сессии для определения начала/конца.
w1Full Полная продолжительность первой торговой сессии (временной диапазон).
w2On Включение второй торговой сессии.
w2Name Название второй торговой сессии.
w2Range Диапазон (окно) второй торговой сессии.
w2Full Полная продолжительность второй торговой сессии.
w3On Включение третьей торговой сессии.
w3Name Название третьей торговой сессии.
w3Range Диапазон (окно) третьей торговой сессии.
w3Full Полная продолжительность третьей торговой сессии.
rangeSat Сколько ширин диапазона сверх Cap/Floor требуется для полного балла Range-пиллара.
showRangeBox Отрисовка коробки диапазона с уровнями Cap, Floor и Equilibrium.
showRangeTags Отображение тегов с названиями уровней диапазона на графике.
keepDays Количество дней хранения диапазонов на графике (на окно).
w1Col Цвет первой торговой сессии на графике.
w2Col Цвет второй торговой сессии на графике.
w3Col Цвет третьей торговой сессии на графике.
fadeMin Минимальная высота стека (уровней) для генерации сигнала.
minMag Минимальная величина импульса (ATR сверх полосы) для генерации сигнала.
needRej При включении требуется наличие реекшен-вика на баре пика импульса.
rejMin Минимальная доля реекшен-вика от диапазона бара пика (0–0.95).
useRsiGate При включении сигнал требует исчерпания по RSI (перекупленность/перепроданность).
rsiLen Период расчёта индикатора RSI для гейта исчерпания.
rsiOB Порог перекупленности RSI: SHORT-сигнал требуется, когда RSI выше этого значения.
rsiOS Порог перепроданности RSI: LONG-сигнал требуется, когда RSI ниже этого значения.
needCluster Гейт: импульс должен достичь или просчитать противоположный кластер для подтверждения сигнала.
clProx Близость кластера в ATR для начисления частичного балла, когда импульс не достиг кластера напрямую.
needRange Гейт: импульс должен выйти за пределы сессионного диапазона.
sessionOnly Гейт: сделки открываются только внутри активной торговой сессии.
allowShort Разрешение на SHORT-сигналы (восходящие импульсы).
allowLong Разрешение на LONG-сигналы (нисходящие импульсы).
cooldown Минимальное количество баров между последовательными сигналами.
stopMode Основа для расчёта стоп-лосса: Burst Extreme, ATR Multiple или Swing Extreme.
swingLook Количество баров назад для поиска экстремумов свинга при расчёте стопа.
stopAtr Множитель ATR для расчёта расстояния стоп-лосса.
slBuf Буфер сверх экстремума для расчёта стоп-лосса (ATR).
maxRisk Верхний предел риска (ATR) для расчёта стоп-лосса.
minRisk Нижний предел риска (ATR) для расчёта стоп-лосса.
targetMode Режим расчёта тейк-профитов: R Multiples, Mean Reversion или Pressure Ladder.
ladderMinR Минимальное расстояние между ступенями в режиме Pressure Ladder (в R).
tp1R Тейк-профит 1 в единицах R (кратность риска).
tp2R Тейк-профит 2 в единицах R.
tp3R Тейк-профит 3 в единицах R.
maxHunt Максимальное количество баров нахождения в сделке (тайм-стоп).
zoneW Ширина универсальной зоны SL/TP в барах.
showBoxes Отображение зон стоп-лосса и тейк-профита на графике.
showLines Отображение линий стоп-лосса и тейк-профита на графике.
showLevelLbl Отображение ценовых меток уровней SL/TP.
showExitLbl Отображение меток с результатами закрытия сделок.
showBasisMark Отображение маркера базовой линии на точке входа.
maxHist Максимальное количество исторических сделок, отображаемых визуально (визуальный лимит).
minStars Минимальная оценка в звёздах для открытия сделки (0–4).
alertStars Минимальная оценка в звёздах для срабатывания оповещения (0–4).
wExt Вес фактора «экстеншен импульса» в формуле оценки сигнала.
wStack Вес фактора «высота стека» в формуле оценки сигнала.
wExh Вес фактора «исчерпание импульса» в формуле оценки сигнала.
wRej Вес фактора «реекшен-вик» в формуле оценки сигнала.
wTrend Вес фактора «соответствие тренду» в формуле оценки сигнала.
wCalm Вес фактора «режим волатильности» в формуле оценки сигнала.
wRoom Вес фактора «зона для реверсии» в формуле оценки сигнала.
wPress Вес фактора «давление кластера» в формуле оценки сигнала.
wRange Вес фактора «сессионный диапазон» в формуле оценки сигнала.
showDash Отображение информационной панели на графике.
dashPosOpt Позиция информационной панели на графике.

Поиск по коду файла

indicator("Strong Pressure Signals", overlay = true, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500, max_bars_back = 2000)

gB = "01 · Burst Engine (signal source)"
srcIn      = input.source(close, "Basis source", group = gB)
basisType  = input.string("EMA", "Basis type", options = ["EMA", "SMA", "HMA", "WMA", "VWMA", "RMA"], group = gB)
basisLen   = input.int(20, "Basis length", minval = 2, maxval = 400, group = gB)
atrLen     = input.int(14, "ATR length", minval = 2, maxval = 200, group = gB)
bandMult   = input.float(2.0, "Band width (ATR beyond basis = burst starts)", minval = 0.2, maxval = 10.0, step = 0.1, group = gB, tooltip = "A bar bursts when its high pokes above basis + this·ATR (or its low below basis − this·ATR).")
stepATR    = input.float(0.5, "ATR per stack step", minval = 0.1, maxval = 3.0, step = 0.05, group = gB)
maxLevels  = input.int(6, "Max stack height", minval = 1, maxval = 6, group = gB)
heatSat    = input.float(3.0, "Heat saturates at (ATR beyond band)", minval = 0.5, maxval = 12.0, step = 0.5, group = gB)
needClose  = input.bool(false, "Require closing burst (close beyond band)", group = gB)
confirmBar = input.bool(true, "Confirm on bar close (non-repaint)", group = gB, tooltip = "ON: burst peaks are only detected on closed bars, so nothing repaints.")

gP = "02 · Pressure Clusters (liquidation fuel)"
clSide     = input.string("Both", "Cluster side", options = ["Both", "Longs Only (below)", "Shorts Only (above)"], group = gP, tooltip = "Long-liquidation clusters sit UNDER price at swing lows (support magnets). Short-liquidation clusters sit ABOVE at swing highs (resistance magnets).")
leftBars   = input.int(12, "Pivot left", minval = 1, group = gP)
rightBars  = input.int(4,  "Pivot right", minval = 1, group = gP)
lookbackW  = input.int(3000, "Lookback (bars, 0 = all)", minval = 0, group = gP)
maxZones   = input.int(30, "Max live clusters", minval = 2, maxval = 60, group = gP)
maxLife    = input.int(400, "Max cluster age (bars)", minval = 10, group = gP)
clMinMag   = input.float(0.0, "Min magnitude to keep (0-1)", minval = 0.0, maxval = 1.0, step = 0.05, group = gP)
hideOverlap= input.bool(true, "Merge overlapping clusters", group = gP)
overlapThr = input.int(35, "Overlap threshold (%)", minval = 1, maxval = 100, group = gP)
clAtrLen   = input.int(200, "Cluster ATR length (band + sweeps)", minval = 1, maxval = 500, group = gP)
bandATR    = input.float(0.5, "Band height (ATR mult)", minval = 0.05, maxval = 6.0, step = 0.05, group = gP, tooltip = "Invisible band around each cluster used for touch / sweep detection.")
minDepth   = input.float(0.15, "Min sweep depth (ATR)", minval = 0.02, maxval = 4.0, step = 0.01, group = gP)
reclaimWin = input.int(6, "Max reclaim window (bars)", minval = 1, maxval = 40, group = gP)
breakAtr   = input.float(0.9, "Decisive break acceptance (ATR)", minval = 0.1, maxval = 8.0, step = 0.1, group = gP)
flipBroken = input.bool(true, "Flip broken clusters (breakers)", group = gP)
magWeight  = input.float(0.7, "Magnitude weight in cluster strength", minval = 0.0, maxval = 1.0, step = 0.05, group = gP)
weightLB   = input.int(1000, "Magnitude lookback (bars)", minval = 100, maxval = 5000, group = gP)
magContrast= input.float(0.6, "Magnitude contrast", minval = 0.1, maxval = 3.0, step = 0.05, group = gP)
volLen     = input.int(20, "Volume baseline length", minval = 1, group = gP)
useBinance = input.bool(true,  "BTC: aggregate Binance volume",  group = gP, tooltip = "On BTC pairs the three venues' volume is aggregated for a fuller pressure read. Every other market uses its own chart volume automatically.")
useCoinbase= input.bool(true,  "BTC: aggregate Coinbase volume", group = gP)
useBitstamp= input.bool(true,  "BTC: aggregate Bitstamp volume", group = gP)

gR = "03 · Session Ranges (timed range context)"
useRange   = input.bool(true, "Enable session ranges", group = gR, tooltip = "Intraday charts only — on Daily and above this module switches itself off and the Range pillar reads neutral.")
tzInput    = input.string("America/New_York", "Timezone", options = ["Exchange", "UTC", "America/New_York", "America/Chicago", "Europe/London", "Europe/Berlin", "Asia/Karachi", "Asia/Kolkata", "Asia/Dubai", "Asia/Tokyo", "Asia/Singapore", "Australia/Sydney"], group = gR)
w1On       = input.bool(true, "Window 1", group = gR, inline = "w1")
w1Name     = input.string("NY", "Name", group = gR, inline = "w1")
w1Range    = input.session("0930-0945", "Range", group = gR, inline = "w1s")
w1Full     = input.session("0930-1600", "Session", group = gR, inline = "w1s")
w2On       = input.bool(true, "Window 2", group = gR, inline = "w2")
w2Name     = input.string("LON", "Name", group = gR, inline = "w2")
w2Range    = input.session("0300-0315", "Range", group = gR, inline = "w2s")
w2Full     = input.session("0300-1100", "Session", group = gR, inline = "w2s")
w3On       = input.bool(false, "Window 3", group = gR, inline = "w3")
w3Name     = input.string("ASIA", "Name", group = gR, inline = "w3")
w3Range    = input.session("2000-2015", "Range", group = gR, inline = "w3s")
w3Full     = input.session("2000-0400", "Session", group = gR, inline = "w3s")
rangeSat   = input.float(1.0, "Range pillar saturates at (x range beyond Cap / Floor)", minval = 0.25, maxval = 5.0, step = 0.25, group = gR, tooltip = "A burst this many range-widths beyond the Pressure Cap (range high) or Pressure Floor (range low) scores a full Range pillar (STRB T2 by default).")
showRangeBox = input.bool(true, "Draw range box + Cap / Floor / Equilibrium", group = gR, tooltip = "Pressure Cap = range high, Pressure Floor = range low, Equilibrium = midpoint. Each level carries a window-prefixed name tag on the chart.")
showRangeTags = input.bool(true, "Show level name tags", group = gR)
keepDays   = input.int(4, "Ranges kept on chart (per window)", minval = 1, maxval = 20, group = gR)
w1Col      = input.color(#2962FF, "W1", group = gR, inline = "wc")
w2Col      = input.color(#AB47BC, "W2", group = gR, inline = "wc")
w3Col      = input.color(#00ACC1, "W3", group = gR, inline = "wc")

gF = "04 · Signal Filter & Pressure Gates"
fadeMin    = input.int(3, "Min stack height to signal", minval = 1, maxval = 6, group = gF)
minMag     = input.float(0.0, "Min burst magnitude (ATR beyond band)", minval = 0, maxval = 12, step = 0.1, group = gF)
needRej    = input.bool(false, "Require rejection wick on the peak bar", group = gF)
rejMin     = input.float(0.30, "Min rejection wick (share of peak-bar range)", minval = 0, maxval = 0.95, step = 0.05, group = gF)
useRsiGate = input.bool(false, "Require RSI exhaustion", group = gF)
rsiLen     = input.int(14, "RSI length", minval = 2, maxval = 100, group = gF)
rsiOB      = input.float(65, "RSI overbought (SHORT above)", minval = 51, maxval = 99, group = gF)
rsiOS      = input.float(35, "RSI oversold (LONG below)", minval = 1, maxval = 49, group = gF)
needCluster= input.bool(false, "GATE · burst must hit / sweep an opposing cluster", group = gF, tooltip = "A SHORT needs the up-burst to reach into a short-liquidation cluster above; a LONG needs the down-burst to reach into a long-liquidation cluster below. A reclaim on the signal bar also satisfies it.")
clProx     = input.float(1.0, "Cluster proximity for partial credit (ATR)", minval = 0.1, maxval = 10, step = 0.1, group = gF, tooltip = "If the burst stops short of a cluster, the Pressure pillar still earns partial credit when the cluster is within this many ATR of the peak extreme.")
needRange  = input.bool(false, "GATE · burst must extend beyond the session range", group = gF)
sessionOnly= input.bool(false, "GATE · only trade inside an enabled trading session", group = gF)
allowShort = input.bool(true, "Allow SHORTS (up bursts)", group = gF)
allowLong  = input.bool(true, "Allow LONGS (down bursts)", group = gF)
cooldown   = input.int(20, "Minimum spacing between signals (bars)", minval = 0, maxval = 500, group = gF)

gT = "05 · Trade Levels & Universal Zones"
stopMode   = input.string("Burst Extreme", "Stop basis", options = ["Burst Extreme", "ATR Multiple", "Swing Extreme"], group = gT)
swingLook  = input.int(10, "Swing lookback (bars)", minval = 2, maxval = 200, group = gT)
stopAtr    = input.float(1.2, "Stop distance (ATR)", minval = 0.1, maxval = 10, step = 0.1, group = gT)
slBuf      = input.float(0.30, "Stop buffer beyond extreme (ATR)", minval = 0.0, maxval = 3, step = 0.05, group = gT)
maxRisk    = input.float(3.0, "Max risk (ATR) — stop cap", minval = 0.3, maxval = 10, step = 0.1, group = gT)
minRisk    = input.float(0.5, "Min risk (ATR) — stop floor", minval = 0.1, maxval = 5, step = 0.1, group = gT)
targetMode = input.string("Pressure Ladder", "Target ladder", options = ["R Multiples", "Mean Reversion (band → basis)", "Pressure Ladder"], group = gT, tooltip = "Pressure Ladder: TP1/2/3 snap to the nearest opposing liquidation clusters in the trade direction (price magnets); any missing rung falls back to its R multiple.\nMean Reversion: TP1 halfway to the basis, TP2 at the basis, TP3 half a band beyond.")
ladderMinR = input.float(0.6, "Pressure Ladder · min rung distance (R)", minval = 0.1, maxval = 5, step = 0.1, group = gT)
tp1R       = input.float(1.0, "TP1 (R)", minval = 0.25, maxval = 50, step = 0.25, group = gT)
tp2R       = input.float(2.0, "TP2 (R)", minval = 0.25, maxval = 50, step = 0.25, group = gT)
tp3R       = input.float(3.0, "TP3 (R)", minval = 0.25, maxval = 50, step = 0.25, group = gT)
maxHunt    = input.int(200, "Max bars in trade (time stop)", minval = 5, maxval = 5000, group = gT)
zoneW      = input.int(18, "UNIVERSAL zone width (bars)", minval = 3, maxval = 150, group = gT)
showBoxes  = input.bool(true, "Show SL / TP zones", group = gT)
showLines  = input.bool(true, "Show SL / TP lines", group = gT)
showLevelLbl = input.bool(true, "Label level prices", group = gT)
showExitLbl  = input.bool(true, "Show trade result labels", group = gT)
showBasisMark= input.bool(true, "Show basis marker on entry", group = gT)
maxHist    = input.int(16, "Max historical tickets drawn", minval = 1, maxval = 30, group = gT, tooltip = "Visual cap only. Statistics stay cumulative over every closed trade.")

gS = "06 · Strength Ranking (0-10)"
minStars   = input.int(0, "Minimum stars to take", minval = 0, maxval = 4, group = gS)
alertStars = input.int(0, "Alert minimum stars", minval = 0, maxval = 4, group = gS)
wExt   = input.float(0.16, "Weight · Burst Extension",     minval = 0, maxval = 1, step = 0.01, group = gS)
wStack = input.float(0.12, "Weight · Stack Height",        minval = 0, maxval = 1, step = 0.01, group = gS)
wExh   = input.float(0.12, "Weight · Momentum Exhaustion", minval = 0, maxval = 1, step = 0.01, group = gS)
wRej   = input.float(0.10, "Weight · Rejection Wick",      minval = 0, maxval = 1, step = 0.01, group = gS)
wTrend = input.float(0.08, "Weight · Trend Fit",           minval = 0, maxval = 1, step = 0.01, group = gS)
wCalm  = input.float(0.06, "Weight · Volatility Regime",   minval = 0, maxval = 1, step = 0.01, group = gS)
wRoom  = input.float(0.06, "Weight · Reversion Room",      minval = 0, maxval = 1, step = 0.01, group = gS)
wPress = input.float(0.20, "Weight · PRESSURE Cluster",    minval = 0, maxval = 1, step = 0.01, group = gS, tooltip = "Peak into / sweep of an opposing liquidation cluster, weighted by that cluster's 0-10 strength. A reclaim on the signal bar scores 0.9.")
wRange = input.float(0.10, "Weight · Session RANGE",       minval = 0, maxval = 1, step = 0.01, group = gS, tooltip = "Burst over-extension beyond the timed session range. A failed breakout back inside on the signal bar scores 0.9. Neutral (0.5) when no range is live.")

gD = "07 · Dashboard"
showDash    = input.bool(true, "Show dashboard", group = gD)
dashPosOpt  = input.string("Top Right", "Position", options = ["Top Right", "Top Left", "Bottom Right", "Bottom Left", "Middle Right", "Middle Left"], group = gD)
dashSizeOpt = input.string("Small", "Text size", options = ["Tiny", "Small", "Normal"], group = gD)
gaugeLen    = input.int(10, "Gauge width (blocks)", minval = 4, maxval = 20, group = gD)
showGauges  = input.bool(true, "Show live quality sliders", group = gD)
showPressRows = input.bool(true, "Show pressure context", group = gD)
showRangeRows = input.bool(true, "Show session range context", group = gD)
showHeatRow = input.bool(true, "Show TP1/2/3 · SL breakdown", group = gD)
showTiers   = input.bool(true, "Show win rate by strength", group = gD)
showRecent  = input.bool(true, "Show last trades", group = gD)
showMtf     = input.bool(true, "Show MTF burst strip", group = gD)
mtfTf2      = input.timeframe("15", "MTF · TF 2", group = gD)
mtfTf3      = input.timeframe("60", "MTF · TF 3", group = gD)

gV = "08 · Visuals & Theme"
theme      = input.string("Aurora", "Color theme", options = ["Aurora", "Gold Noir", "Bloomberg Amber", "Ice Blue", "Aqua Violet", "Neon Magenta", "Institutional"], group = gV)
showSignal = input.bool(true, "Show signal labels", group = gV)
showStars  = input.bool(true, "Show ★ ranking on labels", group = gV)
lblSizeOpt = input.string("Small", "Signal label size", options = ["Tiny", "Small", "Normal", "Large"], group = gV)
showBg     = input.bool(false, "Tint background on extreme bursts", group = gV)
showReclaimMarks = input.bool(false, "Show cluster reclaim diamonds", group = gV, tooltip = "Diamonds mark a sweep-and-reclaim of a cluster (support tone below, resistance tone above). Off by default to keep the chart clean — the reclaim still feeds the Pressure pillar, the dashboard event log and the alerts.")
showFailMarks    = input.bool(true, "Show failed range-breakout crosses", group = gV)
showBubbles= input.bool(true, "Show cluster bubbles", group = gV)
showGlow   = input.bool(true, "Bubble glow halo", group = gV)
showScore  = input.bool(true, "Show strength inside bubble", group = gV)
bubbleBoost= input.int(1, "Bubble size boost", minval = 0, maxval = 2, group = gV)
showLevels = input.bool(true, "Show cluster level lines", group = gV)
levelWidth = input.int(5, "Cluster level width", minval = 1, maxval = 10, group = gV)
levelTransp= input.int(70, "Cluster level transparency", minval = 0, maxval = 100, group = gV)
levelProj  = input.int(3, "Project levels past current bar", minval = 0, maxval = 200, group = gV)
colorMode  = input.string("By Side", "Cluster color mode", options = ["Spectrum (vertical)", "By Side"], group = gV)
topCol     = input.color(#21c997, "Top / Support tone",    group = gV, inline = "cc")
midCol     = input.color(#5b6cff, "Mid",                   group = gV, inline = "cc")
botCol     = input.color(#cc24e2, "Bottom / Resist tone",  group = gV, inline = "cc")
cCold      = input.color(#26c6da, "Mild",    group = gV, inline = "heat")
cWarm      = input.color(#ffd54a, "Warm",    group = gV, inline = "heat")
cHot       = input.color(#ff7a1a, "Hot",     group = gV, inline = "heat")
cExtreme   = input.color(#ff2b4e, "Extreme", group = gV, inline = "heat")

longCol  = theme == "Gold Noir" ? color.rgb(230, 184, 75) : theme == "Bloomberg Amber" ? color.rgb(255, 176, 46) : theme == "Ice Blue" ? color.rgb(38, 198, 255) : theme == "Aqua Violet" ? color.rgb(0, 225, 200) : theme == "Neon Magenta" ? color.rgb(0, 230, 200) : theme == "Institutional" ? color.rgb(31, 176, 118) : color.rgb(20, 214, 122)
shortCol = theme == "Gold Noir" ? color.rgb(203, 68, 56) : theme == "Bloomberg Amber" ? color.rgb(233, 84, 72) : theme == "Ice Blue" ? color.rgb(255, 112, 92) : theme == "Aqua Violet" ? color.rgb(184, 122, 255) : theme == "Neon Magenta" ? color.rgb(255, 62, 190) : theme == "Institutional" ? color.rgb(176, 62, 74) : color.rgb(243, 62, 110)
tpFill   = theme == "Gold Noir" ? color.rgb(120, 92, 20) : theme == "Bloomberg Amber" ? color.rgb(126, 86, 14) : theme == "Ice Blue" ? color.rgb(0, 92, 132) : theme == "Aqua Violet" ? color.rgb(0, 96, 88) : theme == "Neon Magenta" ? color.rgb(0, 98, 86) : theme == "Institutional" ? color.rgb(18, 96, 66) : color.rgb(12, 104, 64)
slFill   = theme == "Gold Noir" ? color.rgb(120, 40, 30) : theme == "Bloomberg Amber" ? color.rgb(122, 44, 34) : theme == "Ice Blue" ? color.rgb(140, 44, 66) : theme == "Aqua Violet" ? color.rgb(96, 40, 120) : theme == "Neon Magenta" ? color.rgb(128, 26, 90) : theme == "Institutional" ? color.rgb(110, 34, 42) : color.rgb(140, 30, 62)

color panelBg     = #0a0c12
color panelBgAlt  = #0f131c
color panelHdr    = #161b27
color panelBorder = #2c3342
color txtHi       = #ebeef5
color txtLo       = #8791a2
color neutralCol  = #69748a
color goodCol     = #21c87a
color badCol      = #e6435a
color warnCol     = color.rgb(214, 176, 74)
color midGray     = #9598A1

f_clamp(float v) => math.min(math.max(v, 0.0), 1.0)

f_size(string s) =>
    switch s
        "Tiny"   => size.tiny
        "Small"  => size.small
        "Normal" => size.normal
        "Large"  => size.large
        => size.small

f_pos(string p) =>
    switch p
        "Top Left"     => position.top_left
        "Top Right"    => position.top_right
        "Bottom Left"  => position.bottom_left
        "Bottom Right" => position.bottom_right
        "Middle Right" => position.middle_right
        "Middle Left"  => position.middle_left
        => position.top_right

f_stars(float sc) => sc >= 7.5 ? "★★★★" : sc >= 6.5 ? "★★★" : sc >= 5.5 ? "★★" : sc >= 4.5 ? "★" : "·"
f_tier(float sc)  => sc >= 7.5 ? 4 : sc >= 6.5 ? 3 : sc >= 5.5 ? 2 : sc >= 4.5 ? 1 : 0
f_tname(float sc) => sc >= 7.5 ? "ELITE" : sc >= 6.5 ? "STRONG" : sc >= 5.5 ? "MODERATE" : sc >= 4.5 ? "WEAK" : "MINIMAL"
f_signedR(float v) => (v >= 0 ? "+" : "") + str.tostring(v, "#.##") + "R"
f_px(float v) => na(v) ? "—" : str.tostring(v, format.mintick)

f_gauge(float v01, int n) =>
    int filled = math.max(0, math.min(n, int(math.round(f_clamp(v01) * n))))
    string s = ""
    for i = 1 to n
        s := s + (i <= filled ? "█" : "░")
    s

f_gcol(float v01) =>
    float t = f_clamp(v01)
    t < 0.5 ? color.from_gradient(t, 0.0, 0.5, badCol, warnCol) : color.from_gradient(t, 0.5, 1.0, warnCol, goodCol)

f_heat(float t) =>
    float tt = f_clamp(t)
    tt < 0.40 ? color.from_gradient(tt, 0.0, 0.40, cCold, cWarm) : tt < 0.75 ? color.from_gradient(tt, 0.40, 0.75, cWarm, cHot) : color.from_gradient(tt, 0.75, 1.0, cHot, cExtreme)

f_spectrum(float t) =>
    float x = f_clamp(t)
    x < 0.5 ? color.from_gradient(x / 0.5, 0.0, 1.0, botCol, midCol) : color.from_gradient((x - 0.5) / 0.5, 0.0, 1.0, midCol, topCol)

basis = switch basisType
    "SMA"  => ta.sma(srcIn, basisLen)
    "HMA"  => ta.hma(srcIn, basisLen)
    "WMA"  => ta.wma(srcIn, basisLen)
    "VWMA" => ta.vwma(srcIn, basisLen)
    "RMA"  => ta.rma(srcIn, basisLen)
    => ta.ema(srcIn, basisLen)

atr        = ta.atr(atrLen)
rsi        = ta.rsi(close, rsiLen)
atrPct     = ta.percentrank(atr, 100)
basisSlope = ta.change(basis, 3)
swingLo    = ta.lowest(low, swingLook)
swingHi    = ta.highest(high, swingLook)

float aSafe = nz(atr) > 0 ? atr : syminfo.mintick
float bSafe = nz(basis, close)
float upper = basis + bandMult * atr
float lower = basis - bandMult * atr

float upExtP = high - upper
float dnExtP = lower - low
float upMag  = na(upExtP) ? 0.0 : upExtP / aSafe
float dnMag  = na(dnExtP) ? 0.0 : dnExtP / aSafe

bool upSpike = not na(upper) and upExtP > 0 and (not needClose or close > upper)
bool dnSpike = not na(lower) and dnExtP > 0 and (not needClose or close < lower)
bool okBar   = confirmBar ? barstate.isconfirmed : true

float upM0 = upSpike ? math.max(0.0, upMag) : 0.0
float dnM0 = dnSpike ? math.max(0.0, dnMag) : 0.0

bool upPeak = okBar and nz(upM0[1]) > 0 and nz(upM0[1]) >= nz(upM0[2]) and nz(upM0[1]) > upM0
bool dnPeak = okBar and nz(dnM0[1]) > 0 and nz(dnM0[1]) >= nz(dnM0[2]) and nz(dnM0[1]) > dnM0

float upPk = nz(upM0[1])
float dnPk = nz(dnM0[1])
int   upLvlPk = math.min(maxLevels, 1 + int(upPk / stepATR))
int   dnLvlPk = math.min(maxLevels, 1 + int(dnPk / stepATR))

float pkHi    = nz(high[1], high)
float pkLo    = nz(low[1], low)
float pkOpen  = nz(open[1], open)
float pkClose = nz(close[1], close)
float pkRange = math.max(pkHi - pkLo, syminfo.mintick)
float upRej   = (pkHi - math.max(pkOpen, pkClose)) / pkRange
float dnRej   = (math.min(pkOpen, pkClose) - pkLo) / pkRange
float rsiPk   = nz(rsi[1], 50.0)

int   liveDir = upSpike ? -1 : dnSpike ? 1 : (close > bSafe ? -1 : 1)
float liveMag = upSpike ? upMag : dnSpike ? dnMag : 0.0
int   liveLvl = upSpike or dnSpike ? math.min(maxLevels, 1 + int(math.max(0.0, liveMag) / stepATR)) : 0
float barRng  = math.max(high - low, syminfo.mintick)
float liveRej = liveDir == -1 ? (high - math.max(open, close)) / barRng : (math.min(open, close) - low) / barRng

int   n      = bar_index
float atrRaw = math.max(nz(ta.atr(clAtrLen), ta.cum(high - low) / (n + 1)), syminfo.mintick)

bool  isBTC = syminfo.basecurrency == "BTC"
float binV  = useBinance  and isBTC ? request.security("BINANCE:BTCUSD",  timeframe.period, volume, gaps = barmerge.gaps_off) : 0.0
float cbV   = useCoinbase and isBTC ? request.security("COINBASE:BTCUSD", timeframe.period, volume, gaps = barmerge.gaps_off) : 0.0
float bsV   = useBitstamp and isBTC ? request.security("BITSTAMP:BTCUSD", timeframe.period, volume, gaps = barmerge.gaps_off) : 0.0
float cumV   = binV + cbV + bsV
float volVal = cumV > 0 ? cumV : volume
float volBase= ta.sma(volVal, volLen)

float liqWeight = volVal * (high - low) * 100.0
float weightMax = math.min(ta.highest(liqWeight, weightLB), 1e10)
float weightMinR= ta.lowest(liqWeight, weightLB)
float weightMin = weightMinR == weightMax ? weightMax * 0.85 : weightMinR
float specHi    = ta.highest(high, weightLB)
float specLo    = ta.lowest(low,  weightLB)

float ph    = ta.pivothigh(leftBars, rightBars)
float pl    = ta.pivotlow(leftBars, rightBars)
bool  inWin = lookbackW <= 0 or (last_bar_index - n) <= lookbackW
float bandH = atrRaw * bandATR
bool  supOn = clSide == "Both" or clSide == "Longs Only (below)"
bool  resOn = clSide == "Both" or clSide == "Shorts Only (above)"

f_zoneCol(float mid, int side) =>
    color c = na
    if colorMode == "By Side"
        c := side == 1 ? topCol : botCol
    else
        float vr = specHi - specLo
        float nv = vr > 0 ? f_clamp((mid - specLo) / vr) : 0.5
        c := f_spectrum(nv)
    c

f_wnorm(float w) =>
    float den = weightMax - weightMin
    float nw  = den > 0 ? f_clamp((w - weightMin) / den) : 0.5
    math.pow(nw, magContrast)

f_tierOf(float wn) => wn < 0.25 ? 0 : wn < 0.5 ? 1 : wn < 0.75 ? 2 : 3
f_coreSize(int t)  => t <= 0 ? size.small : t == 1 ? size.normal : t == 2 ? size.large : size.huge
f_glowSize(int t)  => f_coreSize(t + 1)
f_rangeOverlap(float t1, float b1, float t2, float b2) =>
    float ov   = math.min(t1, t2) - math.max(b1, b2)
    float minH = math.min(t1 - b1, t2 - b2)
    ov > 0 and minH > 0 and ov / minH >= overlapThr / 100.0

type zone
    int   dir     = 1
    float top     = na
    float bot     = na
    float mid     = na
    int   bornBar = na
    int   lastBar = na
    int   touches = 0
    float volSum  = 0.0
    int   volN    = 0
    float wickSum = 0.0
    int   wickN   = 0
    int   sweeps  = 0
    int   phase   = 0
    int   swBar   = na
    float score   = 0.0
    float weight  = 0.0
    int   tier    = 0
    line  ln      = na
    label glow    = na
    label core    = na
    label num     = na
    bool  dead    = false

var array<zone> zones = array.new<zone>()

f_defense(zone z) =>
    float tF = math.min(z.touches / 4.0, 1.0)
    float vF = volBase > 0 and z.volN > 0 ? math.min((z.volSum / z.volN) / volBase, 1.0) : 0.0
    float wF = z.wickN > 0 ? math.min((z.wickSum / z.wickN) / atrRaw, 1.0) : 0.0
    float sF = math.min(z.sweeps / 2.0, 1.0)
    tF * 0.30 + vF * 0.20 + wF * 0.20 + sF * 0.30

f_ageF(int age) => math.max(1.0 - 0.35 * math.min(age / 400.0, 1.0), 0.65)

method buildBubble(zone self) =>
    if not na(self.glow)
        label.delete(self.glow)
    if not na(self.core)
        label.delete(self.core)
    if not na(self.num)
        label.delete(self.num)
    self.glow := na
    self.core := na
    self.num  := na
    if showBubbles
        color base = f_zoneCol(self.mid, self.dir)
        int   t    = math.min(self.tier + bubbleBoost, 3)
        if showGlow
            self.glow := label.new(self.bornBar, self.mid, "", xloc = xloc.bar_index, style = label.style_circle, color = color.new(base, 88), size = f_glowSize(t))
        self.core := label.new(self.bornBar, self.mid, "", xloc = xloc.bar_index, style = label.style_circle, color = color.new(base, 66), size = f_coreSize(t))
        if showScore
            self.num := label.new(self.bornBar, self.mid, "", xloc = xloc.bar_index, style = label.style_label_center, color = color.new(color.black, 100), textcolor = color.white, size = size.small)
    if not na(self.core)
        label.set_xy(self.core, self.bornBar, self.mid)

method refresh(zone self, float sc) =>
    color base = f_zoneCol(self.mid, self.dir)
    int   ct   = int(math.round(66.0 - 46.0 * f_clamp(sc / 10.0)))
    if showLevels
        int lx2 = n + levelProj
        if na(self.ln)
            self.ln := line.new(self.bornBar, self.mid, lx2, self.mid, xloc = xloc.bar_index, color = color.new(base, levelTransp), width = levelWidth, style = line.style_solid)
        else
            line.set_xy1(self.ln, self.bornBar, self.mid)
            line.set_xy2(self.ln, lx2, self.mid)
        if not na(self.ln)
            line.set_color(self.ln, color.new(base, self.phase == 1 ? math.min(levelTransp + 15, 100) : levelTransp))
    else if not na(self.ln)
        line.delete(self.ln)
        self.ln := na
    int et = math.min(self.tier + bubbleBoost, 3)
    if not na(self.core)
        label.set_color(self.core, color.new(base, ct))
        label.set_size(self.core, f_coreSize(et))
    if not na(self.glow)
        label.set_color(self.glow, color.new(base, math.min(ct + 22, 100)))
        label.set_size(self.glow, f_glowSize(et))
    if not na(self.num)
        label.set_text(self.num, str.tostring(int(math.round(sc))))
    if not na(self.core)
        label.set_xy(self.core, self.bornBar, self.mid)

method kill(zone self) =>
    if not na(self.ln)
        line.delete(self.ln)
    if not na(self.glow)
        label.delete(self.glow)
    if not na(self.core)
        label.delete(self.core)
    if not na(self.num)
        label.delete(self.num)
    self.dead := true

f_overlapsActive(float t, float b) =>
    bool hit = false
    if array.size(zones) > 0
        for z in zones
            if not z.dead and z.phase != 1 and f_rangeOverlap(t, b, z.top, z.bot)
                hit := true
                break
    hit

f_spawn(int side, float lvl, float w) =>
    float wn = f_wnorm(nz(w))
    float t  = lvl + bandH / 2.0
    float b  = lvl - bandH / 2.0
    if wn >= clMinMag and not (hideOverlap and f_overlapsActive(t, b))
        zone z = zone.new()
        z.dir     := side
        z.top     := t
        z.bot     := b
        z.mid     := lvl
        z.bornBar := n - rightBars
        z.lastBar := n - rightBars
        z.volSum  := nz(volVal)
        z.volN    := 1
        z.weight  := nz(w)
        z.tier    := f_tierOf(wn)
        z.buildBubble()
        array.push(zones, z)

if supOn and not na(pl) and inWin
    f_spawn(1, pl, liqWeight[rightBars])
if resOn and not na(ph) and inWin
    f_spawn(-1, ph, liqWeight[rightBars])

while array.size(zones) > maxZones
    array.shift(zones).kill()

bool  evTouch  = false
bool  evSweep  = false
bool  evBreak  = false
bool  recBull  = false
bool  recBear  = false
bool  hitRes   = false
bool  hitSup   = false
float hitResSc = 0.0
float hitSupSc = 0.0

float liveMaxW = 0.0
float liveMinW = 1e18
if array.size(zones) > 0
    for z in zones
        if not z.dead
            liveMaxW := math.max(liveMaxW, z.weight)
            liveMinW := math.min(liveMinW, z.weight)
if liveMaxW <= 0.0
    liveMaxW := 1.0
if liveMinW > liveMaxW
    liveMinW := 0.0

if array.size(zones) > 0
    for i = 0 to array.size(zones) - 1
        zone z = array.get(zones, i)
        if not z.dead
            z.volSum += nz(volVal)
            z.volN   += 1
            if n - z.bornBar >= maxLife
                z.kill()
            else
                if z.dir == 1
                    if low <= z.top
                        hitSup   := true
                        hitSupSc := math.max(hitSupSc, z.score)
                    if z.phase == 0
                        if low <= z.top and low >= z.bot and close > z.bot
                            z.touches += 1
                            z.wickSum += math.max(z.top - low, 0)
                            z.wickN   += 1
                            z.lastBar := n
                            evTouch   := true
                        else if low < z.bot - minDepth * atrRaw
                            z.phase := 1
                            z.swBar := n
                            evSweep := true
                    else if z.phase == 1
                        bool accepted = close < z.bot - breakAtr * atrRaw or (n - z.swBar >= reclaimWin and close < z.bot)
                        if close > z.bot
                            recBull   := true
                            z.sweeps  += 1
                            z.lastBar := n
                            z.phase   := 0
                        else if accepted
                            evBreak := true
                            if flipBroken
                                z.dir     := -1
                                z.touches := 0
                                z.wickSum := 0.0
                                z.wickN   := 0
                                z.phase   := 0
                                z.lastBar := n
                            else
                                z.kill()
                else
                    if high >= z.bot
                        hitRes   := true
                        hitResSc := math.max(hitResSc, z.score)
                    if z.phase == 0
                        if high >= z.bot and high <= z.top and close < z.top
                            z.touches += 1
                            z.wickSum += math.max(high - z.bot, 0)
                            z.wickN   += 1
                            z.lastBar := n
                            evTouch   := true
                        else if high > z.top + minDepth * atrRaw
                            z.phase := 1
                            z.swBar := n
                            evSweep := true
                    else if z.phase == 1
                        bool accepted = close > z.top + breakAtr * atrRaw or (n - z.swBar >= reclaimWin and close > z.top)
                        if close < z.top
                            recBear   := true
                            z.sweeps  += 1
                            z.lastBar := n
                            z.phase   := 0
                        else if accepted
                            evBreak := true
                            if flipBroken
                                z.dir     := 1
                                z.touches := 0
                                z.wickSum := 0.0
                                z.wickN   := 0
                                z.phase   := 0
                                z.lastBar := n
                            else
                                z.kill()
                if not z.dead
                    float magN = liveMaxW > liveMinW ? f_clamp((z.weight - liveMinW) / (liveMaxW - liveMinW)) : 0.5
                    magN := math.pow(magN, magContrast)
                    float sc = math.min(math.max((magWeight * magN + (1.0 - magWeight) * f_defense(z) * f_ageF(n - z.lastBar)) * 10.0, 1.0), 10.0)
                    z.score := sc
                    z.tier  := f_tierOf(magN)
                    z.refresh(sc)

if array.size(zones) > 0
    for i = array.size(zones) - 1 to 0
        if array.get(zones, i).dead
            array.remove(zones, i)

float nearResPx = na
float nearResD  = na
float nearResSc = na
float nearSupPx = na
float nearSupD  = na
float nearSupSc = na
int   liveSup   = 0
int   liveRes   = 0
int   sweptCnt  = 0
if array.size(zones) > 0
    for z in zones
        if not z.dead
            if z.phase == 1
                sweptCnt += 1
            if z.dir == -1
                liveRes += 1
                if z.mid > close
                    float d = (z.mid - close) / aSafe
                    if na(nearResD) or d < nearResD
                        nearResD  := d
                        nearResPx := z.mid
                        nearResSc := z.score
            else
                liveSup += 1
                if z.mid < close
                    float d = (close - z.mid) / aSafe
                    if na(nearSupD) or d < nearSupD
                        nearSupD  := d
                        nearSupPx := z.mid
                        nearSupSc := z.score

var string lastEvt    = "—"
var int    lastEvtBar = na
var int    cSweeps    = 0
var int    cReclaims  = 0
var int    cBreaks    = 0
if recBull or recBear
    lastEvt    := recBull ? "RECLAIM ▲" : "RECLAIM ▼"
    lastEvtBar := n
    cReclaims  += 1
else if evBreak
    lastEvt    := "BREAK"
    lastEvtBar := n
    cBreaks    += 1
else if evSweep
    lastEvt    := "SWEEP"
    lastEvtBar := n
    cSweeps    += 1
else if evTouch
    lastEvt    := "TOUCH"
    lastEvtBar := n

bool   rangeOk = useRange and timeframe.isintraday
string tz      = tzInput == "Exchange" ? syminfo.timezone : tzInput

type Win
    string name
    color  col
    bool   wasInside = false
    bool   wasFull   = false
    float  hi        = na
    float  lo        = na
    int    startBar  = na
    bool   done      = false
    bool   armed     = false
    bool   extending = false
    int    brk       = 0
    bool   failed    = false
    int    sessions  = 0
    int    nBrk      = 0
    int    nFail     = 0
    array<line>  lns
    array<box>   bxs
    array<label> lbls

f_runWin(Win w, bool enabled, bool inR, bool inF) =>
    bool brkUp = false
    bool brkDn = false
    bool failU = false
    bool failD = false
    bool rDone = false
    if enabled and barstate.isconfirmed
        bool rStart = inR and not w.wasInside
        bool rEnd   = not inR and w.wasInside
        if not inF and w.wasFull
            w.armed := false
        if rStart
            w.hi        := high
            w.lo        := low
            w.startBar  := bar_index
            w.done      := false
            w.armed     := false
            w.extending := false
            w.brk       := 0
            w.failed    := false
            w.sessions  += 1
            if showRangeBox
                while array.size(w.bxs) >= keepDays
                    box.delete(array.shift(w.bxs))
                while array.size(w.lns) > (keepDays - 1) * 3
                    line.delete(array.shift(w.lns))
                while array.size(w.lbls) > (keepDays - 1) * 3
                    label.delete(array.shift(w.lbls))
                array.push(w.bxs, box.new(bar_index, high, bar_index, low, bgcolor = color.new(w.col, 88), border_color = w.col, border_width = 1))
        else if inR and not na(w.hi)
            w.hi := math.max(w.hi, high)
            w.lo := math.min(w.lo, low)
        if inR and showRangeBox and array.size(w.bxs) > 0
            box bx = array.get(w.bxs, array.size(w.bxs) - 1)
            box.set_top(bx, w.hi)
            box.set_bottom(bx, w.lo)
            box.set_right(bx, bar_index)
        if rEnd and not na(w.hi) and not w.done
            w.done  := true
            w.armed := true
            rDone   := true
            if showRangeBox
                array.push(w.lns, line.new(w.startBar, w.hi, bar_index, w.hi, color = longCol,  width = 2))
                array.push(w.lns, line.new(w.startBar, w.lo, bar_index, w.lo, color = shortCol, width = 2))
                array.push(w.lns, line.new(w.startBar, (w.hi + w.lo) / 2, bar_index, (w.hi + w.lo) / 2, color = color.new(midGray, 30), width = 1, style = line.style_dashed))
                if showRangeTags
                    array.push(w.lbls, label.new(bar_index, w.hi, w.name + " Pressure Cap", style = label.style_label_left, color = color.new(longCol, 100), textcolor = longCol, size = size.small))
                    array.push(w.lbls, label.new(bar_index, w.lo, w.name + " Pressure Floor", style = label.style_label_left, color = color.new(shortCol, 100), textcolor = shortCol, size = size.small))
                    array.push(w.lbls, label.new(bar_index, (w.hi + w.lo) / 2, w.name + " Equilibrium", style = label.style_label_left, color = color.new(midGray, 100), textcolor = midGray, size = size.small))
            w.extending := inF
        if w.extending and not inF
            w.extending := false
        if w.extending and array.size(w.lns) >= 3
            int sz = array.size(w.lns)
            for i = sz - 3 to sz - 1
                line.set_x2(array.get(w.lns, i), bar_index)
        if w.extending and array.size(w.lbls) >= 3
            int lz = array.size(w.lbls)
            for i = lz - 3 to lz - 1
                label.set_x(array.get(w.lbls, i), bar_index)
        if w.armed and w.done and inF and not inR and not na(w.hi)
            if w.brk == 0
                if close > w.hi
                    brkUp := true
                    w.brk := 1
                    w.nBrk += 1
                else if close < w.lo
                    brkDn := true
                    w.brk := -1
                    w.nBrk += 1
            else if not w.failed
                if w.brk == 1 and close < w.hi
                    failU    := true
                    w.failed := true
                    w.nFail  += 1
                else if w.brk == -1 and close > w.lo
                    failD    := true
                    w.failed := true
                    w.nFail  += 1
        w.wasInside := inR
        w.wasFull   := inF
    [brkUp, brkDn, failU, failD, rDone]

var Win w1 = Win.new(name = w1Name, col = w1Col, lns = array.new<line>(), bxs = array.new<box>(), lbls = array.new<label>())
var Win w2 = Win.new(name = w2Name, col = w2Col, lns = array.new<line>(), bxs = array.new<box>(), lbls = array.new<label>())
var Win w3 = Win.new(name = w3Name, col =

Показано первые 50% кода (символов: 55988)