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

Liquidity Master

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

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

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

О программе

«Liquidity Master» — индикатор для TradingView (Pine Script v6), отображаемый поверх цены на графике. Он анализирует «застрявшие» ордера: стопы за свечными максимумами и минимумами, а также ордера, проявившиеся в отброшенных хвостах свечей. Скрипт сохраняет эти пулы ликвидности, тратит их по мере прохождения цены, старит их со временем и визуализирует остатки в виде «лестницы глубины» рядом с ценой.

Лестница отображает bids ниже цены в одном цвете, offers выше — в другом. Чем длиннее столбец, тем больше ордеров в этой зоне. Наибольший пул с каждой стороны называется «стеной» и отслеживается: когда цена доходит до стены, скрипт фиксирует, отступила ли она (стена удержалась) или пробита (стена сломана).

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

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

НастройкаОписание
pivIn Количество баров с каждой стороны для подтверждения свечного максимума или минимума. Стопы размещаются чуть дальше подтверждённых свинг-хай/лоу.
wickIn Минимальная длина хвоста свечи в единицах ATR, при которой хвост распознаётся как отклонение и образует пул ликвидности. Чем больше значение, тем только более выраженные отклонения учитываются.
halfIn Количество баров, за которые половина пула ликвидности «стареет» и исчезает, так как ордера снимаются.
lookIn Количество последних баров, на которых работает движок расчёта. Влияет на производительность.
posIn Расположение лестницы глубины: «Over the last bars» — поверх последних свечей (как профиль объёма), «Right of price» — в свободном пространстве справа от цены.
widthIn Ширина лестницы глубины в барах (горизонтальный размер столбцов).
spanIn Количество баров, диапазон цен которых покрывает лестница глубины, плюс отступ.
rowsIn Количество строк (горизонтальных уровней) в лестнице глубины.
themeIn Цветовая схема лестницы: «Mint and Pink», «Ice» или «Custom» (с ручным выбором цветов bids и asks).
cBidIn Цвет столбцов bids (спроса) ниже цены при выборе темы «Custom».
cAskIn Цвет столбцов offers (предложений) выше цены при выборе темы «Custom».
bright Регулирует яркость отображения лестницы глубины. Влияет на прозрачность столбцов и интенсивность свечения.
showWalls Включает отображение пунктирных линий стен, простирающихся назад по графику, с мягким свечением.
showNames Включает отображение подписей стен (названия и цены) рядом с лестницей.
showPrice Отображает ценную метку рядом с текущей ценой. Видна только при расположении лестницы справа от цены.
showPanel Включает или скрывает информационную панель с данными о стенах и ликвидности.
panelPos Позиция информационной панели на графике: верхний левый, верхний правый, нижний левый или нижний правый угол.
panelSize Размер текста и общей панели: малый, нормальный или большой.

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

indicator("Liquidity Master", "Liquidity Master", overlay = true, max_boxes_count = 500, max_lines_count = 50, max_labels_count = 50, max_bars_back = 500)

grpE = "Liquidity"
pivIn  = input.int(4, "Swing strength (bars)", minval = 2, maxval = 20, group = grpE, tooltip = "Stops rest just past a swing high or swing low. A swing needs this many lower highs or higher lows on each side.")
wickIn = input.float(0.45, "Wick rejection (ATR)", minval = 0.2, maxval = 2, step = 0.05, group = grpE, tooltip = "A wick at least this long shows orders that absorbed a push. They stay on the ladder until price trades back through them.")
halfIn = input.int(300, "Liquidity ages out over (bars)", minval = 50, maxval = 3000, step = 10, group = grpE, tooltip = "Half of a pool is gone after this many bars, because orders get pulled.")
lookIn = input.int(1500, "Bars to compute", minval = 300, maxval = 4000, step = 100, group = grpE, tooltip = "The engine runs on the most recent bars only, to keep the chart fast.")

grpL = "Ladder"
posIn   = input.string("Over the last bars", "Ladder sits", options = ["Over the last bars", "Right of price"], group = grpL, tooltip = "Over the last bars draws the ladder across the most recent candles, like a volume profile. Right of price puts it in the empty space to the right, which needs room: drag the price scale to the left, or raise the right margin in the chart settings.")
widthIn = input.int(30, "Ladder width (bars)", minval = 10, maxval = 100, group = grpL)
spanIn  = input.int(300, "Ladder covers (bars)", minval = 50, maxval = 2000, step = 10, group = grpL, tooltip = "The ladder spans the price range of this many recent bars, plus a margin. Match it to how many bars you keep on screen.")
rowsIn  = input.int(80, "Rows", minval = 20, maxval = 100, group = grpL)
themeIn = input.string("Mint and Pink", "Colours", options = ["Mint and Pink", "Ice", "Custom"], group = grpL)
cBidIn  = input.color(#00FFA3, "", group = grpL, inline = "c")
cAskIn  = input.color(#FF3D71, "", group = grpL, inline = "c")
bright  = input.int(3, "Brightness", minval = 1, maxval = 5, group = grpL)
showWalls = input.bool(true, "Wall lines", group = grpL, inline = "w")
showNames = input.bool(true, "Wall names", group = grpL, inline = "w")
showPrice = input.bool(true, "Price tag", group = grpL, inline = "w", tooltip = "The price tag only shows when the ladder sits right of price, the axis already has it otherwise.")
showPanel = input.bool(true, "Panel", group = grpL, inline = "p")
panelPos  = input.string("Top right", "", options = ["Top left", "Top right", "Bottom left", "Bottom right"], group = grpL, inline = "p")
panelSize = input.string("Normal", "", options = ["Small", "Normal", "Large"], group = grpL, inline = "p")

[colBid, colAsk] = switch themeIn
    "Mint and Pink" => [#00FFA3, #FF3D71]
    "Ice"           => [#7DD3FC, #C4B5FD]
    => [cBidIn, cAskIn]
color colPanel = #262B38
color colEdge  = #2A2E39

int   maxEv     = 400     // pools kept at once
int   maxRows   = 100     // ladder rows available
float zoneATR   = 0.75    // stops sit within three quarters of an ATR past a swing
float pivW      = 1.6     // weight of the stops past a swing
float wickW     = 0.5     // weight of a rejection wick, times its relative volume
int   refreshEvery = 10   // bars between wall refreshes for the record
int   keepRec   = 10      // wall tests remembered
float brokeATR  = 0.5     // a close this far past a wall breaks it
float heldATR   = 0.5     // a close this far back from a wall means it held
int   testBars  = 60      // a test is dropped after this many bars without a verdict
int   lineBack  = 150     // how far the wall lines reach back
float wallAt    = 0.5     // a wall must hold at least this share of the biggest row to be tracked

float atr    = math.max(nz(ta.atr(14), high - low), syminfo.mintick)
float atrG   = math.max(nz(ta.atr(50), atr), syminfo.mintick)      // the slow one, for the ladder's geometry
float vAvg   = ta.sma(nz(volume, 0), 50)
bool  hasVol = not na(volume) and vAvg > 0
float vRel   = hasVol ? math.min(volume / vAvg, 4.0) : 1.0
float ph     = ta.pivothigh(high, pivIn, pivIn)
float pl     = ta.pivotlow(low, pivIn, pivIn)
float hhSince = ta.highest(high, pivIn)     // the bars after a swing high, by the time it confirms
float llSince = ta.lowest(low, pivIn)
bool  active = bar_index > last_bar_index - lookIn
int   nrow   = math.min(rowsIn, maxRows)
float hhSpan = ta.highest(high, spanIn)
float llSpan = ta.lowest(low, spanIn)
float margin = math.max(1.5 * atrG, 0.08 * (hhSpan - llSpan))
float step   = math.max(math.round(((hhSpan - llSpan + 2 * margin) / nrow) / syminfo.mintick) * syminfo.mintick, syminfo.mintick)
float base   = math.floor((llSpan - margin) / step) * step             // rows sit on a fixed grid, so they do not slide with every tick
float brightMul = 0.4 + 0.2 * bright

var evSide = array.new_int()       // 1 above price (offers and buy stops), -1 below (bids and sell stops)
var evP0   = array.new_float()
var evP1   = array.new_float()
var evW    = array.new_float()
var evBar  = array.new_int()
var evExt  = array.new_float()     // the furthest price has traded into the zone since it was created
var rowS   = array.new_float(maxRows, 0.0)
var recHeld = array.new_int()      // 1 the wall held, 0 it broke

bool reachedUp = false
bool reachedDn = false
bool wallHeld  = false
bool wallBroke = false

dropEv(int k) =>
    array.remove(evSide, k)
    array.remove(evP0, k)
    array.remove(evP1, k)
    array.remove(evW, k)
    array.remove(evBar, k)
    array.remove(evExt, k)
    k

addEv(int side, float p0, float p1, float w, int atBar, float ext) =>
    if array.size(evP0) >= maxEv
        dropEv(0)
    array.push(evSide, side)
    array.push(evP0, p0)
    array.push(evP1, p1)
    array.push(evW, w)
    array.push(evBar, atBar)
    array.push(evExt, ext)
    true

buildRows() =>

    for r = 0 to maxRows - 1
        array.set(rowS, r, 0.0)
    int n = array.size(evP0)
    if n > 0
        for k = 0 to n - 1
            int side = array.get(evSide, k)
            float a0 = side == 1 ? math.max(array.get(evP0, k), array.get(evExt, k)) : array.get(evP0, k)
            float a1 = side == 1 ? array.get(evP1, k) : math.min(array.get(evP1, k), array.get(evExt, k))
            if a1 > a0
                float w = array.get(evW, k) * math.pow(0.5, (bar_index - array.get(evBar, k)) / halfIn)
                int r0 = math.max(math.floor((a0 - base) / step), 0)
                int r1 = math.min(math.floor((a1 - base) / step), nrow - 1)
                if r1 >= r0
                    for r = r0 to r1
                        float lo = base + r * step
                        float ov = math.min(a1, lo + step) - math.max(a0, lo)
                        if ov > 0
                            array.set(rowS, r, array.get(rowS, r) + w * ov / (a1 - a0))
    float peak = 0.0
    if nrow >= 3
        float prev = array.get(rowS, 0)
        for r = 0 to nrow - 1
            float cur = array.get(rowS, r)
            float nxt = r < nrow - 1 ? array.get(rowS, r + 1) : cur
            float sm = 0.25 * prev + 0.5 * cur + 0.25 * nxt
            prev := cur
            array.set(rowS, r, sm)
            peak := math.max(peak, sm)
    peak

findWalls(float peak) =>

    float upP = na
    float upT = 0.0
    float dnP = na
    float dnT = 0.0
    float nearUp = na
    float nearDn = na
    float sumUp = 0.0
    float sumDn = 0.0
    if peak > 0
        for r = 0 to nrow - 1
            float mid = base + (r + 0.5) * step
            float t = array.get(rowS, r) / peak
            if mid >= close + 0.3 * atr
                sumUp += t
                if t > upT
                    upT := t
                    upP := mid
                if t >= 0.3 and na(nearUp)
                    nearUp := mid
            else if mid <= close - 0.3 * atr
                sumDn += t
                if t > dnT
                    dnT := t
                    dnP := mid
                if t >= 0.3
                    nearDn := mid
    [upP, upT, dnP, dnT, nearUp, nearDn, sumUp, sumDn]

pushRec(int v) =>
    array.push(recHeld, v)
    if array.size(recHeld) > keepRec
        array.shift(recHeld)
    v

var float wallUpV = na      // the walls as of the last refresh, for the record
var float wallDnV = na
var int   testSide = 0
var float testP = na
var int   testBar = 0

if active and barstate.isconfirmed

    int i = 0
    while i < array.size(evP0)
        int side = array.get(evSide, i)
        bool gone = bar_index - array.get(evBar, i) > 4 * halfIn
        if side == 1
            float ext = math.max(array.get(evExt, i), high)
            array.set(evExt, i, ext)
            gone := gone or ext >= array.get(evP1, i)
        else
            float ext = math.min(array.get(evExt, i), low)
            array.set(evExt, i, ext)
            gone := gone or ext <= array.get(evP0, i)
        if gone
            dropEv(i)
        else
            i += 1

    if not na(ph) and hhSince < ph + zoneATR * atr
        addEv(1, ph, ph + zoneATR * atr, pivW, bar_index - pivIn, math.max(hhSince, ph))
    if not na(pl) and llSince > pl - zoneATR * atr
        addEv(-1, pl - zoneATR * atr, pl, pivW, bar_index - pivIn, math.min(llSince, pl))
    float uw = high - math.max(open, close)
    float dw = math.min(open, close) - low
    if uw >= wickIn * atr
        addEv(1, math.max(open, close), high, wickW * vRel, bar_index, math.max(open, close))
    if dw >= wickIn * atr
        addEv(-1, low, math.min(open, close), wickW * vRel, bar_index, math.min(open, close))

    if bar_index % refreshEvery == 0 and array.size(evP0) >= 15
        float pk = buildRows()
        [u, tu, d, td, nu, nd, su, sd] = findWalls(pk)
        wallUpV := tu >= wallAt ? u : na
        wallDnV := td >= wallAt ? d : na

    if testSide == 0
        if not na(wallUpV) and high >= wallUpV - step / 2
            testSide := 1
            testP := wallUpV
            testBar := bar_index
            wallUpV := na
            reachedUp := true
        else if not na(wallDnV) and low <= wallDnV + step / 2
            testSide := -1
            testP := wallDnV
            testBar := bar_index
            wallDnV := na
            reachedDn := true
    else
        bool broke = testSide == 1 ? close > testP + brokeATR * atr : close < testP - brokeATR * atr
        bool held  = testSide == 1 ? close <= testP - heldAT

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