Merge branch 'master' of https://github.com/boris-kz/CogAlg

# Conflicts:
#	frame_2D_alg/agg_recursion.py
#	frame_2D_alg/frame_blobs.py
#	frame_2D_alg/vect_edge.py

Author: kwcckw

frame_2D_alg/agg_recursion.py

@@ -13,17 +13,20 @@
 prefix  _ denotes prior of two same-name variables, multiple _s for relative precedence
 postfix _ denotes array of same-name elements, multiple _s is nested array
 capitalized vars are summed small-case vars 
+
+Each agg+ cycle forms higher-composition complemented graphs G.altG_ in cluster_N_ and refines them in cluster_C_: 
+cross_comp -> cluster_N_ -> cluster_C -> cross_comp...
 '''
 
-def cross_comp(root):  # breadth-first node_,link_ cross-comp, connect.clustering, recursion
+def cross_comp(root, nest=0):  # breadth-first node_,link_ cross-comp, connect.clustering, recursion
 
     N_,L_,Et = comp_node_(root.node_)  # cross-comp exemplars, extrapolate to their node_s
     # mfork
     if val_(Et, fo=1) > 0:
         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)  # nested distance clustering, calls centroid and higher connect.clustering
+            cluster_N_(root, pL_, nest, fd=0)  # nested distance 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_:
@@ -33,12 +36,12 @@ def cross_comp(root):  # breadth-first node_,link_ cross-comp, connect.clusterin
                 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_, nest, fd=1)
 
-        combine_altG__(root)  # cross-comp | sum contour altG_ to altG
+        comb_altG_(root)  # combine node altG_(contour) by sum,cross-comp -> CG altG
         cluster_C_(root)  # get (G,altG) exemplars, altG_ may reinforce G by borrowing from extended surround?
 
-def cluster_N_(root, L_, fd, nest=0):  # top-down segment L_ by >ave ratio of L.dists
+def cluster_N_(root, L_, nest, fd):  # top-down segment L_ by >ave ratio of L.dists
 
     L_ = sorted(L_, key=lambda x: x.dist)  # shorter links first
     while L_:
@@ -91,7 +94,7 @@ def centroid(dnode_, node_, C=None):  # sum|subtract and average Rim nodes
 
         if C is None:
             C,A, fC = CG(),CG(), 0
-            C.M,C.L, A.M,A.L = 0,0,0,0  # setattr
+            C.M,C.L, A.M,A.L = 0,0,0,0  # centroid setattr
         else:
             A, fC = C.altG_, 1
         sum_G_(C, dnode_, fc=1)  # exclude extend_box and sum extH
@@ -176,28 +179,26 @@ def sum_G_(G, node_, fc=0):
     for n in node_:
         if fc:
             s = n.sign; n.sign = 1  # single-use
-        else: s = 1
         G.latuple += n.latuple * s; G.vert += n.vert * s
         G.Et += n.Et * s; G.aRad += n.aRad * s
         G.yx += n.yx * s
         if n.derH: G.derH.add_tree(n.derH, root=G, rev = s==-1, fc=fc)
         if fc:
-            G.L += 1  # nodes doesn't have M and L? We just need to accumulate M and L into C
+            G.M += n.m*s; G.L += s
         else:
-            if n.extH: G.extH.add_tree(n.extH, root=G, rev = s==-1)
-            G.box = extend_box( G.box, n.box)
-
-def combine_altG__(root):  # combine contour G.altG_ into altG (node_ defined by root=G), for agg+ cross-comp
-
-    for G in root.node_:  # eval altG * borrow from G:
-        if isinstance(G.altG_, list) and G.altG_:  # skip converted alt or empty altG_ 
-            altG_ = G.altG_; G.altG_ = CG(node_=altG_, root=G); G.altG_.sign = 1
-            if val_(np.sum([alt.Et for alt in altG_],axis=0), mEt=G.Et):
-                G.altG_.L = len(G.altG_.node_)
+            if n.extH: G.extH.add_tree(n.extH, root=G, rev = s==-1)  # empty in centroid
+            G.box = extend_box( G.box, n.box)  # extended per separate node_ in centroid
+
+def comb_altG_(root):  # combine contour G.altG_ into altG (node_ defined by root=G), for agg+ cross-comp
+
+    for G in root.node_:
+        if G.nest+1 == root.nest and G.altG_:
+            alt_ = G.altG_
+            sum_G_(alt_[0], [alt for alt in alt_[1:]])
+            G.altG_ = CG(root=G, node_=alt_); G.altG_.sign = 1; G.altG_.m = 0
+            # alt D * G rM:
+            if val_(G.altG_.Et, mEt=G.Et):
                 cross_comp(G.altG_)
-            else:
-                sum_G_(G.altG_, [alt for alt in G.altG_])
-                # or keep altG_ in altG.node_?
 
 if __name__ == "__main__":
     image_file = './images/raccoon_eye.jpeg'
@@ -208,7 +209,7 @@ def combine_altG__(root):  # combine contour G.altG_ into altG (node_ defined by
     if frame.node_:  # converted edges
         G_ = []
         for edge in frame.node_:
-            combine_altG__(edge)
+            comb_altG_(edge)
             cluster_C_(edge)  # no cluster_C_ in vect_edge
             G_ += edge.node_  # unpack edge, or keep if connectivity cluster, or in flat blob altG_?
         frame.node_ = G_

frame_2D_alg/frame_blobs.py

@@ -117,15 +117,11 @@ def term(blob):
     def G(blob): return blob.latuple[-1]
     @property
     def yx_(blob): return list(blob.dert_.keys())
-    # @property
-    # def yx(blob): return map(np.mean, zip(*blob.yx_))
 
 def frame_blobs_root(image):
     dert__ = comp_pixel(image)
     frame = CFrame(image)
-
-    # Flood-fill 1 pixel at a time
-    flood_fill(frame, dert__)
+    flood_fill(frame, dert__)  # flood-fill 1 pixel at a time
 
     return frame
 

frame_2D_alg/vect_edge.py

@@ -427,15 +427,14 @@ def sum_G_(node_):
 def sum2graph(root, grapht, fd, maxL=None, nest=0):  # sum node and link params into graph, aggH in agg+ or player in sub+
 
     node_, link_, Et = grapht
-    graph = CG(fd=fd, Et=Et*icoef, root=root, link_=link_, maxL=maxL, nest=nest)  # internal nesting
+    graph = CG(fd=fd, Et=Et*icoef, root=root, link_=link_, maxL=maxL, nest=nest+1)  # internal nesting
     # arg Et is weaker if internal
     yx = np.array([0,0]); yx_ = []
     derH = CH(root=graph)
     root_ = []
     for N in node_:
-        if nest:  # G is dist-nested in cluster_N_, cluster roots instead of nodes
-            while N.root.nest+1 < nest and N.root is not graph:  # higher root.root maybe updated to graph in prior node, so we need to skip it 
-                N = N.root  # incr/elevation in feedback, return root.nest+1 == nest
+        if nest:  # G is distance-nested in cluster_N_, cluster prior-dist graphs instead of nodes:
+            while N.nest != nest: N = N.root  # get prior top root: nest = arg nest
             if N in root_: continue  # roots overlap
             root_ += [N]
         graph.box = extend_box(graph.box, N.box)  # pre-compute graph.area += N.area?
@@ -458,22 +457,22 @@ def sum2graph(root, grapht, fd, maxL=None, nest=0):  # sum node and link params
     dy,dx = np.divide( np.sum([ np.abs(yx-_yx) for _yx in yx_], axis=0), L)
     graph.aRad = np.hypot(dy,dx)  # ave distance from graph center to node centers
     graph.yx = yx
-    if fd:  # dgraph # and val_(Et, mEt=root.Et) > 0:
+    if fd:  # dgraph, no mGs / dG for now  # and val_(Et, mEt=root.Et) > 0:
         altG_ = []  # mGs overlapping dG
         for L in node_:
             for n in L.nodet:  # map root mG
                 mG = n.root
                 if mG not in altG_:
                     mG.altG_ += [graph]  # cross-comp|sum complete altG_ before next agg+ cross-comp
                     altG_ += [mG]
-    feedback(graph, nest)  # recursive root.derH.add_fork(graph.derH)
+    feedback(graph)  # recursive root.derH.add_fork(graph.derH)
     return graph
 
-def feedback(node, nest):  # propagate node.derH to higher roots
+def feedback(node):  # propagate node.derH to higher roots
 
     while node.root:
         root = node.root
-        root.nest = max(root.nest, node.nest+1)  # when nest == 0, we still need to increase root.nest?
+        root.nest = max(root.nest, node.nest+1)
         lowH = addH = root.derH
         add = 1
         for fd in addH.fd_:  # unpack top-down, each fd was assigned by corresponding level of roots
@@ -504,7 +503,7 @@ def blob2CG(G, **kwargs):
     G.extH = CH()  # sum from rims
     G.altG_ = []  # or altG? adjacent (contour) gap+overlap alt-fork graphs, converted to CG
     if not hasattr(G, 'node_'): G.node_ = []  # add node_ in frame
-    
+
     return G
 
 if __name__ == "__main__":