Changes:

1. Edits in agg_recursion and vect_edge.

Author: kwcckw

frame_2D_alg/agg_recursion.py

@@ -24,17 +24,18 @@ def cross_comp(root):  # breadth-first node_,link_ cross-comp, connect.clusterin
         mlay = CH().add_tree([L.derH for L in L_]); H=root.derH; mlay.root=H; H.Et += mlay.Et; H.lft = [mlay]
         pL_ = {l for n in N_ for l,_ in get_rim(n, fd=0)}
         if len(pL_) > ave_L:
-            cluster_N_([root], pL_, fd=0)  # optional divisive clustering, calls centroid and higher connect.clustering
+            # initial root is not a list
+            cluster_N_(root, pL_, fd=0)  # optional divisive clustering, calls centroid and higher connect.clustering
         # dfork
         if val_(Et, mEt=Et,fo=1) > 0:  # same root for L_, root.link_ was compared in root-forming for alt clustering
             for L in L_:
-                L.extH, L.root, L.Et, L.mL_t, L.rimt, L.aRad, L.visited_ = CH(),[root],copy(L.derH.Et),[[],[]], [[],[]], 0,[L]
+                L.extH, L.root, L.Et, L.mL_t, L.rimt, L.aRad, L.visited_ = CH(),root,copy(L.derH.Et),[[],[]], [[],[]], 0,[L]
             lN_,lL_,dEt = comp_link_(L_,Et)
             if val_(dEt, mEt=Et, fo=1) > 0:
                 dlay = CH().add_tree([L.derH for L in lL_]); dlay.root=H; H.Et += dlay.Et; H.lft += [dlay]
                 plL_ = {l for n in lN_ for l,_ in get_rim(n, fd=1)}
                 if len(plL_) > ave_L:
-                    cluster_N_([root], plL_, fd=1)
+                    cluster_N_(root, plL_, fd=1)
 
         feedback(root)  # add root derH to higher roots derH
 
@@ -69,15 +70,21 @@ def cluster_N_(root_, L_, fd, nest=0):  # top-down segment L_ by >ave ratio of L
                 n.fin = 0; _eN_ += [n]
         G_ += [sum2graph(root_, [list({*node_}),list({*link_}), et, min_dist], fd, nest)]
         # higher root_ assign to all sub_G nodes
+    
+    # this is moved here now since deeper subs are formed later
+    hroot = root_[-1] if isinstance(root_,list) else root_  # higher root
+    if fd: hroot.subL_ = G_
+    else:  hroot.subG_ = G_
+    
     for G in G_:  # breadth-first
         sub_L_ = {l for n in G.node_ for l,_ in get_rim(n,fd) if l.dist < min_dist}
         if len(sub_L_) > ave_L:
             Et = np.sum([sL.derH.Et for sL in sub_L_],axis=0); Et[3]+=nest
             if val_(Et, fo=1) > 0:
+                if not isinstance(root_,list): root_ = [root_]  # first conversion when nest == 1
                 cluster_N_(root_+[G], sub_L_, fd, nest+1)  # sub-cluster shorter links, nest in G.subG_
     # root_ += [root] / dist segment
-    root_[-1].subG_ = G_
-    cluster_C_(root_[-1])
+    cluster_C_(hroot)
 
 ''' Hierarchical clustering should alternate between two phases: generative via connectivity and compressive via centroid.
 

frame_2D_alg/comp_slice.py

@@ -1,6 +1,6 @@
 import numpy as np
 from frame_blobs import CBase, frame_blobs_root, intra_blob_root, imread, unpack_blob_
-from frame_2D_alg.slice_edge import CP, slice_edge, comp_angle, ave_G
+from slice_edge import CP, slice_edge, comp_angle, ave_G
 
 '''
 comp_slice traces edge axis by cross-comparing vertically adjacent Ps: horizontal slices across an edge blob.

frame_2D_alg/vect_edge.py

@@ -425,14 +425,9 @@ def get_rim(N,fd): return N.rimt[0] + N.rimt[1] if fd else N.rim  # add nesting
 def sum2graph(root, grapht, fd, nest):  # sum node and link params into graph, aggH in agg+ or player in sub+
 
     node_, link_, Et = grapht[:3]
-    fsub = len(grapht) == 5  # called from divisive cluster_N
-    graph = CG(fd=fd, Et=Et*icoef, root=root[-1] if fsub else root, node_=node_, link_=link_, rng=nest)
+    graph = CG(fd=fd, Et=Et*icoef, root=root[-1] if isinstance(root,list) else root, node_=node_, link_=link_, rng=nest)  # in cluster_N_, root is not a list when nest == 0
     # arg Et is internalized; only direct root assign before clustering
-    if fsub:  # called from cluster_N
-        minL, subG_ = grapht[3:]
-        if fd: graph.subL_ = subG_
-        else:  graph.subG_ = subG_
-        graph.minL = minL
+    if len(grapht)==4: graph.minL = grapht[3]  # called from cluster_N
     yx = np.array([0,0])
     derH = CH(root=graph)
     for N in node_:
@@ -456,18 +451,20 @@ def sum2graph(root, grapht, fd, nest):  # sum node and link params into graph, a
     yx = np.divide(yx,L); graph.yx = yx
     # ave distance from graph center to node centers:
     graph.aRad = sum([np.hypot( *np.subtract(yx, N.yx)) for N in node_]) / L
-    if fd and val_(Et, mEt=root.Et) > 0:  # strong dgraph
-        altG_ = []  # mGs overlapping dG
-        for L in node_:
-            for n in L.nodet:  # map root mG
-                if isinstance(n.root,list):
-                    for G in n.root[1:]:  # skip the first root: frame or edge
-                        if L.dist >= G.minL:  # same dist segment root
-                            mG = G; break
-                else: mG = n.root
-                if mG not in altG_:
-                    mG.altG = sum_G_([mG.altG, graph])
-                    altG_ += [mG]
+    if fd:  # strong dgraph
+        mEt = np.sum([r.Et for r in root[1:]],axis=1) if isinstance(root, list) else (root.Et if isinstance(root, CG) else [.0,.0,.0,.0])
+        if val_(Et, mEt=mEt):
+            altG_ = []  # mGs overlapping dG
+            for L in node_:
+                for n in L.nodet:  # map root mG
+                    if isinstance(n.root,list):
+                        for G in n.root[1:]:  # skip the first root: frame or edge
+                            if L.dist >= G.minL:  # same dist segment root
+                                mG = G; break
+                    else: mG = n.root
+                    if mG not in altG_:
+                        mG.altG = sum_G_([mG.altG, graph])
+                        altG_ += [mG]
     feedback(graph)  # recursive root.derH.add_fork(graph.derH)
     return graph