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

Eye Liquidity Heatmap

indicator eye liquidity heatmap for tradingview.pine
Вы автор или правообладатель?

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

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

О программе

«Eye Liquidity Heatmap» — индикатор для TradingView (Pine Script v6), отображающий карту ликвидности на графике цены. Он строит уровни стоп-ордеров на основе свинговых максимумов и минимумов заданного таймфрейма и визуализирует их в виде тепловых полос разной интенсивности.

Индикатор рассчитывает «тепло» каждого уровня с учётом объёма на момент свинга и близости к круглым числам, постепенно затухая по экспоненте. При пробое уровня ценой он помечает его как прочерпанный, а при достижении горячих зон ценой запускает тест на разворот.

Визуализация включает тепловые полосы, профиль тепла справа от графика, магниты (самые горячие уровни выше и ниже цены), подсветку свечей в горячих зонах и информационную панель со статистикой. Доступны условия оповещений для прочерпанных горячих уровней, достижения магнитов и приближения цены к ним.

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

НастройкаОписание
lockTf Таймфрейм, на котором строятся уровни ликвидности, тепла, отметок о прочерпывании и магниты. Все графики на или ниже этого таймфрейма отображают одну карту; пустое значение — текущий таймфрейм графика.
pivLen Количество баров по каждой стороне от свинга, необходимое для определения свингового максимума или минимума. Стоп-уровни располагаются вблизи этих свингов.
mergeTol Допуск для объединения близких свинговых уровней в один, выраженный в кратности ATR. Свинги ближе этого расстояния объединяются, а тепло суммируется с бонусом.
useVol Учитывает объём на момент свинга при определении начального тепла уровня. Чем выше объём, тем больше начальная теплота.
useRound Включает бонусное увеличение начального тепла для уровней, расположенных рядом с круглыми ценовыми значениями.
roundStp Шаг для определения круглых ценовых уровней. Значение 0 означает автоматический выбор на основе размера цены (например, около 25 на золоте, 2500 на BTC).
touchAdd Количество тепла, добавляемое к существующему уровню при касании его ценой без пробоя.
halfLife Количество баров (на таймфрейме построения уровней), через которое уровень теряет половину текущего тепла при отсутствии новых свингов или касаний.
maxLv Максимальное количество одновременно активных уровней ликвидности. При превышении удаляется самый холодный уровень.
maxDist Максимальное расстояние от текущей цены (в кратности ATR), в пределах которого отображаются уровни. Более удалённые уровни скрываются для чистоты масштаба графика.
minShow Минимальный порог тепла в процентах. Уровни с теплом ниже этого значения не отображаются на графике.
showBands Включает или отключает отображение тепловых полос для активных уровней ликвидности.
bandW Толщина тепловой полосы при максимальной теплоте, выраженная в кратности ATR. Более горячие уровни отрисовываются толще, холодные — тоньше.
showText Отображает текстовые подписи на тепловых полосах с теплом 70 и выше, указывая сторону ликвидности, теплоту и количество свингов.
showSwept Включает отображение прочерпанных (охлаждённых) уровней в виде полупрозрачных серых полос.
keepSwept Максимальное количество прочерпанных (охлаждённых) уровней, которые хранятся и отображаются на графике.
showProf Включает отображение теплового профиля (гистограммы распределения тепла) справа от графика.
profBins Количество строк (корзин) в тепловом профиле, отображаемом справа от графика. Определяет гранулярность распределения тепла по ценовым уровням.
profWidth Ширина теплового профиля (гистограммы) справа от графика, измеряемая в барах.
extRight На сколько баров вправо от последнего бара графика продлеваются тепловые полосы.
showMag Отображает магниты — самые горячие уровни ликвидности выше и ниже текущей цены, с линиями и подписями.
showSwpL Отображает графические метки (иконки) на барах, где уровни ликвидности были прочерпаны ценой.
hotCandle Включает цветовое выделение свечей, находящихся внутри горячих зон (областей с высокой теплотой).
hotPct Порог тепла в процентах, при котором зона считается горячей и используется для маркировки и тестов разворота.
revBars Количество баров, в течение которых после прочерпывания уровня проверяется его разворот. По истечении срока тест снимается.
revAtr Расстояние (в кратности ATR), на которое цена должна закрыться за уровнем для подтверждения разворота после его прочерпывания.
magBars Количество баров, в течение которых проверяется, достиг ли цена магнита (самого горячего уровня выше или ниже).
dashStyle Стиль информационной панели: рядом с последней свечой на графике, в виде отдельной фиксированной панели в углу экрана или выключена.
hudGap Расстояние в барах между последней свечой и информационной панелью (HUD), отображаемой рядом с ценой.
tblPos Позиция информационной панели на экране при выбранном стиле фиксированной панели: верхний правый, средний правый, нижний правый, верхний левый или нижний левый угол.
tblSize Размер текста в информационной панели: мелкий, маленький или нормальный.
cSwept Цвет тепловых полос для прочерпанных (охлаждённых) уровней, которые уже были пробиты ценой.
cBuy Цвет тепловых полос для уровней ликвидности со стороны продаж (ниже текущей цены). Светлые оттенки означают холод, насыщенные — жар.
cSell Цвет тепловых полос для уровней ликвидности со стороны покупок (выше текущей цены). Светлые оттенки означают холод, насыщенные — жар.

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

indicator("Eye Liquidity Heatmap", "Eye Liquidity Heatmap", overlay=true, max_boxes_count=500, max_lines_count=100, max_labels_count=200, max_bars_back=5000)

grpS = "Liquidity sources"
lockTf   = input.timeframe("30", "Build levels on timeframe", group=grpS, tooltip="Levels, heat, sweeps and magnets are built from this timeframe, so every chart at or below it (1m, 5m, 15m, 30m) shows the same map. 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=grpS, tooltip="A swing high/low needs this many bars on each side. Stops sit just beyond these swings.")
mergeTol = input.float(0.30, "Equal highs/lows tolerance (× ATR)", minval=0.05, step=0.05, group=grpS, tooltip="Swings closer than this join into one level and its heat stacks up (equal highs / equal lows = more stops).")
useVol   = input.bool(true, "Weight by volume at the swing", group=grpS)
useRound = input.bool(true, "Boost levels near round numbers", group=grpS)
roundStp = input.float(0.0, "Round number step (0 = auto)", minval=0.0, group=grpS, tooltip="Auto picks a step from the price size: about 25 on gold, 250 on Nifty, 2500 on BTC, 0.025 on EURUSD.")
touchAdd = input.float(0.3, "Heat added per touch without break", minval=0.0, step=0.1, group=grpS)

grpH = "Heat"
halfLife = input.int(150, "Heat half-life (bars of the build timeframe)", minval=10, maxval=2000, group=grpH, tooltip="A pool loses half of its heat after this many bars of the build timeframe without a new stacked swing or touch.")
maxLv    = input.int(120, "Max active levels", minval=10, maxval=200, group=grpH)
maxDist  = input.float(16.0, "Show levels within (× ATR of price)", minval=2.0, step=0.5, group=grpH, tooltip="Far-away levels are hidden so the chart scale stays clean.")
minShow  = input.int(15, "Hide levels below heat", minval=0, maxval=100, group=grpH)

grpV = "Visuals"
showBands = input.bool(true, "Heat bands", group=grpV)
bandW     = input.float(0.6, "Band thickness at full heat (× ATR)", minval=0.1, step=0.1, group=grpV, tooltip="Hotter levels are drawn thicker. Cold levels are about one quarter of this. Heat 70+ bands get a thin outline.")
showText  = input.bool(true, "Name the hot bands (heat ≥ 70)", group=grpV)
showSwept = input.bool(true, "Show swept (cooled) levels", group=grpV)
keepSwept = input.int(30, "Swept levels kept", minval=0, maxval=100, 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 bands right (bars)", minval=0, maxval=50, group=grpV)
showMag   = input.bool(true, "Magnets (hottest level above / below)", group=grpV)
showSwpL  = input.bool(true, "Sweep marks", group=grpV)
hotCandle = input.bool(true, "Color candles inside hot zones", group=grpV)
showPath  = input.bool(true, "Path arrow to the stronger magnet", group=grpV)

grpT = "Stats"
hotPct  = input.int(60, "Hot zone = heat ≥", minval=10, maxval=100, group=grpT)
revBars = input.int(10, "Sweep → reversal window (bars)", minval=2, maxval=100, group=grpT)
revAtr  = input.float(0.5, "Reversal = close back beyond level by (× ATR)", minval=0.1, step=0.1, group=grpT)
magBars = input.int(50, "Magnet reached within (bars)", minval=5, maxval=500, group=grpT)

grpD = "Dashboard"
dashStyle = input.string("Beside last candle", "Dashboard style", options=["Beside last candle", "Panel (always visible)", "Off"], group=grpD, tooltip="Beside last candle: the dashboard is drawn on the chart right next to the latest candle, with the heat profile and magnet labels after it. Panel: a table fixed to a corner of the screen.")
hudGap  = input.int(6, "Dashboard distance from last candle (bars)", minval=2, maxval=60, group=grpD)
bool showTbl = dashStyle == "Panel (always visible)"
bool showHud = dashStyle == "Beside last candle"
tblPos  = input.string("Top Right", "Panel position", options=["Top Right", "Middle Right", "Bottom Right", "Top Left", "Bottom Left"], group=grpD)
tblSize = input.string("Small", "Text size", options=["Tiny", "Small", "Normal"], group=grpD)

grpK = "Colors"
cSwept = input.color(#B2B5BE, "Swept (cooled) level", group=grpK)
cBuy  = input.color(#089981, "Sell-side liquidity (below price)", group=grpK, tooltip="Heat is shown as strength of the colour: light = cold, strong = hot.")
cSell = input.color(#F23645, "Buy-side liquidity (above price)", group=grpK)

type Liq
    float price
    int   side
    float w
    int   born
    int   bornT
    float half
    bool  rnd = false
    int   sweptBar = na
    box   bx = na
    int   stacks = 1
    int   addB = na

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_src() =>
    float a   = ta.atr(14)
    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]
    [p1[1], p2[1], tp[1], a[1], vfx[1], high[1], low[1]]
[ph, pl, pivT, atrL, vfL, hiL, loL] = 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
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<Liq> act = array.new<Liq>()
var array<Liq> swp = array.new<Liq>()

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(Liq l) =>
    float age = (time - l.bornT) / (effSec * 1000.0)
    l.w * math.pow(0.5, age / halfLife)

f_addLevel(float p, int side, int bornBar, int bornT, float wNew) =>
    float tol = mergeTol * atr
    int hit = -1
    float best = tol
    if act.size() > 0
        for i = 0 to act.size() - 1
            Liq l = act.get(i)
            float d = math.abs(l.price - p)
            if l.side == side and d <= best
                best := d
                hit := i
    if hit >= 0
        Liq l = act.get(hit)

        float cur = f_heat(l)
        float tw = cur + wNew
        l.price := (l.price * cur + p * wNew) / tw
        l.w := tw + wNew * 0.5
        l.stacks += 1
        l.born := math.max(l.born, bornBar)
        l.bornT := math.max(l.bornT, bornT)
        l.addB := bar_index
    else
        float st = f_step()
        bool r = useRound and math.abs(p - math.round(p / st) * st) <= mergeTol * atr
        Liq nl = Liq.new(p, side, wNew * (r ? 1.3 : 1.0), bornBar, bornT, bandW * atr / 2, r)
        nl.addB := bar_index
        act.push(nl)
    hit

if conf and newL and not na(atr) and 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_addLevel(ph, 1, bi, pivT, vf)
    if not na(pl)
        f_addLevel(pl, -1, bi, pivT, vf)

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<float> rvP = array.new<float>()
var array<int>   rvS = array.new<int>()
var array<int>   rvB = array.new<int>()
var array<int>   hRes = array.new<int>()
var array<int>   hSide = array.new<int>()
var int nRev = 0
var int nRevOk = 0
var array<label> swLbls = array.new<label>()
bool hotSweepUp = false
bool hotSweepDn = false
string hotMsg = ""

if conf and act.size() > 0 and not na(atr)
    for i = act.size() - 1 to 0
        Liq l = act.get(i)
        if l.born < bar_index
            bool broke = l.side == 1 ? high > l.price + 0.05 * atr : low < l.price - 0.05 * atr
            bool touch = newL and not na(hiL) and l.addB != bar_index and (l.side == 1 ? hiL >= l.price - l.half : loL <= l.price + l.half)
            if broke
                float hp = maxH > 0 ? 100 * math.sqrt(f_heat(l) / maxH) : 0
                l.sweptBar := bar_index
                if not na(l.bx)
                    l.bx.set_right(bar_index)
                    l.bx.set_top(l.price + l.half)
                    l.bx.set_bottom(l.price - l.half)
                    l.bx.set_bgcolor(color.new(cSwept, 60))
                    l.bx.set_border_color(color(na))
                    l.bx.set_text("")
                act.remove(i)
                swp.push(l)
                if hp >= hotPct
                    hotMsg += (l.side == 1 ? "BUY-SIDE " : "SELL-SIDE ") + str.tostring(l.price, format.mintick) + " (heat " + str.tostring(hp, "0") + ")  "

                    if rvB.size() == 0 or rvB.last() != bar_index or rvS.last() != l.side
                        rvP.push(l.price)
                        rvS.push(l.side)
                        rvB.push(bar_index)
                    if l.side == 1
                        hotSweepUp := true
                    else
                        hotSweepDn := true
                    if showSwpL
                        bool up = l.side == 1
                        swLbls.push(label.new(bar_index, up ? high : low, "⚡", yloc=up ? yloc.abovebar : yloc.belowbar, style=label.style_none, textcolor=up ? cSell : cBuy, size=size.normal, tooltip=(up ? "Buy-side liquidity swept" : "Sell-side liquidity swept") + " · " + str.tostring(l.price, format.mintick) + " · heat " + str.tostring(hp, "0")))
                        while swLbls.size() > 30
                            swLbls.shift().delete()
            else if touch
                l.w := f_heat(l) + touchAdd
                l.bornT := time

    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
        Liq d = act.remove(ci)
        if not na(d.bx)
            d.bx.delete()
    while swp.size() > keepSwept
        Liq d = swp.shift()
        if not na(d.bx)
            d.bx.delete()

if conf and rvP.size() > 0
    for i = rvP.size() - 1 to 0
        float p = rvP.get(i)
        int s = rvS.get(i)
        bool ok = bar_index > rvB.get(i) and (s == 1 ? close <= p - revAtr * atr : close >= p + revAtr * atr)
        bool out = bar_index - rvB.get(i) >= revBars * tfMult
        if ok or out
            nRev += 1
            nRevOk += ok ? 1 : 0
            hRes.push(ok ? 1 : 0)
            hSide.push(s)
            if hRes.size() > 12
                hRes.shift()
                hSide.shift()
            rvP.remove(i)
            rvS.remove(i)
            rvB.remove(i)
var table wm = table.new(position.bottom_right, 1, 1)
if barstate.isfirst
    table.cell(wm, 0, 0, "Telegram @SimpleForexTools", text_color = color.new(color.gray, 70), text_size = size.large)

float maxH2 = 0.0
if act.size() > 0
    for i = 0 to act.size() - 1
        maxH2 := math.max(maxH2, f_heat(act.get(i)))
float hAbove = 0.0
float hBelow = 0.0
int iUp = -1
int iDn = -1
float bUp = 0.0
float bDn = 0.0
int iUpA = -1
int iDnA = -1
float bUpA = 0.0
float bDnA = 0.0
float lim = maxDist * nz(atr)
float inHotP = 0.0
int   inHotS = 0
float nearP = na
float nearH = 0.0
float nearD = 1e30
int nAboveAll = 0
int nBelowAll = 0
if act.size() > 0
    for i = 0 to act.size() - 1
        Liq l = act.get(i)
        float h = f_heat(l)
        float hp = maxH2 > 0 ? 100 * math.sqrt(h / maxH2) : 0
        float dd = math.abs(l.price - close)
        if hp >= hotPct and not na(atr)
            if dd <= bandW * atr * (0.25 + 0.75 * hp / 100) / 2 and hp > inHotP
                inHotP := hp
                inHotS := l.side
            if dd < nearD
                nearD := dd
                nearP := l.price
                nearH := hp
        if l.price > close
            nAboveAll += 1
            if h > bUpA
                bUpA := h
                iUpA := i
        else
            nBelowAll += 1
            if h > bDnA
                bDnA := h
                iDnA := i
        if math.abs(l.price - close) <= lim
            if l.price > close
                hAbove += h
                if h > bUp
                    bUp := h
                    iUp := i
            else
                hBelow += h
                if h > bDn
                    bDn := h
                    iDn := i

bool  magUpFar = iUp < 0 and iUpA >= 0
bool  magDnFar = iDn < 0 and iDnA >= 0
float magUp = iUp >= 0 ? act.get(iUp).price : magUpFar ? act.get(iUpA).price : na
float magDn = iDn >= 0 ? act.get(iDn).price : magDnFar ? act.get(iDnA).price : na
float pUp = maxH2 > 0 ? 100 * math.sqrt((magUpFar ? bUpA : bUp) / maxH2) : 0
float pDn = maxH2 > 0 ? 100 * math.sqrt((magDnFar ? bDnA : bDn) / maxH2) : 0

float yUp = magUpFar ? math.min(magUp, close + lim) : magUp
float yDn = magDnFar ? math.max(magDn, close - lim) : magDn

float hudH = math.max(3.0, 0.4 * maxDist) * nz(atr)
bool magInHud = showMag and not na(atr) and ((not na(yUp) and math.abs(yUp - close) <= 1.2 * hudH) or (not na(yDn) and math.abs(yDn - close) <= 1.2 * hudH))
int  hudX0 = bar_index + hudGap + (magInHud ? 22 : 0)

bool  paintHot = hotCandle and inHotP > 0
color hotC = color.new(inHotS == 1 ? cSell : cBuy, math.round(55 - inHotP * 0.4))
plotcandle(paintHot ? open : na, paintHot ? high : na, paintHot ? low : na, paintHot ? close : na, "Hot-zone candles", color=hotC, wickcolor=hotC, bordercolor=hotC, editable=true)

var float mtUpP = na
var int   mtUpB = na
var float mtDnP = na
var int   mtDnB = na
var int nMag = 0
var int nMagOk = 0
bool magHitUp = false
bool magHitDn = false
if conf
    if not na(mtUpP)
        if high >= mtUpP
            nMag += 1
            nMagOk += 1
            magHitUp := true
            mtUpP := na
        else if bar_index - mtUpB >= magBars * tfMult
            nMag += 1
            mtUpP := na
    if not na(mtDnP)
        if low <= mtDnP
            nMag += 1
            nMagOk += 1
            magHitDn := true
            mtDnP := na
        else if bar_index - mtDnB >= magBars * tfMult
            nMag += 1
            mtDnP := na
    if na(mtUpP) and not na(magUp) and not magUpFar and pUp >= hotPct and magUp - close >= atr
        mtUpP := magUp
        mtUpB := bar_index
    if na(mtDnP) and not na(magDn) and not magDnFar and pDn >= hotPct and close - magDn >= atr
        mtDnP := magDn
        mtDnB := bar_index

f_sideC(int side) =>
    side == 1 ? cSell : cBuy
f_base(float p, int side) =>
    color.new(f_sideC(side), math.round(80 - p * 0.6))

f_col(float p, int side) =>
    color.new(f_sideC(side), math.round(90 - p *

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