Mask-Guided Feature Routing and Adaptive Context Modeling for Wide-FoV UAV Object Detection in IoT Remote Sensing

Highlights

What are the main findings?

• MFRC-Det proposes a foreground-aware detection framework for wide-FoV UAV object detection by combining mask-guided feature routing with adaptive context modeling.
• The proposed routing mechanism suppresses background-dominated computation at the feature level, while ARSNet enhances scale-adaptive representation within retained foreground regions.

What is the implication of the main finding?

• Mask-guided feature routing provides an efficient solution for reducing redundant computation in UAV-based IoT remote sensing imagery.
• Combining foreground-focused routing with adaptive context modeling offers a practical design for tiny object detection under extreme scale variation in IoT remote sensing applications.

Abstract

Object detection in wide-field-of-view (wide-FoV) unmanned aerial vehicle (UAV) imagery for Internet of Things (IoT) remote sensing applications requires accurate recognition of tiny objects under severe background redundancy and extreme scale variation. As the field of view expands, conventional dense detectors tend to waste substantial computation on non-informative regions, while feature downsampling and static receptive fields often cause the dilution of foreground information and scale confusion. To address these issues, we propose MFRC-Det, a unified framework built upon two complementary principles: mask-guided feature routing and adaptive context modeling. Specifically, a Superpixel-Masking Generator (SP-Masker) is introduced to estimate an image-space soft foreground prior by comparing Simple Linear Iterative Clustering (SLIC) superpixel histograms with a peripheral background reference, propagating the resulting scores on a superpixel adjacency graph, and projecting the refined region-level scores back to a pixel-level routing mask. Guided by these priors, a Greedy-Cutter (G-Cutter) converts dense feature maps into compact, foreground-focused patches without repeated backbone evaluation on cropped image regions, thereby reducing redundant background computation while preserving local structural coherence. On top of the retained regions, an Adaptive Receptive-field Selection Network (ARSNet) aggregates multi-scale contextual responses from several learnable receptive-field candidate branches. ARSNet predicts spatial selection weights conditioned on the input features, allowing each location to emphasize a suitable receptive-field response for object representation. Experimental results on VisDrone-DET and UAVDT demonstrate that MFRC-Det achieves competitive detection accuracy with favorable computational efficiency. Specifically, MFRC-Det obtains 36.1% AP, 60.4% $A{P}_{50}$, and 38.5 FPS on VisDrone-DET and 21.3% AP, 36.8% $A{P}_{50}$, and 37.4 FPS on UAVDT. These results validate the effectiveness of mask-guided feature routing and adaptive context modeling for wide-FoV UAV object detection and suggest their potential value for computation-efficient aerial perception in IoT remote sensing applications.

1. Introduction

IoT remote sensing applications such as intelligent transportation, traffic monitoring, and hazard pre-warning increasingly rely on aerial visual data for large-area perception and timely decision support. As an important sensing platform in such systems, UAVs provide flexible deployment and wide-area coverage for remote sensing tasks. However, object detection in wide-field-of-view (wide-FoV) UAV imagery remains challenging because foreground targets occupy only a small fraction of the image while extreme scale variation is common, as shown in Figure 1. Under these conditions, dense full-image computation wastes considerable resources on background-dominated regions, and conventional detectors with aggressive downsampling and static receptive fields often suffer from foreground information dilution and scale confusion. These issues jointly limit both detection accuracy and computational efficiency in IoT remote sensing settings [1]. In practical IoT remote sensing applications, this issue is particularly critical because wide-area aerial sensing often produces low information density, where only a small portion of the image contributes to downstream perception while most computation is spent on non-informative background. Therefore, improving object detection in this setting is not only a matter of representation quality but also a problem of computation allocation under application-oriented efficiency constraints.

Figure 1. Main challenges in wide-FoV UAV object detection.

To counteract representational degradation in small object detection, a prevalent strategy focuses on reconstructing latent spatial details via resolution amplification to augment the feature density of target regions [2]. Many studies utilize super-resolution (SR) as a preprocessing step to improve pixel density and detail expression. SuperYOLO [3] introduces an auxiliary SR branch to learn discriminative high-resolution features. DSAA-YOLO [4] incorporates a dense residual super-resolution module to recover resolution for targets degraded during the enhancement process. By jointly optimizing super-resolution and YOLO detection, YOLOLens [5] first enhances the discriminative fidelity of low-resolution scenes, thereby providing a refined feature foundation for high-precision detection. Similarly, DRADNet [6] employs a joint reconstruction and SR auxiliary branch to guide the network in learning representations across varying degrees of degradation and resolution. Although SR-based methods can enhance local detail, their gains depend on reconstruction quality, and they usually retain dense full-image computation, which limits their efficiency for background-dominated wide-FoV UAV imagery.

To navigate the challenges of scale heterogeneity, contemporary architectures typically leverage Feature Pyramid Networks (FPNs) to facilitate hierarchical feature integration across multiple resolutions [7]. FPNs extract multi-scale features via bottom-up paths and achieve cross-scale fusion through top-down paths and lateral connections, enhancing the model’s adaptability to target scale changes. L-FPN [8] gradually injects deep semantic information into shallow layers to strengthen the fine-grained representation of small objects. BiFPN [9] reconstructs the neck feature aggregation path via bi-directional feature pyramid fusion. FFDN [10] fuses multi-scale features into a global representation before redistributing it to prediction branches to augment information available for small targets. Nevertheless, when features from different object scales are fused through static paths or shared receptive fields, responses from large and visually dominant objects may be broadcast to neighboring or shallow high-resolution representations. This indiscriminate cross-scale mixing weakens the locality and contrast required by tiny objects, resulting in scale confusion rather than merely insufficient feature resolution. Therefore, an effective solution should not only provide multi-scale features but also decide which receptive-field range should be emphasized at each foreground location.

Motivated by these observations, we formulate wide-FoV UAV object detection as a joint problem of foreground-aware computation allocation and scale-adaptive representation learning. This formulation is particularly meaningful in IoT remote sensing, where large-scale aerial observation, limited effective foreground occupancy, and practical throughput requirements make it insufficient to rely solely on stronger dense detection backbones. Therefore, we develop MFRC-Det, a framework that combines mask-guided feature routing with adaptive context modeling in a coarse-to-fine pipeline. In the routing stage, SP-Masker produces class-agnostic spatial priors from superpixel-based foreground estimation, and G-Cutter converts dense feature maps into compact foreground-focused patches, thereby suppressing redundant background computation while preserving target-related structures. In the context modeling stage, ARSNet performs input-conditioned receptive-field response selection within the retained regions to enhance scale-aware feature learning under severe scale heterogeneity. Extensive experiments on VisDrone-DET and UAVDT show that MFRC-Det achieves a competitive accuracy–efficiency trade-off for wide-FoV UAV object detection in IoT remote sensing.

The primary contributions of this work are summarized as follows:

• We propose MFRC-Det, a wide-FoV UAV detection framework for IoT remote sensing that unifies mask-guided feature routing and adaptive context modeling in a coarse-to-fine pipeline.
• We develop a non-parametric foreground routing mechanism instantiated by SP-Masker and G-Cutter to suppress background-dominated computation at the feature level without repeated backbone evaluation on cropped image regions.
• We design an Adaptive Receptive-field Selection Network (ARSNet) for scale-aware representation learning within retained foreground regions. ARSNet uses shared receptive-field candidate branches across inputs and predicts input-conditioned spatial weights to aggregate their responses at each location, enabling location-specific context selection without increasing the routing complexity.

2. Materials

Object detection for UAV imagery, especially under wide-FoV and small-object settings, has been extensively investigated in recent years. Existing studies can be broadly grouped into several major directions. The first direction focuses on detail compensation, where data enhancement, super-resolution, or reconstruction modules are introduced to recover discriminative cues for tiny objects. The second direction emphasizes region selection, where cropping, clustering, or proposal-based mechanisms are used to suppress large-area redundancy. The third direction centers on scale-adaptive representation learning, where multi-scale fusion, receptive-field selection, or input-conditioned response aggregation is employed to handle severe object-size variation. In this paper, ARSNet is positioned as an adaptive receptive-field modeling module. It uses shared receptive-field candidate branches and predicts input-conditioned spatial weights to select suitable contextual responses at each location. In this section, we review these representative lines of research and summarize their remaining limitations in wide-FoV UAV scenarios, thereby clarifying the motivation of the proposed MFRC-Det.

2.1. Small Object Detection

In UAV small object detection tasks, the limited number of pixels occupied by targets, together with the scarcity and non-uniform distribution of small-object samples, often places model training under severe data-scarcity and representation-deficiency constraints. To address this, [11] proposed augmentation strategies based on instance replication and relocation. Building on this, RRNet [12] introduced prior segmentation maps and scale transformations to optimize resampling quality. Furthermore, frameworks such as Cascade-UAV [13] and AGDN [14] generate training samples through image tiling and multi-scale scaling, while DS-GAN [15] utilizes Generative Adversarial Networks (GANs) to synthesize high-quality small-object data, thereby enriching sample diversity. These methods mainly improve small object detection from the sample level by enriching target appearances, increasing effective resolution, or rebalancing the spatial distribution of training instances.

Beyond sample-level enhancement, another major line of research focuses on feature-level detail compensation, since tiny targets in UAV imagery often suffer from weak semantic responses and insufficient discriminative resolution [16]. Consequently, the leveraging of super-resolution techniques to recover target details has become a mainstream research direction [17]. MTGAN [18] focuses on the local super-resolution reconstruction of Regions of Interest (RoIs). To overcome the limitations of traditional SR, which often ignores global context, PerceptualGAN [19] maps the weak features of small objects onto high-resolution, super-resolved features through adversarial learning. Similarly, FSR-CNN [20] introduces a direct supervision mechanism to enhance the precision of feature restoration. In the remote sensing domain, EE-GAN [21] and RFA-SRNet [22] utilize GANs to enhance low-resolution imagery. By employing edge-detail screening and recursive residual aggregation techniques, these methods effectively mitigate the loss of high-frequency information and the interference caused by complex backgrounds. Recent studies trend toward lightweight, context-aware UAV small object detection. Enhanced YOLOv11n [23] leverages multiscale edge features and a lightweight head for improved accuracy, while RE-YOLO [24] targets efficient deployment under resource constraints. Although these methods improve the visibility or discriminability of tiny targets, they usually retain dense full-image computation and therefore do not explicitly address the large-area background redundancy that dominates wide-FoV UAV imagery.

2.2. Region Selection-Based Detection Strategies

Given that UAV imagery is characterized by a wide FoV and high background redundancy, performing global detection directly on high-resolution raw images is not only computationally expensive but also causes foreground target features to be easily overwhelmed by background clutter [1]. To mitigate these issues, researchers have proposed various region-selection strategies, including zoom-based attention, density-guided cropping, and cluster-based partitioning. DZN [25] introduces a reinforcement learning mechanism that enables the model to automatically “zoom” its attention onto high-value, task-relevant regions. DMNet [26] leverages a density map-guided cropping mechanism to effectively suppress background interference using spatial distribution priors. Furthermore, the ClusDet [27] network adaptively partitions ultra-high-resolution images into non-uniform sub-patches based on target clustering density.

To further optimize inference efficiency, frameworks such as UFPMP-Det [28] and CAMS-AI [29] have introduced a “cluster-and-stitch” mechanism. Specifically, these methods employ a Region Proposal Network (RPN) or a coarse detector to extract candidate foregrounds, which are then integrated through clustering and stitched into a mosaic image for the final detector. This strategy ensures fine-grained detection while significantly reducing redundant computations in non-target background areas. Despite their effectiveness in reducing invalid background computation, many of these methods still rely on pixel-level cropping, proposal generation, or repeated backbone encoding, which increases pipeline complexity and may fragment global contextual coherence.

2.3. Cross-Scale Object Detection

Constrained by fixed receptive fields, standard Convolutional Neural Networks (CNNs) struggle to adapt to the drastic cross-scale variations inherent in UAV object detection, often resulting in feature representation mismatch. Existing cross-scale solutions can be broadly divided into two groups. The first group relies on explicit multi-scale processing, such as image pyramids [30] and feature pyramid networks, to enhance scale robustness through hierarchical feature fusion. The second group focuses on scale-adaptive operators, where receptive-field selection, branch-wise response aggregation, or deformable sampling is used to modulate contextual support according to target characteristics. Although image pyramids and FPN-style designs alleviate scale variation to a certain extent, the former carries the risk of training-inference inconsistency, while the latter still performs scale fusion mainly through fixed topologies and fixed aggregation rules. In wide-FoV UAV images, where tiny, distant targets and large, near-field objects often coexist within the same scene, such fixed fusion may introduce cross-scale interference: large-object context can dominate shared feature responses, whereas small-object evidence requires more localized and high-contrast representation. This observation motivates our use of ARSNet as a local, scale-adaptive context module rather than a conventional multi-level FPN neck.

To address these limitations, researchers have explored dynamic and adaptive architectural designs. CondConv [31], Dynamic Convolution [32], and ODConv [33] significantly enhance model adaptability to input variations through multi-kernel parallelism and omni-dimensional adaptive attention aggregation. SKNet [34] and ResNeSt [35] improve representation flexibility via branch selection and grouping mechanisms. SCNet [36] and CoordAtt [37] strengthen localization sensitivity by reconstructing spatial structures and encoding coordinate information, respectively. Furthermore, Deformable ConvNets [38] and its evolved version, DCNv3 [39], explicitly adapt to the geometric and scale deformations of targets using deformable sampling. Recently, Involution [40] and RepLKNet [41] have broken the constraints of spatial invariance and effectively expanded the effective receptive field (ERF) of deep networks by inverting convolutional characteristics or introducing inherently large kernels. These adaptive operators substantially improve scale sensitivity and contextual flexibility. FKIFM-DETR [42] enhances cross-scale UAV small object detection through spatial-frequency fusion and improved FPN design, effectively handling scale variation and background interference. However, most of them are still deployed on globally processed dense feature maps; thus, they remain less effective in reducing the background-dominated computation that is typical of wide-FoV UAV imagery.

In summary, existing studies have substantially advanced UAV small object detection from the perspectives of detail enhancement, region selection, and scale-adaptive representation learning. However, these approaches are often optimized for only one side of the problem. Detail-compensation methods improve local visibility but usually retain dense full-image computation. Region-selection methods reduce invalid background processing but often rely on pixel-level cropping or multi-stage proposal pipelines. Scale-adaptive architectures strengthen representation flexibility, yet they are still commonly deployed on globally processed feature maps and therefore remain less efficient in background-dominated wide-FoV scenarios. These limitations motivate MFRC-Det, which addresses wide-FoV UAV object detection in IoT remote sensing through the joint design of mask-guided feature routing and adaptive context modeling.

3. Methods

3.1. Overall Network Architecture

As illustrated in Figure 2, MFRC-Det is designed for wide-FoV UAV object detection in IoT remote sensing, where small targets are sparsely distributed in large background-dominated images. The framework follows a two-stage design: mask-guided feature routing first suppresses redundant background regions and selects foreground-focused feature patches, while adaptive context modeling further enhances the retained patches with spatially adaptive contextual responses. MFRC-Det inserts ARSNet after feature routing to perform location-wise receptive-field selection before the sparse detection head. This placement allows adaptive context aggregation to operate on foreground-focused patches, where scale heterogeneity is more directly related to target representation. With ResNet50 as the backbone, MFRC-Det consists of a stem block, SP-Masker, G-Cutter, ARSNet, and an anchor-free sparse detection head.

Figure 2. Overall network architecture of the proposed MFRC-Det framework.

The stem serves as the early feature extractor and is implemented as a convolutional module composed of a 3 × 3 convolution, followed by batch normalization and ReLU. In parallel with early feature extraction, SP-Masker estimates an image-space foreground probability map from the input image using superpixel-based statistics and aligns it to the stem feature grid. This foreground prior constrains subsequent feature routing from the entire image to potential regions of interest at minimal computational overhead.

Guided by the feature-aligned foreground routing mask, G-Cutter selects compact foreground-focused patches from the dense stem feature map, thereby retaining potential target regions while suppressing redundant background responses. The retained patches are subsequently processed by ARSNet, which maintains shared multi-receptive-field candidate branches and uses input-conditioned spatial selection weights to generate contextual response maps adapted to sparse foreground layouts.

Finally, the routed contextual responses are restored to the detection grid and concatenated with the feature-aligned foreground prior and the corresponding single-pass stem representation. The concatenated representation is fed into an anchor-free sparse detection head with decoupled classification and regression branches, where object classification is optimized using focally modulated binary cross-entropy loss and bounding-box regression is supervised by CIoU loss. This explicit concatenation preserves stem-level appearance cues, foreground priors, and contextual response as complementary input cues while maintaining compatibility with sparse feature routing and end-to-end detector optimization.

3.2. Superpixel-Masking Generator

In small object detection within wide-FoV imagery, efficiently localizing potential target regions while maintaining low computational overhead is critical for alleviating the computational burden caused by large background-dominated images. An intuitive approach is to use an RPN or a Cluster Proposal Network (CPN) [43] for preliminary filtering. However, in shallow network stages, feature representations are often insufficient for stable object localization, and the boundaries or geometries of small targets are difficult to regress reliably. Consequently, bounding box-based candidate searches may suffer from low recall and localization offsets. Another alternative is to use density maps to estimate target distributions. Although density maps can reflect statistical target distributions, they are typically optimized for counting or center-point estimation, which emphasizes object centers rather than spatial extents. This property makes them less suitable for guiding bounding box-oriented feature routing. Moreover, introducing additional regression networks or density-estimation branches increases computational cost, which is inconsistent with our goal of efficient detection in wide-FoV images. More sophisticated learnable clustering or proposal-based alternatives could also be used for foreground discovery, but they usually introduce additional trainable branches, proposal-generation overhead, or dependence on stable object-level regression in shallow features. SP-Masker is therefore adopted as a deterministic and lightweight region-grouping mechanism for the generation of routing support.

To avoid unstable box regression in shallow features and costly auxiliary prediction branches, SP-Masker generates a class-agnostic soft foreground prior for spatial routing rather than attempting semantic segmentation. SP-Masker operates on the input image and produces an image-space foreground probability map, which is then resized to the stem feature grid:

$$F_s={\mathrm{Conv}}_{stem}\left(I\right),{\mathbf{M}}^{img}={\mathcal{F}}_{\mathrm{SPM}}\left(I\right),\mathbf{M}=\mathrm{Resize}({\mathbf{M}}^{img},H_s,W_s).$$

(1)

Here, I denotes the input image, $F_s$ denotes the stem feature map, ${\mathbf{M}}^{img}$ denotes the image-space foreground probability map generated by SP-Masker, and $\mathbf{M}$ denotes the foreground routing mask aligned to the stem feature grid.

Specifically, SP-Masker first partitions the input image into SLIC superpixels (${\left\{{\mathsf{\Omega }}_i\right\}}_{i=1}^{N_s}$). A peripheral strip (${\mathsf{\Omega }}_b$) with a width of $r_{b}min(H,W)$ is used as the background reference region, where $r_b=0.1$ in our implementation. We compute the normalized color histogram ($h^b$) of ${\mathsf{\Omega }}_b$ and the normalized color histogram ($h_i$) of each superpixel (${\mathsf{\Omega }}_i$). The foreground divergence score of ${\mathsf{\Omega }}_i$ is measured by the Bhattacharyya distance:

$$d_i=\sqrt{1-\sum _{k=1}^{K_h}\sqrt{h_i\left(k\right)h^b\left(k\right)}},$$

(2)

Here, $K_h$ is the number of histogram bins. A larger $d_i$ indicates that the corresponding superpixel is less similar to the peripheral background reference and is therefore more likely to contain foreground evidence.

The raw foreground probability is obtained by min–max normalization:

$$p_i^0={\displaystyle \frac{d_i-{min}_j{d}_j}{{max}_j{d}_j-{min}_j{d}_j+ϵ}},$$

(3)

Here, $ϵ$ is a small constant for numerical stability. To improve spatial coherence, we construct a superpixel adjacency graph ($\mathcal{G}=(\mathcal{V},\mathcal{E})$) where two superpixels are connected if they share a boundary. The foreground scores are propagated on this graph as

$$p_i^{t+1}=\alpha p_i^0+(1-\alpha ){\displaystyle \frac{{\sum }_{j\in \mathcal{N}\left(i\right)}{w}_{ij}{p}_j^t}{{\sum }_{j\in \mathcal{N}\left(i\right)}{w}_{ij}+ϵ}},$$

(4)

Here, $\mathcal{N}\left(i\right)$ denotes the neighboring superpixels of ${\mathsf{\Omega }}_i$, t denotes the propagation step, and $w_{ij}$ measures the appearance similarity between adjacent superpixels:

$$w_{ij}=exp\left(-{\displaystyle \frac{\parallel c_i-c_j{\parallel }_2^2}{2{\sigma }_c^2}}\right).$$

(5)

Here, $c_i$ and $c_j$ are the mean color vectors of superpixels ${\mathsf{\Omega }}_i$ and ${\mathsf{\Omega }}_j$, respectively. The propagation is initialized with $p_i^{t=0}=p_i^0$ and is repeated for T iterations. In our implementation, we set $T=1$.

After graph propagation, the refined superpixel-level score is projected back to the pixel space. For each pixel ($x\in {\mathsf{\Omega }}_i$), we define a position-aware weighting term:

$$w_{pos}\left(x\right)=max\left(0,1-{\displaystyle \frac{\parallel x-{\mu }_i{\parallel }_2}{R_i+ϵ}}\right),$$

(6)

Here, ${\mu }_i$ is the geometric centroid of ${\mathsf{\Omega }}_i$ and $R_i$ is its equivalent radius. To reduce block artifacts near superpixel boundaries, we further introduce a boundary attenuation term:

$$w_{bd}\left(x\right)=1-exp\left(-{\displaystyle \frac{\mathrm{dist}{(x,\partial {\mathsf{\Omega }}_i)}^2}{2{\sigma }_b^2}}\right).$$

(7)

The image-space foreground probability map is then computed as

$${\mathbf{M}}^{img}\left(x\right)=G_{{\sigma }_g}\ast \left[p_i^T\left(0.6w_{pos}\left(x\right)+0.4\right)w_{bd}\left(x\right)\right],x\in {\mathsf{\Omega }}_i,$$

(8)

Here, $G_{{\sigma }_g}$ denotes Gaussian smoothing and T is the number of graph propagation iterations. The final map is clipped to $[0,1]$ before being resized to the stem feature resolution.

To make the non-parametric mechanism fully reproducible, Table 1 summarizes the deterministic implementation of ${\mathcal{F}}_{\mathrm{SPM}}$ in pseudo-code form.

Table 1. Pseudo-code of the deterministic SP-Masker.

Input	Image $I\in {\mathbb{R}}^{H\times W\times 3}$; superpixel number $N_s$; boundary ratio $r_b$; histogram bin number $K_h$; propagation coefficient $\alpha$; propagation step T; scale parameters ${\sigma }_c$, ${\sigma }_b$, and ${\sigma }_g$.
Output	Image-space foreground probability map ${\mathbf{M}}^{img}$ and feature-aligned routing mask $\mathbf{M}$.
1	Partition I into SLIC superpixels ${\left\{{\mathsf{\Omega }}_i\right\}}_{i=1}^{N_s}$ and assign each pixel x to a label $\ell \left(x\right)$.
2	Construct the peripheral strip ${\mathsf{\Omega }}_b$ and compute the normalized RGB histogram $h^b$ of ${\mathsf{\Omega }}_b$.
3	For each superpixel ${\mathsf{\Omega }}_i$, compute its normalized RGB histogram $h_i$ and the Bhattacharyya distance $d_i$ to $h^b$.
4	Normalize $\left\{d_i\right\}$ by min–max scaling to obtain the initial foreground likelihood $p_i^0$.
5	Initialize $p_i^{t=0}=p_i^0$, build the superpixel adjacency graph, and update node scores for T iterations using similarity-weighted neighborhood propagation.
6	Project the propagated score $p_i^T$ back to pixels in ${\mathsf{\Omega }}_i$ with the position-aware term $w_{pos}\left(x\right)$ and the boundary attenuation term $w_{bd}\left(x\right)$.
7	Smooth the projected pixel-level map with $G_{{\sigma }_g}$ and clip it to $[0,1]$ to obtain ${\mathbf{M}}^{img}$; resize ${\mathbf{M}}^{img}$ to the stem feature resolution to obtain $\mathbf{M}$.

This procedure contains no learnable parameters, semantic labels, or auxiliary optimization objectives. Therefore, every value in the foreground mask can be traced to explicit deterministic operations, including SLIC grouping, histogram-based divergence estimation, adjacency-graph propagation, and pixel-level score projection. The generated mask is not used as a semantic segmentation result; instead, it serves as a lightweight spatial prior for subsequent feature routing.

3.3. Greedy-Cutter (G-Cutter) Strategy

Upon obtaining the feature-aligned foreground routing mask ($\mathbf{M}$) from SP-Masker, G-Cutter converts the dense stem feature map into a compact set of foreground-focused feature patches. It selects local candidate patches according to $\mathbf{M}$ to reduce redundant background computation while retaining target-related regions. In the current implementation, G-Cutter uses a fixed base-patch size of $128\times 128$ on the stem feature grid and an upper-bounded number of patches. This size defines the spatial support preserved around each selected foreground anchor. The mask-driven components of G-Cutter include patch localization, priority ordering, boundary calibration, and retained patch selection within the preset computational budget. The choice of this patch size, its influence on patch-exceeding objects, and the adaptive sizing variant are further analyzed in the ablation study and discussed in Section 5.

Existing works, such as [44], typically partition feature maps into $k\times k$ rigid grids and discard inactive tiles. However, rigid grid-based slicing is not well matched to wide-FoV small object detection. First, grid boundaries may split boundary-crossing targets into adjacent patches, which weakens local geometric continuity and increases the risk of missed detections. Second, uniform slicing cannot adapt to the uneven spatial distribution of targets and may still retain substantial invalid background areas.

In light of these challenges, we formulate patch generation from the perspective of target coverage under a bounded patch budget. We propose a topology-aware greedy slicing strategy that seeks high target coverage through a mechanism of peak detection, density estimation, and boundary calibration.

To extract topological cues from the mask ($\mathbf{M}$), we perform two parallel morphological operations. A $3\times 3$ max-pooling operation extracts a set of potential target centers ($C={\left\{(x_c^i,y_c^i)\right\}}_{i=1}^N$), where each coordinate corresponds to a local response extremum on the feature map. This operation preserves spatial precision in locating high-activation candidate regions. In parallel, a $9\times 9$ average-pooling operation produces an importance score set ($S={\left\{s_i\right\}}_{i=1}^N$, where $s_i$ reflects the activated pixel density around the corresponding target center and serves as the priority metric for patch generation). This parallel design balances peak preservation and regional consistency: max pooling alone is insufficient for stable density estimation, whereas average pooling alone can blur spatial localization.

Following the greedy principle during the iterative generation phase, we select the candidate center $(x_c^i,y_c^i)$ from C whose corresponding score ($s_i$) in S is the highest and use it as the anchor point to initialize a fixed-size patch. Let the base width and height of the patch be $W_p$ and $H_p$, respectively; the initial patch (${\mathcal{P}}_i$) boundary coordinates $(x_1^i,y_1^i,x_2^i,y_2^i)$ are defined as a rectangular region centered on the anchor:

$$x_1^i=x_c^i-{\displaystyle \frac{W_p}{2}},y_1^i=y_c^i-{\displaystyle \frac{H_p}{2}},x_2^i=x_c^i+{\displaystyle \frac{W_p}{2}},y_2^i=y_c^i+{\displaystyle \frac{H_p}{2}}.$$

(9)

The coordinates are clipped to valid feature-map ranges after boundary calibration and before feature gathering. While the initial patch covers the target center, it may still contain excessive peripheral background due to positional bias. To further enhance information density, we introduce a deterministic boundary calibration mechanism. Specifically, we collect the activated foreground positions ($A_i=\left\{(x_a^k,y_a^k)\right\}$) covered by the current patch and compute the deviation between the top-left boundary of these foreground responses and the initial patch boundary:

$$\Delta x=\underset{(x_a^k,y_a^k)\in A_i}{min}{x}_a^k-x_1^i,\Delta y=\underset{(x_a^k,y_a^k)\in A_i}{min}{y}_a^k-y_1^i.$$

(10)

If $A_i$ is empty due to thresholding, we set $\Delta x=\Delta y=0$ and keep the initial patch location unchanged. Based on this deviation, we shift the fixed-size patch toward the activated foreground region while keeping its spatial extent unchanged:

$${\widehat{x}}_1^i=\mathrm{clip}(x_1^i+\Delta x,0,W-W_p),{\widehat{y}}_1^i=\mathrm{clip}(y_1^i+\Delta y,0,H-H_p),$$

(11)

$${\widehat{x}}_2^i={\widehat{x}}_1^i+W_p,{\widehat{y}}_2^i={\widehat{y}}_1^i+H_p.$$

(12)

This calibration improves the compact alignment between the retained patch and the foreground responses without changing the preset patch resolution. After each calibrated patch is generated, G-Cutter removes all candidate centers covered by this patch from C, together with their corresponding scores in S, following a greedy elimination strategy analogous to Non-Maximum Suppression (NMS). This localization–calibration–elimination cycle continues until the candidate sets are exhausted ($C,S=\varnothing$) or the maximum patch number is reached. This strategy reduces the amount of input data processed by the subsequent detection network while preserving target clusters within the retained patches.

G-Cutter is a spatial routing module rather than an instance proposal generator. It preserves salient regions without enforcing instance-level separation during patch generation. In densely populated scenes, one retained patch may contain multiple nearby objects; fine-grained instance discrimination is handled by the detection head through classification, bounding-box regression, and non-maximum suppression. Although the greedy slicing procedure contains non-differentiable selection operations, it only determines the spatial support of the retained features. The feature values inside selected patches remain differentiable, which enables normal gradient propagation to the learnable detector parameters.

To clarify the training behavior of the non-differentiable routing stage, we explicitly formulate G-Cutter as a gather–scatter operation on the stem feature map. Let $F_s=f_{{\theta }_s}\left(I\right)\in {\mathbb{R}}^{C\times H\times W}$ denote the stem feature map, and let

$$\mathcal{B}=\mathcal{C}(\mathbf{M};W_p,H_p,N_{max})={\left\{b_i\right\}}_{i=1}^{N_p}$$

(13)

be the integer-valued patch coordinates generated by G-Cutter from the non-parametric routing mask ($\mathbf{M}$). Here, $b_i=(x_i^1,y_i^1,x_i^2,y_i^2)$ and $\mathcal{C}(·)$ includes peak selection, boundary calibration, and greedy elimination. Since $\mathbf{M}$ and $\mathcal{B}$ are deterministic routing outputs, they are treated as fixed indices during back-propagation:

$${\displaystyle \frac{\partial \mathcal{L}}{\partial \mathbf{M}}}=0,{\displaystyle \frac{\partial \mathcal{L}}{\partial b_i}}=0.$$

(14)

No straight-through estimator is used, and the patch coordinates are not relaxed into learnable continuous variables.

For each retained patch, the slicing operation can be written as

$$P_i=\mathcal{G}(F_s;b_i)=F_s[:,y_i^1:y_i^2,x_i^1:x_i^2]$$

(15)

or, equivalently, $P_i=R_i{F}_s$, where $R_i$ is a binary gather matrix determined by $b_i$. The retained patches are first processed by ARSNet to produce patch-wise contextual responses. These responses are restored to the detection grid according to their patch coordinates, forming the contextual response map (${\mathbf{H}}_{ctx}$). After spatial alignment, the restored contextual response (${\mathbf{H}}_{ctx}$), the feature-aligned foreground prior, and the corresponding single-pass stem representation are concatenated along the channel dimension and fed into the sparse detection head to compute the detection loss (${\mathcal{L}}_{det}={\mathcal{L}}_{cls}+{\mathcal{L}}_{reg}$). During back-propagation, the gradient of each patch is scattered back to its source coordinates in $F_s$:

$${\displaystyle \frac{\partial {\mathcal{L}}_{det}}{\partial F_s}}={\displaystyle \sum _{i=1}^{N_p}}{R}_i^{\top }{\displaystyle \frac{\partial {\mathcal{L}}_{det}}{\partial P_i}}.$$

(16)

Equivalently, for a spatial position ($u=(x,y)$) in $F_s$,

$${\displaystyle \frac{\partial {\mathcal{L}}_{det}}{\partial F_s[:,u]}}=\left\{\begin{array}{cc}{\displaystyle \sum _{i:u\in b_i}}{\displaystyle \frac{\partial {\mathcal{L}}_{det}}{\partial P_i[:,{\tau }_i\left(u\right)]}},\hfill & u\in \bigcup _i{b}_i,\hfill \\ 0,\hfill & u\notin \bigcup _i{b}_i,\hfill \end{array}\right.$$

(17)

Here, ${\tau }_i\left(u\right)$ maps the original feature position (u) to its local coordinate inside patch ($P_i$). Thus, selected regions receive standard gradients through the differentiable feature values, overlapping selected patches accumulate gradients by summation, and unselected regions receive no detection-loss gradient in the current iteration.

The above process is summarized in Table 2.

Table 2. Pseudo-code of forward and backward propagation through G-Cutter during training.

Input	Training image I; annotations Y; stem $f_{{\theta }_s}$; SP-Masker ${\mathcal{F}}_{\mathrm{SPM}}$; G-Cutter $\mathcal{C}$; ARSNet ${\mathcal{D}}_{{\theta }_d}$; detection head ${\mathcal{H}}_{{\theta }_h}$.
Output	Updated learnable parameters ${\theta }_s$, ${\theta }_d$, and ${\theta }_h$.
1	Compute the stem feature map $F_s=f_{{\theta }_s}\left(I\right)$, generate the image-space foreground map ${\mathbf{M}}^{img}={\mathcal{F}}_{\mathrm{SPM}}\left(I\right)$, and resize it to the stem feature grid to obtain $\mathbf{M}$.
2	Generate integer patch boxes $\mathcal{B}=\mathcal{C}(\mathbf{M};W_p,H_p,N_{max})$ through deterministic peak selection, boundary calibration, and greedy elimination.
3	Gather retained feature tensors $P_i=\mathcal{G}(F_s;b_i)=R_i{F}_s$ for each $b_i\in \mathcal{B}$.
4	Feed ${\left\{P_i\right\}}_{i=1}^{N_p}$ into ARSNet to obtain patch-wise contextual responses, restore them to the detection grid as ${\mathbf{H}}_{ctx}$, concatenate ${\mathbf{H}}_{ctx}$ with the feature-aligned foreground prior and the corresponding single-pass stem representation, and feed the concatenated representation into the sparse detection head to obtain predictions $\widehat{Y}$.
5	Compute the detection loss ${\mathcal{L}}_{det}={\mathcal{L}}_{cls}+{\mathcal{L}}_{reg}$ on predictions from the concatenated representation.
6	Scatter $\partial {\mathcal{L}}_{det}/\partial P_i$ back to the source feature coordinates according to $\partial {\mathcal{L}}_{det}/\partial F_s={\sum }_i{R}_i^{\top }(\partial {\mathcal{L}}_{det}/\partial P_i)$.
7	Accumulate gradients for overlapping retained patches; positions not covered by any retained patch receive no detection-loss gradient in the current iteration.
8	Update ${\theta }_s$, ${\theta }_d$, and ${\theta }_h$ using the scattered feature gradients. Keep SP-Masker and G-Cutter parameter-free.

Under this gather–scatter formulation, the learnable detector is optimized through the differentiable feature values inside the retained patches. G-Cutter defines the spatial support on which the detection loss is evaluated in each forward pass. Positions outside the retained patch set receive no detection-loss gradient in the current iteration, so the supervision is spatially sparse and conditioned on the mask-guided routing result. This behavior is consistent with the design goal of foreground-aware computational allocation and introduces a hard support constraint: when a true object is completely excluded by the routing mask, its local feature region does not contribute detection loss in that forward pass.

The training process can reduce fixed routing bias in two ways. First, the routing mask is recomputed from each augmented training image rather than being stored as a static annotation. Geometric and photometric augmentations can change the superpixel partition, foreground divergence scores, local response peaks, and greedy patch order, which leads to different retained regions across epochs. Second, G-Cutter is driven by a soft foreground probability map and selects patch-level regions instead of isolated pixels, so partially activated target neighborhoods can still be retained, even when the foreground prior is imperfect. These factors provide routing variability during training and reduce the chance that the same object region is consistently excluded from supervision.

This mechanism still has a clear limitation. Objects with persistently low foreground scores, especially boundary-touching, heavily truncated, or background-similar objects, may be selected less frequently across training. As a result, these regions participate in fewer forward–backward updates and receive weaker optimization signals during training. We describe these cases as hard-to-route objects. In MFRC-Det, such cases mainly reflect insufficient spatial support from the non-parametric routing prior. The learnable backbone, ARSNet, and detection head remain optimized on the retained features, while the main risk lies in insufficient routing frequency for repeatedly suppressed object regions. This limitation is further analyzed with the representative failure case in Section 5.

Overall, G-Cutter serves as the execution module of mask-guided feature routing in MFRC-Det. SP-Masker estimates an image-space foreground probability map and aligns it to the stem feature grid, and G-Cutter performs response-guided slicing directly on feature maps without repeated backbone encoding on spatially cropped sub-images. This feature-level routing reduces repeated backbone evaluation in cropped image regions and preserves contextual coherence within the retained foreground regions. This design reduces the multi-stage complexity and context fragmentation commonly associated with pixel-level cropping pipelines. From a computational perspective, G-Cutter reduces redundant processing by restricting subsequent context modeling to a small set of retained feature patches. Let the routed stem feature map have a spatial size of $H_s\times W_s$, and let G-Cutter retain $N_p$ patches with a size of $H_p\times W_p$. The approximate spatial processing ratio of the post-routing modules can be written as $\gamma =N_p{H}_p{W}_p/\left(H_s{W}_s\right)$. When $\gamma <1$, ARSNet and the sparse detection head operate on fewer spatial locations than dense full-feature processing. The main routing operations in G-Cutter, including pooling-based peak detection, greedy selection, and feature gathering, are lightweight and can be implemented with parallel tensor operations on GPUs. Further acceleration through optimized CUDA kernels, multi-threaded preprocessing, or asynchronous routing will be explored for real-time IoT deployment.

3.4. Adaptive Receptive-Field Selection Network

After G-Cutter reduces background redundancy, the retained targets still exhibit strong scale heterogeneity. Fixed aggregation ranges are insufficient for this setting: small targets require local contrast and fine structural cues, whereas larger targets benefit from broader contextual support. If all foreground locations are processed with the same context range, responses suitable for large objects may interfere with nearby small-object regions, and tiny targets may lose the local evidence needed for classification and localization. ARSNet is designed to adapt the effective receptive field according to local feature content. Given the retained feature regions produced by G-Cutter, ARSNet first extracts candidate responses using several learnable convolutional branches with different receptive-field ranges. A lightweight selection module then predicts spatial weights over these candidate responses, and the final representation is obtained by weighted aggregation at each spatial location.

In ARSNet, “adaptive” denotes input-conditioned spatial selection over receptive-field candidate responses. During training, the candidate kernels are optimized as shared model parameters. During inference, these kernels remain shared across inputs, while the input-conditioned spatial maps determine how their responses are aggregated at each location. Formally, for the i-th candidate branch, ARSNet computes ${\tilde{U}}_i=f_i(X;{\theta }_i)$ using branch parameters (${\theta }_i$) and predicts spatial weights (${\tilde{\mathbf{M}}}^{\left(i\right)}=g_i(X;\varphi )$) from the current feature. This formulation defines ARSNet as an input-conditioned receptive-field response selection module over shared candidate branches.

The large-kernel decomposition is implemented in a cascaded manner, while the spatial selection is applied over the resulting fixed receptive-field candidate responses. Specifically, we propose a Cascaded Large-Kernel Decomposition (CLKD) strategy, which explicitly decomposes a large-kernel convolution into a serialized sequence of depthwise separable convolutions with increasing kernel sizes (k) and dilation rates (d). For the i-th convolutional layer, the cumulative receptive field ($R{F}_i$) is defined as

$$R{F}_1=k_1,R{F}_i=d_i\times (k_i-1)+R{F}_{i-1},$$

(18)

Here, $k_i$ and $d_i$ denote the kernel size and dilation rate of the i-th layer, respectively. To balance efficiency and eliminate gridding artifacts commonly induced by dilated convolutions, we strictly limit the number of decomposition stages. In our implementation, we employ two sets of convolutions with $(k,d)$ pairs of $(5,1)$ and $(7,3)$, respectively, constructing a large-kernel network with an Effective Receptive Field (ERF) of 23. This design efficiently generates multi-scale contextual information while significantly reducing parameter and computational complexity through serialized decomposition. For an input feature (X), we generate a hierarchy of feature representations (U) with varying receptive fields:

$$U_0=X,U_i={\mathrm{Conv}}_i^{dw}\left(U_{i-1}\right),i\in [1,N]$$

(19)

Here, ${\mathrm{Conv}}_i^{dw}(·)$ represents the depthwise separable convolution. Subsequently, the output of each level undergoes a $1\times 1$ convolution for channel projection and mixing, resulting in a set of multi-scale candidate features (${\left\{{\tilde{U}}_i\right\}}_{i=1}^N$):

$${\tilde{U}}_i={\mathrm{Conv}}_i^{1\times 1}\left(U_i\right)$$

(20)

In practice, we set $N=2$. To select a suitable receptive-field response at each spatial location, ARSNet incorporates a spatially aware selection mechanism that predicts input-conditioned weights over shared receptive-field candidate responses. First, all multi-scale features (${\tilde{U}}_i$) are concatenated along the channel dimension to form the aggregated feature (${\mathbf{U}}_{cat}=[{\tilde{U}}_1,\dots ,{\tilde{U}}_N]$). To efficiently extract spatial saliency and compress channel redundancy, we apply channel-wise average pooling and channel-wise max pooling:

$${\mathbf{S}}_{avg}={\mathcal{P}}_{avg}\left({\mathbf{U}}_{cat}\right),{\mathbf{S}}_{max}={\mathcal{P}}_{max}\left({\mathbf{U}}_{cat}\right)$$

(21)

Here, ${\mathbf{S}}_{avg},{\mathbf{S}}_{max}\in {\mathbb{R}}^{H\times W\times 1}$ are the spatial statistical descriptors. These descriptors are concatenated and passed through an aggregation layer (${\mathrm{Conv}}_{agg}(·)$) to produce an N-channel raw spatial selection tensor:

$${\mathbf{M}}_{raw}={\mathrm{Conv}}_{agg}\left([{\mathbf{S}}_{avg},{\mathbf{S}}_{max}]\right)$$

(22)

A Sigmoid activation ($\sigma (·)$) is then applied to normalize the response values into the $(0,1)$ range, yielding the spatial selection weights ($\tilde{\mathbf{M}}\in {\mathbb{R}}^{H\times W\times N}$):

$$\tilde{\mathbf{M}}=\sigma \left({\mathbf{M}}_{raw}\right)$$

(23)

Finally, ARSNet performs spatially adaptive context modeling via weighted summation. Each position on the feature map aggregates information from different receptive fields according to the generated spatial weights. The weighted responses are then projected by a final convolutional layer to produce the output (Y):

$$Y={\mathrm{Conv}}_{out}\left({\displaystyle \sum _{i=1}^N}({\tilde{\mathbf{M}}}^{\left(i\right)}\odot {\tilde{U}}_i)\right)$$

(24)

Here, ⊙ denotes element-wise multiplication and ${\tilde{\mathbf{M}}}^{\left(i\right)}$ represents the spatial weight map corresponding to the i-th scale. As illustrated in Figure 3, ARSNet can assign higher weights to smaller receptive-field responses at small-object locations and higher weights to broader receptive-field responses at large-object locations. This design establishes the connection between scale heterogeneity and ARSNet’s operation: the candidate branches provide different context ranges, and the spatial weights act as a per-location gate that reduces the contribution of scale-mismatched branches. Consequently, small-object positions are less affected by broad responses generated for large objects, while large-object positions can still exploit extended context for holistic modeling. ARSNet performs spatial response selection on routed foreground regions, associating receptive-field adaptation with sparse foreground layouts and foreground-focused computation.

Figure 3. Architecture of the proposed Adaptive Receptive-field Selection Network (ARSNet). “Adaptive” denotes input-conditioned spatial selection over shared receptive-field candidate responses.

4. Results

4.1. Datasets

To ensure a rigorous evaluation and facilitate fair comparison with existing competitive algorithms, we conduct experiments on two challenging wide-FoV UAV remote sensing benchmarks: VisDrone-DET [45] and UAVDT [46].

• VisDrone-DET: VisDrone-DET denotes the image object detection subset of the broader VisDrone benchmark. We utilized the VisDrone-DET dataset to evaluate the model’s generalization capability across complex environments. This dataset was collected by various UAV platforms across wide-FoV scenarios in 14 different cities, comprising 10,209 high-resolution images (with resolutions ranging from $960\times 540$ to $2000\times 1500$). Following the standard protocol described in [45], we partitioned the data into a training set (6471 images), a validation set (548 images), and a test set (3190 images). The dataset covers diverse geographical settings, ranging from urban to rural areas, and includes 10 typical categories such as pedestrians and vehicles. Its significant environmental diversity and extreme scale variations make it an ideal benchmark for validating the robustness of wide-field object detection algorithms.
• UAVDT: To further verify the efficiency of the proposed framework in high-background-redundancy scenarios, we employed the UAVDT dataset. This benchmark focuses on urban traffic monitoring and contains 50 video sequences (approximately 80,000 frames) captured by UAVs at various altitudes and viewing angles, with a uniform resolution of $1024\times 540$. For our experiments, 30 sequences (23,258 frames) were selected for training, and 20 sequences (15,069 frames) were selected for testing. A core characteristic of UAVDT is its pronounced spatial sparsity: while an average image contains about 18 targets, annotated target regions account for only 4.9% of the total pixels, indicating that most image areas correspond to non-target background. This highly sparse distribution provides a stringent test environment for evaluating the efficacy of the proposed G-Cutter strategy in reducing redundant background computation.

4.2. Implementation Details

All experiments were implemented using the PyTorch deep learning framework (version 2.1.0) on a graphics workstation running Ubuntu 20.04 LTS. The hardware configuration consisted of an Intel Core i9-13900K CPU, an NVIDIA GeForce RTX 3090 GPU, and 32 GB of system memory. During training, the Adam optimizer was employed for parameter updates with an initial learning rate of 0.001 and a cosine annealing decay schedule. A linear warm-up strategy was applied during the first five epochs to stabilize early-stage optimization. The batch size was set to 4, and models were trained for 200 epochs to ensure full convergence. Weight decay was fixed at $5\times {10}^{-4}$.

Data augmentation was applied to enhance robustness under scale and viewpoint variations, including random horizontal flipping and multi-scale resizing within a ratio range of 0.5–1.5.

For SP-Masker implementation, SLIC was adopted with approximately $N_s=200$ superpixels per image. Foreground probability estimation was computed using RGB color histograms with 32 bins per channel, and the propagation coefficient ($\alpha$) was fixed at 0.6. The propagation step was set to $T=1$, and the Gaussian smoothing scale was set to ${\sigma }_g=2$. Unless otherwise stated, we keep the SP-Masker settings fixed across all benchmarks.

In G-Cutter, the initial patch size is set as a fixed hyperparameter during training and inference. The base patch size is set to $128\times 128$ on the routed feature map after stem extraction. This setting is selected according to three factors: the projected object-scale distribution on the stem feature grid, the typical spatial extent of local foreground clusters in crowded UAV scenes, and the computation budget required for stable FPS evaluation. The same patch size and patch retention strategy are used for both VisDrone-DET and UAVDT, typically preserving 6–10 high-value patches per image and allowing about 15 patches in dense scenes. Therefore, the patch size is treated as a feature grid-level configuration under a fixed efficiency constraint. For a different input resolution or feature stride, it can be adjusted by preserving a similar relative support on the stem feature grid. A detailed patch-size analysis is provided in the ablation study.

Furthermore, all evaluations of inference speed (Frames Per Second, FPS) were conducted with a batch size of 1 on the specified RTX 3090 platform. Therefore, the reported FPS should be interpreted as a workstation-side throughput indicator under a controlled hardware setting. For energy-sensitive IoT remote sensing deployment, practical cost also depends on power consumption, memory footprint, end-to-end camera-to-detector latency, energy per frame, and embedded-device throughput. These deployment-oriented metrics will be evaluated on edge platforms such as the NVIDIA Jetson series in future work.

4.3. Evaluation Metrics

We evaluate MFRC-Det from two perspectives: detection accuracy and computational throughput. For detection accuracy, Average Precision ($AP$) is used as the primary metric. Specifically, $A{P}_{50}$ is calculated at an Intersection over Union (IoU) threshold of 0.5 to characterize coarse localization performance, while the primary $AP$ metric averages precision over IoU thresholds from 0.5 to 0.95 with a step of 0.05 and, thus, provides a stricter assessment of localization quality. For computational throughput, FPS is reported under the specified hardware setting to characterize the speed–accuracy trade-off. Floating-point operations (FLOPs) and the number of parameters are also reported where applicable to provide additional indicators of computational cost and model size. We note that FPS alone cannot fully characterize deployment cost in energy-sensitive IoT scenarios, where power draw, thermal stability, memory usage, data-transfer latency, and energy per processed frame may also affect practical usability.

4.4. Comparison with Recent Competitive Methods

4.4.1. Quantitative Analysis

Table 3 and Table 4 present the experimental results of MFRC-Det compared with current competitive object detection algorithms on the VisDrone-DET and UAVDT datasets, respectively. All results in the comparison tables were obtained under the same data split, training strategy, and hardware environment. Overall, MFRC-Det achieves a competitive accuracy–efficiency trade-off across both benchmarks.

Table 3. Comparison with recent competitive methods on the VisDrone-DET dataset. The best results are highlighted in bold.

Method	Image Size	AP (%)	AP50 (%)	FPS	FLOPs (G)	Params (M)
FASF [47]	$640\times 640$	26.1	49.7	13.2	72.2	20.0
DSHNet [48]	$640\times 640$	30.4	51.2	15.5	70.1	19.7
UCGNet [49]	$640\times 640$	33.6	53.9	18.2	62.6	23.2
QueryDet [50]	$640\times 640$	28.7	48.5	9.1	45.9	16.9
CEASC [51]	$640\times 640$	28.9	48.8	27.6	150.2	42.9
ClusDet [27]	$640\times 640$	26.7	50.6	6.5	238.8	60.6
YOLOv10-M [52]	$640\times 640$	32.5	49.5	168.7	59.1	15.4
YOLOv11-M [53]	$640\times 640$	33.3	50.0	168.8	68.0	20.1
YOLOv12-M [54]	$640\times 640$	32.2	48.6	164.6	67.5	20.2
RT-DETR-R18 [55]	$640\times 640$	31.5	48.3	79.4	57.0	20.2
RT-DETRv2-R18 [56]	$640\times 640$	35.7	54.1	70.7	60.0	20.0
D-Fine-M [57]	$640\times 640$	32.1	53.6	29.6	56.4	19.2
VRF-DETR [58]	$640\times 640$	30.3	53.9	62.1	44.6	13.8
UAV-DETR-EV2 [59]	$640\times 640$	28.7	47.5	66.2	42.8	13.1
UAV-DETR-R18 [59]	$640\times 640$	29.8	48.8	54.2	77.1	19.8
UAV-DETR-R50 [59]	$640\times 640$	31.5	51.1	40.3	170.0	42.5
Model-R18 [60]	$640\times 640$	27.5	45.9	126.0	79.3	20.8
Model-R50 [60]	$640\times 640$	29.4	47.9	68.8	172.1	42.9
Dome-DETR-S [61]	$640\times 640$	33.5	56.6	66.6	176.5	13.2
Dome-DETR-M [61]	$640\times 640$	36.1	59.8	48.3	284.6	23.9
MFRC-Det (Ours)	$640\times 640$	36.1	60.4	38.5	87.1	25.5

Table 4. Comparison with recent competitive methods on the UAVDT dataset. The best results are highlighted in bold.

Method	Image Size	AP (%)	AP50 (%)	FPS	FLOPs (G)	Params (M)
ClusDet [27]	$1000\times 600$	13.4	26.3	7.9	1647.3	181.0
YOLC [62]	$1024\times 540$	19.3	30.9	1.5	151.0	38.9
LGI-DETR [63]	$1024\times 540$	17.4	30.2	16.6	77.1	19.8
FLDet-N [64]	$1024\times 540$	16.8	28.8	56.2	18.3	4.2
FLDet-S [64]	$1024\times 540$	17.5	30.3	41.3	36.7	9.1
AD-Det [65]	$1024\times 540$	20.1	34.2	7.9	1072.1	64.1
YOLOv5-m	$640\times 640$	17.2	29.8	55.2	64.2	25.1
YOLOv8-m	$640\times 640$	18.8	31.0	59.8	78.9	25.9
FBRT-YOLO-L [66]	$1024\times 540$	18.4	31.1	42.0	119.2	14.6
CollabOD [67]	$1024\times 540$	17.4	31.2	16.2	198.4	63.5
ZoomDet-FRCNN [68]	$1024\times 540$	18.0	32.7	10.7	156.2	41.3
SFFNet-X [69]	$1024\times 540$	20.6	34.4	24.8	124.8	38.6
RemDet-L [70]	$1024\times 540$	20.6	34.5	28.4	67.4	35.3
PRNet [71]	$1024\times 540$	20.8	32.3	23.0	89.5	27.4
Deformable DETR [72]	$1333\times 800$	17.1	28.4	8.2	172.5	40.2
MFRC-Det (Ours)	$1024\times 540$	21.3	36.8	37.4	112.3	25.5

Compared with representative “focus-then-detect” methods such as ClusDet, MFRC-Det achieves a favorable balance between detection precision and inference speed across both datasets. This advantage is related to feature-level routing. Most focus-then-detect methods crop image patches at the pixel level and repeatedly run the backbone on these cropped regions. MFRC-Det performs target search and patch selection on the feature map after a single backbone pass, which reduces redundant computation in overlapping regions. The reported FLOPs and FPS indicate the accuracy–computation trade-off of MFRC-Det: the model maintains competitive AP while avoiding the extremely high computational burdenof repeated crop-based pipelines.

Furthermore, the comparison with general-purpose detectors helps position MFRC-Det within the accuracy–efficiency spectrum. These comparisons show that MFRC-Det provides a specialized accuracy–efficiency trade-off for background-dominated wide-FoV UAV imagery, complementing general-purpose detectors that are designed for broader detection scenarios. Mask-guided feature routing suppresses redundant background computation through a single backbone pass followed by feature-level patch selection, while adaptive context modeling improves scale-adaptive feature aggregation within the retained foreground regions. Together, these two mechanisms provide a favorable balance between detection precision and computational efficiency.

4.4.2. Ablation Study

Effectiveness of SP-Masker

As summarized in Table 5, we evaluate the effectiveness of the superpixel-based scheme in SP-Masker by comparing it with three representative foreground extraction strategies on VisDrone-DET: CPN, CDM [73], and SAM [74].

Table 5. Ablation study on SP-Masker. The best results are highlighted in bold.

Method	${\mathit{A}\mathit{P}}_{50}$ (%)	FPS
CPN [43]	50.9	12.4
CDM [73]	51.8	10.7
SAM [74]	60.7	7.3
SP-Masker (Ours)	60.4	38.5

The results clarify the trade-off of different foreground extraction strategies under wide-FoV settings. Regression-centric schemes such as CPN rely on bounding box-oriented candidate generation, which is less stable for micro-scale targets in shallow feature hierarchies and yields an $A{P}_{50}$ of 50.9%. CDM captures global distribution trends through density estimation, but its emphasis on center responses limits its ability to preserve spatial extent for patch slicing. SAM provides a strong semantic-mask reference and achieves the highest $A{P}_{50}$ of 60.7%, with a speed of 7.3 FPS due to its heavy segmentation inference. SP-Masker introduces no learnable parameters and achieves comparable detection performance with much higher throughput. This result supports the use of non-parametric spatial prior modeling for efficient foreground routing in wide-FoV UAV detection.

Effect of G-Cutter Patch Size

To clarify how the default setting is selected, we evaluate several fixed G-Cutter patch sizes on the VisDrone-DET dataset under the same training and inference protocol. The size is defined on the routed stem feature grid. A smaller window improves inference speed but may cut off large foreground regions or split dense clusters across multiple windows. A larger window preserves more surrounding context but also routes more background responses to the detection head. Therefore, this setting controls the trade-off among foreground support, routed background redundancy, and inference throughput.

As shown in Table 6, the fixed $128\times 128$ setting achieves the best overall detection accuracy among the evaluated strategies, with 36.1% AP and 60.4% AP₅₀ while maintaining 38.5 FPS. Reducing the patch size to $96\times 96$ increases FPS to 40.6, but AP and AP₅₀ decrease to 35.4% and 59.2%, respectively. This result indicates that overly compact windows may cut off large foreground support or split dense foreground clusters across multiple routed regions. Increasing the patch size to $160\times 160$ does not improve detection accuracy; AP decreases to 35.9%, and AP₅₀ decreases to 60.1%, while FPS drops to 34.3 because each retained region contains more background responses.

Table 6. Effect of G-Cutter patch size on detection accuracy and inference efficiency on the VisDrone-DET dataset. The best results are highlighted in bold. For adaptive sizing, Avg. Patches is omitted because the routed regions have variable spatial sizes.

Patch-Size Strategy	AP (%)	AP50 (%)	Avg. Patches	FPS
$96\times 96$	35.4	59.2	8.7	40.6
$128\times 128$	36.1	60.4	8.3	38.5
$160\times 160$	35.9	60.1	8.0	34.3
Adaptive sizing	36.0	60.4	-	28.3

We also evaluate a mask-support adaptive patch strategy, where the routed window size is adjusted according to the connected foreground response around each selected anchor. This adaptive strategy obtains 36.0% AP and 60.4% AP₅₀, showing accuracy comparable to the fixed $128\times 128$ setting. However, its FPS decreases from 38.5 to 28.3 due to the additional overhead introduced by variable-size routing, padding, and alignment operations in standard batch-processing frameworks. These results show that adaptive patch sizing can increase routing flexibility, but it does not provide a better accuracy–efficiency trade-off under the current implementation. Therefore, we use the fixed $128\times 128$ setting as the default configuration, since it provides the most favorable balance between detection accuracy, routing stability, and inference efficiency.

Patch-Support Recall Analysis

We further analyze whether fixed-size routing affects objects whose spatial extent exceeds the routed window. For each ground-truth box projected onto the stem feature grid, we define the relative object size as

$$\rho =max\left({\displaystyle \frac{w_b}{W_p}},{\displaystyle \frac{h_b}{H_p}}\right)$$

(25)

Here, $w_b$ and $h_b$ denote the projected width and height of the ground-truth box and $W_p$ and $H_p$ denote the window width and height. A larger $\rho$ indicates that the object occupies a larger portion of the routed region. When $\rho \ge 1.0$, at least one side of the object exceeds the window size.

As shown in Table 7, most objects have $\rho <0.5$, indicating that the default $128\times 128$ window covers most UAV targets on the stem feature grid. The recall decreases from 62.5% to 55.1% as $\rho$ increases, showing that patch-exceeding objects are more likely to receive incomplete foreground evidence. These results indicate that G-Cutter mainly affects a limited subset of large objects, while the default setting remains suitable for most compact small and medium targets in VisDrone-DET.

Table 7. Recall analysis with respect to object size relative to the G-Cutter patch size on the VisDrone-DET dataset.

Object Group	Object Prop. (%)	Recall (%)	Missed Prop. (%)
$\rho <0.5$	64.2	62.5	61.9
$0.5\le \rho <1.0$	27.4	59.6	28.4
$\rho \ge 1.0$	8.4	55.1	9.7

Boundary-Distance Recall Analysis

To quantify the influence of the peripheral background prior used in SP-Masker, we further group ground-truth objects according to their normalized distance to the nearest image border. Specifically, for an object with center $(x_c,y_c)$ in an image of size $H\times W$, the normalized border distance is defined as

$$r={\displaystyle \frac{min(x_c,W-x_c,y_c,H-y_c)}{min(H,W)}}.$$

(26)

A smaller r indicates that the object is closer to the image boundary. We report the object-level recall of MFRC-Det in different distance groups to examine whether near-border targets are more likely to be missed by the boundary-strip prior. A ground-truth object is regarded as recalled if it is matched by a predicted box with an IoU $\ge 0.5$.

As shown in Table 8, the recall decreases as objects become closer to the image boundary. The nearest-border group ($0\le r<0.05$) accounts for 11.4% of all ground-truth objects and 13.3% of all missed objects. The center-region group ($r\ge 0.20$) accounts for 44.6% of ground-truth objects and 41.7% of missed objects. These statistics show that near-border objects are relatively sparse in the test set, but their missed-object proportion is higher than their occurrence frequency. The center-region group has a missed-object proportion lower than its ground-truth proportion. Therefore, the near-border recall drop mainly reflects an increased miss risk within boundary-adjacent objects. Most missed detections still come from inner regions because these regions contain more objects.

Table 8. Boundary-distance recall and missed-object distribution on the VisDrone-DET dataset. A ground-truth object is counted as missed if it is not matched by any predicted box with an IoU $\ge 0.5$.

Border-Distance Group	GT Prop. (%)	Recall (%)	Missed Prop. (%)	Recall Drop (p.p.)
$0\le r<0.05$	11.4	54.2	13.3	9.1
$0.05\le r<0.10$	15.2	57.8	16.4	5.5
$0.10\le r<0.20$	28.8	61.1	28.6	2.2
$r\ge 0.20$	44.6	63.3	41.7	0.0

Effectiveness of ARSNet

Table 9 compares ARSNet with representative scale-handling modules under the same insertion setting. MFRC-Det without ARSNet (w/o ARSNet) is used as the baseline. Brute-force strategies such as SNIPER [75] enhance $AP$ via multi-scale inputs, and their computational cost increases substantially with resolution, resulting in a clear throughput drop under our evaluated GPU setting. FPN-style modules [7] introduce hierarchical fusion with lower overhead than image pyramids. Their fixed fusion topology treats scale interaction in a largely location-agnostic manner, which limits their improvement on $A{P}_S$ in our sparse wide-FoV setting. ARSNet performs scale adaptation after foreground routing by generating multiple receptive-field candidates and aggregating them with spatial weights. This location-wise gating allows different foreground locations to use different receptive-field responses according to their local scale. Compared with the w/o ARSNet baseline, MFRC-Det w/ ARSNet improves $A{P}_S$, $A{P}_M$, and $A{P}_L$ by 10.9, 20.4, and 14.7 percentage points, respectively, while maintaining a favorable FPS of 38.5. These results indicate that spatially adaptive receptive-field selection improves scale-aware representation within the retained foreground regions.

Table 9. Ablation study on ARSNet.

Method	APS (%)	APM (%)	APL (%)	FPS
MFRC-Det (w/o ARSNet)	6.9	17.0	42.4	39.2
+SNIP [76]	13.8	29.8	46.7	8.3
+SNIPER [75]	14.2	32.0	50.6	11.6
+FPN [7]	9.2	20.4	43.7	17.5
+AugFPN [77]	9.8	19.7	44.0	13.7
+EFPN [78]	14.9	29.0	49.2	14.0
+RFP [79]	12.3	27.4	47.5	11.2
+SKNet [34]	12.3	29.6	48.6	26.4
+SCNet [36]	13.5	25.8	43.8	29.7
+ResNeSt [35]	16.9	35.5	56.6	29.4
MFRC-Det (w/ARSNet)	17.8	37.4	57.1	38.5

We further compare ARSNet with representative dynamic convolution operators under the same insertion setting, as summarized in Table 10. This comparison examines different forms of input-conditioned adaptation for wide-FoV UAV object detection. Dynamic convolution operators adapt the convolutional operation through input-conditioned kernel aggregation or attention. ARSNet adapts the effective receptive field through spatial selection over shared candidate responses. Specifically, its candidate convolutional branches are optimized as shared learnable parameters, and the spatial weighting maps are predicted from the current feature to aggregate candidate responses at each location. The results show that ARSNet achieves a favorable balance between detection accuracy and inference efficiency, as shown in Figure 4. This performance indicates that input-conditioned spatial response selection provides an effective form of scale-adaptive context modeling for sparse foreground regions in wide-FoV UAV imagery.

Table 10. Comparison between ARSNet and representative dynamic convolution operators under the same insertion setting. ARSNet uses shared receptive-field candidate branches with input-conditioned spatial selection weights.

Method	Kernel Setting	${\mathit{A}\mathit{P}}_{50}$ (%)	FPS
Atrous Conv	(5, 1) + (7, 3)	42.0	36.6
DynamicConv [80]	Input-dependent kernels	59.7	21.7
SMBlock [81]	Input-adaptive block	55.3	28.2
ARSNet (Ours)	Shared candidates + spatial selection	60.4	38.5

Figure 4. Visual comparison of different adaptive convolution/context modeling methods.

We also conduct runtime profiling under the same inference settings used for FPS evaluation to analyze the computational distribution. The backbone and stem dominate the computation, accounting for 68.5% of the total inference time, followed by ARSNet at 21.2%. SP-Masker and G-Cutter introduce only 4.1% and 1.3% overhead, respectively, and the sparse detection head occupies 4.9%. This distribution confirms that the proposed mask-guided sparsification modules contribute minimal additional cost. The overall efficiency gain of MFRC-Det primarily stems from eliminating repeated backbone evaluations through feature-level routing, with architectural compression and parameter reduction playing a secondary role.

4.4.3. Qualitative Analysis and Visualization

To examine the input-conditioned spatial selection behavior of ARSNet under extreme scale variations, we conduct a visualization analysis on the VisDrone-DET validation set. Figure 5 illustrates the spatial activation maps of ARSNet across diverse input scenarios. We specifically selected representative samples characterized by significant scale heterogeneity—such as the coexistence of large proximal vehicles and distant, micro-scale pedestrians.

Figure 5. Spatial activation maps of ARSNet under different object scales. The visualization illustrates input-conditioned spatial selection over shared receptive-field candidate responses.

The distribution of the heatmaps is consistent with the intended design of ARSNet. For large-scale targets, high-response regions tend to appear in channels associated with broader receptive fields, which supports the use of wider contextual information for object-level representation. For micro-scale targets, activation responses are more concentrated around localized small-receptive-field regions, indicating that ARSNet can preserve fine-grained local cues. This input-conditioned spatial matching behavior suggests that ARSNet helps alleviate scale mismatch in wide-FoV scenarios.

Figure 6 visualizes the processing pipeline of MFRC-Det, including the foreground probability masks generated by SP-Masker, the patches selected by G-Cutter, and the final detection results. The visualization shows that SP-Masker highlights sparse target clusters and that G-Cutter removes large, non-informative regions such as sky and water. It also shows that many micro-scale targets remain visible within the retained patches. These observations support the role of mask-guided feature routing in reducing background redundancy while preserving local cues for tiny objects.

Figure 6. Visualization of mask-guided routing and inference results of MFRC-Det, including the input image, SP-Masker foreground prior, G-Cutter selected patches, and final detection results.

As shown in Figure 7, MFRC-Det yields predictions that are generally well aligned with the ground truth across different wide-FoV UAV scenes. It correctly identifies most vehicles under several challenging conditions, including dense object distributions, small targets, complex background interference, and low-light environments. These visual results are consistent with the quantitative comparisons and suggest that the proposed mask-guided feature routing helps reduce background redundancy while maintaining informative foreground representations.

Figure 7. Visual results of MFRC-Det on the VisDrone-DET dataset. Columns correspond to the original input image, the ground truth, and the inference result of MFRC-Det.

5. Discussion

5.1. Discussion of Mask-Guided Feature Routing and Adaptive Context Modeling

MFRC-Det addresses wide-FoV UAV object detection through the joint design of mask-guided feature routing and adaptive context modeling. This design is aligned with IoT remote sensing scenarios, where wide-area imagery frequently exhibits low foreground density and background-dominated computation. Conventional focus-then-detect pipelines usually invoke the backbone multiple times on local image patches, which introduces substantial redundant computation and may disrupt global contextual continuity. MFRC-Det performs foreground-aware routing directly in feature space, reducing repeated feature encoding and preserving global context.

5.2. Complementary Roles of SP-Masker, G-Cutter, and ARSNet

Within this framework, SP-Masker employs standard SLIC superpixel segmentation as a non-parametric region-grouping tool and aligns the resulting foreground prior to the stem feature grid for feature routing. Its purpose is to provide structurally coherent local support for foreground–background divergence estimation relative to a boundary-strip background reference. This design avoids the instability of pixel-wise modeling and introduces no additional learnable parameters or proposal-generation overhead. SP-Masker and G-Cutter contain non-differentiable operations, including superpixel grouping, histogram-based foreground scoring, peak selection, boundary calibration, and greedy elimination. Their role is to determine the spatial support of feature routing. Once the retained patches are selected, the feature values inside these patches remain connected to the learnable backbone, ARSNet, and detection head through standard back-propagation. Therefore, the training behavior of MFRC-Det can be interpreted as sparse supervision over routed feature regions, with the routing quality determining how much foreground evidence is exposed to the detector in each iteration.

ARSNet complements this sparse routing mechanism by applying spatially adaptive context selection over shared receptive-field candidate responses within the retained regions. It enhances receptive-field diversity and semantic aggregation under sparse layouts, which helps compensate for partial foreground evidence caused by coarse routing. Together, SP-Masker, G-Cutter, and ARSNet form a coarse-to-fine processing pipeline that reallocates computation according to foreground likelihood.

5.3. Limitations and Analysis of Our Failure Case

The proposed SP-Masker still has two main limitations that may affect foreground-prior reliability in challenging scenes. First, the boundary-strip background prior is sensitive to peripheral-reference quality. When salient objects appear close to image borders, their visual responses may enter the boundary reference used for background modeling. This contamination reduces the foreground–background divergence estimated by SP-Masker and can assign boundary-touching objects a lower foreground probability. This effect is more evident for tiny objects with weak texture, truncated objects located at image borders, and objects whose color statistics are similar to nearby background regions. Second, SLIC is a low-level visual grouping method without semantic awareness. In cluttered scenes that contain target-like background textures, the superpixel partition may become fragmented or locally misaligned with object structure. The resulting routing prior can become spatially dispersed, shifted, or insufficiently compact for downstream patch selection.

Another limitation arises from the fixed-window design of G-Cutter. The fixed patch size and upper-bounded patch count keep routing deterministic, batching-friendly, and efficient, but they also constrain the spatial support available to each selected foreground region. As analyzed in Table 7, objects with a larger relative size ($\rho$) are more likely to exceed the default patch support and receive incomplete foreground evidence. In these cases, a selected patch may contain only part of the object region, and the remaining evidence may fall into neighboring patches with lower foreground priority. The resulting errors may appear as localization shifts, low-confidence predictions, or missed detections when the retained patch budget is saturated. Elongated foreground clusters may also cross patch boundaries, but such targets are relatively sparse in the evaluated annotations. Therefore, elongation is discussed as a secondary geometric limitation without an additional quantitative grouping.

We also examine mask-support adaptive patch sizing in Table 6. For each selected foreground anchor, the connected response region is estimated from the SP-Masker probability map, and the patch size is selected from a small candidate set according to the foreground support. This strategy allows compact regions to use smaller windows and larger connected regions to use larger windows. The results show that adaptive sizing provides comparable detection accuracy, but its variable-size routing introduces additional padding and alignment overhead, leading to lower FPS under the current batch-processing implementation. Therefore, the fixed $128\times 128$ setting is retained as the default configuration due to its more stable accuracy–efficiency balance.

Figure 8 illustrates a representative failure case of MFRC-Det. The missed white van is located near the lower-right image boundary, where the peripheral-strip background prior becomes less reliable because the target region partially overlaps with the border reference area. In addition, the van exhibits limited color contrast with the surrounding background. This ambiguity is further aggravated by the nearby blue rooftop, which causes the captured appearance of the white van to shift toward a bluish tone. As a result, the histogram-based foreground initialization of SP-Masker tends to assign this region a background-similar response, which weakens the local routing prior. Consequently, the corresponding patch is not sufficiently emphasized during feature routing, and the object is eventually omitted in the final prediction. This example indicates that SP-Masker may underperform when boundary contamination and chromatic ambiguity occur simultaneously, especially for small or truncated objects located near image borders.

Figure 8. One failure case of MFRC-Det on the VisDrone-DET dataset. The white vehicle in the lower-right corner is missed. From left to right: input image, ground truth, and inference result of MFRC-Det.

This case also reflects the hard support constraint of non-parametric routing. If a true object repeatedly receives low foreground scores, its feature region may be selected less frequently and receive weaker optimization signals during training. Across training, data augmentation and local appearance variation can reduce this effect by changing the foreground prior. Boundary-contaminated, low-contrast, or background-like objects may remain hard to route.

This observation suggests that the robustness of mask-guided routing depends on foreground-prior coverage near image boundaries. A concrete improvement is multi-reference background sampling. The boundary area can be divided into several strips and corner regions to construct multiple background candidates. Candidate references with high local contrast, high foreground likelihood, or strong overlap with activated object-like responses can be down-weighted before aggregation. This design reduces the influence of object-contaminated boundary regions on foreground-prior estimation.

A second extension is lightweight learnable refinement after SP-Masker. The refinement module can take the initial foreground probability map, local image features, and boundary-distance encoding as inputs, then predict a residual correction map for ambiguous regions. The corrected prior can be used by G-Cutter for patch ranking and selection. This design keeps the non-parametric foreground prior as the initialization while improving the routing response for boundary-touching and visually ambiguous objects.

A further practical limitation lies in deployment-oriented evaluation. The current FPS is measured on an RTX 3090 workstation and mainly reflects workstation-side throughput under a controlled setting. In edge-based IoT remote sensing systems, actual deployment performance may also depend on memory bandwidth, power budget, model conversion overhead, camera-to-detector data transfer latency, and runtime scheduling. Future work will evaluate MFRC-Det on embedded platforms with deployment-oriented metrics, including end-to-end latency, memory usage, power consumption, embedded-device throughput, and energy per frame.

6. Conclusions

This paper presents MFRC-Det, a wide-FoV UAV object detection framework for IoT remote sensing built upon two complementary principles: mask-guided feature routing and adaptive context modeling. The proposed framework targets a core perception bottleneck in wide-area aerial imagery: improving detection quality while avoiding redundant processing over background-dominated regions. By prioritizing informative foreground regions at the feature level, MFRC-Det reduces repeated backbone evaluation on cropped image regions. ARSNet further improves scale-aware representation learning by aggregating context across different receptive fields within the retained regions. Experiments on the VisDrone-DET and UAVDT benchmarks show that MFRC-Det achieves competitive performance in small-object and multi-scale scenarios with favorable computational efficiency. These results suggest that foreground-aware routing and scale-adaptive context modeling constitute a practical design direction for wide-area aerial perception. Future work will further investigate content-adaptive foreground priors, lightweight semantic-aware region grouping, and embedded-platform evaluation to improve robustness in boundary-touching, visually ambiguous, and energy-constrained scenarios.