Quantifying the Frontal-to-Ceiling Domain Gap for YOLO-Based Hand Gesture Recognition in Smart Homes Authors: Ufuk Beşenk, Sarp Ege Nayim, Ömür Öcal, Mehmet Öztemel, Ahmet Özkurt, Mustafa Alper Selver Published: 2026 ABSTRACT Vision-based hand gesture recognition (HGR) systems are predominantly developed for frontal camera viewpoints, whereas smart-home cameras are often ceiling-mounted, creating a viewpoint-induced domain gap. To investigate this issue, we collected and manually annotated CeilGest, an 18-class ceiling-view hand gesture dataset comprising 156,282 annotated frames from 68 participants recorded in distinct domestic environments. We then systematically evaluated frontal-to-ceiling transfer using YOLO-based detectors trained on HaGRID and compared their performance with an in-domain CeilGest-trained model. On identical ceiling-view footage, the frontal-trained YOLOv8n produced approximately 24× more class-to-class misclassified frames than the in-domain model (486 vs. 20 across 27,000 frames); this large paired difference remained evident when temporal dependence within gesture holds was taken into account. The effect was strongly class-dependent, with AP decreasing by up to 5.5 percentage points for the worst-affected gesture, while the aggregate same-architecture mAP50 difference was 0.6 percentage points. Across five YOLOv8 variants evaluated on frontal HaGRID, mAP50 remained at 0.995, supporting selection of the lightweight YOLOv8n for edge deployment. The complete ceiling-view HGR pipeline was implemented on Raspberry Pi 5 using NCNN and Jetson Orin Nano using TensorRT. Mean inference latency was 74.69 ± 4.72 ms and 12.72 ± 0.12 ms, respectively. During a 10 min continuous Raspberry Pi 5 test, mean inference latency increased by 17.6% and junction temperature reached 90.8 °C with thermal throttling. Power consumption and INT8 inference were not evaluated. Overall, the results show that training–deployment viewpoint consistency is a major consideration for ceiling-mounted HGR and establish an in-domain supervised baseline relative to frontal-only training without domain adaptation. 1. Introduction Hand Gesture Recognition (HGR) is a compelling modality for smart-home control with contactless, low cognitive load. It is potentially relevant for individuals with speech or mobility impairments for whom voice assistants or touchscreens present barriers [1,2,3,4,5]. Single-stage YOLO detectors achieve up to 0.99 mAP50 on HGR benchmarks such as the 18-class HaGRID [6,7,8] and the TSL Detection dataset [9]. However, nearly all vision-based HGR systems assume frontal camera perspective [10], yet smart-home cameras are routinely ceiling-mounted for wider coverage. This mismatch creates a measurable domain gap. On identical ceiling footage, a frontal-trained detector produced ≈24× more misclassified frames than one trained on in-domain data (486 vs. 20 misclassified frames across the 27,000-frame test set; see Section 4). On the worst-affected class (i.e., call), per-class mAP50 fell by up to 5.5 percentage points. Furthermore, deploying these models in real smart homes introduces four interconnected challenges: (i) selecting an expressive yet intuitive and user-friendly gesture vocabulary; (ii) overcoming the viewpoint-induced domain gap between frontal training data and ceiling-mounted cameras; (iii) achieving efficient inference on resource-constrained edge hardware; and (iv) preserving user privacy through fully on-device processing. Gesture vocabulary: We target 18 static postures mapped to home-automation commands. Static gestures avoid temporal-modelling overhead on edge hardware, align with the HaGRID class definitions [6], and impose lower motor demands on users with limited dexterity. Gesture vocabulary: We target 18 static postures mapped to home-automation commands. Static gestures avoid temporal-modelling overhead on edge hardware, align with the HaGRID class definitions [6], and impose lower motor demands on users with limited dexterity. Domain gap: Ceiling mounting introduces foreshortening, geometric distortion, and altered occlusion patterns [11], yet the overwhelming majority of HGR datasets assume frontal or first-person (i.e., ego-perspective) views [10]. Domain gap: Ceiling mounting introduces foreshortening, geometric distortion, and altered occlusion patterns [11], yet the overwhelming majority of HGR datasets assume frontal or first-person (i.e., ego-perspective) views [10]. Edge deployment: Running models within 4–8 GB memory and 7–15 W TDP requires quantisation [12,13] and hardware-specific backends, which can degrade accuracy [14]. Despite this, only a small fraction of edge HGR studies target sub-15 W devices [15]. Edge deployment: Running models within 4–8 GB memory and 7–15 W TDP requires quantisation [12,13] and hardware-specific backends, which can degrade accuracy [14]. Despite this, only a small fraction of edge HGR studies target sub-15 W devices [15]. Privacy: The GDPR [16] recognises that hand geometry may constitute biometric data when processed for the purpose of uniquely identifying a natural person; users therefore prefer local processing. This motivates a fully on-device pipeline where frames are processed and immediately discarded. Privacy: The GDPR [16] recognises that hand geometry may constitute biometric data when processed for the purpose of uniquely identifying a natural person; users therefore prefer local processing. This motivates a fully on-device pipeline where frames are processed and immediately discarded. Within the literature surveyed in Section 2, we did not identify a system that jointly addresses these four challenges. Baptista et al. [17] show that user-identity shift degrades HGR accuracy from near-perfect to ≈84% and recover it to ≈90% via contrastive training, but only for four classes under a fixed frontal camera on a desktop GPU. Alabdullah et al. [4] achieve 92.6% accuracy on seven HaGRID classes using skeleton-feature fusion with a recurrent neural network (RNN), yet require desktop hardware and a frontal viewpoint. Hobbs and Ali [18]—the closest edge-deployed system—run MediaPipe landmarks through a TensorFlow Lite classifier on Raspberry Pi 5 at 20.4 FPS, but rely on CPU-only inference, a frontal camera, and a simple 3-of-4 majority vote for temporal filtering. However, their skeleton-based pipeline degrades under non-frontal angles [10]. GECO [19] demonstrates end-to-end IoT integration with sub-50 ms latency, yet is limited to frontal views on a smartphone processor. Each of the above-mentioned studies addresses at most two of the four challenges; thus the intersection of frontal-to-ceiling domain shift, accelerated edge inference, and an 18-class vocabulary remains an open area of research. Accordingly, the contributions of this study are twofold: (1) Frontal-to-ceiling domain-gap quantification: We present what is, to the best of our knowledge, the first systematic analysis of the viewpoint-induced performance degradation of YOLO-based HGR under ceiling-mounted cameras. To support this analysis, we collected and manually annotated CeilGest, a ceiling-view hand gesture dataset comprising 156,282 images from 68 subjects, and evaluated the impact of viewpoint shift using both HaGRID and CeilGest. (2) Privacy-preserving edge deployment: We develop and validate a complete smart-home HGR pipeline for on-device inference using YOLOv8 on Raspberry Pi 5 (NCNN) and Jetson Orin Nano (TensorRT), incorporating temporal verification to improve robustness while preserving user privacy through local processing. The remainder of this paper is organised as follows. Section 2 reviews related work on HGR, viewpoint robustness, and edge AI. Section 3 describes the proposed system architecture, the HaGRID and CeilGest datasets, the training procedure, and the deployment pipeline. Section 4 presents the experimental results, including model-capacity analysis, frontal-to-ceiling domain-gap evaluation, and edge deployment validation. Section 5 discusses the findings, limitations, and future research directions. Finally, Section 6 concludes the paper. 2. Related Works This section reviews HGR for smart-home control, viewpoint robustness and domain shift, and edge-AI deployment on resource-constrained hardware. 2.1. Hand Gesture Recognition (HGR) HGR has progressed from handcrafted-feature methods [1,2] through convolutional neural network (CNN)–long short-term memory (LSTM) hybrids [20,21] to lightweight single-stage detectors and transformers [22], yet robust cross-environment generalisation remains an open challenge. Detection-based formulations in particular have been applied across both dynamic and static gesture settings, from SSD-style detectors for human–computer interfaces [23] to two-stage variants combining Mask R-CNN with multibox detection in applied domains [24]. Recent surveys converge on the limitations relevant here: Linardakis et al. [10] report that the overwhelming majority of studies assume a frontal camera and that bounding-box capture dominates classification pipelines; Cui et al. [3] find that lightweight models exhibit weak environmental adaptability; and Fertl et al. [15] find that only a small fraction of systems target genuine edge hardware. These observations—frontal bias, limited environmental robustness, and desktop dependence—define the gap addressed by this work. 2.1.1. YOLO-Based Gesture Detection Gao et al. [9] benchmarked YOLOv8n–v13n on 31 gesture classes, with YOLOv9t achieving mAP50 = 0.990 and YOLOv10n the fastest inference (0.7 ms), though on a single custom dataset. We selected YOLOv8n and YOLOv10n for their TensorRT compatibility, competitive nano-scale accuracy, and, for YOLOv10n, NMS-free inference that reduces edge latency [8]. 2.1.2. Smart-Home HGR Systems Table 1 compares closely related methods. Alabdullah et al. [4] and Ahuja et al. [25] reach 92.6% and 93.0% classification accuracy but are limited to desktop-GPU, frontal-view settings with small vocabularies (7 and 10 classes). Hobbs and Ali [18], the closest prior edge-deployed system, use MediaPipe landmarks on a Raspberry Pi 5 (CPU-only) for 15 classes at ∼90% accuracy. Lopes et al. [19] present GECO, a MediaPipe-based gesture controller running on Android with MQTT-based IoT integration, achieving high user-rated intuitiveness (9.5/10) and <50 ms latency, but supporting only seven classes under frontal views without dedicated edge accelerators. A consistent pattern emerges: existing systems either achieve high accuracy on desktop hardware under frontal views, or deploy on edge with reduced accuracy and vocabulary. None evaluate the frontal-to-ceiling domain shift. 2.2. Viewpoint Robustness and Domain Shift Camera viewpoint changes introduce geometric distortion, foreshortening, and altered occlusion that degrade models trained on a single view. The closest precedent is overhead person detection: Ahmad et al. [26] train a YOLO detector on frontal-view data and evaluate it on an overhead-view person dataset, confirming that the canonical-to-overhead shift is severe enough to warrant separate treatment. Their target is nonetheless the whole human body, whose overhead appearance is considerably more stable than that of a deformable hand pose. In the broader action-recognition literature, cross-view methods learn view-invariant representations to cope with drastic appearance changes between viewpoints [11]; however, these approaches target full-body actions captured by multi-camera rigs and do not transfer directly to single-camera HGR settings. The 3D hand pose community has addressed viewpoint variation more directly—InterHand2.6M [27] and FreiHAND [28] show that hand appearance changes substantially across views due to self-occlusion and finger foreshortening—but these methods require depth sensors or multi-view setups [29] incompatible with single-camera edge deployment, and recover joint coordinates rather than gesture classes. For HGR specifically, Andriyanov and Mikhailova [30] evaluated MediaPipe + YOLO-Pose under moderate angle variations (mAP > 0.80) without considering ceiling perspectives. Data augmentation including learned policies [31] can simulate moderate viewpoint changes but cannot fully recover the ceiling transformation. Domain-adaptation methods such as adversarial alignment [32] and knowledge distillation [33] offer more principled alternatives, yet to the best of our knowledge, no prior study has quantified this specific domain gap for hand gestures. In our experiments, collecting in-domain ceiling data and retraining proved highly effective (mAP50 > 0.99; Section 4); we deliberately scope this study to establishing the in-domain performance baseline rather than benchmarking DA strategies (Section 5.4). 2.3. Edge AI for Smart Environments Edge computing reduces latency and enhances privacy versus cloud designs [34,35], but deploying deep models on constrained hardware requires pruning [12], INT8/FP16 quantisation [13], and knowledge distillation [33]; lightweight architectures have likewise been pursued for other dense prediction tasks such as semantic segmentation [36]. These are complemented by platform-specific engines: TensorRT for Jetson, NCNN [37] for ARM CPUs. YOLOv8 [7] and YOLOv10 [8] suit edge deployment owing to anchor-free heads, efficient backbones, and NMS-free inference. Alqahtani et al. [14] found the Jetson Orin Nano fastest and most energy-efficient among RPi 3/4/5 and Coral TPU configurations, though their benchmark covered general object detection (COCO) rather than HGR; among the reviewed HGR systems, Hobbs and Ali [18] report a 15-class skeleton-based recogniser on a CPU-only Raspberry Pi 5 at ∼90% accuracy. Of reviewed HGR systems, only Hobbs and Ali [18] deploy on genuine edge hardware, and Lopes et al. [19] on mobile processors rather than dedicated accelerators. Accelerated inference backends are thus mature for general object detection, but their application to HGR, particularly under non-frontal viewpoints, remains unexplored. 3. Materials and Methods 3.1. Datasets 3.1.1. Benchmark Dataset Selection and Prior Work HaGRID [6] was selected as the source-domain dataset because it is currently the largest publicly available RGB hand gesture detection benchmark with bounding-box annotations. It contains 554,800 images collected from 37,583 contributors, covering 18 gesture classes together with a no gesture class. Its gesture vocabulary closely matches the requirements of smart-home control while its scale enables robust detector training. A key limitation of HaGRID is that it was collected almost exclusively from frontal webcam viewpoints, which limits its suitability for evaluating ceiling-mounted cameras (see Section 4). This frontal-view bias motivates the collection of the CeilGest dataset described in the following subsection. Alternative datasets such as Jester [38], NVGesture [39] (dynamic gestures, no bounding boxes), and EgoGesture [40] (first-person views) were not selected because they target different recognition tasks, including dynamic and egocentric gestures, and therefore do not provide an appropriate benchmark for ceiling-view, static HGR. 3.1.2. Custom Ceiling Dataset (CeilGest) To enable systematic evaluation of the frontal-to-ceiling domain gap, we collected and manually annotated CeilGest, a ceiling-view hand gesture dataset comprising 156,282 RGB images from 68 participants (41 male, 27 female; ages 19–58 years, median 26). All images were acquired using cameras mounted 2.5–3.0 m above floor level, closely reflecting the installation geometry of ceiling-mounted smart-home cameras. Unlike existing HGR datasets, which predominantly assume frontal or egocentric viewpoints, CeilGest captures the overhead perspective encountered in practical smart-home environments while preserving the same 18 static gesture vocabulary used by HaGRID. Recordings were carried out in the participants’ own homes, so the dataset spans 68 distinct domestic environments—one per participant—rather than a single instrumented room or laboratory setting. Because acquisition took place in real dwellings, several factors varied without experimental control: ceiling height within the 2.5–3.0 m mounting range, illumination (daylight and artificial, unregulated), room geometry and furniture layout, and consequently the subject-to-camera distance and viewing angle. These constitute nuisance variation spanned by the dataset rather than experimental conditions; their individual contributions were not isolated, and no controlled distance or illumination study was conducted. Each participant performed all 18 gesture classes multiple times. Rather than recording a single continuous pose, every gesture was repeated approximately five times (varying across participants). Between repetitions, the participant completely lowered the hand before re-performing the gesture, introducing natural variations in hand position, in-plane orientation, wrist pose, and approach angle. Each repetition was held for approximately 5 s. All sessions were recorded at 30 fps with a resolution of 1280×720 px. To reduce redundancy while preserving temporal diversity, frames were sampled at 5 fps, yielding approximately 2300 manually annotated images per participant. Representative frames illustrating the range of environments, illumination conditions and viewing geometries are shown in Figure 1. Although consecutive frames within an individual repetition remain visually similar, the repeated lowering and re-positioning of the hand means that each (participant, gesture) pair contributes multiple distinct pose realisations rather than a single sustained static observation. Consequently, CeilGest provides substantially greater appearance variability than would be obtained from one sustained gesture per participant. Nevertheless, temporal correlation remains within each repetition, and multiple repetitions from the same participant should not be regarded as fully independent statistical observations, as discussed in Section 5.4. For the held-out test split specifically, each (subject, gesture) instance comprises approximately five separate repetitions, with the hand re-posed between takes. This yields approximately 50 separate gesture repetitions per class (10 held-out subjects × ≈5 repetitions), compared with 1500 sampled frames per class. These repetitions provide a more appropriate scale for considering temporal dependence than the raw frame count, but they are not fully independent because multiple repetitions originate from the same 10 held-out subjects. Consequently, generalisation to unseen individuals remains primarily constrained by the number and diversity of held-out subjects. This issue is quantified further in Section 4.3 and discussed as a limitation in Section 5.4. Data were split at the subject level to prevent identity leakage: 50 subjects (73.5%) for training, 8 (11.8%) for validation, and 10 (14.7%) for testing. Because each participant was recorded in a different home, this split is simultaneously environment-disjoint: the ten test subjects were recorded in ten domestic environments appearing in neither the training nor the validation split. Reported test performance therefore reflects generalisation to unseen individuals in unseen rooms, rather than to unseen individuals within a shared recording environment. The test set comprises 27,000 images (1500 per class) from held-out subjects only. 3.2. System Architecture and Edge Deployment The system follows four design principles: privacy by design (all processing occurs locally), real-time responsiveness, robustness (temporal verification filters incidental movements), and broad coverage (ceiling mounting provides unobstructed room coverage, a configuration that is also relevant for users with limited mobility). The end-to-end pipeline (Figure 2) comprises six stages: (1) image acquisition from a ceiling-mounted camera at 2.5–3.0 m above floor level (1280×720 px, 30 fps); (2) CPU-side preprocessing (letterbox resize to 640×640 px, normalisation to [0,1] in RGB); (3) gesture detection via YOLOv8n with platform-specific backends (Section 3.5); (4) temporal verification requiring consistent classification over a 2 s sliding window with confidence threshold τ=0.7 (Section 3.2); (5) UART command transmission at 115,200 baud (8N1) to appliance controllers; and (6) auditory feedback confirming each action via a 0.5 s audio clip. Per-frame inference latency on both platforms is well below one second (see Section 4), enabling real-time visual feedback. The 2 s temporal verification window introduces an intentional activation delay to suppress false positives; consequently, the end-to-end time from the onset of a sustained gesture to appliance actuation is approximately 2.1–2.4 s depending on the platform. We consider this acceptable for non-urgent smart-home commands, where reliability takes precedence over instantaneous response. Two inference configurations are evaluated. RPi 5 (CPU): NCNN backend with ARM NEON single-instruction-multiple-data (SIMD) vectorisation (FP32). RPi 5 (CPU): NCNN backend with ARM NEON single-instruction-multiple-data (SIMD) vectorisation (FP32). Jetson Orin Nano: TensorRT backend with layer fusion, kernel auto-tuning, and FP16 Tensor Core acceleration. Jetson Orin Nano: TensorRT backend with layer fusion, kernel auto-tuning, and FP16 Tensor Core acceleration. These two platforms differ principally in computation and memory. The Raspberry Pi 5 (Raspberry Pi Ltd., Cambridge, UK) uses a BCM2712 SoC (quad-core Cortex-A76, 4 GB LPDDR4X, ≈12 W) with the NCNN backend (FP32, ARM NEON) and a PiCamera V3 (CSI; Raspberry Pi Ltd., Cambridge, UK), while the Jetson Orin Nano (NVIDIA Corporation, Santa Clara, CA, USA) uses an 8 GB Orin module (6-core Cortex-A78AE, 1024-core Ampere GPU, 15 W) on a Leetop A603 carrier board (Leetop Technology, Shenzhen, China) with TensorRT 10.3.0 (FP16, JetPack 6.2.1) and a USB webcam. The software environments were Debian 12 (bookworm, 64-bit) with Python 3.11.2, OpenCV 4.8.0 and NumPy 1.24.3 on the Raspberry Pi 5, and Ubuntu 22.04.5 LTS with Python 3.10.12, OpenCV 4.12.0, NumPy 2.2.6 and CUDA 12.6.68 on the Jetson Orin Nano. Recognised gestures are mapped to single-byte UART commands transmitted at 115,200 baud (8N1) via an FT232R USB-to-TTL converter (FTDI Ltd., Glasgow, UK). The receiving Arduino Nano (Arduino S.r.l., Monza, Italy) acknowledges each command with a single-byte ACK (0xFF) within 50 ms; unacknowledged commands are retransmitted once. The complete inference loop, including temporal verification and command transmission, is summarised in Algorithm 1. Algorithm 1 End-to-end ceiling-view HGR inference pipeline (per device)Require: Ceiling camera stream (1280×720, 30 fps); exported engine net for backend B ∈ {ncnn, TensorRT}; gesture-to-command map cmd[·]Require: τ=0.7, α=0.80, β=0.90, Tw=2.0 s, Tr=1.0 s, Mmin=2 1: net ← LoadEngine(B) ▹ NCNN FP32 (ARM NEON) or TensorRT FP16 2: W←∅ ▹ sliding window of triples (ti,y^i,pi) 3: tlast←−∞ ▹ time of last confirmed command 4: while camera active do 5: Iraw,t←Acquire 6: I ← Letterbox(Iraw,640×640) 7: I←I/255 in RGB ▹ normalisation to [0,1] 8: D ← net.Infer(I) ▹ boxes, classes, confidences 9: if B requires NMS then 10: D←NMS(D,IoU=0.7) ▹ skipped for NMS-free YOLOv1011: end if 12: if D=∅ then 13: (y^t,pt)←(no_gesture,0) 14: else 15: (y^t,pt)←argmaxd∈Dpd ▹ highest-confidence detection16: end if 17: W←W∪{(t,y^t,pt)} 18: W←{(ti,y^i,pi)∈W:t−ti≤Tw} ▹ trailing-interval window; |W|=Mt19: if t−tlast≥Tr then▹ refractory period elapsed20: c^ ← TemporalVerify(W,t) 21: if c^≠ null then 22: SendCommand(cmd[c^]) 23: PlayFeedback(c^) ▹ 0.5 s audio confirmation24: W←∅; tlast←t ▹ NCNN FP32 (ARM NEON) or TensorRT FP1625: end if 26: end if 27: discard Iraw,I,D ▹ no frame stored or transmitted28: end while 29: procedure SendCommand(b) 30: UartWrite(b) ▹ 115,200 baud, 8N131: if not AwaitAck(0xFF, 50 ms) then 32: UartWrite(b) ▹ single retransmission33: end if 34: end procedure Require: Ceiling camera stream (1280×720, 30 fps); exported engine net for backend B ∈ {ncnn, TensorRT}; gesture-to-command map cmd[·] Ceiling camera stream (1280×720, 30 fps); exported engine net for backend B ∈ {ncnn, TensorRT}; gesture-to-command map cmd[·] Require: τ=0.7, α=0.80, β=0.90, Tw=2.0 s, Tr=1.0 s, Mmin=2 τ=0.7, α=0.80, β=0.90, Tw=2.0 s, Tr=1.0 s, Mmin=2 Temporal Verification Rather than triggering actions on single-frame detections, the system requires consistent recognition over a sliding window to distinguish intentional gestures from incidental hand movements. At each frame t, the detector produces a class prediction y^t with confidence pt. A detection is considered valid if pt≥τ and y^t≠no_gesture, where τ=0.7. Let Wt denote the sliding window containing all frames acquired during the trailing interval [t−Tw,t], where Tw=2.0 s is the window duration. Unlike a fixed-length frame buffer, Wt adapts to the achieved frame rate: its cardinality |Wt|=Mt equals the number of frames the device actually processes within Tw, so the criterion is independent of inference throughput. Let Vt⊆Wt be the subset of valid detections within the window, and let c^t=mode{y^i:i∈Vt} be the modal class among valid frames. A gesture is confirmed at time t if and only if the window spans the full duration Tw, contains at least a minimum number of processed frames (Mt≥Mmin, with Mmin=2 to guarantee a meaningful vote at low frame rates), and the following two conditions are jointly satisfied:Confidence gate (fraction-based): |Vt|/Mt≥α, where α=0.80; i.e., at least 80% of the frames processed within the window carry a valid detection above threshold.Class consistency: |{i∈Vt:y^i=c^t}|/|Vt|≥β, where β=0.90; i.e., at least 90% of the valid frames agree on the same gesture class. Confidence gate (fraction-based): |Vt|/Mt≥α, where α=0.80; i.e., at least 80% of the frames processed within the window carry a valid detection above threshold. Confidence gate (fraction-based): |Vt|/Mt≥α, where α=0.80; i.e., at least 80% of the frames processed within the window carry a valid detection above threshold. Class consistency: |{i∈Vt:y^i=c^t}|/|Vt|≥β, where β=0.90; i.e., at least 90% of the valid frames agree on the same gesture class. Class consistency: |{i∈Vt:y^i=c^t}|/|Vt|≥β, where β=0.90; i.e., at least 90% of the valid frames agree on the same gesture class. Expressing both gates as fractions of the frames actually processed—rather than as fixed counts derived from a nominal 30 fps—makes the verification logic invariant to the deployment frame rate: the same α,β thresholds apply whether the device sustains 30 fps or the ∼6 fps observed on the Raspberry Pi 5. Upon confirmation, the modal class c^t is emitted as a UART command and the window buffer is cleared to prevent repeated triggering. A refractory period of Tr=1.0 s is imposed before the next gesture can be confirmed. The verification procedure is given in Algorithm 2. The temporal-verification parameters (τ=0.7, α=0.80, β=0.90, Tw=2.0 s, and Tr=1.0 s) were selected empirically using the CeilGest validation experiments. The confidence threshold τ was additionally assessed through the F1–confidence analysis described in Section 4.5. The selected values of α and β correspond to requiring high proportions of valid and class-consistent detections within each verification window, while Tw and Tr define the verification and refractory intervals, respectively. Three properties of this parameterisation are worth making explicit, since they determine how sensitive the verification stage is to the particular values chosen. First, the detection threshold τ sits well inside a region over which the in-domain detector is insensitive: the F1–confidence characterisation of Section 4.5 shows F1 >0.95 maintained across the range 0.10–0.70, with a peak at 0.60, so τ=0.7 lies at the upper edge of a broad plateau rather than at a sharp optimum. It is the flatness of that curve, not the absolute level of F1, that carries the argument: the threshold sweep is a paired comparison on identical frames, so the sample-size inflation discussed in Section 4.3 affects every operating point equally and cancels in the shape, even though it leaves the absolute value imprecise. The frontal-trained models peak at lower thresholds (0.40–0.45), which is itself a symptom of the domain shift rather than a property of the verification rule. Second, α and β are more readily interpreted as frame budgets than as abstract fractions. At the deployment frame rate of the Raspberry Pi 5 (∼6 fps; Section 4.6) the window contains Mt≈12 processed frames, so α=0.80 permits at most two frames within the window to yield no valid detection, and β=0.90 permits at most one of the remaining valid frames to disagree with the modal class. At the full camera rate the same fractions correspond to twelve and five frames, respectively. Expressing the gates as fractions rather than counts is what keeps this interpretation stable as throughput varies—including under the thermal degradation reported in Section 4.6, which reduces Mt but leaves the admissible error budget proportionally unchanged. Third, the 2 s verification window Tw defines the nominal observation interval before a gesture can be confirmed, whereas τ, α, and β influence whether the activation criterion is satisfied within that interval. More stringent thresholds may therefore increase the realised activation latency by causing additional windows to be rejected. The refractory period Tr constrains the timing of subsequent activations rather than the initial confirmation delay. A full factorial sweep of τ, α, and β against measured false-activation rate and end-to-end activation latency was not performed and is identified as a limitation in Section 5.4. Algorithm 2 Temporal verification over the sliding window Wt 1: procedure TemporalVerify(W,t) 2: if t−min{ti:i∈W}0.95 over a broad threshold range (0.10–0.70), indicating limited sensitivity to threshold selection. This range is the empirical basis for the detection threshold τ=0.7 adopted in the temporal-verification stage (Section 3.2): the operating point lies within a plateau rather than at a sharp optimum, so the verification stage does not depend on a finely tuned value of τ. In contrast, the HaGRID-trained models reached their optimal F1 at lower thresholds (0.40–0.45), suggesting a shift in prediction-confidence characteristics when frontal-trained models were applied to ceiling-view data. YOLOv10nHaGRID showed the greatest degradation at low confidence thresholds, consistent with its more diffuse error pattern in the confusion matrix. 4.6. Edge Deployment Validation To evaluate the feasibility of fully on-device operation, the trained YOLO models were deployed on two low-power embedded platforms: Raspberry Pi 5 using the NCNN backend and NVIDIA Jetson Orin Nano using TensorRT. Both platforms processed live 1280×720 video from ceiling-mounted cameras, with model inference performed at 640×640 px. The exported inference engines preserved the detection performance of their corresponding PyTorch checkpoints on the HaGRID-derived validation set. For YOLOv8n, the exported model achieved mAP50 = 0.995 and mAP50–95 = 0.897, matching the original checkpoint (Table 3). Thus, conversion to the hardware-specific inference backend introduced no measurable accuracy degradation at the validation level. The complete pipeline was functionally validated on both platforms. Gestures captured from the ceiling-mounted camera were detected on-device, temporally verified, and translated into UART control signals for external devices. The 2 s temporal verification mechanism successfully suppressed transient predictions before command execution. During continuous operation, the Raspberry Pi 5 implementation displayed an observed processing rate of approximately 6.2 FPS, demonstrating that the pipeline can operate at a rate sufficient for the temporal verification mechanism. All image processing was performed locally, and frames were discarded after inference without transmission to an external server, providing the privacy-preserving operation required for residential deployment. Controlled Latency and Thermal Measurements We carried out controlled measurements on both platforms under live operation with the ceiling-mounted camera, in order to characterise the behaviour that functional validation alone cannot establish. No recorded video or pre-existing image set was used; capture, pre-processing, inference and post-processing were timed separately on the live stream. The same exported checkpoint was driven through an identical pre-processing, decoding and NMS implementation on both devices, so that the only component differing between platforms was the inference call itself; the NCNN build was version 1.0.20250503. Both platforms were passively cooled, as in the intended deployment. Capture in these runs used a single USB UVC camera at 640 × 480 on both devices rather than the 1280 × 720 acquisition of Section 3.2, so that capture behaviour was identical across platforms and any latency difference was attributable to the inference backend alone. Because inference operates on letterboxed 640 × 640 crops in either case, the inference-stage figures reported below are independent of capture resolution. The thermal load under the higher-resolution deployment capture would, if anything, be greater, so the degradation reported here should be read as a conservative estimate; on the Raspberry Pi the pipeline was in any case compute-limited rather than capture-limited, meaning the device was running continuously at capacity, which is the worst case for sustained thermal behaviour. Throughput figures from these runs are correspondingly not directly comparable with the end-to-end rate reported earlier in this section for the deployment configuration. Inference latency was 12.72 ± 0.12 ms on the Jetson Orin Nano (TensorRT FP16; p50 12.68 ms, p95 12.94 ms) and 74.69 ± 4.72 ms on the Raspberry Pi 5 (NCNN FP32). The platforms differ not only in mean latency but also in stability: the standard deviation is 0.9% of the mean on the Jetson and 6.3% on the Raspberry Pi. The Raspberry Pi’s Cortex-A76 cores processed the same model in 301.11 ms compared with 405.11 ms for the Jetson’s Cortex-A78AE CPU-only configuration. Thus, the substantially lower end-to-end inference latency observed for the Jetson in the accelerated configuration is primarily associated with GPU-accelerated TensorRT inference rather than superior CPU-only performance. On the Raspberry Pi, NCNN reduced inference latency by approximately 4.0× relative to PyTorch 2.13.0, further illustrating the importance of the inference backend on platforms without a dedicated accelerator. The sharpest difference between the platforms is thermal. Over a ten-minute continuous run—a separate acquisition from the 60 s measurement reported above, begun from a warmer start, so that its first-minute mean exceeds the 74.69 ms of that shorter run—mean inference latency on the Raspberry Pi 5 rose from 76.69 ms in the first minute to 90.23 ms in the last, a degradation of 17.6%, while junction temperature reached 90.8 °C and the hardware raised its frequency-capping and throttling flags. The degradation was not monotonic: latency climbed steeply over the first two minutes, held a plateau near 84–85 ms for roughly three minutes, then entered a second rise from the sixth minute onwards that coincided with temperatures above 89 °C. Critically, the system had not reached a stable operating point within the measurement window, so even a ten-minute run does not yield the equilibrium value; the second-half mean of 88.91 ms should be treated as a more representative lower bound for deployment planning than any figure measured in the opening seconds. Under the same workload the Jetson Orin Nano rose by 0.5 °C over sixty seconds and raised no throttling flags, and its latency drift was −0.3%. Realised throughput on the Raspberry Pi over the same ten-minute run fell from 12.62 to 11.02 frames per second; as noted above these figures are specific to the 640 × 480 capture configuration and are not comparable with the end-to-end rate reported earlier for the deployment configuration. Short measurements therefore systematically overstate the sustained performance of a passively cooled Raspberry Pi 5 on this workload. Power consumption was not instrumented, and INT8 inference was not evaluated; both remain limitations of the present study. These measurements characterise latency, sustained throughput and thermal behaviour, but they do not constitute a full deployment-grade benchmark (Section 5.4). 4.7. Summary of Key Findings Table 8 consolidates the principal findings of the experimental analyses together with their scope and main caveats. Three results are particularly relevant to the objectives of this study. First, viewpoint mismatch produced the most pronounced performance degradation observed, with approximately 24× more class-to-class misclassifications for frontal-only than in-domain training on identical ceiling footage. Second, increasing model capacity provided comparatively limited benefit: lightweight YOLOv8n achieved similar frontal-view mAP50 to substantially larger variants, while the in-domain YOLOv8n produced fewer ceiling-view errors than the larger frontal-trained models. Third, the complete HGR pipeline was deployed on both Raspberry Pi 5 (NCNN) and Jetson Orin Nano (TensorRT) and characterised under controlled conditions, establishing the feasibility of fully on-device operation while also identifying sustained thermal degradation on the passively cooled Raspberry Pi 5 as a deployment constraint. These findings and their implications are discussed in the next section; the associated methodological limitations are consolidated in Section 5.4. 5. Discussion Taken together, the results indicate that viewpoint mismatch is a key determinant of HGR performance under ceiling-mounted deployment, while increasing model capacity provides only partial compensation under the conditions evaluated. Viewpoint-matched training, by contrast, enables a lightweight detector to achieve substantially lower error rates and supports practical on-device deployment. 5.1. Viewpoint-Induced Domain Shift The experiments demonstrate that viewpoint mismatch can substantially degrade HGR performance even when aggregate detection metrics remain high. The clearest evidence is the paired comparison on identical ceiling-view footage: YOLOv8nHaGRID produced 486 class-to-class misclassifications, compared with only 20 for the in-domain YOLOv8nceil, corresponding to an approximately 24× increase. Because both models were evaluated on the same test footage, this comparison is unaffected by differences in test-set composition and provides the most robust measure of the observed domain-shift effect. Importantly, the corresponding change in aggregate mAP50 is comparatively small, showing that performance metrics can conceal practically important class-specific failures. The class-wise analysis further demonstrates this effect. The worst-affected gesture, call, exhibited an AP decrease of up to 5.5 percentage points under the frontal-to-ceiling shift. The resulting confusion patterns are geometrically interpretable. The call–like distinction depends strongly on thumb orientation, which becomes less discriminative under the overhead projection because of foreshortening and self-occlusion. Similarly, finger-count gestures such as one, peace, and three lose part of their inter-finger spread and orientation cues when fingers extend toward the camera rather than across the image plane. These observations are consistent with findings from 3D hand pose estimation, where out-of-distribution viewpoints have been shown to increase ambiguity through self-occlusion and loss of depth information [27,28]. Increasing model capacity partially reduced these cross-view errors but did not eliminate them. YOLOv10xHaGRID produced a cleaner confusion matrix than the smaller frontal-trained models, suggesting that additional capacity can exploit residual cues such as wrist and forearm orientation. Nevertheless, the lightweight YOLOv8nceil produced substantially fewer errors than any frontal-trained model evaluated. Thus, within the configurations examined, matching the training and deployment viewpoints had a greater practical effect than increasing model capacity. This supports viewpoint-matched training data as an important consideration when HGR systems are deployed under camera geometries that differ substantially from those represented in conventional benchmarks. The comparatively small effect observed for colour representation provides additional context for this finding: changes among the evaluated colour spaces produced only minor performance differences. We emphasise that subject-to-camera distance and illumination were not manipulated experimentally; they varied naturally across the 68 recording environments and are therefore spanned by the test set as nuisance variation rather than isolated as controlled factors. Taken together, these observations suggest that viewpoint mismatch is a more important design consideration than colour representation under the conditions evaluated in this study. 5.2. Model Scaling and Efficient Model Selection: Can a Larger Model Solve That Problem? The comparable mAP50 obtained across all five YOLOv8 variants (Section 4.2) indicates that increasing model capacity provides little additional benefit for the evaluated 18-class frontal-view gesture detection task. This observation is consistent with previous HGR studies reporting competitive performance with lightweight architectures [3,15]. In our experiments, a 21× reduction in parameter count produced no measurable difference in mAP50, supporting the selection of YOLOv8n for resource-constrained deployment. This result should be interpreted as task-specific rather than as evidence that model capacity is generally unimportant for HGR. Differences among the YOLOv8 variants remained visible in mAP50–95, indicating that larger models provide more precise bounding-box localisation. For the present application, however, the downstream objective is reliable gesture recognition rather than precise hand localisation; therefore, mAP50 is the more operationally relevant metric. The observed behaviour should not be extrapolated to substantially larger gesture vocabularies, fine-grained sign-language recognition, or applications requiring highly accurate localisation. 5.3. Edge Deployment and Privacy: Can the Resulting Lightweight Solution Actually Be Deployed? The deployment experiments demonstrate that the proposed HGR pipeline can operate entirely on resource-constrained edge hardware using platform-specific inference backends, and the controlled measurements of Section 4.6 characterise how well it does so. The same lightweight detector was deployed using NCNN on Raspberry Pi 5 and TensorRT on Jetson Orin Nano, illustrating the portability of the pipeline across CPU- and GPU-oriented embedded platforms. The exported inference engines preserved the detection performance of the original model at the validation level, indicating that conversion to the hardware-specific deployment format did not introduce measurable accuracy degradation in the evaluated configuration. The observed processing rate on Raspberry Pi 5 was sufficient for the temporal verification mechanism used in the proposed smart-home pipeline. Importantly, this application does not require inference at the native camera frame rate: control commands are generated only after a gesture remains stable across the processed frames within the verification interval. This provides a practical mechanism for combining lightweight inference with robust command generation on low-power hardware, and it is also what makes the thermal degradation reported in Section 4.6 tolerable: because the verification gates are expressed as fractions of the frames actually processed rather than as fixed frame counts, the decision rule remains applicable as throughput changes. Reduced throughput may nevertheless increase realised activation latency, an effect that was not quantified directly in the present study. The thermal results nonetheless carry a concrete deployment implication. A passively cooled Raspberry Pi 5 running this workload continuously reaches its throttling threshold within the first minutes and had not stabilised after ten minutes, so sustained residential operation should assume either active cooling, a duty-cycled inference schedule, or the lower sustained throughput indicated by the second-half plateau rather than the figures obtained from short benchmark runs. The Jetson Orin Nano exhibited no such behaviour under the same workload. We note that this contrast concerns thermal headroom rather than energy cost, which we did not measure. Fully on-device processing also addresses an important privacy requirement of camera-based smart-home systems. Hand images may contain biometric information when processed for identification purposes, and continuous transmission of residential video to external servers may therefore raise privacy and user-acceptance concerns. In the proposed pipeline, frames are processed locally and discarded immediately after inference; no video data need to be stored or transmitted to an external server. The edge implementation therefore contributes not only to computational feasibility but also to privacy-preserving operation in residential environments. 5.4. Limitations of the Study Several limitations should be considered when interpreting the findings. First, although CeilGest comprises 156,282 annotated frames, the data were collected from 68 participants, substantially fewer than the 37,583 contributors represented in HaGRID. Subject-level train/validation/test splitting prevents identity leakage and, because each participant was recorded in a separate home, also guarantees that training and test environments are disjoint; nevertheless, the participant pool remains small relative to large-scale public benchmarks, which may restrict generalisation to broader populations. A further consequence of the one-participant-per-home acquisition design is that subject identity and recording environment are perfectly confounded: the held-out results cannot separate generalisation to unseen individuals from generalisation to unseen rooms. Disentangling the two would require recording several participants per environment, or the same participant across several environments. Second, consecutive frames within each gesture repetition are temporally correlated. Although participants lowered and re-positioned their hands between repetitions, the effective number of independent observations is substantially smaller than the raw frame count. Near-perfect per-frame performance of YOLOv8nceil should therefore be interpreted as strong detection consistency on the held-out recordings rather than as accuracy over 27,000 independent observations. The principal domain-shift finding relies instead on paired comparisons of models on identical footage, including the approximately 24× difference in class-to-class misclassifications. Third, each model configuration was trained once; repeated-seed experiments and confidence intervals were not available. Small differences between models should therefore not be interpreted as statistically significant. Viewpoint, model capacity, architecture, and colour space were examined in separate analyses rather than through a fully factorial design. Subject-to-camera distance and illumination, by contrast, varied naturally across the 68 recording environments and were not manipulated as controlled experimental factors. The synthesis of these observations should consequently be interpreted as engineering guidance under the evaluated conditions rather than as a controlled quantitative ranking of independent effect sizes. Fourth, the objective of this study was to quantify the frontal-to-ceiling domain gap and establish an in-domain supervised baseline using CeilGest. Domain adaptation approaches, including domain-adversarial training and pseudo-label self-training, were not evaluated. The improvement obtained with CeilGest should therefore be interpreted relative to frontal-only training with no adaptation and does not establish that supervised in-domain training is superior to domain adaptation. Fifth, the temporal-verification parameters were not characterised by a full factorial sweep. Section 3.2 reports the empirical basis for τ and provides a frame-budget interpretation of α and β. The 2 s verification window defines the nominal observation interval, whereas τ, α, and β may influence realised activation latency by determining whether a given window satisfies the confirmation criteria. We do not report measured false-activation rates and end-to-end activation latencies across a grid of (τ,α,β). Such an analysis requires time-ordered per-frame detector outputs, which were not available for this revision, and remains an important extension of the present work. Sixth, the gesture vocabulary is restricted to 18 static postures. Dynamic and sequential gestures, which would require temporal modelling beyond the sliding-window verification used here, were not addressed, and the conclusions of this study should not be extrapolated to them or to larger vocabularies such as fine-grained sign language. Seventh, the acquisition conditions themselves are narrow. All recordings used a ceiling mount between 2.5 and 3.0 m with a single camera type and a near-vertical downward view; other mounting heights, oblique ceiling angles, wide-angle or infrared optics, and low-light or night-time operation were not evaluated. The reported robustness therefore applies to the geometry and illumination range spanned by the 68 recording environments and should not be extrapolated beyond it. Finally, the edge characterisation remains incomplete. Inference latency, sustained throughput, and thermal behaviour were measured under controlled conditions (Section 4.6), but power consumption and energy per inference were not measured. Reduced-precision inference was evaluated using FP16 on the Jetson Orin Nano, whereas INT8 quantisation was not evaluated. The two platforms therefore cannot be compared directly in terms of energy efficiency. Both devices were passively cooled during the reported experiments; the degradation observed on the Raspberry Pi 5 further indicates that sustained deployment on that platform may require active cooling or duty-cycled operation. 5.5. Future Work Future work should address three main directions. First, the supervised in-domain baseline established in this study should be compared with domain adaptation strategies, including adversarial domain alignment and pseudo-label self-training, to determine how much of the frontal-to-ceiling gap can be recovered without labelled target-domain data. Second, CeilGest should be expanded to include a larger and more diverse participant population, additional domestic environments, and naturalistic non-gesture activity. Evaluation at the level of distinct gesture instances and subject-level cross-validation would provide stronger estimates of generalisation and enable analysis of false activation rates during everyday activity. Finally, the edge implementation should be characterised through controlled measurements of latency, sustained throughput, power consumption, and thermal behaviour including direct evaluation of any associated accuracy changes. 6. Conclusions This study presented a privacy-preserving, ceiling-mounted hand gesture recognition system for smart-home control and provided what is, to the best of our knowledge, the first systematic quantification of the frontal-to-ceiling domain gap for YOLO-based HGR across an 18-class static gesture vocabulary. To support this investigation, we collected and manually annotated CeilGest, a ceiling-view dataset comprising 156,282 annotated frames from 68 participants. The principal finding is that viewpoint mismatch can substantially degrade gesture recognition even when aggregate detection metrics remain high. On identical ceiling-view footage, the frontal-trained YOLOv8n produced approximately 24× more class-to-class misclassifications than its in-domain counterpart. This is a paired frame-level comparison on identical footage, and the substantially greater error burden of the frontal-trained model remains evident when temporal dependence within gesture holds is taken into account. However, the hold-level quantities reported in Section 4.3 are analytical estimates derived from frame-level counts rather than an independent empirical re-estimation of the exact error ratio. Accordingly, absolute aggregate detection metrics should not be interpreted as estimates based on 27,000 statistically independent observations. The effect was strongly class-dependent, with AP decreasing by up to 5.5 percentage points for the worst-affected gesture (call). The observed confusions were geometrically interpretable, particularly for gestures distinguished by thumb orientation and finger configuration, highlighting the importance of class-wise analysis when evaluating HGR under viewpoint changes. We emphasise that this establishes an in-domain supervised baseline rather than an optimum: mainstream domain-adaptation methods were not evaluated against the frontal-to-ceiling gap, so the improvement reported here is measured relative to no adaptation at all, and a comparison against those methods remains the principal open question (Section 5.5). Increasing model capacity provided limited benefit under the evaluated conditions. Five YOLOv8 variants achieved similar mAP50 on HaGRID, supporting selection of the lightweight YOLOv8n, while viewpoint-matched training produced substantially fewer ceiling-view errors than increasing the capacity of frontal-trained models. Among the factors examined, these findings identify training–deployment viewpoint consistency as a key consideration for HGR systems operating under non-standard camera geometries. Finally, the complete pipeline was deployed and characterised on Raspberry Pi 5 using NCNN and Jetson Orin Nano using TensorRT. Processing was performed entirely on-device, allowing acquired frames to be discarded after inference without transmission to an external server. Controlled measurement showed that the two platforms differ sharply under sustained load: a passively cooled Raspberry Pi 5 degraded by 17.6% within ten minutes and had not stabilised, so continuous residential operation on that platform would require active cooling or duty-cycled inference. Power consumption and INT8 inference were not evaluated. Together, the results demonstrate the feasibility of lightweight, viewpoint-aware, and privacy-preserving HGR for ceiling-mounted smart-home applications, subject to the limitations discussed in Section 5.4.