Strong Magnet Zones
Похожие материалы по тегам
Сообщите нам, если считаете, что материал размещён без разрешения.
Сообщить о материале
Обращение по товару «indicator strong magnet zones for tradingview.pine» отправится на рассмотрение. Укажите контакт для ответа и опишите причину.
О программе
«Strong Magnet Zones» — индикатор для TradingView, который строит зоны спроса и предложения (магнитные зоны) на основе свинговых структур цены. Зоны формируются на выбранном таймфрейме и отображаются на графике в виде залитых прямоугольников с оценкой актуальности (тепло), которое постепенно затухает со временем. Индикатор отслеживает, как цена тестирует эти зоны, и фиксирует результаты — отработка, разворот или продолжение движения.
Встроена система теплового scoring: каждая зона получает числовую оценку, зависящую от актуальности, количества наложений, объёма при формировании и близости к ровным числам. Горячие зоны выделяются специальной подсветкой и свечами. На графике отображаются магниты — самые горячие зоны выше и ниже текущей цены, а также метки проскальзывания с информацией о результатах.
Индикатор поддерживает систему тикетов с входом, стоп-лоссом и тейк-профитом, которые отрисовываются при срабатывании сигналов. Фильтрация сигналов осуществляется с помощью инвизуального фильтра Лагерра (по настройкам пользователя). Доступны условные оповещения TradingView для различных событий: проскальзывание зон, достижение магнитов, срабатывание сигналов и закрытие тикетов.
Настройки программы
| Настройка | Описание |
|---|---|
| lockTf | Таймфрейм, на котором строятся зоны. Все графики на или ниже этого таймфрейма видят одни и те же зоны |
| pivLen | Длина свинга — количество баров по каждой стороне для определения свинг-хая/лоу |
| mergeTol | Допуск слияния новых зон с существующими (в кратных ATR) |
| useVol | Учитывать объём при формировании свинга для веса зоны |
| useRound | Усиливать зоны, расположенные на ровных числах |
| roundStp | Шаг ровного числа для усиления зон (0 = автоматический) |
| heightMode | Метод расчёта высоты зоны: ATR Based или Fixed Percentage |
| heightATR | Высота зоны в кратных значениях ATR (при режиме ATR Based) |
| heightPct | Высота зоны в процентах от цены (при режиме Fixed Percentage) |
| atrLen | Длина ATR для таймфрейма построения зон |
| minBase | Минимальное количество свечей в базе спроса/предложения |
| maxBase | Максимальное количество свечей в базе спроса/предложения |
| baseThresh | Максимальное соотношение тела свечи к диапазону для базы спроса/предложения |
| legOutThresh | Минимальное соотношение тела к диапазону для выхода из базы |
| legOutMult | Множитель диапазона выхода относительно среднего диапазона базы |
| depCandles | Количество свечей устойчивого удаления для подтверждения базы |
| halfLife | Период полураспада тепла в барах таймфрейма построения |
| touchAdd | Количество тепла, добавляемое при касании зоны без проскальзывания |
| maxLv | Максимальное количество активных зон одновременно |
| maxDist | Максимальная дистанция от цены для отображения зон (в кратных ATR) |
| minShow | Минимальная оценка зоны для отображения на графике (0–10) |
| hotPct | Порог тепла для признания зоны горячей (от 0 до 100) |
| workRR | Множитель высоты зоны: цена должна пройти это расстояние после теста для признания отработкой |
| revBars | Окно в барах для определения разворота после проскальзывания зоны |
| revAtr | Множитель ATR для подтверждения разворота после проскальзывания зоны |
| keepRes | Количество решённых зон, сохраняемых на графике |
| showSig | Отображать торговые сигналы и тикеты |
| sigMode | Режим фильтра тренма для сигналов: Trend aligned, Trend or turning или Any |
| lagLen | Период фильтра Лагерра для определения тренма |
| sigWin | Окно в барах после проскальзывания для восстановления зоны и генерации сигнала |
| minScore | Минимальная оценка сигнала для его срабатывания (0–10) |
| coolBars | Пауза в барах после закрытия тикета перед открытием нового сигнала |
| showTk | Отрисовывать R-тикеты с уровнями входа, стоп-лосса и тейк-профита |
| slPad | Отступ стоп-лосса за экстремум проскальзывания (в кратных ATR) |
| maxRisk | Максимальный риск в кратных ATR |
| minRisk | Минимальный риск в кратных ATR |
| defRR | Целевое расстояние по R по умолчанию, если не подходит магнит |
| maxRR | Максимальное расстояние цели по R |
| maxHold | Таймаут тикета в барах — после истечения тикет закрывается |
| keepTk | Количество тикетов, сохраняемых на графике |
| showZ | Отображать магнитные зоны на графике |
| maxSide | Максимальное количество живых зон, отображаемых на каждую сторону |
| showLbl | Отображать подписи внутри активных зон |
| lblMax | Максимальное количество подписей внутри лучших активных зон |
| lblMin | Минимальная оценка зоны для отображения подписи (0–10) |
| lblRes | Отображать краткие подписи на решённых зонах |
| lblSize | Размер подписей внутри зон |
| showEdge | Отображать линии ближнего (сплошная) и дальнего (пунктирная) краёв зон |
| showSwept | Отображать решённые зоны (затенённые) |
| resBars | Максимальная длина полосы решённых зон в барах |
| showProf | Отображать тепловой профиль справа от графика |
| profBins | Количество строк (корзин) в тепловом профиле справа |
| profWidth | Ширина теплового профиля в барах |
| extRight | Количество баров для продления зон вправо от последней свечи |
| showMag | Отображать магниты — самые горячие зоны выше и ниже цены |
| showSwpL | Отображать метки проскальзывания ⚡ (сплошная = разворот, затухшая = продолжение) |
| hotCandle | Подсвечивать свечи внутри горячих зон |
| cBull | Цвет бычьих магнитных зон |
| cBear | Цвет медвежьих магнитных зон |
| cSwept | Цвет решённых (проскользнувших) зон |
| fillTransp | Прозрачность заливки зон |
| showBord | Отображать границы зон |
| bordTransp | Прозрачность границ зон |
| cTp | Цвет тейк-профита на тикете |
| cSl | Цвет стоп-лосса на тикете |
Поиск по коду файла
indicator("Strong Magnet Zones", "Strong Magnet Zones", overlay=true, max_boxes_count=500, max_lines_count=500, max_labels_count=500, max_bars_back=5000)
grpB = "1 · Build"
lockTf = input.timeframe("30", "Build zones on timeframe", group=grpB, tooltip="Stop pools AND supply/demand bases are built from this timeframe, so every chart at or below it (1m, 5m, 15m, 30m) shows the same zones. Charts above it use their own timeframe. Leave empty to always use the chart timeframe.")
pivLen = input.int(5, "Swing length", minval=2, maxval=30, group=grpB, tooltip="A swing high/low needs this many bars on each side. Stops sit just beyond these swings.")
mergeTol = input.float(0.30, "Merge tolerance (× ATR)", minval=0.05, step=0.05, group=grpB, tooltip="A new pool or base that comes within this distance of a same-side zone merges into it (equal highs/lows stack heat; a pool inside a base becomes a confluence zone).")
useVol = input.bool(true, "Weight by volume at the swing", group=grpB)
useRound = input.bool(true, "Boost zones holding a round number", group=grpB)
roundStp = input.float(0.0, "Round number step (0 = auto)", minval=0.0, group=grpB)
grpZ = "2 · Zone height (universal)"
heightMode = input.string("ATR Based", "Height method", options=["ATR Based", "Fixed Percentage"], group=grpZ, tooltip="Every zone — stop pool, base or merged — gets the SAME thickness, centered on its level (swing price, or base midpoint).")
heightATR = input.float(0.6, "Zone height (ATR mult)", minval=0.05, maxval=10.0, step=0.05, group=grpZ)
heightPct = input.float(0.30, "Zone height (% of price)", minval=0.01, maxval=5.0, step=0.05, group=grpZ)
atrLen = input.int(200, "ATR length (build TF)", minval=1, maxval=500, group=grpZ)
grpS = "3 · Supply / demand bases"
minBase = input.int(1, "Min base candles", minval=1, group=grpS)
maxBase = input.int(5, "Max base candles", minval=1, maxval=20, group=grpS)
baseThresh = input.float(0.65, "Max base body/range ratio", minval=0.1, maxval=0.95, step=0.05, group=grpS)
legOutThresh = input.float(0.55, "Min leg-out body/range ratio", minval=0.3, maxval=0.95, step=0.05, group=grpS)
legOutMult = input.float(1.4, "Leg-out range vs base average (×)", minval=1.0, step=0.1, group=grpS)
depCandles = input.int(1, "Sustained departure candles", minval=1, maxval=5, group=grpS)
grpH = "4 · Heat & lifecycle"
halfLife = input.int(150, "Heat half-life (bars of build TF)", minval=10, maxval=2000, group=grpH)
touchAdd = input.float(0.3, "Heat added per touch without sweep", minval=0.0, step=0.1, group=grpH)
maxLv = input.int(60, "Max active zones", minval=10, maxval=200, group=grpH)
maxDist = input.float(16.0, "Show zones within (× ATR of price)", minval=2.0, step=0.5, group=grpH)
minShow = input.float(4.0, "Hide zones scoring below (0–10)", minval=0.0, maxval=10.0, step=0.5, group=grpH)
hotPct = input.int(60, "Hot zone = heat ≥", minval=10, maxval=100, group=grpH)
workRR = input.float(1.0, "WORKED = price travels (× zone height) after a test", minval=0.5, maxval=5.0, step=0.5, group=grpH)
revBars = input.int(10, "Sweep → reversal window (bars)", minval=2, maxval=100, group=grpH)
revAtr = input.float(0.5, "Reversal = close back beyond zone by (× ATR)", minval=0.1, step=0.1, group=grpH)
keepRes = input.int(30, "Resolved zones kept on chart", minval=0, maxval=150, group=grpH)
grpG = "5 · Signals & tickets"
showSig = input.bool(true, "Signals", group=grpG)
sigMode = input.string("Trend or turning", "Trend gate (Laguerre, not drawn)", options=["Trend aligned", "Trend or turning", "Any"], group=grpG, tooltip="An invisible Ehlers Laguerre fast/slow filter gates signals. Trend aligned: BUY only when fast > slow AND rising. Trend or turning: either. Any: no gate. Nothing is plotted.")
lagLen = input.int(20, "Laguerre period", minval=5, group=grpG)
sigWin = input.int(8, "Reclaim within (bars after a sweep)", minval=1, maxval=50, group=grpG)
minScore = input.float(6.0, "Min signal score (0–10)", minval=0.0, maxval=10.0, step=0.5, group=grpG)
coolBars = input.int(10, "Cooldown after a ticket closes (bars)", minval=0, maxval=200, group=grpG)
showTk = input.bool(true, "Draw R-tickets (entry / SL / TP)", group=grpG)
slPad = input.float(0.15, "SL pad beyond the sweep extreme (× ATR)", minval=0.0, step=0.05, group=grpG)
maxRisk = input.float(2.0, "Max risk (× ATR)", minval=0.3, step=0.1, group=grpG)
minRisk = input.float(0.4, "Min risk (× ATR)", minval=0.1, step=0.1, group=grpG)
defRR = input.float(2.0, "Default target (R) when no magnet fits", minval=0.5, step=0.5, group=grpG)
maxRR = input.float(5.0, "Max target distance (R)", minval=1.0, step=0.5, group=grpG)
maxHold = input.int(60, "Ticket timeout (bars)", minval=5, maxval=500, group=grpG)
keepTk = input.int(12, "Tickets kept on chart", minval=1, maxval=60, group=grpG)
grpV = "6 · Visuals"
showZ = input.bool(true, "Magnet zones", group=grpV)
maxSide = input.int(5, "Max live zones shown per side", minval=1, maxval=30, group=grpV, tooltip="Only the best-scoring live zones in view are drawn, per side. Keeps the chart readable.")
showLbl = input.bool(true, "Labels inside zones", group=grpV)
lblMax = input.int(4, "Max labels (best live zones)", minval=1, maxval=20, group=grpV)
lblMin = input.float(5.0, "Label zones scoring ≥", minval=0.0, maxval=10.0, step=0.5, group=grpV)
lblRes = input.bool(true, "Brief labels on resolved zones", group=grpV, tooltip="Resolved zones are greyed out and carry a short label: score · outcome (WORKED ✔ / ⚡ REVERSED ✔ / ⚡ CONTINUED ✘).")
lblSize = input.string("Normal", "Label size", options=["Tiny", "Small", "Normal", "Large"], group=grpV)
showEdge = input.bool(false, "Proximal (solid) / distal (dashed) edge lines", group=grpV)
showSwept = input.bool(true, "Show resolved zones (greyed out)", group=grpV)
resBars = input.int(400, "Resolved band max length (bars)", minval=20, maxval=3000, group=grpV)
showProf = input.bool(true, "Heat profile on the right", group=grpV)
profBins = input.int(40, "Profile rows", minval=10, maxval=80, group=grpV)
profWidth = input.int(12, "Profile width (bars)", minval=5, maxval=100, group=grpV)
extRight = input.int(3, "Extend zones right (bars)", minval=0, maxval=50, group=grpV)
showMag = input.bool(true, "Magnets (hottest zone above / below)", group=grpV)
showSwpL = input.bool(true, "Sweep marks ⚡ (solid = reversed · faded = continued)", group=grpV)
hotCandle = input.bool(true, "Glow candles inside hot zones", group=grpV)
grpK = "7 · Style"
cBull = input.color(#21c997, "Magnet Zone Bulls tone", group=grpK)
cBear = input.color(#cc24e2, "Magnet Zone Bears tone", group=grpK)
cSwept = input.color(#B2B5BE, "Swept / resolved zone", group=grpK)
fillTransp= input.int(84, "Zone transparency", minval=50, maxval=96, group=grpK)
showBord = input.bool(true, "Show zone borders", group=grpK)
bordTransp= input.int(35, "Border transparency", minval=0, maxval=100, group=grpK)
cTp = input.color(#4caf50, "Ticket TP", group=grpK)
cSl = input.color(#e53935, "Ticket SL", group=grpK)
type MZ
float lvl
float top
float bot
int side
float w
int born
int bornT
int stacks = 0
bool sd = false
float imp = 0.0
float bod = 0.0
float vf = 1.0
bool rnd = false
int tests = 0
bool inLast = false
int addB = na
int state = 0
int revRes = 0
int endBar = na
float score = 0.0
float hpEnd = 0.0
box bx = na
line pLn = na
line dLn = na
label tag = na
type Tk
int dir
float entry
float sl
float tp
int born
float r
line eLn
line sLn
line tLn
box rBox
box pBox
label sig
label out = na
int state = 0
int chSec = timeframe.in_seconds()
int lkSec = lockTf == "" ? chSec : timeframe.in_seconds(lockTf)
string effTf = lkSec > chSec ? lockTf : timeframe.period
int effSec = math.max(lkSec, chSec)
float tfMult = float(effSec) / chSec
f_sdDetect() =>
int dirO = 0
float zTop = na
float zBot = na
float imp = 0.0
float bod = 0.0
float vf = 1.0
int st = na
float va = ta.sma(nz(volume), 50)
int lo = depCandles
if bar_index >= maxBase + lo + 5
float rngL = high[lo] - low[lo]
float bdyL = math.abs(close[lo] - open[lo])
if rngL > 0 and bdyL / rngL >= legOutThresh
bool bull = close[lo] > open[lo]
int bc = 0
int sb = lo + 1
for i = 0 to maxBase - 1
float r = high[sb + i] - low[sb + i]
float b = math.abs(close[sb + i] - open[sb + i])
if r > 0 and b / r <= baseThresh
bc += 1
else
break
bool inside = high[sb] <= high[sb + 1] and low[sb] >= low[sb + 1]
if bc >= minBase and not inside
float bh = high[sb]
float bl = low[sb]
float sum = 0.0
for b2 = 0 to bc - 1
bh := math.max(bh, high[sb + b2])
bl := math.min(bl, low[sb + b2])
sum += high[sb + b2] - low[sb + b2]
float avg = sum / bc
float zh = bh - bl
if zh > 0 and zh < rngL and rngL >= avg * legOutMult
bool ok = true
for dep = 1 to depCandles
int d = lo - dep
if d >= 0
if bull ? (close[d] <= bh or low[d] <= bh) : (close[d] >= bl or high[d] >= bl)
ok := false
if ok and (bull ? close[lo] > bh : close[lo] < bl)
dirO := bull ? 1 : -1
zTop := bh
zBot := bl
imp := rngL / avg
bod := bdyL / rngL
vf := va[lo] > 0 ? math.min(math.max(nz(volume[lo]) / va[lo], 0.5), 3.0) : 1.0
st := time[sb + bc - 1]
[dirO, zTop, zBot, imp, bod, vf, st]
f_src() =>
float a = ta.atr(14)
float a2 = ta.atr(atrLen)
float va = ta.sma(nz(volume), 50)
float vfx = va[pivLen] > 0 ? math.min(math.max(nz(volume[pivLen]) / va[pivLen], 0.5), 3.0) : 1.0
float p1 = ta.pivothigh(high, pivLen, pivLen)
float p2 = ta.pivotlow(low, pivLen, pivLen)
int tp = time[pivLen]
[sdD, sdT, sdB, sdI, sdBo, sdV, sdS] = f_sdDetect()
[p1[1], p2[1], tp[1], a[1], a2[1], vfx[1], high[1], low[1], sdD[1], sdT[1], sdB[1], sdI[1], sdBo[1], sdV[1], sdS[1]]
[ph, pl, pivT, atrL, atrNL, vfL, hiL, loL, sdDir, sdTop, sdBot, sdImp, sdBod, sdVf, sdStartT] = request.security(syminfo.tickerid, effTf, f_src(), lookahead=barmerge.lookahead_on)
bool tfCh = timeframe.change(effTf)
bool newL = effTf == timeframe.period ? true : tfCh
float atr = atrL
float atrN = math.max(nz(atrNL, atr), syminfo.mintick)
float zoneH = heightMode == "ATR Based" ? atrN * heightATR : close * (heightPct / 100.0)
bool conf = barstate.isconfirmed
bool hasVol = ta.cum(nz(volume)) > 0
f_idxAt(int t) =>
int k = 0
while k < 4900 and bar_index - k > 0 and time[k] > t
k += 1
bar_index - k
var array<MZ> act = array.new<MZ>()
var array<MZ> res = array.new<MZ>()
f_step() =>
float s = roundStp
if s <= 0
s := math.pow(10, math.floor(math.log10(math.max(close, 1e-10))) - 2) * 2.5
s
f_heat(MZ z) =>
float age = (time - z.bornT) / (effSec * 1000.0)
z.w * math.pow(0.5, age / halfLife)
f_clamp(float v, float lo, float hi) =>
math.max(lo, math.min(hi, v))
f_prox(MZ z) =>
z.side == 1 ? z.top : z.bot
f_dist(MZ z) =>
z.side == 1 ? z.bot : z.top
f_hasRound(float top, float bot) =>
float st = f_step()
float r = math.round((top + bot) / 2 / st) * st
r >= bot and r <= top
f_setBounds(MZ z) =>
z.top := z.lvl + zoneH / 2
z.bot := z.lvl - zoneH / 2
f_stars(float sc) =>
sc >= 8 ? "★★★★" : sc >= 6.5 ? "★★★" : sc >= 5 ? "★★" : sc >= 3 ? "★" : "·"
f_tier(float sc) =>
sc >= 8 ? "ELITE" : sc >= 6.5 ? "STRONG" : sc >= 5 ? "MODERATE" : sc >= 3 ? "WEAK" : "FORMING"
f_score(MZ z, float mx) =>
float hp = mx > 0 ? math.sqrt(math.max(f_heat(z), 0) / mx) : 0.0
float pts = 4.0 * hp
pts += math.min(1.5, z.stacks * 0.5)
if z.sd
pts += f_clamp((z.imp - 1.0) * 1.5, 0.0, 2.0) + f_clamp((z.bod - 0.5) * 3.0, 0.0, 1.0)
pts += f_clamp((z.vf - 1.0), 0.0, 1.0)
pts += z.sd and z.stacks > 0 ? 1.5 : 0.0
pts += z.rnd ? 0.5 : 0.0
pts += z.state == 0 and z.tests == 0 ? 0.5 : 0.0
f_clamp(pts, 0.0, 10.0)
f_add(float lvl, int side, float wNew, int bornBar, int bornT, bool isSD, float imp, float bod, float vf) =>
float tol = math.max(mergeTol * atr, zoneH / 2)
int hit = -1
float best = tol
if act.size() > 0
for i = 0 to act.size() - 1
MZ z = act.get(i)
float d = math.abs(z.lvl - lvl)
if z.side == side and d <= best
best := d
hit := i
if hit >= 0
MZ z = act.get(hit)
float cur = f_heat(z)
float tw = cur + wNew
z.lvl := (z.lvl * cur + lvl * wNew) / tw
f_setBounds(z)
z.w := tw + (isSD ? 0.0 : wNew * 0.5)
z.born := math.min(z.born, bornBar)
z.bornT := math.max(z.bornT, bornT)
z.addB := bar_index
if isSD
z.sd := true
z.imp := math.max(z.imp, imp)
z.bod := math.max(z.bod, bod)
z.vf := math.max(z.vf, vf)
else
z.stacks += 1
z.vf := math.max(z.vf, vf)
z.rnd := useRound and f_hasRound(z.top, z.bot)
else
MZ nz1 = MZ.new(lvl, lvl + zoneH / 2, lvl - zoneH / 2, side, wNew, bornBar, bornT)
nz1.rnd := useRound and f_hasRound(nz1.top, nz1.bot)
if nz1.rnd
nz1.w := nz1.w * 1.3
if isSD
nz1.sd := true
nz1.imp := imp
nz1.bod := bod
nz1.vf := vf
else
nz1.stacks := 1
nz1.vf := vf
nz1.addB := bar_index
act.push(nz1)
hit
if conf and newL and not na(atr) and atr > 0 and zoneH > 0
if not na(pivT)
float vf = useVol and hasVol ? nz(vfL, 1.0) : 1.0
int bi = na(ph) and na(pl) ? na : f_idxAt(pivT)
if not na(ph)
f_add(ph, -1, vf, bi, pivT, false, 0.0, 0.0, vf)
if not na(pl)
f_add(pl, 1, vf, bi, pivT, false, 0.0, 0.0, vf)
if nz(sdDir) != 0 and not na(sdTop) and not na(sdBot) and not na(sdStartT)
float wSD = 1.0 + f_clamp((sdImp - 1.0) * 0.5, 0.0, 1.0)
f_add((sdTop + sdBot) / 2, sdDir, wSD, f_idxAt(sdStartT), sdStartT, true, sdImp, sdBod, useVol and hasVol ? sdVf : 1.0)
float maxH = 0.0
if act.size() > 0
for i = 0 to act.size() - 1
maxH := math.max(maxH, f_heat(act.get(i)))
var array<label> swLbls = array.new<label>()
var int nRev = 0
var int nRevOk = 0
bool sweepBull = false
bool sweepBear = false
bool workEv = false
bool testEv = false
float swBullHp = 0.0
float swBearHp = 0.0
float swBullP = na
float swBearP = na
float swBullSc = 0.0
float swBearSc = 0.0
string hotMsg = ""
f_zName(MZ z) =>
z.side == 1 ? "MAGNET ZONE BULLS" : "MAGNET ZONE BEARS"
f_zCol(MZ z) =>
z.side == 1 ? cBull : cBear
f_zSize() =>
lblSize == "Tiny" ? size.tiny : lblSize == "Normal" ? size.normal : lblSize == "Large" ? size.large : size.small
f_zText(MZ z, float hp) =>
float hpx = z.state == 0 ? hp : z.hpEnd
string t = f_stars(z.score) + " " + str.tostring(z.score, "0.0") + "/10 " + f_tier(z.score) + " · heat " + str.tostring(hpx, "0")
if z.stacks > 1
t += " · ×" + str.tostring(z.stacks)
if z.sd
t += " · S/D " + str.tostring(z.imp, "0.0") + "×"
if z.sd and z.stacks > 0
t += " · CONF"
if z.vf > 1.05
t += " · vol " + str.tostring(z.vf, "0.0") + "×"
if z.rnd
t += " · ◎"
t += z.state == 1 ? " · WORKED ✔" : z.state == 2 ? (z.revRes == 1 ? " · SWEPT → REVERSED ✔" : z.revRes == -1 ? " · SWEPT → CONTINUED ✘" : " · SWEPT") : z.tests == 0 ? " · FRESH" : " · R:" + str.tostring(z.tests)
t
f_zBrief(MZ z) =>
str.tostring(z.score, "0.0") + (z.state == 1 ? " · WORKED ✔" : z.revRes == 1 ? " · ⚡ REVERSED ✔" : z.revRes == -1 ? " · ⚡ CONTINUED ✘" : " · ⚡ SWEPT")
f_zDel(MZ z) =>
if not na(z.bx)
z.bx.delete()
if not na(z.pLn)
z.pLn.delete()
if not na(z.dLn)
z.dLn.delete()
if not na(z.tag)
z.tag.delete()
true
f_zFreeze(MZ z, color c, int alpha) =>
int xl = math.max(z.born, bar_index - resBars)
if na(z.bx)
z.bx := box.new(xl, z.top, bar_index, z.bot, border_color=color(na), bgcolor=color.new(c, alpha))
else
z.bx.set_lefttop(xl, z.top)
z.bx.set_rightbottom(bar_index, z.bot)
z.bx.set_bgcolor(color.new(c, alpha))
z.bx.set_border_color(color(na))
if not na(z.pLn)
z.pLn.delete()
z.pLn := na
if not na(z.dLn)
z.dLn.delete()
z.dLn := na
if lblRes and showLbl
if na(z.tag)
z.tag := label.new(bar_index, (z.top + z.bot) / 2, f_zBrief(z), style=label.style_label_right, color=color.new(c, 100), textcolor=color.new(cSwept, 20), size=size.tiny)
else
z.tag.set_x(bar_index)
z.tag.set_text(f_zBrief(z))
z.tag.set_textcolor(color.new(cSwept, 20))
z.tag.set_size(size.tiny)
else if not na(z.tag)
label old = z.tag
z.tag := na
old.delete()
true
if conf and act.size() > 0 and not na(atr)
for i = act.size() - 1 to 0
MZ z = act.get(i)
if zoneH > 0
f_setBounds(z)
if z.born < bar_index
float hp = maxH > 0 ? 100 * math.sqrt(f_heat(z) / maxH) : 0
bool swept = z.side == 1 ? low < z.bot - 0.05 * atr : high > z.top + 0.05 * atr
bool inZone = high >= z.bot and low <= z.top
bool touchH = newL and not na(hiL) and z.addB != bar_index and (z.side == 1 ? loL <= z.top : hiL >= z.bot)
bool worked = z.tests > 0 and (z.side == 1 ? high >= z.top + (z.top - z.bot) * workRR : low <= z.bot - (z.top - z.bot) * workRR)
if swept
z.state := 2
z.endBar := bar_index
z.hpEnd := hp
z.score := f_score(z, maxH)
if hp >= hotPct
hotMsg += (z.side == 1 ? "BULLS " : "BEARS ") + str.tostring(f_prox(z), format.mintick) + " (heat " + str.tostring(hp, "0") + ") "
if z.side == 1
sweepBull := true
if hp > swBullHp
swBullHp := hp
swBullP := z.top
swBullSc := z.score
else
sweepBear := true
if hp > swBearHp
swBearHp := hp
swBearP := z.bot
swBearSc := z.score
if showSwpL and hp >= hotPct
bool up = z.side == -1
label sl = label.new(bar_index, up ? high : low, "⚡", yloc=up ? yloc.abovebar : yloc.belowbar, style=label.style_none, textcolor=up ? cBear : cBull, size=size.normal, tooltip=f_zName(z) + " swept · " + str.tostring(f_prox(z), format.mintick) + " · heat " + str.tostring(hp, "0") + " · outcome pending")
swLbls.push(sl)
while swLbls.size() > 24
swLbls.shift().delete()
f_zFreeze(z, cSwept, 84)
act.remove(i)
res.push(z)
else if worked
z.state := 1
z.endBar := bar_index
z.hpEnd := hp
z.score := f_score(z, maxH)
workEv := true
f_zFreeze(z, cSwept, 80)
act.remove(i)
res.push(z)
else
if inZone and not z.inLast
z.tests += 1
testEv := true
if touchH
z.w := f_heat(z) + touchAdd
z.bornT := time
z.inLast := inZone
while act.size() > maxLv
int ci = 0
float ch = 1e30
for j = 0 to act.size() - 1
float h = f_heat(act.get(j))
if h < ch
ch := h
ci := j
MZ d = act.remove(ci)
f_zDel(d)
if conf and res.size() > 0 and not na(atr)
for i = 0 to res.size() - 1
MZ z = res.get(i)
if z.state == 2 and z.revRes == 0
bool ok = bar_index > z.endBar and (z.side == 1 ? close >= z.top + revAtr * atr : close <= z.bot - revAtr * atr)
bool out = bar_index - z.endBar >= revBars * tfMult
if ok or out
z.revRes := ok ? 1 : -1
nRev += 1
nRevOk += ok ? 1 : 0
if not na(z.tag)
z.tag.set_text(f_zBrief(z))
if swLbls.size() > 0
for k = swLbls.size() - 1 to 0
Показано первые 50% кода (символов: 29766)