Is there any way to convert this indicator to ProRealTime?

Viewing 4 posts - 1 through 4 (of 4 total)
  • Author
    Posts
  • #230614 quote
    osnxp7
    Participant
    New

    Is there any way to convert this indicator to ProRealTime?

    SD_Code.txt
    #230618 quote
    GraHal
    Participant
    Master

    You are best to post the content of the text file as folks may be reluctant to click on the file but may see the code (if you post it)  and they may give it a go to convert for you.

    Use the ‘Insert PRT Code’ button (blue button, far right in the grey band above a new blank post) … even though it isn’t PRT code it might look better formatted for PRT.

    osnxp7 and robertogozzi thanked this post
    #230619 quote
    osnxp7
    Participant
    New
    // © Alpha
     
    //@version=4
    study("Demand/Supply Zones", "Alpha D/S Zones", overlay = true, max_bars_back = 501)
    prd = input(defval = 10, title="Pivot Period", minval = 4, maxval = 30, group = "Settings ", tooltip="Used while calculating Pivot Points, checks left&right bars")
    ppsrc = input(defval = 'High/Low', title="Source", options = ['High/Low', 'Close/Open'], group = "Settings ", tooltip="Source for Pivot Points")
    ChannelW = input(defval = 5, title = "Maximum Channel Width %", minval = 1, maxval = 8, group = "Settings ", tooltip="Calculated using Highest/Lowest levels in 300 bars")
    minstrength = input(defval = 1, title = "Minimum Strength", minval = 1, group = "Settings ", tooltip = "Channel must contain at least 2 Pivot Points")
    maxnumsr = input(defval = 6, title = "Maximum Number of S/R", minval = 1, maxval = 10, group = "Settings ", tooltip = "Maximum number of Support/Resistance Channels to Show") - 1
    loopback = input(defval = 290, title = "Loopback Period", minval = 100, maxval = 400, group = "Settings ", tooltip="While calculating S/R levels it checks Pivots in Loopback Period")
    res_col = input(defval = color.new(color.red, 75), title = "Resistance Color", group = "Colors ")
    sup_col = input(defval = color.new(color.lime, 75), title = "Support Color", group = "Colors ")
    inch_col = input(defval = color.new(color.gray, 75), title = "Color When Price in Channel", group = "Colors ")
    showpp = input(defval = false, title = "Show Pivot Points", group = "Extras ⏶⏷")
    showsrbroken = input(defval = false, title = "Show Broken Support/Resistance", group = "Extras ⏶⏷")
    showthema1en = input(defval = false, title = "MA 1", inline = "ma1")
    showthema1len = input(defval = 50, title = "", inline = "ma1")
    showthema1type = input(defval = "SMA", title = "", options = ["SMA", "EMA"], inline = "ma1")
    showthema2en = input(defval = false, title = "MA 2", inline = "ma2")
    showthema2len = input(defval = 200, title = "", inline = "ma2")
    showthema2type = input(defval = "SMA", title = "", options = ["SMA", "EMA"], inline = "ma2")
    
    ma1 = showthema1en ? (showthema1type == "SMA" ? sma(close, showthema1len) : ema(close, showthema1len)) : na
    ma2 = showthema2en ? (showthema2type == "SMA" ? sma(close, showthema2len) : ema(close, showthema2len)) : na
    
    plot(ma1, color = not na(ma1) ? color.blue : na)
    plot(ma2, color = not na(ma2) ? color.red : na)
    
    // get Pivot High/low
    float src1 =  ppsrc == 'High/Low' ? high : max(close, open)
    float src2 =  ppsrc == 'High/Low' ? low: min(close, open)
    float ph = pivothigh(src1, prd, prd)
    float pl = pivotlow(src2, prd, prd) 
    
    // draw Pivot points
    plotshape(ph and showpp, text = "H",  style = shape.labeldown, color = na, textcolor = color.red, location = location.abovebar, offset = -prd)
    plotshape(pl and showpp, text = "L",  style = shape.labelup, color = na, textcolor = color.lime, location = location.belowbar, offset = -prd)
    
    //calculate maximum S/R channel width
    prdhighest =  highest(300)
    prdlowest = lowest(300)
    cwidth = (prdhighest - prdlowest) * ChannelW / 100
    
    // get/keep Pivot levels
    var pivotvals= array.new_float(0)
    var pivotlocs= array.new_float(0)
    if ph or pl
        array.unshift(pivotvals, ph ? ph : pl)
        array.unshift(pivotlocs, bar_index)
        for x = array.size(pivotvals) - 1 to 0
            if bar_index - array.get(pivotlocs, x) > loopback // remove old pivot points
                array.pop(pivotvals)
                array.pop(pivotlocs)
                continue
            break
    
    //find/create SR channel of a pivot point
    get_sr_vals(ind)=>
        float lo = array.get(pivotvals, ind)
        float hi = lo
        int numpp = 0
        for y = 0 to array.size(pivotvals) - 1
            float cpp = array.get(pivotvals, y)
            float wdth = cpp <= hi ? hi - cpp : cpp - lo
            if wdth <= cwidth // fits the max channel width?
                if cpp <= hi
                    lo := min(lo, cpp)
                else
                    hi := max(hi, cpp)
                    
                numpp := numpp + 20 // each pivot point added as 20
        [hi, lo, numpp] 
    
    // keep old SR channels and calculate/sort new channels if we met new pivot point
    var suportresistance = array.new_float(20, 0) // min/max levels
    changeit(x, y)=>
        tmp = array.get(suportresistance, y * 2)
        array.set(suportresistance, y * 2, array.get(suportresistance, x * 2))
        array.set(suportresistance, x * 2, tmp)
        tmp := array.get(suportresistance, y * 2 + 1)
        array.set(suportresistance, y * 2 + 1, array.get(suportresistance, x * 2 + 1))
        array.set(suportresistance, x * 2 + 1, tmp)
        
    if ph or pl
        supres = array.new_float(0)  // number of pivot, strength, min/max levels
        stren = array.new_float(10, 0)
        // get levels and strengs
        for x = 0 to array.size(pivotvals) - 1
            [hi, lo, strength] = get_sr_vals(x)
            array.push(supres, strength)
            array.push(supres, hi)
            array.push(supres, lo)
        
        // add each HL to strengh
        for x = 0 to array.size(pivotvals) - 1
            h = array.get(supres, x * 3 + 1)
            l = array.get(supres, x * 3 + 2)
            s = 0
            for y = 0 to loopback
                if (high[y] <= h and high[y] >= l) or
                   (low[y] <= h and low[y] >= l)
                    s := s + 1
            array.set(supres, x * 3, array.get(supres, x * 3) + s)
        
        //reset SR levels
        array.fill(suportresistance, 0)
        // get strongest SRs
        src = 0
        for x = 0 to array.size(pivotvals) - 1
            stv = -1. // value
            stl = -1 // location
            for y = 0 to array.size(pivotvals) - 1
                if array.get(supres, y * 3) > stv and array.get(supres, y * 3) >= minstrength * 20
                    stv := array.get(supres, y * 3)
                    stl := y
            if stl >= 0
                //get sr level
                hh = array.get(supres, stl * 3 + 1)
                ll = array.get(supres, stl * 3 + 2)
                array.set(suportresistance, src * 2, hh)
                array.set(suportresistance, src * 2 + 1, ll)
                array.set(stren, src, array.get(supres, stl * 3))
                
                // make included pivot points' strength zero 
                for y = 0 to array.size(pivotvals) - 1
                    if (array.get(supres, y * 3 + 1) <= hh and array.get(supres, y * 3 + 1) >= ll) or
                       (array.get(supres, y * 3 + 2) <= hh and array.get(supres, y * 3 + 2) >= ll)
                        array.set(supres, y * 3, -1)
    
                src += 1
                if src >= 10
                    break
        
        for x = 0 to 8
            for y = x + 1 to 9
                if array.get(stren, y) > array.get(stren, x)
                    tmp = array.get(stren, y) 
                    array.set(stren, y, array.get(stren, x))
                    changeit(x, y)
                    
        
    get_level(ind)=>
        float ret = na
        if ind < array.size(suportresistance)
            if array.get(suportresistance, ind) != 0
                ret := array.get(suportresistance, ind)
        ret
        
    get_color(ind)=>
        color ret = na
        if ind < array.size(suportresistance)
            if array.get(suportresistance, ind) != 0
                ret := array.get(suportresistance, ind) > close and array.get(suportresistance, ind + 1) > close ? res_col :
                       array.get(suportresistance, ind) < close and array.get(suportresistance, ind + 1) < close ? sup_col :
                       inch_col
        ret
    
    var srchannels = array.new_box(10)
    for x = 0 to min(9, maxnumsr)
        box.delete(array.get(srchannels, x))
        srcol = get_color(x * 2)
        if not na(srcol)
            array.set(srchannels, x, 
                      box.new(left = bar_index, top = get_level(x * 2), right = bar_index + 1, bottom = get_level(x * 2 + 1), 
                              border_color = srcol, 
                              border_width = 1,
                              extend = extend.both, 
                              bgcolor = srcol))
    
    resistancebroken = false
    supportbroken = false
    
    // check if it's not in a channel
    not_in_a_channel = true
    for x = 0 to min(9, maxnumsr)
        if close <= array.get(suportresistance, x * 2) and close >= array.get(suportresistance, x * 2 + 1) 
            not_in_a_channel := false
    
    // if price is not in a channel then check broken ones
    if not_in_a_channel
        for x = 0 to min(9, maxnumsr)
            if close[1] <= array.get(suportresistance, x * 2) and close > array.get(suportresistance, x * 2)
                resistancebroken := true
            if close[1] >= array.get(suportresistance, x * 2 + 1) and close < array.get(suportresistance, x * 2 + 1)
                supportbroken := true
    
    alertcondition(resistancebroken, title = "Resistance Broken", message = "Resistance Broken")
    alertcondition(supportbroken, title = "Support Broken", message = "Support Broken")
    plotshape(showsrbroken and resistancebroken, style = shape.triangleup, location = location.belowbar, color = color.new(color.lime, 0), size = size.tiny)
    plotshape(showsrbroken and supportbroken, style = shape.triangledown, location = location.abovebar, color = color.new(color.red, 0), size = size.tiny)
    
    #231344 quote
    Iván González
    Moderator
    Master

    Hi! Here it is the code translated:
    https://www.prorealcode.com/prorealtime-indicators/demand-supply-zones-indicator/

    //--------------------------------------------------------//
    //PRC_Demand/Supply Zones
    //version = 0
    //08.04.24
    //Iván González @ www.prorealcode.com
    //Sharing ProRealTime knowledge
    //--------------------------------------------------------//
    //-----inputs--------------------------------------------//
    prd = 10 //Pivot period
    ppsrc = 1// 1 = "high/low" // 0 = "close/open"
    showpp = 1//Show Pivot Points
    
    channelw = 5 //Maximum channel width %
    minstrength = 1 //minimum strength
    maxnumsr = 6 //Maximum Number of S/R
    loopback = 290 //Loopback Period
    
    ShowEMA = 0 //Show moving averages
    ma1len = 50 //MA 1
    ma1type = 0 //sma=0 ema=1
    ma2len = 200 //MA 2
    ma2type = 0 //sma=0 ema=1
    //-------------------------------------------------------//
    //-----AVERAGES------------------------------------------//
    if ShowEMA then
    ma1 = average[ma1len,ma1type](close)
    ma2 = average[ma2len,ma2type](close)
    else
    ma1 = undefined
    ma2 = undefined
    endif
    //-------------------------------------------------------//
    //-----Get Pivot high / low------------------------------//
    if ppsrc then
    src1 = low
    src2 = high
    else
    src1 = max(close,open)
    src2 = min(close,open)
    endif
    //-----pivots low
    if src1 > src1[prd] and lowest[prd](src1) > src1[prd] and src1[prd] < lowest[prd](src1)[prd+1] then
    $pivotlowy[z+1] = src1[prd]
    $pivotlowx[z+1] = barindex[prd]
    z=z+1
    endif
    //-----pivots high
    if src2 < src2[prd] and highest[prd](src2)<src2[prd] and src2[prd]>highest[prd](src2)[prd+1] then
    $pivothighy[t+1]=src2[prd]
    $pivothighx[t+1]=barindex[prd]
    t=t+1
    endif
    //-------------------------------------------------------//
    //-----Draw pivot points---------------------------------//
    if showpp and z <> z[1] then
    drawpoint($pivotlowx[z],$pivotlowy[z],2)coloured("red",50)
    elsif showpp and t <> t[1] then
    drawpoint($pivothighx[t],$pivothighy[t],2)coloured("blue",50)
    endif
    //-------------------------------------------------------//
    //-----Calculate maximum S/R channel width---------------//
    prdhighest = highest[300](high)
    prdlowest = lowest[300](low)
    cwidth = (prdhighest - prdlowest) * ChannelW / 100
    //-------------------------------------------------------//
    //-----Get/keep Pivot levels-----------------------------//
    if z <> z[1] then
    $pivotvals[m+1]=src1[prd]
    $pivotlocs[m+1]=barindex[prd]
    m=m+1
    elsif t <> t[1] then
    $pivotvals[m+1]=src2[prd]
    $pivotlocs[m+1]=barindex[prd]
    m=m+1
    endif
    //-------------------------------------------------------//
    //-----Calculate Strengs---------------------------------//
    if islastbarupdate then
    //get levels and strengs
    for x=0 to m-1 do
    lo=$pivotvals[x]
    hi=lo
    numpp=0
    for Y= 0 to m-1 do
    cpp=$pivotvals[y]
    if cpp <=hi then
    wdth=hi-cpp
    else
    wdth=cpp-lo
    endif
    if wdth<=cwidth then
    numpp=numpp+20
    if cpp<=hi then
    lo=min(lo,cpp)
    else
    hi=max(hi,cpp)
    endif
    endif
    next
    $lo[x]=lo
    $hi[x]=hi
    $strength[x]=numpp
    next
    //add each HL to strengh
    for z=0 to m-1 do
    lo2=$lo[z]
    hi2=$hi[z]
    s=0
    for t=0 to loopback do
    if (high[t]<=hi2 and high[t]>=lo2) or (low[t]<=hi2 and low[t]>=lo2) then
    s=s+1
    endif
    $strength[z]=$strength[z]+s
    next
    next
    endif
    //-------------------------------------------------------//
    //-----Support&Resistance levels Array-------------------//
    //reset SR levels
    unset($suportresistance)
    // get strongest SRs
    src=0
    for i=0 to m-1 do
    stv=-1
    stl=-1
    for j=0 to m-1 do
    if $strength[j]>stv and $strength[j]>=minstrength*20 then
    stv=$strength[j]
    stl=j
    endif
    next
    if stl>=0 then
    //get sr level
    hh=$hi[stl]
    ll=$lo[stl]
    $suportresistance[src*2]=hh
    $suportresistance[src*2+1]=ll
    $stren[src]=$strength[stl]
    // make included pivot points' strength zero
    for n=0 to m-1 do
    if ($hi[n]<=hh and $hi[n]>=ll) or ($lo[n]<=hh and $lo[n]>=ll) then
    $strength[n]=-1
    endif
    next
    src=src+1
    if src>=10 then
    break
    endif
    endif
    next
    //-------------------------------------------------------//
    //-----Draw Support&Resistance---------------------------//
    for x=0 to min(9,maxnumsr-1) do
    //Calculate Top level
    if x*2 < LastSet($suportresistance) then
    if $suportresistance[x*2] <> 0 then
    boxtop = $suportresistance[x*2]
    endif
    endif
    //Calculate Bottom level
    if x*2+1 < LastSet($suportresistance) then
    if $suportresistance[x*2+1] <> 0 then
    boxbot = $suportresistance[x*2+1]
    endif
    endif
    //Color definition
    if close > boxtop then
    r=0
    g=255
    b=0
    elsif close < boxbot then
    r=255
    g=0
    b=0
    else
    r=255
    g=255
    b=50
    endif
    //Draw rectangle
    drawrectangle(0,boxtop,barindex,boxbot)coloured(r,g,b,0)fillcolor(r,g,b,50)
    next
    //-------------------------------------------------------//
    return ma1 as "SMA 1" coloured("blue"),ma2 as "SMA 2" coloured("red")
Viewing 4 posts - 1 through 4 (of 4 total)
  • You must be logged in to reply to this topic.

Is there any way to convert this indicator to ProRealTime?


Platform Support: Charts, Data & Broker Setup

New Reply
Author
author-avatar
osnxp7 @osnxp7 Participant
Summary

This topic contains 3 replies,
has 3 voices, and was last updated by Iván González
1 year, 10 months ago.

Topic Details
Forum: Platform Support: Charts, Data & Broker Setup
Language: English
Started: 03/27/2024
Status: Active
Attachments: 1 files
Logo Logo
Loading...