def execute(model_path, frames_input_src, output_dir): ## Initialization ## #initialize acl runtime acl_resource = AclResource() acl_resource.init() ## Prepare Model ## # parameters for model path and model inputs model_parameters = { 'model_dir': model_path, 'width': 368, # model input width 'height': 368, # model input height } # perpare model instance: init (loading model from file to memory) # model_processor: preprocessing + model inference + postprocessing model_processor = ModelProcessor(acl_resource, model_parameters) ## Get Input ## # Read the image input using OpenCV img_original = cv2.imread(args.frames_input_src) ## Model Prediction ## # model_processor.predict: processing + model inference + postprocessing # canvas: the picture overlayed with human body joints and limbs canvas = model_processor.predict(img_original) # Save the detected results cv2.imwrite(os.path.join(args.output_dir, 'Result_Pose.jpg'), canvas)
def main(): """ acl resource initialization """ if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) #ACL resource initialization acl_resource = AclResource() acl_resource.init() model = Model(model_path) images_list = [ os.path.join(INPUT_DIR, img) for img in os.listdir(INPUT_DIR) if os.path.splitext(img)[1] in IMG_EXT ] for pic in images_list: orig_shape, orig_l, l_data = preprocess(pic) result_list = model.execute([ l_data, ]) postprocess(result_list, pic, orig_shape, orig_l) break print("Execute end")
def execute(model_path, frames_input_src, output_dir): ## Initialization ## #initialize acl runtime acl_resource = AclResource() acl_resource.init() ## Prepare Model ## # parameters for model path and model inputs model_parameters = { 'model_dir': model_path, 'width': 224, # model input width 'height': 224, # model input height } # perpare model instance: init (loading model from file to memory) # model_processor: preprocessing + model inference + postprocessing model_processor = ModelProcessor(acl_resource, model_parameters) ## Get Input ## # Read the image input using OpenCV; OpenCV imread as BGR img_original = cv2.imread(args.frames_input_src) ## Model Prediction ## # model_processor.predict: processing + model inference + postprocessing # category: the category with hightest prob. category = model_processor.predict(img_original) # Save the detected results cv2.putText(img_original, category, (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2) cv2.imwrite(os.path.join(args.output_dir, 'Result.jpg'), img_original)
def main(): """ main """ if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() crowdcount = CrowdCount(MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) ret = crowdcount.init() if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")): os.mkdir(os.path.join(SRC_PATH, "../outputs")) image_dir = sys.argv[1] images_list = [os.path.join(image_dir, img) for img in os.listdir(image_dir) if os.path.splitext(img)[1] in constants.IMG_EXT] for image_file in images_list: image = AclImage(image_file) crop_and_paste_image = crowdcount.pre_process(image) print("pre process end") result = crowdcount.inference([crop_and_paste_image]) result_img_encode = crowdcount.post_process(result, image_file) return result_img_encode
def main(): """ main """ #create output directory if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) #acl init acl_resource = AclResource() acl_resource.init() #load model model = Model(MODEL_PATH) src_dir = os.listdir(INPUT_DIR) #infer picture for pic in src_dir: if not pic.lower().endswith(('.bmp', '.dib', '.png', '.jpg', '.jpeg', '.pbm', '.pgm', '.ppm', '.tif', '.tiff')): print('it is not a picture, %s, ignore this file and continue,' % pic) continue #read picture pic_path = os.path.join(INPUT_DIR, pic) bgr_img = cv2.imread(pic_path).astype(np.float32) #get pic data orig_shape, rgb_img = preprocess(bgr_img) #inference result_list = model.execute([rgb_img, ]) #postprocess postprocess(result_list, orig_shape, bgr_img, pic) print("Execute end")
def main(): #初始化acl acl_resource = AclResource() acl_resource.init() #创建一个检测网络实例,当前使用vgg_ssd网络.当更换检测网络时,在此实例化新的网络 detector = VggSsd(acl_resource, MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) video_decoders, postprocessor = create_threads(detector) if video_decoders is None: log_error("Please check the configuration in %s is valid" % (FACE_DETEC_CONF)) return while True: all_process_fin = True for decoder in video_decoders: ret, data = decoder.get_data() if ret == False: log_info("Read data ret ", ret) continue if data: detect_results = detector.execute(data) postprocessor.process(data, detect_results) all_process_fin = False if all_process_fin: log_info("all video decoder finish") break postprocessor.exit() log_info("sample execute end")
def main(): """ Program execution with picture directory parameters """ if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() #Instantiation classification detection, incoming om model path, model input width and height parameters classify = Classify(acl_resource, MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) #Get the picture storage directory from the parameters, and infer picture by picture image_dir = sys.argv[1] images_list = [ os.path.join(image_dir, img) for img in os.listdir(image_dir) if os.path.splitext(img)[1] in IMG_EXT ] #Create a directory and save the infer results if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")): os.mkdir(os.path.join(SRC_PATH, "../outputs")) for image_file in images_list: #read the picture image = AclImage(image_file) image_dvpp = image.copy_to_dvpp() #preprocess image resized_image = classify.pre_process(image_dvpp) print("pre process end") #inference result = classify.inference(resized_image) #post process classify.post_process(result, image_file)
def main(): """ Program execution with picture directory parameters """ if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() #Instance classification detection, pass into the OM model storage path, model input width and height parameters classify = Classify(acl_resource, MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) #From the parameters of the picture storage directory, reasoning by a picture image_dir = sys.argv[1] images_list = [ os.path.join(image_dir, img) for img in os.listdir(image_dir) if os.path.splitext(img)[1] in IMG_EXT ] #Create a directory to store the inference results if not os.path.isdir('../outputs'): os.mkdir('../outputs') resized_image_list = [] batch_image_files = [] num = 0 batch_amount = len(images_list) // BATCH left = len(images_list) % BATCH for image_file in images_list: num += 1 #Read the pictures image = AclImage(image_file) image_dvpp = image.copy_to_dvpp() #preprocess image resized_image = classify.pre_process(image_dvpp) print("pre process end") batch_image_files.append(image_file) resized_image_list.append(resized_image) if batch_amount > 0: #Each set of BATCH pictures, reasoning and post-processing if num == BATCH: #Reasoning pictures result = classify.inference(resized_image_list, BATCH) #process inference results classify.post_process(result, batch_image_files, BATCH) batch_amount -= 1 num = 0 batch_image_files = [] resized_image_list = [] else: #remaining images are inferred and post-processed if num == left: #Reasoning pictures result = classify.inference(resized_image_list, BATCH) #The inference results are processed classify.post_process(result, batch_image_files, left)
def CreateGraphWithoutDVPP(model_name): acl_resource = AclResource() acl_resource.init() MODEL_PATH = model_name + ".om" model = Model(acl_resource, MODEL_PATH) return model
def execute(model_path): ## Initialization ## #initialize acl runtime acl_resource = AclResource() acl_resource.init() ## Prepare Model ## # parameters for model path and model inputs model_parameters = { 'model_dir': model_path, 'width': 368, # model input width 'height': 368, # model input height } # perpare model instance: init (loading model from file to memory) # model_processor: preprocessing + model inference + postprocessing model_processor = ModelProcessor(acl_resource, model_parameters) ## Get Input ## # Initialize Camera cap = Camera(id = 0, fps = 10) ## Set Output ## # open the presenter channel chan = presenteragent.presenter_channel.open_channel(BODYPOSE_CONF) if chan == None: print("Open presenter channel failed") return while True: ## Read one frame from Camera ## img_original = cap.read() if not img_original: print('Error: Camera read failed') break # Camera Input (YUV) to RGB Image image_byte = img_original.tobytes() image_array = np.frombuffer(image_byte, dtype=np.uint8) img_original = YUVtoRGB(image_array) img_original = cv2.flip(img_original,1) ## Model Prediction ## # model_processor.predict: processing + model inference + postprocessing # canvas: the picture overlayed with human body joints and limbs canvas = model_processor.predict(img_original) ## Present Result ## # convert to jpeg image for presenter server display _,jpeg_image = cv2.imencode('.jpg',canvas) # construct AclImage object for presenter server jpeg_image = AclImage(jpeg_image, img_original.shape[0], img_original.shape[1], jpeg_image.size) # send to presenter server chan.send_detection_data(img_original.shape[0], img_original.shape[1], jpeg_image, []) # release the resources cap.release()
def main(): acl_resource = AclResource() acl_resource.init() detect = VggSsd(acl_resource, MODEL_WIDTH, MODEL_HEIGHT) model = Model(MODEL_PATH) chan = presenteragent.presenter_channel.open_channel(MASK_DETEC_CONF) if chan is None: print("Open presenter channel failed") return lenofUrl = len(sys.argv) if lenofUrl <= 1: print("[ERROR] Please input mp4/Rtsp URL") exit() elif lenofUrl >= 3: print("[ERROR] param input Error") exit() URL = sys.argv[1] URL1 = re.match('rtsp://', URL) URL2 = re.search('.mp4', URL) if URL1 is None and URL2 is None: print("[ERROR] should input correct URL") exit() cap = video.AclVideo(URL) while True: # Read a frame ret, image = cap.read() if ret != 0: print("read None image, break") break #pre process model_input = detect.pre_process(image) if model_input is None: print("Pre process image failed") break # inference result = model.execute(model_input) if result is None: print("execute mode failed") break # post process jpeg_image, detection_list = detect.post_process(result, image) if jpeg_image is None: print("The jpeg image for present is None") break chan.send_detection_data(CAMERA_FRAME_WIDTH, CAMERA_FRAME_HEIGHT, jpeg_image, detection_list)
def main(): """ acl resource initialization """ acl_resource = AclResource() acl_resource.init() #load model model = Model(model_path) chan = presenteragent.presenter_channel.open_channel(COLORIZATION_CONF) if chan is None: print("Open presenter channel failed") return lenofUrl = len(sys.argv) if lenofUrl <= 1: print("[ERROR] Please input mp4/Rtsp URL") exit() elif lenofUrl >= 3: print("[ERROR] param input Error") exit() URL = sys.argv[1] URL1 = re.match('rtsp://', URL) URL2 = re.search('.mp4', URL) if URL1 is None and URL2 is None: print("[ERROR] should input correct URL") exit() cap = cv.VideoCapture(URL) #Gets the total frames frames_num = cap.get(7) currentFrames = 0 while True: #read image ret, frame = cap.read() if ret is not True: print("read None image, break") break if currentFrames == frames_num - 1: currentFrames = 0 cap.set(1, 0) currentFrames += 1 #Gets the L channel value orig_shape, orig_l, l_data = preprocess(frame) result_list = model.execute([l_data,]) result_jpeg = postprocess(result_list, orig_shape, orig_l) chan.send_image(orig_shape[0], orig_shape[1], result_jpeg)
def main(): """ main """ if (len(sys.argv) != 2): print("Please input video path") exit(1) #acl init acl_resource = AclResource() acl_resource.init() #load model model = Model(MODEL_PATH) #open video video_path = sys.argv[1] print("open video ", video_path) cap = cv2.VideoCapture(video_path) fps = cap.get(cv2.CAP_PROP_FPS) Width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) Height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) lf.set_img_size((Width, Height)) #create output directory if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) output_Video = os.path.basename(video_path) output_Video = os.path.join(OUTPUT_DIR, output_Video) fourcc = cv2.VideoWriter_fourcc( *'mp4v') # DIVX, XVID, MJPG, X264, WMV1, WMV2 outVideo = cv2.VideoWriter(output_Video, fourcc, fps, (Width, Height)) # Read until video is completed while (cap.isOpened()): ret, frame = cap.read() if ret == True: #preprocess orig_shape, rgb_img, framecv = preprocess(frame) #inference result_list = model.execute([ rgb_img, ]) #postprocess frame = postprocess(result_list, framecv, orig_shape) outVideo.write(frame) # Break the loop else: break cap.release() outVideo.release() print("Execute end")
def main(): """ main """ SRC_PATH = os.path.realpath(__file__).rsplit("/", 1)[0] MODEL_PATH = "../model/deploy_vel.om" MODEL_WIDTH = 512 MODEL_HEIGHT = 512 # With picture directory parameters during program execution if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() single_image_dehaze = SingleImageDehaze(MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) ret = single_image_dehaze.init() utils.check_ret("single_image_dehaze init ", ret) image_dir = sys.argv[1] images_list = [ os.path.join(image_dir, img) for img in os.listdir(image_dir) if os.path.splitext(img)[1] in constants.IMG_EXT ] # Create a directory to save inference results if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")): os.mkdir(os.path.join(SRC_PATH, "../outputs")) for image_file in images_list: image_name = image_file.split('/')[-1] # read image im = Image.open(image_file) # Preprocess the picture resized_image = single_image_dehaze.pre_process(im) # Inferencecd result = single_image_dehaze.inference([ resized_image, ]) # # Post-processing single_image_dehaze.post_process(result, image_name)
def main(image_dirs, masks_dirs): if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) #acl init acl_resource = AclResource() stream = acl_resource.init() #load model model = Model( MODEL_PATH) matmul_om = Model( MODEL_MATMUL_PATH) paths_img, paths_mask = get_imgs_masks_file_list(image_dirs, masks_dirs) for i in range(len(paths_img)): print('==========') raw_img, raw_mask = readimages(paths_img[i], paths_mask[i]) print("file: % s, shape= % s" % (paths_img[i], raw_img.shape)) img_large, mask_large, img_512, mask_512 = pre_process(raw_img, raw_mask) inpainted_512, attention, mask_512_new = inference(model,[img_512, mask_512,]) # post-processing res_raw_size = post_process(matmul_om,raw_img, img_large, mask_large, inpainted_512[0], img_512, mask_512_new[0], attention[0]) filename = os.path.join(OUTPUT_DIR, 'outpaint_' + os.path.basename(paths_img[i])) cv2.imwrite(filename , res_raw_size) print("Execute end")
def main(): """ main """ image_dir = os.path.join(currentPath, "data") images_list = [ os.path.join(image_dir, img) for img in os.listdir(image_dir) if os.path.splitext(img)[1] in constants.IMG_EXT ] acl_resource = AclResource() acl_resource.init() hpa = Hpa(MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) ret = hpa.init() utils.check_ret("hpa init ", ret) # Create a directory to save inference results if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) for image_file in images_list: image_name = os.path.join(image_dir, os.path.basename(image_file)) print('====' + image_name + '====') # read image im = Image.open(image_name) if len(im.split()) != 3: print('warning: "{}" is not a color image and will be ignored'. format(image_name)) continue # Preprocess the picture resized_image = hpa.pre_process(im) # Inferencecd result = hpa.inference([ resized_image, ]) # # Post-processing hpa.post_process(result, image_name)
def main(): """ acl resource initialization """ acl_resource = AclResource() acl_resource.init() model = Model(model_path) with codecs.open(dict_path, 'r', 'utf-8') as reader: for line in reader: token = line.strip() token_dict[token] = len(token_dict) with open(sample_path, "r") as f: text = f.read() with open(label_path, "r", encoding="utf-8") as f: label_dict = json.loads(f.read()) X1, X2 = preprocess(text) X1 = np.ascontiguousarray(X1, dtype='float32') X2 = np.ascontiguousarray(X2, dtype='float32') X1 = np.expand_dims(X1, 0) X2 = np.expand_dims(X2, 0) s_time = time.time() result_list = model.execute([X1, X2]) e_time = time.time() print(result_list) y = postprocess(result_list) if not os.path.exists(output_dir): os.mkdir(output_dir) save_to_file(output_dir + 'prediction_label.txt', label_dict[str(y)]) print("Original text: %s" % text) print("Prediction label: %s" % label_dict[str(y)]) print("Cost time:", e_time - s_time) print("Execute end")
def main(): """ main """ if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() gesture = Gesture(MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) ret = gesture.init() utils.check_ret("Gesture.init ", ret) image_dir = sys.argv[1] images_list = [ os.path.join(image_dir, img) for img in os.listdir(image_dir) if os.path.splitext(img)[1] in const.IMG_EXT ] if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")): os.mkdir(os.path.join(SRC_PATH, "../outputs")) for image_file in images_list: image = AclImage(image_file) resized_image = gesture.pre_process(image) print("pre process end") result = gesture.inference([ resized_image, ]) gesture.post_process(result, image_file)
def execute(model_path, frames_input_src, output_dir, is_presenter_server): ## Initialization ## #initialize acl runtime acl_resource = AclResource() acl_resource.init() ## Prepare Model ## # parameters for model path and model inputs model_parameters = { 'model_dir': model_path, 'width': 368, # model input width 'height': 368, # model input height } # perpare model instance: init (loading model from file to memory) # model_processor: preprocessing + model inference + postprocessing model_processor = ModelProcessor(acl_resource, model_parameters) ## Get Input ## # Read the video input using OpenCV cap = cv2.VideoCapture(frames_input_src) ## Set Output ## if is_presenter_server: # if using presenter server, then open the presenter channel chan = presenteragent.presenter_channel.open_channel(BODYPOSE_CONF) if chan == None: print("Open presenter channel failed") return else: # if saving result as video file (mp4), then set the output video writer using opencv video_output_path = '{}/demo-{}-{}.mp4'.format( output_dir, os.path.basename(frames_input_src), str(random.randint(1, 100001))) video_writer = cv2.VideoWriter(video_output_path, 0x7634706d, 25, (1280, 720)) if video_writer == None: print('Error: cannot get video writer from openCV') while (cap.isOpened()): ## Read one frame of the input video ## ret, img_original = cap.read() if not ret: print('Cannot read more, Reach the end of video') break ## Model Prediction ## # model_processor.predict: processing + model inference + postprocessing # canvas: the picture overlayed with human body joints and limbs canvas = model_processor.predict(img_original) ## Present Result ## if is_presenter_server: # convert to jpeg image for presenter server display _, jpeg_image = cv2.imencode('.jpg', canvas) # construct AclImage object for presenter server jpeg_image = AclImage(jpeg_image, img_original.shape[0], img_original.shape[1], jpeg_image.size) # send to presenter server chan.send_detection_data(img_original.shape[0], img_original.shape[1], jpeg_image, []) else: # save to video video_writer.write(canvas) # release the resources cap.release() if not is_presenter_server: video_writer.release()
a = [r for r in resultList1.flat] b = [r for r in resultList2.flat] # calculate cosine similarity distance between the two face vectors cos_sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)) print('Cosine similarity between faces: ', cos_sim) if __name__ == '__main__': model_name = 'sphereface' img_file1 = cv2.imread('face1.jpeg') img_file2 = cv2.imread('test_human.jpg') # initialize acl resource acl_resource = AclResource() acl_resource.init() # load offline model MODEL_PATH = model_name + ".om" print("MODEL_PATH:", MODEL_PATH) model = Model(acl_resource, MODEL_PATH) # load image file input_image1 = PreProcessing(img_file1) print(input_image1.shape) input_image2 = PreProcessing(img_file2) print(input_image2.shape) # om model inference resultList1 = model.execute([input_image1])[0].copy() resultList2 = model.execute([input_image2])[0].copy()
def main(opt): # Step 1: initialize ACL and ACL runtime acl_resource = AclResource() # 1.2: one line of code, call the 'init' function of the AclResource object, to initilize ACL and ACL runtime acl_resource.init() # Step 2: Load models mot_model = Model(acl_resource, 'model/dlav0.om') # Create output dir if not exist; default outputs result_root = opt.output_root if opt.output_root != '' else '.' mkdir_if_missing(result_root) video_name = os.path.basename(opt.input_video).replace(' ', '_').split('.')[0] # setup dataloader, use LoadVideo or LoadImages dataloader = LoadVideo(opt.input_video, (1088, 608)) # result_filename = os.path.join(result_root, 'results.txt') frame_rate = dataloader.frame_rate # dir for output images; default: outputs/'VideoFileName' save_dir = os.path.join(result_root, video_name) if save_dir and os.path.exists(save_dir) and opt.rm_prev: shutil.rmtree(save_dir) mkdir_if_missing(save_dir) # initialize tracker tracker = JDETracker(opt, mot_model, frame_rate=frame_rate) timer = Timer() results = [] # img: h w c; 608 1088 3 # img0: c h w; 3 608 1088 for frame_id, (path, img, img0) in enumerate(dataloader): if frame_id % 20 == 0: print('Processing frame {} ({:.2f} fps)'.format( frame_id, 1. / max(1e-5, timer.average_time))) # run tracking, start tracking timer timer.tic() # list of Tracklet; see multitracker.STrack online_targets = tracker.update(np.array([img]), img0) # prepare for drawing, get all bbox and id online_tlwhs = [] online_ids = [] for t in online_targets: tlwh = t.tlwh tid = t.track_id vertical = tlwh[2] / tlwh[3] > 1.6 if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical: online_tlwhs.append(tlwh) online_ids.append(tid) timer.toc() # draw bbox and id online_im = vis.plot_tracking(img0, online_tlwhs, online_ids, frame_id=frame_id, fps=1. / timer.average_time) cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)), online_im)
def main(): acl_resource = AclResource() acl_resource.init() #Create an object to perform detection preprocessing, postprocessing and so on detect = VggSsd(acl_resource, MODEL_WIDTH, MODEL_HEIGHT) #Load the pre-trained model from path model = Model(MODEL_PATH) #Connect to the Presenter Server according to the config file chan = presenteragent.presenter_channel.open_channel(MASK_DETEC_CONF) if chan == None: print("Open presenter channel failed") return #Start the Pi camera on the Atlas 200DK, input argument for the camera port(0 or 1) cap = Camera(0) while True: #Read an image frame from the camera image = cap.read() if image is None: print("read None image, break") break #Image preprocessing model_input = detect.pre_process(image) if model_input == None: print("Pre process image failed") break #Send the data to the model for detection result = model.execute(model_input) if result is None: print("execute mode failed") break #Post-process the detection result jpeg_image, detection_list = detect.post_process(result, image) for i in range(len(detection_list)): #Print the detection result, the detection box coordinates, #detected label, confidence print(detection_list[i].box.lt.x, detection_list[i].box.lt.y, detection_list[i].box.rb.x, detection_list[i].box.rb.y, detection_list[i].result_text, detection_list[i].confidence) ##################################################################################################################################################################### d = math.sqrt( pow(detection_list[i].box.lt.x - detection_list[i].box.rb.x, 2) + pow(detection_list[i].box.lt.y - detection_list[i].box.rb.y, 2)) if (d > 80): msg = detection_list[i].result_text bytesToSend = str.encode(msg) serverAddressPort = ("192.168.1.22", 20001) bufferSize = 1024 UDPClientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) UDPClientSocket.sendto(bytesToSend, serverAddressPort) for j in range(i + 1, len(detection_list)): x_cor_1 = detection_list[i].box.lt.x + abs( (detection_list[i].box.lt.x - detection_list[i].box.rb.x)) / 2 y_cor_1 = detection_list[i].box.lt.y + abs( (detection_list[i].box.lt.y - detection_list[i].box.rb.y)) / 2 x_cor_2 = detection_list[j].box.lt.x + abs( (detection_list[j].box.lt.x - detection_list[j].box.rb.x)) / 2 y_cor_2 = detection_list[j].box.lt.y + abs( (detection_list[j].box.lt.y - detection_list[j].box.rb.y)) / 2 width_1 = abs(detection_list[i].box.lt.x - detection_list[i].box.rb.x) width_2 = abs(detection_list[j].box.lt.x - detection_list[j].box.rb.x) width_thrs = abs(min(width_1, width_2) * 3) diss = math.sqrt( pow(x_cor_1 - x_cor_2, 2) + pow(y_cor_1 - y_cor_2, 2)) #print("Too close!!!!!!", j , "distance:",diss,"threshhold:",width_thrs) if width_1 > 50 and width_2 > 50: if diss < width_thrs: msg = "too_close" bytesToSend = str.encode(msg) serverAddressPort = ("192.168.1.22", 20001) bufferSize = 1024 UDPClientSocket = socket.socket( socket.AF_INET, socket.SOCK_DGRAM) UDPClientSocket.sendto(bytesToSend, serverAddressPort) ######################################################################################################################################################## if jpeg_image == None: print("The jpeg image for present is None") break #Send the result to the Present Server to display onto the browser chan.send_detection_data(CAMERA_FRAME_WIDTH, CAMERA_FRAME_HEIGHT, jpeg_image, detection_list)
def main(): if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) if not os.path.exists(OUTPUT_TXT_DIR): os.mkdir(OUTPUT_TXT_DIR) #acl资源初始化 acl_resource = AclResource() acl_resource.init() #加载模型 model = Model(acl_resource, MODEL_PATH) src_dir = os.listdir(INPUT_DIR) print("src_dir = ", src_dir) #从data目录逐张读取图片进行推理 for pic in src_dir: #读取图片 pic_path = os.path.join(INPUT_DIR, pic) pic_name = pic.split('.')[0] print(pic_name) bgr_img = cv2.imread(pic_path) t1 = time.time() img, ratio = letterbox(bgr_img, new_shape=(320, 640)) # resize to (320,640,3) img = img[:, :, ::-1] #bgr to rgb img = img.transpose(2, 0, 1) #(3,320,640) img = np.ascontiguousarray(img) img = img.astype(np.float32) img = img / 255.0 data = np.concatenate((img[:, ::2, ::2], img[:, 1::2, ::2], img[:, ::2, 1::2], img[:, 1::2, 1::2]), axis=0) #[12,160,320] t2 = time.time() result_list = model.execute([ data, ]) t3 = time.time() post = yolov5_post(result_list) #[1,25200,12] result_return = non_max_suppression(post, conf_thres=conf_threshold, iou_thres=iou_threshold) if len(result_return['detection_classes']): det = np.array(result_return['detection_boxes'])[:, :4] bbox = scale_coords((320, 640), det, bgr_img.shape, ratio) t4 = time.time() print("result = ", result_return) print("preprocess cost:", t2 - t1) print("forward cost:", t3 - t2) print("postprocess cost:", t4 - t3) print("total cost:", t4 - t1) print("FPS:", 1 / (t4 - t1)) for i in range(len(result_return['detection_classes'])): box = bbox[i] class_name = result_return['detection_classes'][i] confidence = result_return['detection_scores'][i] cv2.rectangle(bgr_img, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), colors[i % 6]) p3 = (max(int(box[0]), 15), max(int(box[1]), 15)) out_label = class_name cv2.putText(bgr_img, out_label, p3, cv2.FONT_ITALIC, 0.6, colors[i % 6], 1) output_file = os.path.join(OUTPUT_DIR, "out_" + pic) print("output:%s" % output_file) cv2.imwrite(output_file, bgr_img) pic_name = pic.split('.')[0] predict_result_path = os.path.join(OUTPUT_TXT_DIR, str(pic_name) + '.txt') with open(predict_result_path, 'w') as f: for i in range(len(result_return['detection_classes'])): box = bbox[i] class_name = result_return['detection_classes'][i] confidence = result_return['detection_scores'][i] box = list(map(int, box)) box = list(map(str, box)) confidence = '%.4f' % confidence bbox_mess = ' '.join([ class_name, confidence, box[0], box[1], box[2], box[3] ]) + '\n' f.write(bbox_mess) print("Execute end")
def execute(model_path): ## Initialization ## #initialize acl runtime acl_resource = AclResource() acl_resource.init() # load offline model for face detection model_face = Model(acl_resource, MODEL_PATH_FACE) model_head_pose = Model(acl_resource, MODEL_PATH_HEAD_POSE) ## Prepare Model ## # parameters for model path and model inputs model_parameters = { 'model_dir': model_path, 'width': 368, # model input width 'height': 368, # model input height } # perpare model instance: init (loading model from file to memory) # model_processor: preprocessing + model inference + postprocessing model_processor = ModelProcessor(acl_resource, model_parameters) last_five_frame_result = [] # Initialize Camera cap = Camera(id = 0, fps = 10) # Read reference images img_left1 = cv2.imread(LEFT1_PATH) img_left2 = cv2.imread(LEFT2_PATH) img_right1 = cv2.imread(RIGHT1_PATH) img_right2 = cv2.imread(RIGHT2_PATH) img_stop = cv2.imread(STOP_PATH) # Get reference output canvas_left1,joint_list_left1 = model_processor.predict(img_left1) canvas_left2,joint_list_left2 = model_processor.predict(img_left2) canvas_right1,joint_list_right1 = model_processor.predict(img_right1) canvas_right2,joint_list_right2 = model_processor.predict(img_right2) canvas_stop,joint_list_stop = model_processor.predict(img_stop) # Get angles from reference images angle_left1=getangle(joint_list_left1) angle_left2=getangle(joint_list_left2) angle_right1=getangle(joint_list_right1) angle_right2=getangle(joint_list_right2) angle_stop=getangle(joint_list_stop) # Initialize count countleft=0 countright=0 countstop=0 ## Presenter Server Output ## chan = presenteragent.presenter_channel.open_channel(BODYPOSE_CONF) if chan == None: print("Open presenter channel failed") return predict = StateMachine() while True: ## Read one frame of the input video ## img_original = cap.read() if not img_original: print('Error: Camera read failed') break ## HEAD POSE BEGIN ## # Camera Input (YUV) to RGB Image image_byte = img_original.tobytes() image_array = np.frombuffer(image_byte, dtype=np.uint8) img_original = YUVtoRGB(image_array) img_original = cv2.flip(img_original, -1) # Make copy of image for head model processing and body model processing img_bodypose = copy.deepcopy(img_original) img_headpose = copy.deepcopy(img_original) ## Model Prediction ## # model_processor.predict: processing + model inference + postprocessing # canvas: the picture overlayed with human body joints and limbs # img_bodypose is modified with skeleton canvas, joint_list_input = model_processor.predict(img_bodypose) angle_input=getangle(joint_list_input) dif5=abs(angle_input-angle_left1) dif6=abs(angle_input-angle_left2) dif7=abs(angle_input-angle_right1) dif8=abs(angle_input-angle_right2) dif9=abs(angle_input-angle_stop) result = "invalid" # last_five_result = "invalid" if all( i < 25 for i in dif5): result = "left1" elif all( i < 25 for i in dif6): result = "left2" elif all( i < 25 for i in dif7): result = "right1" elif all( i < 25 for i in dif8): result = "right2" elif all( i < 25 for i in dif9): result = "stop" font = cv2.FONT_HERSHEY_SIMPLEX bottomLeftCornerOfText = (10, 100) fontScale = 1 fontColor = (255,255,255) lineType = 2 cv2.putText(img_bodypose, result, bottomLeftCornerOfText, font, fontScale, fontColor, lineType) ## FACE DETECTION MODEL BEGIN ## input_image = PreProcessing_face(img_headpose) face_flag = False try: resultList_face = model_face.execute([input_image]).copy() # draw bounding box on img_bodypose xmin, ymin, xmax, ymax = PostProcessing_face(img_bodypose, resultList_face) bbox_list = [xmin, ymin, xmax, ymax] face_flag = True except: print('No face detected') # FACE DETECTION MODEL END ## ## HEADPOSE BEGIN ## head_status_string = "No output" if face_flag is True: input_image = PreProcessing_head(img_headpose, bbox_list) try: resultList_head = model_head_pose.execute([input_image]).copy() except Exception as e: print('No head pose estimation output') # draw headpose points on image facepointList, head_status_string, canvas = PostProcessing_head(resultList_head, bbox_list, img_bodypose) print('Headpose:', head_status_string) headpose_result = head_status_string ## HEADPOSE END ## predict.staterunner(result,headpose_result) ## Present Result ## # convert to jpeg image for presenter server display _,jpeg_image = cv2.imencode('.jpg', img_bodypose) # construct AclImage object for presenter server jpeg_image = AclImage(jpeg_image, img_original.shape[0], img_original.shape[1], jpeg_image.size) # send to presenter server chan.send_detection_data(img_original.shape[0], img_original.shape[1], jpeg_image, []) cap.release()
def main(): if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) if not os.path.exists(OUTPUT_TXT_DIR): os.mkdir(OUTPUT_TXT_DIR) #acl资源初始化 acl_resource = AclResource() acl_resource.init() #加载模型 model = Model(acl_resource, MODEL_PATH) src_dir = os.listdir(INPUT_DIR) print("src_dir = ", src_dir) #从data目录逐张读取图片进行推理 t_pre = 0 t_for = 0 t_post = 0 for pic in src_dir: #读取图片 pic_path = os.path.join(INPUT_DIR, pic) bgr_img = cv.imread(pic_path) #预处理 t1 = time.time() #data, w, h= preprocess(pic_path) data, w, h = preprocess_cv2(bgr_img) t2 = time.time() t_pre += (t2-t1) #送进模型推理 result_list = model.execute([data,]) t3 = time.time() t_for += (t3-t2) #处理推理结果 result_return = post_process(result_list, w, h) t4 = time.time() t_post += (t4-t3) print("result = ", result_return) print("preprocess cost:", t2-t1) print("forward cost:", t3-t2) print("proprocess cost:", t4-t3) for i in range(len(result_return['detection_classes'])): box = result_return['detection_boxes'][i] class_name = result_return['detection_classes'][i] confidence = result_return['detection_scores'][i] cv.rectangle(bgr_img, (int(box[1]), int(box[0])), (int(box[3]), int(box[2])), colors[i%6], 2) p3 = (max(int(box[1]), 15), max(int(box[0]), 15)) out_label = class_name cv.putText(bgr_img, out_label, p3, cv.FONT_ITALIC, 0.6, colors[i%6], 1) output_file = os.path.join(OUTPUT_DIR, "out_" + pic) print("output:%s" % output_file) cv.imwrite(output_file, bgr_img) pic_name = pic.split('.')[0] predict_result_path = os.path.join(OUTPUT_TXT_DIR, str(pic_name)+'.txt') with open(predict_result_path, 'w') as f: for i in range(len(result_return['detection_classes'])): box = result_return['detection_boxes'][i] class_name = result_return['detection_classes'][i] confidence = result_return['detection_scores'][i] box = list(map(int, box)) box = list(map(str, box)) confidence = '%.4f' % confidence bbox_mess = ' '.join([class_name, confidence, box[1], box[0], box[3], box[2]]) + '\n' f.write(bbox_mess) num = len(src_dir) print("avg preprocess cost:", t_pre/num) print("avg forward cost:", t_for/num) print("avg proprocess cost:", t_post/num) total = t_pre/num + t_for/num + t_post/num print("avg total cost:", total) print("avg FPS:", 1/(total)) print("Execute end")