from scipy import misc
def inc_rng(a, aV, aD, min_r, A, AV, AD, r, w, p_):
if r > min_r: # A, AV, AD inc.to adjust for redundancy to patterns formed by prior comp:
A += a # a: min m for inclusion into positive vP
AV += aV # aV: min V for initial comp() recursion, AV: min V for higher recursions
if r > min_r-1: # default range is shorter for d_[w]: ds are redundant to and smaller than ps
AD += aD # aV: min |D| for initial comp() recursion over d_[w], AD: min |D| for higher recursions
W = w # to differentiate from new w
ip_ = p_ # to differentiate from new p_; local nP is initialized:
n, P_ = (0, dict()) # r was incremented in higher-scope p_
pri_s, w, I, D, V, rv, p_ = (0, 0, 0, 0, 0, 0, dict()) # tuple vP=0
pri_sd, wd, Id, Dd, Vd, rd, d_ = (0, 0, 0, 0, 0, 0, dict()) # tuple dP=0
for x in range(r+2, W):
p, fd, fv = ip_[x] # keys = w, always start from 1, comp to r+2 pixels back
pp, pfd, pfv = ip_[x-r] # previously compared p(ignored) and its fd and fv to next p
fv += pfv # fv is summed over extended-comp range
fd += pfd # fd is summed over extended-comp range
pri_p, pri_fd, pri_fv = ip_[x-r-1] # for comp(p, pri_p), pri_fd and pri_fv are ignored
pri_s, w, I, D, V, rv, p_, pri_sd, wd, Id, Dd, Vd, rd, d_, n, P_ = \
comp(p, pri_p, fd, fv, W, x,
pri_s, w, I, D, V, rv, p_,
pri_sd, wd, Id, Dd, Vd, rd, d_,
a, aV, aD, min_r, A, AV, AD, r, n, P_)
return P_ # local vPs and dPs to replace p_, A, AV, AD accumulated per comp recursion but not for next pixel
def inc_der(a, aV, aD, min_r, A, AV, AD, r, wd, d_):
if r > min_r:
A += a; AV += aV
if r > min_r-1:
AD += aD
W = wd # to differentiate from new w
ip_ = d_ # to differentiate from new d_; local nP is initialized:
fd, fv, r, n, P_ = (0, 0, 0, 0, dict()) # r is initialized for each d_
pri_s, w, I, D, V, rv, p_ = (0, 0, 0, 0, 0, 0, dict()) # tuple nP=0,
pri_sd, wd, Id, Dd, Vd, rd, d_ = (0, 0, 0, 0, 0, 0, dict()) # tuple nP=0
for x in range(1, W): # keys = wd, always start from 1
p = ip_[x]
if x > 1:
pri_s, w, I, D, V, rv, p_, pri_sd, wd, Id, Dd, Vd, rd, d_, n, P_ = \
comp(p, pri_p, fd, fv, W, x,
pri_s, w, I, D, V, rv, p_,
pri_sd, wd, Id, Dd, Vd, rd, d_,
a, aV, aD, min_r, A, AV, AD, r, n, P_)
pri_p = p
return P_ # local vPs and dPs to replace d_
def comp(p, pri_p, fd, fv, W, x, # x is from higher-scope for loop w
pri_s, w, I, D, V, rv, p_,
pri_sd, wd, Id, Dd, Vd, rd, d_,
a, aV, aD, min_r, A, AV, AD, r, n, P_):
d = p - pri_p # difference between consecutive pixels
m = min(p, pri_p) # match between consecutive pixels
v = m - A # relative match (predictive value) between consecutive pixels
fd += d # fd includes all shorter- and current- range ds between comparands
fv += v # fv includes all shorter- and current- range vs between comparands
# formation of value pattern vP: span of pixels forming same-sign v s:
s = 1 if v > 0 else 0 # s: positive sign of v
if x > r+1 and (s != pri_s or x == W-1): # (if derived pri_s) vP is terminated
n += 1 # n: number of dPs + vPs formed within line, or recursively within higher p_ or d_
if w > r+3 and pri_s == 1 and V > AV: # w includes P_? ps in p_ are cross-compared over extended distance:
r += 1 # r: incremental range of comp
rv = 1 # rv: incremental range flag:
w += 1 # concat?
p_[w] = inc_rng(a, aV, aD, min_r, A, AV, AD, r, w, p_)
P_[n] = 0, pri_s, w, I, D, V, rv, p_ # output of vP
w, I, D, V, rv, p_ = (0, 0, 0, 0, 0, dict()) # initialization of new vP
pri_s = s # prior s updated, v pattern is incremented:
w += 1 # span of vP: number of pixels forming same-sign v
I += pri_p # ps summed within w
D += fd # fds summed within w into fuzzy D
V += fv # fvs summed within w into fuzzy V
p_[w] = pri_p, fd, fv # buffered within w for selective extended comp
# formation of difference pattern dP: span of pixels forming same-sign d s:
sd = 1 if d > 0 else 0 # sd: positive sign of d;
if x > r+2 and (sd != pri_sd or x == W-1): # (if derived pri_sd) dP is terminated
n += 1
if wd > 3 and abs(Dd) > AD: # wd includes P_? ds in d_ are cross-compared:
rd = 1 # rd: incremental derivation flag:
wd += 1 # concat?
d_[wd] = inc_der(a, aV, aD, min_r, A, AV, AD, r, wd, d_)
P_[n] = 1, pri_sd, wd, Id, Dd, Vd, rd, d_ # output of dP
wd, Id, Dd, Vd, rd, d_ = (0, 0, 0, 0, 0, dict()) # initialization of new dP
pri_sd = sd # prior sd updated, d pattern is incremented:
wd += 1 # span of dP: number of pixels forming same-sign d
Id += pri_p # ps summed within wd
Dd += fd # fds summed within wd
Vd += fv # fvs summed within wd
d_[wd] = fd # prior fds are buffered in d_, same-sign as distinct from in p_
return pri_s, w, I, D, V, rv, p_, pri_sd, wd, Id, Dd, Vd, rd, d_, n, P_
# for next p comparison, vP and dP increment, and output
def frame(Fp_): # last '_' distinguishes array name from element name:
FP_ = dict() # output frame of patterns, P_: line of patterns (vP or dP)
H, W = Fp_.shape # H: frame height, W: frame width
a = 127 # minimal filter for vP inclusion
aV = 63 # minimal filter for incremental-range comp
aD = 63 # minimal filter for incremental-derivation comp
min_r=0 # default range of fuzzy comparison
for y in range(H):
ip_ = Fp_[y, :] # y is index of new line ip_; or p_ = dict(zip(range(len(p_)), p_.values())))?
if min_r == 0: A = a; AV = aV # actual filters, incremented per comp recursion
else: A = 0; AV = 0 # if r > min_r
if min_r <= 1: AD = aD
else: AD = 0
fd, fv, r, x, n, P_ = (0, 0, 0, 0, 0, dict()) # nP tuple = (n, P_, r, A, AV, AD)
pri_s, w, I, D, V, rv, p_ = (0, 0, 0, 0, 0, 0, dict()) # vP tuple = (pri_s, w, I, D, V, rv, p_)
pri_sd, wd, Id, Dd, Vd, rd, d_ = (0, 0, 0, 0, 0, 0, dict()) # dP tuple = (pri_sd, wd, Id, Dd, Vd, rd, d_)
for x in range(W): # cross-compares consecutive pixels, forming a sequence of d, m, v:
p = ip_[x] # new pixel, comp to prior pixel:
if x > 0:
pri_s, w, I, D, V, rv, p_, pri_sd, wd, Id, Dd, Vd, rd, d_, n, P_ = \
comp(p, pri_p, fd, fv, W, x,
pri_s, w, I, D, V, rv, p_,
pri_sd, wd, Id, Dd, Vd, rd, d_,
a, aV, aD, min_r, A, AV, AD, r, n, P_)
pri_p = p # prior pixel, pri_ values are always derived before use
FP_[y] = n, P_ # y = len(FP_), or FP_ = P_, line of patterns is added to frame of patterns
return FP_ # or return FP_ # frame of patterns (vP or dP): output to level 2;
f = misc.face(gray=True) # input frame of pixels
f = f.astype(int)
frame(f)