detect_mask_video.py

# USAGE
# python detect_mask_video.py

# import the necessary packages
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
import tensorflow as tf
from imutils.video import VideoStream
from imutils.video import FPS
import numpy as np
import argparse
import imutils
import time
import cv2
import os
from flask import Flask, render_template, Response

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

def gen():
    # Initialize frame rate calculation
    frame_rate_calc = 1
    freq = cv2.getTickFrequency()
    # loop over the frames from the video stream
    while True:
        # grab the frame from the threaded video stream and resize it
        # to have a maximum width of 400 pixels
        # Start timer (for calculating frame rate)
        t1 = cv2.getTickCount()
        frame = videostream.read()
        frame = imutils.resize(frame, width=400)

        # detect faces in the frame and determine if they are wearing a
        # face mask or not
        (locs, preds) = detect_and_predict_mask(frame, faceNet, interpreter)

        # loop over the detected face locations and their corresponding
        # locations
        for (box, pred) in zip(locs, preds):
            # unpack the bounding box and predictions
            (startX, startY, endX, endY) = box
            (mask, withoutMask) = pred

            # determine the class label and color we'll use to draw
            # the bounding box and text
            label = "Mask" if mask > withoutMask else "No Mask"
            color = (0, 255, 0) if label == "Mask" else (0, 0, 255)

            # include the probability in the label
            label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)

            # display the label and bounding box rectangle on the output
            # frame
            cv2.putText(frame, label, (startX, startY - 10),
                cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
            cv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)
            display_message(mask > withoutMask )
        cv2.putText(frame,'FPS: {0:.2f}'.format(frame_rate_calc),(30,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,0),2,cv2.LINE_AA)

        # show the output frame
        #cv2.imshow("Frame", frame)
        #key = cv2.waitKey(1) & 0xFF
        # Draw framerate in corner of frame
        
        # Calculate framerate
        t2 = cv2.getTickCount()
        time1 = (t2-t1)/freq
        frame_rate_calc= 1/time1

       
        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' +  cv2.imencode('.jpg', frame)[1].tobytes() + b'\r\n')

@app.route('/video_feed')
def video_feed():
    return Response(gen(),
                    mimetype='multipart/x-mixed-replace; boundary=frame')


displayLed=True
from numpy import asarray
try:
    from sense_hat import SenseHat
except ImportError:
    displayLed=False
if displayLed:
    sense = SenseHat()

CONFIDENCE=0.5

# Define some colours
g = (0, 255, 0) # Green
b = (0, 0, 0) # Black

r = (255, 0, 0) # Green

# Set up where each colour will display
creeper_mask_pixels = [
    g, g, g, g, g, g, g, g,
    g, g, g, g, g, g, g, g,
    g, b, b, g, g, b, b, g,
    g, b, b, g, g, b, b, g,
    g, g, g, b, b, g, g, g,
    g, g, b, b, b, b, g, g,
    g, g, b, b, b, b, g, g,
    g, g, b, g, g, b, g, g
]

creeper_nomakk_pixels = [
    r, r, r, r, r, r, r, r,
    r, r, r, r, r, r, r, r,
    r, b, b, r, r, b, b, r,
    r, b, b, r, r, b, b, r,
    r, r, r, b, b, r, r, r,
    r, r, b, b, b, b, r, r,
    r, r, b, b, b, b, r, r,
    r, r, b, r, r, b, r, r
]



def display_message(mask_detected):
    if displayLed:
        if mask_detected:
            sense.set_pixels(creeper_mask_pixels)
            time.sleep(2.0)
            sense.clear()
        else:
            sense.set_pixels(creeper_nomakk_pixels)
            time.sleep(0.5)
            sense.clear()
            time.sleep(0.5)
            sense.set_pixels(creeper_nomakk_pixels)
            time.sleep(0.5)
            sense.clear()
            
def detect_and_predict_mask(frame, faceNet, maskNet):
    # grab the dimensions of the frame and then construct a blob
    # from it
    (h, w) = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
        (104.0, 177.0, 123.0))

    # pass the blob through the network and obtain the face detections
    faceNet.setInput(blob)
    detections = faceNet.forward()

    # initialize our list of faces, their corresponding locations,
    # and the list of predictions from our face mask network
    faces = []
    locs = []
    preds = []

    # loop over the detections
    for i in range(0, detections.shape[2]):
        # extract the confidence (i.e., probability) associated with
        # the detection
        confidence = detections[0, 0, i, 2]

        # filter out weak detections by ensuring the confidence is
        # greater than the minimum confidence
        if confidence > CONFIDENCE:
            # compute the (x, y)-coordinates of the bounding box for
            # the object
            box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
            (startX, startY, endX, endY) = box.astype("int")

            # ensure the bounding boxes fall within the dimensions of
            # the frame
            (startX, startY) = (max(0, startX), max(0, startY))
            (endX, endY) = (min(w - 1, endX), min(h - 1, endY))

            # extract the face ROI, convert it from BGR to RGB channel
            # ordering, resize it to 224x224, and preprocess it
            face = frame[startY:endY, startX:endX]
            face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
            face = cv2.resize(face, (224, 224))
            face = img_to_array(face)
            face = preprocess_input(face)
            face = np.expand_dims(face, axis=0)
            # add the face and bounding boxes to their respective
            # lists

            interpreter.set_tensor(input_details[0]['index'],face)
            interpreter.invoke()
            #print(output_details[0]['index'])
            pred=interpreter.get_tensor(output_details[0]['index'])[0] # Bounding box coordinates of detected objects
            preds.append(pred)
            faces.append(face)
            locs.append((startX, startY, endX, endY))

    
    # return a 2-tuple of the face locations and their corresponding
    # locations
    return (locs, preds)


if __name__ == '__main__':

    # load our serialized face detector model from disk
    print("[INFO] loading face detector model...")
    prototxtPath = os.path.sep.join(["face_detector", "deploy.prototxt"])
    weightsPath = os.path.sep.join(["face_detector",
        "res10_300x300_ssd_iter_140000.caffemodel"])
    faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)

    # load the face mask detector model from disk
    print("[INFO] loading face mask detector model...")
    interpreter = tf.lite.Interpreter(model_path="mask_detector.tflite")
    interpreter.allocate_tensors()

    # Get input and output tensors.
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()
    details=interpreter.get_tensor_details()

    # initialize the video stream and allow the camera sensor to warm up
    print("[INFO] starting video stream...")


    # Initialize video stream
    videostream = VideoStream(src=0).start()

    time.sleep(2.0)


    app.run(host='0.0.0.0', debug=True)
        # do a bit of cleanup
    cv2.destroyAllWindows()
    videostream.stop()