Исходный код · ID 4727

Диапазон Профиля Объёмов

$volume profile range$.pine

Вы автор или правообладатель?

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

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

О программе

Индикатор «Диапазон Профиля Объёмов» предназначен для анализа распределения объёма торгов на графике в платформе TradingView. Он отображает профиль объёма — горизонтальные уровни, соответствующие объёму торгов на каждой ценовой отметке за заданный период, с настраиваемым количеством строк и длиной анализируемого диапазона.

Индикатор выделяет ключевые уровни профиля: точку контроля (POC), верхнюю и нижнюю границы области значения (VAH и VAL). Также распознаются пиковые и впадинные узлы объёма, позволяющие визуально выделить зоны повышенной и пониженной активности. Пики и впадины можно отображать как отдельные отметки или кластеры.

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

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

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

Настройка	Описание
vn_peaksShow	Режим отображения пиковых узлов объёма: Пики, Кластеры или Нет.
vn_peakVolumeColor	Цвет заливки пиковых узлов объёма.
vn_peaksNumberOfNodes	Процент соседних узлов, используемый для определения пиковых узлов объёма.
vn_troughsShow	Режим отображения впадинных узлов объёма: Впадины, Кластеры или Нет.
vn_troughVolumeColor	Цвет заливки впадинных узлов объёма.
vn_troughsNumberOfNodes	Процент соседних узлов, используемый для определения впадинных узлов объёма.
vn_VolumeNodeThreshold	Минимальная доля объёма от максимального, необходимая для распознавания пиковых и впадинных узлов.
vn_highestNVolumeNodes	Количество наибольших узлов объёма, которые будут выделены на графике.
vn_highestVolumeColor	Цвет заливки наибольших узлов объёма.
vn_lowestNVolumeNodes	Количество наименьших узлов объёма, которые будут выделены на графике.
vn_lowestVolumeColor	Цвет заливки наименьших узлов объёма.
vp_profileShow	Включает или отключает отображение профиля объёма на графике.
vp_profileGradientColors	Режим окраски профиля: Градиентные цвета или Классические цвета.
vp_valueAreaUpColor	Цвет заливки области значения выше средней цены.
vp_valueAreaDwonColor	Цвет заливки области значения ниже средней цены.
vp_profileUpVolumeColor	Цвет профиля объёма для покупательских баров.
vp_profileDownVolumeColor	Цвет профиля объёма для продавательских баров.
vp_pocShow	Режим отображения точки контроля: Развивающаяся, Обычная или Нет.
vp_pocColor	Цвет линии точки контроля (POC).
vp_pocWidth	Толщина линии точки контроля (POC).
vp_vahShow	Включает или отключает отображение верхней границы области значения (VAH).
vp_vahColor	Цвет линии верхней границы области значения (VAH).
vp_valShow	Включает или отключает отображение нижней границы области значения (VAL).
vp_valColor	Цвет линии нижней границы области значения (VAL).
vp_profileLevels	Размер текстовых меток ценовых уровней профиля: Крошечный, Маленький, Нормальный или Нет.
vp_profileLength	Количество баров, используемых для расчёта профиля объёма.
vp_valueAreaThreshold	Процент от общего объёма, определяющий границы области значения.
vp_profilePlracment	Положение профиля на графике: Справа или Слева.
vp_profileNumberOfRows	Количество горизонтальных строк (уровней) в профиле объёма.
vp_profileWidth	Ширина отображения профиля объёма в процентах от ширины графика.
vp_profileHorizontalOffset	Горизонтальное смещение профиля в барах от правого или левого края.
vp_valueAreaBackground	Включает или отключает заливку фона области значения (между VAH и VAL).
vp_valueAreaBackgroundColor	Цвет заливки фона области значения.
vp_profileBackground	Включает или отключает заливку фона всего диапазона профиля.
vp_profileBackgroundColor	Цвет заливки фона диапазона профиля.
i_amp	Амплитуда (ширина) колонок гистограммы объёма в процентах от доступного пространства.
i_rows	Количество строк (уровней) сетки гистограммы объёма.
i_delta_on	Включает расчёт и отображение дельты объёмов — разделение на покупательский и продавательский объём.
i_quote_on	Пересчёт объёма в котируемые единицы вместо стандартного объёма сделок.
i_log_on	Пересчёт сетки гистограммы на логарифмическую шкалу.
i_htf_on	Включает или отключает отображение данных с более высокого таймфрейма и HTF-баров.
i_htf	Выбор таймфрейма для отображения данных высокого таймфрейма на графике (Auto, 5m, 15m, 1h, 1D и др.).
i_htf_iso	Изолированное вычисление профиля в периоде высокого таймфрейма.
i_fill	Цвет заливки гистограммы общего объёма (при отключённой дельте).
i_fill_vp	Цвет заливки гистограммы покупательского объёма (при включённой дельте).
i_fill_vn	Цвет заливки гистограммы продавательского объёма (при включённой дельте).
i_other_c	Цвет отображения баров высокого таймфрейма и вспомогательных графических элементов.
i_wrng_c	Цвет значка и текста предупреждений, отображаемых на графике.
i_lng	Язык отображения информационных сообщений и предупреждений на графике (English, Русский).
i_chn_c	Цвет линий скользящих средних с периодами центрированных гексагональных чисел (CHN-RMA).

Получить полный код

indicator(title = '<[$/Диапазон Профиля Объёмов/$]>', shorttitle = '<{Диапазон Профиля Объёмов}>',  overlay = true, max_polylines_count = 100, max_lines_count = 300, max_boxes_count = 500, max_bars_back = 5000)

display = display.all - display.status_line

vn_volumeNodesGroup = 'Узлы объёма'
vn_peakTTip = 'Пиковый узел объёма распознаётся, когда узлы профиля объёма для N предыдущих и N последующих узлов ниже, чем у оцениваемого узла, где N определяется параметром \'Процент обнаружения узлов %\''
vn_peaksShow = input.string('Пики', 'Пики объёма', options = ['Пики', 'Кластеры', 'Нет'], inline = 'vnP', tooltip = vn_peakTTip, group = vn_volumeNodesGroup, display = display)
vn_peakVolumeColor = input.color(#f3212180, '', inline = 'vnP', group = vn_volumeNodesGroup)
vn_peaksNumberOfNodes = input.int(9, '  Процент обнаружения узлов %', minval = 0, maxval = 100, group = vn_volumeNodesGroup, display = display) / 100
vn_peaksShow := vn_peaksNumberOfNodes == 0 ? 'None' : vn_peaksShow

vn_troughsTTip = 'Узел впадины объёма распознаётся, когда узлы профиля объёма для N предыдущих и N последующих узлов превышают оцениваемый узел, где N определяется параметром \'Процент обнаружения узлов %\''
vn_troughsShow = input.string('Нет', 'Впадины объёма', options = ['Впадины', 'Кластеры', 'Нет'], inline = 'vnT', tooltip = vn_troughsTTip, group = vn_volumeNodesGroup, display = display)
vn_troughVolumeColor = input.color(color.new(color.gray, 50), '', inline = 'vnT', group = vn_volumeNodesGroup)
vn_troughsNumberOfNodes = input.int(7, '  Процент обнаружения узлов %', minval = 0, maxval = 100, group = vn_volumeNodesGroup, display = display) / 100
vn_troughsShow := vn_troughsNumberOfNodes == 0 ? 'None' : vn_troughsShow

vn_thresholdTTip = 'Указанное в процентах пороговое значение используется для обнаружения пиковых/впадинных узлов объёма. Если значение установлено, обнаружение будет игнорировать значения узлов объёма ниже указанного порога.'
vn_VolumeNodeThreshold = input.int(1, 'Порог узла объёма %', minval = 0, maxval = 100, tooltip = vn_thresholdTTip, group = vn_volumeNodesGroup, display = display) / 100

vn_highestNVolumeNodes = input.int(0, 'Наибольшие узлы объёма', minval = 0, maxval = 31, inline = 'vnL', group = vn_volumeNodesGroup, display = display)
vn_highestVolumeColor = input.color(color.new(color.orange, 25), '', inline = 'vnL', group = vn_volumeNodesGroup)

vn_lowestNVolumeNodes = input.int(0, 'Наименьшие узлы объёма', minval = 0, maxval = 31, inline = 'vnH', group = vn_volumeNodesGroup, display = display)
vn_lowestVolumeColor = input.color(color.new(color.navy, 25), '', inline = 'vnH', group = vn_volumeNodesGroup)

vp_componentsGroup = 'Профиль объёма - Компоненты'

vp_profileShow = input.bool(true, 'Профиль объёма', inline = 'vp', group = vp_componentsGroup)
vp_profileGradientColors = input.string('Градиентные цвета', '', options = ['Градиентные цвета', 'Классические цвета'], inline = 'vp', group = vp_componentsGroup)
vp_valueAreaUpColor = input.color(color.new(#2962ff, 30), '  Область значения Вверх / Вниз', inline = 'VA', group = vp_componentsGroup)
vp_valueAreaDwonColor = input.color(color.new(#fbc02d, 30), '/', inline = 'VA', group = vp_componentsGroup)
vp_profileUpVolumeColor = input.color(color.new(#5d606b, 50), '  Профиль Вверх / Вниз объёма', inline = 'VP', group = vp_componentsGroup)
vp_profileDownVolumeColor = input.color(color.new(#d1d4dc, 50), '/', inline = 'VP', group = vp_componentsGroup)

vp_pocShow = input.string('Нет', 'Точка контроля (POC)', options = ['Развивающаяся', 'Обычная', 'Нет'], inline = 'poc', group = vp_componentsGroup, display = display)
vp_pocColor = input.color(#fbc02d, '', inline = 'poc', group = vp_componentsGroup)
vp_pocWidth = input.int(2, 'Ширина', inline = 'poc', group = vp_componentsGroup, display = display)

vp_vahShow = input.bool(true, 'Высшая точка области значения (VAH)', inline = 'vah', group = vp_componentsGroup)
vp_vahColor = input.color(#2962ff, '', inline = 'vah', group = vp_componentsGroup)

vp_valShow = input.bool(true, 'Низшая точка области значения (VAL)', inline = 'val', group = vp_componentsGroup)
vp_valColor = input.color(#2962ff, '', inline = 'val', group = vp_componentsGroup)

vp_profileLevels = input.string('Маленький', 'Метки цен профиля', options = ['Крошечный', 'Маленький', 'Нормальный', 'Нет'], group = vp_componentsGroup, display = display)

vp_displayGroup = 'Профиль объёма - Настройки отображения'

vp_profileLength = input.int(120, 'Длина профиля', minval = 10, maxval = 5000, step = 10, group = vp_displayGroup, display = display)
vp_profileLength := last_bar_index < vp_profileLength ? last_bar_index : vp_profileLength - 1

vp_valueAreaThreshold = input.float(68, 'Значение области (%)', minval = 0, maxval = 100, group = vp_displayGroup, display = display) / 100

vp_profilePlracment = input.string('Справа', 'Размещение профиля', options = ['Справа', 'Слева'], group = vp_displayGroup, display = display)
profilePlacementRight = vp_profilePlracment == 'Справа'
vp_profileNumberOfRows = input.int(100, 'Количество строк профиля', minval = 30, maxval = 130, step = 10, group = vp_displayGroup, display = display)
vp_profileWidth = input.float(25, 'Ширина профиля', minval = 0, maxval = 250, group = vp_displayGroup, display = display) / 100
vp_profileHorizontalOffset = input.int(2, 'Горизонтальное смещение профиля', maxval = 50, group = vp_displayGroup, display = display)

vp_valueAreaBackground = input.bool(false, 'Фон области значения  ', inline = 'vBG', group = vp_displayGroup)
vp_valueAreaBackgroundColor = input.color(color.new(#2962ff, 89), '', inline = 'vBG', group = vp_displayGroup)

vp_profileBackground = input.bool(false, 'Фон диапазона профиля ', inline = 'pBG', group = vp_displayGroup)
vp_profileBackgroundColor = input.color(color.new(#2962ff, 95), '', inline = 'pBG', group = vp_displayGroup)

type BAR
	float open = open
	float high = high
	float low = low
	float close = close
	float volume = volume
	int index = bar_index

type barData
	array<float> barHigh
	array<float> barLow
	array<float> barVolume
	array<bool> barPolarity
	array<int> barCount

type volumeData
	array<float> totalVolume
	array<float> bullishVolume
	array<float> bearishVolume
	array<int> endProfileIndex
	array<bool> peakVolume
	array<bool> troughVolume

type volumeProfile
	array<box> boxes
	array<chart.point> pocPoints
	polyline pocPolyline
	int pocLevel
	int vahLevel
	int valLevel
	int startIndex

BAR bar = BAR.new()
array<BAR> ltfBarData = array.new<BAR>(1, BAR.new())

var barData barDataArray = barData.new(array.new<float>(na), array.new<float>(na), array.new<float>(na), array.new<bool>(na), array.new<int>(na))

volumeData volumeDataArray = volumeData.new(array.new<float>(vp_profileNumberOfRows, 0.), array.new<float>(vp_profileNumberOfRows, 0.), array.new<float>(vp_profileNumberOfRows, 0.), array.new<int>(vp_profileNumberOfRows, 0), array.new<bool>(vp_profileNumberOfRows, bool(0.)), array.new<bool>(vp_profileNumberOfRows, bool(0.)))

var volumeProfile VP = volumeProfile.new(array.new<box>(na), array.new<chart.point>(na), polyline.new(na), na, na, na, na)

var float highestPrice = na
var float lowestPrice = na

renderLine(_x1, _y1, _x2, _y2, _xloc, _extend, _color, _style, _width) =>
    var id = line.new(_x1, _y1, _x2, _y2, _xloc, _extend, _color, _style, _width)
    line.set_xy1(id, _x1, _y1)
    line.set_xy2(id, _x2, _y2)
    line.set_color(id, _color)

renderLabel(_x, _y, _text, _color, _style, _textcolor, _size, _tooltip) =>
    var lb = label.new(_x, _y, _text, xloc.bar_index, yloc.price, _color, _style, _textcolor, _size, text.align_left, _tooltip)
    lb.set_xy(_x, _y)
    lb.set_text(_text)
    lb.set_tooltip(_tooltip)
    lb.set_textcolor(_textcolor)

requestBarData(_lowerTimeframe) =>
    request.security_lower_tf(syminfo.tickerid, _lowerTimeframe, BAR.new(), ignore_invalid_timeframe = true)

calculateTimeframe(_depth) =>
    int tfInMs = timeframe.in_seconds(timeframe.period)
    int mInMS = 60

    if _depth == 2
        switch 
            tfInMs < 30 => '1S'
            tfInMs < 1 * mInMS => '5S'

            tfInMs <= 15 * mInMS => '1'
            tfInMs <= 60 * mInMS => '5'
            tfInMs <= 240 * mInMS => '15'
            tfInMs <= 1440 * mInMS => '60'
            => 'D'

    else if _depth == 1
        switch 
            tfInMs < 15 => '1S'
            tfInMs < 30 => '5S'
            tfInMs < 1 * mInMS => '15S'

            tfInMs <= 5 * mInMS => '1'
            tfInMs <= 15 * mInMS => '5'
            tfInMs <= 60 * mInMS => '15'
            tfInMs <= 240 * mInMS => '60'
            tfInMs <= 1440 * mInMS => '240'
            => 'D'

getTextSize(_text) =>
    if _text != 'None'
        switch _text
            'Tiny' => size.tiny
            'Small' => size.small
            'Normal' => size.normal
            => size.auto

profileLevesSize = getTextSize(vp_profileLevels)

if bar.index == last_bar_index - vp_profileLength
    VP.startIndex := bar.index
    lowestPrice := bar.low
    highestPrice := bar.high
    highestPrice
else if bar.index > last_bar_index - vp_profileLength
    lowestPrice := math.min(bar.low, lowestPrice)
    highestPrice := math.max(bar.high, highestPrice)
    highestPrice

if vp_profileLength <= 700
    ltfBarData := requestBarData(calculateTimeframe(2))
    ltfBarData
else
    ltfBarData := array.new<BAR>(1, BAR.new(bar.open, bar.high, bar.low, bar.close, bar.volume))
    ltfBarData

if barstate.ishistory and bar.index >= last_bar_index - vp_profileLength and bar.index < last_bar_index and ltfBarData.size() > 0

    log.info('yaz_kizim {0} {1}', ltfBarData.get(0).volume, na(nz(ltfBarData.get(0).volume)))

    if ltfBarData.size() > 0 and not na(nz(ltfBarData.get(0).volume))
        for currentLtfBar = 0 to ltfBarData.size() - 1 by 1
            barDataArray.barHigh.push(ltfBarData.get(currentLtfBar).high)
            barDataArray.barLow.push(ltfBarData.get(currentLtfBar).low)
            barDataArray.barVolume.push(ltfBarData.get(currentLtfBar).volume)
            barDataArray.barPolarity.push(ltfBarData.get(currentLtfBar).close > ltfBarData.get(currentLtfBar).open)

        barDataArray.barCount.push(ltfBarData.size())

priceStep = (highestPrice - lowestPrice) / vp_profileNumberOfRows

if barstate.islast and ltfBarData.size() > 0 //  barDataArray.barVolume.size() > 0 //

    if VP.boxes.size() > 0
        for boxIndex = 0 to VP.boxes.size() - 1 by 1
            box.delete(VP.boxes.shift())

    if barDataArray.barCount.size() > vp_profileLength
        barCount = barDataArray.barCount.shift()
        for barCountIndex = 0 to barCount - 1 by 1
            barDataArray.barHigh.shift()
            barDataArray.barLow.shift()
            barDataArray.barVolume.shift()
            barDataArray.barPolarity.shift()

    VP.pocPoints.clear()
    VP.pocPolyline.delete()

    if ltfBarData.size() > 0 and not na(nz(ltfBarData.get(0).volume))
        for currentLtfBar = 0 to ltfBarData.size() - 1 by 1
            barDataArray.barHigh.push(ltfBarData.get(currentLtfBar).high)
            barDataArray.barLow.push(ltfBarData.get(currentLtfBar).low)
            barDataArray.barVolume.push(ltfBarData.get(currentLtfBar).volume)
            barDataArray.barPolarity.push(ltfBarData.get(currentLtfBar).close > ltfBarData.get(currentLtfBar).open)

        barDataArray.barCount.push(ltfBarData.size())

    barIndex = vp_profileLength
    numberOfBars = 0
    arraySize = barDataArray.barVolume.size()

    for arrayIndex = 0 to arraySize - 1 by 1

        levelHigh = barDataArray.barHigh.get(arrayIndex)
        levelLow = barDataArray.barLow.get(arrayIndex)
        levelVolume = barDataArray.barVolume.get(arrayIndex)

        int startSlotIndex = math.max(math.floor((levelLow - lowestPrice) / priceStep), 0)
        int endSlotIndex = math.min(math.floor((levelHigh - lowestPrice) / priceStep), vp_profileNumberOfRows - 1)

        for priceLevelIndex = startSlotIndex to endSlotIndex by 1

            float priceLevel = lowestPrice + priceLevelIndex * priceStep

            volumeProportion = switch 
                levelLow >= priceLevel and levelHigh > priceLevel + priceStep => (priceLevel + priceStep - levelLow) / (levelHigh - levelLow)
                levelHigh <= priceLevel + priceStep and levelLow < priceLevel => (levelHigh - priceLevel) / (levelHigh - levelLow)
                levelLow >= priceLevel and levelHigh <= priceLevel + priceStep => 1
                => priceStep / (levelHigh - levelLow)

            volumeDataArray.totalVolume.set(priceLevelIndex, volumeDataArray.totalVolume.get(priceLevelIndex) + levelVolume * volumeProportion)

            if barDataArray.barPolarity.get(arrayIndex)
                volumeDataArray.bullishVolume.set(priceLevelIndex, volumeDataArray.bullishVolume.get(priceLevelIndex) + levelVolume * volumeProportion)

        var int field_0 = na
        var float field_1 = na
        var float field_2 = na
        var int field_3 = na
        var int field_4 = na
        var int field_5 = na

        if vp_pocShow == 'Развивающаяся'
            if arrayIndex == barDataArray.barCount.get(vp_profileLength - barIndex)
                field_0 := bar.index
                field_1 := bar.high
                field_2 := bar.low
                VP.pocPoints.push(chart.point.from_index(field_0, math.avg(field_1, field_2)))
                field_3 := bar.index
                VP.pocPoints.push(chart.point.from_index(field_3 + 1, lowestPrice + (volumeDataArray.totalVolume.indexof(volumeDataArray.totalVolume.max()) + .5) * priceStep))
                numberOfBars := numberOfBars + barDataArray.barCount.get(vp_profileLength - barIndex)
                barIndex := barIndex - 1
                barIndex
            else if arrayIndex == numberOfBars + barDataArray.barCount.get(vp_profileLength - barIndex) and numberOfBars != 0
                field_4 := bar.index
                VP.pocPoints.push(chart.point.from_index(field_4 + 1, lowestPrice + (volumeDataArray.totalVolume.indexof(volumeDataArray.totalVolume.max()) + .5) * priceStep))
                numberOfBars := numberOfBars + barDataArray.barCount.get(vp_profileLength - barIndex)
                barIndex := barIndex - 1
                barIndex
            else if barIndex == 0
                field_5 := bar.index
                VP.pocPoints.push(chart.point.from_index(field_5 + 1, lowestPrice + (volumeDataArray.totalVolume.indexof(volumeDataArray.totalVolume.max()) + .5) * priceStep))
                numberOfBars := numberOfBars + barDataArray.barCount.get(vp_profileLength - barIndex)
                numberOfBars

    VP.pocPolyline := polyline.new(VP.pocPoints, false, false, xloc.bar_index, vp_pocColor, color(na), line.style_solid, vp_pocWidth)

    for volumeIndex = 0 to vp_profileNumberOfRows - 1 by 1
        bearishVolume = 2 * volumeDataArray.bullishVolume.get(volumeIndex) - volumeDataArray.totalVolume.get(volumeIndex)
        volumeDataArray.bearishVolume.set(volumeIndex, volumeDataArray.bearishVolume.get(volumeIndex) + bearishVolume * (bearishVolume > 0 ? 1 : -1))

    VP.pocLevel := volumeDataArray.totalVolume.indexof(volumeDataArray.totalVolume.max())
    totalTradedVolume = volumeDataArray.totalVolume.sum() * vp_valueAreaThreshold
    valueAreaVolume = VP.pocLevel != -1 ? volumeDataArray.totalVolume.get(VP.pocLevel) : 0
    VP.vahLevel := VP.pocLevel
    VP.valLevel := VP.pocLevel

    while valueAreaVolume < totalTradedVolume
        if VP.valLevel == 0 and VP.vahLevel == vp_profileNumberOfRows - 1
            break

        volumeAbovePOC = 0.
        if VP.vahLevel < vp_profileNumberOfRows - 1
            volumeAbovePOC := volumeDataArray.totalVolume.get(VP.vahLevel + 1)
            volumeAbovePOC

        volumeBelowPOC = 0.
        if VP.valLevel > 0
            volumeBelowPOC := volumeDataArray.totalVolume.get(VP.valLevel - 1)
            volumeBelowPOC

        if volumeBelowPOC == 0 and volumeAbovePOC == 0
            break

        if volumeAbovePOC >= volumeBelowPOC
            valueAreaVolume := valueAreaVolume + volumeAbovePOC
            VP.vahLevel := VP.vahLevel + 1
            VP.vahLevel
        else
            valueAreaVolume := valueAreaVolume + volumeBelowPOC
            VP.valLevel := VP.valLevel - 1
            VP.valLevel

    vahPrice = lowestPrice + (VP.vahLevel + 1.) * priceStep
    pocPrice = lowestPrice + (VP.pocLevel + .5) * priceStep
    valPrice = lowestPrice + (VP.valLevel + .0) * priceStep

    profilePlottingLength = vp_profileLength > 360 ? 360 : vp_profileLength
    profileWidth = profilePlottingLength * vp_profileWidth
    profileHorizontalOffset = int(profileWidth + vp_profileHorizontalOffset)

    if vp_profileShow and profilePlacementRight and vp_pocShow == 'Развивающаяся'
        renderLine(last_bar_index, pocPrice, profileHorizontalOffset + int(last_bar_index - profileWidth + 1), pocPrice, xloc.bar_index, extend.none, vp_pocColor, line.style_solid, vp_pocWidth)

    if vp_vahShow
        renderLine(VP.startIndex, vahPrice, profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : last_bar_index, vahPrice, xloc.bar_index, extend.none, vp_vahColor, line.style_solid, 1)

    if vp_pocShow == 'Обычная'
        renderLine(VP.startIndex, pocPrice, profilePlacementRight ? vp_profileShow ? profileHorizontalOffset + int(last_bar_index - profileWidth + 1) : last_bar_index : last_bar_index, pocPrice, xloc.bar_index, extend.none, vp_pocColor, line.style_solid, vp_pocWidth)

    if vp_valShow
        renderLine(VP.startIndex, valPrice, profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : last_bar_index, valPrice, xloc.bar_index, extend.none, vp_valColor, line.style_solid, 1)

    if vp_valueAreaBackground
        VP.boxes.push(box.new(VP.startIndex, valPrice, last_bar_index, vahPrice, vp_valueAreaBackgroundColor, 1, line.style_dotted, bgcolor = vp_valueAreaBackgroundColor))

    if vp_profileBackground
        VP.boxes.push(box.new(VP.startIndex, lowestPrice, last_bar_index, highestPrice, vp_profileBackgroundColor, 1, line.style_dotted, bgcolor = vp_profileBackgroundColor))

    if vp_profileLevels != 'Нет' and VP.pocLevel != -1
        renderLabel(profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : vp_profileShow ? VP.startIndex : last_bar_index, highestPrice, str.tostring(highestPrice, format.mintick), color.new(chart.fg_color, 89), label.style_label_down, chart.fg_color, profileLevesSize, 'Профиль Высокий')

        renderLabel(profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : last_bar_index, vahPrice, str.tostring(vahPrice, format.mintick), color.new(vp_vahColor, 89), label.style_label_left, vp_vahColor, profileLevesSize, 'Область Значения Высокая')

        renderLabel(profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : last_bar_index, pocPrice, str.tostring(pocPrice, format.mintick), color.new(vp_pocColor, 89), label.style_label_left, vp_pocColor, profileLevesSize, 'Точка Контроля')

        renderLabel(profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : last_bar_index, valPrice, str.tostring(valPrice, format.mintick), color.new(vp_valColor, 89), label.style_label_left, vp_valColor, profileLevesSize, 'Область Значения Низкая')

        renderLabel(profilePlacementRight ? (vp_profileShow ? profileHorizontalOffset : 0) + last_bar_index : vp_profileShow ? VP.startIndex : last_bar_index, lowestPrice, str.tostring(lowestPrice, format.mintick), color.new(chart.fg_color, 89), label.style_label_up, chart.fg_color, profileLevesSize, 'Профиль Низкий')

    for volumeNodeLevel = 0 to vp_profileNumberOfRows - 1 by 1

        if vp_profileShow
            if vp_profileGradientColors == 'Градиентные цвета'
                vp_valueAreaUpColor := color.from_gradient(volumeDataArray.totalVolume.get(volumeNodeLevel) / volumeDataArray.totalVolume.max(), 0, 1, color.new(vp_valueAreaUpColor, 95), color.new(vp_valueAreaUpColor, 0))
                vp_valueAreaDwonColor := color.from_gradient(volumeDataArray.totalVolume.get(volumeNodeLevel) / volumeDataArray.totalVolume.max(), 0, 1, color.new(vp_valueAreaDwonColor, 95), color.new(vp_valueAreaDwonColor, 0))
                vp_profileUpVolumeColor := color.from_gradient(volumeDataArray.totalVolume.get(volumeNodeLevel) / volumeDataArray.totalVolume.max(), 0, 1, color.new(vp_profileUpVolumeColor, 95), color.new(vp_profileUpVolumeColor, 0))
                vp_profileDownVolumeColor := color.from_gradient(volumeDataArray.totalVolume.get(volumeNodeLevel) / volumeDataArray.totalVolume.max(), 0, 1, color.new(vp_profileDownVolumeColor, 95), color.new(vp_profileDownVolumeColor, 0))
                vp_profileDownVolumeColor

            startProfileIndex = profilePlacementRight ? profileHorizontalOffset + int(last_bar_index - volumeDataArray.bullishVolume.get(volumeNodeLevel) / volumeDataArray.totalVolume.max() * profileWidth) : VP.startIndex
            endProfileIndex = profilePlacementRight ? profileHorizontalOffset + last_bar_index : int(startProfileIndex + volumeDataArray.bullishVolume.get(volumeNodeLevel) / volumeDataArray.totalVolume.max() * profileWidth)

            VP.boxes.push(box.new(startProfileIndex, lowestPrice + (volumeNodeLevel + .1) * priceStep, endProfileIndex, lowestPrice + (volumeNodeLevel + .9) * priceStep, color(na), bgcolor = volumeNodeLevel >= VP.valLevel and volumeNodeLevel <= VP.vahLevel ? vp_valueAreaUpColor : vp_profileUpVolumeColor))

            startProfileIndex := profilePlacementRight ? startProfileIndex : endProfileIndex
            endProfileIndex := profilePlacementRight ? startProfileIndex - int((volumeDataArray.totalVolume.get(volumeNodeLevel) - volumeDataArray.bullishVolume.get(volumeNodeLevel)) / volumeDataArray.totalVolume.max() * profileWidth) : startProfileIndex + int((volumeDataArray.totalVolume.get(volumeNodeLevel) - volumeDataArray.bullishVolume.get(volumeNodeLevel)) / volumeDataArray.totalVolume.max() * profileWidth)

            VP.boxes.push(box.new(startProfileIndex, lowestPrice + (volumeNodeLevel + .1) * priceStep, endProfileIndex, lowestPrice + (volumeNodeLevel + .9) * priceStep, color(na), bgcolor = volumeNodeLevel >= VP.valLevel and volumeNodeLevel <= VP.vahLevel ? vp_valueAreaDwonColor : vp_profileDownVolumeColor))
            volumeDataArray.endProfileIndex.set(volumeNodeLevel, endProfileIndex)

    if vn_peaksShow != 'None' or vn_troughsShow != 'None'
        var int startVolumeNodeIndex = na
        var int endVolumeNodeIndex = na
        var bool peakUpperNth = false
        var bool peakLowerNth = false

        peaksNumberOfNodes = int(vp_profileNumberOfRows * vn_peaksNumberOfNodes)

        tempPeakTotalVolume = volumeDataArray.totalVolume.copy()

        for index = 1 to peaksNumberOfNodes by 1
            tempPeakTotalVolume.unshift(0.)
            tempPeakTotalVolume.push(0.)

        for volumeNodeLevel = 0 to vp_profileNumberOfRows - 1 + 2 * peaksNumberOfNodes by 1

            if vn_peaksShow != 'None' and volumeNodeLevel >= 2 * peaksNumberOfNodes

                for currentVolumeNode = volumeNodeLevel - 2 * peaksNumberOfNodes to volumeNodeLevel - peaksNumberOfNodes - 1 by 1
                    if tempPeakTotalVolume.get(volumeNodeLevel - peaksNumberOfNodes) <= tempPeakTotalVolume.get(currentVolumeNode)
                        peakUpperNth := false
                        break
                    else
                        peakUpperNth := true
                        peakUpperNth

                for currentVolumeNode = volumeNodeLevel - peaksNumberOfNodes + 1 to volumeNodeLevel by 1
                    if tempPeakTotalVolume.get(volumeNodeLevel - peaksNumberOfNodes) <= tempPeakTotalVolume.get(currentVolumeNode)
                        peakLowerNth := false
                        break
                    else
                        peakLowerNth := true
                        peakLowerNth

                if peakUpperNth and peakLowerNth and tempPeakTotalVolume.get(volumeNodeLevel - peaksNumberOfNodes) / tempPeakTotalVolume.max() > vn_VolumeNodeThreshold

                    startVolumeNodeIndex := vp_profileShow ? profilePlacementRight ? VP.startIndex : volumeDataArray.endProfileIndex.get(volumeNodeLevel - 2 * peaksNumberOfNodes) : VP.startIndex //VP.startIndex + int(volumeDataArray.totalVolume.get(volumeNodeLevel - vn_peaksNumberOfNodes) / volumeDataArray.totalVolume.max() * profileWidth) : VP.startIndex

                    endVolumeNodeIndex := vp_profileShow ? profilePlacementRight ? volumeDataArray.endProfileIndex.get(volumeNodeLevel - 2 * peaksNumberOfNodes) : last_bar_index : last_bar_index //profileHorizontalOffset + int(last_bar_index - volumeDataArray.totalVolume.get(volumeNodeLevel - vn_peaksNumberOfNodes) / volumeDataArray.totalVolume.max() * profileWidth) : last_bar_index : last_bar_index

                    vn_peakVolumeColor := vn_peaksShow == 'Peaks' ? vn_peakVolumeColor : color.from_gradient(tempPeakTotalVolume.get(volumeNodeLevel - peaksNumberOfNodes) / tempPeakTotalVolume.max(), 0, 1, color.new(vn_peakVolumeColor, 95), color.new(vn_peakVolumeColor, 65))

                    VP.bo

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

Открыть по тарифу

Купите тариф с пакетом открытий или войдите, если тариф уже есть. Открытый файл останется в вашем кабинете навсегда.

Выбрать тариф Войти и открыть по тарифу

Разовая покупка файла

На этой странице откроется полный исходный код файла вместо ознакомительного фрагмента.

Зачем нужен email? После подтверждения оплаты файл сохранится в кабинете на этот email. Если аккаунта ещё нет, мы создадим его и пришлём ссылку для задания пароля. Если аккаунт уже есть, покупка добавится в него. Укажите адрес, к которому у вас есть доступ.

Чтобы оформить заказ, введите email и перейдите к оплате.

Стоимость полного кода

4 013₽ ≈ $50