# Padded resize

img = letterbox(img1, new_shape=img_size)[0]

# Convert

img = img[:, :, ::-1].transpose(2, 0, 1)

# BGR to RGB, to 3x416x416

img = np.ascontiguousarray(img)

# cv2.imwrite(path + '.letterbox.jpg', 255 * img.transpose((1, 2, 0))[:, :, ::-1]) # save letterbox image

# Resize image to a 32-pixel-multiple rectangle https://github.com/ultralytics/yolov3/issues/232

shape = img.shape[:2]

# current shape [height, width]

if isinstance(new_shape, int):

new_shape = (new_shape, new_shape)

# Scale ratio (new / old)

r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])

if not scaleup:

# only scale down, do not scale up (for better test mAP)

r = min(r, 1.0)

# Compute padding

ratio = r, r

# width, height ratios

new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))

dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]

# wh padding

if auto:

# minimum rectangle

dw, dh = np.mod(dw, 64), np.mod(dh, 64)

# wh padding

elif scaleFill:

# stretch

dw, dh = 0.0, 0.0

new_unpad = (new_shape[1], new_shape[0])

ratio = new_shape[1] / shape[1], new_shape[0] / shape[0]

# width, height ratios

dw /= 2

# divide padding into 2 sides

dh /= 2

if shape[::-1] != new_unpad:

# resize

img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)

top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))

left, right = int(round(dw - 0.1)), int(round(dw + 0.1))

img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)

# add border

while cap.isOpened():

ret, frame = cap.read()

t0 = time.time()

if not ret:

print_div('No Frame')

break

fps_t1 = time.time()

img, img0 = img_preprocess(frame)

# img: Resize , img0:Orginal

img = torch.from_numpy(img).to(device)

img = img.half() if half else img.float()

# uint8 to fp16/32

img /= 255.0

# 0 - 255 to 0.0 - 1.0

if img.ndimension() == 3:

img = img.unsqueeze(0)

# Inference

t1 = time_synchronized()

pred = model(img, augment=opt.augment)[0]

# Apply NMS : 取得每項預測的數值

pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)

t2 = time_synchronized()

# Apply Classifier : 取得該數值的LAbel

if False:

pred = apply_classifier(pred, modelc, img, img0)

# Draw Box

for i, det in enumerate(pred):

s = '%gx%g ' % img.shape[2:]

# print string

gn = torch.tensor(img0.shape)[[1, 0, 1, 0]]

# normalization gain whwh

if det is not None and len(det):

# Rescale boxes from img_size to im0 size

det[:, :4] = scale_coords(img.shape[2:], det[:, :4], img0.shape).round()

# Print results

for c in det[:, -1].unique():

n = (det[:, -1] == c).sum()

# detections per class

s += '%g %ss, ' % (n, names[int(c)])

# add to string

# Write results

for *xyxy, conf, cls in reversed(det):

label = '%s %.2f' % (names[int(cls)], conf)

plot_one_box(xyxy, img0, label=label, color=colors[int(cls)], line_thickness=3)

# Print Results(inference + NMS)

#print_div('%sDone. (%.3fs)' % (s, t2 - t1))

# Draw Image

x, y, w, h = (img0.shape[1]//4), 25, (img0.shape[1]//2), 30

cv2.rectangle(img0, (x, 10),(x+w, y+h), (0,0,0), -1)

cv2.putText(img0, '{} | inference: {:.4f}s | fps: {:.4f}'.format(opt.weights[0], t2-t1, 1/(time.time()-t0)),(x+20, y+20),cv2.FONT_HERSHEY_SIMPLEX,1,(0,0,255),2)

print_div('INTIL')

out, source, weights, view_img, save_txt, imgsz,count = \

opt.output, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size,opt.threads

# Initialize

print_div('GET DEVICE')

set_logging()

device = select_device(opt.device)

half = device.type != 'cpu'

# half precision only supported on CUDA

# Load model

print_div('LOAD MODEL')

model = attempt_load(weights, map_location=device)

# load FP32 model

imgsz = check_img_size(imgsz, s=model.stride.max())

# check img_size

if half:

model.half()

# to FP16

# Second-stage classifier

print_div('LOAD MODEL_CLASSIFIER')

classify = False

if classify:

modelc = load_classifier(name='resnet101', n=2)

# initialize

modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model'])

# load weights

modelc.to(device).eval()

# Get names and colors

print_div('SET LABEL COLOR')

names = model.module.names if hasattr(model, 'module') else model.names

colors = [[random.randint(0, 255) for _ in range(3)] for _ in range(len(names))]

# Run inference

###############################################################################

print_div("RUN INFERENCE")

img = torch.zeros((1, 3, imgsz, imgsz), device=device)

# init img

_ = model(img.half() if half else img) if device.type != 'cpu' else None

# run muti

q =[]

rescale = 0.5

threads = []

img=[None] * 9

videowrite =[]

time_count=time.time()

for i in range(0,8):

video_path =source+"/test"+str(i+1)+".mp4"

cap=cv2.VideoCapture(video_path)

videowrite.append(cv2.VideoWriter(r'end'+str(i+1)+'.mp4',-1,20, (960, 540)))

q.append(Queue())

multithreading(cap,device,half,names,colors,model, q[i])

#threads[i].start()

#threads[i].join()

cap.release()

for k in range(0,q[0].qsize()):

for j in range(0,8):

img[j]=q[j].get()

re_img0 = (int(img[j].shape[1]*rescale) ,int(img[j].shape[0]*rescale))

img[j]=cv2.resize(img[j], re_img0)

videowrite[j].write(img[j])

#print(k)

#mix= np.vstack((img[0], img[1])).toarray()

#mix1= np.hstack((img[3], img[4],img[5]))

#mix2= np.hstack((img[6], img[7],img[8]))

#mix=np.vstack((mix, mix1,mix2))

#cv2.imshow('Stream_Detected',img[0])

#cv2.waitKey(1)

# After break