def handle(self, **options):
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-c",
"--confidence",
type=float,
default=0.5,
help="minimum probability to filter weak detections")
ap.add_argument("-t",
"--threshold",
type=float,
default=0.3,
help="threshold when applyong non-maxima suppression")
args = vars(ap.parse_args())
# load the COCO class labels our YOLO model was trained on
labelsPath = "yolo/yolo-coco/coco.names"
LABELS = open(labelsPath).read().strip().split("\n")
# initialize a list of colors to represent each possible class label
np.random.seed(42)
COLORS = np.random.randint(0,
255,
size=(len(LABELS), 3),
dtype="uint8")
# derive the paths to the YOLO weights and model configuration
weightsPath = "yolo/yolo-coco/yolov3.weights"
configPath = "yolo/yolo-coco/yolov3.cfg"
# load our YOLO object detector trained on COCO dataset (80 classes)
# and determine only the *output* layer names that we need from YOLO
print("[INFO] loading YOLO from disk...")
net = cv2.dnn.readNetFromDarknet(configPath, weightsPath)
ln = net.getLayerNames()
ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]
# initialize the video stream, pointer to output video file, and
# frame dimensions
# old: vs = cv2.VideoCapture(args["input"])
vs = VideoStream(src=0).start()
vs.rotation = 180
# allow camera to warm up
time.sleep(2.0)
writer = None
(W, H) = (None, None)
# loop over frames from the video file stream
while True:
print("looping")
# key listener for q to quit the program
# if the 'q' key is pressed, stop the loop
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
# read the next frame from the stream
frame = vs.read()
frame = imutils.rotate(frame, angle=180)
#frame = white_balance(frame)
cv2.imshow("frame", frame)
#cv2.waitKey(0);
# if the frame dimensions are empty, grab them
if W is None or H is None:
(H, W) = frame.shape[:2]
# construct a blob from the input frame and then perform a forward
# pass of the YOLO object detector, giving us our bounding boxes
# and associated probabilities
blob = cv2.dnn.blobFromImage(frame,
1 / 255.0, (416, 416),
swapRB=True,
crop=False)
net.setInput(blob)
start = time.time()
layerOutputs = net.forward(ln)
end = time.time()
# initialize our lists of detected bounding boxes, confidences,
# and class IDs, respectively
boxes = []
confidences = []
classIDs = []
# loop over each of the layer outputs
for output in layerOutputs:
# loop over each of the detections
for detection in output:
# extract the class ID and confidence (i.e., probability)
# of the current object detection
scores = detection[5:]
classID = np.argmax(scores)
confidence = scores[classID]
# filter out weak predictions by ensuring the detected
# probability is greater than the minimum probability
if confidence > args["confidence"]:
# scale the bounding box coordinates back relative to
# the size of the image, keeping in mind that YOLO
# actually returns the center (x, y)-coordinates of
# the bounding box followed by the boxes' width and
# height
box = detection[0:4] * np.array([W, H, W, H])
(centerX, centerY, width, height) = box.astype("int")
# use the center (x, y)-coordinates to derive the top
# and and left corner of the bounding box
x = int(centerX - (width / 2))
y = int(centerY - (height / 2))
# CUSTOM: prevent other objects besides cars from being
# processed
if LABELS[classID] != 'car':
continue
# update our list of bounding box coordinates,
# confidences, and class IDs
boxes.append([x, y, int(width), int(height)])
confidences.append(float(confidence))
classIDs.append(classID)
# CshoUSTOM: crop each object TODO
cropped = frame[y:y + int(height), x:x + int(width)]
if cropped.shape[0] < 1 or cropped.shape[1] < 1:
continue
color = get_colors(cropped, 3, False)
cv2.imshow("Frame", cropped)
cv2.waitKey(0)
# apply non-maxima suppression to suppress weak, overlapping
# bounding boxes
idxs = cv2.dnn.NMSBoxes(boxes, confidences, args["confidence"],
args["threshold"])
# ensure at least one detection exists
if len(idxs) > 0:
# loop over the indexes we are keeping
for i in idxs.flatten():
# extract the bounding box coordinates
(x, y) = (boxes[i][0], boxes[i][1])
(w, h) = (boxes[i][2], boxes[i][3])
# draw a bounding box rectangle and label on the frame
color = [int(c) for c in COLORS[classIDs[i]]]
cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
text = "{}: {:.4f}".format(LABELS[classIDs[i]],
confidences[i])
cv2.putText(frame, text, (x, y - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
# release the file pointers
print("[INFO] cleaning up...")
vs.stop()
