Source Code for Module pyvision.surveillance.testsuite

  1  ''' 
  2  Copyright David S. Bolme 
  3   
  4  Created on Nov 19, 2010 
  5   
  6  @author: bolme 
  7  ''' 
  8  import unittest 
  9  import os.path 
 10  import pyvision as pv 
 11   
 12  BUGS_VIDEO = os.path.join(pv.__path__[0],'data','test','BugsSample.m4v') 
 13  TAZ_VIDEO = os.path.join(pv.__path__[0],'data','test','TazSample.m4v') 
 14  TOYCAR_VIDEO = os.path.join(pv.__path__[0],'data','test','toy_car.m4v') 
 15   
 16 -class MotionDetectTest(unittest.TestCase): 
 17   
 18   
 19 -    def setUp(self): 
 20          pass 
 21   
 22   
 23 -    def tearDown(self): 
 24          pass 
 25   
 26   
 27 -    def testMotionDetectAMF(self): 
 28          ilog = None # pv.ImageLog() 
 29           
 30          md = pv.MotionDetector(method=pv.BG_SUBTRACT_AMF,minArea=200) 
 31           
 32          video = pv.Video(BUGS_VIDEO) 
 33           
 34          i = 0 
 35          for frame in video:             
 36              _ = md.detect(frame) 
 37   
 38              _ = md.getStandardizedRects() 
 39              _ = md.getBoundingRects() 
 40               
 41              _ = md.getPolygons(return_all=True) 
 42               
 43              if ilog != None: 
 44                  print "Processing Frame:",i 
 45                   
 46                  key_frame = md.getKeyFrame() 
 47                   
 48                  md.annotateFrame(key_frame) 
 49                   
 50                  if key_frame != None: 
 51                      ilog(key_frame,format='jpg') 
 52                               
 53              i += 1 
 54              if i > 20: break 
 55           
 56          if ilog != None: 
 57              ilog.show() 
 58   
 59   
 60 -    def testMotionDetectMF(self): 
 61          ilog =  None # pv.ImageLog() 
 62           
 63          md = pv.MotionDetector(method=pv.BG_SUBTRACT_MF,minArea=200) 
 64           
 65          video = pv.Video(BUGS_VIDEO) 
 66           
 67          i = 0 
 68          for frame in video:             
 69              _ = md.detect(frame) 
 70   
 71              _ = md.getStandardizedRects() 
 72              _ = md.getBoundingRects() 
 73               
 74              _ = md.getPolygons(return_all=True) 
 75               
 76              if ilog != None: 
 77                  print "Processing Frame:",i 
 78                   
 79                  key_frame = md.getKeyFrame() 
 80                   
 81                  md.annotateFrame(key_frame) 
 82                   
 83                  if key_frame != None: 
 84                      ilog(key_frame,format='jpg') 
 85                               
 86              i += 1 
 87              if i > 20: break 
 88           
 89          if ilog != None: 
 90              ilog.show() 
 91   
 92   
 93   
 94 -    def testMotionDetectFD(self): 
 95          ilog = None # pv.ImageLog() 
 96           
 97          md = pv.MotionDetector(method=pv.BG_SUBTRACT_FD,minArea=200) 
 98           
 99          video = pv.Video(BUGS_VIDEO) 
100           
101          i = 0 
102          for frame in video:             
103              _ = md.detect(frame) 
104   
105              _ = md.getStandardizedRects() 
106              _ = md.getBoundingRects() 
107               
108              _ = md.getPolygons(return_all=True) 
109               
110              if ilog != None: 
111                  print "Processing Frame:",i 
112                   
113                  key_frame = md.getKeyFrame() 
114                   
115                  md.annotateFrame(key_frame) 
116                   
117                  if key_frame != None: 
118                      ilog(key_frame,format='jpg') 
119                               
120              i += 1 
121              if i > 20: break 
122           
123          if ilog != None: 
124              ilog.show() 
125   
126 -    def testMotionDetectMCFD(self): 
127          ilog = None # pv.ImageLog() 
128           
129          #flow = pv.OpticalFlow()   #This is now encapsulated in MCFD object 
130          md = pv.MotionDetector(method=pv.BG_SUBTRACT_MCFD,minArea=200,rect_type=pv.STANDARDIZED_RECTS) 
131          video = pv.Video(TOYCAR_VIDEO) 
132           
133          i = 0 
134          for frame in video:     
135   
136              #flow.update(frame) #no longer required, this is encapsulated 
137              md.detect(frame) 
138               
139              if ilog != None: 
140                  print "Processing Frame:",i 
141                  #flow.annotateFrame(frame)  #this is encapsulated in the md.annotateFrame method 
142   
143                  key_frame = md.getKeyFrame()                 
144                  md.annotateFrame(key_frame) 
145                   
146                  if key_frame != None: 
147                      ilog(key_frame,format='jpg') 
148                               
149              i += 1 
150              #if i > 20: break 
151           
152          if ilog != None: 
153              ilog.show() 
154   
155   
156 -class OpticalFlowTest(unittest.TestCase): 
157   
158   
159 -    def setUp(self): 
160          pass 
161   
162   
163 -    def tearDown(self): 
164          pass 
165   
166   
167 -    def testOpticalFlow(self): 
168          ilog = None # pv.ImageLog() 
169           
170          flow = pv.OpticalFlow() 
171           
172          video = pv.Video(TAZ_VIDEO) 
173           
174          i = 0 
175          for frame in video:           
176              flow.update(frame) 
177               
178              flow.annotateFrame(frame) 
179              if ilog != None: 
180                  print "Processing Frame:",i   
181                  ilog(frame,format='jpg') 
182   
183              i += 1 
184              if i > 10: break 
185           
186          if ilog != None: 
187              ilog.show() 
188               
189 -    def testHomographies(self): 
190          ilog =  None # pv.ImageLog() 
191           
192          flow = pv.OpticalFlow() 
193           
194          video = pv.Video(TAZ_VIDEO) 
195           
196          i = 0 
197          prev_frame = None 
198          for frame in video:   
199                    
200              flow.update(frame) 
201               
202              flow.annotateFrame(frame) 
203              if ilog != None: 
204                  print "Processing Frame:",i   
205                  if hasattr(frame,'to_prev'): 
206                      prev_im = frame.to_prev(frame) 
207                      ilog(prev_im,'back',format='jpg') 
208                       
209                  if prev_frame != None: 
210                      forward_im = prev_frame.to_next(prev_frame) 
211                      ilog(forward_im,'forward',format='jpg') 
212                   
213                  ilog(frame,"current",format='jpg') 
214   
215              i += 1 
216              if i > 10: break 
217               
218              prev_frame = frame 
219           
220          if ilog != None: 
221              ilog.show() 
222                           
223               
224   
225  if __name__ == "__main__": 
226      #import sys;sys.argv = ['', 'Test.testName'] 
227      unittest.main(testRunner = unittest.TextTestRunner(verbosity=2)) 
228