From 6ef01c17a7acd8022a8b72a10f98851251f4e33a Mon Sep 17 00:00:00 2001 From: builder Date: Tue, 10 Feb 2026 15:01:31 +0000 Subject: [PATCH] Samples: Add a new C++ sample and update others Conclude the modifications made to which settings are used to capture in the samples. The new sample is a direct translation for the same script in python. It takes a ZDF file in input and then converts to different selected file formats, or all of the file formats if none is given. There are also options to control colorspace and if you want to use unordered point clouds. --- README.md | 2 + .../MultiCameraCalibration.cpp | 39 ++- .../MultiCameraCalibrationFromZDF.cpp | 5 +- .../StitchByTransformation.cpp | 50 +++- .../FileFormats/ConvertZDF/ConvertZDF.cpp | 282 ++++++++++++++++++ source/Applications/PointCloudTutorial.md | 6 +- source/CMakeLists.txt | 130 ++++---- 7 files changed, 417 insertions(+), 97 deletions(-) create mode 100644 source/Applications/Basic/FileFormats/ConvertZDF/ConvertZDF.cpp diff --git a/README.md b/README.md index e5d5e6d0..fde6fc89 100644 --- a/README.md +++ b/README.md @@ -106,6 +106,8 @@ from the camera can be used. - [ProjectImageStartAndStop](https://github.com/zivid/zivid-cpp-samples/tree/master/source/Applications/Basic/Visualization/ProjectImageStartAndStop/ProjectImageStartAndStop.cpp) - Start the Image Projection and Stop it. - [ReadPCLVis3D](https://github.com/zivid/zivid-cpp-samples/tree/master/source/Applications/Basic/Visualization/ReadPCLVis3D/ReadPCLVis3D.cpp) - Read point cloud from PCL file and visualize it. - **FileFormats** + - [ConvertZDF](https://github.com/zivid/zivid-cpp-samples/tree/master/source/Applications/Basic/FileFormats/ConvertZDF/ConvertZDF.cpp) - Convert point cloud data from a ZDF file to your + preferred format - [ReadIterateZDF](https://github.com/zivid/zivid-cpp-samples/tree/master/source/Applications/Basic/FileFormats/ReadIterateZDF/ReadIterateZDF.cpp) - Read point cloud data from a ZDF file, iterate through it, and extract individual points. - **Advanced** diff --git a/source/Applications/Advanced/MultiCamera/MultiCameraCalibration/MultiCameraCalibration.cpp b/source/Applications/Advanced/MultiCamera/MultiCameraCalibration/MultiCameraCalibration.cpp index 4a74fe88..436a7aeb 100644 --- a/source/Applications/Advanced/MultiCamera/MultiCameraCalibration/MultiCameraCalibration.cpp +++ b/source/Applications/Advanced/MultiCamera/MultiCameraCalibration/MultiCameraCalibration.cpp @@ -43,7 +43,9 @@ namespace }; // Detect checkerboard feature points from each camera capture - std::vector getDetections(const std::vector &connectedCameras) + std::vector getDetections( + const std::vector &connectedCameras, + const std::string &settingsPath) { auto detectionsList = std::vector(); @@ -51,6 +53,15 @@ namespace { const auto serial = camera.info().serialNumber().toString(); std::cout << "Capturing frame with camera: " << serial << std::endl; + if(settingsPath.empty()) + { + const auto frame = Zivid::Calibration::captureCalibrationBoard(camera); + } + else + { + const auto settings = Zivid::Settings(settingsPath); + const auto frame = camera.capture2D3D(settings); + } const auto frame = Zivid::Calibration::captureCalibrationBoard(camera); std::cout << "Detecting checkerboard in point cloud" << std::endl; const auto detectionResult = Zivid::Calibration::detectCalibrationBoard(frame); @@ -111,25 +122,31 @@ int main(int argc, char **argv) { try { - Zivid::Application zivid; - + bool showHelp = false; std::string transformationMatricesSavePath; - - clipp::group cli; - cli.push_back( - clipp::values("Path to YAML files", transformationMatricesSavePath) - % "Path where the transformation matrices YAML files will be saved"); - - if(!parse(argc, argv, cli)) + std::string settingsPath; + auto cli = + (clipp::option("-h", "--help").set(showHelp) % "Show help message", + clipp::values("Path to YAML files", transformationMatricesSavePath) + % "Path where the transformation matrices YAML files will be saved", + clipp::option("--settings-path") + & clipp::value("path", settingsPath) % "Path to the camera settings YML file"); + if(!clipp::parse(argc, argv, cli)) { auto fmt = clipp::doc_formatting{}.alternatives_min_split_size(1).surround_labels("\"", "\""); std::cout << "SYNOPSIS:" << std::endl; std::cout << clipp::usage_lines(cli, "MultiCameraCalibration", fmt) << std::endl; std::cout << "OPTIONS:" << std::endl; std::cout << clipp::documentation(cli) << std::endl; + if(showHelp) + { + return EXIT_SUCCESS; + } throw std::runtime_error("No path provided."); } + Zivid::Application zivid; + std::cout << "Finding cameras" << std::endl; auto cameras = zivid.cameras(); std::cout << "Number of cameras found: " << cameras.size() << std::endl; @@ -142,7 +159,7 @@ int main(int argc, char **argv) std::cout << "Number of connected cameras: " << connectedCameras.size() << std::endl; // detect checkerboard feature points from Capture for each camera - const auto detections = getDetections(connectedCameras); + const auto detections = getDetections(connectedCameras, settingsPath); // Perform multi-camera calibration runMultiCameraCalibration(detections, transformationMatricesSavePath); diff --git a/source/Applications/Advanced/MultiCamera/MultiCameraCalibrationFromZDF/MultiCameraCalibrationFromZDF.cpp b/source/Applications/Advanced/MultiCamera/MultiCameraCalibrationFromZDF/MultiCameraCalibrationFromZDF.cpp index 6e17e37f..ab674d83 100644 --- a/source/Applications/Advanced/MultiCamera/MultiCameraCalibrationFromZDF/MultiCameraCalibrationFromZDF.cpp +++ b/source/Applications/Advanced/MultiCamera/MultiCameraCalibrationFromZDF/MultiCameraCalibrationFromZDF.cpp @@ -92,11 +92,9 @@ int main(int argc, char **argv) { try { - Zivid::Application zivid; - + auto zdfFileList = std::vector{}; std::string transformationMatricesSavePath; - auto zdfFileList = std::vector{}; auto cli = (clipp::required("-zdf") & clipp::values("ZDF filenames", zdfFileList) @@ -116,6 +114,7 @@ int main(int argc, char **argv) throw std::runtime_error("No files provided."); } + Zivid::Application zivid; // Read from ZDF and detect checkerboard feature const auto detections = getDetectionsFromZDF(zdfFileList); diff --git a/source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp b/source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp index ebe85684..03a5b455 100644 --- a/source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp +++ b/source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp @@ -24,6 +24,10 @@ namespace using Model = Zivid::CameraInfo::Model::ValueType; switch(camera.info().model().value()) { + // Not using [[fallthrough]] because of clang-tidy bug: https://github.com/llvm/llvm-project/issues/47588 + case Model::zividOnePlusSmall: // intentional fallthrough + case Model::zividOnePlusMedium: // intentional fallthrough + case Model::zividOnePlusLarge: throw std::invalid_argument("Invalid camera model"); case Model::zividTwo: return "Zivid_Two_M70"; case Model::zividTwoL100: return "Zivid_Two_L100"; case Model::zivid2PlusM130: return "Zivid_Two_Plus_M130"; @@ -33,9 +37,6 @@ namespace case Model::zivid2PlusMR60: return "Zivid_Two_Plus_MR60"; case Model::zivid2PlusLR110: return "Zivid_Two_Plus_LR110"; case Model::zivid3XL250: return "Zivid_Three_XL250"; - case Model::zividOnePlusSmall: return "Zivid_One_Plus_Small"; - case Model::zividOnePlusMedium: return "Zivid_One_Plus_Medium"; - case Model::zividOnePlusLarge: return "Zivid_One_Plus_Large"; default: throw std::runtime_error("Unhandled camera model: " + camera.info().model().toString()); } @@ -107,26 +108,39 @@ int main(int argc, char **argv) { try { - Zivid::Application zivid; - + bool showHelp = false; auto transformationMatricesfileList = std::vector{}; std::string stitchedPointCloudFileName; - auto saveStitched = false; - auto cli = (clipp::values("File Names", transformationMatricesfileList) - % "List of YAML files containing the corresponding transformation matrices.", - clipp::required("-o", "--output-file").set(saveStitched) - % "Save the stitched point cloud to a file with this name. (.ply)") - & clipp::value("Output point cloud (PLY) file name", stitchedPointCloudFileName); - - if(!parse(argc, argv, cli)) + std::string settingsPath; + auto cli = + (clipp::option("-h", "--help").set(showHelp) % "Show help message", + clipp::values("File Names", transformationMatricesfileList) + % "List of YAML files containing the corresponding transformation matrices", + clipp::option("-o", "--output-file") + & clipp::value("Output point cloud (PLY) file name", stitchedPointCloudFileName) + % "Save the stitched point cloud to a file with this name (.ply)", + clipp::option("--settings-path") + & clipp::value("path", settingsPath) % "Path to the camera settings YML file"); + + if(!parse(argc, argv, cli) || showHelp) { std::cout << "SYNOPSIS:" << std::endl; std::cout << clipp::usage_lines(cli, "StitchByTransformation") << std::endl; std::cout << "OPTIONS:" << std::endl; std::cout << clipp::documentation(cli) << std::endl; - throw std::runtime_error("No file provided."); + if(showHelp) + { + return EXIT_SUCCESS; + } + + throw std::runtime_error("No path provided."); } + Zivid::Application zivid; + + bool pathNotProvided = settingsPath.empty(); + bool saveStitched = !stitchedPointCloudFileName.empty(); + auto cameras = zivid.cameras(); std::cout << "Number of cameras found: " << cameras.size() << std::endl; @@ -139,8 +153,12 @@ int main(int argc, char **argv) for(auto &camera : connectedCameras) { - const auto settingsPath = std::string(ZIVID_SAMPLE_DATA_DIR) + "/Settings/" + sanitizedModelName(camera) - + "_ManufacturingSpecular.yml"; + if(pathNotProvided) + { + settingsPath = std::string(ZIVID_SAMPLE_DATA_DIR) + "/Settings/" + sanitizedModelName(camera) + + "_ManufacturingSpecular.yml"; + } + std::cout << "Imaging from camera: " << camera.info().serialNumber() << std::endl; const auto frame = camera.capture2D3D(Zivid::Settings(settingsPath)); const auto unorganizedPointCloud = frame.pointCloud().toUnorganizedPointCloud(); diff --git a/source/Applications/Basic/FileFormats/ConvertZDF/ConvertZDF.cpp b/source/Applications/Basic/FileFormats/ConvertZDF/ConvertZDF.cpp new file mode 100644 index 00000000..928214a5 --- /dev/null +++ b/source/Applications/Basic/FileFormats/ConvertZDF/ConvertZDF.cpp @@ -0,0 +1,282 @@ +/* +Convert point cloud data from a ZDF file to your preferred format +If a directory is provided, all ZDF files in the directory will be converted + +Available formats: + PLY, PCD, XYZ, CSV, TXT - 3D point cloud + PNG, JPG, BMP - 2D RGB image +*/ + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace +{ + using ColorSpace = Zivid::Experimental::PointCloudExport::ColorSpace; + using namespace Zivid::Experimental::PointCloudExport::FileFormat; + + std::string toLower(std::string str) + { + std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) { return std::tolower(c); }); + return str; + } + + bool contains(const std::vector &vec, const std::vector &values) + { + return std::all_of(values.begin(), values.end(), [&](const std::string &value) { + return std::find(vec.begin(), vec.end(), toLower(value)) != vec.end(); + }); + } + + template + void writeColorsToFile( + std::ofstream &file, + const Zivid::Array2D &colors, + const Zivid::Array2D &points, + const Zivid::Array2D &snrs, + size_t size) + { + for(size_t i = 0; i < size; ++i) + { + const auto &point = points(i); + const auto &color = colors(i); + const auto &snr = snrs(i); + + if(!point.isNaN()) + { + file << point.x << "," << point.y << "," << point.z << "," << static_cast(color.r) << "," + << static_cast(color.g) << "," << static_cast(color.b) << "," + << static_cast(color.a) << "," << snr.value << "\n"; + } + } + } + + template + void save2DImage( + const ImageType &image2D, + const ImageType &image2DInPointCloudResolution, + const std::filesystem::path &fileName, + const std::filesystem::path &fileNamePointCloudResolution) + { + std::cout << "Saving the frame to " << fileName << " and " << fileNamePointCloudResolution << std::endl; + image2D.save(fileName.string()); + image2DInPointCloudResolution.save(fileNamePointCloudResolution.string()); + } + + void + flattenAndSavePointCloud(const Zivid::PointCloud &pointCloud, const std::filesystem::path &filePath, bool linearRgb) + { + std::ofstream file(filePath); + if(!file.is_open()) + { + throw std::runtime_error("Failed to open file: " + filePath.string()); + } + + file << std::fixed << std::setprecision(3); + + const auto points = pointCloud.copyPointsXYZ(); + const auto snrs = pointCloud.copySNRs(); + + if(linearRgb) + { + const auto colors = pointCloud.copyColorsRGBA(); + writeColorsToFile(file, colors, points, snrs, pointCloud.size()); + } + else + { + const auto colors = pointCloud.copyColorsRGBA_SRGB(); + writeColorsToFile(file, colors, points, snrs, pointCloud.size()); + } + } + + void convertTo3D( + const Zivid::Frame &frame, + const std::filesystem::path &filePath, + const std::vector &fileFormats, + bool linearRgb, + bool unordered) + { + for(const auto &format : fileFormats) + { + const auto fileNameWithExtension = filePath.parent_path() / (filePath.stem().string() + "." + format); + const auto colorSpace = linearRgb ? ColorSpace::linearRGB : ColorSpace::sRGB; + + std::cout << "Saving the frame to " << fileNameWithExtension << std::endl; + + if(format == "ply") + { + const auto layout = unordered ? PLY::Layout::unordered : PLY::Layout::ordered; + Zivid::Experimental::PointCloudExport::exportFrame( + frame, PLY{ fileNameWithExtension.string(), layout, colorSpace }); + } + else if(format == "pcd") + { + if(!unordered) + { + std::cout + << "NOTE: If you have configured the config file for PCD, points will be ordered. " + << "If not they will be unordered. See " + << "https://support.zivid.com/en/latest/reference-articles/point-cloud-structure-and-output-formats.html#organized-pcd-format" + << " for more information." << std::endl; + } + Zivid::Experimental::PointCloudExport::exportFrame( + frame, PCD{ fileNameWithExtension.string(), colorSpace }); + } + else if(format == "xyz") + { + Zivid::Experimental::PointCloudExport::exportFrame( + frame, XYZ{ fileNameWithExtension.string(), colorSpace }); + } + else if(format == "csv" || format == "txt") + { + flattenAndSavePointCloud(frame.pointCloud(), fileNameWithExtension, linearRgb); + } + } + } + + void convertTo2D( + const Zivid::Frame &frame, + const std::filesystem::path &filePath, + const std::vector &fileFormats, + bool linearRgb) + { + for(const auto &format : fileFormats) + { + const auto fileName = filePath.parent_path() / (filePath.stem().string() + "." + format); + const auto fileNamePointCloudResolution = + filePath.parent_path() / (filePath.stem().string() + "_point_cloud_resolution." + format); + + if(linearRgb) + { + save2DImage( + frame.frame2D()->imageRGBA(), + frame.pointCloud().copyImageRGBA(), + fileName, + fileNamePointCloudResolution); + } + else + { + save2DImage( + frame.frame2D()->imageRGBA_SRGB(), + frame.pointCloud().copyImageRGBA_SRGB(), + fileName, + fileNamePointCloudResolution); + } + } + } +} // namespace + +int main(int argc, char **argv) +{ + try + { + std::string inputPath; + std::vector formats3DSelected; + std::vector formats2DSelected; + bool convertAll = false; + bool linearRgb = false; + bool unordered = false; + bool showHelp = false; + const std::vector formats3D = { "ply", "pcd", "xyz", "csv", "txt" }; + const std::vector formats2D = { "jpg", "png", "bmp" }; + + auto cli = + (clipp::option("-h", "--help").set(showHelp) % "Show this help message", + clipp::value("path", inputPath) % "File/directory holding ZDF file(s)", + clipp::option("-a", "--all").set(convertAll) % "Convert to all formats (default if no formats specified)", + clipp::option("--3d") + & clipp::values("formats3D", formats3DSelected) + % "3D format(s) to convert to (ply, pcd, xyz, csv, txt)", + clipp::option("--2d") + & clipp::values("formats2D", formats2DSelected) % "2D format(s) to convert to (jpg, png, bmp)", + clipp::option("--linearRGB").set(linearRgb) + % "Use linear RGB color space instead of sRGB for selected format(s)", + clipp::option("--unordered").set(unordered) + % "Save point clouds as unordered instead of ordered (PLY, PCD)"); + + if(!clipp::parse(argc, argv, cli) || showHelp || inputPath.empty() || !contains(formats3D, formats3DSelected) + || !contains(formats2D, formats2DSelected)) + { + auto fmt = clipp::doc_formatting{}.alternatives_min_split_size(1).surround_labels("\"", "\""); + std::cout << "Convert from a ZDF to your preferred format\n\n"; + std::cout << "SYNOPSIS:\n"; + std::cout << clipp::usage_lines(cli, "ConvertZDF", fmt) << "\n\n"; + std::cout << "OPTIONS:\n"; + std::cout << clipp::documentation(cli) << "\n"; + std::cout << "\nExample:\n"; + std::cout << " ConvertZDF Zivid3D.zdf --3d ply xyz csv --2d jpg png\n"; + return showHelp ? EXIT_FAILURE : EXIT_SUCCESS; + } + + const std::filesystem::path path(inputPath); + if(!std::filesystem::exists(path)) + { + throw std::runtime_error(inputPath + " does not exist"); + } + + Zivid::Application zivid; + + std::vector> frames; + + std::cout << "Reading point cloud(s) from: " << inputPath << std::endl; + + if(std::filesystem::is_directory(path)) + { + for(const auto &entry : std::filesystem::directory_iterator(path)) + { + if(entry.path().extension() == ".zdf") + { + frames.emplace_back(Zivid::Frame(entry.path().string()), entry.path()); + } + } + } + else + { + frames.emplace_back(Zivid::Frame(inputPath), path); + } + + if(frames.empty()) + { + throw std::runtime_error(inputPath + " does not contain any ZDF files"); + } + + // If no formats specified or --all is set, convert to all formats + if(convertAll || (formats3DSelected.empty() && formats2DSelected.empty())) + { + formats3DSelected = formats3D; + formats2DSelected = formats2D; + } + + for(const auto &[frame, filePath] : frames) + { + if(!formats3DSelected.empty()) + { + convertTo3D(frame, filePath, formats3DSelected, linearRgb, unordered); + } + + if(!formats2DSelected.empty()) + { + convertTo2D(frame, filePath, formats2DSelected, linearRgb); + } + } + } + catch(const std::exception &e) + { + std::cerr << "Error: " << Zivid::toString(e) << std::endl; + std::cout << "Press enter to exit." << std::endl; + std::cin.get(); + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/source/Applications/PointCloudTutorial.md b/source/Applications/PointCloudTutorial.md index 6c0c0d1b..e04f9aae 100644 --- a/source/Applications/PointCloudTutorial.md +++ b/source/Applications/PointCloudTutorial.md @@ -145,7 +145,7 @@ point cloud. While doing so, all NaN values are removed, and the point cloud is flattened to a 1D array. ([go to -source](https://github.com/zivid/zivid-cpp-samples/tree/master//source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp#L146)) +source](https://github.com/zivid/zivid-cpp-samples/tree/master//source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp#L164)) ``` sourceCode cpp const auto unorganizedPointCloud = frame.pointCloud().toUnorganizedPointCloud(); @@ -289,7 +289,7 @@ that in this sample is is not necessary to create a new instance, as the untransformed point cloud is not used after the transformation. ([go to -source](https://github.com/zivid/zivid-cpp-samples/tree/master//source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp#L148)) +source](https://github.com/zivid/zivid-cpp-samples/tree/master//source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp#L166)) ``` sourceCode cpp const auto transformedUnorganizedPointCloud = unorganizedPointCloud.transformed(transformationMatrix); @@ -389,7 +389,7 @@ minPointsPerVoxel can be used to only fill voxels that both captures "agree" on. ([go to -source](https://github.com/zivid/zivid-cpp-samples/tree/master//source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp#L153)) +source](https://github.com/zivid/zivid-cpp-samples/tree/master//source/Applications/Advanced/MultiCamera/StitchByTransformation/StitchByTransformation.cpp#L171)) ``` sourceCode cpp const auto finalPointCloud = stitchedPointCloud.voxelDownsampled(0.5, 1); diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt index a2223515..ef9cbdc5 100644 --- a/source/CMakeLists.txt +++ b/source/CMakeLists.txt @@ -25,70 +25,70 @@ option(USE_GENTL "Enable samples which depend on GenTL" OFF) option(USE_HALCON "Enable samples which depend on Halcon" OFF) set(SAMPLES + Applications/Basic/Visualization/CaptureAndVisualizeNormals + Applications/Basic/Visualization/CaptureFromFileCameraVis3D + Applications/Basic/Visualization/CaptureVis3D + Applications/Basic/Visualization/CaptureWritePCLVis3D + Applications/Basic/Visualization/ProjectImageStartAndStop + Applications/Basic/Visualization/ReadPCLVis3D + Applications/Basic/FileFormats/ConvertZDF + Applications/Basic/FileFormats/ReadIterateZDF + Applications/Advanced/BarcodeDetector + Applications/Advanced/CaptureUndistort2D + Applications/Advanced/CreateDepthMap + Applications/Advanced/Downsample + Applications/Advanced/GammaCorrection + Applications/Advanced/MaskPointCloud + Applications/Advanced/ProjectAndFindMarker + Applications/Advanced/ReadProjectAndCaptureImage + Applications/Advanced/ReprojectPoints + Applications/Advanced/ROIBoxViaArucoMarker + Applications/Advanced/ROIBoxViaCheckerboard + Applications/Advanced/StitchViaLocalPointCloudRegistration + Applications/Advanced/StitchContinuouslyRotatingObject + Applications/Advanced/StitchUsingRobotMountedCamera + Applications/Advanced/TransformPointCloudViaArucoMarker + Applications/Advanced/TransformPointCloudViaCheckerboard + Applications/Advanced/TransformPointCloudFromMillimetersToMeters + Applications/Advanced/HandEyeCalibration/HandEyeCalibration + Applications/Advanced/HandEyeCalibration/UtilizeHandEyeCalibration + Applications/Advanced/HandEyeCalibration/PoseConversions + Applications/Advanced/MultiCamera/MultiCameraCalibration + Applications/Advanced/MultiCamera/MultiCameraCalibrationFromZDF + Applications/Advanced/MultiCamera/StitchByTransformation + Applications/Advanced/MultiCamera/StitchByTransformationFromZDF Camera/Basic/Capture Camera/Basic/CaptureFromFileCamera Camera/Basic/CaptureWithSettingsFromYML Camera/Basic/CaptureHDRCompleteSettings + Camera/Advanced/AllocateMemoryForPointCloudData Camera/Advanced/Capture2DAnd3D Camera/Advanced/CaptureAndPrintNormals - Camera/Advanced/MultiCameraCaptureSequentially - Camera/Advanced/MultiCameraCaptureSequentiallyWithInterleavedProcessing - Camera/Advanced/MultiCameraCaptureInParallel - Camera/Advanced/AllocateMemoryForPointCloudData Camera/Advanced/CaptureHalconViaGenICam Camera/Advanced/CaptureHalconViaZivid Camera/Advanced/CaptureViaGenICam + Camera/Advanced/MultiCameraCaptureSequentially + Camera/Advanced/MultiCameraCaptureSequentiallyWithInterleavedProcessing + Camera/Advanced/MultiCameraCaptureInParallel Camera/InfoUtilOther/AutomaticNetworkConfigurationForCameras + Camera/InfoUtilOther/CameraInfo Camera/InfoUtilOther/CameraUserData Camera/InfoUtilOther/CaptureWithDiagnostics - Camera/InfoUtilOther/GetCameraIntrinsics Camera/InfoUtilOther/FirmwareUpdater + Camera/InfoUtilOther/FrameInfo + Camera/InfoUtilOther/GetCameraIntrinsics + Camera/InfoUtilOther/MeasureSceneConditions Camera/InfoUtilOther/NetworkConfiguration - Camera/InfoUtilOther/CameraInfo Camera/InfoUtilOther/SettingsInfo - Camera/InfoUtilOther/FrameInfo - Camera/InfoUtilOther/ZividBenchmark Camera/InfoUtilOther/Warmup - Camera/InfoUtilOther/MeasureSceneConditions - Camera/Maintenance/VerifyCameraInField - Camera/Maintenance/VerifyCameraInFieldFromZDF + Camera/InfoUtilOther/ZividBenchmark Camera/Maintenance/CorrectCameraInField Camera/Maintenance/ResetCameraInField - Applications/Basic/Visualization/CaptureFromFileCameraVis3D - Applications/Basic/Visualization/CaptureVis3D - Applications/Basic/Visualization/ReadPCLVis3D - Applications/Basic/Visualization/ProjectImageStartAndStop - Applications/Basic/Visualization/CaptureWritePCLVis3D - Applications/Basic/Visualization/CaptureAndVisualizeNormals - Applications/Basic/FileFormats/ReadIterateZDF - Applications/Advanced/CaptureUndistort2D - Applications/Advanced/Downsample - Applications/Advanced/MaskPointCloud - Applications/Advanced/HandEyeCalibration/HandEyeCalibration - Applications/Advanced/HandEyeCalibration/UtilizeHandEyeCalibration - Applications/Advanced/HandEyeCalibration/PoseConversions - Applications/Advanced/CreateDepthMap - Applications/Advanced/MultiCamera/MultiCameraCalibration - Applications/Advanced/MultiCamera/MultiCameraCalibrationFromZDF - Applications/Advanced/MultiCamera/StitchByTransformation - Applications/Advanced/MultiCamera/StitchByTransformationFromZDF - Applications/Advanced/TransformPointCloudViaArucoMarker - Applications/Advanced/TransformPointCloudViaCheckerboard - Applications/Advanced/TransformPointCloudFromMillimetersToMeters - Applications/Advanced/ROIBoxViaArucoMarker - Applications/Advanced/ROIBoxViaCheckerboard - Applications/Advanced/StitchViaLocalPointCloudRegistration - Applications/Advanced/StitchContinuouslyRotatingObject - Applications/Advanced/StitchUsingRobotMountedCamera - Applications/Advanced/GammaCorrection - Applications/Advanced/ProjectAndFindMarker - Applications/Advanced/ReadProjectAndCaptureImage - Applications/Advanced/ReprojectPoints - Applications/Advanced/BarcodeDetector + Camera/Maintenance/VerifyCameraInField + Camera/Maintenance/VerifyCameraInFieldFromZDF ) set(Eigen3_DEPENDING - UtilizeHandEyeCalibration PoseConversions ROIBoxViaArucoMarker ROIBoxViaCheckerboard @@ -97,63 +97,65 @@ set(Eigen3_DEPENDING StitchViaLocalPointCloudRegistration StitchContinuouslyRotatingObject StitchUsingRobotMountedCamera + UtilizeHandEyeCalibration ) set(PCL_DEPENDING Capture2DAnd3D + CaptureAndVisualizeNormals + CaptureWritePCLVis3D MaskPointCloud ReadPCLVis3D - CaptureWritePCLVis3D - CaptureAndVisualizeNormals ) set(OpenCV_DEPENDING + AllocateMemoryForPointCloudData Capture2DAnd3D CaptureUndistort2D CreateDepthMap - MaskPointCloud - TransformPointCloudViaArucoMarker - TransformPointCloudViaCheckerboard - AllocateMemoryForPointCloudData GammaCorrection + MaskPointCloud ProjectAndFindMarker ReprojectPoints ReadProjectAndCaptureImage + TransformPointCloudViaArucoMarker + TransformPointCloudViaCheckerboard ) set(Visualization_DEPENDING - CaptureVis3D - CaptureLiveVis3D + CreateDepthMap CaptureFromFileCameraVis3D - Downsample - CaptureWritePCLVis3D + CaptureLiveVis3D CaptureUndistort2D - CreateDepthMap + CaptureVis3D + CaptureWritePCLVis3D + Downsample ROIBoxViaArucoMarker ROIBoxViaCheckerboard StitchByTransformation StitchByTransformationFromZDF - StitchViaLocalPointCloudRegistration StitchContinuouslyRotatingObject + StitchViaLocalPointCloudRegistration StitchUsingRobotMountedCamera ) set(Clipp_DEPENDING AutomaticNetworkConfigurationForCameras CameraUserData + Capture2DAnd3D + CaptureFromFileCamera + CaptureFromFileCameraVis3D CaptureViaGenICam CaptureWithSettingsFromYML + CaptureWritePCLVis3D + ConvertZDF + GammaCorrection + HandEyeCalibration + MultiCameraCalibration MultiCameraCalibrationFromZDF + ReadPCLVis3D StitchByTransformation StitchByTransformationFromZDF StitchContinuouslyRotatingObject StitchUsingRobotMountedCamera - MultiCameraCalibration - Capture2DAnd3D - ZividBenchmark - CaptureFromFileCamera - CaptureFromFileCameraVis3D - ReadPCLVis3D - CaptureWritePCLVis3D - GammaCorrection Warmup - HandEyeCalibration + ZividBenchmark ) set(GenTL_DEPENDING CaptureViaGenICam) set(Thread_DEPENDING