마스크 디텍션 출력

+# 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
+from tensorflow.keras.models import load_model
+from imutils.video import VideoStream
+import numpy as np
+import argparse
+import imutils
+import time
+import os
+
+import cv2
+import sys
+from PyQt5 import QtCore
+from PyQt5 import QtWidgets
+from PyQt5 import QtGui
+
+class ShowVideo(QtCore.QObject):
+
+    flag = 0
+
+    camera = cv2.VideoCapture(0) # 연결된 영상장치 index, 기본은 0
+
+    ret, image = camera.read()  # 2개의 값 리턴, 첫 번째는 프레임 읽음여부, 두 번째는 프레임 자체
+    height, width = image.shape[:2]
+
+    VideoSignal1 = QtCore.pyqtSignal(QtGui.QImage)  # VideoSignal1이라는 사용자 정의 시그널 생성
+    VideoSignal2 = QtCore.pyqtSignal(QtGui.QImage)  # VideoSignal2이라는 사용자 정의 시그널 생성
+
+    def __init__(self, parent=None):
+        super(ShowVideo, self).__init__(parent)
+
+    @QtCore.pyqtSlot()
+    def startVideo(self, faceNet, maskNet):
+        global image
+
+        run_video = True
+        while run_video:
+            ret, image = self.camera.read()
+
+            # detect faces in the frame and determine if they are wearing a
+            # face mask or not
+            (locs, preds) = detect_and_predict_mask(image, faceNet, maskNet)
+
+            frame = image
+            # 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)
+            ###
+            color_swapped_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+            qt_image1 = QtGui.QImage(color_swapped_image.data,
+                                    self.width,
+                                    self.height,
+                                    color_swapped_image.strides[0],
+                                    QtGui.QImage.Format_RGB888)
+            self.VideoSignal1.emit(qt_image1)
+
+
+            if self.flag:
+                img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+                img_canny = cv2.Canny(img_gray, 50, 100)
+
+                qt_image2 = QtGui.QImage(img_canny.data,
+                                         self.width,
+                                         self.height,
+                                         img_canny.strides[0],
+                                         QtGui.QImage.Format_Grayscale8)
+
+                self.VideoSignal2.emit(qt_image2)
+
+
+            loop = QtCore.QEventLoop()
+            QtCore.QTimer.singleShot(25, loop.quit) #25 ms
+            loop.exec_()
+
+    @QtCore.pyqtSlot()
+    def canny(self):
+        self.flag = 1 - self.flag
+
+
+class ImageViewer(QtWidgets.QWidget):
+    def __init__(self, parent=None):
+        super(ImageViewer, self).__init__(parent)
+        self.image = QtGui.QImage()
+        self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
+
+    def paintEvent(self, event):
+        painter = QtGui.QPainter(self)
+        painter.drawImage(0, 0, self.image)
+        self.image = QtGui.QImage()
+
+    def initUI(self):
+        self.setWindowTitle('Webcam')
+
+    @QtCore.pyqtSlot(QtGui.QImage)
+    def setImage(self, image):
+        if image.isNull():
+            print("Viewer Dropped frame!")
+
+        self.image = image
+        if image.size() != self.size():
+            self.setFixedSize(image.size())
+        self.update()
+
+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 > args["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)
+
+			# add the face and bounding boxes to their respective
+			# lists
+			faces.append(face)
+			locs.append((startX, startY, endX, endY))
+
+	# only make a predictions if at least one face was detected
+	if len(faces) > 0:
+		# for faster inference we'll make batch predictions on *all*
+		# faces at the same time rather than one-by-one predictions
+		# in the above `for` loop
+		faces = np.array(faces, dtype="float32")
+		preds = maskNet.predict(faces, batch_size=32)
+
+	# return a 2-tuple of the face locations and their corresponding
+	# locations
+	return (locs, preds)
+
+
+if __name__ == '__main__':
+
+    # construct the argument parser and parse the arguments
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-f", "--face", type=str,default="face_detector",
+	help="path to face detector model directory")
+    ap.add_argument("-m", "--model", type=str,default="mask_detector.model",
+                    help="path to trained face mask detector model")
+    ap.add_argument("-c", "--confidence", type=float, default=0.5,
+                    help="minimum probability to filter weak detections")
+    args = vars(ap.parse_args())
+
+    # load our serialized face detector model from disk
+    print("[INFO] loading face detector model...")
+    prototxtPath = os.path.sep.join([args["face"], "deploy.prototxt"])
+    weightsPath = os.path.sep.join([args["face"],
+                                    "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...")
+    maskNet = load_model(args["model"])
+    
+    
+    app = QtWidgets.QApplication(sys.argv)  # app 생성
+
+
+    thread = QtCore.QThread()
+    thread.start()
+    vid = ShowVideo()
+    vid.moveToThread(thread)
+
+    image_viewer1 = ImageViewer()
+    #image_viewer2 = ImageViewer()
+
+    vid.VideoSignal1.connect(image_viewer1.setImage)
+    #vid.VideoSignal2.connect(image_viewer2.setImage)
+
+    #push_button1 = QtWidgets.QPushButton('Start')
+    #push_button2 = QtWidgets.QPushButton('Canny')
+    #push_button1.clicked.connect(vid.startVideo)
+    #push_button2.clicked.connect(vid.canny)
+
+    vertical_layout = QtWidgets.QVBoxLayout()
+    horizontal_layout = QtWidgets.QHBoxLayout()
+    horizontal_layout.addWidget(image_viewer1)
+    #horizontal_layout.addWidget(image_viewer2)
+    vertical_layout.addLayout(horizontal_layout)
+    #vertical_layout.addWidget(push_button1)
+    #vertical_layout.addWidget(push_button2)
+
+    layout_widget = QtWidgets.QWidget()
+    layout_widget.setLayout(vertical_layout)
+
+    main_window = QtWidgets.QMainWindow()
+    main_window.setCentralWidget(layout_widget)
+    main_window.setWindowTitle('웹캠 테스트')    # main window 제목
+    main_window.show()
+    ####    
+    vid.startVideo(faceNet, maskNet)
+    ####
+    sys.exit(app.exec_())   # 프로그램 대기상태 유지, 무한루프