C++ Programmer's Guide#

This topic provides information specific to Basler Stereo mini cameras and doesn't aim to give a comprehensive overview of the pylon C++ API.

If you are new to pylon, Basler recommends making yourself familiar with the pylon C++ API first by reading the Getting Started section of the pylon C++ Programmer's Guide.

C++ Programming Samples#

The following Stereo mini C++ samples are available:

• FirstSample: Grabs intensity and range data and prints center pixel values.
  • Opens the first Stereo mini device using BaslerGenTlStmDeviceClass.
  • Enables intensity and range components.
  • Reads center pixel intensity (RGBA) and range values.
• GrabDepthMap: Converts range data to a colorized depth map using OpenCV.
  • Uses the range component (Coord3D_C16).
  • Colorizes depth values with OpenCV for live visualization.
• ShowPointCloud: Displays live colored point clouds with PCL.
  • Uses the range component (Coord3D_ABC32f) and intensity for color.
  • Converts grab results to pcl::PointCloud<pcl::PointXYZRGB>.
  • Displays a live point cloud viewer.
• SavePointCloud: Saves one colored point cloud as a .ply file.
  • Captures one frame and exports a colored point cloud to pointcloud_color.ply.

Prerequisites for Building the Samples#

sudo apt -y install build-essential cmake libopencv-dev libpcl-dev libboost-all-dev

How to Build the Samples#

CMake is used as the build system for all C++ samples.

Installing the OpenCV Library#

cmake -DOpenCV_DIR="C:\Program Files\OpenCV\build\x64\vc16\lib" ..

C:\Program Files\OpenCV\build\x64\vc16\bin

sudo apt-get -y install libopencv-dev

cmake -DOpenCV_DIR=$HOME/OpenCV/lib ..

Installing the Point Cloud Library#

cmake -DPCL_DIR="C:\Program Files\PCL 1.14.0\cmake" ..

sudo apt-get -y install libpcl-dev

cmake -DPCL_DIR=$HOME/PCL/cmake ..

Running the Samples#

Run an executable from the build output folder, for example:

./FirstSample/FirstSample
./GrabDepthMap/GrabDepthMap
./ShowPointCloud/ShowPointCloud
./SavePointCloud/SavePointCloud

How to Build Applications#

Use CMake to create your own Stereo mini C++ applications, as demonstrated by the sample set provided.

Using IDE Projects#

Using CMake#

The Stereo mini samples use a CMake setup with:

• find_package(pylon 10.0 REQUIRED)
• optional find_package(OpenCV QUIET) for depth map visualization
• optional find_package(PCL QUIET) for point cloud visualization

A minimal CMake project for a Stereo mini application can look like this:

cmake_minimum_required(VERSION 3.21)
project(stereo_mini_app LANGUAGES CXX)

# Locate pylon on Windows
list(APPEND CMAKE_PREFIX_PATH $ENV{PYLON_DEV_DIR})

find_package(pylon 10.0 REQUIRED)

add_executable(stereo_mini_app main.cpp)
target_link_libraries(stereo_mini_app PRIVATE pylon::pylon)

cmake_minimum_required(VERSION 3.21)
project(stereo_mini_app LANGUAGES CXX)

# Locate pylon on Linux
list(APPEND CMAKE_PREFIX_PATH $ENV{PYLON_ROOT})

find_package(pylon 10.0 REQUIRED)

add_executable(stereo_mini_app main.cpp)
target_link_libraries(stereo_mini_app PRIVATE pylon::pylon)

If your application uses the same optional dependencies as the samples, add them conditionally:

find_package(OpenCV QUIET)
find_package(PCL QUIET)

if (OpenCV_FOUND)
    target_include_directories(stereo_mini_app PRIVATE ${OpenCV_INCLUDE_DIRS})
    target_link_libraries(stereo_mini_app PRIVATE ${OpenCV_LIBS})
endif()

if (PCL_FOUND)
    target_include_directories(stereo_mini_app PRIVATE ${PCL_INCLUDE_DIRS})
    target_compile_definitions(stereo_mini_app PRIVATE ${PCL_DEFINITIONS})
    target_link_libraries(stereo_mini_app PRIVATE ${PCL_LIBRARIES})
endif()

To build from the command line:

mkdir -p build
cd build
cmake ..
cmake --build .

Accessing Camera Features#

Opening a Device#

Use the Pylon::CTlFactory::CreateFirstDevice() method to create a camera object for the first available Stereo mini camera. Always specify the pylon device class identifier for Stereo mini cameras to prevent CreateFirstDevice() from creating a camera object for a different type of camera:

// Open first available Stereo mini camera
Pylon::CStereoMiniInstantCamera camera(
        Pylon::CTlFactory::GetInstance().CreateFirstDevice(
                Pylon::CDeviceInfo().SetDeviceClass(Pylon::BaslerGenTlStmDeviceClass)));

std::cout << "Using device: " << camera.GetDeviceInfo().GetFriendlyName() << std::endl;

camera.Open();

Acquiring Data#

Refer to the Grabbing Images section of the pylon C++ Programmer's Guide to get familiar with how to acquire data using the pylon API.

pylon represents grabbed images as data structures called GrabResults. GrabResults acquired by a Stereo ace camera contain multiple components. By default, each GrabResult stores an intensity image, a depth map, and additional information.

// Enable intensity image by enabling the Intensity component
camera.ComponentSelector.FromString("Intensity");
camera.ComponentEnable.SetValue(true);

Grabbing Images#

pylon supports different approaches for setting up a grab loop and provides different strategies for handling memory buffers.

Refer to the Grabbing Images section of the pylon C++ Programmer's Guide for more details.

The following code snippet illustrates a typical grab loop using the CStereoMiniInstantCamera class:

camera.StartGrabbing();

Pylon::CGrabResultPtr ptrGrabResult;
camera.RetrieveResult(5000, ptrGrabResult, Pylon::TimeoutHandling_ThrowException);

if (ptrGrabResult->GrabSucceeded())
{
        const auto intensity = ptrGrabResult->GetDataComponent(Pylon::EComponentType::ComponentType_Intensity);
        const auto range = ptrGrabResult->GetDataComponent(Pylon::EComponentType::ComponentType_Range);
        // Process components
}

Accessing Components#

To access the individual components of a GrabResult, you can use the Pylon::CPylonDataContainer and Pylon::CPylonDataComponent classes. A container can hold one or more components. You can use the container to query for the number of components and to retrieve a specific component. Each component in the container holds the actual data, e.g., the depth values, as well as its metadata.

Use the Pylon::CGrabResultData::GetDataContainer() method to get access to a GrabResult's CPylonDataContainer. Use the Pylon::CPylonDataContainer::GetDataComponent() method to access a component by specifying the index of the component.

Refer to the Multi-Component Grab Results section in the the Advanced Topics chapter of the pylon C++ Programmer's Guide for more information about how pylon provides access to GrabResults containing multiple components.

Accessing Depth Data#

Stereo mini cameras provide depth data through the Range component. Depending on the selected pixel format, range data is available as:

• Coord3D_C16 for 16-bit depth values
• Coord3D_ABC32f for direct 3D coordinates (X, Y, Z floats)

camera.ComponentSelector.FromString("Range");
camera.PixelFormat.FromString("Coord3D_C16");

Using the pylon API#

For more detailed information about using the pylon C++ API with Stereo mini cameras, refer to the pylon C++ Programmer's Guide.