When several robots or headsets share one wireless cell and each must align its 3D scan to a map held on an edge server, the radio scheduler decides who gets bandwidth. It usually decides by channel quality. This proposal argues that for 3D alignment, channel quality is the wrong currency. The right one is how much each device's transmitted points would pin down the pose directions that are still uncertain. A device in a featureless corridor whose scan cannot fix motion along the corridor axis needs a few well-chosen points far more than a device in a cluttered room with an excellent channel. We propose to jointly choose which geometric points each device sends (a discrete choice) and how much bandwidth and power each device gets (continuous choices), with a deadline that covers both the upload time and the edge server's global alignment search.
The two halves of the problem come from fields that rarely meet. 3D registration, meaning finding the rotation and translation that best align two point clouds, is a non-convex six-dimensional search. Exact global solvers prune it with branch-and-bound, but their runtime grows with the number and cleanliness of the points they receive. Wireless joint resource allocation mixes discrete and continuous decisions into mixed-integer nonlinear programs, and the usual remedies are decomposition and learned pruning. Our claim is that coupling the two changes the answer in a specific, testable regime: several devices with geometrically degenerate views share a tight uplink. In that regime, giving spectrum to devices by geometric information should cut worst-case pose error relative to channel-driven scheduling followed by per-device point selection. Outside that regime, the decoupled pipeline should be nearly as good, and we will show that as well.
Core Claim and Formulation
Consider $K$ devices. Each device $k$ holds candidate points or local features $\mathcal{V}_k$, each with a size in bits $c_i$ and a $6\times 6$ information contribution $J_i$ to its pose estimate. For a point-to-plane residual, $J_i$ is the outer product of the residual's Jacobian with respect to the pose. The scheduler picks subsets $S_k \subseteq \mathcal{V}_k$, bandwidth $b_k$ and power $p_k$, and maximizes the worst device's pose certainty:
$$\max_{S,b,p}\ \min_k \ \log\det\Big(\Lambda_k + \sum_{i\in S_k} J_i\Big) \quad \text{s.t.}\quad \frac{\sum_{i\in S_k} c_i}{r_k(b_k,p_k)} + T_{\text{search}}\big(|S_k|,\rho_k\big) \le D,\ \ \sum_k b_k \le B,\ \ p_k\le P_{\max}.$$
Here $\Lambda_k$ is the prior information from odometry, $r_k(b_k,p_k)=b_k\log_2(1+p_k g_k/(b_k N_0))$ is the Shannon rate on an orthogonal share of spectrum with channel gain $g_k$ and noise density $N_0$, and $D$ is the deadline. $T_{\text{search}}$ is the edge server's global registration time. It depends on the number of points sent and on their estimated inlier ratio $\rho_k$, and we will measure it offline rather than assume a form. The log-determinant is the D-optimality criterion used for keyframe selection in AdaptSLAM. The search-time term is what brings the high-dimensional search problem into the allocation. Sending more points improves conditioning, but it also lengthens the branch-and-bound search and, if the points are indistinct, lowers the inlier ratio. The robust global solver of RPM-HTB is known to degrade in exactly that case, when outliers are mixed in with the true matches.
The problem decomposes in a convenient way. If the selections are fixed, each device's upload time is a convex function of its bandwidth and power. The continuous subproblem is then convex, mirroring the structure that Lin et al. exploit for AI service placement, where any fixed binary placement leaves a strictly convex resource problem. If the allocations are fixed, each device faces a knapsack-constrained log-determinant maximization. That objective is submodular, so cost-benefit greedy selection with rank-one Sherman-Morrison updates applies, as in AdaptSLAM. We alternate the two steps and add one coupling move. We compute each device's marginal log-det gain per hertz and use it as a price that moves bandwidth between devices. This price is the quantity a channel-only scheduler cannot see.
Relation to Prior Work
Three papers motivate this design, and each stops short of it in a different way. AdaptSLAM chooses whole keyframes for one device under a bandwidth budget it does not control. We work at the level of individual points, across several devices, and treat bandwidth and power as decision variables. The ISCC partitioning work of Liu et al. jointly optimizes discrete network split points with beamforming and CPU allocation, but its sensing payload is an abstract neural network tensor with no geometric objective. Our payload is valued by what it constrains in $SE(3)$. Yu et al. show that solving radio and compute allocation jointly rather than in silos can double energy savings. That result supports joint optimization in general, though it says nothing about geometric payloads.
A second group supplies the method or the oracle. Learned branch-and-bound pruning for joint discrete-continuous wireless problems (MINIMAL; the DAgger-based Cloud-RAN pruner) speeds up exact solvers by learning which tree nodes to discard. We use exact branch-and-bound only as a small-instance oracle that measures our alternating method's optimality gap; learned pruning is not our contribution. On the geometric side, Go-ICP and the translation-first search of GoTS are the edge server's registration engines, and we profile them to build $T_{\text{search}}$. GoTS matters for another reason too. Its rotation-invariant features make a descriptor's distinctiveness, and therefore its expected inlier contribution, computable on the device before upload.
One paper constrains the design. SlicePilot shows that a learned multi-agent scheduler cuts decision time but raises QoS violations 2.42x under heavy load. Deadline-critical allocation therefore argues for a structured optimizer with an explicit feasibility check rather than a learned policy.
Research Program
The work has three parts. The first is building the edge-side cost model. We will run Go-ICP and a GoTS-style solver on point subsets of varying size and inlier ratio drawn from 3DMatch fragments, and fit $T_{\text{search}}$ and the success rate as empirical functions. This also tells us whether the deadline ever binds through search time or only through upload time, and that is a finding in its own right. The second part is the allocator: the alternating convex/greedy scheme with the information-per-hertz price, plus a feasibility check that falls back to the best deadline-meeting solution found so far. The third part is a regime map. We will vary the number of devices, the total bandwidth, the spread of channel gains, and the degree of geometric degeneracy, measured as the condition number of each device's full information matrix. The goal is to chart where joint allocation pays off and where it does not.
Baselines
The naive reference is uniform random downsampling of each device's cloud to whatever fits an equal bandwidth share, followed by global registration at the edge. It shows the cost of ignoring both geometry and channels.
The strongest decoupled competitor allocates bandwidth and power by water-filling on channel gains alone. Each device then runs AdaptSLAM-style greedy log-det selection, at point granularity, within its own budget. This is the baseline a careful systems engineer would build. It uses the same selection machinery as our method, so any gap isolates the effect of letting geometry drive the spectrum. A keyframe-level variant reproduces AdaptSLAM's original granularity. For context on AdaptSLAM itself, the file reports a 62% reduction in RMS absolute trajectory error relative to ORBBuf on EuRoC MAV and TUM VI, accuracy within 0.05 m of full local SLAM, and about 162 ms selection latency (AdaptSLAM). For the multi-device 3DMatch setting there is no reported result found on Lacuna for any of these methods, so all numbers there will be produced by us under identical conditions.
The oracle is exact branch-and-bound over the joint problem on small instances (two to four devices, discretized bandwidth). It gives the true optimum, against which we report our optimality gap. The file's reference points for gaps from learned-pruning solvers on wireless problems are below 0.6% for the Cloud-RAN pruner and below 3% for MINIMAL. Our alternating scheme should land in that range to count as near-optimal.
Two ablations isolate the key ingredients. The first removes the $T_{\text{search}}$ term, keeping only the upload deadline. The second replaces the max-min objective with a sum, which lets well-conditioned devices absorb resources.
All methods see the same point clouds, the same simulated channels, the same deadline and the same registration engine. Any method with parameters gets the same tuning grid on held-out scenes. We count our method as beating the decoupled baseline only if it lowers 95th-percentile rotation and translation error, or raises the fraction of devices registered within threshold before the deadline. The comparison must hold across seeds at matched total bandwidth, with selection latency no worse than the baseline's order of magnitude.
Why not just…?
Why not just water-fill on channels and let each device pick its best points? This is the real threat, and we expect it to win or tie whenever devices see similarly well-conditioned scenes, since the geometric price then roughly matches the channel ranking. The joint method can only help when a device's need for information and its channel quality disagree, such as a corridor device on a weak link next to a rich-scene device on a strong one. The regime map is designed to measure this directly. If the gap stays negligible even in high-degeneracy, low-bandwidth cells, we will report that joint allocation is unnecessary for this task.
Why not just send compressed full scans and run local ICP? Local solvers fall into wrong minima under poor initialization and partial overlap, as Go-ICP and RPM-HTB document. Even ignoring that, the full-scan baseline cannot meet the deadline once bandwidth is shared. We include it at relaxed deadlines to show where it breaks.
Why not just train a reinforcement-learning scheduler end to end? It would be fast. But SlicePilot reports a 2.42x rise in QoS violations under load for exactly this kind of learned allocator, and deadline misses are the failure we care about. We report deadline-miss rates under overload to make this comparison explicit rather than assumed.
Why not just call an exact mixed-integer solver? Exact branch-and-bound on these problems runs far slower than learned or structured alternatives: more than 20x in the Cloud-RAN study, and about 100 s for SpiderMatch's 1,000-triangle instances. We use it only as the small-instance oracle.
Proposed Experiments
The primary testbed is multi-device registration built from 3DMatch. Each simulated device holds one fragment and must register it to a scene map at the edge, over Rayleigh-fading orthogonal uplinks of the kind used in the synthetic Cloud-RAN studies. Degeneracy is controlled by selecting fragments by the condition number of their full information matrix. The second testbed is EuRoC MAV and TUM VI, with sequences assigned to concurrent virtual agents. There the metric is absolute trajectory error under a shared bandwidth cap, swept down to and below the 40 Mbps level at which AdaptSLAM reports heuristic buffers failing. Metrics are rotation and translation error percentiles, registration success before the deadline, worst-agent error, allocator latency, and optimality gap against the oracle.
The decisive check is a two-dimensional sweep over degeneracy spread and bandwidth per device. The hypothesis predicts a gain over decoupled water-filling plus greedy selection that rises with degeneracy spread and with bandwidth scarcity, and vanishes when either is small. A flat or reversed surface would refute the claim. A second check asks whether removing the search-time term changes outcomes at realistic deadlines. If it does not, the high-dimensional search cost is not a binding resource here, and the proposal reduces to geometry-aware spectrum sharing. That would be a narrower but still useful result.
References
- AdaptSLAM: Edge-Assisted Adaptive SLAM with Resource Constraints via Uncertainty Minimization
- Hybrid Trilinear and Bilinear Programming for Aligning Partially Overlapping Point Sets
- Optimizing AI Service Placement and Resource Allocation in Mobile Edge Intelligence Systems
- Toward Intelligent Edge Sensing for ISCC Network: Joint Multi-Tier DNN Partitioning and Beamforming Design
- Joint Subcarrier and CPU Time Allocation for Mobile Edge Computing
- Optimal Solutions for Joint Beamforming and Antenna Selection: From Branch and Bound to Graph Neural Imitation Learning
- Scalable Network Adaptation for Cloud-Rans: An Imitation Learning Approach
- Go-ICP: Solving 3D Registration Efficiently and Globally Optimally
- Efficient Global Point Cloud Registration by Matching Rotation Invariant Features Through Translation Search
- SlicePilot: Demystifying Network Slice Placement in Heterogeneous Cloud Infrastructures
- SpiderMatch: 3D Shape Matching with Global Optimality and Geometric Consistency