本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。
//@version=6
// ═══════════════════════════════════════════════════════════════════════════
// FC_VolumeEngine — shared fine price-grid volume engine
// Used by: PVP Pro (v1.2+)
// ───────────────────────────────────────────────────────────────────────────
// VERSION LOG
// v1 2026-10-05 Extracted from PVP Pro v1.1: adaptive grid accumulate /
// coarsen, TPO bar-visit counts, rows + POC + VA (single /
// two-row, midpoint tie-break), composite merge, HVN/LVN,
// row smoothing
// ═══════════════════════════════════════════════════════════════════════════
// @description Adaptive fine price-grid volume engine: accumulate buy/sell volume, then build volume-profile rows, POC, value area, composites and volume nodes.
library("FC_VolumeEngine", overlay = true)
// @type Engine configuration
// @field useTick Size rows in ticks instead of a fixed row count
// @field tickRow Ticks per row when useTick is true
// @field rows Row count when useTick is false
// @field vaPct Value-area volume percent
// @field pocMid Break POC ties toward the range midpoint
// @field twoRow Use two-row (CBOT) value-area expansion
// @field maxG Max fine-grid buckets before coarsening
// @field maxRows Max rows in tick mode
// @field tick Symbol min tick
export type Cfg
bool useTick = false
int tickRow = 4
int rows = 50
float vaPct = 70.0
bool pocMid = true
bool twoRow = false
int maxG = 2000
int maxRows = 250
float tick = 0.01
// @type Accumulating period state (fine grid)
export type PState
int startBar = na
float o = na
float h = na
float l = na
float c = na
bool isAH = false
float base = na
float gsz = na
array<float> gv
array<float> gu
array<float> gc
float tv = 0.0
float tb = 0.0
int nBars = 0
int fpBars = 0
// @type Computed profile
export type PResult
array<float> rv
array<float> ru
array<float> rc
float rowLow
float rowH
int n
int poc
int vaLo
int vaHi
float pocPx
float vahPx
float valPx
float tv
float tb
f_rt(float x, float t) =>
math.round(x / t) * t
// @function Centered moving average across profile rows
// @param a Row values
// @param len Window length
// @returns Smoothed copy
export smooth(array<float> a, int len) =>
int n = a.size()
array<float> out = array.new<float>(n, 0.0)
int half = int(len / 2)
if n > 0
for i = 0 to n - 1
float sm = 0.0
int cnt = 0
for k = math.max(0, i - half) to math.min(n - 1, i + half)
sm += a.get(k)
cnt += 1
out.set(i, sm / cnt)
out
// @function Fine-grid bucket size for a new period
// @param c Config
// @param est Expected period range (e.g. previous period's range)
// @returns Bucket size in price
export gridSize(Cfg c, float est) =>
c.useTick ? c.tickRow * c.tick : math.max(1, math.floor(est / (c.rows * 4) / c.tick)) * c.tick
// @function New empty state
// @returns PState with empty arrays
export newState() =>
PState.new(gv = array.new<float>(), gu = array.new<float>(), gc = array.new<float>())
// @function Append one empty bucket
export method gpush(PState s) =>
s.gv.push(0.0)
s.gu.push(0.0)
s.gc.push(0.0)
s
// @function Halve grid resolution (merge bucket pairs)
export method coarsen(PState s) =>
int n = s.gv.size()
if n > 0
int m = int(math.ceil(n / 2.0))
array<float> nv = array.new<float>(m, 0.0)
array<float> nu = array.new<float>(m, 0.0)
array<float> nc = array.new<float>(m, 0.0)
for i = 0 to n - 1
int j = int(i / 2)
nv.set(j, nv.get(j) + s.gv.get(i))
nu.set(j, nu.get(j) + s.gu.get(i))
nc.set(j, math.max(nc.get(j), s.gc.get(i)))
s.gv := nv
s.gu := nu
s.gc := nc
s.gsz := s.gsz * 2
s
// @function Spread volume uniformly over a price range
// @param a Range bound
// @param b Range bound
// @param v Total volume
// @param vb Buy volume
// @param maxG Max buckets
export method addVol(PState s, float a, float b, float v, float vb, int maxG) =>
if v > 0 and not na(a) and not na(b)
float lo = math.min(a, b)
float hi = math.max(a, b)
if na(s.base)
s.base := math.floor(lo / s.gsz) * s.gsz
while (s.base - lo) / s.gsz > maxG or (hi - s.base) / s.gsz > maxG * 2
s.coarsen()
int iLo = int(math.floor((lo - s.base) / s.gsz + 1e-9))
if iLo < 0
int addN = -iLo
for k = 1 to addN
s.gv.unshift(0.0)
s.gu.unshift(0.0)
s.gc.unshift(0.0)
s.base := s.base - addN * s.gsz
iLo := 0
int iHi = math.max(iLo, int(math.floor((hi - s.base) / s.gsz + 1e-9)))
while iHi >= s.gv.size()
s.gpush()
int cnt = iHi - iLo + 1
float per = v / cnt
float perB = nz(vb) / cnt
for i = iLo to iHi
s.gv.set(i, s.gv.get(i) + per)
s.gu.set(i, s.gu.get(i) + perB)
s.tv := s.tv + v
s.tb := s.tb + nz(vb)
while s.gv.size() > maxG
s.coarsen()
s
// @function Count one bar visit across a price range (TPO-style)
export method markBar(PState s, float lo, float hi) =>
int G = s.gv.size()
if G > 0 and not na(s.base)
int iLo = math.max(0, int(math.floor((lo - s.base) / s.gsz + 1e-9)))
int iHi = math.min(G - 1, int(math.floor((hi - s.base) / s.gsz + 1e-9)))
if iHi >= iLo
for i = iLo to iHi
s.gc.set(i, s.gc.get(i) + 1)
s
// @function Start a new period
export method reset(PState s, int bar, float op, float hp, float lp, float cp, bool ah, float gsz) =>
s.startBar := bar
s.o := op
s.h := hp
s.l := lp
s.c := cp
s.isAH := ah
s.base := na
s.gsz := gsz
s.gv := array.new<float>()
s.gu := array.new<float>()
s.gc := array.new<float>()
s.tv := 0.0
s.tb := 0.0
s.nBars := 0
s.fpBars := 0
s
// @function Build rows, POC and value area
// @param s Period state
// @param cfg Config
// @param nRows Row count (ignored in tick mode)
// @returns PResult or na
export compute(PState s, Cfg cfg, int nRows) =>
PResult res = na
int G = s.gv.size()
if G > 0 and s.tv > 0
float rowH = 0.0
float rowLow = 0.0
int n = 1
if cfg.useTick
rowH := cfg.tickRow * cfg.tick
if rowH < s.gsz
rowH := math.ceil(s.gsz / rowH - 1e-9) * rowH
int k0 = int(math.ceil((s.h - s.l) / (rowH * cfg.maxRows)))
if k0 > 1
rowH := rowH * k0
rowLow := math.floor(s.l / rowH) * rowH
n := math.max(1, int(math.floor((s.h - rowLow) / rowH + 1e-9)) + 1)
else
n := nRows
rowLow := s.l
rowH := (s.h - s.l) / nRows
if rowH <= 0
n := 1
rowH := s.gsz
rowLow := s.l - s.gsz * 0.5
array<float> rv = array.new<float>(n, 0.0)
array<float> ru = array.new<float>(n, 0.0)
array<float> rc = array.new<float>(n, 0.0)
for j = 0 to G - 1
float vj = s.gv.get(j)
float cj = s.gc.get(j)
if vj > 0 or cj > 0
float uj = s.gu.get(j)
float bLo = s.base + j * s.gsz
float bHi = bLo + s.gsz
int rA = math.max(0, math.min(n - 1, int(math.floor((bLo - rowLow) / rowH))))
int rB = math.max(0, math.min(n - 1, int(math.floor((bHi - rowLow) / rowH - 1e-9))))
for ri = rA to rB
rc.set(ri, math.max(rc.get(ri), cj))
if vj > 0
if rA == rB
rv.set(rA, rv.get(rA) + vj)
ru.set(rA, ru.get(rA) + uj)
else
float fs = 0.0
for ri = rA to rB
float f = math.max(0.0, math.min(bHi, rowLow + (ri + 1) * rowH) - math.max(bLo, rowLow + ri * rowH)) / s.gsz
fs += f
rv.set(ri, rv.get(ri) + vj * f)
ru.set(ri, ru.get(ri) + uj * f)
float rem = 1.0 - fs
if rem > 1e-9
int re = bLo < rowLow ? rA : rB
rv.set(re, rv.get(re) + vj * rem)
ru.set(re, ru.get(re) + uj * rem)
float tot = rv.sum()
float mxv = rv.max()
int poc = rv.indexof(mxv)
if cfg.pocMid
float mid = (n - 1) / 2.0
float bestD = math.abs(poc - mid)
for i = 0 to n - 1
if rv.get(i) >= mxv * (1 - 1e-9) and math.abs(i - mid) < bestD
bestD := math.abs(i - mid)
poc := i
float tgt = tot * cfg.vaPct / 100.0
float acc = rv.get(poc)
int lo2 = poc
int hi2 = poc
while acc < tgt and (lo2 > 0 or hi2 < n - 1)
int stepU = math.min(cfg.twoRow ? 2 : 1, n - 1 - hi2)
int stepD = math.min(cfg.twoRow ? 2 : 1, lo2)
float vU = -1.0
float vD = -1.0
if stepU > 0
vU := 0.0
for k = 1 to stepU
vU += rv.get(hi2 + k)
if stepD > 0
vD := 0.0
for k = 1 to stepD
vD += rv.get(lo2 - k)
if vU >= vD
hi2 += stepU
acc += vU
else
lo2 -= stepD
acc += vD
float pPx = cfg.useTick ? rowLow + poc * rowH + (rowH - cfg.tick) * 0.5 : rowLow + (poc + 0.5) * rowH
res := PResult.new(rv = rv, ru = ru, rc = rc, rowLow = rowLow, rowH = rowH, n = n, poc = poc, vaLo = lo2, vaHi = hi2, pocPx = f_rt(pPx, cfg.tick), vahPx = f_rt(rowLow + (hi2 + 1) * rowH, cfg.tick), valPx = f_rt(rowLow + lo2 * rowH, cfg.tick), tv = tot, tb = s.tb)
res
// @function Merge period snapshots + current period into one composite state
// @param snaps Completed-period snapshots
// @param cur Current period
// @param maxG Max buckets
// @returns Merged PState
export merge(array<PState> snaps, PState cur, int maxG) =>
float gsz = cur.gsz
float lo = cur.l
float hi = cur.h
int sb = cur.startBar
for s in snaps
gsz := math.max(gsz, s.gsz)
lo := math.min(lo, s.l)
hi := math.max(hi, s.h)
sb := math.min(sb, s.startBar)
while (hi - lo) / gsz > maxG
gsz *= 2
float base = math.floor(lo / gsz) * gsz
int G = int(math.floor((hi - base) / gsz)) + 2
PState m = PState.new(startBar = sb, h = hi, l = lo, c = cur.c, base = base, gsz = gsz, gv = array.new<float>(G, 0.0), gu = array.new<float>(G, 0.0), gc = array.new<float>(G, 0.0))
array<PState> all = snaps.copy()
all.push(cur)
for s in all
int sg = s.gv.size()
if sg > 0 and not na(s.base)
for j = 0 to sg - 1
float v = s.gv.get(j)
if v > 0
float cp = s.base + (j + 0.5) * s.gsz
int k = math.max(0, math.min(G - 1, int(math.floor((cp - base) / gsz))))
m.gv.set(k, m.gv.get(k) + v)
m.gu.set(k, m.gu.get(k) + s.gu.get(j))
m.tv := m.tv + s.tv
m.tb := m.tb + s.tb
m
// @function HVN / LVN row indices
// @returns [hvn rows, lvn rows]
export nodes(PResult r, int win, float hvnPct, float lvnPct, int maxN, bool wantH, bool wantL) =>
array<int> hv = array.new<int>()
array<int> lw = array.new<int>()
int n = r.n
if n > 2 * win + 2
array<float> sm = smooth(r.rv, 3)
float mx = sm.max()
for i = win to n - 1 - win
float v = sm.get(i)
bool isMax = true
bool isMin = true
for j = i - win to i + win
if j != i
float w = sm.get(j)
if (j < i and w >= v) or (j > i and w > v)
isMax := false
if (j < i and w <= v) or (j > i and w < v)
isMin := false
if isMax and wantH and v >= mx * hvnPct / 100.0 and math.abs(i - r.poc) > win
hv.push(i)
if isMin and wantL and v <= mx * lvnPct / 100.0
lw.push(i)
while hv.size() > maxN
int wi = 0
for q = 1 to hv.size() - 1
if sm.get(hv.get(q)) < sm.get(hv.get(wi))
wi := q
hv.remove(wi)
while lw.size() > maxN
int wi = 0
for q = 1 to lw.size() - 1
if sm.get(lw.get(q)) > sm.get(lw.get(wi))
wi := q
lw.remove(wi)
[hv, lw]