def crop_and_paste_get_roi(self, image, width, height, crop_and_paste_width, crop_and_paste_height): """ :image: input image :width: input image width :height: input image height :crop_and_paste_width: crop_and_paste_width :crop_and_paste_height: crop_and_paste_height :return: return AclImage """ print('[Dvpp] vpc crop and paste stage:') input_desc = self._gen_input_pic_desc(image) stride_width = utils.align_up16(crop_and_paste_width) stride_height = utils.align_up2(crop_and_paste_height) out_buffer_size = utils.yuv420sp_size(stride_width, stride_height) out_buffer, ret = acl.media.dvpp_malloc(out_buffer_size) output_desc = \ self._gen_output_pic_desc(crop_and_paste_width, crop_and_paste_height, out_buffer, out_buffer_size) self._crop_config = acl.media.dvpp_create_roi_config( 0, (width >> 1 << 1) - 1, 0, (height >> 1 << 1) - 1) self._paste_config = acl.media.dvpp_create_roi_config( 0, crop_and_paste_width - 1, 0, crop_and_paste_height - 1) ret = acl.media.dvpp_vpc_crop_and_paste_async(self._dvpp_channel_desc, input_desc, output_desc, self._crop_config, self._paste_config, self._stream) utils.check_ret("acl.media.dvpp_vpc_crop_and_paste_async", ret) ret = acl.rt.synchronize_stream(self._stream) utils.check_ret("acl.rt.synchronize_stream", ret) print('[Dvpp] vpc crop and paste stage success') stride_width = utils.align_up16(crop_and_paste_width) stride_height = utils.align_up2(crop_and_paste_height) return AclImage(out_buffer, stride_width, stride_height, out_buffer_size, constants.MEMORY_DVPP)
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(): if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() model = Model(MODEL_PATH) dvpp = Dvpp(acl_resource) 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 ] #Create a directory to store the inference results if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")): os.mkdir(os.path.join(SRC_PATH, "../outputs")) image_info = construct_image_info() for image_file in images_list: image = AclImage(image_file) resized_image = pre_process(image, dvpp) print("pre process end") result = model.execute([ resized_image, ]) post_process(result, image_file) print("process " + image_file + " end")
def jpegd(self, image): """ jepg image to yuv image """ # Create conversion output image desc output_desc, out_buffer = self._gen_jpegd_out_pic_desc(image) ret = acl.media.dvpp_jpeg_decode_async(self._dvpp_channel_desc, image.data(), image.size, output_desc, self._stream) if ret != constants.ACL_ERROR_NONE: log_error("dvpp_jpeg_decode_async failed ret={}".format(ret)) return None ret = acl.rt.synchronize_stream(self._stream) if ret != constants.ACL_ERROR_NONE: log_error("dvpp_jpeg_decode_async failed ret={}".format(ret)) return None # Return the decoded AclImage instance stride_width = utils.align_up128(image.width) stride_height = utils.align_up16(image.height) stride_size = utils.yuv420sp_size(stride_width, stride_height) return AclImage(out_buffer, stride_width, stride_height, stride_size, constants.MEMORY_DVPP)
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() model = Model(MODEL_PATH) dvpp = Dvpp(acl_resource) #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 const.IMG_EXT] #Create a directory to store the inference results if not os.path.isdir('../outputs'): os.mkdir('../outputs') image_info = construct_image_info() for image_file in images_list: #read picture image = AclImage(image_file) #preprocess image resized_image = pre_process(image, dvpp) print("pre process end") #reason pictures result = model.execute([resized_image, image_info]) #process resresults post_process(result, image, image_file)
def crop_and_paste( self, image, width, height, crop_and_paste_width, crop_and_paste_height): """ crop_and_paste """ print('[Dvpp] vpc crop and paste stage:') input_desc = self._gen_input_pic_desc(image) stride_width = utils.align_up16(crop_and_paste_width) stride_height = utils.align_up2(crop_and_paste_height) out_buffer_size = utils.yuv420sp_size(stride_width, stride_height) out_buffer, ret = acl.media.dvpp_malloc(out_buffer_size) output_desc = self._gen_output_pic_desc( crop_and_paste_width, crop_and_paste_height, out_buffer, out_buffer_size) self._crop_config = acl.media.dvpp_create_roi_config( 0, (width >> 1 << 1) - 1, 0, (height >> 1 << 1) - 1) # set crop area: rx = float(width) / float(crop_and_paste_width) ry = float(height) / float(crop_and_paste_height) if rx > ry: dx = 0 r = rx dy = int((crop_and_paste_height - height / r) / 2) else: dy = 0 r = ry dx = int((crop_and_paste_width - width / r) / 2) pasteRightOffset = int(crop_and_paste_width - 2 * dx) pasteBottomOffset = int(crop_and_paste_height - 2 * dy) if (pasteRightOffset % 2) == 0: pasteRightOffset = pasteRightOffset - 1 if (pasteBottomOffset % 2) == 0: pasteBottomOffset = pasteBottomOffset - 1 self._paste_config = acl.media.dvpp_create_roi_config( 0, pasteRightOffset, 0, pasteBottomOffset) ret = acl.media.dvpp_vpc_crop_and_paste_async(self._dvpp_channel_desc, input_desc, output_desc, self._crop_config, self._paste_config, self._stream) utils.check_ret("acl.media.dvpp_vpc_crop_and_paste_async", ret) ret = acl.rt.synchronize_stream(self._stream) utils.check_ret("acl.rt.synchronize_stream", ret) print('[Dvpp] vpc crop and paste stage success') stride_width = crop_and_paste_width - 2 * dx stride_height = crop_and_paste_height - 2 * dy #stride_width = utils.align_up16(crop_and_paste_width) #stride_height = utils.align_up2(crop_and_paste_height) return AclImage(out_buffer, stride_width, stride_height, out_buffer_size, constants.MEMORY_DVPP)
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 read(self): """Read frame from camera""" frame_data = CameraOutputC() ret = libatlas.ReadCameraFrame(self._id, byref(frame_data)) if (ret != CAMERA_OK): log_error("Read camera %d failed" % (self._id)) return None return AclImage(addressof(frame_data.data.contents), self._width, self._height, self._size, const.MEMORY_DVPP)
def _get_pic_desc_data(self, pic_desc, user_data): pic_data = acl.media.dvpp_get_pic_desc_data(pic_desc) pic_data_size = acl.media.dvpp_get_pic_desc_size(pic_desc) ret_code = acl.media.dvpp_get_pic_desc_ret_code(pic_desc) if ret_code: channel_id, frame_id = user_data acl_log.log_error("Decode channel %d frame %d failed, error %d" % (channel_id, frame_id, ret_code)) acl.media.dvpp_free(pic_data) else: image = AclImage(pic_data, self._width, self._height, pic_data_size, const.MEMORY_DVPP) self._frame_queue.put(image) acl.media.dvpp_destroy_pic_desc(pic_desc)
def jpegd(self, image): #jepg图片转yuv图片 #创建转换输出图片desc output_desc, out_buffer = self._gen_jpegd_out_pic_desc(image) ret = acl.media.dvpp_jpeg_decode_async(self._dvpp_channel_desc, image.data(), image.size, output_desc, self._stream) if ret != ACL_ERROR_NONE: print("dvpp_jpeg_decode_async failed ret={}".format(ret)) return None ret = acl.rt.synchronize_stream(self._stream) if ret != ACL_ERROR_NONE: print("dvpp_jpeg_decode_async failed ret={}".format(ret)) return None width, height, size = self._stride_yuv_size(image.width, image.height) return AclImage(out_buffer, width, height, size)
def resize(self, image, resize_width, resize_height): """ Scale yuvsp420 picture to specified size """ # Generate input picture desc input_desc = self._gen_input_pic_desc(image) # Calculate the image size after scaling stride_width = utils.align_up16(resize_width) stride_height = utils.align_up2(resize_height) output_size = utils.yuv420sp_size(stride_width, stride_height) # Request memory for the zoomed picture out_buffer, ret = acl.media.dvpp_malloc(output_size) if ret != constants.ACL_ERROR_NONE: log_error("Dvpp malloc failed, error: ", ret) return None # Create output image output_desc = self._gen_output_pic_desc(resize_width, resize_height, out_buffer, output_size) if output_desc is None: log_error("Gen resize output desc failed") return None # Call dvpp asynchronous zoom interface to zoom pictures ret = acl.media.dvpp_vpc_resize_async(self._dvpp_channel_desc, input_desc, output_desc, self._resize_config, self._stream) if ret != constants.ACL_ERROR_NONE: log_error("Vpc resize async failed, error: ", ret) return None # Wait for the zoom operation to complete ret = acl.rt.synchronize_stream(self._stream) if ret != constants.ACL_ERROR_NONE: log_error("Resize synchronize stream failed, error: ", ret) return None # Release the resources requested for scaling acl.media.dvpp_destroy_pic_desc(input_desc) acl.media.dvpp_destroy_pic_desc(output_desc) return AclImage(out_buffer, stride_width, stride_height, output_size, constants.MEMORY_DVPP)
def main(): # check param if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) # get all pictures 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 ] acl_resource = AclResource() acl_resource.init() # instantiation Cartoonization object cartoonization = Cartoonization(MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) # init ret = cartoonization.init() utils.check_ret("Cartoonization.init ", ret) # create dir to save result if not os.path.isdir('../outputs'): os.mkdir('../outputs') for image_file in images_list: # read image image = AclImage(image_file) # preprocess crop_and_paste_image = cartoonization.pre_process(image) print("[Sample] pre process end") # inference result = cartoonization.inference([ crop_and_paste_image, ]) # postprocess cartoonization.post_process(result, image_file, image)
def jpege(self, image): """ Convert yuv420sp pictures to jpeg pictures """ # create input image input_desc = self._gen_input_pic_desc(image) # Predict the memory size required for conversion output_size, ret = acl.media.dvpp_jpeg_predict_enc_size( input_desc, self._jpege_config) if (ret != constants.ACL_ERROR_NONE): log_error("Predict jpege output size failed") return None # Request memory required for conversion output_buffer, ret = acl.media.dvpp_malloc(output_size) if (ret != constants.ACL_ERROR_NONE): log_error("Malloc jpege output memory failed") return None output_size_array = np.array([output_size], dtype=np.int32) output_size_ptr = acl.util.numpy_to_ptr(output_size_array) # Call jpege asynchronous interface to convert pictures ret = acl.media.dvpp_jpeg_encode_async(self._dvpp_channel_desc, input_desc, output_buffer, output_size_ptr, self._jpege_config, self._stream) if (ret != constants.ACL_ERROR_NONE): log_error("Jpege failed, ret ", ret) return None # Wait for the conversion to complete ret = acl.rt.synchronize_stream(self._stream) if (ret != constants.ACL_ERROR_NONE): print("Jpege synchronize stream, failed, ret ", ret) return None # Release resources acl.media.dvpp_destroy_pic_desc(input_desc) return AclImage( output_buffer, image.width, image.height, int( output_size_array[0]), constants.MEMORY_DVPP)
def resize(self, image, resize_width, resize_height): # resize yuvsp420 image to specified size # generate input image desc input_desc = self._gen_input_pic_desc(image) # calculate resized image size stride_width = align_up16(resize_width) stride_height = align_up2(resize_height) output_size = yuv420sp_size(stride_width, stride_height) # allocate memory for resized image out_buffer, ret = acl.media.dvpp_malloc(output_size) if ret != ACL_ERROR_NONE: print("Dvpp malloc failed, error: ", ret) return None #create output desc output_desc = self._gen_output_pic_desc(resize_width, resize_height, out_buffer, output_size) if output_desc == None: print("Gen resize output desc failed") return None # call DVPP asynchronous resize interface to resize image ret = acl.media.dvpp_vpc_resize_async(self._dvpp_channel_desc, input_desc, output_desc, self._resize_config, self._stream) if ret != ACL_ERROR_NONE: print("Vpc resize async failed, error: ", ret) return None # wait for resize to complete ret = acl.rt.synchronize_stream(self._stream) if ret != ACL_ERROR_NONE: print("Resize synchronize stream failed, error: ", ret) return None # release allocated memory for resize acl.media.dvpp_destroy_pic_desc(input_desc) acl.media.dvpp_destroy_pic_desc(output_desc) return AclImage(out_buffer, stride_width, stride_height, output_size, MEMORY_DVPP)
def resize(self, image, resize_width, resize_height): #缩放yuvsp420图片到指定大小 #先生成输入图片desc input_desc = self._gen_input_pic_desc(image) #计算缩放后的图片尺寸 stride_width = align_up16(resize_width) stride_height = align_up2(resize_height) output_size = yuv420sp_size(stride_width, stride_height) #为缩放后的图片申请内存 out_buffer, ret = acl.media.dvpp_malloc(output_size) if ret != ACL_ERROR_NONE: print("Dvpp malloc failed, error: ", ret) return None #创建输出desc output_desc = self._gen_output_pic_desc(resize_width, resize_height, out_buffer, output_size) if output_desc == None: print("Gen resize output desc failed") return None #调用dvpp异步缩放接口缩放图片 ret = acl.media.dvpp_vpc_resize_async(self._dvpp_channel_desc, input_desc, output_desc, self._resize_config, self._stream) if ret != ACL_ERROR_NONE: print("Vpc resize async failed, error: ", ret) return None #等待缩放操作完成 ret = acl.rt.synchronize_stream(self._stream) if ret != ACL_ERROR_NONE: print("Resize synchronize stream failed, error: ", ret) return None #释放缩放申请的资源 acl.media.dvpp_destroy_pic_desc(input_desc) acl.media.dvpp_destroy_pic_desc(output_desc) return AclImage(out_buffer, stride_width, stride_height, output_size, MEMORY_DVPP)
def jpege(self, image): # convert yuv420sp image to jpeg image # create input image desc input_desc = self._gen_input_pic_desc(image) # predict memory size for conversion output_size, ret = acl.media.dvpp_jpeg_predict_enc_size( input_desc, self._jpege_config) if (ret != ACL_ERROR_NONE): print("Predict jpege output size failed") return None # allocate memory for conversion output_buffer, ret = acl.media.dvpp_malloc(output_size) if (ret != ACL_ERROR_NONE): print("Malloc jpege output memory failed") return None # output size is an parameter for both input and output, which needs to be a pointer output_size_array = np.array([output_size], dtype=np.int32) output_size_ptr = acl.util.numpy_to_ptr(output_size_array) # call jpeg asynchronous interface to convert image异步接口转换图片 ret = acl.media.dvpp_jpeg_encode_async(self._dvpp_channel_desc, input_desc, output_buffer, output_size_ptr, self._jpege_config, self._stream) if (ret != ACL_ERROR_NONE): print("Jpege failed, ret ", ret) return None # wait for conversion to complete ret = acl.rt.synchronize_stream(self._stream) if (ret != ACL_ERROR_NONE): print("Jpege synchronize stream, failed, ret ", ret) return None # release resource acl.media.dvpp_destroy_pic_desc(input_desc) return AclImage(output_buffer, image.width, image.height, int(output_size_array[0]), MEMORY_DVPP)
def jpege(self, image): #将yuv420sp图片转为jpeg图片 #创建输入图片desc input_desc = self._gen_input_pic_desc(image) #预测转换所需内存大小 output_size, ret = acl.media.dvpp_jpeg_predict_enc_size( input_desc, self._jpege_config) if (ret != ACL_ERROR_NONE): print("Predict jpege output size failed") return None #申请转换需要的内存 output_buffer, ret = acl.media.dvpp_malloc(output_size) if (ret != ACL_ERROR_NONE): print("Malloc jpege output memory failed") return None #输出大小参数为既是输入参数,也是输出参数,需要时一个指针 output_size_array = np.array([output_size], dtype=np.int32) output_size_ptr = acl.util.numpy_to_ptr(output_size_array) #调用jpege异步接口转换图片 ret = acl.media.dvpp_jpeg_encode_async(self._dvpp_channel_desc, input_desc, output_buffer, output_size_ptr, self._jpege_config, self._stream) if (ret != ACL_ERROR_NONE): print("Jpege failed, ret ", ret) return None #等待转换完成 ret = acl.rt.synchronize_stream(self._stream) if (ret != ACL_ERROR_NONE): print("Jpege synchronize stream, failed, ret ", ret) return None #释放资源 acl.media.dvpp_destroy_pic_desc(input_desc) return AclImage(output_buffer, image.width, image.height, int(output_size_array[0]), MEMORY_DVPP)
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 main(): """ main """ image_dir = os.path.join(currentPath, "data") if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) acl_resource = AclResource() acl_resource.init() classify = Classify(MODEL_PATH, MODEL_WIDTH, MODEL_HEIGHT) ret = classify.init() utils.check_ret("Classify init ", ret) 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 ] for image_file in images_list: print('=== ' + os.path.basename(image_file) + '===') # read image image = AclImage(image_file) # Preprocess the picture resized_image = classify.pre_process(image) # Inferencecd result = classify.inference([ resized_image, ]) # # Post-processing classify.post_process(result, image_file)
self.callback_run_flag = False while self._is_thread_exit == False: time.sleep(0.01) ret = acl.util.stop_thread(self._cb_thread_id) log_info("[INFO] stop_thread", ret) if __name__ == '__main__': ret = acl.init("") utils.check_ret("acl.init", ret) ret = acl.rt.set_device(DEVICE_ID) utils.check_ret("acl.rt.set_device", ret) run_mode, ret = acl.rt.get_run_mode() utils.check_ret("acl.rt.get_run_mode", ret) venc_handel = AclVenc() venc_cnt = 16 while venc_cnt: # load file image = AclImage(VENC_FILE_PATH, 1280, 720) image = image.copy_to_dvpp() venc_handel.process(image) venc_cnt -= 1 log_info("process end") venc_handel.finish() ret = acl.rt.reset_device(DEVICE_ID) utils.check_ret("acl.rt.reset_device", ret) ret = acl.finalize() utils.check_ret("acl.finalize", ret)
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()
def main(): """main""" if (len(sys.argv) != 2): print("The App arg is invalid") exit(1) acl_resource = AclResource() acl_resource.init() model = Model(MODEL_PATH) dvpp = Dvpp(acl_resource) 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 ] # Create a directory to save inference results if not os.path.isdir('./outputs'): os.mkdir('./outputs') # Create a directory to save the intermediate results of the large image detection if not os.path.isdir('./bigpic'): os.mkdir('./bigpic') # Create a directory to save the results of the big picture cropping inference outCrop = os.path.join('./bigpic', 'output') if not os.path.isdir(outCrop): os.mkdir(outCrop) # Create a directory, save the large and cropped pictures cropImg = os.path.join('./bigpic', 'cropimg') if not os.path.isdir(cropImg): os.mkdir(cropImg) image_info = construct_image_info() for image_file in images_list: imagename = get_file_name(image_file) tempfile = os.path.splitext(imagename)[0] imgdic = {} imgdic['name'] = imagename obj_res = [] img = cv2.imread(image_file, -1) (width, height, depth) = img.shape if width > 1000 and height > 1000: # Create a directory to save the divided pictures of each big picture crop_target = os.path.join(cropImg, tempfile) if not os.path.isdir(crop_target): os.mkdir(crop_target) # Create a directory to save the inference results of each large image out_target = os.path.join(outCrop, tempfile) if not os.path.isdir(out_target): os.mkdir(out_target) # Large image clipping function crop_picture(image_file, crop_target) cropimg_list = [ os.path.join(crop_target, imgs) for imgs in os.listdir(crop_target) if os.path.splitext(imgs)[1] in const.IMG_EXT ] # After the execution of the crop function is over, # the small picture after the big picture crop should be saved in a folder crop_target for cropimg_file in cropimg_list: print("the crop filename is :\t", cropimg_file) image = AclImage(cropimg_file) resized_image = pre_process(image, dvpp) result = model.execute([resized_image, image_info]) resdic = post_process_big(result, image, cropimg_file, out_target) obj_res.extend(resdic) imgdic['object_result'] = obj_res merge_picture(out_target, tempfile) # Read in the picture, if the picture size is less than 1000x1000, # it will be read in and processed normally else: print("detect the small picture") image = AclImage(image_file) resized_image = pre_process(image, dvpp) print("pre process end") result = model.execute([resized_image, image_info]) resdic = post_process(result, image, image_file) obj_res.extend(resdic) imgdic['object_result'] = obj_res
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()