Toute interface graphique Python rapide pour afficher des images en direct de la caméra

Question

J'essaie d'afficher des images en direct de mon appareil photo 1394. Actuellement, mon code est capable d'obtenir des images dans une boucle à partir de la caméra et je cherchais une interface graphique rapide qui se mettra à jour dynamiquement (comme un fil séparé). Je peux le faire dans PyQt peut-être en utilisant QThreads mais y a-t-il une recommandation ou une façon plus rapide de le faire? Voici mon code

#loop Capture d'images de la caméra

for frame in range(1,500): 

print 'frame:',frame 

TIME.sleep(1) #capture frame every second 

image_binary = pycam.cam.RetrieveBuffer() 

#convert to PIL Image 

pilimg = PIL.Image.frombuffer("L",(cimg.GetCols(),cimg.GetRows()),image_binary,'raw', "RGBA", 0, 1) 
    # At this point I want to send my image data to a GUI window and display it 

Remerciement.

Answer 1

est ici le code wxPython qui le fera ...

import wx 
from PIL import Image 

SIZE = (640, 480) 

def get_image(): 
    # Put your code here to return a PIL image from the camera. 
    return Image.new('L', SIZE) 

def pil_to_wx(image): 
    width, height = image.size 
    buffer = image.convert('RGB').tostring() 
    bitmap = wx.BitmapFromBuffer(width, height, buffer) 
    return bitmap 

class Panel(wx.Panel): 
    def __init__(self, parent): 
     super(Panel, self).__init__(parent, -1) 
     self.SetSize(SIZE) 
     self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) 
     self.Bind(wx.EVT_PAINT, self.on_paint) 
     self.update() 
    def update(self): 
     self.Refresh() 
     self.Update() 
     wx.CallLater(15, self.update) 
    def create_bitmap(self): 
     image = get_image() 
     bitmap = pil_to_wx(image) 
     return bitmap 
    def on_paint(self, event): 
     bitmap = self.create_bitmap() 
     dc = wx.AutoBufferedPaintDC(self) 
     dc.DrawBitmap(bitmap, 0, 0) 

class Frame(wx.Frame): 
    def __init__(self): 
     style = wx.DEFAULT_FRAME_STYLE & ~wx.RESIZE_BORDER & ~wx.MAXIMIZE_BOX 
     super(Frame, self).__init__(None, -1, 'Camera Viewer', style=style) 
     panel = Panel(self) 
     self.Fit() 

def main(): 
    app = wx.PySimpleApp() 
    frame = Frame() 
    frame.Center() 
    frame.Show() 
    app.MainLoop() 

if __name__ == '__main__': 
    main() 

Answer 2

Essayez de jeter un coup d'œil à gstreamer. This est le premier résultat que google m'a donné à la recherche de "gstreamer 1394" et this one est le premier pour "gstreamer pyqt".

Answer 3

Je recommande d'utiliser Tkinter car il fait déjà partie de python. Je n'ai jamais utilisé PIL mais un rapide google montre qu'il est facile d'utiliser les images PIL dans les widgets Tk (via la méthode pil.ImageTk.PhotoImage()).

Si vous avez déjà un widget Tkinter configuré pour afficher des images (un widget Étiquette fonctionne correctement), tout ce que vous devez faire est d'organiser la mise à jour de l'image toutes les secondes. Vous pouvez le faire en utilisant la commande after de tkinter.

Voici un exemple; Je n'ai pas PIL il utilise une image statique mais il illustre comment utiliser la boucle d'événement pour aller chercher des images chaque seconde:

import Tkinter 

class App(Tkinter.Tk): 
    def __init__(self): 
     Tkinter.Tk.__init__(self) 
     self.label = Tkinter.Label(text="your image here", compound="top") 
     self.label.pack(side="top", padx=8, pady=8) 
     self.iteration=0 
     self.UpdateImage(1000) 

    def UpdateImage(self, delay, event=None): 
     # this is merely so the display changes even though the image doesn't 
     self.iteration += 1 

     self.image = self.get_image() 
     self.label.configure(image=self.image, text="Iteration %s" % self.iteration) 
     # reschedule to run again in 1 second 
     self.after(delay, self.UpdateImage, 1000) 

    def get_image(self): 
     # this is where you get your image and convert it to 
     # a Tk PhotoImage. For demonstration purposes I'll 
     # just return a static image 
     data = ''' 
      R0lGODlhIAAgALMAAAAAAAAAgHCAkC6LV76+vvXeswD/ANzc3DLNMubm+v/6zS9PT6Ai8P8A//// 
      /////yH5BAEAAAkALAAAAAAgACAAAAS00MlJq7046803AF3ofAYYfh8GIEvpoUZcmtOKAO5rLMva 
      0rYVKqX5IEq3XDAZo1GGiOhw5rtJc09cVGo7orYwYtYo3d4+DBxJWuSCAQ30+vNTGcxnOIARj3eT 
      YhJDQ3woDGl7foNiKBV7aYeEkHEignKFkk4ciYaImJqbkZ+PjZUjaJOElKanqJyRrJyZgSKkokOs 
      NYa2q7mcirC5I5FofsK6hcHHgsSgx4a9yzXK0rrV19gRADs= 
     ''' 
     image = Tkinter.PhotoImage(data=data) 
     return image 

if __name__ == "__main__": 
    app=App() 
    app.mainloop() 

Answer 4

Je pensais que je vais essayer PyQt4 exemple imageviewer.py et cela a fonctionné pour moi . Merci pour votre aide les gars. Voici mon code modifié:

from PyQt4 import QtCore, QtGui 
class CameraViewer(QtGui.QMainWindow): 
    def __init__(self): 
    super(CameraViewer, self).__init__() 

    self.imageLabel = QtGui.QLabel() 
    self.imageLabel.setBackgroundRole(QtGui.QPalette.Base) 
    self.imageLabel.setScaledContents(True) 

    self.scrollArea = QtGui.QScrollArea() 
    self.scrollArea.setWidget(self.imageLabel) 
    self.setCentralWidget(self.scrollArea) 

    self.setWindowTitle("Image Viewer") 
    self.resize(640, 480) 

    timer = QtCore.QTimer(self) 
    timer.timeout.connect(self.open) 
    timer.start(33) #30 Hz 

    def open(self): 
    #get data and display 
    pilimg = getMyPILImageDatFromCamera() 
    image = PILQT.ImageQt.ImageQt(pilimg) 
    if image.isNull(): 
     QtGui.QMessageBox.information(self, "Image Viewer","Cannot load %s." % fileName) 
     return 

    self.imageLabel.setPixmap(QtGui.QPixmap.fromImage(image)) 
    self.imageLabel.adjustSize() 


if __name__ == '__main__': 

    import sys 

    app = QtGui.QApplication(sys.argv) 
    CameraViewer = CameraViewer() 
    CameraViewer.show() 
    sys.exit(app.exec_())