Motion Detection and High Speed Camera Image Trigger

Updated: August 27, 2026

Detecting a slightest motion in the camera’s field of view and starting video recording is a common task in many surveillance and security systems. The problem is to detect the motion fast enough to be able to capture it in frame, so that the camera wouldn’t record empty video.

The software or FPGA detects a moving object by building histograms of input frames and comparing adjacent frames’ histograms for differences. If a histogram changes significantly, this signalizes about a new object moving in the shot. Such process is called Image Trigger. Image trigger works as a signal to begin capturing of several or multiple frames from a high-speed camera until the movement stops or another trigger activates.

Fastvideo developed such image trigger as PC software. We believe that CPU computations don’t allow attaining the desirable productivity and FPGA solutions are too complicated, so we transferred the histogram calculation to GPU and applied NVIDIA CUDA parallel processing technology. We use CameraLink high speed cameras with PCI-Express framegrabber as a data source for imaging system. Camera sends all data to PC RAM and our software is capable to calculate histogram for every image received in real time. Such architecture still has some latency, but the problem could be easily solved by organizing a circle buffer in PC RAM. Upon every trigger event software calculates a histogram data set and determines whether it differs from the starting histogram. Unprecedented performance of our Image Trigger technology opens a wide range of applications.

How these numbers were measured. Fastvideo benchmarks are measured on NVIDIA GPUs, timing pure GPU processing at the resolution, bit depth, format and quality stated on this page. See the full benchmark methodology and test environment and the Fastvideo SDK benchmark report (PDF). Our tools are open source on GitHub and built on NVIDIA CUDA.

Check a single module. Every module in the Fastvideo SDK comes with a command-line sample. Run it on your own images on your own GPU and compare the result with the figures published here.

Check the whole pipeline. A module in the middle of a pipeline cannot be judged on its own: its input is hard to prepare, and its output is an intermediate product you cannot look at. What matters is how it changes the final image and the total time of the schema. Two of our applications run the complete pipeline and report the time of every stage — FastVCR (live cameras or RAW files from disk, so no camera is required) and Fast CinemaDNG (DNG, offline). The benchmark module is included in the free builds of both.

Detailed benchmark data. Measured results are published on our benchmark pages: all benchmarks.

We wrote these algorithms ourselves

Image processing has always been a trade-off between quality and speed. The methods that give a good result take minutes per frame; the fast ones leave halos and artifacts. The reason is the compute budget: on a CPU there was never enough of it, so algorithms were simplified — and much of the industry still runs on simplifications accepted decades ago.

Fastvideo’s codecs and ISP modules are neither ports of that legacy nor wrappers around third-party code. We designed — and in many cases invented — the algorithms behind our demosaicing, denoising, tone mapping and JPEG/JPEG2000 codecs, and wrote them for CUDA from the start, on top of image-processing expertise built since 2009. An algorithm moved to the GPU still carries the compromises it was simplified for; ours were never made under that constraint. On a modern GPU the budget is large enough that, for practical workloads, the choice between quality and speed no longer has to be made.

That is why you get a complete, tuned imaging solution rather than a bag of GPU primitives — and why, when your pipeline needs something specific, we can change the algorithm itself, not just call it.

GPU image trigger features

Data input: uncompressed 8-bit grayscale image
Data output: final 256-bin histogram
Continuous data mode (input one image after another)
Parallel performance for image loading and computations
Unlimited input image size
Compatibility with NVIDIA mobile and table top video cards

PC test configuration

ASUS P6T Deluxe V2 LGA1355, Core i7 2600, 3.4 GHz, DDR-III 8 GB
GPU GeForce GTX 1080 or better
OS Windows-10, 64-bit, CUDA-12

Applications for high-performance histogram calculations

High-performance CUDA histogram is suitable for a variety of digital imaging applications

Image trigger for high speed cameras
Image processing

What we could offer for your NVIDIA GPU

CUDA histogram calculations for high speed imaging
HPC custom solutions for CUDA image processing tasks
Custom software development for NVIDIA GPU

Support

Full technical support up to successful client integration

For any further information on these solutions please contact us via email.

About the author

Fyodor Serzhenko, PhD, is the founder and CEO of Fastvideo. He earned his PhD at the Moscow Institute of Physics and Technology (MIPT) in 1993. Since 2009 he has led the development of Fastvideo’s GPU-accelerated image codecs and ISP modules, including the Fastvideo SDK. Connect on LinkedIn.

Why you can trust these results

Fastvideo has built GPU-accelerated image processing software since 2009. Our codecs comply with the standards they implement — JPEG (ITU-T T.81 / ISO IEC 10918) and JPEG2000 (ITU-T T.800 / ISO IEC 15444) — and our tools are open source on GitHub. Every performance figure we publish is reproducible: see our benchmark methodology, download the Fastvideo SDK benchmark report (PDF), and measure it on your own GPU.