Introduction to Modjoy-Heatmap Liquidity Zones by BigBeluga

At Modjoy, we are committed to providing traders with cutting-edge tools and indicators to enhance their trading experience. Our latest innovation, the Modjoy-Heatmap Liquidity Zones, is an exclusive feature developed in collaboration with BigBeluga. This article will delve into the world of liquidity zones and explore how our heatmap solution can revolutionize your trading strategy.

Understanding Liquidity Zones

Liquidity zones refer to areas on a trading chart where the market has historically shown a high level of buying or selling activity. These zones are crucial in identifying potential support and resistance levels, which can significantly impact a trader's decision-making process. By understanding liquidity zones, traders can gain valuable insights into market dynamics and make more informed trading decisions.

What are Modjoy-Heatmap Liquidity Zones?

Modjoy-Heatmap Liquidity Zones is an innovative indicator that uses a heatmap to visualize liquidity zones on a trading chart. This tool is designed to provide traders with a clear and concise representation of market activity, allowing them to quickly identify areas of high liquidity and potential trading opportunities. The heatmap is color-coded, with warmer colors indicating higher levels of liquidity and cooler colors indicating lower levels.

Key Features of Modjoy-Heatmap Liquidity Zones

Real-time Data: Our heatmap is updated in real-time, ensuring that traders have access to the most current market data.
Customizable: Traders can adjust the heatmap settings to suit their individual trading needs and preferences.
Multi-Asset Support: Modjoy-Heatmap Liquidity Zones can be applied to a wide range of financial assets, including stocks, forex, and cryptocurrencies.
Alert System: Traders can set up custom alerts to notify them when the market reaches a specific liquidity zone, allowing them to respond quickly to changing market conditions.

Benefits of Using Modjoy-Heatmap Liquidity Zones

By incorporating Modjoy-Heatmap Liquidity Zones into their trading strategy, traders can expect to see several benefits, including:

Improved Risk Management: By identifying areas of high liquidity, traders can better manage their risk and make more informed decisions.
Enhanced Trading Opportunities: The heatmap provides traders with a clear visual representation of market activity, allowing them to quickly identify potential trading opportunities.
Increased Efficiency: The Modjoy-Heatmap Liquidity Zones indicator saves traders time and effort by providing a concise and easy-to-understand representation of market data.

Conclusion

Modjoy-Heatmap Liquidity Zones is a powerful trading tool that can help traders gain a competitive edge in the markets. By providing a clear and concise visual representation of liquidity zones, our heatmap solution can help traders make more informed decisions and improve their overall trading performance. Try Modjoy-Heatmap Liquidity Zones today and experience the difference for yourself.

Disclaimer: Trading carries inherent risks, and it is essential to do your own research and consider your own risk tolerance before making any trading decisions. Modjoy and BigBeluga are not responsible for any losses incurred as a result of using the Modjoy-Heatmap Liquidity Zones indicator.

Exclusive Source Code: Modjoy-Heatmap Liquidity Zones [BigBeluga]

MODJOY-HEATMAP LIQUIDITY ZONES [BIGBELUGA] SOURCE CODE

// This work is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International  

//@version=6
indicator("Modjoy-Heatmap Liquidity Zones [BigBeluga]", overlay = true
            , max_boxes_count = 500
            , calc_bars_count = 4000
            , max_lines_count = 500
            , max_bars_back = 5000
            , max_labels_count = 500)


// Inputs 
// Inputs 
tf = input.timeframe(
     "W",
     "Higher Timeframe",
     tooltip = "Select the higher timeframe used to build volume heatmap ranges.\nEach new HTF candle resets the accumulation range."
)

atrLen = 100

atrMult = input.float(
     0.25,
     "Bin Size Multiplier",
     step = 0.05,
     minval = 0.0001,
     tooltip = "Multiplier applied to ATR to define vertical bin size.\nLower values create more detailed heatmap resolution.\nHigher values create broader liquidity zones."
)

maxBins = input.int(
     40,
     "Max Bins",
     minval = 10,
     maxval = 100,
     tooltip = "Maximum number of price bins inside each HTF range.\nHigher values increase precision but use more resources."
)

liquidityFilter = input.float(
     0,
     "Liquidity Filter %",
     minval = 0,
     maxval = 100,
     tooltip = "Minimum relative volume (percentage of peak bin volume) required to mark a liquidity level.\nHigher values filter weaker zones."
)
liquidityWidth = input.int(
     5,
     "Liquidity Level Width",
     minval = 1,
     maxval = 10,
     tooltip = "Controls the thickness of drawn liquidity levels.\nHigher values make key zones more visually prominent."
)
liquidityExtend = input.int(
     25,
     "Liquidity Level Extend",
     minval = 0,

     tooltip = "Controls how far the levels are extended into the future from last bar."
)
heatColor2 = input.color(
     color.rgb(64, 17, 151, 90),
     "Low Density (0%–25%)",
     tooltip = "Color used for low volume density areas."
)

heatColor1 = input.color(
     color.rgb(27, 183, 255, 90),
     "Mid Density (25%–75%)",
     tooltip = "Color used for medium volume density areas."
)

heatColor3 = input.color(
     color.rgb(255, 235, 59, 50),
     "High Density (75%–100%)",
     tooltip = "Color used for highest liquidity zones."
)
tfChange  = timeframe.change(tf)

var max = 0.
var min = low
var start = 0


type level 
    int start 
    float lvl
    bool isRes
    float vol
    color color1
var Levels = array.new()


atrValue = ta.atr(atrLen)
binSize  = atrValue * atrMult

if not tfChange
    max := math.max(max, high)
    min := math.min(min, low)

range_ = max - min

// Safe bin count (int) + guards
rawBins    = math.min(maxBins, int(math.floor(range_[1] / binSize)))
binSize1   = range_ / rawBins
volumeBins = array.new(rawBins, 0.)


// Historical 
if tfChange
    for i = 0 to rawBins - 1
        ll = min[1] + binSize1[1] * i 
        mid = ll + binSize1[1]/2

        hh = ll + binSize1[1]

        for k = 0 to bar_index - start
            if math.abs(close[k]-mid) <= binSize1[1]
                volumeBins.set(i, volumeBins.get(i) + volume[k])

    for i = 0 to rawBins - 1
        ll = min[1] + binSize1[1] * i 
       
        hh  = ll + binSize1[1]
        vol = volumeBins.get(i) / volumeBins.max()
        
        col = vol <= 0.5 ? color.from_gradient(vol, 0, 0.5, heatColor2, heatColor1)
             : color.from_gradient(vol, 0.5, 1, heatColor1, heatColor3)

        col1 = vol <= 0.5 ? color.from_gradient(vol, 0, 0.5, color.new(heatColor2, 95), color.new(heatColor1, 95))
             : color.from_gradient(vol, 0.5, 1, color.new(heatColor1, 95), color.new(heatColor3, 95))

        box.new(start, hh, bar_index, ll
             , bgcolor = col
             , border_color = col1)

        if vol >= liquidityFilter/100
            mid = math.avg(hh, ll)
            Levels.push(level.new(bar_index, mid, low < mid, vol, col))



for s in Levels 

    if s.isRes
        if high > s.lvl 
            Levels.remove(Levels.indexof(s))
    else 
        if low < s.lvl 
            Levels.remove(Levels.indexof(s))


if not tfChange and barstate.islast

    var boxes = array.new()
    var lines = array.new()
    var labels = array.new()

    for b in boxes 
        b.delete()
    boxes.clear()

    for b in lines 
        b.delete()
    lines.clear()

    for b in labels 
        b.delete()
    labels.clear()

    for i = 0 to volumeBins.size() - 1
        ll  = min[1] + binSize1[1] * i 
        mid = ll + binSize1[1]/2
        hh  = ll + binSize1[1]

        for k = 0 to bar_index - start
            if math.abs(close[k]-mid) <= binSize1[1]
                volumeBins.set(i, volumeBins.get(i) + volume[k])

    for i = 0 to volumeBins.size() - 1
        ll  = min[1] + binSize1[1] * i 
        hh  = ll + binSize1[1]
        vol = volumeBins.get(i) / volumeBins.max()

        col = vol <= 0.5 ? color.from_gradient(vol, 0, 0.5, heatColor2, heatColor1)
             : color.from_gradient(vol, 0.5, 1, heatColor1, heatColor3)

        col1 = vol <= 0.5 ? color.from_gradient(vol, 0, 0.5, color.new(heatColor2, 95), color.new(heatColor1, 95))
             : color.from_gradient(vol, 0.5, 1, color.new(heatColor1, 95), color.new(heatColor3, 95))

        b = box.new(start, hh, bar_index, ll
             , bgcolor = col
             , border_color = col1)

        boxes.push(b)



    for s in Levels 

        labelSize =
             s.vol < 0.30 ? size.tiny  :
             s.vol < 0.55 ? size.small :
             s.vol < 0.80 ? size.normal :
                             size.large

        if s.start >= bar_index-2000
            lines.push(
                line.new(s.start, s.lvl, bar_index+liquidityExtend, s.lvl, color = s.color1, width = liquidityWidth)
            )

            labels.push(label.new(bar_index+liquidityExtend, s.lvl, "", style = label.style_circle, size = labelSize, color = s.color1))


            if s.vol >= 0.5
                labels.push(label.new(bar_index+liquidityExtend, s.lvl, str.tostring(s.vol*100, format.percent), style = label.style_label_left, size = labelSize, color = color.new(chart.bg_color, 100), textcolor = s.color1))


var length = 2

length += 1


if tfChange
    max := high
    min := low
    start := bar_index
    length := 2




// Smoothing MA inputs
GRP = "Moving Average"
maTypeInput = input.string("None", "Type", options = ["None", "SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], group = GRP, display = display.none)
maLengthInput = input.int(25, "Length", group = GRP, display = display.none, inline = "len")
autoLength = input.bool(false, "Auto", group = GRP, display = display.none, inline = "len")
src = input(close, title="Source", group = GRP)

pine_ema(src, length) =>
    alpha = 2 / (length + 1)
    sum = 0.0
    sum := na(sum[1]) ? src : alpha * src + (1 - alpha) * nz(sum[1])

pine_rma(src, length) =>
    alpha = 1/length
    sum = 0.0
    sum := na(sum[1]) ? ta.sma(src, length) : alpha * src + (1 - alpha) * nz(sum[1])

// Smoothing MA Calculation
ma(source, length, MAtype) =>
    switch MAtype
        "SMA"                   => ta.sma(source, length)
        "EMA"                   => pine_ema(source, length)
        "SMMA (RMA)"            => pine_rma(source, length)
        "WMA"                   => ta.wma(source, length)
        "VWMA"                  => ta.vwma(source, length)

plot(tfChange ? float(na) : ma(src, autoLength ? length : maLengthInput, maTypeInput), color=color.yellow, title="MA", show_last = 5000, style = plot.style_linebr)

Also Like

Modjoy-Heatmap Liquidity Zones [BigBeluga]