| Scenes | Exposure time (s) | Data Pairs | Fixed Settings |
| Indoor fixed position | 1/256, 1/128, 1/64, 1/32, 1/16, 1/8, 1/4, 3/8 | 2744 pairs | Format: .raw, resolution: 1280*1024 |
| Indoor sliding platform | 1/256, 1/128, 1/64, 1/32, 1/16, 1/8, 1/4, 3/8 | 800 pairs |
| Outdoor sliding platform | 1/4096, 1/2048, 1/1024, 1/512, 1/256, 1/128, 1/64, 1/32 | 440 pairs |
+
+The cameras are mounted on the sliding platform on sturdy tripods or a fixed platform on a sturdy table. When mounted on the sliding platform, the camera is adjusted to the same position by sliding the platform to minimize the position displacement among images captured by two cameras in the same scene. When mounted on the fixed platform, the camera is attached to the same position as the platform to minimize the position displacement. Camera gain is set with the camera default value. Focal lengths are adjusted to maximize the quality of the images under long exposure. The exposure time is adjusted according to the specific scene environment.
+
+Position displacement is unavoidable in the capture process. Hence, it is necessary to align the images captured from two cameras. The best exposure colored raw and monochrome raw is selected to align the images captured by two cameras in the same scenes. Then, homography feature matching is utilized to extract key points from the selected image pair, and a brute force matcher is utilized to find the matched key points. The extracted locations of good matches are filtered based on an empirical thresholding method. A homography matrix can be decided based on the filtered location of good matches. Finally, the homography transformation is applied to other images captured from the same scene. The statistic information of the dataset is summarized in Table 1. Fig. 2(a) demonstrates a series of monochrome-colored raw paired images from the dataset.
+
+Artificial Mono-Colored Raw SID Dataset. The original SID dataset collected in [3] contains 5,094 raw short-exposure images taken from the indoor and outdoor environments, while each short-exposure image has a corresponding long-exposure reference image. The short exposure time is usually between 1/30 second and 1/10 second, and the exposure time of the corresponding long-exposure image is 10 to 30 seconds.
+
+However, monochrome images are not available in the original SID dataset. To address this, we built an artificial Mono-colored raw dataset based on SID [3] dataset in this work. More specifically, we first convert the long-exposure raw images in the original SID dataset to RGB images, and these RGB images are further converted to grayscale by forming a weighted sum of the R, G, and B channels, as shown in Fig. 3(h). Such conversion can eliminate the hue and saturation information while retaining the luminance information.
+
+
+(a) Input raw
+
+
+(b) CSAIE
+
+
+
+
+
+
+
+
+
+
+
+
+(c) HE
+
+
+(d) SGN [6]
+
+
+(e) DID [18]
+
+
+(f) RED [14]
+
+
+(g) SID [3]
+
+
+(h) LDC [31]
+
+
+(i) Ours
+
+
+(j) GT
+
+
+(A) Input raw
+(F) RED
+Figure 4. Visual results of state-of-the-art methods and ours on low-light images RAW in our dataset. The larger boxes show the zoom-in version of the regions in the smaller boxes of the same color. The 'CSAIE' means 'Commercial Software Automatic Image Enhancement'.
+
+
+(B) CSAIE
+(G) SID [3]
+
+
+(C) HE
+(H) LDC [31]
+
+
+(D) SGN [6]
+(I) Ours
+
+
+(E) DID [18]
+(J) GT
+
+# 3.4. Training
+
+By default, we pre-process the input images similarly to [3] where images' pixel values are amplified with predefined ratios followed by a pack raw operation. We incorporate the CA layer [8] to bridge the domain gap between features from monochrome and colored raw images. The whole system is trained jointly with L1 loss to directly output the corresponding long-exposure monochrome and sRGB images.
+
+The dataset is split into train and test sets without overlapping by the ratio of 9:1. The input patches are randomly cropped from the original images with $512 \times 512$ . In the case of raw image input, the RGGB pixel position is carefully preserved in the cropping process. We implement our model with Pytorch 1.7 on the RTX 3090 GPU platform, and we train the networks from scratch using the Adam [12] optimizer. The learning rate was set to $10^{-4}$ and $10^{-5}$ after converging, and the weight-decay was set to 0.
+
+# 4. Experiments and Results
+
+In this section, we present a comprehensive performance evaluation of the proposed low-light image enhancement system. To measure the performance, we evaluate the system performance in terms of peak signal-to-noise ratio (PSNR) and structural similarity (SSIM). For PSNR and SSIM, a higher value means a better similarity between output image and ground truth.
+
+# 4.1. Comparison with State-of-the-Art Methods
+
+Qualitative Comparison. We first visually compare the results of the proposed method with other state-of-the-art deep learning-based image enhancement methods, including SID [3], DID [18],SGN [6],LDC [31],and RED [14]. In addition, the traditional histogram equalization (HE) approach and a Commercial Software Automatic Image Enhancement (CSAIE) method are also included in the com
+
+Table 2. Comparison with SOTA.
+
+| Method | multi-scale | #Epochs | #Params (M) | GFLOPs | AP | \( AP_{0.5} \) | \( AP_{0.75} \) | \( AP_S \) | \( AP_M \) | \( AP_L \) |
| Baseline methods trained for long epochs: |
| Faster-RCNN-R50-DC5 [35] | | 108 | 166 | 320 | 41.1 | 61.4 | 44.3 | 22.9 | 45.9 | 55.0 |
| Faster-RCNN-FPN-R50 [24,35] | ✓ | 108 | 42 | 180 | 42.0 | 62.1 | 45.5 | 26.6 | 45.4 | 53.4 |
| DETR-R50 [3] | | 500 | 41 | 86 | 42.0 | 62.4 | 44.2 | 20.5 | 45.8 | 61.1 |
| DETR-R50-DC5 [3] | | 500 | 41 | 187 | 43.3 | 63.1 | 45.9 | 22.5 | 47.3 | 61.1 |
| Comparison of SAM-DETR with other detectors under shorter training schemes: |
| Faster-RCNN-R50 [35] | | 12 | 34 | 547 | 35.7 | 56.1 | 38.0 | 19.2 | 40.9 | 48.7 |
| DETR-R50 [3]‡ | | 12 | 41 | 86 | 22.3 | 39.5 | 22.2 | 6.6 | 22.8 | 36.6 |
| Deformable-DETR-R50 [63] | | 12 | 34 | 78 | 31.8 | 51.4 | 33.5 | 15.0 | 35.7 | 44.7 |
| Conditional-DETR-R50 [31] | | 12 | 44 | 90 | 32.2 | 52.1 | 33.4 | 13.9 | 34.5 | 48.7 |
| SMCA-DETR-R50 [10] | | 12 | 42 | 86 | 31.6 | 51.7 | 33.1 | 14.1 | 34.4 | 46.5 |
| SAM-DETR-R50 (Ours) | | 12 | 58 | 100 | 33.1 | 54.2 | 33.7 | 13.9 | 36.5 | 51.7 |
| SAM-DETR-R50 w/ SMCA (Ours) | | 12 | 58 | 100 | 36.0 | 56.8 | 37.3 | 15.8 | 39.4 | 55.3 |
| Faster-RCNN-R50-DC5 [35] | | 12 | 166 | 320 | 37.3 | 58.8 | 39.7 | 20.1 | 41.7 | 50.0 |
| DETR-R50-DC5 [3]‡ | | 12 | 41 | 187 | 25.9 | 44.4 | 26.0 | 7.9 | 27.1 | 41.4 |
| Deformable-DETR-R50-DC5 [63] | | 12 | 34 | 128 | 34.9 | 54.3 | 37.6 | 19.0 | 38.9 | 47.5 |
| Conditional-DETR-R50-DC5 [31] | | 12 | 44 | 195 | 35.9 | 55.8 | 38.2 | 17.8 | 38.8 | 52.0 |
| SMCA-DETR-R50-DC5 [10] | | 12 | 42 | 187 | 32.5 | 52.8 | 33.9 | 14.2 | 35.4 | 48.1 |
| SAM-DETR-R50-DC5 (Ours) | | 12 | 58 | 210 | 38.3 | 59.1 | 40.1 | 21.0 | 41.8 | 55.2 |
| SAM-DETR-R50-DC5 w/ SMCA (Ours) | | 12 | 58 | 210 | 40.6 | 61.1 | 42.8 | 21.9 | 43.9 | 58.5 |
| Faster-RCNN-R50 [35] | | 36 | 34 | 547 | 38.4 | 58.7 | 41.3 | 20.7 | 42.7 | 53.1 |
| DETR-R50 [3]‡ | | 50 | 41 | 86 | 34.9 | 55.5 | 36.0 | 14.4 | 37.2 | 54.5 |
| Deformable-DETR-R50 [63] | | 50 | 34 | 78 | 39.4 | 59.6 | 42.3 | 20.6 | 43.0 | 55.5 |
| Conditional-DETR-R50 [31] | | 50 | 44 | 90 | 40.9 | 61.8 | 43.3 | 20.8 | 44.6 | 59.2 |
| SMCA-DETR-R50 [10] | | 50 | 42 | 86 | 41.0 | - | - | 21.9 | 44.3 | 59.1 |
| SAM-DETR-R50 (Ours) | | 50 | 58 | 100 | 39.8 | 61.8 | 41.6 | 20.5 | 43.4 | 59.6 |
| SAM-DETR-R50 w/ SMCA (Ours) | | 50 | 58 | 100 | 41.8 | 63.2 | 43.9 | 22.1 | 45.9 | 60.9 |
| Deformable-DETR-R50 [63] | ✓ | 50 | 40 | 173 | 43.8 | 62.6 | 47.7 | 26.4 | 47.1 | 58.0 |
| SMCA-DETR-R50 [10] | ✓ | 50 | 40 | 152 | 43.7 | 63.6 | 47.2 | 24.2 | 47.0 | 60.4 |
| Faster-RCNN-R50-DC5 [35] | | 36 | 166 | 320 | 39.0 | 60.5 | 42.3 | 21.4 | 43.5 | 52.5 |
| DETR-R50-DC5 [3]‡ | | 50 | 41 | 187 | 36.7 | 57.6 | 38.2 | 15.4 | 39.8 | 56.3 |
| Deformable-DETR-R50-DC5 [63] | | 50 | 34 | 128 | 41.5 | 61.8 | 44.9 | 24.1 | 45.3 | 56.0 |
| Conditional-DETR-R50-DC5 [31] | | 50 | 44 | 195 | 43.8 | 64.4 | 46.7 | 24.0 | 47.6 | 60.7 |
| SAM-DETR-R50-DC5 (Ours) | | 50 | 58 | 210 | 43.3 | 64.4 | 46.2 | 25.1 | 46.9 | 61.0 |
| SAM-DETR-R50-DC5 w/ SMCA (Ours) | | 50 | 58 | 210 | 45.0 | 65.4 | 47.9 | 26.2 | 49.0 | 63.3 |
| Accelerating DETR's convergence with self-supervised learning: |
| UP-DETR-R50 [6] | | 150 | 41 | 86 | 40.5 | 60.8 | 42.6 | 19.0 | 44.4 | 60.0 |
| UP-DETR-R50 [6] | | 300 | 41 | 86 | 42.8 | 63.0 | 45.3 | 20.8 | 47.1 | 61.7 |
+
+Table 1. Comparison of the proposed SAM-DETR, other DETR-like detectors, and Faster R-CNN on COCO 2017 val set. $\ddagger$ denotes the original DETR [3] with aligned setups, including increased number of object queries (100→300) and focal loss for classification.
+
+We adopt two training schemes for experiments, which include a 12-epoch scheme where the learning rate decays after 10 epochs, as well as a 50-epoch scheme where the learning rate decays after 40 epochs.
+
+# 4.2. Experiment Results
+
+Table 1 presents a thorough comparison of the proposed SAM-DETR, other DETR-like detectors [3, 6, 10, 31, 63], and Faster R-CNN [35]. As shown, Faster R-CNN and DETR can both achieve impressive performance when trained for long epochs. However, when trained for only
+
+12 epochs, Faster R-CNN still achieves good performance, while DETR performs substantially worse due to its slow convergence. Several recent works [10, 31, 63] modify the original attention mechanism and effectively boost DETR's performance under the 12-epoch training scheme, but still have large gaps compared with the strong Faster R-CNN baseline. For standalone usage, our proposed SAM-DETR can achieve a significant performance gain compared with the original DETR baseline $(+10.8\%)$ AP) and outperform all DETR's variants [10, 31, 63]. Furthermore, the proposed SAM-DETR can be easily integrated with existing
+
+ | adaptive to decode locations? | adaptive to decode content? | extra networks before the query decoder1? |
| DETR [4] | yes, multi-head attention aggregation | no, linear projection | TransformerEncoder |
| Deformable DETR [53] | yes, multi-scale multi-head adaptive sampling | no, linear projection2 | Multi-scale DeformTransEncoder |
| Sparse R-CNN [37] | restricted, RoIAlign [16] | partially yes, adaptive point-wise conv. | FPN |
| AdaMixer (ours) | yes, adaptive 3D sampling | yes, adaptive channel and spatial mixing | linear projection to form 3D feature space |
+
+Table 1. Comparisons of the adaptability of decoders across different query-based object detectors. We specify trainable networks introduced after pre-trained backbones before the query decoder. We regard the softmax aggregation in deformable attention as one step in decoding locations as the softmax weights normalize to one.
+
+# 3. Approach
+
+In this paper, we focus on the query decoder in query-based object detectors since the decoder design is essential to casting learned queries to potential objects in each image. We first revisit decoders in popular query-based object detectors from the perspective of semantic and positional adaptability, and then elaborate on our proposed adaptive query decoder.
+
+# 3.1. Object Query Decoder Revisited
+
+Plain attention decoders. DETR [4] applies plain multihead cross attention between queries and features to cast object queries to potential objects. As depicted in Table 1, the cross attention decoder is adaptive to decode sampling locations in the sense that it exploits the relation of object queries and features to aggregate features. However, the linear transformation of features after aggregation fails to adaptively decode them based on the query.
+
+Deformable multi-scale attention decoders. Deformable DETR [53] improves the ability of decoding sampling locations in plain cross attention in terms of shift equivalence and scale invariance by introducing explicit reference points and multi-scale features. But like DETR, the content decoding of sampled features still remains static by the linear transformation. Overall, decoders in DETR and Deformable DETR lack the reasoning of aggregated features conditionally on the query and thus limit the semantic adaptability of queries to features. As a result, both of them require stacks of extra attentional encoders to enrich feature semantics.
+
+RoIAlign and dynamic interactive head as decoders. Sparse R-CNN [37], as the intersection between region-based and query-based detectors, uses the RoIAlign operator and dynamic interactive head as the query decoder. The dynamic interactive head uses point-wise convolutions, whose kernel is adaptive based on the query, to process RoI features. This enables the adaptability of queries to RoI features but only partially, in the sense that the adaptive pointwise convolution can not infer adaptive spatial structures from those features to build queries. Moreover, the sampling locations by RoIAlign operator [16] are restricted inside of the box indicated by a query and a specific level in FPN [22], which limits positional adaptability and requires explicit pyramid networks for multi-scale modeling.
+
+Summary. Given a limited number of queries and varying potential objects across images, an ideal decoder should consider both the semantic and positional adaptability of such queries to the content of images, that is, how to adaptively decode sampling locations and sampled content. This naturally motivates our design of AdaMixer.
+
+# 3.2. Our Object Query Definition
+
+Starting from the object query definition, we associate two vectors with a query following our semantic and positional view of decoders: one is the content vector $\mathbf{q}$ and the other is the positional vector $(x,y,z,r)$ . This is also in line with [37, 43, 53] to disentangle the location or the represented bounding box of a query from its content. The content vector $\mathbf{q}$ is a vector in $\mathbb{R}^{d_q}$ and $d_{q}$ is the channel dimension. The vector $(x,y,z,r)$ describes scaled geometric properties of the bounding box indicated by a query, that is, the x- and y-axis coordinates of its center point and the logarithm of its scale and aspect ratio. The $x,y,z$ components also directly represent coordinates of a query in the 3D feature space, which will be introduced below.
+
+Decoding the bounding box from a query. We can simply decode the bounding box from the positional vector. The center $(x_{B},y_{B})$ and the width and height $w_{B}$ and $h_B$ of the indicated bounding box can be decoded:
+
+$$
+x _ {B} = s _ {\text {b a s e}} \cdot x, \quad y _ {B} = s _ {\text {b a s e}} \cdot y, \tag {1}
+$$
+
+$$
+w _ {B} = s _ {\text {b a s e}} \cdot 2 ^ {z - r}, h _ {B} = s _ {\text {b a s e}} \cdot 2 ^ {z + r}, \tag {2}
+$$
+
+where $s_{\mathrm{base}}$ is the base downsampling stride offset and we set $s_{\mathrm{base}} = 4$ according to the stride of the largest feature map we use in the experiments.
+
+# 3.3. Adaptive Location Sampling
+
+As discussed in Section 3.1, the decoder should adaptively decide which feature to sample regarding the query. That is, the decoder should decode sampling locations with the consideration of both the positional vector $(x,y,z,r)$ and content vector $\mathbf{q}$ . Also, we argue that the decoder must be adaptive not only over $(x,y)$ space but also be flexible in scales of potential objects. Specifically, we can accomplish these goals by regarding multi-scale features as a 3D feature space and adaptively sampling features from it.
+
+Multi-scale features as the 3D feature space. Given a feature map, indexed $j$ , with the downsampling stride $s_j^{\mathrm{feat}}$
+
+
+Figure 2. 3D feature sampling process. A query first obtains sampling points in the 3D feature space and then perform 3D interpolation on these sampling points.
+
+
+Figure 3. Adaptive mixing procedure between an object query and sampled features. The object query first generates adaptive mixing weights and then apply these weights to mix sampled features in the channel and spatial dimension. Note that for clarity, we demonstrate adaptive mixing for one sampling group.
+
+from the backbone, we first transform them by a linear layer to the same channel $d_{\mathrm{feat}}$ and compute its z-axis coordinate:
+
+$$
+z _ {j} ^ {\text {f e a t}} = \log_ {2} \left(s _ {j} ^ {\text {f e a t}} / s _ {\text {b a s e}}\right). \tag {3}
+$$
+
+Then we virtually rescale the height and width of feature maps of different strides to the same ones $H / s_{\mathrm{base}}$ and $W / s_{\mathrm{base}}$ , where $H$ and $W$ is the height and width of the input image, and put them aligned on x- and y-axis in the 3D space as depicted in Figure 2. These feature maps are supporting planes for the 3D feature space, whose interpolation is described below.
+
+Adaptive 3D feature sampling process. A query first generate $P_{\mathrm{in}}$ sets of offset vectors to $P_{\mathrm{in}}$ points, $\{(\Delta x_i, \Delta y_i, \Delta z_i)\}_{P_{\mathrm{in}}}$ , where each offset vector is indexed by $i$ , and depends on its content vector $\mathbf{q}$ by a linear layer:
+
+$$
+\left\{\left(\Delta x _ {i}, \Delta y _ {i}, \Delta z _ {i}\right) \right\} _ {P _ {\text {i n}}} = \operatorname {L i n e a r} (\mathbf {q}). \tag {4}
+$$
+
+Then, these offsets are transformed to sampling locations according to the positional vector of the query for every $i$ :
+
+$$
+\left\{ \begin{array}{l} \tilde {x} _ {i} = x + \Delta x _ {i} \cdot 2 ^ {z - r}, \\ \tilde {y} _ {i} = y + \Delta y _ {i} \cdot 2 ^ {z + r}, \\ \tilde {z} _ {i} = z + \Delta z _ {i}, \end{array} \right. \tag {5}
+$$
+
+It is worth noting that the area $\{\Delta x_i, \Delta y_i \in [-0.5, 0.5]\}$ describes the bounding box decoded from the query. Our offsets are not restricted to this range, meaning that a query can sample features "out of the box". Having obtained $\{(\tilde{x}_i, \tilde{y}_i, \tilde{z}_i)\}_{P_{\mathrm{in}}}$ , our sampler samples values given these points in the 3D space. In the current implementation, the interpolation over the 3D space is in the compositional manner: it first samples values given points by bilinear interpolation in the $(x,y)$ space and then interpolates over the z-axis by gaussian weighting given a sampling $\tilde{z}$ , where the weight for the $j$ -th feature map is:
+
+$$
+\tilde {w} _ {j} = \frac {\exp \left(- \left(\tilde {z} - z _ {j} ^ {\text {f e a t}}\right) ^ {2} / \tau_ {z}\right)}{\sum_ {j} \exp \left(- \left(\tilde {z} - z _ {j} ^ {\text {f e a t}}\right) ^ {2} / \tau_ {z}\right)}, \tag {6}
+$$
+
+where $\tau_z$ is the softing coefficient for interpolating values over the z-axis and we keep $\tau_z = 2$ in this work. With the feature map of the channel $d_{\mathrm{feat}}$ , the shape of sampled feature matrix $\mathbf{x}$ is $\mathbb{R}^{P_{\mathrm{in}} \times d_{\mathrm{feat}}}$ . The adaptive 3D feature sampling process eases the decoder learning by sampling features with explicit, adaptive and coherent locations and scales regarding a query.
+
+Group sampling. To sample as many points as possible, we introduce the group sampling mechanism, analogous to multiple heads in attentional operators [40] or groups in group convolution [44]. The group sampling first splits the channel $d_{\mathrm{feat}}$ of the 3D feature space into $g$ groups, each with the channel $d_{\mathrm{feat}} / g$ , and performs 3D sampling individually for each group. With the group sampling mechanism, the decoder can generate $g \cdot P_{\mathrm{in}}$ offset vectors for a query to enrich the diversity of sampling points and exploit richer spatial structure of these points. Sampled feature matrix $\mathbf{x}$ now are of the shape $\mathbb{R}^{g \times P_{\mathrm{in}} \times (d_{\mathrm{feat}} / g)}$ . The grouping mechanism is also applied to the adaptive mixing for efficiency as described below, and we term the group sampling and mixing unified as the grouping mechanism.
+
+# 3.4. Adaptive Content Decoding
+
+With features sampled, how to adaptively decode them is another key design in our AdaMixer decoder. To capture correlation in spatial and channel dimension of $\mathbf{x}$ , we propose to efficiently decode the content in each dimension separately. Specifically, we design a simplified and adaptive variant of MLP-mixer [39], termed as adaptive mixing, with dynamic mixing weights similar to dynamic filters in convolutions [19]. As shown in Figure 3, the procedure contains sequentially the adaptive channel mixing and adaptive spatial mixing to involve both adaptive channel semantics and spatial structures under the guidance of a query.
+
+Adaptive channel mixing. Given sampled feature matrix $\mathbf{x} \in \mathbb{R}^{P_{\mathrm{in}} \times C}$ for a query in a group, where $C = d_{\mathrm{feat}} / g$ , the adaptive channel mixing (ACM) is to use the dynamic weight based on $\mathbf{q}$ to transform features $\mathbf{x}$ on the channel
+
+
+Figure 4. Our decoder structure of the AdaMixer. There are two operator streams on a query: one on its content vector $\mathbf{q}$ (the solid horizontal line) and one on its positional vector $(x,y,z,r)$ (the dashed horizontal line). Each operator on the content vector in the decoder is followed by a residual addition and LayerNorm.
+
+dimension to adaptively enhance channel semantics:
+
+$$
+M _ {c} = \operatorname {L i n e a r} (\mathbf {q}) \in \mathbb {R} ^ {C \times C} \tag {7}
+$$
+
+$$
+\operatorname {A C M} (\mathbf {x}) = \operatorname {R e L U} \left(\operatorname {L a y e r N o r m} \left(\mathbf {x} M _ {c}\right)\right), \tag {8}
+$$
+
+where $\mathrm{ACM}(\mathbf{x})\in \mathbb{R}^{P_{\mathrm{in}}\times C}$ is the channel mixed feature output and the linear layer is individual for each group. The layer normalization [1] is applied to both dimensions of the mixed output. Note that in this step, the dynamic weight is shared across different sampling points in 3D space, analogous to adaptive $1\times 1$ convolution in [37] on RoI features. Adaptive spatial mixing. To enable the adaptability of a query to spatial structures of sampled features, we introduce the adaptive spatial mixing (ASM) process. As depicted in Figure 3, ASM can be described as firstly transposing channel mixed feature matrix and applying the dynamic kernel to the spatial dimension of it:
+
+$$
+M _ {s} = \operatorname {L i n e a r} (\mathbf {q}) \in \mathbb {R} ^ {P _ {\mathrm {i n}} \times P _ {\mathrm {o u t}}} \tag {9}
+$$
+
+$$
+\operatorname {A S M} (\mathbf {x}) = \operatorname {R e L U} \left(\operatorname {L a y e r N o r m} \left(\mathbf {x} ^ {T} M _ {s}\right)\right), \tag {10}
+$$
+
+where $\mathrm{ASM}(\mathbf{x})\in \mathbb{R}^{C\times P_{\mathrm{out}}}$ is the spatial mixed output and $P_{\mathrm{out}}$ is the number of spatial mixing out patterns. Note that the dynamic weight is shared across different channels. As sampling points may be from different feature scales, ASM naturally involves multi-scale interaction modeling, which is necessary for high performance object detection.
+
+The adaptive mixing procedure overall is depicted in Figure 3, where the adaptive spatial mixing follows the adaptive channel mixing, both applied in a sampling group. The final output of the shape $\mathbb{R}^{g\times C\times P_{\mathrm{out}}}$ across group is flattened and transformed to the $d_{q}$ dimension by a linear layer to add back to the content vector.
+
+# 3.5. Overall AdaMixer Detector
+
+Like the decoder architecture in [4, 53], we place the self-attention between queries, our proposed adaptive mixing, and feedforward-feed network (FFN) sequentially in a
+
+stage of the decoder regarding the query content vector $\mathbf{q}$ , as shown in Figure 4. The query positional vector is updated by another FFN at the end of each stage:
+
+$$
+x ^ {\prime} = x + \Delta x \cdot 2 ^ {z}, y ^ {\prime} = y + \Delta y \cdot 2 ^ {z}, \tag {11}
+$$
+
+$$
+z ^ {\prime} = z + \Delta z, \quad r ^ {\prime} = r + \Delta r, \tag {12}
+$$
+
+where $(\Delta x, \Delta y, \Delta z, \Delta r)$ is produced by the lower small FFN block in Figure 4.
+
+Position-aware multi-head self-attention. Since we disentangle the content and position for a query, the naive multi-head self-attention between the content vectors of queries is not aware of what geometric relation between a query and another query is, which is proven beneficial to suppress redundant detections [4]. To achieve this, we embed positional information into the self-attention. Our positional embedding for the content vector in the sinusoidal form and every component of $(x,y,z,r)$ takes up a quarter of channels. We also embed the intersection over foreground (IoF) as a bias to the attention weight between queries to explicitly incorporate the relation of being contained between queries. The attention for each head is
+
+$$
+\operatorname {A t t n} (Q, K, V) = \operatorname {S o f t m a x} \left(Q K ^ {T} / \sqrt {d _ {q}} + \alpha B\right) V, \tag {13}
+$$
+
+where $B_{ij} = \log (|\mathrm{box}_i\cap \mathrm{box}_j| / |\mathrm{box}_i| + \epsilon)$ , $\epsilon = 10^{-7}$ , $Q, K, V\in \mathbb{R}^{N\times d_q}$ , standing for the query, key and value matrix in the self-attention procedure, and $\alpha$ is a learnable scalar for each head. The $B_{ij} = 0$ stands for the box $i$ being totally contained in the box $j$ and $B_{ij} = \log \epsilon \ll 0$ indicates that there is no overlapping between $i$ and $j$ .
+
+Overall AdaMixer detector. The detection pipeline of AdaMixer is only composed of a backbone and a AdaMixer decoder. It avoids adding explicit feature pyramid networks or attentional encoders between backbone and decoder. The AdaMixer directly gathers predictions of decoded queries as final object detection results.
+
+# 4. Experiments
+
+In this section, we first elaborate on the implementation and training details. Then we compare our models with other competitive detectors with limited training epochs. Next, we perform ablation studies on the design of our detector. We also align the training recipe to other query-based detectors and compare our AdaMixer to them fairly.
+
+# 4.1. Implementation Details
+
+Dataset. We conduct extensive experiments on MS COCO 2017 dataset [24] in mmdetection codebase [6]. Following the common practice, we use trainval35k subset consisting up of 118K images to train our models and use minival subset of 5K images as the validation set.
+
+| Vision Task | Head | Learning Rate | Backbone | Batch Size | Optimizer | Weight Decay |
| Classification | - | {0.001, [0.005:0.005:0.1]} | ResNet18, 34, 50 | [8:4:64] | SGD, Adam, Adamax, Adagrad, Adadelta | {1e-5, [0:5e-5:0.001]} |
| Detection | CascadeRCNN [4], FoveaBox [27], RetinaNet [34], FasterRCNN [45], RepPoints [54], ATSS [56], FSAF [60] | [0.001:0.001:0.025] | ResNet50 [15], ResNeXt50 [52], ResNeSt50 [55] | [4:2:12] |
| Segmentation | GCNet [5], DeepLabv3+ [6], DANet [13], CCNet [19], FCN [36], PSPNet [58], PSANet [59] | [0.001:0.001:0.020] | | | | |
+
+Table 1. Search Space. The continuous hyper-parameters are discretized into the form of [start:step:end]. In the 100,000-level search space, finding the optimal hyper-parameter configuration under limited resources is an extremely difficult problem.
+
+| Stage | Function Description | Involved Operations (Parameters) | Solutions (Parameters' Options) Provided by Existing Works |
| Stage 1: Data Preprocessing Stage | Enhance the representation power of the input. | Input Processing Method (IPM) X' = IPM(X) | IPM1: Real Position (M2) IPM2: Relative Position (M1, M3, M5) IPM3: Real + Relative Position (M4) |
| Stage 2: Feature Extraction Stage | Capture features of the historical trajectory. | Feature Extraction Method (FExM) F = FExM(X', X) | FExM1: Sparse Graph Convolution Network (M1) FExM2: Multilayer Perceptron Network (M2) FExM3: Spatio-Temporal Graph CNN (M3) FExM4: LSTM based Motion Encoder Module (M4) FExM5: GAT-based Crowd Interaction Modeling (M5) |
| Feature Enhancement Method (FEnM) F' = FEnM(X', X, F) | FEnM1: None (M1, M3) FEnM2: Latent Belief Energy-based Module (M2) FEnM3: Attention Pooling Module (M4) FEnM4: LSTM-based Temporal Correlation Modeling (M5) |
| Stage 3: Feature Fusion Stage | Combine features of historical trajectory. | Feature Fusion Method (FFM) Fall = FFM(F, F') | FFM1: Concentrate All Features in Stage 2 (M1, M2, M3) FFM2: Concentrate All Features in Stage 2 and Noise (M4, M5) |
| Stage 4: Trajectory Prediction Stage | Transform the output of the Stage 3 into the expected prediction. | Prediction Processing Structure (PPS) Y = PPS(Fall) | PPS1: Time Convolution Network (M1) PPS2: Time-Extrapolator Convolution Neural Network (M3) PPS3: Multiple Fully-Connected Layer (M2, M4) PPS4: LSTM + Fully-Connected Layer (M5) |
| Output Contents (OC) | OC1: Predict Coordinates Sequentially (M4) OC2: Predict Coordinates Directly (M2, M5) OC3: Predict Parameters of Bi-Variate Gaussian Distribution (M1, M3) |
| Stage 5: Model Training Stage | Determine suitable training setting for the designed Trajectory Prediction model. | Loss Function (LF) | LF1: L2 loss (M2, M4, M5) LF2: Distribution-based Negative Log-Likelihood Loss (M1, M3) |
| Training Mode (TM) | TM1: General LF-based Model Training (M1, M2, M3) TM2: Generative Adversarial Network based Model Training (M4) LM3: Variety Loss based Model Training (M5) |
| Learning Rate (LR) | LR1: 1e-2 (M1, M3) LR2: 1e-4 (M2) LR3: 0.0015 LR4: 1e-3 (M4, M5) |
| Optimization Function (OF) | OF1: Adam (M1, M2, M4, M5) OF2: SGD (M3) |
+
+$$
+\begin{array}{l}\mathrm {I P M} \rightarrow \mathrm {F E x M} \rightarrow \mathrm {F E n M} \rightarrow \mathrm {F E x M} _ {\mathrm {a d d}} \rightarrow \mathrm {F E n M} _ {\mathrm {a d d}}\\\rightarrow \mathrm {F F M} \rightarrow \mathrm {P P S} \rightarrow \mathrm {O C} \rightarrow \mathrm {L F} \rightarrow \mathrm {T M} \rightarrow \mathrm {L R} \rightarrow \mathrm {O F}\end{array}
+$$
+
+$\mathbf{R}_2$ Restrictive Relations. Some operations may fail to cooperate with certain operations to construct effective TP models due to special requirements.
+
+For example, $\mathbf{LF}_2$ in Table 1 is designed for TP models which estimate bi-variate distribution $(\mathbf{OC}_3)$ , not applicable to $\mathbf{OC}_1$ and $\mathbf{OC}_2$ . $\mathbf{FExM}_2$ is unable to deal with variable-length trajectories, and thus fail to predict coordinates sequentially $(\mathbf{OC}_1)$ .
+
+$\mathbf{R}_{3}$ Technical Connections. Some operations may apply the same type of neural architectures or techniques.
+
+For example, both $\mathbf{FExM}_3$ and $\mathbf{PPS}_1$ use CNN, $\mathbf{FExM}_5$ and $\mathbf{FEnM}_3$ apply the attention mechanism.
+
+These association relationships are valuable and can help improve the search performance: $\mathbf{R}_1 - \mathbf{R}_3$ can assist search strategy better understanding characteristics of each operation, obtaining better TP models; $\mathbf{R}_1$ and $\mathbf{R}_2$ can guide the search strategy to avoid invalid operation combinations and thus improve the search efficiency. In addition, we note that the valid and optimal options of the subsequent operations can be affected by the selected TP operation sequence.
+
+Relation-Sequence-Aware Strategy. Based on above features, we design a relation-sequence-aware search strategy in ATPFL, which can utilize relational information among operations, combining with the historical operation sequence to sequentially and efficiently select the optimal subsequent operations, and thus obtain effective TP models. Figure 2 gives the overall framework of our strategy.
+
+Our strategy contains two parts, i.e., GNN based embedding learning and masked RNN optimizer.
+
+Part1: GNN based Embedding Learning. We firstly use GNN to learn the effective embedding representation of each operation from relational information in the TP search space. We treat the operations in search space as nodes and transform $\mathbf{R}_1 - \mathbf{R}_3$ into three different types of edges to connect related operation pairs, and thus construct a heterogeneous graph to represent relations among operations. Then, we introduce FAGCN [4], an effective GCN with a self-gating mechanism, to automatically learn associations between nodes and obtain high-level node features by adaptively integrating related neighboring information.
+
+Note that different types of neighbors may make different contributions to the final embedding of the target operation node. Therefore, we make FAGCN adaptively learn the importance of different edge types on the target node.
+
+
+Figure 2. The overall framework of the relation-sequence-aware search strategy in ATPFL. Note that $\mathbf{R_1}$ , i.e., temporal relation, exists between adjacent operations with different types and we omit these edges in the heterogeneous graph.
+
+The embedding learning formula for each operation in the search space is as follows:
+
+$$
+\mathbb {E} _ {i} ^ {\prime} = \epsilon \cdot \mathbf {x} _ {i} + \sum_ {k = 1} ^ {3} \sum_ {j \in \mathcal {N} _ {i, \mathbf {R} _ {\mathbf {k}}}} \frac {\alpha_ {i , j , \mathbf {R} _ {\mathbf {k}}}}{\sqrt {d _ {i , \mathbf {R} _ {\mathbf {k}}} d _ {j , \mathbf {R} _ {\mathbf {k}}}}} \mathbf {x} _ {j} \tag {2}
+$$
+
+where $\mathbf{x}_i$ , $\mathcal{N}_{i,\mathbf{R_k}}$ and $d_{i,\mathbf{R_k}}$ denote the initial embedding representation, neighbor set and node degree w.r.t. edge $\mathbf{R_k}$ of node $i$ , respectively. The attention coefficients $\alpha_{i,j,\mathbf{R_k}}$ are computed based on the trainable parameter vector $\mathbf{a}_{\mathbf{R_k}}$ .
+
+$$
+\alpha_ {i, j, \mathbf {R} _ {\mathbf {k}}} = \operatorname {t a n h} \left(\mathbf {a} _ {\mathbf {R} _ {\mathbf {k}}} ^ {\top} \left[ \mathbf {x} _ {i}, \mathbf {x} _ {j} \right]\right) \tag {3}
+$$
+
+Part2: Masked RNN Optimizer. Then, we use RNN, heterogeneous graph and the learned high-level operation embeddings to sequentially and efficiently obtain the optimal and valid TP model design scheme.
+
+We fed embeddings of the selected operations $o_{1 \sim t} = (o_1, \ldots, o_t)$ into RNN sequentially to extract the effective features $\mathbb{F}_{o_{1 \sim t}}$ of the historical operation sequence. And predict the possibility $\mathbb{P}_{t+1}^{o_{1 \sim t}}$ that each next-step operation is the optimal according to $\mathbb{F}_{o_{1 \sim t}}$ .
+
+$$
+\mathbb {P} _ {t + 1} ^ {\sigma_ {1} \sim t} = \operatorname {s o f t m a x} \left(\mathbf {F C} \left(\mathbf {R N N} \left(\mathbb {E} _ {o _ {1}}, \dots , \mathbb {E} _ {o _ {t}}\right)\right)\right) \tag {4}
+$$
+
+$\mathbb{P}_{t + 1}^{o_{1}\sim t}\in \mathbb{R}^{|S_{t + 1}|}$ , where $S_{t + 1}$ denotes the set of operations in the next step, can guide us to explore more promising TP models, but may recommend invalid TP model design schemes due to ignorance of $\mathbf{R}_2$ restrictive relations among operations. In order to avoid invalid exploration and further improve the search efficiency, we construct a mask vector $\mathbb{M}_{t + 1}^{o_1\sim t}\in \mathbb{R}^{|S_{t + 1}|}$ for $\mathbb{P}_{t + 1}^{o_1\sim t}$ to shield out invalid next-step operations. Specifically, we identify $\mathbf{R}_2$ neighbors of $o_{1\sim t}$ from $S_{t + 1}$ , setting their mask values to 0 while keep the other values to 1, and thus obtain $\mathbb{M}_{t + 1}^{o_1\sim t}$ . With the help of $\mathbb{M}_{t + 1}^{o_1\sim t}$ , $\mathbb{P}_{t + 1}^{o_1\sim t}$ is modified to $\widetilde{\mathbb{P}_{t + 1}^{o_1\sim t}}$ , and thus RNN can filter out the effective operation options and obtain the next best operation more efficiently.
+
+$$
+\widetilde {\mathbb {P} _ {t + 1} ^ {o _ {1} \sim t}} = \operatorname {s o f t m a x} \left(\mathbb {M} _ {t + 1} ^ {o _ {1} \sim t} \cdot \mathbb {P} _ {t + 1} ^ {o _ {1} \sim t}\right) \tag {5}
+$$
+
+Repeat above steps, then a promising and valid TP model design scheme can be obtained.
+
+As for the model parameters $\theta$ involved in the GCN and RNN optimizer, we optimize their weights following the reinforce policy [10, 28].
+
+$$
+\begin{array}{l} \nabla_ {\theta} \mathbb {E} _ {P (o _ {1 \sim 1 2}; \theta)} [ \mathrm {R e w a r d} ] \\ = \sum_ {t = 1} ^ {1 2} \mathbb {E} _ {P \left(o _ {1 \sim t}; \theta\right)} \left[ \nabla_ {\theta} \log \widetilde {\mathbb {P} _ {t} ^ {o _ {1 \sim t - 1}}} (\text {R e w a r d} - b) \right] \tag {6} \\ \end{array}
+$$
+
+where $b$ is an exponential moving average of the previous model rewards, and $Reward$ is the negative ADE score of the TP model generated by RNN optimizer. This reinforce strategy can effectively update the model weights by maximizing the expected benefits of the strategy, guiding our search strategy to recommend better TP models.
+
+# 3.2. Federated Training of the TP Model
+
+ATPFL needs to find suitable federated TP model training methods, to be able to work effectively and efficiently under the FL framework.
+
+Specifically, the optimal model search stage of ATPFL generally needs to evaluate many TP models, and requires a federated training method with fast convergence. In this way, ATPFL can distinguish TP models with different performances using few federated training epochs, and thus reducing evaluation cost and increasing search efficiency. In addition, the optimal TP model training stage of ATPFL requires the most effective federated training method. In this way, ATPFL can gain a more powerful TP model under the FL framework, further improving the final performance.
+
+Based on the above demands, we analyze the convergence speed and federated performance of three federated training methods, including FedAvg [19], Per-FedAvg [7] and pFedMe [6], on TP models, aiming to find appropriate ones to work for ATPFL.
+
+Three Federated Training Methods. Given a dataset $\mathbb{D} = \{D_1, \ldots, D_C\}$ that are distributed and non-shared across $C$ clients, federated training methods optimize the
+
+
+(a) Social-STGCNN Model
+
+
+(b) STGAT Model
+Figure 3. Performance curves of different federated training methods on TP models and a federated TP dataset. We simulates this federated dataset by equally distributing trajectory data of ETH [23] and UCY [15] to 20 clients.
+
+global model weight $\mathbf{w}$ as follows.
+
+$$
+\nabla F (\mathbf {w}) = \frac {1}{C} \sum_ {i = 1} ^ {C} \nabla F _ {i} (\mathbf {w}) \tag {7}
+$$
+
+$$
+\mathbf {w} = \mathbf {w} + \eta \nabla F (\mathbf {w})
+$$
+
+where $F_{i}(\mathbf{w})$ is the local training loss of client $i$ , and is calculated differently in different federated training methods. FedAvg directly considers $f_{i}(\mathbf{w})$ , i.e., the training loss of $\mathbf{w}$ on local dataset $D_{i}$ , as $F_{i}(\mathbf{w})$ :
+
+$$
+F _ {i} (\mathbf {w}) := f _ {i} (\mathbf {w}) \tag {8}
+$$
+
+Per-FedAvg uses personalized models to obtain $F_{i}(\mathbf{w})$ :
+
+$$
+F _ {i} (\mathbf {w}) := f _ {i} \left(\theta_ {i} (\mathbf {w})\right) = f _ {i} (\mathbf {w} - \alpha \nabla f _ {i} (\mathbf {w})) \tag {9}
+$$
+
+pFedMe generates more flexible personalized weights $\vartheta_{i}$ under the guidance of global weight $\mathbf{w}$ to measure $F_{i}(\mathbf{w})$ :
+
+$$
+F _ {i} (\mathbf {w}) := \min _ {\vartheta_ {i}} \left\{f _ {i} \left(\vartheta_ {i}\right) + \frac {\lambda}{2} \left\| \vartheta_ {i} - \mathbf {w} \right\| ^ {2} \right\} \tag {10}
+$$
+
+Features of Three Methods. We analyze the performance curves of above three methods on existing TP models (Figure 3 gives an example). We find that FedAvg coverage the fastest among them at the early training stage, and also achieves the best final performance among them. pFedMe and Per-FedAvg are not prominent in both convergence speed and federated performance, and thus not suitable for our ATPFL algorithm. These findings show us that powerful TP models heavily rely on abundant data sources, and personalized training methods, which pay more attention to the local data, do not help much in TP area.
+
+Based on these observations, we use FedAvg to quickly evaluate TP models during the TP model search stage of ATPFL, and train the optimal TP model in ATPFL. With its help, ATPFL can achieve better performance under FL framework.
+
+# 4. Experiments
+
+In this section, we examine the performance of ATPFL. We analyze the importance of federated training on TP models, and compare the AutoML part of ATPFL with existing AutoML algorithms (Section 4.2). In addition, ablation experiments are conducted to analyze the relation-sequence-aware search strategy designed in ATPFL (Section 4.3). All experiments are implemented using Pytorch.
+
+# 4.1. Experimental Setup
+
+Datasets. In order to evaluate the performance of our approach under FL framework, we construct a federated TP dataset $\mathbb{D}$ by equally distributing trajectory data of two publicly available datasets: ETH [23] and UCY [15], to 20 clients. The ETH dataset contains two scenes of real-world human trajectories, i.e., ETH and Hotel, each with 750 different pedestrians. The UCY dataset has 3 components: ZARA01, ZARA02 and UNIV, containing two scenes with 786 people. In total, our federated TP dataset $\mathbb{D}$ contains 5 sets of data with 4 different trajectory scenes. For each client, we hold the $60\%$ , $20\%$ , $20\%$ of its local dataset as the training set, validation set and test set, respectively. As for the evaluation of TP models under single-source datasets, we take ETH, Hotel, ZARA01, ZARA02 and UNIV as 5 single-source datasets applying the same split ratio.
+
+Evaluation Metrics. We use Average Displacement Error (ADE) [23] and Final Displacement Error (FDE) [1] to examine prediction errors of the TP models.
+
+$$
+\mathrm {A D E} = \frac {\sum_ {i \in \mathcal {P}} \sum_ {t = t _ {\mathrm {o b s}} + 1} ^ {t _ {\mathrm {p r e d}}} \left\| \left(\left(\hat {x} _ {t} ^ {i} , \hat {y} _ {t} ^ {i}\right) - \left(x _ {t} ^ {i} , y _ {t} ^ {i}\right)\right) \right\| _ {2}}{| \mathcal {P} | \cdot t _ {\mathrm {p r e d}}} \tag {11}
+$$
+
+$$
+\mathrm {F D E} = \frac {\sum_ {i \in \mathcal {P}} \left\| \left(\left(\hat {x} _ {t} ^ {i} , \hat {y} _ {t} ^ {i}\right) - \left(x _ {t} ^ {i} , y _ {t} ^ {i}\right)\right) \right\| _ {2}}{\left| \mathcal {P} \right|}, t = t _ {p r e d}
+$$
+
+where $\mathcal{P} = \{p_1, p_2, \ldots, p_N\}$ is the set of pedestrians, $(\hat{x}_t^i, \hat{y}_t^i)$ are the predicted coordinates at time $t$ and $(x_t^i, y_t^i)$ are the ground-truth coordinates.
+
+As for the final federated performance of TP models, we use the federated ADE/FDE score on test set to compare their performance under FL framework:
+
+$$
+\mathrm {A D E} _ {\mathbb {D} _ {\text {t e s t}}} = \sum_ {i = 1} ^ {C} \frac {\left| D _ {i , \text {t e s t}} \right|}{\left| \mathbb {D} _ {\text {t e s t}} \right|} \mathrm {A D E} (\mathcal {M}, D _ {i, \text {t e s t}}) \tag {12}
+$$
+
+where $D_{i,\mathrm{test}}$ is the test set of client $i$ , and $\mathbb{D}_{\mathrm{test}}$ denotes all test data in the federated TP dataset $\mathbb{D}$ . Replace $ADE$ to $FDE$ then we get $\mathrm{ADE}_{\mathbb{D}_{\mathrm{test}}}$ .
+
+Baselines. We compare ATPFL with two popular search strategies for AutoML: an RL search strategy that combines recurrent neural network controller [10] and EA-based search strategy for multi-objective optimization [5], and a commonly used baseline in AutoML, Random Search.
+
+Table 2. Performance comparison of ATPFL, AutoML algorithms and manually designed TP models. The first part examines the performance of existing TP models on single-source TP datasets. The second part compares different federated training methods on a TP model. The third part compares different AutoML methods under FL framework. Best-i denotes the $i^{st}$ best ADE score achieved by the clients.
+
+| System Setup | Curve Degree | Previous? |
| Mirror Type | Camera Position | Mirror Parameters | Central? |
| General | Any | A = *, B = *, C = * | No | 6 | - |
| General | Axial | A = *, B = *, C = * | No | 6 | - |
| Sphere | Any | A = 1, B = 0, C = * | No | 4 | [1] |
| Cone | Axial | A = -1, B = 0, C = 0 | No | 4 | [7,8]† |
| Ellipsoidal | Axial | A = 2k/c32+2k, B = -2c3k/c32+2k, C = -c32k/2c32+4k + k/2 | No | 6 | - |
| Ellipsoidal | At the foci, i.e., [0 0 c3]T | A = 2k/c32+2k, B = -2c3k/c32+2k, C = -c32k/2c32+4k + k/2 | Yes | 2 | [4,18] |
| Hyperboloidal | Axial | A = -2/k-2, B = 2c3/k-2, C = c32k/k-2 - c32k/2k | No | 6 | - |
| Hyperboloidal | At the foci, i.e., [0 0 c3]T | A = -2/k-2, B = 2c3/k-2, C = c32k/k-2 - c32k/2k | Yes | 2 | [4,18] |
+
+Table 1. We show a small set of specific configurations representing the degrees of the implicit equations derived in this paper against the previous techniques when there is one. We note that previous methods only consider specific camera configurations in mirror parameters and camera position. The parameter $k$ in the table is a general mirror parameter representing central catadioptric cameras, as defined in [3]. $\dagger$ indicates these polynomial degrees are not directly derived in [7,8].
+
+Points and central systems: This has been extensively studied for perspective cameras [25,31]. For the conditions derived in [3], [18] proposes a unified projection model for central omnidirectional cameras. This method uses a two projections pipeline. It first consists of projecting the points into a sphere, then projecting them into the image using a changed perspective projection model. [33] adapts this model and considers planar grids for a flexible calibration technique. Other well-known works on the image formation of omnidirectional systems consider projection approximations, such as [16,48]. [55] presents another interesting work. A point is projected into a line in the image, making it model-independent from distortion.
+
+Lines and central systems: Line projection for perspective cameras is well defined; see [25, 31]. We also find their modeling for central catadioptric systems. [18] is the first work exploring this problem. The authors follow the same two projections strategy used to project 3D points. In [4], the authors further explore this line projection problem. They present some relevant properties and their advantages in camera calibration. Some other authors focus on line projection fitting; see for example [6,9,32]. Table 1 lists current central solutions.
+
+Points and non-central systems: One of the first works addressing the image formation of non-central catadioptric cameras is [53], in which the authors use caustics on the modeling. Most authors use polynomials (implicit equations) to represent these 3D point projections at the mirror. [1] starts by proposing a polynomial equation of degree 6 to represent the projection of 3D points in axial noncentral catadioptric cameras (camera aligned with the mirrors axis of symmetry). This work is extended for general camera positions in [2], with a polynomial equation of degree 8. In [21-23], the authors follow a different approach. They notice that the problem could not be solved using
+
+closed-form operations and focus on defining efficient iterative techniques.
+
+Lines and non-central catadioptric: Analytical solutions to the line-image for non-central catadioptric cameras were only analyzed for two camera positions/mirror configurations. As in the latest works on modeling 3D projection of points, previous authors rely on modeling these projections using implicit equations in the form of polynomials. [1] proposes a solution to the 3D projection of lines into non-central catadioptric cameras with spherical mirrors. The authors obtain a 4-degree polynomial to represent the curve in the image. In [7, 8], the line projection model and their fitting for conical non-central catadioptric cameras are proposed. Concerning the model, the authors assume an axial system and get a 4-degree polynomial to represent the curve in the mirror. Other authors admit approximate solutions for this line projection. [14] study the projection of 3D lines using the Generalized Linear Camera model, showing good results for a small local window. Yang et al. [57] fit several lines using an approximate projection that makes use of a set of basis functions and a look-up table. Other authors present analytical solutions to different non-central systems; see [27, 34, 44, 58].
+
+Unlike prior work, this paper offers a general and analytical model for the 3D projection of lines in the entire image space. Our solution can be used to model systems with any rotationally symmetric mirror and camera positions, i.e., central and non-central imaging devices.
+
+# 3. Problem Definition
+
+As in previous catadioptric image formation works, [1,4, 7,8,18], we use rotationally symmetric mirrors, represented by $\Omega (\mathbf{m}) = 0$ , where
+
+$$
+\Omega (\mathbf {m}) = x ^ {2} + y ^ {2} + A z ^ {2} + B z - C, \tag {1}
+$$
+
+
+Figure 1. Projection model: The input is a line in the world $(\mathbf{q}_w$ and a direction $\mathbf{d}_w$ ). The first step transforms the line parameters to the mirror's reference frame by applying a rigid transformation $\mathbf{R}_w \in \mathcal{SO}(3)$ and $\mathbf{c}_w \in \mathbb{R}^3$ (the rotation and world frame position of the mirror, respectively). Next, we map the 3D line from the world into the normalized image space. Last step applies a standard collineation between two projective planes; $\mathbf{H} = \mathbf{K}\mathbf{R}$ .
+
+and $\mathbf{m} = [xy]^T$ is a point on the mirror's surface. From (1), the normal vector at the mirror point $\mathbf{m}$ is given by
+
+$$
+\mathbf {n} (\mathbf {m}) = \nabla \Omega (\mathbf {m}) = \left[ \begin{array}{l l l} x & y & A z + B / 2 \end{array} \right] ^ {T}. \tag {2}
+$$
+
+Taking the perspective projection equation (see [25]), the image of a point in the mirror's surface is given by
+
+$$
+\zeta \left[ \begin{array}{l} u \\ v \\ 1 \end{array} \right] = \mathbf {K R} (\mathbf {m} - \mathbf {c}) \tag {3}
+$$
+
+where $\mathbf{K} \in \mathbb{R}^{3 \times 3}$ represents the camera intrinsics. $[u v]$ are an image point in pixel coordinates. $\mathbf{R} \in \mathcal{SO}(3)$ and $\mathbf{c} \in \mathbb{R}^3$ are the rotation of the camera and its center with respect to the mirror's reference frame, respectively. As in [1], without loss of generality, given its symmetry, one can rotate the mirror's coordinate system, getting $\mathbf{c} = [0 c_2 c_3]^T$ .
+
+To represent lines, we use a point $\mathbf{q} \in \mathbb{R}^3$ and a direction $\mathbf{s} \in \mathbb{R}^3$ ; any point on the line satisfies
+
+$$
+\mathbf {p} (\lambda) = \mathbf {q} + \lambda \mathbf {s}, \text {f o r a n y} \lambda \in \mathbb {R}. \tag {4}
+$$
+
+Given the high degrees of some polynomials in the paper, we use $\kappa_{i}^{j}[.]$ to denote the $i^{\mathrm{th}}$ polynomials $j^{\mathrm{th}}$ total degree $^2$ .
+
+We conclude this section by describing our problem:
+
+Problem 1 (Line projection). The projection of lines in general catadioptric cameras with rotationally symmetric mirrors is given by an implicit equation (in polynomial form), $\mathcal{I}(u,v)$ , with coefficients specified as a function of the $3D$ line, perspective camera, and mirror parameters.
+
+# 4. Line Projection in Catadioptric Cameras
+
+Figure 1 shows the projection model used for catadioptric cameras. As in [1,4], without loss of generality, we assume that the world reference frame is aligned with the mirror (i.e., $\mathbf{R}_w = \mathbf{I}$ and $\mathbf{c}_w = \mathbf{0}$ ). Then, this section focuses on mapping the line coordinates.
+
+
+(a) Reflection Plane
+
+
+(b) Snell Reflection Law
+Figure 2. Projection constraints: At the left, we show the planar constraint defined by each point on the line, its reflection point on the mirror, and the perspective camera center. At the right, we show Snell's reflection constraint. The red curve in the images represents the line projection into the mirror.
+
+Consider a 3D line, $\mathbf{p}(\lambda)$ , represented in the mirror frame, as shown in (4). This section proposes a parametric representation for the line projection, $\mathcal{I}(u,v)$ ; i.e., solves Problem 1. We start by defining some basic projection constraints in Sec. 4.1. The algebraic line-reflection constraint we use to model line projections is derived in Sec. 4.2. Section 4.3 presents the parameterization of the projection curve in normalized image coordinates. To conclude, the implications on the application of the standard collineation is shown in Sec. 4.4 (affine transformation $\mathbf{H}$ in Fig. 1).
+
+# 4.1. Projection Constraints
+
+We use two basic properties of the catadioptric image formation for deriving the line-projection constraint (to be presented in the following subsection), see [2, 21]:
+
+Definition 1. A point on the line, $\mathbf{p}(\lambda)$ , its reflection point on the mirror, $\mathbf{m}(\lambda)$ , and the perspective camera's center of projection, $\mathbf{c}$ , define a plane $\Pi(\lambda)$ (see Fig. 2(a)); and
+
+Definition 2. The incoming and reflected rays, $\mathbf{d}_{p,m}(\lambda)$ (from $\mathbf{p}(\lambda)$ to $\mathbf{m}(\lambda)$ ) and $\mathbf{d}_{m,c}(\lambda)$ (from $\mathbf{m}(\lambda)$ to $\mathbf{c}$ ) respectively, in Fig. 2(b), must satisfy the Snell's law of reflection.
+
+We start with the plane constraint at Definition 1. Using the fact that $\mathbf{k}(\lambda) = \mathbf{m}(\lambda) + \mu \nabla \Omega (\mathbf{m})$ , for $\mu \in \mathbb{R}$ , is in the 3D plane and intersects the mirror's axis of symmetry at $\mu = -1$ , we write
+
+$$
+\mathbf {k} (\lambda) = \left[ \begin{array}{l l l} 0 & 0 & (1 - A) z - B / 2 \end{array} \right] ^ {T}. \tag {5}
+$$
+
+Now, stacking $\mathbf{m}(\lambda),\mathbf{k}(\lambda),\mathbf{c},$ and $\mathbf{p}(\lambda)$ , such that
+
+$$
+\mathbf {M} ^ {T} = \left[ \begin{array}{c c c c} \mathbf {m} (\lambda) & \mathbf {p} (\lambda) & \mathbf {k} (\lambda) & \mathbf {c} \\ 1 & 1 & 1 & 1 \end{array} \right], \tag {6}
+$$
+
+since all these points are on the same plane, a constraint is obtained; the determinant of $\mathbf{M}$ must be zero, $\mathcal{C}_1(\mathbf{m},\lambda) = \det (\mathbf{M}) = 0$ . By expanding the determinant of $\mathbf{M}$ , we describe the following Lemma:
+
+Lemma 1 (Plane reflection constraint). A 3D point on the line, $\mathbf{p}(\lambda)$ , verifying Definition 1 provides a constraint $\mathcal{C}_1(\mathbf{m},\lambda) = 0$ , such that
+
+$$
+\mathcal {C} _ {1} (\mathbf {m}, \lambda) \doteq \kappa_ {1} ^ {1} [ x, y ] \lambda z + \kappa_ {2} ^ {1} [ x, y ] z + \kappa_ {3} ^ {1} [ x, y ] \lambda + \kappa_ {4} ^ {1} [ x, y ]. \tag {7}
+$$
+
+Let us now focus on Definition 2. Taking the Snell reflection law and the fact that $\mathbf{d}_{p,m}(\lambda) \times \mathbf{d}_{p,m}(\lambda) = \mathbf{0}$ , after some simplifications, we obtain
+
+$$
+\begin{array}{l} \langle \mathbf {n} (\mathbf {m}), \mathbf {n} (\mathbf {m}) \rangle [ \mathbf {d} _ {p, m} (\lambda) ] _ {\mathrm {x}} \mathbf {d} _ {m, c} (\lambda) - \\ 2 \langle \mathbf {d} _ {m, c} (\lambda), \mathbf {n} (\mathbf {m}) \rangle [ \mathbf {d} _ {p, m} (\lambda) ] _ {\mathrm {x}} \mathbf {n} (\mathbf {m}) = \mathbf {0}, \tag {8} \\ \end{array}
+$$
+
+in which $[\mathbf{a}]_{\mathbf{x}}$ is a skew-symmetric matrix that linearizes the cross product, i.e., $\mathbf{a} \times \mathbf{b} = [\mathbf{a}]_{\mathbf{x}}\mathbf{b} = \mathbf{0}$ . In addition, by definition, we have
+
+$$
+\mathbf {d} _ {m, c} (\lambda) = \mathbf {m} (\lambda) - \mathbf {c}, \text {a n d} \mathbf {d} _ {p, m} (\lambda) = \mathbf {p} (\lambda) - \mathbf {m} (\lambda). \tag {9}
+$$
+
+Substituting (9) in (8), we get three algebraic constraints