Pith. sign in

REVIEW 4 major objections 5 minor 30 references

Faster than Fast: Accelerating Oriented FAST Feature Detection on Low-end Embedded GPUs

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Two GPU kernels—binary-encoding FAST and a circular-buffer semi-separable Sobel for Harris—speed Oriented FAST feature detection by up to 13x on a Jetson TX2, making real-time ORB-SLAM on low-end embedded GPUs practical.

desk verdict Plausible FAST kernel acceleration, but the Harris kernel pseudocode contradicts its own separable Sobel equations, leaving the headline Harris speedups unverified. read the letter →

arxiv 2506.07164 v1 pith:PV7H4N5H submitted 2025-06-08 cs.CV

Qiong Chang , Xinyuan Chen , Xiang Li , Weimin Wang , Jun Miyazaki This is my paper
classification cs.CV
keywords ORBFASTdetectionHarrisbinaryencodingseparableSobelembeddedGPUCUDAkernelsJetsonTX2
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to accelerate the two most time-consuming pieces of Oriented FAST feature detection—the FAST segment test and the Harris corner filter—on low-end embedded GPUs, where memory bandwidth is roughly a tenth of desktop GPUs. It claims a binary encoding trick replaces the branch-heavy consistency check in FAST, and a 'semi-separable' Sobel operator with circular buffers makes Harris gradients cheap to compute in shared memory. On a Jetson TX2 the combined kernels are reported to run FAST detection 2.2–4.5x faster than the CUDA_ORB baseline and Harris detection 1.1–13x faster, averaging over 7.3x faster than OpenCV with GPU support. If those numbers hold, Oriented FAST would no longer dominate the ORB-SLAM budget, and real-time visual SLAM on power-constrained mobile robots and wearables would be much more attainable.

What carries the argument

The two load-bearing mechanisms are (1) buffer32b, a 32-bit integer that encodes the 16 FAST comparisons as dark/bright bits, extended into two 24-bit ring buffers so that all 16 possible nine-pixel segments can be tested by shifting against the mask 0x1FF; and (2) a semi-separable Sobel operator that decomposes the 2D Sobel into 1D passes, executes them alternately, and keeps only three rows of intermediate results rotating through per-thread register arrays sgx[3] and sgy[3] with shared-memory accumulators sxx, syy, sxy for the Harris products. Together they replace branch-heavy pixel-loop logic with bitwise operations and replace an intermediate image with a small circular buffer, which is precisely what a low-bandwidth embedded GPU needs.

What would settle it

Implement Algorithm 3 exactly as printed and compare its Harris scores and corner locations on the paper's eight test images against those of the standard 2D-Sobel Harris with k=0.04; if the gradients used in Equation 3 differ systematically—for instance, horizontal-smoothing values appearing where horizontal gradients should be—the speedups come from computing a different detector and the equivalence claim fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that the bottleneck in GPU-based Oriented FAST is not arithmetic but control flow and memory traffic, and that both can be attacked at the instruction level. For FAST, the 16 per-pixel comparisons around a candidate are packed into a 32-bit integer—dark states in the upper half, bright states in the lower—and detection reduces to checking whether any nine consecutive bits are all 1, done with a mask and shift instead of loops of if-else branches. For Harris, the Sobel operator is applied separably, but the horizontal pass is interleaved with the vertical pass and the three row results rotate through per-thread registers, so intermediate images never need to be stored; a warp writes the accumulated gxx, gyy, gxy products to shared memory and each detected point reads them out. The paper argues, with PTX instruction counts and timings on eight images, that this combination removes over a third of global loads and branch instructions in FAST and makes the Harris stage's runtime depend mainly on the number of feature points rather than on image size.

Load-bearing premise

The load-bearing premise is that the semi-separable Sobel kernel, as actually shipped, computes exactly the same Harris scores as the standard 2D Sobel operator; the pseudocode in the paper is internally inconsistent about which intermediate value its circular buffers hold, and no source code is provided to confirm that the shipped kernel follows the intended version.

Editorial extensions

If this is right

  • A real-time ORB front-end becomes feasible on Jetson-class hardware: the paper's Semi-Sep_ORB reaches roughly 144 FPS on a 768x432 indoor video and 55 FPS on a 1280x720 street video on the TX2.
  • The FAST binary encoding makes detection runtime nearly independent of the spatial pattern of dark/bright segments, unlike the early-exit baseline whose runtime varies with pattern shape.
  • Since the Harris stage is fused into the same warp and its runtime scales with feature-point count rather than image size, images with many FAST points benefit most; the paper reports up to 13x Harris speedup on decentralized images.
  • The same kernels also run faster on a higher-end embedded GPU (Jetson AGX Xavier), achieving about 6.3x speedup over the baseline while lowering energy per frame, so the optimization is not specific to one chip.
  • SLAM systems can devote the saved time to other stages (bundle adjustment, loop closure) or to higher-resolution images without leaving the real-time budget.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the binary segment-test trick is correct, it should generalize to other segment tests (e.g., FAST-12 or different N) by changing the mask width, which the paper does not explore.
  • The circular-buffer semi-separable Sobel is a general stencil technique: any 2D separable filter with a small vertical kernel could reuse the same register-rotation pattern on memory-constrained GPUs, not just Harris.
  • The paper reports per-stage speedups but not downstream SLAM trajectory accuracy; a natural next experiment is to feed Semi-Sep_ORB's corners into ORB-SLAM and compare map and trajectory quality against CUDA_ORB to confirm the accelerated detector is not just faster but equally usable.
  • Porting the binary encoding to FPGA, as the paper suggests for future work, would replace branch evaluation with parallel logic and could be tested by synthesizing buffer32b's segment check as combinational logic.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes two GPU kernels to accelerate the Oriented FAST feature detection stage of ORB-SLAM on low-end embedded GPUs: BinaryFAST, which encodes the 16 FAST circle comparisons into bit masks to avoid branch instructions, and Semi-SepHarris, a semi-separable Sobel Harris detector using a circular buffer in registers and shared-memory accumulation, fused with FAST detection in a single kernel. Experiments on a Jetson TX2 (and a Jetson AGX Xavier) compare runtime against CUDA_ORB, OpenCV CPU ORB, and OpenCV GPU ORB, reporting 2.2-4.5x faster FAST detection and 1.1-13x faster Harris detection than CUDA_ORB, with the abstract claiming an average speedup of over 7.3x versus OpenCV GPU. The paper also reports power and energy-efficiency metrics.

Significance. If the reported speedups are for a functionally equivalent Oriented FAST pipeline, the work is a useful contribution to real-time embedded SLAM: the binary-encoding FAST idea is a clean, plausible branch-reduction technique, the shared-memory/warp-cooperative Harris design targets a genuine embedded-GPU bottleneck, and the PTX instruction counts for FAST support the branch-reduction story. However, the central Harris claim is not yet substantiated: the only pseudocode specification of Semi-SepHarris appears to compute a different quantity than the separable Sobel decomposition it is derived from, and no accuracy/repeatability comparison or source code is provided. The abstract's OpenCV-GPU speedup is not present in the experimental section. These gaps place the headline numerical claims in doubt until corrected.

major comments (4)
  1. [Section 5.2, Algorithm 3] The sliding-loop assignments in Algorithm 3 swap the roles of sgx and sgy relative to the separable Sobel decomposition in Eq. 4 and the initialization in lines 10-11. Line 18 stores the horizontal smoothing I[r][Tid+1]+2*I[r][Tid]+I[r][Tid-1] into sgx (which should hold the horizontal derivative for Gx), and line 19 stores the vertical difference I[r+1][Tid]-I[r-1][Tid] into sgy (which should hold the horizontal smoothing for Gy). Consequently, line 20 computes a vertical smoothing of a horizontally blurred image rather than Gx, and line 21 computes a vertical difference of vertical differences rather than Gy. In addition, line 14 computes gy from sgy[1]-sgy[0] instead of sgy[2]-sgy[0] for the center row. If the shipped kernel matches this pseudocode, the Harris scores from Eq. 3 are not computed from Sobel gradients, and the reported 1.1-13x Harris speedups are for a different computation. If the shipped kernel is correct, the manuscript does not report it, and no source code is provided to resolve the discrepancy.
  2. [Section 6.2, Figures 10-13] The abstract claims 'an average speedup of over 7.3 times compared to widely used OpenCV with GPU support,' but no such number appears in Section 6.2. The labels in Figures 10-13 are speedups relative to CUDA_ORB (as stated in the captions), and the text reports ranges (2.2-4.5x for FAST, 1.1-13x for Harris) relative to the baseline. The speedup versus OPENCVGPU_ORB is never tabulated or averaged, so the headline claim is unverifiable as written. Please report the OpenCV-GPU-relative speedups explicitly or revise the abstract.
  3. [Section 6, Table 3] The text states that the total PTX instruction count of Baseline(Harris) is 'considerably smaller' than other methods because it nests the two-dimensional Sobel operations in loops without unrolling, but the table gives Baseline(Harris) a total of 1114 instructions versus 213-429 for the proposed Harris variants. This contradicts the stated conclusion and undermines the PTX-based efficiency argument for the Harris kernel. Please clarify whether the 1114 count is a static count before loop unrolling or includes loop body expansion, and correct the narrative accordingly.
  4. [Section 6, throughout] No accuracy, repeatability, or feature-point correspondence comparison is provided. Because Algorithm 3 is the only specification of the Harris kernel, a runtime-only evaluation cannot distinguish an optimized but correct Harris detector from a fast but wrong one. Please include a repeatability or correspondence metric (e.g., number of matching corners with OpenCV ORB, or repeatability under image transformations) for at least a subset of the test images, and/or release source code so that the equivalence of the semi-separable Harris score to the standard Harris score can be checked.
minor comments (5)
  1. [Section 5.2, Algorithm 3 line 32] The variable 'f actor' is used in the Harris score formula but is never defined; if it is a fixed scaling factor its value should be stated, since it enters the computed score.
  2. [General presentation] The title and author affiliation contain typos ('A CCELERATING', 'F EATURE', 'Coumputing'); Table 1 contains garbled text ('OpenCV 4.5.31866 MHx' and '1866 MHx'); reference [17] is truncated; and 'compiled' is misspelled as 'complied' in Section 6.
  3. [Section 6, runtime figures] The runtime figures report single measurements without error bars or repeated-run statistics; given the large reported speedups, at least a few repeated runs with standard deviation for the main comparison (Semi-Sep_ORB vs CUDA_ORB) would strengthen the reproducibility of the numbers.
  4. [Section 5.2 vs Section 6] The notation is inconsistent between 'Semi-SepHarris' (used in Section 5.2) and 'Semi-Sep_ORB' (used in Section 6 and the figures); please unify the terminology.
  5. [Section 6.2, Figures 10-11] The sentence 'OPENCVGPU shows a superior performance but falls short on small images' is ambiguous because in Figures 10-11 OpenCVGPU is sometimes faster and sometimes slower than CUDA_ORB depending on image size; please state explicitly that the comparison is relative to the CUDA_ORB baseline.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular reasoning: the reported speedups are measured against external CUDA_ORB and OpenCV baselines, and the kernel optimizations are specified independently of those benchmark claims.

full rationale

The paper's derivation chain is: (1) FAST detection is accelerated by encoding the 16 intensity comparisons into a 32-bit buffer and checking 9-bit runs with bitwise operations; (2) Harris detection is accelerated by a semi-separable Sobel implementation using a circular buffer in shared memory; (3) runtimes are then measured against CUDA_ORB, OpenCV CPU, and OpenCV GPU. None of these steps defines its output in terms of its input. The separable Sobel decomposition in Eq. 4 is cited to the authors' prior work [27], but it is a standard mathematical identity (two 1D convolutions equivalent to the 2D Sobel mask) and the implementation is given in explicit pseudocode, so that self-citation is not load-bearing for the speedup claim. The undefined 'f actor' in Algorithm 3 line 32 is never said to be fitted, and no runtime result depends on its value, so it is at most an implementation ambiguity rather than a fitted input renamed as a prediction. The internal inconsistency between lines 10-11 and 18-19 of Algorithm 3 is a correctness risk concerning whether the shipped kernel computes true Harris scores, but circularity requires a claimed derivation that reduces to its own inputs; benchmarking a possibly incorrect kernel against external baselines is not a circular derivation. The claimed 2.2-4.5x FAST speedup, 1.1-13x Harris speedup, and 7.3x average speedup over OpenCV GPU are empirical, falsifiable measurements, and no calibration parameter determines them by construction.

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The central claim is empirical: measured runtimes. The only free inputs are the FAST threshold, Harris k, and an unexplained scale factor; none are fitted to make the speedup numbers come out. The algorithms rely on standard GPU and Sobel math assumptions. No new entities are postulated.

free parameters (3)
  • FAST intensity threshold t = not specified
    Threshold for classifying surrounding pixels as bright/dark; affects the number of detected points. The paper does not report the value used, so the speedups are conditional on the chosen threshold.
  • Harris constant k = 0.04
    Empirical constant in the Harris score, standard in ORB and OpenCV. Not fitted for this paper, but an input parameter.
  • Harris score scale factor = unspecified
    Algorithm 3 line 32 multiplies the Harris score by an undefined 'factor'. If this constant is chosen to match OpenCV's Harris threshold, it is a hand-set calibration parameter.
assumptions (3)
  • domain assumption FAST 9-of-16 segment test defines a feature point
    Standard FAST definition, used as ground truth for detection; not re-derived in the paper.
  • standard math Sobel kernel is separable as in Eq. 4
    The decomposition of the 2D Sobel into two 1D convolutions is standard linear algebra.
  • domain assumption Warp-synchronous __any_sync semantics on the target GPU
    Algorithm 3 line 7 uses __any_sync(0xFFFFFFFF, isPoint), which assumes a full warp of 32 threads and a valid membership mask; this is hardware dependent.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Faster than Fast: Accelerating Oriented FAST Feature Detection on Low-end Embedded GPUs." pith.science (2026). https://pith.science/paper/PV7H4N5H

@misc{pith2026250607164,
  author       = {Pith},
  title        = {Pith review of: Faster than Fast: Accelerating Oriented FAST Feature Detection on Low-end Embedded GPUs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PV7H4N5H}},
  note         = {Machine review of arXiv:2506.07164}
}
read the original abstract

The visual-based SLAM (Simultaneous Localization and Mapping) is a technology widely used in applications such as robotic navigation and virtual reality, which primarily focuses on detecting feature points from visual images to construct an unknown environmental map and simultaneously determines its own location. It usually imposes stringent requirements on hardware power consumption, processing speed and accuracy. Currently, the ORB (Oriented FAST and Rotated BRIEF)-based SLAM systems have exhibited superior performance in terms of processing speed and robustness. However, they still fall short of meeting the demands for real-time processing on mobile platforms. This limitation is primarily due to the time-consuming Oriented FAST calculations accounting for approximately half of the entire SLAM system. This paper presents two methods to accelerate the Oriented FAST feature detection on low-end embedded GPUs. These methods optimize the most time-consuming steps in Oriented FAST feature detection: FAST feature point detection and Harris corner detection, which is achieved by implementing a binary-level encoding strategy to determine candidate points quickly and a separable Harris detection strategy with efficient low-level GPU hardware-specific instructions. Extensive experiments on a Jetson TX2 embedded GPU demonstrate an average speedup of over 7.3 times compared to widely used OpenCV with GPU support. This significant improvement highlights its effectiveness and potential for real-time applications in mobile and resource-constrained environments.

Figures

Figures reproduced from arXiv: 2506.07164 by the authors.

Figure 1
Figure 1. Runtime distribution of each step in Oriented-FAST using a Jetson TX2 GPU [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Two primary detection steps in Oriented FAST. (a) An example of FAST feature point detection circle, [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Rapid consistency determination using a binary encoding strategy. 16 differences [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (11 more)
Figure 4
Figure 4. Figure 4: Processing flow of Harris score calculation. Step1: 1D Sobel Operator. Step2: 1D Sobel operator & [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Image set used in the experiments 6.1 Evaluation of Proposed Oriented FAST Kernel To clarify the acceleration effect brought by each optimization step, the proposed methods are categorized into the several components and choose the standard implementation CUDA_ORB [20]…
Figure 6
Figure 6. Figure 6: Test cases for FAST detection. (a) nine continuous bright points from the beginning; (b) more than nine [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]
Figure 7
Figure 7. Figure 7: Performance comparison of FAST-like algorithms on different test cases. The subscripts 1 and 4 represent the [PITH_FULL_IMAGE:figures/full_fig_p013_7.png]
Figure 8
Figure 8. Figure 8: Performance comparison of different methods on centralized images [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]
Figure 9
Figure 9. Figure 9: Performance comparison of different methods on decentralized images [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: Performance comparison of different FAST detection methods on centralized images. Labels above the bars [PITH_FULL_IMAGE:figures/full_fig_p014_10.png]
Figure 11
Figure 11. Figure 11: Performance comparison of different FAST detection methods on decentralized images. Labels above the [PITH_FULL_IMAGE:figures/full_fig_p014_11.png]
Figure 12
Figure 12. Figure 12: Performance comparison of different Harris detection methods on centralized images. Labels above the bars [PITH_FULL_IMAGE:figures/full_fig_p015_12.png]
Figure 13
Figure 13. Figure 13: Performance comparison of different Harris detection methods on decentralized images. Labels above the [PITH_FULL_IMAGE:figures/full_fig_p015_13.png]
Figure 14
Figure 14. Figure 14: Video processing across different platforms. (a),(b),(e),(f): frames from the [PITH_FULL_IMAGE:figures/full_fig_p017_14.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

30 extracted references · 28 canonical work pages

  1. [1]

    IEEE robotics & automation magazine, 13(2):99–110, 2006

    Simultaneous localization and mapping: part i. IEEE robotics & automation magazine, 13(2):99–110, 2006

    work page 2006

  2. [2]

    Edge-slam: Edge-assisted visual simultaneous localization and mapping

    Ali J Ben Ali, Marziye Kouroshli, Sofiya Semenova, Zakieh Sadat Hashemifar, Steven Y Ko, and Karthik Dantu. Edge-slam: Edge-assisted visual simultaneous localization and mapping. ACM Transactions on Embedded Computing Systems, 22(1):1–31, 2022

    work page 2022

  3. [3]

    Robust embedded autonomous driving positioning system fusing lidar and inertial sensors

    Zhijian He, Bohuan Xue, Xiangcheng Hu, Zhaoyan Shen, Xiangyue Zeng, and Ming Liu. Robust embedded autonomous driving positioning system fusing lidar and inertial sensors. ACM Transactions on Embedded Computing Systems, 23(1):1–26, 2024

    work page 2024

  4. [4]

    Feature-based visual simultaneous localization and mapping: A survey

    Rana Azzam, Tarek Taha, Shoudong Huang, and Yahya Zweiri. Feature-based visual simultaneous localization and mapping: A survey. SN Applied Sciences, 2:1–24, 2020

    work page 2020

  5. [5]

    Distinctive image features from scale-invariant keypoints

    David G Lowe. Distinctive image features from scale-invariant keypoints. International journal of computer vision, 60:91–110, 2004

    2004

  6. [6]

    Speeded-up robust features (surf)

    Herbert Bay, Andreas Ess, Tinne Tuytelaars, and Luc Van Gool. Speeded-up robust features (surf). Computer vision and image understanding, 110(3):346–359, 2008

    work page 2008

  7. [7]

    Features from accelerated segment test (fast)

    Deepak Geetha Viswanathan. Features from accelerated segment test (fast). In Proceedings of the 10th workshop on image analysis for multimedia interactive services, London, UK, pages 6–8, 2009

    work page 2009

  8. [8]

    Cnn-based feature-point extraction for real-time visual slam on embedded fpga

    Zhilin Xu, Jincheng Yu, Chao Yu, Hao Shen, Yu Wang, and Huazhong Yang. Cnn-based feature-point extraction for real-time visual slam on embedded fpga. In 2020 IEEE 28th Annual International Symposium on Field- Programmable Custom Computing Machines (FCCM), pages 33–37. IEEE, 2020

    work page 2020

Show all 30 references
  1. [9]

    D2-net: A trainable cnn for joint description and detection of local features

    Mihai Dusmanu, Ignacio Rocco, Tomas Pajdla, Marc Pollefeys, Josef Sivic, Akihiko Torii, and Torsten Sattler. D2-net: A trainable cnn for joint description and detection of local features. In Proceedings of the ieee/cvf conference on computer vision and pattern recognition, pag...

    2019

  2. [10]

    Orb: An efficient alternative to sift or surf

    Ethan Rublee, Vincent Rabaud, Kurt Konolige, and Gary Bradski. Orb: An efficient alternative to sift or surf. In 2011 International conference on computer vision, pages 2564–2571. Ieee, 2011

    2011

  3. [11]

    Orb-slam3: An accurate open-source library for visual, visual–inertial, and multimap slam

    Carlos Campos, Richard Elvira, Juan J Gómez Rodríguez, José MM Montiel, and Juan D Tardós. Orb-slam3: An accurate open-source library for visual, visual–inertial, and multimap slam. IEEE Transactions on Robotics, 37(6):1874–1890, 2021

    2021

  4. [12]

    Locator: Low-power orb accelerator for autonomous cars

    Raúl Taranco, José-Maria Arnau, and Antonio González. Locator: Low-power orb accelerator for autonomous cars. Journal of Parallel and Distributed Computing, 174:32–45, 2023

    2023

  5. [13]

    eslam: An energy-efficient accelerator for real-time orb-slam on fpga platform

    Runze Liu, Jianlei Yang, Yiran Chen, and Weisheng Zhao. eslam: An energy-efficient accelerator for real-time orb-slam on fpga platform. In Proceedings of the 56th Annual Design Automation Conference 2019, pages 1–6, 2019

    2019

  6. [14]

    A flexible and efficient real-time orb-based full-hd image feature extraction accelerator

    Rongdi Sun, Jiuchao Qian, Romero Hung Jose, Zheng Gong, Ruihang Miao, Wuyang Xue, and Peilin Liu. A flexible and efficient real-time orb-based full-hd image feature extraction accelerator. IEEE Transactions on Very Large Scale Integration (VLSI) Systems, 28(2):565–575, 2019

    2019

  7. [15]

    Fslam: an efficient and accurate slam accelerator on soc fpgas

    Vibhakar Vemulapati and Deming Chen. Fslam: an efficient and accurate slam accelerator on soc fpgas. In 2022 International Conference on Field-Programmable Technology (ICFPT), pages 1–9. IEEE, 2022

    2022

  8. [16]

    Tinystereo: A tiny coarse-to-fine framework for vision-based depth estimation on embedded gpus

    Qiong Chang, Xin Xu, Aolong Zha, Meng Joo Er, Yongqing Sun, and Yun Li. Tinystereo: A tiny coarse-to-fine framework for vision-based depth estimation on embedded gpus. IEEE Transactions on Systems, Man, and Cybernetics: Systems, pages 1–13, 2024

    2024

  9. [17]

    Acceleration of video stabilization using embedded gpu

    Yuzuki Mimura, Chang Qiong, and Tsutomu Maruyama. Acceleration of video stabilization using embedded gpu. In 2022 IEEE 33rd Internationa

    2022

  10. [18]

    Brief announcement: Opti- mized gpu-accelerated feature extraction for orb-slam systems

    Filippo Muzzini, Nicola Capodieci, Roberto Cavicchioli, and Benjamin Rouxel. Brief announcement: Opti- mized gpu-accelerated feature extraction for orb-slam systems. In Proceedings of the 35th ACM Symposium on Parallelism in Algorithms and Architectures, pages 299–302, 2023

    2023

  11. [19]

    Realization of cuda-based real-time registration and target localization for high-resolution video images

    Xiyang Zhi, Junhua Yan, Yiqing Hang, and Shunfei Wang. Realization of cuda-based real-time registration and target localization for high-resolution video images. Journal of Real-Time Image Processing, 16:1025–1036, 2019. 18 A PREPRINT - AUGUST 26, 2025

    2019

  12. [20]

    Cuda-orb

    Accustomer. Cuda-orb. https://github.com/Accustomer/CUDA-ORB, 2023. Accessed: 2023-11-01

    2023

  13. [21]

    Ptx: Parallel thread execution isa version 8.7

    nvidia. Ptx: Parallel thread execution isa version 8.7. https://docs.nvidia.com/cuda/parallel-thread-execution/, 2025

    2025

  14. [22]

    Faster than fast: Gpu-accelerated frontend for high-speed vio

    Balázs Nagy, Philipp Foehn, and Davide Scaramuzza. Faster than fast: Gpu-accelerated frontend for high-speed vio. In 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 4361–4368. IEEE, 2020

    2020

  15. [23]

    A 182 mw 94.3 f/s in full HD pattern-matching based image recognition accelerator for an embedded vision system in 0.13-µm CMOS technology

    Jun-Seok Park, Hyo-Eun Kim, and Lee-Sup Kim. A 182 mw 94.3 f/s in full HD pattern-matching based image recognition accelerator for an embedded vision system in 0.13-µm CMOS technology. IEEE Trans. Circuits Syst. Video Technol., 23(5):832–845, 2013

    2013

  16. [24]

    Parallel harris corner detection on heterogeneous architec- ture

    Yiwei He, Yue Ma, Dalian Liu, and Xiaohua Chen. Parallel harris corner detection on heterogeneous architec- ture. In Computational Science–ICCS 2018: 18th International Conference, Wuxi, China, June 11-13, 2018, Proceedings, Part II 18, pages 443–452. Springer, 2018

    2018

  17. [25]

    Harris corner detection on a numa manycore

    Olfa Haggui, Claude Tadonki, Lionel Lacassagne, Fatma Sayadi, and Bouraoui Ouni. Harris corner detection on a numa manycore. Future Generation Computer Systems, 88:442–452, 2018

    2018

  18. [26]

    Optimizing Harris corner detection on GPGPUs using CUDA

    Justin Loundagin. Optimizing Harris corner detection on GPGPUs using CUDA. M.Sc. thesis. California Poly- technic State University, 2015

    2015

  19. [27]

    Multi-directional sobel operator kernel on gpus

    Qiong Chang, Xiang Li, Yun Li, and Jun Miyazaki. Multi-directional sobel operator kernel on gpus. Journal of Parallel and Distributed Computing, 177:160–170, 2023

    2023

  20. [28]

    Cuda c programming guide

    Nvidia Corporation. Cuda c programming guide. https://docs.nvidia.com/cuda/archive/11.2.0/cuda-c- programming-guide/index.html, 2021

    2021

  21. [29]

    Opencv: Open source computer vision library

    OpenCV Development Team. Opencv: Open source computer vision library. https://opencv.org/, Year. Version 4.1

  22. [30]

    Intel-iot-devkit

    Intel Iot Libraries. Intel-iot-devkit. https://github.com/intel-iot-devkit/sample-videos, 2018. 19

    2018

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.