OpenCV的封裝 for Python programming

CaptureManager類用於獲取輸入：圖像，視頻或者相機

WindowManager類用於顯示圖像與響應鍵盤、鼠標

######################managers.py########################

#definition of two essential classes

import cv2
import numpy
import time

class CaptureManager(object):
    def __init__(self, capture, previewWindowManager = None,
                 shouldMirrorPreview = False):
        self.previewWindowManager = previewWindowManager
        self.shouldMirrorPreview = shouldMirrorPreview
        
        self._capture = capture
        self._channel = 0
        self._enteredFrame = None
        self._frame = None
        self._readimageFilename = None
        self._writeimageFilename = None
        self._videoFilename = None
        self._videoEncoding = None
        self._videoWriter = None
        
        self._startTime = None
        self._framesElapsed = long(0)
        self._fpsEstimate = None
        
    @property
    def channel(self):
        return self._channel
    
    @channel.setter
    def channel(self, value):
        if self._channel != value:
            self._channel = value
            self._frame = None
    #@property        
    def frame(self):
        if self._enteredFrame and self._frame is None:
            flag,self._frame = self._capture.retrieve()
        elif self._readimageFilename is not None:
            self._frame = cv2.imread(self._readimageFilename,cv2.CV_LOAD_IMAGE_GRAYSCALE)
        else:
            self._frame = None
        return self._frame
        
    def isWritingImage(self):
        return self._writeimageFilename is not None
    
    def isReadingImage(self):
        return self._readimageFilename is not None
        
    def isWritingVideo(self):
        return self._videoFilename is not None
    
    def enterFrame(self):
        """Capture the next frame, if any."""
        if self._capture is not None:
            #But first, check the any previous frame was exited.
            assert not self._enteredFrame,'previous enterFrame() had no matching exitFrame()'
            
            if self._capture is not None:
                self._enteredFrame = self._capture.grab()
        else:
            None
            
    def exitFrame(self):
        """Draw to the window. write to files. Release the frame."""
        
        #Check whether any grabbed frame is retrievable.
        #The getter may retrieve and cache the frame
        if self._frame is None:
            self._enteredFrame = False
            return
        
        #Update the FPS estimate and related variables.
        if self._framesElapsed ==0:
            self._startTime = time.time()
        else:
            timeElapsed = time.time() - self._startTime
            self._fpsEstimate = self._framesElapsed/timeElapsed
        self._framesElapsed += 1
        
        #Draw to window, if any
        if self.previewWindowManager is not None:
            #cv2.waitKey(1)
            if self.shouldMirrorPreview:
                mirroredFrame = numpy.fliplr(self._frame).copy()
                self.previewWindowManager.show(mirroredFrame)
            else:
                self.previewWindowManager.show(self._frame)
                       
        #Write to the image file, if any
        if self.isWritingImage():
            cv2.imwrite(self._writeimageFilename, self._frame)
            self._writeimageFilename = None
            
        #Write to the video file, if any
        if self.isWritingVideo():
            self._writeVideoFrame()
        
        #Release the frame.
        self._frame = None
        self._enteredFrame = False
            
    def writeImage(self, filename):
        """Write the next exited frame to an image file"""
        self._writeimageFilename = filename
        
    def readImage(self, filename):
        """Write the next exited frame to an image file"""
        self._readimageFilename = filename
        
    def startWritingVideo(self,filename,\
                          encoding = cv2.cv.CV_FOURCC('I','4','2','0')):
        """Start writing exited frames to a video file """
        self._videoFilename = filename
        self._videoEncoding = encoding
        
    def stopWritingVideo(self):
        """Stop writing exited frames to a video file"""
        self._videoFilename = None
        self._videoEncoding = None
        self._videoWriter = None
        
    def _writerVideoFrame(self):
        
        if not self.isWritingVideo():
            return
        if self._videoWriter is None:
            fps = self._capture.get(cv2.cv.CV_CAP_PROP_FPS)
            if fps == 0.0:
                if self.framesElapsed <20:
                    #wait until more frames elapse so that the
                    #estimat is more stable.
                    return
                else:
                    fps = self._fpsEstimate
            size = (int(self._capture.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)),\
                    int(self._capture.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)))
            self._videoWriter = cv2.VideoWriter(self._videoFilename,self._videoEncoding,fps,size)
            self._videoWriter.write(self._frame)
            
    def _writerImage(self):
        
        if not self.isWritingImage:
            return
        if self._ImageWriter is None:
            cv2.imwrite(self._writeimageFilename,self._frame) 
                             
class WindowManager(object):
    
    def __init__(self,windowName, keypressCallback = None):
        self.keypressCallback = keypressCallback
        self._windowName = windowName
        self._ifWindowCreated = False
        
    def isWindowCreated(self):
        return self._isWindowCreated
    def show(self,frame):
        cv2.imshow(self._windowName,frame)
        
    def createWindow(self):
        cv2.namedWindow(self._windowName)
        self._isWindowCreated = True
        
    def destroyWindow(self):
        cv2.destroyWindow(self._windowName)
        self._isWindowCreated = False
    
    def processEvents(self):
        keycode = cv2.waitKey(1)
        if self.keypressCallback is not None:
            #Discard any non -ASCII info encoded by GTK
            #keycode &= 0xFF
            self.keypressCallback(keycode)
        if keycode != -1:
            print(keycode)

例子1，輸入圖像：

####################cameo1.py#################################

from managersD import WindowManager, CaptureManager

class Cameo(object):
    def __init__(self):
        self._windowManager = WindowManager('Cameo',self.onKeypress)
        self._captureManager = CaptureManager(None, self._windowManager, False)
    
    def run(self):
        """Run the main loop"""
        self._windowManager.createWindow()
        self._captureManager.readImage("e:\python\corner_s2.jpg")
        while self._windowManager._isWindowCreated:
            self._captureManager.enterFrame()
            self._captureManager.frame()
            
            #TODO: Filter the frame (...)
            self._captureManager.exitFrame()
            self._windowManager.processEvents()
    def onKeypress(self, keycode):
        """Handle a keypress.
        
        space -> Take a screenshot
        tab   -> Start/stop recording a screencast
        escape-> Quit
        
        """
        if keycode ==32: #space
            self._captureManager.writeImage('screenshot.png')
        elif keycode ==27: #escape
            self._windowManager.destroyWindow()
        elif keycode == -1:
            print("non")
            #self._windowManager.show(self._captureManager.frame())
if __name__ =="__main__":
    Cameo().run()

例子2，輸入video或相機圖像：

#################cameo2.py##########################################

import cv2
from managersD import WindowManager, CaptureManager

class Cameo(object):
    def __init__(self):
        self._windowManager = WindowManager('Cameo',self.onKeypress)
        self._captureManager = CaptureManager(cv2.VideoCapture(0), self._windowManager, False)
    
    def run(self):
        """Run the main loop"""
        self._windowManager.createWindow()
        while self._windowManager._isWindowCreated:
            self._captureManager.enterFrame()
            self._captureManager.frame()
            
            #TODO: Filter the frame (...)
            self._captureManager.exitFrame()
            self._windowManager .processEvents()
    def onKeypress(self, keycode):
        """Handle a keypress.
        
        space -> Take a screenshot
        tab   -> Start/stop recording a screencast
        escape-> Quit
        
        """
        if keycode ==32: #space
            self._captureManager.writeImage('screenshot.png')
        elif keycode == 9: #tab
            if not self._captureManager.isWritingVideo():
                self._captureManager.startWritingVideo('screencast.avi')
            else:
                self._captureManager.stopWritingVideo()
        elif keycode ==27: #escape
            self._windowManager.destroyWindow()
        
if __name__ =="__main__":
    Cameo().run()

OpenCV computer vision with python電子版的下載地址：http://filepi.com/i/VHV2mnu