def predetect(idcardcls, idcardfront, idcardback, batch_size, req): _t1 = time.time() # loading image img = load_image(req["data"]["uri"], body=req['data']['body']) _t2 = time.time() CTX.logger.info("inference :: cost for loading image: %f", _t2 - _t1) # classify idcard cls = idcardcls.run(img) _t3 = time.time() CTX.logger.info("inference :: cost for loading image: %f", _t3 - _t2) # preprocess for adjust idcard # 0: front side; 1: back side; if (cls == 0): alignedImg, names, regions, boxes = idcardfront.predet(img) else: alignedImg, names, regions, boxes = idcardback.predet(img) _t4 = time.time() CTX.logger.info("inference :: cost for image preprocessing: %f", _t4 - _t3) return { "class": cls, "alignedImg": base64.b64encode(cv2.imencode('.jpg', alignedImg)[1]), "names": names, "regions": regions, "bboxes": boxes }
def prerecog(handler, batch_size, req): _t1 = time.time() # loading image img = load_image(req["data"]["uri"], body=req['data']['body']) _t2 = time.time() CTX.logger.info("inference :: cost for loading image: %f", _t2 - _t1) CTX.logger.info("input names: %s", req["params"]["names"]) names = map(lambda name: name.encode('utf8'), req["params"]["names"]) detboxes = req["params"]["detectedBoxes"] if len(detboxes[0]) == 8: # transform from [x0,y0,x1,y1,x2,y2,x3,y3] to [[x0,y0],[x1,y1],[x2,y2],[x3,y3]] detboxes = list( map( lambda x: [[x[0], x[1]], [x[2], x[3]], [x[4], x[5]], [x[6], x[7]]], detboxes)) bboxes = handler.prerecog(detboxes, img, names, req["params"]["regions"], req["params"]["bboxes"]) _t3 = time.time() CTX.logger.info("inference :: cost for image pre-recognize process: %f", _t3 - _t2) return {"bboxes": bboxes}
def pre_eval(net, batch_size, reqs): ''' prepare net forward data Parameters ---------- net: net created by net_init reqs: parsed reqs from net_inference reqid: reqid from net_inference Return ---------- code: error code, int message: error message, string ''' cur_batchsize = len(reqs) if cur_batchsize > batch_size: for i in range(cur_batchsize): raise ErrorOutOfBatchSize(batch_size) image_shape_list_h_w = [] images = [] _t1 = time.time() for i in range(cur_batchsize): img = load_image(reqs[i]["data"]["uri"]) height, width, _ = img.shape if height <= 32 or width <= 32: raise ErrorBase( 400, "image too small " + str(height) + "x" + str(width)) if img.ndim != 3: raise ErrorBase(400, "image ndim is " + str(img.ndim) + ", should be 3") image_shape_list_h_w.append([height, width]) images.append(preProcessImage(oriImage=img)) _t2 = time.time() CTX.logger.info("read image and transform: %f\n", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return image_shape_list_h_w, images
def net_inference(model, reqs): CTX.logger.info("inference begin...") # datas = json.loads(args) predictor = model['predictor'] classes_dict = model['labels']['class'] # threshold uses for default threshold_dict = model['labels']['minMt'] # minModelThreshold rets = [] nms = py_nms_wrapper(config.TEST.NMS) box_voting = py_box_voting_wrapper(config.TEST.BOX_VOTING_IOU_THRESH, config.TEST.BOX_VOTING_SCORE_THRESH, with_nms=True) try: for data in reqs: try: im = load_image(data['data']['uri'], body=data['data']['body']) except ErrorBase as e: rets.append({"code":e.code, "message": e.message, "result": None}) continue # return [], 400, 'load image error' if im.shape[0] > im.shape[1]: long_side, short_side = im.shape[0], im.shape[1] else: long_side, short_side = im.shape[1], im.shape[0] if short_side > 0 and float(long_side)/float(short_side) > 50.0: msg = "aspect ration is too large, long_size:short_side should not larger than 50.0" # raise ErrorBase.__init__(400, msg) rets.append({"code": 400, "message": msg, "result": None}) continue data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale, config) det_ret = [] # labels.csv file not include background for cls_index in sorted(classes_dict.keys()): cls_ind = cls_index cls_name = classes_dict.get(cls_ind) cls_boxes = boxes[0][:, 4:8] if config.CLASS_AGNOSTIC else boxes[0][:, 4 * cls_ind:4 *4 * (cls_ind + 1)] cls_scores = scores[0][:, cls_ind, np.newaxis] threshold = float(threshold_dict[cls_ind]) keep = np.where(cls_scores > threshold)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) det_ret.extend(_build_result(det, cls_name, cls_ind, model['labels']) for det in dets[keep, :]) # get review value rets.append(dict(code=0,message='',result=dict(detections=det_ret))) except Exception as e: # print(traceback.format_exc()) CTX.logger.info("inference error:%s"%(traceback.format_exc())) return [], 599, str(e) return rets, 0, ''
def pre_eval(net, batch_size, reqs): ''' prepare net forward data Parameters ---------- net: net created by net_init reqs: parsed reqs from net_inference reqid: reqid from net_inference Return ---------- code: error code, int message: error message, string ''' cur_batchsize = len(reqs) CTX.logger.info("cur_batchsize: %d\n", cur_batchsize) if cur_batchsize > batch_size: for i in range(cur_batchsize): raise ErrorOutOfBatchSize(batch_size) images = [] _t1 = time.time() for i in range(cur_batchsize): data = reqs[i] img = load_image(data["data"]["uri"], body=data['data']['body']) if img is None: CTX.logger.info("input data is none : %s\n", data) raise ErrorBase(400, "image data is None ") if img.ndim != 3: raise ErrorBase(400, "image ndim is " + str(img.ndim) + ", should be 3") images.append(preProcessImage(img)) _t2 = time.time() CTX.logger.info("read image and transform: %f\n", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return images
def _load_image(req, width, height, mean_value=[0.0, 0.0, 0.0], std_value=[1.0, 1.0, 1.0]): try: img = load_image(req["uri"], body=req['body']) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) if img is None: return None, {"code": 400, "message": "cv2 load image failed"} # convert into format (batch, RGB, width, height) img = img.astype(float) img = cv2.resize(img, (width, height)) img -= mean_value img /= std_value img = np.swapaxes(img, 0, 2) img = np.swapaxes(img, 1, 2) return img, None except Exception as _e: logger.error("_load_image error: %s", traceback.format_exc(), extra={"reqid": ""}) if isinstance(_e, ErrorBase): return None, {"code": _e.code, "message": str(_e)} return None, {"code": 400, "message": str(_e)}
def postrecog(daikai_model, fapaiolian_model, req): img = load_image(req["data"]["uri"], body=req['data']['body']) # CTX.logger.info("load param - dict: %s", req["params"]["dict"]) # CTX.logger.info("load param - texts: %s", req["params"]["texts"]) # boxes_dict = json.loads(req["params"]["dict"]) rec_result = req["params"]["texts"] CTX.logger.info("load param - texts: %s", rec_result) _t1 = time.time() vat = ZenZhuiShui_reco() # 没法传递image_dict参数,只能新建实例然后重新生成参数 _, boxes_dict = vat.gen_img_dict(img) # vat.gen_img_dict_base(img) vat.predict_oridinary(boxes_dict, rec_result) vat.predict_other(boxes_dict, rec_result) vat.predict_XiaoShouMingXi(boxes_dict, rec_result) vat.predict_svm(daikai_model) vat.predict_FaPiaoLianCi(fapaiolian_model) vat.predict_XiaoLeiMingCheng() res = postProcess(vat.out_dict) _t2 = time.time() CTX.logger.info("post: %f", _t2 - _t1) monitor_rt_post().observe(_t2 - _t1) return res
def decodeReqsImage(reqs): """ process reqs image ---- reqs : return : imageReadInfoDict, # reqs image load info normalImageMapToOriginalImage, # normal image id map to original image id images # load image result data """ cur_batchsize = len(reqs) _t1 = time.time() imageReadInfoDict = dict() # reqs image info normalImageMapToOriginalImage = dict( ) # normal image id map to original image images = [] normalImageIndex = 0 for i in range(cur_batchsize): data = reqs[i] infoOfImage = dict() img = None try: # load image error img = load_image(data["data"]["uri"], body=data['data']['body']) if img is None: CTX.logger.info("input data is none : %s\n", data) infoOfImage['errorInfo'] = "image data is None" infoOfImage['errorCode'] = 400 infoOfImage['flag'] = 1 elif img.ndim != 3: CTX.logger.info("image ndim is " + str(img.ndim) + ", should be 3\n") infoOfImage['errorInfo'] = "image ndim is " + \ str(img.ndim) + ", should be 3" infoOfImage['errorCode'] = 400 infoOfImage['flag'] = 1 except ErrorBase as e: CTX.logger.info("image of index : %d,preProcess error: %s\n", i, str(e)) infoOfImage['errorInfo'] = str(e) infoOfImage['errorCode'] = e.code infoOfImage['flag'] = 1 # 1 is the image preprocess error if infoOfImage.get('flag', 0) == 1: # the image preProcess error imageReadInfoDict[i] = infoOfImage continue # because , some images error, so need all images's map relation . infoOfImage['flag'] = 0 # normal image preProcess infoOfImage['normalImageIndex'] = normalImageIndex # new image id map to old image id normalImageMapToOriginalImage[normalImageIndex] = i imageReadInfoDict[i] = infoOfImage normalImageIndex += 1 images.append(img) _t2 = time.time() CTX.logger.info("load images : %f\n", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return imageReadInfoDict, normalImageMapToOriginalImage, images
def _load_image(req): try: img = load_image(req["uri"], body=req['body']) except Exception as _e: logger.info("load image error:%s, trackback:%s", str(_e), traceback.format_exc(), extra={"reqid": ""}) return None, None, {"code": 400, "message": str(_e)} return img, img.shape, None
def pre_eval(net, batch_size, reqs): ''' prepare net forward data ''' imageReadInfoDict = dict() images = [] netinfeImageIdToinputImageId = dict() # net infe image id map to input image id cur_batchsize = len(reqs) CTX.logger.info("cur_batchsize: %d\n", cur_batchsize) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) # image_shape_list_h_w = [] # images = [] _t1 = time.time() normalImageIndex = 0 for i in range(cur_batchsize): data = reqs[i] infoOfImage = dict() img = None try: # load image error img = load_image(data["data"]["uri"],body=data['data']['body']) if img is None: CTX.logger.info("input data is none : %s\n", data) infoOfImage['errorInfo'] = "image data is None" infoOfImage['errorCode'] = 400 infoOfImage['flag'] = 1 elif img.ndim != 3: CTX.logger.info("image ndim is " + str(img.ndim) + ", should be 3\n") infoOfImage['errorInfo'] = "image ndim is " + \ str(img.ndim) + ", should be 3" infoOfImage['errorCode'] = 400 infoOfImage['flag'] = 1 except ErrorBase as e: CTX.logger.info("image of index : %d,preProcess error: %s\n", i,str(e)) infoOfImage['errorInfo'] = str(e) infoOfImage['errorCode'] = e.code infoOfImage['flag'] = 1 # 1 is the image preprocess error if infoOfImage.get('flag',0) == 1: # the image preProcess error imageReadInfoDict[i] = infoOfImage continue height, width, _ = img.shape infoOfImage['flag'] = 0 # normal image preProcess infoOfImage['height'] = height infoOfImage['width'] = width infoOfImage['normalImageIndex'] = normalImageIndex # because , some images error, so need all images's map relation . netinfeImageIdToinputImageId[normalImageIndex] = i # new image id map to old image id imageReadInfoDict[i] = infoOfImage normalImageIndex += 1 images.append(preProcessImage(oriImage=img)) _t2 = time.time() CTX.logger.info("read image and transform: %f\n", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return imageReadInfoDict, netinfeImageIdToinputImageId, images
def detect(req): _t1 = time.time() # loading image img = load_image(req["data"]["uri"], body=req['data']['body']) _t2 = time.time() CTX.logger.info("inference :: cost for loading image: %f", _t2 - _t1) _t3 = time.time() vat = ZenZhuiShui_reco() # create new instance rect_boxes, boxes_dict = vat.gen_img_dict(img) _t4 = time.time() CTX.logger.info("forward: %f", _t4 - _t3) monitor_rt_forward().observe(_t4 - _t1) return {"bboxes": rect_boxes, "dict": boxes_dict}
def net_inference(model, reqs): ''' net inference ''' CTX.logger.debug("enter net_inference") handler = model['net'] rets = [] _t1 = time.time() try: for data in reqs: CTX.logger.debug("data:%s", data) img = data["data"]["uri"] im = load_image(data["data"]["uri"], data['data']['body']) if im is None: CTX.logger.debug("read image failed, path:%s", data['data']['uri']) rets.append({"code": 400, "message": "read image failed"}) continue feature = handler.ext_process([im]) if feature is None or len(feature) == 0: rets.append({ "code": 400, "message": "failed to get features of the image" }) continue CTX.logger.info("feature length info:" + str(len(feature)) + "len(feature[0]): " + str(len(feature[0]))) stream = struct.pack('>' + str(len(feature[0])) + 'f', *feature[0]) #CTX.logger.error("struct.unpack info:" + ">" +str(len(stream) / 4) + "f") #hash_sha1 = hashlib.sha1() #hash_sha1.update(stream) #feature_file_name = os.path.join("/tmp/eval/", hash_sha1.hexdigest()) #file = open(feature_file_name, "wb") #file.write(stream) #file.close() #rets.append({"code": 0, "message": "", "result_file": str(feature_file_name)}) rets.append({"code": 0, "message": "", "body": stream}) except Exception as e: CTX.logger.error("inference error:%s", traceback.format_exc()) return [], 599, str(e) _t2 = time.time() monitor_rt_forward().observe(_t2 - _t1) CTX.logger.debug("rets:%s", rets) return rets, 0, ''
def net_inference(model, reqs): ''' net inference ''' CTX.logger.debug("enter net_inference") handler = model['net'] rets = [] _t1 = time.time() try: for data in reqs: CTX.logger.debug("data:%s", data) img = data["data"]["uri"] if data['data']['body'] is not None: hash_sha1 = hashlib.sha1() hash_sha1.update(str(data['data']['body'])) img = os.path.join("/tmp", hash_sha1.hexdigest()) file = open(img, "wb") file.write(data['data']['body']) file.close() im = load_image(img) if im is None: CTX.logger.debug("read image failed, path:%s", data['data']['uri']) rets.append({"code": 400, "message": "read image failed"}) continue ret = handler.recognize(im) if ret["status"] == -1: rets.append({ "code": 400, "message": "no valid id info obtained" }) continue rets.append(dict(code=0, message='', result=ret['id_res'])) if data['data']['body'] is not None and os.path.exists(img): os.remove(img) except Exception as e: if data['data']['body'] is not None and os.path.exists(img): os.remove(img) CTX.logger.error("inference error:%s", traceback.format_exc()) return [], 599, str(e) _t2 = time.time() monitor_rt_forward().observe(_t2 - _t1) CTX.logger.debug("rets:%s", rets) return rets, 0, ''
def pre_eval(net, batch_size, reqs): ''' prepare net forward data Parameters ---------- net: net created by net_init reqs: parsed reqs from net_inference reqid: reqid from net_inference Return ---------- code: error code, int message: error message, string ''' cur_batchsize = len(reqs) CTX.logger.info("cur_batchsize: %d\n", cur_batchsize) if cur_batchsize > batch_size: for i in range(cur_batchsize): raise ErrorOutOfBatchSize(batch_size) image_shape_list_h_w = [] images = [] _t1 = time.time() for i in range(cur_batchsize): data = reqs[i] image_path = data["data"]["uri"] if data['data']['body'] is not None: print("body") hash_sha1 = hashlib.sha1() hash_sha1.update(str(data['data']['body'])) image_path = os.path.join("/tmp", hash_sha1.hexdigest()) file = open(image_path, "wb") file.write(data['data']['body']) file.close() img = load_image(image_path) if img is None: CTX.logger.info("input data is none : %s\n", reqs[i]) raise ErrorBase(400, "image data is None ") height, width, _ = img.shape if img.ndim != 3: raise ErrorBase(400, "image ndim is " + str(img.ndim) + ", should be 3") image_shape_list_h_w.append([height, width]) images.append(preProcessImage(oriImage=img)) _t2 = time.time() CTX.logger.info("read image and transform: %f\n", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return image_shape_list_h_w, images
def pre_eval(batch_size, reqs): cur_batchsize = len(reqs) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) ret = [] _t1 = time.time() for i in range(cur_batchsize): img = load_image(reqs[i]["data"]["uri"], body=reqs[i]['data']['body']) img_type = reqs[i]["data"]["attribute"].get("image_type", 0) img_name = reqs[i]["data"]["attribute"].get("name", "") video = reqs[i]["data"]["attribute"].get("video", False) lane_pts = reqs[i]["data"]["attribute"].get("lane_pts") ret.append((img, img_type, video, img_name, lane_pts)) _t2 = time.time() CTX.logger.info("load: %f", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return ret
def pre_eval(batch_size, reqs): cur_batchsize = len(reqs) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) ret = [] _t1 = time.time() for i in range(cur_batchsize): img = load_image(reqs[i]["data"]["uri"], body=reqs[i]['data']['body']) ret.append((img)) _t2 = time.time() CTX.logger.info("load: %f", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return ret
def pre_eval(batch_size, reqs): cur_batchsize = len(reqs) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) ret = [] _t1 = time.time() for req in reqs: img = load_image(req["data"]["uri"], body=req['data']['body']) bboxes = req["params"]["bboxes"] if len(bboxes[0]) == 8: # transform from [x0,y0,x1,y1,x2,y2,x3,y3] to [[x0,y0],[x1,y1],[x2,y2],[x3,y3]] bboxes = list(map(lambda x:[[x[0],x[1]],[x[2],x[3]],[x[4],x[5]],[x[6],x[7]]],bboxes)) ret.append((img, bboxes)) _t2 = time.time() CTX.logger.info("image load cost: %f", _t2 - _t1) # monitor_rt_load().observe(_t2 - _t1) return ret
def pre_eval(batch_size, reqs): cur_batchsize = len(reqs) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) ret = [] _t1 = time.time() for i in range(cur_batchsize): img = load_image(reqs[i]["data"]["uri"], body=reqs[i]['data']['body']) if img.shape[2] == 4: img = img[:, :, :3] #print(img.shape) ret.append((img)) _t2 = time.time() CTX.logger.info("load: %f", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) #print("ret:"+str(ret[0])) #print("ret_size:"+str(ret[0].shape)) return ret
def net_inference(model, reqs): text_classify = model['text_classify'] batch_size = model['batch_size'] threshold = model['threshold'] CTX.logger.info("inference begin ...") CTX.logger.info("requests: %s", reqs) try: ret = [] for i in range(len(reqs)): img = load_image(reqs[i]["data"]["uri"], body=reqs[i]['data']['body']) resp = process_image_fun(text_classify, img, threshold) ret.append(resp) except ErrorBase as e: return [], e.code, str(e) except Exception as e: CTX.logger.error("inference error: %s", traceback.format_exc()) return [], 599, str(e) return ret, 0, ''
def pre_eval(batch_size, reqs): cur_batchsize = len(reqs) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) ret = [] _t1 = time.time() for req in reqs: img = load_image(req["data"]["uri"], body=req['data']['body']) detections = req["data"]["attribute"]["detections"] pts_arr = [] for det in detections: pts_arr.append(det["pts"]) ret.append((img, pts_arr)) _t2 = time.time() CTX.logger.info("load: %f", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return ret
def net_inference(model): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :return: None """ # datas = json.loads(args) predictor = model['predictor'] classes = model['classes'] threshold = model['threshold'] thresholds = model['thresholds'] rets = [] nms = py_nms_wrapper(config.TEST.NMS) box_voting = py_box_voting_wrapper(config.TEST.BOX_VOTING_IOU_THRESH, config.TEST.BOX_VOTING_SCORE_THRESH, with_nms=True) try: time_str = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) fileOp = "/tmp/eval/init/20170930_guns_1083-begin-" + time_str + '.csv' fileOp_op = open(fileOp, 'w') time_str = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) fileOp_1 = "/tmp/eval/init/20170930_guns_1083-end-" + time_str + '.csv' fileOp_1_op = open(fileOp_1, 'w') fileOp_2 = "/tmp/eval/init/20170930_guns_1083-image-" + time_str + '.jpg' for i in sorted(os.listdir("/tmp/eval/init/images")): imageFile = os.path.join("/tmp/eval/init/images", i) try: im = load_image(imageFile, 50.0) # cv2.imwrite('fileOp_2', im) print(im[0, :]) # np.savetxt(fileOp_2, im, delimiter=",") except ErrorBase as e: rets.append({"code": e.code, "message": e.message}) continue data_batch, data_names, im_scale = generate_batch(im) print("*" * 100) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale, config) det_ret = [] for cls_index, cls in enumerate(classes[1:], start=1): if len(cls) > 1: cls_ind = int(cls[0]) cls_name = cls[1] else: cls_ind = cls_index cls_name = cls[0] cls_boxes = boxes[0][:, 4:8] if config.CLASS_AGNOSTIC else boxes[ 0][:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[0][:, cls_ind, np.newaxis] if len(classes) <= len(thresholds): threshold = thresholds[cls_ind] keep = np.where(cls_scores >= threshold)[0] dets = np.hstack( (cls_boxes, cls_scores)).astype(np.float32)[keep, :] if "20170930_guns_1083.jpg" in imageFile: # print(dets) # print('*'*100) # for i in dets: # fileOp_op.write(i) # fileOp_op.write('\n') np.savetxt(fileOp, dets, delimiter=",") pass keep = nms(dets) if "20170930_guns_1083.jpg" in imageFile: # print("end"*10) # print(dets[keep, :]) # print('*'*100) # for i in dets: # fileOp_1_op.write(i) # fileOp_1_op.write('\n') np.savetxt(fileOp_1, dets[keep, :], delimiter=",") det_ret.extend( _build_result(det, cls_name, cls_ind) for det in dets[keep, :]) rets.append( dict(code=0, message=imageFile, result=json.dumps(dict(detections=det_ret)))) except Exception, e: print(traceback.format_exc())
def pre_eval(model, reqs): CTX.logger.info("---> Inference pre_eval() begin ...\n") # feature_extractor = model["feature_extractor"] face_aligner = model["face_aligner"] batch_size = model["batch_size"] output_square = model["input_height"] == model["input_width"] cur_batchsize = len(reqs) if cur_batchsize > batch_size: raise ErrorOutOfBatchSize(batch_size) face_chips = [] _t1 = time.time() for i in range(cur_batchsize): # print reqs[i] CTX.logger.info('---> req[%d] image uri: %s', i, reqs[i]["data"]["uri"]) check_req_data_body(reqs[i]) img = load_image(reqs[i]["data"]["uri"], body=reqs[i]["data"]["body"]) CTX.logger.info('---> req[%d] image shape: %s', i, str(img.shape)) landmarks = None pts = None try: if "attribute" in reqs[i]["data"]: if "landmarks" in reqs[i]["data"]["attribute"]: landmarks = reqs[i]["data"]["attribute"]["landmarks"] CTX.logger.info('---> req[%d] face landmarks: %s', i, str(landmarks)) checked_landmarks = check_landmarks(landmarks) _faces = face_aligner.get_face_chips( img, [], [checked_landmarks], output_square=output_square) face_chips.extend(_faces) elif "pts" in reqs[i]["data"]["attribute"]: pts = reqs[i]["data"]["attribute"]["pts"] roi_scale = model["roi_scale"] if "params" in reqs[i] and "roi_scale" in reqs[i]["params"]: roi_scale = reqs[i]["params"]["roi_scale"] CTX.logger.info('---> req[%d] roi_scale: %s', i, str(roi_scale)) checked_pts = check_bbox(pts, roi_scale) CTX.logger.info('---> req[%d] face bbox pts: %s', i, str(pts)) CTX.logger.info('---> req[%d] checked face bbox pts: %s', i, str(checked_pts)) _faces = face_aligner.get_face_chips( img, [checked_pts], output_square=output_square) face_chips.extend(_faces) except Exception as e: CTX.logger.error("Error when align and crop face: %s\n", traceback.format_exc()) raise Exception("Error align and crop face") if landmarks is None and pts is None: if (img.shape[0] == model["input_height"] and img.shape[1] == model["input_width"]): face_chips.append(img) else: raise ErrorNoPTS(reqs[i]["data"]["uri"]) # if pts is None: # # if img.shape[0] != model["input_height"] or img.shape[1] != model["input_width"]: # # img = cv2.resize( # # img, (model["input_width"], model["input_height"])) # # face_chips.append(img) # face_chips.append(img) # else: # _faces = face_aligner.get_face_chips( # img, [pts], output_square=output_square) # face_chips.extend(_faces) # for i, chip in enumerate(face_chips): # print "face chip #%d, shape: %s" % (i, str(chip.shape)) # win_name = "face_%d" % i # cv2.imshow(win_name, chip) # cv2.waitKey(0) # cv2.destroyAllWindows() _t2 = time.time() CTX.logger.info( "===> Pre-eval Time (loading images and aligning faces): %f\n", _t2 - _t1) monitor_rt_load().observe(_t2 - _t1) return face_chips