Changes:

1. Various edits.

Author: kwcckw

frame_2D_alg/agg_recursion.py

@@ -311,18 +311,26 @@ def agg_H_par(focus):  # draft parallel level-updating pipeline
 
         frame.aggH = list(H)  # convert back to list
 
-def agg_H_seq(focus, image, _nestt=(1,0), rave_=[]):  # recursive level-forming pipeline, called from cluster_C_
+def rave_2AG(rave_):
+    
     # draft:
     global ave, ave_L, icoef, max_dist  # add derTT aves
-    if rave_:
-        ave_ = np.array([ave, ave_L, max_dist, icoef])  # mw_, dw_
-        ave, ave_L, max_dist, icoef = ave_ * rave_
-    else:
-        rave_ = np.append(np.ones(4), np.ones(4), np.ones(4))
-        # weight per ave?
-    frame = frame_blobs_root(focus, rave_2FB(rave_))
-    intra_blob_root(frame, rave_2IB(rave_))  # not sure
-    vectorize_root(frame, rave_2VR(rave_))
+    rmM,rmD,rmn,rmo, rmI,rmG,rmA,rmL = rave_[0]
+    rdM,rdD,rdn,rdo, rdI,rdG,rdA,rdL = rave_[1]
+    
+    # ave, ave_L, icoef, max_dist:
+    ave *= rmM
+    ave_L *= rmL
+    icoef *= rmM
+    max_dist *= rmM
+
+def agg_H_seq(focus, image, _nestt=(1,0), rave_=np.ones((2,8))):  # recursive level-forming pipeline, called from cluster_C_
+   
+    # weight per ave?
+    rave_2AG(rave_)
+    frame = frame_blobs_root(focus, rave_)
+    intra_blob_root(frame, rave_)  # not sure
+    vectorize_root(frame, rave_)
     if not frame.nnest:
         return frame
     comb_altG_(frame.node_[-1].node_, ave*2)  # PP graphs in frame.node_[2]

frame_2D_alg/comp_slice.py

@@ -50,30 +50,38 @@ def __init__(l, nodet, span, angle, yx, Et, vertuple, latuple=None, root=None):
         l.prim = []
     def __bool__(l): return l.nodet
 
-def vectorize_root(frame, _fb_={}, fb_={}):
-
-    if _fb_:  # update ave based on feedback coefficients
-        global ave, ave_d, ave_G, ave_PPm, ave_PPd, ave_L, ave_dI, mw_, dw_, ave_md
-        ave *= _fb_['vect_edge']  # get feedback coefficient from comp_slice
-        ave_d *= _fb_['vect_edge']
-        ave_G *= _fb_['vect_edge']
-        ave_PPm *= _fb_['vect_edge']
-        ave_PPd *= _fb_['vect_edge']
-        ave_L *= _fb_['vect_edge']
-        ave_dI *= _fb_['vect_edge']
-        mw_ *= _fb_['vect_edge']
-        dw_ *= _fb_['vect_edge']
-    fb_['slice_edge'] = (ave+ave_d+ave_G+ave_PPm+ave_PPd+ave_L+ave_dI+sum(mw_)+sum(dw_))/23  # feedback coefficient to the next slice_edge
 
+def rave_2CS(rave_):
+    
+    global ave, ave_d, ave_G, ave_PPm, ave_PPd, ave_L, ave_dI, mw_, dw_, ave_md
+    rmM,rmD,rmn,rmo, rmI,rmG,rmA,rmL = rave_[0]
+    rdM,rdD,rdn,rdo, rdI,rdG,rdA,rdL = rave_[1]
+    
+    # ave, ave_d, ave_G, ave_PPm, ave_PPd, ave_L, ave_dI:
+    ave *= rmM
+    ave_d *= rdM
+    ave_G *= rmG
+    ave_PPm *= rmM
+    ave_PPd *= rdM
+    ave_L *= rmL
+    ave_dI *= rmI
+
+    # mw_, dw_:
+    rmw_, rdw_ = [rmI, rmG, rmM, rmD, rmL, rmA], [rdI, rdG, rdM, rdD, rdL, rdA]
+    mw_ *= rmw_; dw_ *= rdw_
+
+def vectorize_root(frame):
+    
     blob_ = unpack_blob_(frame)
     for blob in blob_:
         if not blob.sign and blob.G > ave_G * blob.root.olp:
             edge = slice_edge(blob)
             if edge.G * (len(edge.P_) - 1) > ave_PPm:  # eval PP, olp=1
                 comp_slice(edge)
 
-def comp_slice(edge):  # root function
+def comp_slice(edge, rave_=np.ones((2,8))):  # root function
 
+    rave_2CS(rave_)
     edge.Et, edge.vertuple = np.zeros(4), np.array([np.zeros(6), np.zeros(6)])  # (M, D, n, o), (m_,d_)
     for P in edge.P_:  # add higher links
         P.vertuple = np.array([np.zeros(6), np.zeros(6)])

frame_2D_alg/frame_blobs.py

@@ -128,11 +128,16 @@ def G(blob): return blob.latuple[-1]
     @property
     def yx_(blob): return list(blob.dert_.keys())
 
-def frame_blobs_root(image, _fb_={}):
-    if _fb_:  # update ave based on feedback coefficients
-        global ave
-        ave *= _fb_['frame_blobs']   # get feedback coefficient from intra_blob
 
+def rave_2FB(rave_):
+
+    global ave
+    # ave:
+    ave *= rave_[0][0]  # ave *= rmM
+
+def frame_blobs_root(image, rave_=np.ones((2,8))):
+    
+    rave_2FB(rave_)
     dert__ = comp_pixel(image)
     frame = CFrame(image)
     flood_fill(frame, dert__)  # flood-fill 1 pixel at a time
@@ -185,13 +190,16 @@ def __init__(rnode_, blob):
         rnode_.olp= blob.root.olp + 1.5
         rnode_.rng = blob.root.rng + 1
 
-def intra_blob_root(frame, _fb_={}, fb_={}):
+def rave_2IB(rave_):
+
+    global ave, aveR
+    # ave, aveR:
+    ave *= rave_[0][0]   # ave *= rmM
+    aveR *= rave_[0][0]  # aveR *= rmM
 
-    if _fb_:  # update ave based on feedback coefficients
-        global aveR
-        aveR *= _fb_['intra_blob']  # get feedback coefficient from slice_edge
-    fb_['frame_blobs'] = aveR  # feedback coefficient to the next frame_blobs
+def intra_blob_root(frame, rave_=np.ones((2,8))):
 
+    rave_2IB(rave_)
     frame.olp = frame.rng = 1
     for blob in frame.blob_:
         rblob(blob)

frame_2D_alg/slice_edge.py

@@ -33,15 +33,20 @@ def vectorize_root(frame):
         if not blob.sign and blob.G > frame.ave.G:
             slice_edge(blob, frame.ave)
 
-def slice_edge(edge, _fb_={}, fb_={}):
+def rave_2CS(rave_):
+    
+    global ave_I, ave_G, ave_dangle
+    rmM,rmD,rmn,rmo, rmI,rmG,rmA,rmL = rave_[0]
+    rdM,rdD,rdn,rdo, rdI,rdG,rdA,rdL = rave_[1]
 
-    if _fb_:  # update ave based on feedback coefficients
-        global ave_I, ave_G, ave_dangle
-        ave_I *= _fb_['slice_edge']  # get feedback coefficient from comp_slice
-        ave_G *= _fb_['slice_edge']
-        ave_dangle *= _fb_['slice_edge']
-    fb_['intra_blob'] = (ave_I+ave_G+ave_dangle)/3  # feedback coefficient to the next intra_blob (sum them? or return an array? But we only need 1)
+    # ave_I, ave_G, ave_dangle:
+    ave_I *= rmI
+    ave_G *= rmG
+    ave_dangle *= rdA
 
+def slice_edge(edge, rave_=np.ones((2,8))):
+
+    rave_2CS(rave_)   
     axisd = select_max(edge)
     yx_ = sorted(axisd.keys(), key=lambda yx: edge.dert_[yx][-1])  # sort by g
     edge.P_ = []; edge.rootd = {}

frame_2D_alg/vect_edge.py

@@ -148,7 +148,7 @@ class CL(CBase):  # link or edge, a product of comparison between two nodes or l
     def __init__(l,  **kwargs):
         super().__init__()
         l.nodet = kwargs.get('nodet',[])  # e_ in kernels, else replaces _node,node: not used in kernels
-        l.L = 0  # distance between nodes
+        l.L = kwargs.get('L', 1)  # distance between nodes (L shouldn't be 0?)
         l.Et = kwargs.get('Et', np.zeros(4))
         l.fd = kwargs.get('fd',0)
         l.yx = kwargs.get('yx', np.zeros(2))  # [(y+Y)/2,(x,X)/2], from nodet
@@ -158,23 +158,40 @@ def __init__(l,  **kwargs):
         # add med, rimt, extH in der+
     def __bool__(l): return bool(l.nodet)
 
-def vectorize_root(frame, rave_=[]):  # init for agg+:
-    # draft:
+def rave_2VR(rave_):
+    
     global ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_
-    if rave_:
-        ave_ = np.array([ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_])
-        ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_ = ave_ * rave_
-    else:
-        rave_ = np.append(np.ones(10), np.ones(10), np.ones(10))  # weight per ave?
+    rmM,rmD,rmn,rmo, rmI,rmG,rmA,rmL = rave_[0]
+    rdM,rdD,rdn,rdo, rdI,rdG,rdA,rdL = rave_[1]
+    
+    # ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI:
+    ave *= rmM
+    ave_d *= rdM
+    ave_rn *= rmn
+    ave_ro *= rmo
+    ave_G *= rmG
+    ave_L *= rmL
+    max_dist *= rmM
+    icoef *= rmM
+    med_cost *= rmM
+    ave_dI *= rmI
+
+    # mw_, dw_
+    mw_ *= rave_[0]; dw_ *= rave_[1]
+
+
+def vectorize_root(frame, rave_=np.ones((2,8))):  # init for agg+:
+    # draft:
+    rave_2VR(rave_)
     blob_ = unpack_blob_(frame)
     frame2G(frame, derH=[CLay(root=frame)], node_=[blob_], root=None)
     edge_ = []  # cluster, unpack
     for blob in blob_:
         if not blob.sign and blob.G > ave_G * blob.root.olp:
             # convert rave_ to slice_edge coefs:
-            edge = slice_edge(blob, rave_2SE(rave_))
+            edge = slice_edge(blob, rave_)
             if edge.G * (len(edge.P_)-1) > ave:  # eval PP
-                comp_slice(edge, rave_2CS(rave_))
+                comp_slice(edge, rave_)
                 if edge.Et[0] * (len(edge.node_)-1)*(edge.rng+1) > ave:
                     G_ = [PP2G(PP)for PP in edge.node_ if PP[-1][0] > ave]  # Et, no altGs
                     if len(G_) > ave_L:  # no comp node_,link_,PPd_
@@ -576,7 +593,7 @@ def PP2G(PP):
 
     baseT = np.array((*latuple[:2], *latuple[-1]))  # I,G,Dy,Dx
     [mI,mG,mA,mM,mD,mL], [dI,dG,dA,dM,dD,dL] = vert
-    derTT = np.array([np.array([mM,mD,mL,1,mI,mG,*mA,mL]), np.array([dM,dD,dL,1,dI,dG,*dA,dL])])
+    derTT = np.array([np.array([mM,mD,mL,1,mI,mG,mA,mL]), np.array([dM,dD,dL,1,dI,dG,dA,dL])])  # mA and dA is scalar here
     y,x,Y,X = box; dy,dx = Y-y,X-x              # A = (dy,dx); L = np.hypot(dy,dx)
     G = CG(root=root, fd=0, Et=Et, node_=P_, link_=[], baseT=baseT, derTT=derTT, box=box, yx=yx, aRad=np.hypot(dy/2, dx/2),
            derH=[[CLay(node_=P_,link_=link_, derTT=deepcopy(derTT)), CLay()]])  # empty dfork