eSDK Pro Programmer’s Guide Overview

Emergent Vision Technologies designs high-speed industrial cameras and software for capturing, processing, and managing image data in demanding machine vision systems.

eSDK Pro lets you build applications to capture and process images from many Emergent Vision cameras without writing thousands of lines of low-level control code. It is built for systems with many cameras, often spread across multiple servers, and keeps your application code small and clear.

With the classic eSDK, synchronizing dozens of cameras across multiple servers could take hundreds or even thousands of lines of code. With eSDK Pro, you can do it in just a few clear API calls.

How it fits in your system: Your application calls the eSDK Pro API, which communicates with one or more servers running Emergent Vision cameras. The API manages pipelines — groups of cameras and processing tasks — that control the cameras, process frames, and store or stream results. Unlike the classic eSDK, which manages individual cameras, eSDK Pro manages the entire camera network as a single system. It uses a client–server architecture. Your application can manage cameras on remote servers, start and stop them together, and handle data flows without complex orchestration code.

Why use eSDK Pro

The classic eSDK is a low-level API that requires detailed, camera-by-camera management. This makes integration time-consuming and often requires significant support from Emergent. eSDK Pro simplifies integration. Its high-level API abstracts many low-level functions so you can get started quickly and build applications with minimal boilerplate code.

Acceleration with FlexProc and FlexTrans

eSDK Pro sits on top of Emergent’s acceleration frameworks, FlexProc (processing) and FlexTrans (data movement). FlexProc lets you run image-processing tasks on CPUs, GPUs, FPGAs, or the cloud using a plugin model — modular tasks you can extend with your own code. FlexTrans moves frames and results between GPUs and servers with GPUDirect/zero-copy paths, meaning direct GPU-to-GPU transfers without extra memory copies. Together, they provide the scalable performance foundation for multi-camera, multi-server systems. These same capabilities power eCapture Pro and are also available when you build your own applications with the SDK.

Core Features of eSDK Pro

eSDK Pro offers a range of capabilities designed to speed up development and simplify complex multi-camera systems:

• High-level API: Replace large amounts of setup and management code with a few function calls.
• System-level design: Manage many cameras and servers as one coordinated system.‍
• FlexProc and FlexTrans acceleration: Built-in frameworks for high-performance processing and data movement across CPUs, GPUs, FPGAs, and servers.‍
• Client–server management: Use the same API for remote and local servers.‍
• Simplified concurrency: Handles multi-threading and synchronization for you.‍
• Image processing: Use built-in tasks for raw recording or NVENC compression, and extend functionality with custom plugins.‍
• Modern C++ API: Works on Windows and Linux with support for major C++ compilers.

eSDK Pro Use Cases

eSDK Pro is designed for:

• Quick integration: Set up multi-camera, multi-server recording systems with far less code than the classic eSDK.
• Rapid prototyping: Build small, clear prototypes that scale to production systems.
• Multi-server coordination: Record synchronized video from cameras on multiple servers without writing orchestration code.
• Out-of-the-box workflows: Perform raw recording or NVENC compression without writing custom processing code.

eSDK Pro vs. Classic eSDK: Key Differences

Emergent offers two SDKs, each designed for different levels of control and system complexity:

• eSDK Pro: High-level, system-wide control for multi-camera and multi-server applications. Abstracts networking, threading, and synchronization so you can focus on application logic.
• Classic eSDK: Low-level, camera-by-camera control with fine-grained feature access but more development overhead.

Applications should use one SDK or the other — never both in the same project.

eSDK Pro vs. eCapture Pro: Workflow Comparison

eSDK Pro and eCapture Pro share the same architecture but serve different roles:

• eCapture Pro: A GUI application for configuring and recording from Emergent cameras.
• eSDK Pro: A programmable SDK for building custom applications.

Both use the same core server architecture. You cannot run them at the same time on the same server. A common workflow is to configure cameras in eCapture Pro, close it, and then run your eSDK Pro application.

Core Concepts

• Pipeline: Works like a production line — multiple cameras capture data, tasks process it, and the output is stored or streamed, all starting and stopping together.
• Processing task: A unit of work in a pipeline, such as saving raw images or compressing video.
• Plugin: A custom module you develop to add new processing tasks for frames.

Roadmap for Developers

Use the following sections to explore eSDK Pro in more detail:

• eSDK Pro System Requirements — Supported operating systems, toolchains, GPU requirements, and networking prerequisites for scalable multi-camera systems.
• Installing eSDK Pro — Step-by-step installation on Windows and Linux.
• eSDK Pro Examples — Practical examples for raw recording, NVENC compression, and plugins.
• eSDK Pro System Architecture — Deep dive into System, Server, Camera, Pipeline, Task, and TaskWorker.
• eSDK Pro API Reference — Complete reference for classes and methods, including error handling and versioning.