| """Level, centre and co-register a 2023/2025 crop pair. |
| Usage: python align.py raw2023.ply raw2025.ply out_dir [tag] |
| Writes out_dir/2023.ply, out_dir/2025.ply, out_dir/alignment.json""" |
| import sys, os, json, time |
| import numpy as np, pandas as pd |
| from scipy.spatial import cKDTree |
|
|
| def header_len(path): |
| n = 0 |
| with open(path, 'rb') as f: |
| for line in f: |
| n += 1 |
| if line.strip() == b'end_header': return n |
|
|
| def load(p): |
| return pd.read_csv(p, sep=r'\s+', header=None, skiprows=header_len(p), usecols=[0,1,2], |
| dtype=np.float64, engine='c').to_numpy() |
|
|
| def write_ply(path, pts, comments=()): |
| with open(path, 'w', newline='\n') as f: |
| f.write('ply\nformat ascii 1.0\n') |
| for c in comments: f.write(f'comment {c}\n') |
| f.write(f'element vertex {len(pts)}\nproperty float x\nproperty float y\nproperty float z\n' |
| 'property uchar red\nproperty uchar green\nproperty uchar blue\nend_header\n') |
| np.savetxt(f, pts, fmt='%.4f %.4f %.4f 0 0 0') |
|
|
| def ground_points(P, cell=1.0): |
| """lowest point per 1 m XY cell -> candidate ground samples""" |
| ij = np.floor(P[:, :2] / cell).astype(np.int64) |
| key = (ij[:, 0] - ij[:, 0].min()) * 100000 + (ij[:, 1] - ij[:, 1].min()) |
| order = np.lexsort((P[:, 2], key)) |
| key_s = key[order] |
| first = np.r_[True, key_s[1:] != key_s[:-1]] |
| return P[order[first]] |
|
|
| def ransac_plane(G, iters=400, thr=0.15, rng=np.random.default_rng(0)): |
| best_n, best_d, best_inl = None, None, -1 |
| for _ in range(iters): |
| s = G[rng.choice(len(G), 3, replace=False)] |
| n = np.cross(s[1]-s[0], s[2]-s[0]); nn = np.linalg.norm(n) |
| if nn < 1e-9: continue |
| n /= nn |
| if n[2] < 0: n = -n |
| if n[2] < 0.7: continue |
| d = -n @ s[0] |
| dist = np.abs(G @ n + d) |
| inl = (dist < thr).sum() |
| if inl > best_inl: best_n, best_d, best_inl = n, d, inl |
| |
| m = np.abs(G @ best_n + best_d) < thr |
| c = G[m].mean(0) |
| _, _, vt = np.linalg.svd(G[m] - c) |
| n = vt[2]; n = n if n[2] > 0 else -n |
| return n, -n @ c, best_inl / len(G) |
|
|
| def rot_to_z(n): |
| """rotation matrix taking unit vector n to +z""" |
| z = np.array([0, 0, 1.0]); v = np.cross(n, z); s = np.linalg.norm(v); c = n @ z |
| if s < 1e-12: return np.eye(3) |
| vx = np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]]) |
| return np.eye(3) + vx + vx @ vx * ((1 - c) / s**2) |
|
|
| def kabsch(A, B): |
| ca, cb = A.mean(0), B.mean(0) |
| U, S, Vt = np.linalg.svd((A-ca).T @ (B-cb)) |
| D = np.diag([1, 1, np.sign(np.linalg.det(Vt.T @ U.T))]) |
| R = Vt.T @ D @ U.T |
| return R, cb - R @ ca |
|
|
| def icp(A, B, iters=60, trim=0.7, max_d=3.0, seed=0): |
| """trimmed point-to-point ICP aligning A onto B; returns R,t (applied as A@R.T+t) and final median NN dist""" |
| rng = np.random.default_rng(seed) |
| sa = A[rng.choice(len(A), min(250000, len(A)), replace=False)] |
| sb = B[rng.choice(len(B), min(400000, len(B)), replace=False)] |
| tree = cKDTree(sb) |
| R, t = np.eye(3), np.zeros(3) |
| prev = np.inf |
| for it in range(iters): |
| cur = sa @ R.T + t |
| d, idx = tree.query(cur, workers=-1) |
| m = d < max_d |
| k = int(trim * m.sum()) |
| sel = np.argsort(np.where(m, d, np.inf))[:k] |
| Ri, ti = kabsch(cur[sel], sb[idx[sel]]) |
| R, t = Ri @ R, Ri @ t + ti |
| err = np.median(d[sel]) |
| if abs(prev - err) < 1e-5: break |
| prev = err |
| cur = sa @ R.T + t |
| d, _ = tree.query(cur, workers=-1) |
| return R, t, float(np.median(d)), float(np.percentile(d, 90)), it + 1 |
|
|
| def dsm(P, cell, x0, y0, nx, ny, zmax=15.0): |
| ix = np.floor((P[:, 0] - x0) / cell).astype(int); iy = np.floor((P[:, 1] - y0) / cell).astype(int) |
| m = (ix >= 0) & (ix < nx) & (iy >= 0) & (iy < ny) & (P[:, 2] > -1) & (P[:, 2] < zmax) |
| img = np.full((ny, nx), -np.inf) |
| np.maximum.at(img, (iy[m], ix[m]), P[m, 2]) |
| occ = np.isfinite(img); img[~occ] = 0 |
| return img, occ |
|
|
| def coarse_xy(A, B, cell=0.5, search=25.0): |
| """XY shift (dx,dy) to apply to A so it best overlays B: cross-correlation of clipped DSMs""" |
| from scipy.signal import fftconvolve |
| lo = np.minimum(A[:, :2].min(0), B[:, :2].min(0)) - search; hi = np.maximum(A[:, :2].max(0), B[:, :2].max(0)) + search |
| nx, ny = int(np.ceil((hi[0]-lo[0]) / cell)), int(np.ceil((hi[1]-lo[1]) / cell)) |
| ia, oa = dsm(A, cell, lo[0], lo[1], nx, ny); ib, ob = dsm(B, cell, lo[0], lo[1], nx, ny) |
| ia = (ia - ia[oa].mean()) * oa; ib = (ib - ib[ob].mean()) * ob |
| cc = fftconvolve(ib, ia[::-1, ::-1], mode='same') |
| ov = fftconvolve(ob.astype(float), oa[::-1, ::-1].astype(float), mode='same') |
| cc = cc / np.maximum(ov, 0.05 * ov.max()) |
| cy, cx = np.array(cc.shape) // 2 |
| r = int(search / cell) |
| win = cc[cy-r:cy+r+1, cx-r:cx+r+1] |
| py, px = np.unravel_index(np.argmax(win), win.shape) |
| return (px - r) * cell, (py - r) * cell |
|
|
| def level(P): |
| G = ground_points(P) |
| n, d, frac = ransac_plane(G) |
| R = rot_to_z(n) |
| p0 = np.array([0.0, 0.0, -d / n[2]]) |
| Q = (P - p0) @ R.T |
| tilt = np.degrees(np.arccos(np.clip(n[2], -1, 1))) |
| return Q, R, tilt, 0.0, frac |
|
|
| def main(f23, f25, out, tag='', pre=None, clip=False): |
| """pre=(yaw_deg, [tx, ty]): 2D rigid transform p_map = Rot(yaw).p_loop + t linking the loop frame to the map frame; |
| the 2025 crop is first brought into the 2023 map frame with its inverse. clip=True keeps only 2025 points inside the |
| XY bounding box of the aligned 2023 crop, so both clouds cover the same footprint.""" |
| t0 = time.time() |
| A = load(f23); B = load(f25) |
| if pre is not None: |
| yaw, tt = pre; c, s = np.cos(np.radians(yaw)), np.sin(np.radians(yaw)) |
| Rz = np.array([[c, -s], [s, c]]) |
| B[:, :2] = (B[:, :2] - np.asarray(tt)) @ Rz |
| ctr = (np.r_[A[:, :2].min(0), 0] + np.r_[A[:, :2].max(0), 0]) / 2 |
| A = A - ctr; B = B - ctr |
| Bl, RB, tiltB, gzB, fracB = level(B); Bl[:, 2] -= gzB |
| Al, RA, tiltA, gzA, fracA = level(A); Al[:, 2] -= gzA |
| |
| cB = np.r_[(Al[:, :2].min(0) + Al[:, :2].max(0)) / 2, 0] |
| Bl -= cB; Al -= cB |
| dx, dy = coarse_xy(Al, Bl) |
| Al = Al + np.array([dx, dy, 0.0]) |
| R, t = np.eye(3), np.zeros(3); nit = 0 |
| for md in (4.0, 2.0, 1.0, 0.5): |
| Ri, ti, med, p90, ni = icp(Al @ R.T + t, Bl, iters=30, max_d=md) |
| R, t = Ri @ R, Ri @ t + ti; nit += ni |
| t = t + R @ np.array([dx, dy, 0.0]) |
| Al = Al - np.array([dx, dy, 0.0]) |
| Af = Al @ R.T + t |
| yaw = np.degrees(np.arctan2(R[1, 0], R[0, 0])) |
| rot = np.degrees(np.arccos(np.clip((np.trace(R) - 1) / 2, -1, 1))) |
| n_b_raw = len(B) |
| if clip: |
| lo, hi = Af[:, :2].min(0), Af[:, :2].max(0) |
| keep = (Bl[:, 0] >= lo[0]) & (Bl[:, 0] <= hi[0]) & (Bl[:, 1] >= lo[1]) & (Bl[:, 1] <= hi[1]) |
| Bl = Bl[keep] |
| |
| d_ba, _ = cKDTree(Af).query(Bl[np.random.default_rng(1).choice(len(Bl), min(200000, len(Bl)), replace=False)], workers=-1) |
| os.makedirs(out, exist_ok=True) |
| cm = [f'Subiaco change-detection pair {tag}'.strip(), 'Generated 2026-09-27 by align.py (level by RANSAC ground plane, XY-centre, trimmed ICP 2023->2025)'] |
| write_ply(os.path.join(out, '2023.ply'), Af, cm + [f'source {os.path.basename(f23)}']) |
| write_ply(os.path.join(out, '2025.ply'), Bl, cm + [f'source {os.path.basename(f25)}']) |
| info = {'tag': tag, 'src2023': os.path.basename(f23), 'src2025': os.path.basename(f25), |
| 'n2023': int(len(A)), 'n2025': int(len(Bl)), 'n2025_raw_crop': int(n_b_raw), 'clipped_to_2023_footprint': bool(clip), |
| 'pre_transform_loop_to_map': None if pre is None else {'yaw_deg': float(pre[0]), 't': [float(v) for v in pre[1]]}, |
| 'xy_centre_raw': ctr[:2].round(3).tolist(), |
| 'tilt2023_deg': round(float(tiltA), 3), 'tilt2025_deg': round(float(tiltB), 3), |
| 'ground_inlier_frac_2023': round(float(fracA), 3), 'ground_inlier_frac_2025': round(float(fracB), 3), |
| 'icp_rot_deg': round(float(rot), 3), 'icp_yaw_deg': round(float(yaw), 3), 'icp_t': t.round(3).tolist(), 'icp_iters': nit, 'coarse_xy_shift': [round(float(dx),2), round(float(dy),2)], |
| 'nn_median_2023to2025_m': round(med, 3), 'nn_p90_2023to2025_m': round(p90, 3), |
| 'nn_median_2025to2023_m': round(float(np.median(d_ba)), 3), 'nn_p90_2025to2023_m': round(float(np.percentile(d_ba, 90)), 3), |
| 'bbox2023': [Af.min(0).round(2).tolist(), Af.max(0).round(2).tolist()], |
| 'bbox2025': [Bl.min(0).round(2).tolist(), Bl.max(0).round(2).tolist()], 'seconds': round(time.time() - t0, 1)} |
| json.dump(info, open(os.path.join(out, 'alignment.json'), 'w'), indent=1) |
| print(json.dumps(info), flush=True) |
| return info |
|
|
| if __name__ == '__main__': |
| main(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4] if len(sys.argv) > 4 else '') |
|
|
