r5.2.0 (#739)

Co-authored-by: Julien Delclos <julien.delclos@stereolabs.com>

Author: JujuDel

CMakeLists.txt

@@ -44,7 +44,15 @@ if(${BUILD_CPP})
     add_subdirectory("camera streaming/receiver/${TYPE}")
     add_subdirectory("camera streaming/single_sender/${TYPE}")
     add_subdirectory("camera streaming/multi_sender/${TYPE}")
-    add_subdirectory("zed one/${TYPE}")	
+    add_subdirectory("zed one/live/${TYPE}")
+    add_subdirectory("zed one/svo_playback/${TYPE}")
+    add_subdirectory("zed one/svo_recording/${TYPE}")
+    add_subdirectory("zed one/svo_external_data/${TYPE}")
+    add_subdirectory("zed one/streaming_sender/${TYPE}")
+    add_subdirectory("zed one/streaming_receiver/${TYPE}")
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+        add_subdirectory("zed one/custom_inference/${TYPE}")
+    endif()
     add_subdirectory("virtual stereo/${TYPE}")
 endif()
 

camera streaming/multi_sender/python/streaming_senders.py

@@ -67,17 +67,21 @@ def open_camera(zed, sn, port, camera_fps=30):
     if isinstance(zed, sl.Camera):
         init_params = sl.InitParameters()
         init_params.depth_mode = sl.DEPTH_MODE.NONE  # No depth mode for this example
+        init_params.camera_resolution = sl.RESOLUTION.AUTO
+        init_params.set_from_serial_number(sn)
+        init_params.camera_fps = camera_fps
+        open_err = zed.open(init_params)
     elif isinstance(zed, sl.CameraOne):
-        init_params = sl.InitParametersOne()
+        init_params_one = sl.InitParametersOne()
+        init_params_one.camera_resolution = sl.RESOLUTION.AUTO
+        init_params_one.set_from_serial_number(sn)
+        init_params_one.camera_fps = camera_fps
+        open_err = zed.open(init_params_one)
     else:
         print(f"Unsupported camera type: {type(zed)}")
         return False
-    init_params.camera_resolution = sl.RESOLUTION.AUTO
-    init_params.set_from_serial_number(sn)
-    init_params.camera_fps = camera_fps
 
     # Open the camera
-    open_err = zed.open(init_params)
     if open_err <= sl.ERROR_CODE.SUCCESS:
         print(f"{zed.get_camera_information().camera_model}_SN{sn} Opened")
     else:

depth sensing/automatic region of interest/python/automatic_region_of_interest.py

@@ -104,7 +104,7 @@ def main(opt):
 
     roi_running = False
     roi_param = sl.RegionOfInterestParameters()
-    roi_param.auto_apply_module = [sl.MODULE.ALL]
+    roi_param.auto_apply_module = {sl.MODULE.ALL}
     roi_param.depth_far_threshold_meters = 2.5
     roi_param.image_height_ratio_cutoff = 0.5
     zed.start_region_of_interest_auto_detection(roi_param)
@@ -150,8 +150,9 @@ def main(opt):
         elif key == ord('l'):
             # Load the mask from a previously saved file
             tmp = cv2.imread(mask_name, cv2.IMREAD_GRAYSCALE)
-            if tmp is not None and not tmp.empty():
-                slROI = sl.Mat(sl.Resolution(tmp.cols, tmp.rows), sl.MAT_TYPE.U8_C1, tmp.data, tmp.step)
+            if tmp is not None and tmp.size > 0:
+                rows, cols = tmp.shape[:2]
+                slROI = sl.Mat(sl.Resolution(cols, rows), sl.MAT_TYPE.U8_C1, tmp.data, tmp.strides[0])
                 zed.set_region_of_interest(slROI)
             print(mask_name, "could not be found")
 

depth sensing/depth sensing/cpp/src/main.cpp

@@ -42,7 +42,6 @@ int main(int argc, char** argv) {
     init_parameters.depth_mode = DEPTH_MODE::NEURAL;
     init_parameters.coordinate_system = COORDINATE_SYSTEM::RIGHT_HANDED_Y_UP; // OpenGL's coordinate system is right_handed
     init_parameters.sdk_verbose = 1;
-    init_parameters.maximum_working_resolution = sl::Resolution(0, 0);
     auto mask_path = parseArgs(argc, argv, init_parameters);
 
     // Open the camera
@@ -64,12 +63,9 @@ int main(int argc, char** argv) {
 
     auto camera_config = zed.getCameraInformation().camera_configuration;
     // Automatically set to the optimal resolution
-    sl::Resolution res(-1, -1);
+    sl::Resolution res = zed.getRetrieveMeasureResolution();
 
     Mat point_cloud;
-    zed.retrieveMeasure(point_cloud, MEASURE::XYZRGBA, MEM::GPU, res);
-    res = point_cloud.getResolution();
-
     auto stream = zed.getCUDAStream();
 
     // Point cloud viewer

global localization/live/python/live.py

@@ -97,6 +97,7 @@ def main():
         # Get GNSS data:
         status, input_gnss = gnss_reader.grab()
         if status == sl.ERROR_CODE.SUCCESS:
+            assert input_gnss is not None
             # Display it on the Live Server
             viewer.updateRawGeoPoseData(input_gnss)
 

global localization/playback/python/gnss_replay.py

@@ -247,8 +247,8 @@ def getGNSSData(self, gnss_data, gnss_idx):
             elif gpsd_status == 9:  # STATUS_PPS_FIX
                 sl_status = sl.GNSS_STATUS.SINGLE
 
-            current_gnss_data.gnss_mode = sl_mode.value
-            current_gnss_data.gnss_status = sl_status.value
+            current_gnss_data.gnss_mode = sl_mode
+            current_gnss_data.gnss_status = sl_status
 
         return current_gnss_data
 

global localization/playback/python/playback.py

@@ -119,6 +119,7 @@ def main(opt):
             exit()
         status, input_gnss = gnss_replay.grab(zed_pose.timestamp.get_nanoseconds())
         if status == sl.FUSION_ERROR_CODE.SUCCESS:
+            assert input_gnss is not None
             ingest_error = fusion.ingest_gnss_data(input_gnss)
             latitude, longitude, altitude = input_gnss.get_coordinates(False)
             coordinates = {

global localization/recording/cpp/src/main.cpp

@@ -52,7 +52,7 @@ int main(int argc, char** argv) {
     // Enable SVO recording:
     std::string svo_path = "ZED_SN" + std::to_string(zed.getCameraInformation().serial_number) + "_" + getCurrentDatetime() + ".svo";
     sl::String path_output(svo_path.c_str());
-    auto returned_state = zed.enableRecording(sl::RecordingParameters(path_output, sl::SVO_COMPRESSION_MODE::H264_LOSSLESS));
+    auto returned_state = zed.enableRecording(sl::RecordingParameters(path_output, sl::SVO_COMPRESSION_MODE::H265_LOSSLESS));
     if (returned_state != sl::ERROR_CODE::SUCCESS) {
         std::cerr << "Recording ZED : " << returned_state << std::endl;
         zed.close();

global localization/recording/python/recording.py

@@ -60,7 +60,7 @@ def main():
 
     #Enable SVO recording :
     svo_path = "ZED_SN"+str(zed.get_camera_information().serial_number)+"_"+get_current_datetime()+".svo"
-    returned_state = zed.enable_recording(sl.RecordingParameters(svo_path,sl.SVO_COMPRESSION_MODE.H264_LOSSLESS))
+    returned_state = zed.enable_recording(sl.RecordingParameters(svo_path,sl.SVO_COMPRESSION_MODE.H265_LOSSLESS))
     if returned_state != sl.ERROR_CODE.SUCCESS:
         print("Recording ZED : "+repr(status)+". Exit program.")
         zed.close()
@@ -117,6 +117,7 @@ def main():
         # Get GNSS data:
         status, input_gnss = gnss_reader.grab()
         if status == sl.ERROR_CODE.SUCCESS:
+            assert input_gnss is not None
             # Display it on the Live Server
             viewer.updateRawGeoPoseData(input_gnss)
 

object detection/birds eye viewer/cpp/src/main.cpp

@@ -101,11 +101,14 @@ int main(int argc, char** argv) {
     // default detection threshold, apply to all object class
     int detection_confidence = 60;
     ObjectDetectionRuntimeParameters detection_parameters_rt(detection_confidence);
+    detection_parameters_rt.object_tracking_parameters.velocity_smoothing_factor = 0.5f; // Object tracking global setting
     // To select a set of specific object classes:
     detection_parameters_rt.object_class_filter = {OBJECT_CLASS::VEHICLE, OBJECT_CLASS::PERSON};
     // To set a specific threshold
     detection_parameters_rt.object_class_detection_confidence_threshold[OBJECT_CLASS::PERSON] = detection_confidence;
     detection_parameters_rt.object_class_detection_confidence_threshold[OBJECT_CLASS::VEHICLE] = detection_confidence;
+    detection_parameters_rt.object_class_tracking_parameters[OBJECT_CLASS::VEHICLE].velocity_smoothing_factor
+        = 0.7; // Will override global setting for vehicles
 
     // Detection output
     bool quit = false;