Seam Repair: Tiled Oriented Detection Without Overlap

Satellite and drone images are often 4000×4000 pixels or larger, far too big to push through a detector in one piece during training. The standard fix is to cut each image into overlapping tiles, detect objects in each tile separately, and merge the boxes afterward. The fix has two costs. Every pixel in an overlap margin is processed more than once. And long, thin, tilted objects such as ships, bridges and airliners still get cut in half, because a diagonal 300-meter vessel can be longer than any sensible overlap.

We propose to cut the image into tiles with no overlap at all. Each tile's backbone features are stitched into one global feature map. A small learned module then repairs only the narrow strips of features along the seams, trained so that the stitched map matches what full-image inference would have produced. Because detection then runs on a single seamless feature map, a tilted box can span a seam and no cross-tile box merging is needed. Once seams are repaired locally, empty tiles such as open ocean can skip the backbone entirely, and the remaining work breaks into small independent jobs that a GPU can run concurrently.

Core Claim

Seam damage in tiled oriented detection is mainly a feature problem, not a box-merging problem. Near a tile edge, the backbone pads with zeros where real image content should be, so objects crossing the edge are described by corrupted features in both tiles. If that is true, repairing a thin feature strip around each seam should recover most of the accuracy of full-image inference on seam-crossing objects. It should do so at lower compute than the standard overlapping pipeline and lower peak memory than whole-image inference. The same repair should also make it safe to skip empty tiles, which is how visual-token redundancy enters.

The directions in this note carry different weights. Patch boundary artifacts and oriented detection are the core problem. Visual-token redundancy supplies the compute saving. Concurrent stream multiplexing is the execution regime. Seam repair creates a dependency structure in which each strip needs only its two neighboring tiles, and that structure is what lets the work be multiplexed efficiently.

Relation to Prior Work

Two papers define the pipeline this proposal replaces. DOTA established the practice of cutting aerial scenes into 1024×1024 crops with stride 824 and a 200-pixel overlap. That covers each pixel about $(1024/824)^2 \approx 1.54$ times on average, and it relies on post-hoc merging for objects that cross crops. The Power of Tiling for Small Object Detection showed that tiling is necessary for small targets: on VisDrone2018, tiling raised mAP from 11% to 36%. It used 25% overlap and overlap non-maximum suppression (NMS, the step that deletes duplicate boxes) with horizontal boxes only. Both papers motivate our work, because they document the overlap tax and the reliance on merging heuristics. Neither exchanges any information between tiles at the feature level, which is the step we add.

Three oriented detectors supply the detection machinery we reuse unchanged. Oriented R-CNN is a two-stage detector that describes rotated proposals by offsets from horizontal anchors. RoI Transformer learns to turn horizontal regions into rotated ones and then extracts features aligned to the rotation. Rethinking Boundary Discontinuity fixes a different "boundary": the jump in angle labels between 0 and π, via an Angle Correct Module (ACM). It raised the KFIoU detector's AP75 on HRSC2016 from 62.95% to 87.77%. That fix operates in angle space, while ours operates in image space, so the two are complementary. We keep the ACM as a fixed component rather than a competitor.

All of these detectors assume the whole object lies inside the input they see. Our stitched feature map makes that assumption true again. Rotated feature extraction, the step that pools features from inside a tilted box, can then run across a seam. Rotation-Sensitive Regression and Shape-Aware Dynamic Alignment Network constrain the design. They show that slender rotated objects are very sensitive to polluted or misaligned features, which is why a repair that leaves seam features merely "plausible" will not be enough. The repair is trained to match full-image features, not just to fool the detector.

On the redundancy side, the relevant precedent is upstream skipping rather than pruning after encoding. CARES uses a small proxy model to choose the input resolution before tokenization. It cut prefill compute by 70–80% with under 1% accuracy loss, and it names joint resolution-and-tiling selection as open. CROP keeps tokens inside a single question-guided horizontal box. FEATHER shows that unguided pruning develops spatial biases that hurt localization. These results support skipping at the tile level before the backbone runs. They also warn that a skip decision made carelessly at a tile border will erase the halves of objects that cross into a skipped tile. Seam repair is meant to handle exactly that case.

We also note CARES's caveat that small proxy models miss tiny targets. Our skip decision is therefore made conservatively and audited by recall.

On execution, SpaceServe divides a GPU's compute units between vision encoders and language decoders and uses a static cost model. It reduced time per output token by 4.81× on average but had negligible effect on time to first output. Our workload is different: content-dependent and uneven across tiles. FlowLoader supplies the scheduling pattern we borrow for spatial tiles instead of weight chunks: out-of-order delivery of chunks with fixed addresses, plus idle workers stealing tasks. We do not claim a new systems primitive. We claim that a local dependency structure among tiles makes ordinary concurrent GPU streams, the independent work queues a GPU can run in parallel, sufficient.

Research Program

The model has four parts. First, a zero-overlap grid of tiles is encoded independently by a standard backbone with a feature pyramid (ResNet-50), and the per-tile outputs are placed into one global feature map at each pyramid level.

Second, along every seam, a seam-repair module reads a strip of width $2r$ feature cells from the two adjacent tiles and writes corrected features back into the same strip. The module is a few convolutional or local-attention layers. At the finest pyramid level, $r$ is a small constant, for example 4 cells, and we sweep it.

Third, the repair module is trained by distillation against full-image features:

$$\mathcal{L} = \mathcal{L}_{\text{det}} + \lambda \sum_{\ell} \big\| M_\ell \odot (\hat F_\ell - F^{\text{full}}_\ell) \big\|_2^2 .$$

Here $\mathcal{L}_{\text{det}}$ is the usual oriented-detection loss, and $\hat F_\ell$ is the repaired stitched feature map at pyramid level $\ell$. $F^{\text{full}}_\ell$ is the feature map the same backbone produces on the whole image. We compute it offline, either on a large-memory GPU or by tiling with overlap and keeping only each crop's interior. $M_\ell$ masks the loss to the seam strips, and $\lambda$ weights the distillation term.

Fourth, the unchanged Oriented R-CNN head, with ACM angle coding, runs on the repaired global map. It uses one global NMS and no cross-tile merging.

Tile skipping comes next. A cheap classifier looks at a low-resolution thumbnail and marks tiles as empty. Skipped tiles get a learned background embedding instead of backbone features. Their seams are still repaired, with the repair module seeing the background embedding plus a thin strip of pixels from the skipped side, encoded by the stem alone. The skip threshold is set to hold recall on a validation set.

On the execution side, tiles are dispatched to concurrent GPU streams as soon as they are loaded. Each seam strip becomes a task that is ready when its two neighbors finish. A work-stealing queue in the style of FlowLoader keeps streams busy despite uneven per-tile cost. We then measure end-to-end latency, peak memory, and GPU utilization.

The analysis centers on a seam-stratified evaluation that current benchmarks do not report. For a given grid, we tag every ground-truth oriented box by whether it crosses a seam, by the angle between the object's long axis and the seam, and by aspect ratio. We then report AP separately for crossing and interior objects. This split turns "boundary artifacts" into a measurable quantity, and every claim below is judged on it.

Baselines

The naive reference point is zero-overlap tiling with independent per-tile detection and plain NMS merging. It costs the least compute and should show the worst seam-crossing AP.

The strongest existing method is Oriented R-CNN with a ResNet-50 backbone under the standard DOTA protocol of 1024 crops, stride 824, with merging. Oriented R-CNN reports 75.87% mAP on DOTA-v1.0 and 15.1 frames per second on 1024×1024 inputs on an RTX 2080Ti. It is the strongest competitor because it is the best accurate and efficient single-scale oriented detector in the file, and because its crop protocol is the exact thing we replace. We retrain it ourselves with the same backbone, schedule, augmentation, angle coding and hyperparameter search budget as our model. The only differences are the tiling scheme and the repair module. Beating it means matching its overall mAP within noise, improving seam-crossing AP on long-object classes (ship, bridge, harbor, ground track field, large vehicle), and using fewer total backbone operations per scene.

A second strong baseline is full-image inference: the same trained detector run on each whole scene without tiling. We found no reported result on Lacuna for full-image Oriented R-CNN inference on DOTA. We will measure it, treating its seam-free accuracy as the ceiling and its peak memory and latency as the costs to beat.

We also run overlap sweeps at 25%, 40% and 50% on the standard pipeline to trace the accuracy-versus-compute curve our method must lie above.

Four ablations isolate the key ingredient. The first stitches features with no repair, which tests whether a global map and global NMS alone help. The second repairs without the distillation term, which tests whether full-image features are needed as a target. The third skips tiles without repairing skipped borders, which tests whether repair is what makes skipping safe. The fourth disables concurrent scheduling, which separates algorithmic savings from execution savings.

Why not just…?

Why not just run the detector on the whole image at test time? This is the most serious alternative, and we treat it as the accuracy ceiling rather than dismiss it. On a large-memory GPU, a convolutional detector may fit a 4000×4000 scene. It will still pay full compute on empty ocean, and a train-on-crops, test-on-whole mismatch in object density and context may also cost accuracy. If full-image inference matches our accuracy at comparable latency and memory on the target hardware, the contribution reduces to tile skipping plus repair. We will report that plainly. The full-image comparison, especially peak memory at 4K and larger on memory-limited hardware, decides this.

Why not just increase the overlap? Pixel redundancy grows roughly with the square of 1/(1 − overlap fraction), so 50% overlap roughly quadruples coverage. The tiling study shows that cost scales with tile count. More fundamentally, a diagonal object longer than the margin is cut regardless. The overlap sweep, stratified by object length along the crossing direction, will show where seam-crossing AP stops improving.

Why not just merge truncated box fragments better after detection? Fragment merging is cheap and could fix double-counting. However, the file's evidence on feature pollution for slender rotated objects (RoI Transformer, Shape-Aware Dynamic Alignment Network) suggests the fragments themselves are often missed or misoriented, and no merge can recover a missed fragment. We will test an oracle merge that unions every predicted fragment matching the same ground-truth object. If the oracle closes most of the gap to full-image inference, the problem really is merging and our repair is unnecessary.

Why not just skip empty tiles in the standard overlapping pipeline? This captures much of the compute saving with no new model, so it is a real threat to the redundancy part of the claim. The test is seam-crossing recall at matched skip rates. Our prediction is that plain skipping loses the halves of objects that extend into skipped tiles, and that repair of skipped borders retains them.

Proposed Experiments and Decisive Checks

The main experiments run on DOTA-v1.0, with stratified analysis on the validation split because test labels are held by an evaluation server, and on FAIR1M for scale and fine-grained classes. The FAIR1M paper reports a best baseline of 34.65% mAP. HRSC2016 images are small, so there we impose artificially small tiles to stress seams on the dataset's long, slender ships. For reference, Oriented R-CNN reports 96.50% mAP on untiled HRSC2016. Metrics are mAP, AP75, seam-crossing versus interior AP broken down by aspect ratio and crossing angle, backbone operations per scene, peak memory, end-to-end latency, and the fraction of tiles skipped at fixed recall.

The first check comes before any model is built. We measure the seam-crossing versus interior AP gap for the standard pipeline against full-image inference. If that gap is small on DOTA's long-object classes, the premise fails and the project should pivot to pure skipping.

The second check asks whether repair with strip width $r$ recovers at least most of that gap at zero overlap, and how recovery depends on $r$. A good result is that recovery saturates at small $r$, which would mean seam damage is local.

The third check asks whether repair-plus-skipping holds seam-crossing recall while cutting backbone compute on maritime and rural scenes.

The fourth check asks whether the dependency-aware concurrent schedule reduces wall-clock latency beyond what the compute savings alone predict, compared against the same model run sequentially.