Add radio tomography: online static RF-attenuation map per floor

Reconstructs where the radio sees something solid (walls, appliances, the
refrigerator) from the node-to-node links already streaming in — no acquisition
step, no ground truth. Each link's excess path loss beyond free space is treated
as a line integral through an unknown attenuation field; many crisscrossing links
let us invert (non-negative ridge) for the per-cell attenuation. A per-link
decaying-max strips out transient people so the map captures static structure.

- RadioTomographyService (BackgroundService): every 30s, per floor, builds the
  link set from State, rasterizes each ray into a grid, solves ridge, exposes the
  latest per-floor grids (attenuation + coverage).
- GET /api/tomography returns the grids.
- Calibration page gains an "Obstructions" tab: a heatmap overlay on the floor
  plan (Turbo colormap, faded where link coverage is low) so a human can validate
  it by eye — "that hot blob is my fridge."

Purpose is twofold: (1) visual validation that the model is learning real physics
(recognizable structure can't be faked the way a scalar accuracy number can), and
(2) groundwork for obstruction-aware locating (down-weighting nodes whose path to
a candidate crosses a known blocker).

Verified live: hottest first-floor cell lands on the kitchen node where the
refrigerator (a Faraday cage) actually is.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: DTTerastar

src/Controllers/TomographyController.cs

@@ -0,0 +1,14 @@
+using ESPresense.Models;
+using ESPresense.Services;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ESPresense.Controllers;
+
+[Route("api/tomography")]
+[ApiController]
+public class TomographyController(RadioTomographyService tomography) : ControllerBase
+{
+    /// <summary>Latest reconstructed per-floor static RF-attenuation map.</summary>
+    [HttpGet]
+    public TomographyResult Get() => tomography.Latest;
+}

src/Models/Tomography.cs

@@ -0,0 +1,34 @@
+namespace ESPresense.Models;
+
+/// <summary>
+/// A reconstructed static RF-attenuation field for one floor: a grid of "extra path loss beyond
+/// free space" inferred from the node-to-node links that cross each cell. High-attenuation cells
+/// are where the radio sees something solid (walls, appliances, a refrigerator).
+/// </summary>
+public class TomographyFloor
+{
+    public string? FloorId { get; set; }
+    public string? FloorName { get; set; }
+
+    // Grid origin (metres) and geometry.
+    public double MinX { get; set; }
+    public double MinY { get; set; }
+    public double CellSize { get; set; }
+    public int Cols { get; set; }
+    public int Rows { get; set; }
+
+    /// <summary>Row-major (row * Cols + col) attenuation in dB per metre, clamped to >= 0.</summary>
+    public double[] Attenuation { get; set; } = System.Array.Empty<double>();
+
+    /// <summary>Row-major ray coverage per cell (total link length through the cell). Low = unreliable.</summary>
+    public double[] Coverage { get; set; } = System.Array.Empty<double>();
+
+    public int Links { get; set; }
+    public double MaxAttenuation { get; set; }
+}
+
+public class TomographyResult
+{
+    public System.DateTime Updated { get; set; }
+    public System.Collections.Generic.List<TomographyFloor> Floors { get; set; } = new();
+}

src/Program.cs

@@ -75,9 +75,11 @@
 builder.Services.AddSingleton<FirmwareUpdateJobService>();
 builder.Services.AddSingleton<DeviceService>();
 builder.Services.AddSingleton<DeviceCaptureService>();
+builder.Services.AddSingleton<RadioTomographyService>();
 builder.Services.AddSingleton<LeaseService>();
 builder.Services.AddSingleton<ILeaseService>(provider => provider.GetRequiredService<LeaseService>());
 
+builder.Services.AddHostedService(provider => provider.GetRequiredService<RadioTomographyService>());
 builder.Services.AddHostedService<MultiScenarioLocator>();
 builder.Services.AddHostedService<OptimizationRunner>();
 builder.Services.AddHostedService(provider => provider.GetRequiredService<DeviceTracker>());

src/Services/RadioTomographyService.cs

@@ -0,0 +1,194 @@
+using ESPresense.Models;
+using MathNet.Numerics.LinearAlgebra;
+using Microsoft.Extensions.Hosting;
+using Serilog;
+
+namespace ESPresense.Services;
+
+/// <summary>
+/// Continuously reconstructs a static RF-attenuation map per floor from the node-to-node links that
+/// are already streaming in. Each link's "excess path loss beyond free space" is treated as a line
+/// integral through an unknown attenuation field; many crisscrossing links let us invert for where
+/// the attenuation actually sits (walls, appliances, the refrigerator). Runs online, no acquisition
+/// step — the result is exposed for the calibration-page heatmap so a human can eyeball it ("that
+/// rectangle is my fridge") and, later, fed into the locator to down-weight blocked paths.
+/// </summary>
+public class RadioTomographyService : BackgroundService
+{
+    private readonly State _state;
+
+    // Tunables (kept conservative for a first cut).
+    private const double FreeSpaceExponent = 2.0;  // n in rssi = ref - 10*n*log10(d)
+    private const double CellSizeMeters = 1.0;
+    private const int MaxCells = 1200;             // bound the inverse-problem size
+    private const int MinLinksPerFloor = 6;
+    private const double Regularization = 0.15;    // ridge strength, relative to data scale
+    private const double DecayDbPerCycle = 1.0;    // how fast the per-link "clean" peak forgets
+    private static readonly TimeSpan Interval = TimeSpan.FromSeconds(30);
+
+    // Per-link rolling "clean" (least-shadowed) RSSI, keyed "tx|rx". The decaying max strips out
+    // transient people walking through a link while keeping the persistent static structure.
+    private readonly Dictionary<string, double> _cleanRssi = new();
+
+    public TomographyResult Latest { get; private set; } = new();
+
+    public RadioTomographyService(State state)
+    {
+        _state = state;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                Latest = Compute();
+            }
+            catch (Exception ex)
+            {
+                Log.Warning(ex, "Radio tomography compute failed");
+            }
+            await Task.Delay(Interval, stoppingToken);
+        }
+    }
+
+    private TomographyResult Compute()
+    {
+        var result = new TomographyResult { Updated = DateTime.UtcNow };
+
+        foreach (var floor in _state.Floors.Values)
+        {
+            if (floor.Bounds is not { Length: 2 }) continue;
+            var tf = ComputeFloor(floor);
+            if (tf != null) result.Floors.Add(tf);
+        }
+
+        return result;
+    }
+
+    private TomographyFloor? ComputeFloor(Floor floor)
+    {
+        double minX = Math.Min(floor.Bounds![0].X, floor.Bounds[1].X);
+        double minY = Math.Min(floor.Bounds[0].Y, floor.Bounds[1].Y);
+        double maxX = Math.Max(floor.Bounds[0].X, floor.Bounds[1].X);
+        double maxY = Math.Max(floor.Bounds[0].Y, floor.Bounds[1].Y);
+        double w = maxX - minX, h = maxY - minY;
+        if (w <= 0 || h <= 0) return null;
+
+        // Pick a cell size that keeps the grid under the size cap.
+        double cell = CellSizeMeters;
+        while (Math.Ceiling(w / cell) * Math.Ceiling(h / cell) > MaxCells) cell *= 1.5;
+        int cols = (int)Math.Ceiling(w / cell);
+        int rows = (int)Math.Ceiling(h / cell);
+        int cellCount = cols * rows;
+
+        bool OnFloor(Node n) => n.HasLocation && (n.Floors?.Any(f => f.Id == floor.Id) ?? false);
+
+        // Gather links between nodes on this floor.
+        var rows_W = new List<double[]>();
+        var ys = new List<double>();
+        var coverage = new double[cellCount];
+
+        foreach (var tx in _state.Nodes.Values)
+        {
+            if (!OnFloor(tx)) continue;
+            foreach (var meas in tx.RxNodes.Values)
+            {
+                var rx = meas.Rx;
+                if (rx == null || !OnFloor(rx) || !meas.Current || meas.Rssi == 0) continue;
+
+                double d = Math.Sqrt(Math.Pow(tx.Location.X - rx.Location.X, 2) + Math.Pow(tx.Location.Y - rx.Location.Y, 2));
+                if (d < 0.5) continue;
+
+                double clean = UpdateClean($"{tx.Id}|{rx.Id}", meas.Rssi);
+                double freeExpected = meas.RefRssi - 10.0 * FreeSpaceExponent * Math.Log10(d);
+                double excess = freeExpected - clean;     // dB of loss beyond free space
+                if (excess < 0) excess = 0;               // can't be "less than free space" (ignore rare constructive multipath)
+
+                var rowW = new double[cellCount];
+                RasterizeRay(tx.Location.X, tx.Location.Y, rx.Location.X, rx.Location.Y, minX, minY, cell, cols, rows, rowW);
+                double rayLen = rowW.Sum();
+                if (rayLen <= 0) continue;
+
+                for (int c = 0; c < cellCount; c++) coverage[c] += rowW[c];
+                rows_W.Add(rowW);
+                ys.Add(excess);
+            }
+        }
+
+        if (rows_W.Count < MinLinksPerFloor) return null;
+
+        var attenuation = SolveRidge(rows_W, ys, cellCount);
+
+        var tf = new TomographyFloor
+        {
+            FloorId = floor.Id,
+            FloorName = floor.Name,
+            MinX = minX,
+            MinY = minY,
+            CellSize = cell,
+            Cols = cols,
+            Rows = rows,
+            Attenuation = attenuation,
+            Coverage = coverage,
+            Links = rows_W.Count,
+            MaxAttenuation = attenuation.Length > 0 ? attenuation.Max() : 0
+        };
+        return tf;
+    }
+
+    private double UpdateClean(string key, double rssi)
+    {
+        if (_cleanRssi.TryGetValue(key, out var prev))
+        {
+            double clean = Math.Max(rssi, prev - DecayDbPerCycle);
+            _cleanRssi[key] = clean;
+            return clean;
+        }
+        _cleanRssi[key] = rssi;
+        return rssi;
+    }
+
+    /// <summary>Accumulate per-cell path length for the segment by fine sampling.</summary>
+    private static void RasterizeRay(double x0, double y0, double x1, double y1,
+        double minX, double minY, double cell, int cols, int rows, double[] rowW)
+    {
+        double dx = x1 - x0, dy = y1 - y0;
+        double len = Math.Sqrt(dx * dx + dy * dy);
+        if (len <= 0) return;
+        int steps = Math.Max(1, (int)Math.Ceiling(len / (cell * 0.25)));
+        double stepLen = len / steps;
+        for (int s = 0; s < steps; s++)
+        {
+            double t = (s + 0.5) / steps;
+            double px = x0 + dx * t, py = y0 + dy * t;
+            int col = (int)((px - minX) / cell);
+            int row = (int)((py - minY) / cell);
+            if (col < 0 || col >= cols || row < 0 || row >= rows) continue;
+            rowW[row * cols + col] += stepLen;
+        }
+    }
+
+    /// <summary>Non-negative ridge regression: min ||Wx - y||^2 + λ||x||^2, then clamp x >= 0.</summary>
+    private static double[] SolveRidge(List<double[]> rowsW, List<double> ys, int cellCount)
+    {
+        int L = rowsW.Count;
+        var W = Matrix<double>.Build.Dense(L, cellCount, (i, j) => rowsW[i][j]);
+        var y = Vector<double>.Build.Dense(L, i => ys[i]);
+
+        var wtw = W.TransposeThisAndMultiply(W);          // C x C, SPD after ridge
+        double meanDiag = 0;
+        for (int i = 0; i < cellCount; i++) meanDiag += wtw[i, i];
+        meanDiag = cellCount > 0 ? meanDiag / cellCount : 1.0;
+        double lambda = Regularization * meanDiag + 1e-9;
+        for (int i = 0; i < cellCount; i++) wtw[i, i] += lambda;
+
+        var wty = W.TransposeThisAndMultiply(y);
+        var x = wtw.Cholesky().Solve(wty);
+
+        var result = new double[cellCount];
+        for (int i = 0; i < cellCount; i++) result[i] = Math.Max(0, x[i]);
+        return result;
+    }
+}

src/ui/src/lib/CalibrationTabs.svelte

@@ -15,6 +15,9 @@
 				<button class="px-4 py-1 rounded-full text-sm font-medium transition-colors {calibrationType === 'device' ? 'bg-emerald-400 text-black' : 'text-white hover:bg-slate-500'}" onclick={() => (calibrationType = 'device')}>
 					Devices
 				</button>
+				<button class="px-4 py-1 rounded-full text-sm font-medium transition-colors {calibrationType === 'obstructions' ? 'bg-emerald-400 text-black' : 'text-white hover:bg-slate-500'}" onclick={() => (calibrationType = 'obstructions')}>
+					Obstructions
+				</button>
 			</div>
 		</div>
 	</nav>

src/ui/src/lib/Map.svelte

@@ -14,6 +14,9 @@
 	import AxisY from './AxisY.svelte';
 	import MapCoordinates from './MapCoordinates.svelte';
 	import CalibrationSpot from './CalibrationSpot.svelte';
+	import Tomography from './Tomography.svelte';
+	import { onDestroy } from 'svelte';
+	import type { TomographyResult, TomographyFloor } from '$lib/types';
 
 	let svg: Element;
 	let transform = zoomIdentity;
@@ -24,8 +27,35 @@
 	export let exclusive: boolean = false;
 	export let calibrate: boolean = false;
 	export let calibrationSpot: { x: number; y: number } | null = null;
+	export let showTomography: boolean = false;
 	export let onselected: ((item: Device | Node) => void) | undefined = undefined;
 
+	let tomography: TomographyResult | null = null;
+	let tomoTimer: ReturnType<typeof setInterval> | null = null;
+
+	async function fetchTomography() {
+		try {
+			const r = await fetch('/api/tomography');
+			if (r.ok) tomography = await r.json();
+		} catch {
+			/* transient; keep last */
+		}
+	}
+
+	$: if (showTomography && !tomoTimer) {
+		fetchTomography();
+		tomoTimer = setInterval(fetchTomography, 15000);
+	}
+	$: if (!showTomography && tomoTimer) {
+		clearInterval(tomoTimer);
+		tomoTimer = null;
+	}
+	onDestroy(() => {
+		if (tomoTimer) clearInterval(tomoTimer);
+	});
+
+	$: tomoFloor = (showTomography && tomography?.floors?.find((f) => f.floorId === floorId)) || null;
+
 	$: floor = $config?.floors.find((f) => f.id === floorId) ?? $config?.floors.find((f) => f != null);
 	$: bounds = floor?.bounds;
 	$: squareBounds = bounds ? makeSquareBounds(bounds) : undefined;
@@ -141,6 +171,9 @@
 			<AxisX {transform} />
 			<AxisY {transform} />
 			<Rooms {transform} {floorId} />
+			{#if showTomography}
+				<Tomography {transform} tomo={tomoFloor} />
+			{/if}
 			<Nodes {transform} {floorId} {deviceId} {nodeId} onselected={selectedNode} onhovered={hoveredNode} />
 			<Devices {transform} {floorId} {deviceId} {exclusive} onselected={selectedDevice} onhovered={hoveredDevice} />
 			{#if calibrate && calibrationSpot}

src/ui/src/lib/Tomography.svelte

@@ -0,0 +1,71 @@
+<script lang="ts">
+	import { getContext } from 'svelte';
+	import { zoomIdentity } from 'd3-zoom';
+	import { interpolateTurbo } from 'd3';
+	import type { LayerCakeContext, TomographyFloor } from '$lib/types';
+
+	const { xScale, yScale } = getContext<LayerCakeContext>('LayerCake');
+
+	export let tomo: TomographyFloor | null = null;
+	export let transform = zoomIdentity;
+	export let opacity = 0.65;
+
+	interface Cell {
+		x: number;
+		y: number;
+		w: number;
+		h: number;
+		fill: string;
+		a: number;
+	}
+
+	// Project a cell (in metres) to screen-space, handling axis flips.
+	function rect(cx: number, cy: number, size: number) {
+		const sx0 = $xScale(cx),
+			sx1 = $xScale(cx + size);
+		const sy0 = $yScale(cy),
+			sy1 = $yScale(cy + size);
+		return {
+			x: Math.min(sx0, sx1),
+			y: Math.min(sy0, sy1),
+			w: Math.abs(sx1 - sx0),
+			h: Math.abs(sy1 - sy0)
+		};
+	}
+
+	$: maxAtt = tomo?.maxAttenuation && tomo.maxAttenuation > 0 ? tomo.maxAttenuation : 1;
+	$: maxCov = tomo ? Math.max(1, ...tomo.coverage) : 1;
+
+	$: cells = (() => {
+		if (!tomo) return [] as Cell[];
+		const out: Cell[] = [];
+		for (let row = 0; row < tomo.rows; row++) {
+			for (let col = 0; col < tomo.cols; col++) {
+				const idx = row * tomo.cols + col;
+				const att = tomo.attenuation[idx] ?? 0;
+				const cov = tomo.coverage[idx] ?? 0;
+				if (att <= 0.05 || cov <= 0) continue;
+				const cx = tomo.minX + col * tomo.cellSize;
+				const cy = tomo.minY + row * tomo.cellSize;
+				const intensity = Math.min(1, att / maxAtt);
+				// Fade cells that few links cross — low confidence, not "nothing there".
+				const conf = Math.min(1, cov / (0.25 * maxCov));
+				const r = rect(cx, cy, tomo.cellSize);
+				out.push({
+					...r,
+					fill: interpolateTurbo(0.15 + 0.85 * intensity),
+					a: intensity * conf
+				});
+			}
+		}
+		return out;
+	})();
+</script>
+
+{#if tomo}
+	<g transform={transform.toString()} pointer-events="none">
+		{#each cells as c}
+			<rect x={c.x} y={c.y} width={c.w} height={c.h} fill={c.fill} fill-opacity={c.a * opacity} />
+		{/each}
+	</g>
+{/if}