| """Select N new 80 m boxes. Each 2023 map and 2025 loop is in its own frame, so:
|
| 1. use the pairwise map<->loop rigid fits (pairwise_frames.json) to predict overlap and generate candidate boxes in the map frame
|
| 2. verify every candidate by a local relief-NCC search of the box template inside the loop (exact yaw + position)
|
| 3. reject duplicates (same physical place) by template-vs-template NCC against existing pairs and already-accepted boxes
|
| Writes selected.json"""
|
| import numpy as np, glob, os, json, sys, time
|
| from scipy.signal import fftconvolve
|
| from pairwise_frames import fps, raster, mncc, CELL as C4
|
|
|
| N_NEW = int(sys.argv[1]) if len(sys.argv) > 1 else 12
|
| BOX = 80.0; CELL = 2.0; NB = int(BOX / CELL); STEP = 5
|
| MIN_JOINT = 0.6; MIN_PTS = 300_000; SEP = 130.0
|
| GHOST_Q10 = float(os.environ.get('GHOST_Q10', 1.0)); GHOST_Q25 = float(os.environ.get('GHOST_Q25', 3.0))
|
| MIN_SCORE = 0.70; MIN_MARGIN = 0.15; MAX_PER_LOOP = 3; MAX_PER_MAP = 4
|
| SRC23 = "E:/Subiaco Change Detection point cloud data/Subiaco2023"; SRC25 = "E:/Subiaco Change Detection point cloud data/Subiaco2025"
|
| LOOP_TIME = {1: '1845', 2: '1850', 3: '1852', 4: '1855', 5: '1859', 6: '1902', 7: '1922', 8: '1920', 9: '1918', 10: '1914', 11: '1913', 12: '1910',
|
| 13: '1908', 14: '1904', 15: '2010', 16: '1935', 17: '1940', 18: '2006', 19: '1948', 20: '1958', 21: 'xxxx'}
|
| ANCHORS = {('M2023_20230715_1439', 'Loop3'), ('M2023_20230715_1450', 'Loop4'), ('M2023_20230715_1450', 'Loop6'),
|
| ('M2023_20230715_1514', 'Loop17'), ('M2023_20230715_1459', 'Loop17')}
|
|
|
| pw = json.load(open('pairwise_frames.json'))
|
|
|
| _l23 = json.load(open('existing_located.json')); _l25 = json.load(open('existing_located_2025.json'))
|
| _corr = {}
|
| for _pr in _l23:
|
| if _l23[_pr]['score'] < 0.7 or _l25[_pr]['score'] < 0.7: continue
|
| _corr.setdefault((_l23[_pr].get('map', _l23[_pr].get('map2023')), _l25[_pr]['map']), []).append((_pr, np.array(_l23[_pr]['centre_new_frame']), np.array(_l25[_pr]['centre_new_frame']),
|
| _l23[_pr]['yaw_deg'] - _l25[_pr]['yaw_deg']))
|
| for (_m, _l), _cs in _corr.items():
|
| if len(_cs) >= 2:
|
| A_ = np.array([c[1] for c in _cs]); B_ = np.array([c[2] for c in _cs])
|
| ca, cb = A_.mean(0), B_.mean(0); H = (B_ - cb).T @ (A_ - ca); U, S, Vt = np.linalg.svd(H); R_ = Vt.T @ U.T
|
| if np.linalg.det(R_) < 0: Vt[1] *= -1; R_ = Vt.T @ U.T
|
| yaw_ = float(np.degrees(np.arctan2(R_[1, 0], R_[0, 0]))); t_ = ca - R_ @ cb
|
| else:
|
| yaw_ = float((_cs[0][3] + 180) % 360 - 180); c_, s_ = np.cos(np.radians(yaw_)), np.sin(np.radians(yaw_))
|
| t_ = _cs[0][1] - np.array([[c_, -s_], [s_, c_]]) @ _cs[0][2]
|
| for o in pw:
|
| if o['map'] == _m and o['loop'] == _l:
|
| print(f"override {_m[6:]}<->{_l}: pairwise yaw {o['yaw_deg']} t {o['t']} score {o['score']} -> anchor yaw {yaw_:.2f} t {t_.round(1).tolist()} from {[c[0] for c in _cs]}")
|
| o['yaw_deg'] = yaw_; o['t'] = t_.tolist(); o['score'] = max(o['score'], 0.9); o['overlap_ha'] = max(o['overlap_ha'], 3.0); o['anchor'] = [c[0] for c in _cs]
|
| combos = [o for o in pw if (o['score'] >= 0.5 and o['overlap_ha'] >= 3.0) or (o['map'], o['loop']) in ANCHORS]
|
| print(f'{len(combos)} map/loop combinations considered')
|
| loc = json.load(open('existing_located.json'))
|
|
|
|
|
| def rot(yaw):
|
| c, s = np.cos(np.radians(yaw)), np.sin(np.radians(yaw)); return np.array([[c, -s], [s, c]])
|
|
|
|
|
| def relief_img(k, cell=CELL):
|
| d = fps[k]; x0, y0 = int(d['cx'].min()), int(d['cy'].min()); W, H = int(d['cx'].max()) - x0 + 1, int(d['cy'].max()) - y0 + 1
|
| R = np.zeros((H, W)); Q = np.zeros((H, W)); R[d['cy'] - y0, d['cx'] - x0] = np.minimum(d['zmax'] - d['zmin'], 20.0); Q[d['cy'] - y0, d['cx'] - x0] = 1
|
| return R, Q, x0, y0
|
|
|
|
|
| LOOP_IMG = {}
|
|
|
|
|
| def loop_img(l):
|
| if l not in LOOP_IMG: LOOP_IMG[l] = relief_img(l)
|
| return LOOP_IMG[l]
|
|
|
|
|
| def box_cells(m, xmin, ymin):
|
| d = fps[m]; x = d['cx'] * 2.0 + 1; y = d['cy'] * 2.0 + 1
|
| sel = (x >= xmin) & (x < xmin + BOX) & (y >= ymin) & (y < ymin + BOX)
|
| return x[sel], y[sel], np.minimum(d['zmax'][sel] - d['zmin'][sel], 20.0), int(d['n'][sel].sum())
|
|
|
|
|
| def template(x, y, rel, yaw):
|
| xy = np.c_[x, y] @ rot(yaw).T
|
| ix = np.floor(xy[:, 0] / CELL).astype(int); iy = np.floor(xy[:, 1] / CELL).astype(int); ox, oy = ix.min(), iy.min(); ix -= ox; iy -= oy
|
| T = np.zeros((iy.max() + 1, ix.max() + 1)); M = np.zeros_like(T); np.maximum.at(T, (iy, ix), rel); M[iy, ix] = 1
|
| return T, M, ox, oy
|
|
|
|
|
| def ncc_search(R, Q, x, y, rel, yaws, min_ov):
|
| best = (-2, None)
|
| for yaw in yaws:
|
| T, M, ox, oy = template(x, y, rel, yaw)
|
| cc, n = mncc(R, Q, T, M, min_ov)
|
| iy, ix = np.unravel_index(np.argmax(cc), cc.shape)
|
| if cc[iy, ix] > best[0]:
|
| best = (float(cc[iy, ix]), (float(yaw), ix, iy, T.shape, ox, oy, cc))
|
| return best
|
|
|
|
|
| def verify(m, l, xmin, ymin, yaw0):
|
| """template = 2023 box relief; image = whole loop relief. returns dict or None"""
|
| x, y, rel, n23 = box_cells(m, xmin, ymin)
|
| if len(x) < 0.3 * NB * NB: return None
|
| R, Q, lx0, ly0 = loop_img(l)
|
| min_ov = int(0.5 * len(x))
|
| sc, (yaw, ix, iy, shp, ox, oy, cc) = ncc_search(R, Q, x, y, rel, np.arange(yaw0 - 12, yaw0 + 12.1, 1.0), min_ov)
|
| sc, (yaw, ix, iy, shp, ox, oy, cc) = ncc_search(R, Q, x, y, rel, np.arange(yaw - 1, yaw + 1.01, 0.25), min_ov)
|
| flat = cc.copy(); r = 30; flat[max(0, iy - r):iy + r, max(0, ix - r):ix + r] = -1; second = float(flat.max())
|
|
|
| Tw, Th = shp[1], shp[0]
|
| t = np.array([(ix - (Tw - 1) + lx0 - ox) * CELL, (iy - (Th - 1) + ly0 - oy) * CELL])
|
| ctr_map = np.array([xmin + BOX / 2, ymin + BOX / 2]); ctr_loop = rot(yaw) @ ctr_map + t
|
| corners = np.array([[xmin, ymin], [xmin + BOX, ymin], [xmin, ymin + BOX], [xmin + BOX, ymin + BOX]]) @ rot(yaw).T + t
|
| return {'score': round(sc, 3), 'second': round(second, 3), 'yaw_deg': yaw, 't': t.round(2).tolist(), 'centre_loop': ctr_loop.round(1).tolist(),
|
| 'loop_bbox': [corners.min(0).round(1).tolist(), corners.max(0).round(1).tolist()], 'n2023': n23, 'template': (x, y, rel)}
|
|
|
|
|
| def tt_ncc(a, b):
|
| """max masked NCC between two box templates over all yaws (duplicate test)"""
|
| xa, ya, ra = a; xb, yb, rb = b
|
| Ta, Ma, _, _ = template(xa, ya, ra, 0.0)
|
| P = 45; R = np.pad(Ta, P); Q = np.pad(Ma, P)
|
| best = -1
|
| for yaw in np.arange(0, 360, 5.0):
|
| T, M, _, _ = template(xb, yb, rb, yaw)
|
| cc, n = mncc(R, Q, T, M, int(0.4 * min(Ma.sum(), M.sum())))
|
| best = max(best, float(cc.max()))
|
| return best
|
|
|
|
|
|
|
| from align import load, level
|
| EXIST = {}
|
| for pr in sorted(loc):
|
| d = f"E:/Subiaco Change Detection point cloud data/Pairs/{pr}"
|
| f = [f for f in os.listdir(d) if '2023' in f and 'Cloud' in f][0]
|
| P = load(f'{d}/{f}'); P = P - P.mean(0); Pl = level(P)[0]
|
| ix = np.floor(Pl[:, 0] / CELL).astype(int); iy = np.floor(Pl[:, 1] / CELL).astype(int)
|
| key = (ix - ix.min()) * 100000 + (iy - iy.min()); u, inv = np.unique(key, return_inverse=True)
|
| zmin = np.full(len(u), np.inf); zmax = np.full(len(u), -np.inf); np.minimum.at(zmin, inv, Pl[:, 2]); np.maximum.at(zmax, inv, Pl[:, 2])
|
| cx = (u // 100000 + ix.min()) * CELL + 1; cy = (u % 100000 + iy.min()) * CELL + 1
|
| EXIST[pr] = (cx, cy, np.minimum(zmax - zmin, 20.0))
|
| print('existing templates ready')
|
|
|
| PW = {(o['map'], o['loop']): o for o in pw}
|
|
|
|
|
| def same_place_dist(a, b):
|
| """smallest distance (m) between two boxes evaluated in every frame they can both be expressed in"""
|
| ds = []
|
| if a['map'] == b['map']: ds.append(np.hypot(*(a['pm'] - b['pm'])))
|
| if a['loop'] == b['loop']: ds.append(np.hypot(*(a['pl'] - b['pl'])))
|
| for x, y in ((a, b), (b, a)):
|
| o = PW.get((x['map'], y['loop']))
|
| if o and (o['score'] >= 0.5 or 'anchor' in o):
|
| ds.append(np.hypot(*(x['pm'] - (rot(o['yaw_deg']) @ y['pl'] + np.array(o['t'])))))
|
| return min(ds) if ds else 9999.0
|
|
|
|
|
|
|
| cands = []
|
| for o in combos:
|
| m, l = o['map'], o['loop']; yaw, t = o['yaw_deg'], np.array(o['t'])
|
| dm = fps[m]; x0, y0 = int(dm['cx'].min()), int(dm['cy'].min()); W, H = int(dm['cx'].max()) - x0 + 1, int(dm['cy'].max()) - y0 + 1
|
| occm = np.zeros((H, W), bool); occm[dm['cy'] - y0, dm['cx'] - x0] = True
|
| cntm = np.zeros((H, W)); cntm[dm['cy'] - y0, dm['cx'] - x0] = dm['n']
|
| dl = fps[l]; pl = np.c_[dl['cx'] * 2.0 + 1, dl['cy'] * 2.0 + 1] @ rot(yaw).T + t
|
| lx = np.floor(pl[:, 0] / CELL).astype(int) - x0; ly = np.floor(pl[:, 1] / CELL).astype(int) - y0
|
| ok = (lx >= 0) & (lx < W) & (ly >= 0) & (ly < H)
|
| occl = np.zeros((H, W), bool); occl[ly[ok], lx[ok]] = True
|
| cntl = np.zeros((H, W)); np.add.at(cntl, (ly[ok], lx[ok]), dl['n'][ok])
|
|
|
| relm = np.full((H, W), np.nan); relm[dm['cy'] - y0, dm['cx'] - x0] = dm['zmax'] - dm['zmin']
|
| rell = np.full((H, W), np.inf); np.minimum.at(rell, (ly[ok], lx[ok]), (dl['zmax'] - dl['zmin'])[ok]); rell[~np.isfinite(rell)] = np.nan
|
| def integ(g): I = np.zeros((H + 1, W + 1)); I[1:, 1:] = np.cumsum(np.cumsum(g, 0), 1); return I
|
| Ij, Im, Il = integ((occm & occl).astype(float)), integ(cntm), integ(cntl)
|
| for yc in range(0, H - NB + 1, STEP):
|
| for xc in range(0, W - NB + 1, STEP):
|
| bs = lambda I: I[yc + NB, xc + NB] - I[yc, xc + NB] - I[yc + NB, xc] + I[yc, xc]
|
| J = bs(Ij) / (NB * NB)
|
| if J < MIN_JOINT: continue
|
| nm, nl = bs(Im), bs(Il)
|
| if nm < MIN_PTS or nl < MIN_PTS: continue
|
| rm_ = relm[yc:yc + NB, xc:xc + NB]; rl_ = rell[yc:yc + NB, xc:xc + NB]
|
| qm = np.nanpercentile(rm_, [10, 25]); ql = np.nanpercentile(rl_, [10, 25])
|
| if qm[0] > GHOST_Q10 or qm[1] > GHOST_Q25 or ql[0] > GHOST_Q10 or ql[1] > GHOST_Q25: continue
|
| cands.append({'map': m, 'loop': l, 'xmin': (xc + x0) * CELL, 'ymin': (yc + y0) * CELL, 'joint': float(J), 'n_map': int(nm), 'n_loop_pred': int(nl), 'yaw0': yaw, 'relief_q10_q25_2023': qm.round(2).tolist(), 'relief_q10_q25_2025': ql.round(2).tolist()})
|
| print(f'{len(cands)} candidates')
|
| cands.sort(key=lambda c: -c['joint'])
|
|
|
| sel = []; tried = 0; t0 = time.time()
|
| per_loop = {}; per_map = {}
|
| for c in cands:
|
| if len(sel) >= N_NEW: break
|
| m, l = c['map'], c['loop']
|
| if per_loop.get(l, 0) >= MAX_PER_LOOP or per_map.get(m, 0) >= MAX_PER_MAP: continue
|
| cx, cy = c['xmin'] + BOX / 2, c['ymin'] + BOX / 2
|
| if any(s['map'] == m and np.hypot(cx - s['cx'], cy - s['cy']) < SEP for s in sel): continue
|
| if any(e['map2023'] == m and np.hypot(cx - e['centre_new_frame'][0], cy - e['centre_new_frame'][1]) < max(e['half_size_m']) * 1.1 + BOX / 2 + 6 for e in loc.values()): continue
|
| tried += 1
|
| v = verify(m, l, c['xmin'], c['ymin'], -c['yaw0'])
|
| if v is None: continue
|
| t0_ = np.array(pw[[i for i, o in enumerate(pw) if o['map'] == m and o['loop'] == l][0]]['t'])
|
| pred = rot(c['yaw0']).T @ (np.array([cx, cy]) - t0_)
|
| far = float(np.hypot(*(np.array(v['centre_loop']) - pred)))
|
| ok = v['score'] >= MIN_SCORE and v['score'] - v['second'] >= MIN_MARGIN and far < 150
|
| here = {'map': m, 'loop': l, 'pm': np.array([cx, cy]), 'pl': np.array(v['centre_loop'])}
|
| others = [{'map': e.get('map', e.get('map2023')), 'loop': _l25[p]['map'], 'pm': np.array(e['centre_new_frame']), 'pl': np.array(_l25[p]['centre_new_frame'])}
|
| for p, e in loc.items()] + [{'map': s['map'], 'loop': s['loop'], 'pm': np.array([s['cx'], s['cy']]), 'pl': np.array(s['centre_loop'])} for s in sel]
|
| dup = min([same_place_dist(here, o) for o in others] + [9999.0]) if ok else 9999.0
|
| status = 'ACCEPT' if ok and dup >= SEP else ('DUPLICATE' if ok else 'REJECT')
|
| print(f"[{tried}] {m[6:]}+{l} box({c['xmin']:.0f},{c['ymin']:.0f}) joint={c['joint']:.2f} -> score {v['score']:.2f}/{v['second']:.2f} yaw {v['yaw_deg']:.2f} "
|
| f"pred-err {far:.0f} m nearest-other {dup:.0f} m {status} [{time.time()-t0:.0f}s]", flush=True)
|
| if status != 'ACCEPT': continue
|
| per_loop[l] = per_loop.get(l, 0) + 1; per_map[m] = per_map.get(m, 0) + 1
|
| s = {'pair': f'Pair{9 + len(sel)}', 'map': m, 'loop': l, 'cx': cx, 'cy': cy, 'xmin': c['xmin'], 'xmax': c['xmin'] + BOX, 'ymin': c['ymin'], 'ymax': c['ymin'] + BOX,
|
| 'joint': c['joint'], 'n2023': v['n2023'], 'n2025_pred': c['n_loop_pred'], 'yaw_deg': v['yaw_deg'], 't': v['t'], 'centre_loop': v['centre_loop'],
|
| 'loop_bbox': v['loop_bbox'], 'score': v['score'], 'second': v['second'], 'pred_err_m': round(far, 1), 'dup_ncc': round(dup, 3),
|
| 'relief_q10_q25_2023': c['relief_q10_q25_2023'], 'relief_q10_q25_2025': c['relief_q10_q25_2025'],
|
| 'src2023': glob.glob(f"{SRC23}/{m[6:19]}*.ply")[0], 'src2025': f"{SRC25}/{l}.ply", 'time2025': LOOP_TIME[int(l[4:])], 'template': v['template']}
|
| sel.append(s)
|
| for s in sel: s.pop('template')
|
| json.dump(sel, open('selected.json', 'w'), indent=1)
|
| print(f'selected {len(sel)} boxes after {tried} verifications')
|
|
|
