Support Map

Study2Win · study · 366 行 · 点赞 151 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
indicator("Support Map", "SupMap", overlay = true,
     max_boxes_count = 60, max_lines_count = 60, max_labels_count = 60)
 
gF     = "Flat supports"
pvLen  = input.int(5,     "Swing strength",            minval = 1,    group = gF)
atrLen = input.int(14,    "ATR length",                minval = 1,    group = gF)
minH   = input.float(0.25,"Min zone height (x ATR)",   minval = 0.05, step = 0.05, group = gF)
maxH   = input.float(1.0, "Max zone height (x ATR)",   minval = 0.2,  step = 0.1,  group = gF)
mergeK = input.float(0.6, "Merge within (x ATR)",      minval = 0.1,  step = 0.1,  group = gF)
zViol  = input.int(3,     "Zone: max closes below",    minval = 0,    group = gF)
showN  = input.int(4,     "Flat zones to show",        minval = 1, maxval = 10, group = gF)
 
gI      = "Inclined support"
useInc  = input.bool(true, "Show inclined support / channel", group = gI)
minLows = input.int(4,     "Minimum lows ON the line", minval = 3, group = gI)
bandK   = input.float(1.0, "Low counts as on the line within (x ATR)", minval = 0.3, step = 0.1, group = gI)
pokePct = input.float(20,  "% of lows allowed below the base line", minval = 0, maxval = 40, step = 5, group = gI)
topPoke = input.float(5,   "% of highs allowed above the top line", minval = 0, maxval = 30, step = 5, group = gI)
trimPct = input.float(15,  "% worst spikes ignored when fitting angle", minval = 0, maxval = 40, step = 5, group = gI)
maxDist = input.float(6.0, "Line must be within (x ATR) below price", minval = 1.0, step = 0.5, group = gI)
minSpan = input.int(60,    "Minimum span (bars)", minval = 20, group = gI)
minHi   = input.int(3,     "Minimum highs to fit the top line", minval = 2, group = gI)
 
gS   = "Risk grading (both)"
dLow = input.int(180, "LOW risk  : span >= bars", minval = 20, group = gS)
dMid = input.int(120, "MID risk  : span >= bars", minval = 10, group = gS)
dHigh= input.int(60,  "HIGH risk : span >= bars", minval = 5,  group = gS)
 
gG     = "General"
lookbk = input.int(750, "Lookback (bars)", minval = 100, group = gG)
tolATR = input.float(0.25, "Zone dip tolerance (x ATR)", minval = 0.0, step = 0.05, group = gG)
cLow   = input.color(color.green,  "LOW risk",  group = gG)
cMid   = input.color(color.orange, "MID risk",  group = gG)
cHigh  = input.color(color.red,    "HIGH risk", group = gG)
cConv  = input.color(color.gray,   "Converging (no trade)", group = gG)
 
plot(close, "ref", color = color.new(color.gray, 100), display = display.pane, editable = false)
 
atr = ta.atr(atrLen)
ph  = ta.pivothigh(high, pvLen, pvLen)
pl  = ta.pivotlow(low,  pvLen, pvLen)
 
var array<float> cls  = array.new<float>()
var int          bas0 = na
if na(bas0)
    bas0 := bar_index
array.push(cls, close)
if array.size(cls) > lookbk
    array.shift(cls)
    bas0 += 1
 
f_close(int b) =>
    int i = b - bas0
    i >= 0 and i < array.size(cls) ? array.get(cls, i) : na
 
var array<float> plP = array.new<float>()
var array<int>   plB = array.new<int>()
var array<float> phP = array.new<float>()
var array<int>   phB = array.new<int>()
 
var array<float> zLo = array.new<float>()
var array<float> zHi = array.new<float>()
var array<int>   zTc = array.new<int>()
var array<int>   zF  = array.new<int>()
var array<int>   zL  = array.new<int>()
 
var array<box>   bxs = array.new<box>()
var array<line>  lns = array.new<line>()
var array<label> lbs = array.new<label>()
 
if not na(pl) and not na(atr)
    int   pb   = bar_index - pvLen
    float lo   = pl
    float body = math.min(open[pvLen], close[pvLen])
    float hi   = math.max(lo + atr * minH, math.min(body, lo + atr * maxH))
 
    array.push(plP, lo)
    array.push(plB, pb)
 
    int hit = -1
    if array.size(zLo) > 0
        for i = 0 to array.size(zLo) - 1
            float a = array.get(zLo, i)
            float b = array.get(zHi, i)
            if lo <= b + atr * mergeK and hi >= a - atr * mergeK
                hit := i
    if hit >= 0
        array.set(zLo, hit, math.min(array.get(zLo, hit), lo))
        array.set(zHi, hit, math.max(array.get(zHi, hit), hi))
        array.set(zTc, hit, array.get(zTc, hit) + 1)
        array.set(zL,  hit, pb)
    else
        array.push(zLo, lo)
        array.push(zHi, hi)
        array.push(zTc, 1)
        array.push(zF,  pb)
        array.push(zL,  pb)
 
if not na(ph)
    array.push(phP, ph)
    array.push(phB, bar_index - pvLen)
 
if array.size(plB) > 0
    if array.get(plB, 0) < bar_index - lookbk
        array.shift(plP)
        array.shift(plB)
if array.size(phB) > 0
    if array.get(phB, 0) < bar_index - lookbk
        array.shift(phP)
        array.shift(phB)
if array.size(zLo) > 0
    for i = array.size(zLo) - 1 to 0
        if array.get(zL, i) < bar_index - lookbk
            array.remove(zLo, i)
            array.remove(zHi, i)
            array.remove(zTc, i)
            array.remove(zF,  i)
            array.remove(zL,  i)
 
if barstate.islast and not na(atr)
    if array.size(bxs) > 0
        for i = 0 to array.size(bxs) - 1
            box.delete(array.get(bxs, i))
    if array.size(lns) > 0
        for i = 0 to array.size(lns) - 1
            line.delete(array.get(lns, i))
    if array.size(lbs) > 0
        for i = 0 to array.size(lbs) - 1
            label.delete(array.get(lbs, i))
    array.clear(bxs)
    array.clear(lns)
    array.clear(lbs)
 
    array<int> cand = array.new<int>()
    if array.size(zLo) > 0
        for i = 0 to array.size(zLo) - 1
            float zl   = array.get(zLo, i)
            float zh   = array.get(zHi, i)
            int   span = array.get(zL, i) - array.get(zF, i)
            if array.get(zTc, i) >= 2 and span >= dHigh and zh < close
                int v = 0
                for b = array.get(zF, i) to array.get(zL, i)
                    float c = f_close(b)
                    if not na(c) and c < zl - atr * tolATR
                        v += 1
                if v <= zViol
                    array.push(cand, i)
 
    int n = math.min(showN, array.size(cand))
    if n > 0
        for c = 1 to n
            int   pick = -1
            float top  = -1e20
            for k = 0 to array.size(cand) - 1
                int   id = array.get(cand, k)
                float t  = array.get(zHi, id)
                if t > top
                    top  := t
                    pick := k
            int id = array.get(cand, pick)
            array.remove(cand, pick)
 
            int    span = array.get(zL, id) - array.get(zF, id)
            color  gc   = span >= dLow ? cLow : span >= dMid ? cMid : cHigh
            string gt   = span >= dLow ? "LOW" : span >= dMid ? "MID" : "HIGH"
 
            box b = box.new(array.get(zF, id), array.get(zHi, id),
                 bar_index + 20, array.get(zLo, id),
                 xloc = xloc.bar_index, border_color = color.new(gc, 40),
                 border_width = 1, bgcolor = color.new(gc, 85), force_overlay = true)
            array.push(bxs, b)
 
            label l = label.new(bar_index + 20 + (c - 1) * 22, array.get(zHi, id),
                 "FLAT · " + gt + " · " + str.tostring(span) + "d · ×" +
                 str.tostring(array.get(zTc, id)) + "  " +
                 str.tostring(array.get(zLo, id), format.mintick) + "–" +
                 str.tostring(array.get(zHi, id), format.mintick),
                 xloc = xloc.bar_index, style = label.style_label_left,
                 color = color.new(gc, 85), textcolor = gc, size = size.small,
                 force_overlay = true)
            array.push(lbs, l)
 
    int m = array.size(plB)
    if useInc and m >= minLows
        int   bS  = -1
        float bSl = na
        float bIc = na
        int   bN  = 0
        float bSc = -1e20
        array<float> res = array.new<float>()
 
        for s = 0 to m - minLows
            int   b0 = array.get(plB, s)
            int   cN = m - s
            float sx = 0.0
            float sy = 0.0
            float sxy = 0.0
            float sxx = 0.0
            for k = s to m - 1
                float x = array.get(plB, k) - b0
                float y = array.get(plP, k)
                sx  += x
                sy  += y
                sxy += x * y
                sxx += x * x
            float den = cN * sxx - sx * sx
            if den != 0
                float sl1 = (cN * sxy - sx * sy) / den
                float ic1 = (sy - sl1 * sx) / cN
 
                array.clear(res)
                for k = s to m - 1
                    float x = array.get(plB, k) - b0
                    array.push(res, array.get(plP, k) - (ic1 + sl1 * x))
                float cut = array.percentile_linear_interpolation(res, trimPct)
 
                float tx  = 0.0
                float ty  = 0.0
                float txy = 0.0
                float txx = 0.0
                int   tN  = 0
                for k = s to m - 1
                    float x = array.get(plB, k) - b0
                    float y = array.get(plP, k)
                    if y - (ic1 + sl1 * x) >= cut
                        tx  += x
                        ty  += y
                        txy += x * y
                        txx += x * x
                        tN  += 1
                float den2 = tN * txx - tx * tx
                float sl2  = (tN >= 2 and den2 != 0) ? (tN * txy - tx * ty) / den2 : sl1
 
                array.clear(res)
                for k = s to m - 1
                    float x = array.get(plB, k) - b0
                    array.push(res, array.get(plP, k) - sl2 * x)
                float ic2 = array.percentile_linear_interpolation(res, pokePct)
 
                float d0 = array.get(plP, s) - ic2
                bool startsOnLow = d0 >= -atr * 0.5 and d0 <= atr * bandK
 
                int onLine = 0
                for k = s to m - 1
                    float d = array.get(plP, k) - (ic2 + sl2 * (array.get(plB, k) - b0))
                    if d >= -atr * 0.5 and d <= atr * bandK
                        onLine += 1
 
                float now  = ic2 + sl2 * (bar_index - b0)
                int   span = bar_index - b0
                if sl2 > 0 and startsOnLow and onLine >= minLows and span >= minSpan and now < close and close - now <= atr * maxDist
                    if span > bSc
                        bSc := span
                        bS  := s
                        bSl := sl2
                        bIc := ic2
                        bN  := onLine
 
        if bS >= 0
            int    b0   = array.get(plB, bS)
            int    span = bar_index - b0
            color  rc   = span >= dLow ? cLow : span >= dMid ? cMid : cHigh
            string gt   = span >= dLow ? "LOW" : span >= dMid ? "MID" : "HIGH"
 
            array<float> hxs = array.new<float>()
            array<float> hys = array.new<float>()
            array<int>   hbs = array.new<int>()
            if array.size(phB) > 0
                for k = 0 to array.size(phB) - 1
                    int bk = array.get(phB, k)
                    if bk >= b0
                        array.push(hxs, bk - b0)
                        array.push(hys, array.get(phP, k))
                        array.push(hbs, bk)
 
            int hStart = 0
            int hTot   = array.size(hys)
            if hTot > 0
                int   pkI = 0
                float pkV = -1e20
                for k = 0 to hTot - 1
                    if array.get(hys, k) > pkV
                        pkV := array.get(hys, k)
                        pkI := k
                if hTot - pkI >= minHi
                    hStart := pkI
 
            float hSl   = na
            float hIc   = na
            int   hFrom = hTot > 0 ? array.get(hbs, hStart) : b0
            int   hN    = hTot - hStart
 
            if hN >= minHi
                array<float> hres = array.new<float>()
                float ax  = 0.0
                float ay  = 0.0
                float axy = 0.0
                float axx = 0.0
                for k = hStart to hTot - 1
                    float x = array.get(hxs, k)
                    float y = array.get(hys, k)
                    ax  += x
                    ay  += y
                    axy += x * y
                    axx += x * x
                float aden = hN * axx - ax * ax
                if aden != 0
                    float hs1 = (hN * axy - ax * ay) / aden
                    float hi1 = (ay - hs1 * ax) / hN
 
                    // drop the WEAK highs, keep the peak
                    array.clear(hres)
                    for k = hStart to hTot - 1
                        array.push(hres, array.get(hys, k) - (hi1 + hs1 * array.get(hxs, k)))
                    float hcut = array.percentile_linear_interpolation(hres, trimPct)
 
                    float bx  = 0.0
                    float bsy = 0.0
                    float bxy = 0.0
                    float bxx = 0.0
                    int   bN2 = 0
                    for k = hStart to hTot - 1
                        float x = array.get(hxs, k)
                        float y = array.get(hys, k)
                        if y - (hi1 + hs1 * x) >= hcut
                            bx  += x
                            bsy += y
                            bxy += x * y
                            bxx += x * x
                            bN2 += 1
                    float bden = bN2 * bxx - bx * bx
                    hSl := (bN2 >= 2 and bden != 0) ? (bN2 * bxy - bx * bsy) / bden : hs1
 
                    // sit the line ON the highs
                    array.clear(hres)
                    for k = hStart to hTot - 1
                        array.push(hres, array.get(hys, k) - hSl * array.get(hxs, k))
                    hIc := array.percentile_linear_interpolation(hres, 100 - topPoke)
 
            float  thr  = atr * 0.5 / 100
            bool   conv = not na(hSl) and hSl < -thr
            color  gc   = conv ? cConv : rc
 
            line lb = line.new(b0, bIc, bar_index + 20, bIc + bSl * (bar_index + 20 - b0),
                 xloc = xloc.bar_index, color = gc, width = 2, force_overlay = true)
            array.push(lns, lb)
 
            if not na(hSl)
                line lt = line.new(hFrom, hIc + hSl * (hFrom - b0), bar_index + 20,
                     hIc + hSl * (bar_index + 20 - b0),
                     xloc = xloc.bar_index, color = gc, width = 2,
                     style = line.style_dashed, force_overlay = true)
                array.push(lns, lt)
 
            string bTx = bSl > thr ? "base +" : "base flat"
            string tTx = na(hSl) ? "highs ?" : hSl > thr ? "highs +" : hSl < -thr ? "highs −" : "highs flat"
            string sTx = conv ? "  CONVERGING" : ""
 
            label lc = label.new(bar_index + 20, bIc + bSl * (bar_index + 20 - b0),
                 "INCLINED · " + gt + " · " + str.tostring(span) + "d · ×" +
                 str.tostring(bN) + " on line · " + bTx + " / " + tTx + sTx,
                 xloc = xloc.bar_index, style = label.style_label_left,
                 color = color.new(gc, 85), textcolor = gc, size = size.small,
                 force_overlay = true)
            array.push(lbs, lc)

← 返回列表