NiklasKroeger-AlliedVision
commented
3 years ago Unfortunately I cannot reproduce the error you are getting at the moment. I tried to create a small test from the code you provided and ended up with the following which uses your code to record 10 frames for sample code 1 and 10 frames for sample code 2:
import time
from vimba import *
count = 0
def do_something(frame):
global count
count += 1
print(count)
return count >= 10
# Sample code 1
result = False
while not result:
time.sleep(2) # I have also tried using timestamp
with Vimba.get_instance() as vimba:
cams = vimba.get_all_cameras()
with cams[0] as cam:
frame = cam.get_frame()
raw = frame.as_opencv_image()
result = do_something(raw)
count = 0
# Sample code 2
result = False
with Vimba.get_instance() as vimba:
cams = vimba.get_all_cameras()
while not result:
time.sleep(2)
with cams[0] as cam:
frame = cam.get_frame()
raw = frame.as_opencv_image()
result = do_something(raw)Does running this produce the error on your machine?
Generally speaking the synchronous image acquisition (cam.get_frame()) is not the recommended way to use our cameras. Especially in VimbaPython there is quite some overhead involved that quickly can become problematic if get_frame() is called multiple times in quick succession. The main problem is that synchronous acquisition is implemented in such a way, that every time get_frame() is called the required frame buffers are allocated, announced to the Transport Layer, Queued and then acquisition is started. For asynchronous acquisition this is not done for every frame but only once. This might also be the reason for the memory leak you are seeing:
If I use try and except pass for this error, it will cause memory leak.
What I believe you are noticing is this fresh acquisition for every call to get_frame(). And since python has a garbage collector that frees up memory only from time to time, it looks like the memory use is growing constantly. In fact Python would free that memory eventually as it sees that the frame is no longer needed (assuming in your do_something() function you are not saving all data in some way). So far we were not able to detect any memory leaks from VimbaPython, and with the example code above I see the typical behaviour of "memory increases constantly but after some time some blocks are freed" that is typical for the garbage collector. See this screenshot below where I ran the example above for a couple of hundred frames:
After leaving the process run for about 30 minutes now I would say the memory never jumps above ~480MB because the garbage collector cleans up before that.
Back to your problem:
If you are open for changing your image acquisition procedure (you mention that you already tried to use "the streaming method") I would suggest using asynchronous image acquisition and triggering images via a software trigger. This way you can still control at what point in your code an image should be recorded, but the overhead that comes with synchronous acquisition is eliminated. And since you are only receiving frames very slowly (depending on how often you run the software trigger) the CPU load should also be far lower than what you were experiencing. Here is a small code snippet that showcases how to use asynchronous image acquisition together with software triggering to get you started. If you have further questions or need help integrating this into your existing code feel free to let me know.
import vimba
import time
def frame_callback(cam: vimba.Camera, frame: vimba.Frame):
# Called every time a new frame is received. Perform image analysis here
print('{} acquired {}'.format(cam, frame), flush=True)
# Hand used frame back to Vimba so it can store the next image in this memory
cam.queue_frame(frame)
def setup_software_triggering(cam: vimba.Camera):
# Always set the selector first so that folling features are applied correctly!
cam.TriggerSelector.set('FrameStart')
# optional in this example but good practice as it might be needed for hadware triggering
cam.TriggerActivation.set('RisingEdge')
# Make camera listen to Software trigger
cam.TriggerSource.set('Software')
cam.TriggerMode.set('On')
with vimba.Vimba.get_instance() as vmb:
cams = vmb.get_all_cameras()
with cams[0] as cam:
setup_software_triggering(cam)
try:
# Tell the camera to start streaming. The first frame will be recorded when the software
# trigger is executed
cam.start_streaming(handler=frame_callback)
# example loop to record 10 images and then stop.
for _ in range(10):
cam.TriggerSoftware.run()
time.sleep(2)
finally:
cam.stop_streaming()
print("done")
ColbearChan
frischwood
Hi,
The current situation requires me to perform get_frame() within a loop for every 2 seconds.
However, occasionally, I will get the following error: VmbErrorIncomplete, -19
I have found this error on the Vimba c manual, where it says: VmbErrorIncomplete, -19, A multiple registers read or write was partially incomplete.
If I use try and except pass for this error, it will cause memory leak.
I have tried many ways to use get_frame(), and the error still pops up. Here are two sample codes:
Sample Code 1 (With little memory leak, dropped after jumping out from the loop)
Sample Code 2 (With heavy memory leak, dropped after jumping out from the loop)
I have noticed the timeout parameter in get_frame_generator, however, by increasing from the default value, the problem still occurs.
I have also tried to use the streaming method, which streaming runs by its own thread, and the main program will take the latest frame from the buffer every time (by constantly emptying the built in queue __capture_fsm so I could take the latest frame lol). This method works, however, due to the limited computational power, it took too many of my CPU usage, averaging 98%.
Please let me know if there is a solution or workaround for this problem. Thank you!
PC: Jetson Nano