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