用Raspberry Pi消除害虫

from pygame import mixer

class SoundPlayer:
    def __init__(self, sound_file):
        mixer.init(44100, -16, 2, 2048)
        self.sound = mixer.Sound(sound_file)
        
    def play(self):
        self.sound.play()

接下来，我们需要一个类来衡量应用程序的帧处理速度：

import time

class FPS:
    def __init__(self):
        self.frame_count = 0
        self.elapsed_time = 0
        
    def start(self):
        self.start_time = time.time()

    def stop(self):
        self.stop_time = time.time()
        self.frame_count += 1
        self.elapsed_time += (self.stop_time-self.start_time)
    
    def count(self):
        return self.frame_count
    
    def elapsed(self):
        return self.elapsed_time
    
    def fps(self):
        if self.elapsed_time==0:
            return 0
        else:
            return self.frame_count/self.elapsed_time

现在，我们可以修改上一篇文章中开发的VideoPD类，以播放声音并评估检测速度：

class VideoPDSound:
    def __init__(self, md, pd, thresh, sp):
        self.md = md
        self.pd = pd
        self.thresh = thresh
        self.sp = sp
        self.fps = FPS()
        
    def play(self, file_path):
        capture = cv2.VideoCapture(file_path)
        
        md_name = 'Motion objects'
        cv2.namedWindow(md_name, cv2.WINDOW_NORMAL)
        cv2.resizeWindow(md_name, 640, 480)
        
        counter = 0
        play_dt = 10.0
        curr_time = time.time()
        play_time = curr_time - play_dt - 0.1
        detect_count = 0
        
        while(True):    
            (ret, frame) = capture.read()
            if frame is None:
                break
            
            counter = counter + 1
            #if (counter % 3) != 0:
            #    continue
            
            self.fps.start()
            self.md.process(frame)
            objects = self.md.objects()
            
            l = len(objects)
            pests = []
            if l>0 :
                for (i, obj) in enumerate(objects) :
                    (roi, (class_num, class_conf)) = self.pd.detect(frame, obj)
                    if (class_num>0) and (class_conf>=self.thresh) :
                        pests.append(roi)
                        
            self.fps.stop()
            
            if l>0:
                Utils.draw_objects(objects, "OBJECT", (255, 0, 0), frame)
            
            k = len(pests)
            if k>0:
                detect_count = detect_count + 1
                Utils.draw_objects(pests, "PEST", (0, 0, 255), frame)
                curr_time = time.time()
                dt = curr_time - play_time
                if dt>play_dt :
                    self.sp.play()
                    play_time = curr_time
            
            # Display the resulting frame with object rects
            cv2.imshow(md_name, frame)
            
            #time.sleep(0.01)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
            
        capture.release()
        cv2.destroyAllWindows()    

        f = self.fps.fps()
        return (detect_count, f)

现在，此代码通过调用self.fps.start和self.fps.stop方法来监视检测过程的性能。请注意，我们仅评估检测算法的执行时间（运动检测和分类）。当在框架中检测到有害生物时，修改后的代码还会通过调用self.sp.play来播放声音。在现实生活中，很可能会在几个连续的帧中检测到驼鹿。我们不想每次在相机视图中出现驼鹿时都播放声音。

video_file = r"/home/pi/Desktop/PI_PEST/video/moose_1.mp4"

md = MD(0.05, 0.1)
proto = r"/home/pi/Desktop/PI_PEST/net/moose.prototxt"
model = r"/home/pi/Desktop/PI_PEST/net/moose.caffemodel"
pd = PestDetector(proto, model, 128)

sound_file = r"/home/pi/Desktop/PI_PEST/video/buzzer.wav"
scarer = SoundPlayer(sound_file)

v_pd = VideoPDSound(md, pd, 0.99, scarer)
(detect_count, fps) = v_pd.play(video_file)
print("FPS = %s" % fps)

这是捕获的视频结果：