Develop Reference

How can I preview streaming images in tkinter with Allied Vision camera that uses Vimba SDK?

I want to display images from an Allied Vision camera inside a tkinter frame using OpenCV and the SDK for the camera, VimbaPython.
The only possible way to initialize the camera is with a Python with statement:
with Vimba.get_instance() as vimba:
cams = vimba.get_all_cameras()
with cams[0] as camera:
camera.get_frame()
# Convert frame to opencv image, then use Image.fromarray and ImageTk.PhotoImage to
# display it on the tkinter GUI
Everything works fine so far. But I don't only need a single frame. Instead, I need to continuously get frames and display them on the screen so that it is streaming.
I found that one way to do it is to call the .after(delay, function) method from a tkinter Label widget.
So, after obtaining one frame, I want to call the same function to get a new frame and display it again. The code would look like that:
with Vimba.get_instance() as vimba:
cams = vimba.get_all_cameras()
with cams[0] as camera:
def show_frame():
frame = camera.get_frame()
frame = frame.as_opencv_image()
im = Image.fromarray(frame)
img = Image.PhotoImage(im)
lblVideo.configure(image=img) # this is the Tkinter Label Widget
lblVideo.image = img
show_frame()
lblVideo.after(20, show_frame)
Then this shows the first frame and stops, throwing an error saying that Vimba needs to be initialized with a with statement. I don't know much about Python, but it looks like when I call the function with the .after() method it ends the with statement.
I would like to know if it is possible to execute this show_frame() function without ending the with. Also, I can't initialize the camera every time because the program goes really slow.
Thank you

I know this question is pretty old, but I ran into a similar problem with the Allied Vision cameras and found the solution to be relatively robust. So I hope this helps someone, even if not the OP.
An alternative to using with statements is using __enter__ and __exit__ (see sample here). With this, I created a class for the Vimba camera and during the __init__ I used these functions twice: once to initialize the Vimba instance, and once to open the camera itself. An example as follows...
vimba_handle = Vimba.get_instance().__enter__()
camera = vimba_handle.get_all_cameras()[0].__enter__()
I'll include a longer snippet as code as well, but please note my purpose was slightly different the OP's intent. Hopefully, it is still useful.
class VimbaCam:
def __init__(self, device_id=0):
# Variables
self.current_frame = np.array([])
self.device = None
self.device_id = device_id
self.vimba_handle = Vimba.get_instance().__enter__()
self.is_streaming = False
self.scale_window = 4
self.stream_thread = threading.Thread(target=self.thread_stream, daemon=True)
# Default settings
self.auto_exposure = "Off"
self.auto_gain = "Off"
self.acquisition = "Continuous"
self.exposure_us = 200000
self.fps = 6.763
self.gain = 0
self.gamma = 1
self.open()
def close(self):
if self.device is not None:
if self.is_streaming:
self.stop_stream()
time.sleep(1)
self.device.__exit__(None, None, None)
self.vimba_handle.__exit__(None, None, None)
def open(self):
cams = self.vimba_handle.get_all_cameras()
if not cams:
error_check(151, currentframe())
else:
self.device = cams[self.device_id].__enter__()
self.set_defaults()
self.start_stream()
def start_stream(self):
if self.device is not None:
self.is_streaming = True
self.stream_thread.start()
time.sleep(1)
def thread_stream(self):
while self.is_streaming:
current_frame = self.device.get_frame().as_opencv_image()
h, w, _ = current_frame.shape
self.current_frame = current_frame.reshape((h, w))
self.stream_thread = threading.Thread(target=self.thread_stream, daemon=True)
def stop_stream(self):
if self.device is not None:
self.is_streaming = False
def live_video(self):
if self.device is not None:
window_name = "Allied Vision"
h, w = self.current_frame.shape
w = int(w / self.scale_window)
h = int(h / self.scale_window)
cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
cv2.resizeWindow(window_name, w, h)
while 1:
cv2.imshow(window_name, self.current_frame)
cv2.waitKey(1)
if cv2.getWindowProperty(window_name, cv2.WND_PROP_VISIBLE) < 1:
break
cv2.destroyAllWindows()
def set_defaults(self):
if self.device is not None:
# Exposure time settings
self.device.ExposureAuto.set(self.auto_exposure)
self.device.ExposureTimeAbs.set(self.exposure_us)
# Gain settings
self.device.GainAuto.set(self.auto_gain)
self.device.Gain.set(self.gain)
# Gamma settings
self.device.Gamma.set(self.gamma)
self.device.AcquisitionMode.set(self.acquisition)
self.device.AcquisitionFrameRateAbs.set(self.fps)
# Try to adjust GeV packet size (available for GigE only)
try:
self.device.GVSPAdjustPacketSize.run()
while not self.device.GVSPAdjustPacketSize.is_done():
pass
except (AttributeError, VimbaFeatureError):
pass
# Color formatting (tries mono first, then color)
cv_formats = intersect_pixel_formats(self.device.get_pixel_formats(), OPENCV_PIXEL_FORMATS)
mono_formats = intersect_pixel_formats(cv_formats, MONO_PIXEL_FORMATS)
color_formats = intersect_pixel_formats(cv_formats, COLOR_PIXEL_FORMATS)
if mono_formats:
self.device.set_pixel_format(mono_formats[0])
elif color_formats:
self.device.set_pixel_format(color_formats[0])
if __name__ == "__main__":
dev = VimbaCam()
dev.live_video()
dev.close()

You need to use thread to run the capture code and pass the frames read via queue. Then the main tkinter application reads the queue and show the frames periodically using .after().
Below is an example based on your posted code:
import threading
from queue import SimpleQueue
import tkinter as tk
from PIL import Image, ImageTk
from vimba import Vimba
def camera_streaming(queue):
global is_streaming
is_streaming = True
print("streaming started")
with Vimba.get_instance() as vimba:
with vimba.get_all_cameras()[0] as camera:
while is_streaming:
frame = camera.get_frame()
frame = frame.as_opencv_image()
im = Image.fromarray(frame)
img = ImageTk.PhotoImage(im)
queue.put(img) # put the capture image into queue
print("streaming stopped")
def start_streaming():
start_btn["state"] = "disabled" # disable start button to avoid running the threaded task more than once
stop_btn["state"] = "normal" # enable stop button to allow user to stop the threaded task
show_streaming()
threading.Thread(target=camera_streaming, args=(queue,), daemon=True).start()
def stop_streaming():
global is_streaming, after_id
is_streaming = False # terminate the streaming thread
if after_id:
lblVideo.after_cancel(after_id) # cancel the showing task
after_id = None
stop_btn["state"] = "disabled" # disable stop button
start_btn["state"] = "normal" # enable start button
# periodical task to show frames in queue
def show_streaming():
global after_id
if not queue.empty():
image = queue.get()
lblVideo.config(image=image)
lblVideo.image = image
after_id = lblVideo.after(20, show_streaming)
queue = SimpleQueue() # queue for video frames
after_id = None
root = tk.Tk()
lblVideo = tk.Label(root, image=tk.PhotoImage(), width=640, height=480)
lblVideo.grid(row=0, column=0, columnspan=2)
start_btn = tk.Button(root, text="Start", width=10, command=start_streaming)
start_btn.grid(row=1, column=0)
stop_btn = tk.Button(root, text="Stop", width=10, command=stop_streaming, state="disabled")
stop_btn.grid(row=1, column=1)
root.mainloop()
Note that I don't have the camera and the SDK installed, the above code may not work for you. I just demonstrate how to use thread, queue and .after().
Below is a testing vimba module (saved as vimba.py) I use to simulate VimbaPython module using OpenCV and a webcam:
import cv2
class Frame:
def __init__(self, frame):
self.frame = frame
def as_opencv_image(self):
return self.frame
class Camera:
def __init__(self, cam_id=0):
self.cap = cv2.VideoCapture(cam_id, cv2.CAP_DSHOW)
def __enter__(self):
return self
def __exit__(self, *args):
self.cap.release()
return self
def get_frame(self):
ret, frame = self.cap.read()
if ret:
return Frame(frame)
class Vimba:
_instance = None
#classmethod
def get_instance(self):
if self._instance is None:
self._instance = Vimba()
return self._instance
def __enter__(self):
return self
def __exit__(self, *args):
return self
def get_all_cameras(self):
return (Camera(),)

I tried to read the frames in openCV and display them in tkinter label. I was able to do so using the below code:
import tkinter as tk
import cv2
from PIL import ImageTk, Image
video_path = "SAMPLE/STORED_VIDEO/PATH"
root = tk.Tk()
base_img = Image.open("PATH/TO/DEFAULT/LABLE/IMAGE")
img_obj = ImageTk.PhotoImage(base_img)
lblVideo = tk.Label(root, image=img_obj)
lblVideo.pack()
cap = cv2.VideoCapture(video_path)
if cap.isOpened():
def show_frame():
_, frame = cap.read()
im = Image.fromarray(frame)
img = ImageTk.PhotoImage(im)
lblVideo.configure(image=img)
lblVideo.image = img
lblVideo.after(1, show_frame) # Need to create callback here
show_frame()
root.mainloop()
Although this doesnot contain the with statement, you can try replacing the after() callback inside the show_frame function itself.

OpenCV video playback: image not shown when reopening a video

I ran into a strange problem using Python (3.8.6) Tkinter and OpenCV. I'm trying to play a video in a loop, until another video is selected.
When I open a video the first time, it starts playback normally. When I then open another video (same video or other video), the first video stops, but the image of the second video is not displayed (it seems to play in background). Strangely, it does display the video when the tkinter filedialog shows to open yet another video. But when the dialog is cancelled, the display stops again.
If I manually close the playback ('p') and reopen a video ('o') it works normally.
If the video is finished (without looping) before a new video is opened it also works normally.
import os
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk
import cv2
VIDEO_RATE = int(1000.0/30.0)
class VideoPlayback:
def __init__(self):
self.cv2Video = None
def __del__(self):
if self.cv2Video and self.cv2Video.isOpened():
self.cv2Video.release()
def openVideo(self, src, width=405, height=720):
self.cv2Video = cv2.VideoCapture(src)
if not self.cv2Video.isOpened():
raise ValueError("Unable to open video source", src)
self.resizeDim = (width,height)
def closeVideo(self):
if self.cv2Video:
self.cv2Video.release()
def readVideoFrame(self, retry=5):
if self.cv2Video and self.cv2Video.isOpened():
ret, frame = self.cv2Video.read()
if ret:
return (ret, cv2.cvtColor(cv2.resize(frame, self.resizeDim), cv2.COLOR_BGR2RGB))
else:
if retry:
self.cv2Video.set(cv2.CAP_PROP_POS_FRAMES, 0)
return self.readVideoFrame(retry=retry-1)
else:
return (False, None)
else:
return (False, None)
class MainWindow(tk.Tk):
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
tk.Tk.wm_title(self,"Minimal working example")
self.geometry("1280x740+2+2")
self.attributes("-fullscreen",True)
frTop = tk.Frame(master=self, width=1280, height=720)
frTop.pack(side='top', fill='both', expand=1)
# Playback canvas
self.cnvVideo = tk.Canvas(master=frTop, width=405, height=720)
self.cnvVideoImg = self.cnvVideo.create_image(0,0, anchor='nw')
self.cnvVideo.pack(side='right', fill='both', expand=1)
# Buttons
self.bind("o",self.openVideoPlayback)
self.bind("p",self.closeVideoPlayback)
# reference video playback
self.video = VideoPlayback()
self.afterVideo = None
def openVideoPlayback(self, *args):
# show file dialog
videoSrc = filedialog.askopenfilename(title = 'Open video', filetypes=(("Video files (*.mp4)","*.mp4"),("All files (*.*)","*.*")))
if videoSrc:
# open selected video for playback
self.video.openVideo(videoSrc, width=405, height=720)
# start update loop
self.afterVideo = self.after(VIDEO_RATE, self.updateVideoPlayback)
def updateVideoPlayback(self):
(ret, frame) = self.video.readVideoFrame()
if ret:
image = Image.fromarray(frame)
image = ImageTk.PhotoImage(image, master=self)
self.cnvVideo.itemconfig(self.cnvVideoImg, image=image)
self.cnvVideo.image = image
self.cnvVideo.after(VIDEO_RATE, self.updateVideoPlayback)
else:
print("Stop rescheduling")
def closeVideoPlayback(self, *args):
# stop video playback
if self.video:
self.video.closeVideo()
app = MainWindow()
app.mainloop()
I tried adding self.video.closeVideo() before opening a new video.
I tried adding self.after_cancel(self.afterVideo) before opening a new video.
The code is part of a larger Tkinter interface, but stripped to minimal (non)working example.

How to remove video in apps of Tkinter Python?

I have created an apps to display video by Tkinter and Python. I can play, pause video in app and the problem is now I want to remove the video out of my app. I have tried a lot of solutions but It can not be removed. Code to display video in my app:
def load_vid(path):
global stop
global frame_image
global vlabel
video = imageio.get_reader(path)
frame = 0
stop = Button(tab1, text="Stop",command=stop)
stop.place(x=350,y=370,anchor="e")
for image in video.iter_data():
frame += 1
image_frame = PIL.Image.fromarray(image)
image_frame.thumbnail((500,500))
try:
frame_image = ImageTk.PhotoImage(image_frame)
vlabel = Label(tab1,image=frame_image)
#vlabel.config(image=frame_image)
vlabel.image = frame_image
vlabel.place(x=50, y=210, anchor="w")
if stop == True:
break
except:
sys.exit()
Function to remove the video:
def stop():
global stop
stop = True
print('stop')
vlabel.config(image = "")
I want to remove video out of the main frame of app.
With image, I can remove by using .config(image ="") but now it does not work. Is there any solution? Thanks for helping.

From the looks of it, you are creating a new Label during every frame of your video.
for image in video.iter_data():
...
try:
...
vlabel = Label(tab1,image=frame_image)
vlabel.place(x=50, y=210, anchor="w")
...
except:
...
There would be hundreds of Label stacking on top without knowing, and you are only setting the last created Label image to None.
Perhaps you should start by creating the Label outside of your loop, and only modify the image during your iteration:
def load_vid(path):
...
stop = Button(tab1, text="Stop",command=stop)
stop.place(x=350,y=370,anchor="e")
vlabel = Label(tab1)
vlabel.place(x=50, y=210, anchor="w")
for image in video.iter_data():
...
try:
frame_image = ImageTk.PhotoImage(image_frame)
vlabel.config(image=frame_image)
vlabel.image = frame_image
if stop == True:
break
except:
sys.exit()

webcam recording with python tkinter

I want to record video (not audio) from webcam.
I have put two buttons for start recording & stop recording.
As program starts it pick image from camera & shows on screen.works perfect.
My problem is when i click start recording & after some times stop recording,
only avi file created ,with 0K or 6K size found. No further recording found.
import tkinter
import cv2
import PIL.Image, PIL.ImageTk
stopb = None
class App():
def __init__(self, window, window_title):
self.window = window
self.window.title = window_title
self.ok = False
self.video = cv2.VideoCapture(0)
self.width = self.video.get(cv2.CAP_PROP_FRAME_WIDTH)
self.height = self.video.get(cv2.CAP_PROP_FRAME_HEIGHT)
#create videowriter
self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.out = cv2.VideoWriter('output.avi',self.fourcc,10,(640,480))
# Create a canvas that can fit the above video source size
self.canvas = tkinter.Canvas(window, width=self.width, height=self.height)
self.canvas.pack()
self.opencamera = tkinter.Button(window, text="open camera", command=self.open_camera)
self.opencamera.pack()
self.closecamera = tkinter.Button(window, text="close camera", command=self.close_camera)
self.closecamera.pack()
self.delay = 10
self.update()
# After it is called once, the update method will be automatically called every delay milliseconds
self.window.mainloop()
def update(self):
ret, frame = self.video.read()
if self.ok == 'T':
self.out.write(frame)
if ret:
self.photo = PIL.ImageTk.PhotoImage(image=PIL.Image.fromarray(frame))
self.canvas.create_image(0, 0, image=self.photo, anchor=tkinter.NW)
self.window.after(self.delay, self.update)
def open_camera(self):
self.ok = True
print("camera opened")
print(self.ok)
def close_camera(self):
print("camera closed")
self.ok = False
self.video.release()
self.out.release()
def __del__(self):
if self.video.isOpened():
self.video.release()
self.out.release()
App(tkinter.Tk(), "mywindow")

Your problem is that you're never writing anything to your output, as if self.ok == 'T' will never evaluate to true. You should change it to just if self.ok, the same thing you did with ret.
def update(self):
ret, frame = self.video.read()
if self.ok:
self.out.write(frame)
if ret:
self.photo = PIL.ImageTk.PhotoImage(image=PIL.Image.fromarray(frame))
self.canvas.create_image(0, 0, image=self.photo, anchor=tkinter.NW)
self.window.after(self.delay, self.update)

One more issue I found was- after clicking the close camera button followed by the open camera button, the new recording won't start.
Meaning you will just be able to record the first video captured before clicking the close camera button.
This is because the close camera function releases the video object and output object thus video.read() of the update function won't work.
A quick fix is to create a method of set_camera() which creates the video object. Call this function every time in open camera.
https://replit.com/#AmitYadav4/video-record-in-tkinker-canvas

How do I stop my gif from freezing in tkinter?

I'm trying to use Python 2.7 and Tkinker to play a gif on loop. It is to be run on a raspberry pi, but my implementation is lagging even on my more powerful Macbook pro. Here is an example of how it's implemented:
frames= [] #holds gif images
weatherIND = 0 #frame of gif currently being displayed
#processes and initializes gif, then starts the loop
def getWeather()
global frames
frames= []
self.processImage("assets/Rain.gif")
print("frames len = " + str(len(frames)))
Photo = frames[0] #initialize
self.iconLbl.config(image=Photo)
self.iconLbl.image = Photo
self.after(0, self.update) #start the loop
#displays the next frame of the gif every 20 ms
def update(self):
global weatherInd
global frames
if weatherInd == (len(frames)):
weatherInd = 0
Photo = frames[weatherInd]
self.iconLbl.config(image=Photo)
self.iconLbl.image = Photo
weatherInd+=1
self.after(20, self.update)
#takes a gif and puts each frame in a list as a PhotoImage object
def processImage(self, path):
'''
Iterate the GIF, extracting each frame.
'''
global frames
mode = 'global'
im = Image.open(path)
i = 0
p = im.getpalette()
last_frame = im.convert('RGBA')
try:
while True:
print "saving %s (%s) frame %d, %s %s" % (path, mode, i, im.size, im.tile)
'''
If the GIF uses local colour tables, each frame will have its own palette.
If not, we need to apply the global palette to the new frame.
'''
if not im.getpalette():
im.putpalette(p)
new_frame = Image.new('RGBA', im.size)
'''
Is this file a "partial"-mode GIF where frames update a region of a different size to the entire image?
If so, we need to construct the new frame by pasting it on top of the preceding frames.
'''
if mode == 'partial':
new_frame.paste(last_frame)
new_frame.paste(im, (0,0), im.convert('RGBA'))
new_frame = new_frame.resize((100,100), Image.ANTIALIAS)
Photo = ImageTk.PhotoImage(new_frame)
frames.append(Photo)
i += 1
last_frame = new_frame
im.seek(im.tell() + 1)
except EOFError:
pass
Now the problem is that when the gif is playing, every 5-10 seconds it will hang on a frame for 1/2-1 second. This would be expected if I were trying to process or resize the gif frame every 20 ms, but I believe I'm just updating the label with a pre-processed image. Is there a more efficient way to do this so tkinter won't lag?