calling pointcloud.get_value frequently leaks memory

[thomaswester]

I am seeing a slow but noticeable increase in memory that I have tracked down to calling get_value on a pointcloud.

I can reproduce this with the depth_sensing tutorial provided as part of the sdk (see below). In this example I call get_value on a point cloud 5000 times to demonstrate the leak.

I am running Windows 10 with CUDA 10, SDK 2.7.1 on Geforce RTX 2080 with the latest pyzed

Please advise if there is a different / better way to retrieve volumetric points from the camera.

In my case I need to retrieve about 500 coordinates for each frame, this is part of an installation that runs 14 hours a day on otherwise memory constricted machine.

import pyzed.camera as zcam
import pyzed.defines as sl
import pyzed.types as tp
import pyzed.core as core
import math
import numpy as np
import sys

def main():
    # Create a PyZEDCamera object
    zed = zcam.PyZEDCamera()

    # Create a PyInitParameters object and set configuration parameters
    init_params = zcam.PyInitParameters()
    init_params.depth_mode = sl.PyDEPTH_MODE.PyDEPTH_MODE_PERFORMANCE  # Use PERFORMANCE depth mode
    init_params.coordinate_units = sl.PyUNIT.PyUNIT_MILLIMETER  # Use milliliter units (for depth measurements)

    # Open the camera
    err = zed.open(init_params)
    if err != tp.PyERROR_CODE.PySUCCESS:
        exit(1)

    # Create and set PyRuntimeParameters after opening the camera
    runtime_parameters = zcam.PyRuntimeParameters()
    runtime_parameters.sensing_mode = sl.PySENSING_MODE.PySENSING_MODE_STANDARD  # Use STANDARD sensing mode

    # Capture 50 images and depth, then stop
    i = 0
    image = core.PyMat()
    depth = core.PyMat()
    point_cloud = core.PyMat()

    #stress to highlight memory leak
    while True:
        # A new image is available if grab() returns PySUCCESS
        if zed.grab(runtime_parameters) == tp.PyERROR_CODE.PySUCCESS:
            # Retrieve left image
            zed.retrieve_image(image, sl.PyVIEW.PyVIEW_LEFT)
            # Retrieve depth map. Depth is aligned on the left image
            zed.retrieve_measure(depth, sl.PyMEASURE.PyMEASURE_DEPTH)
            # Retrieve colored point cloud. Point cloud is aligned on the left image.
            zed.retrieve_measure(point_cloud, sl.PyMEASURE.PyMEASURE_XYZRGBA)

            # Get and print distance value in mm at the center of the image
            # We measure the distance camera - object using Euclidean distance
            x = round(image.get_width() / 2)
            y = round(image.get_height() / 2)
            
            #stress to highlight memory leak
            for i in range(5000):
                err, point_cloud_value = point_cloud.get_value(x, y)

                distance = math.sqrt(point_cloud_value[0] * point_cloud_value[0] +
                                     point_cloud_value[1] * point_cloud_value[1] +
                                     point_cloud_value[2] * point_cloud_value[2])

                if not np.isnan(distance) and not np.isinf(distance):
                    distance = round(distance)
                    print("Distance to Camera at ({0}, {1}): {2} mm\n".format(x, y, distance))
                    # Increment the loop
                    i = i + 1
                else:
                    print("Can't estimate distance at this position, move the camera\n")
            sys.stdout.flush()

    # Close the camera
    zed.close()

if __name__ == "__main__":
    main()

[adujardin]

Hi,
There was indeed a leak in get_value. It has been fixed. Thanks for reporting the issue!

The get_value function is a valid way to retrieve a few values but is quite costly. An alternative would be to read the value using a numpy array for instance. Like this :

np_cloud=point_cloud.get_data()
value=np_cloud[x,y]
distance = math.sqrt(value[0] * value[0] + value[1] * value[1] + value[2] * value[2])

Of course, the numpy array conversion has a cost (but support range operation... and is more flexible)

Here is a sample "benchmarking" it :

import pyzed.camera as zcam
import pyzed.defines as sl
import pyzed.types as tp
import pyzed.core as core
import math
import numpy as np
import sys
import time

def main():

    zed = zcam.PyZEDCamera()
    init_params = zcam.PyInitParameters()
    runtime_parameters = zcam.PyRuntimeParameters()
    point_cloud = core.PyMat()

    err = zed.open(init_params)
    if err != tp.PyERROR_CODE.PySUCCESS:
        exit(1)

    while True:
        if zed.grab(runtime_parameters) == tp.PyERROR_CODE.PySUCCESS:
            zed.retrieve_measure(point_cloud, sl.PyMEASURE.PyMEASURE_XYZRGBA)
            x = round(point_cloud.get_width() / 2)
            y = round(point_cloud.get_height() / 2)
            
            start = time.time()
            np_cloud=point_cloud.get_data()
            end = time.time()
            print("Numpy conversion %f ms" % ((end - start)*1000))

            start = time.time()
            value=np_cloud[x,y]
            end = time.time()
            print("Numpy get_value %f ms" % ((end - start)*1000))

            start = time.time()
            err, point_cloud_value = point_cloud.get_value(x, y)
            end = time.time()
            print("PyMat get_value %f ms" % ((end - start)*1000))
            print("\n")

    zed.close()

if __name__ == "__main__":
    main()