def auth_request(): """ This api is used for captcha prediction with authentication :return: """ start_time = time.time() if not request.json or 'image' not in request.json: abort(400) if interface_manager.total == 0: logger.info('There is currently no model deployment and services are not available.') return json.dumps({"message": "", "success": False, "code": -999}) bytes_batch, response = ImageUtils.get_bytes_batch(request.json['image']) if not bytes_batch: logger.error('Type[{}] - Site[{}] - Response[{}] - {} ms'.format( request.json.get('model_type'), request.json.get('model_site'), response, (time.time() - start_time) * 1000) ) return json.dumps(response), 200 image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if 'model_site' in request.json: interface = interface_manager.get_by_sites(request.json['model_site'], size_string, strict=system_config.strict_sites) elif 'model_type' in request.json: interface = interface_manager.get_by_type_size(size_string, request.json['model_type']) elif 'model_name' in request.json: interface = interface_manager.get_by_name(request.json['model_name']) else: interface = interface_manager.get_by_size(size_string) split_char = request.json['split_char'] if 'split_char' in request.json else interface.model_conf.split_char if 'need_color' in request.json and request.json['need_color']: bytes_batch = [interface.separate_color(_, color_map[request.json['need_color']]) for _ in bytes_batch] image_batch, response = ImageUtils.get_image_batch(interface.model_conf, bytes_batch) if not image_batch: logger.error('[{}] - Size[{}] - Type[{}] - Site[{}] - Response[{}] - {} ms'.format( interface.name, size_string, request.json.get('model_type'), request.json.get('model_site'), response, (time.time() - start_time) * 1000) ) return json.dumps(response), 200 result = interface.predict_batch(image_batch, split_char) logger.info('[{}] - Size[{}] - Type[{}] - Site[{}] - Predict Result[{}] - {} ms'.format( interface.name, size_string, request.json.get('model_type'), request.json.get('model_site'), result, (time.time() - start_time) * 1000 )) response['message'] = result return json.dumps(response), 200
def post(self): start_time = time.time() data = self.parse_param() if 'image' not in data.keys(): raise tornado.web.HTTPError(400) # # You can separate the http service and the gRPC service like this: # response = rpc_request( # data['image'], # data['model_name'] if 'model_name' in data else '', # data['model_type'] if 'model_type' in data else '' # ) model_type = ParamUtils.filter(data.get('model_type')) model_site = ParamUtils.filter(data.get('model_site')) model_name = ParamUtils.filter(data.get('model_name')) split_char = ParamUtils.filter(data.get('split_char')) need_color = ParamUtils.filter(data.get('need_color')) bytes_batch, response = ImageUtils.get_bytes_batch(data['image']) if not bytes_batch: logger.error('Type[{}] - Site[{}] - Response[{}] - {} ms'.format( model_type, model_site, response, (time.time() - start_time) * 1000) ) return self.finish(json_encode(response)) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if 'model_site' in data: interface = interface_manager.get_by_sites(model_site, size_string) elif 'model_type' in data: interface = interface_manager.get_by_type_size(size_string, model_type) elif 'model_name' in data: interface = interface_manager.get_by_name(model_name) else: interface = interface_manager.get_by_size(size_string) split_char = split_char if 'split_char' in data else interface.model_conf.split_char image_batch, response = ImageUtils.get_image_batch(interface.model_conf, bytes_batch, color=need_color) if not image_batch: logger.error('[{}] - Size[{}] - Type[{}] - Site[{}] - Response[{}] - {} ms'.format( interface.name, size_string, model_type, model_site, response, (time.time() - start_time) * 1000) ) return self.finish(json_encode(response)) result = interface.predict_batch(image_batch, split_char) logger.info('[{}] - Size[{}] - Type[{}] - Site[{}] - Predict Result[{}] - {} ms'.format( interface.name, size_string, model_type, model_site, result, (time.time() - start_time) * 1000) ) response['message'] = result return self.write(json_encode(response))
def predict(self, request, context): start_time = time.time() bytes_batch, status = ImageUtils.get_bytes_batch(request.image) if interface_manager.total == 0: logger.info( 'There is currently no model deployment and services are not available.' ) return {"result": "", "success": False, "code": -999} if not bytes_batch: return grpc_pb2.PredictResult(result="", success=status['success'], code=status['code']) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if request.model_site: interface = interface_manager.get_by_sites(request.model_site, size_string) elif request.model_name: interface = interface_manager.get_by_name(request.model_name) elif request.model_type: interface = interface_manager.get_by_type_size( size_string, request.model_type) else: interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return {"result": "", "success": False, "code": 999} if request.need_color: bytes_batch = [ color_extract.separate_color(_, color_map[request.need_color]) for _ in bytes_batch ] image_batch, status = ImageUtils.get_image_batch( interface.model_conf, bytes_batch) if not image_batch: return grpc_pb2.PredictResult(result="", success=status['success'], code=status['code']) result = interface.predict_batch(image_batch, request.split_char) logger.info( '[{}] - Size[{}] - Type[{}] - Site[{}] - Predict Result[{}] - {} ms' .format(interface.name, size_string, request.model_type, request.model_site, result, (time.time() - start_time) * 1000)) return grpc_pb2.PredictResult(result=result, success=status['success'], code=status['code'])
def auth_request(): """ This api is used for captcha prediction with authentication :return: """ start_time = time.time() if not request.json or 'image' not in request.json: abort(400) bytes_batch, response = ImageUtils.get_bytes_batch(request.json['image']) if not bytes_batch: logger.error('Type[{}] - Site[{}] - Response[{}] - {} ms'.format( request.json.get('model_type'), request.json.get('model_site'), response, (time.time() - start_time) * 1000)) return json.dumps(response), 200 image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if 'model_site' in request.json: interface = interface_manager.get_by_sites(request.json['model_site'], size_string) elif 'model_type' in request.json: interface = interface_manager.get_by_type_size( size_string, request.json['model_type']) elif 'model_name' in request.json: interface = interface_manager.get_by_name(size_string, request.json['model_name']) else: interface = interface_manager.get_by_size(size_string) split_char = request.json[ 'split_char'] if 'split_char' in request.json else interface.model_conf.split_char image_batch, response = ImageUtils.get_image_batch(interface.model_conf, bytes_batch) if not image_batch: logger.error( '[{}] - Size[{}] - Type[{}] - Site[{}] - Response[{}] - {} ms'. format(interface.name, size_string, request.json.get('model_type'), request.json.get('model_site'), response, (time.time() - start_time) * 1000)) return json.dumps(response), 200 result = interface.predict_batch(image_batch, split_char) logger.info( '[{}] - Size[{}] - Type[{}] - Site[{}] - Predict Result[{}] - {} ms'. format(interface.name, size_string, request.json.get('model_type'), request.json.get('model_site'), result, (time.time() - start_time) * 1000)) response['message'] = result return json.dumps(response), 200
def post(self): start_time = time.time() data = self.parse_param() if 'image' not in data.keys(): raise tornado.web.HTTPError(400) model_type = ParamUtils.filter(data.get('model_type')) model_site = ParamUtils.filter(data.get('model_site')) model_name = ParamUtils.filter(data.get('model_name')) split_char = ParamUtils.filter(data.get('split_char')) need_color = ParamUtils.filter(data.get('need_color')) if interface_manager.total == 0: logger.info('There is currently no model deployment and services are not available.') return self.finish(json_encode({"message": "", "success": False, "code": -999})) bytes_batch, response = ImageUtils.get_bytes_batch(data['image']) if not bytes_batch: logger.error('[{} {}] | Type[{}] - Site[{}] - Response[{}] - {} ms'.format( self.request.remote_ip, self.request.uri, model_type, model_site, response, (time.time() - start_time) * 1000) ) return self.finish(json_encode(response)) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if 'model_site' in data and data['model_site']: interface = interface_manager.get_by_sites(model_site, size_string, strict=system_config.strict_sites) elif 'model_type' in data and data['model_type']: interface = interface_manager.get_by_type_size(size_string, model_type) elif 'model_name' in data and data['model_name']: interface = interface_manager.get_by_name(model_name) else: interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return self.finish(json_encode({"message": "", "success": False, "code": 999})) split_char = split_char if 'split_char' in data else interface.model_conf.split_char if need_color: bytes_batch = [color_extract.separate_color(_, color_map[need_color]) for _ in bytes_batch] image_batch, response = ImageUtils.get_image_batch(interface.model_conf, bytes_batch) if not image_batch: logger.error('[{} {}] | [{}] - Size[{}] - Type[{}] - Site[{}] - Response[{}] - {} ms'.format( self.request.remote_ip, self.request.uri, interface.name, size_string, model_type, model_site, response, round((time.time() - start_time) * 1000)) ) return self.finish(json_encode(response)) response['message'] = yield self.predict(interface, image_batch, split_char, size_string, model_type, model_site, start_time) return self.finish(json.dumps(response, ensure_ascii=False).replace("</", "<\\/"))
def post(self): start_time = time.time() if interface_manager.total == 0: logger.info( 'There is currently no model deployment and services are not available.' ) return self.finish( json_encode({ self.message_key: "", self.status_bool_key: False, self.status_code_key: -999 })) bytes_batch, response = self.image_utils.get_bytes_batch( self.request.body) if not bytes_batch: logger.error('Response[{}] - {} ms'.format( response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return self.finish( json_encode({ self.message_key: "", self.status_bool_key: False, self.status_code_key: 999 })) image_batch, response = ImageUtils.get_image_batch( interface.model_conf, bytes_batch, param_key=None) if not image_batch: logger.error( '[{}] | [{}] - Size[{}] - Response[{}] - {} ms'.format( self.request.remote_ip, interface.name, size_string, response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) result = interface.predict_batch(image_batch, None) logger.info('[{}] | [{}] - Size[{}] - Predict[{}] - {} ms'.format( self.request.remote_ip, interface.name, size_string, result, (time.time() - start_time) * 1000)) response[self.message_key] = result return self.write( json.dumps(response, ensure_ascii=False).replace("</", "<\\/"))
def post(self): start_time = time.time() if interface_manager.total == 0: logger.info( 'There is currently no model deployment and services are not available.' ) return self.finish( json_encode({ "message": "", "success": False, "code": -999 })) bytes_batch, response = ImageUtils.get_bytes_batch(self.request.body) if not bytes_batch: logger.error('Response[{}] - {} ms'.format( response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return self.finish( json_encode({ "message": "", "success": False, "code": 999 })) image_batch, response = ImageUtils.get_image_batch( interface.model_conf, bytes_batch) if not image_batch: logger.error('[{}] - Size[{}] - Response[{}] - {} ms'.format( interface.name, size_string, response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) result = interface.predict_batch(image_batch, None) logger.info('[{}] - Size[{}] - Predict[{}] - {} ms'.format( interface.name, size_string, result, (time.time() - start_time) * 1000)) response['message'] = result return self.write(json_encode(response))
def processFile(filePath, filename): rawFilePath = filePath print("---------开始处理: " + rawFilePath + " ---------") existingRawFileInDB = ImageUtils.getFaceInDBByRawImage(rawFilePath) if (len(existingRawFileInDB) == 0): resultData = cropFaces.cropFaces2(rawFilePath) if (resultData is not None): faceList = resultData['croppedImageList'] featureList = resultData['croppedFeatureList'] faceIndex = 0 if (len(faceList) == 0): faceId = FaceUtils.createNewFaceForPerson('', rawFilePath, Constants.PERSON_ID_UNNAMED) FaceUtils.updateFaceFeatureFile(faceId, '') else: for index in range(0, len(faceList)): faceImage = faceList[index] featureData = featureList[index] faceFileName = os.path.join(Constants.DATA_ROOT_PATH, Constants.FACE_IMG_FILE_PATH, "face_" + filename + "_" + str(faceIndex) + ".bmp") cv.imwrite(faceFileName, faceImage) faceIndex = faceIndex + 1 faceId = FaceUtils.createNewFaceForPerson(faceFileName, rawFilePath, Constants.PERSON_ID_UNNAMED) faceFeaturePath = os.path.join(Constants.DATA_ROOT_PATH, Constants.FEATURE_FILE_PATH, 'faceFeature_' + str(faceId) + '.npy') print ("开始保存feature:" + faceFeaturePath) saveFeatureData = np.array(featureData) np.save(faceFeaturePath, saveFeatureData) FaceUtils.updateFaceFeatureFile(faceId, faceFeaturePath) updateMostSimilarPerson(faceId) else: print(" " + rawFilePath + " 已处理过了") print("---------结束处理: " + rawFilePath + " ---------")
def cropFaces(imagePath): #Loading the image to be tested image_raw = ImageUtils.createImageFromPath(imagePath) #Converting to grayscale image_gray = cv.cvtColor(image_raw, cv.COLOR_BGR2GRAY) haar_cascade_face = cv.CascadeClassifier( Constants.DATA_ROOT_PATH + '/' + Constants.PROGRAM_DATA_PATH + '/' + 'haarcascade_frontalface_default.xml') faces_rects = haar_cascade_face.detectMultiScale(image_gray, scaleFactor=1.2, minNeighbors=5) # Let us print the no. of faces found print('Faces found: ', len(faces_rects)) croppedImage_list = [] for (x, y, w, h) in faces_rects: croppedImage = image_raw[y:(y + h), x:(x + w)] croppedImage_list.append(croppedImage) cv.rectangle(image_raw, (x, y), (x + w, y + h), (0, 255, 0), 2) result_data = {} result_data['croppedImageList'] = croppedImage_list result_data['imageHighlighed'] = image_raw return result_data
def LoadImage(self, request, context): g = GenerateData(request) response = Manager.LoadImage_Response() try: List = ImageUtils.LoadImage(g) except docker.errors.ImageLoadError: response.exit_code = Manager.LoadImage_Response.ExitCode.ERROR return response response.exit_code = Manager.LoadImage_Response.ExitCode.SUCCESS for image_obj in List: image = ImageUtils.GetImage(image_obj.id) image_attr = response.image_attr.add() for tag in image['RepoTags']: temp = image_attr.repoTags.add() temp = tag image_attr.created = image['Created'] image_attr.size = int(image['Size']) image_attr.author = image['Author'] return response
def BuildImage(self, request, context): response = Manager.BuildImage_Response() dockerfile = TemporaryFile() dockerfile.write(request.dockerfile) # print("-------") dockerfile.seek(0) image_obj = ImageUtils.BuildImageByFile(dockerfile, request.tag) # try: # except docker.errors.APIError: # response.exit_code = Manager.BuildImage_Response.ExitCode.ERROR # return response response.exit_code = Manager.BuildImage_Response.ExitCode.SUCCESS image = ImageUtils.GetImage(image_obj.id) response.image_attr.id = image['Id'] for tag in image['RepoTags']: response.image_attr.repoTags.append(tag) response.image_attr.created = image['Created'] response.image_attr.size = int(image['Size']) response.image_attr.author = image['Author'] return response
def predict(self, request, context): start_time = time.time() bytes_batch, status = ImageUtils.get_bytes_batch(request.image) if not bytes_batch: return grpc_pb2.PredictResult(result="", success=status['success'], code=status['code']) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if request.model_site: interface = interface_manager.get_by_sites(request.model_site, size_string) elif request.model_name: interface = interface_manager.get_by_name(request.model_name) elif request.model_type: interface = interface_manager.get_by_type_size( size_string, request.model_type) else: interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return {"result": "", "success": False, "code": 999} image_batch, status = ImageUtils.get_image_batch( interface.model_conf, bytes_batch) if not image_batch: return grpc_pb2.PredictResult(result="", success=status['success'], code=status['code']) result = interface.predict_batch(image_batch, request.split_char) logger.info( '[{}] - Size[{}] - Type[{}] - Site[{}] - Predict Result[{}] - {} ms' .format(interface.name, size_string, request.model_type, request.model_site, result, (time.time() - start_time) * 1000)) return grpc_pb2.PredictResult(result=result, success=status['success'], code=status['code'])
def PullImage(self, request, context): if request.tag == '': request.tag = 'latest' auth_config = None if request.auth_config is not None: auth_config = {} auth_config['username'] = request.auth_config.username auth_config['password'] = request.auth_config.password ImageUtils.PullImage(repository=request.repository, tag=request.tag, auth_config=auth_config) return Manager.PullImage_Response()
def ListImages(self, request, context): List = ImageUtils.ListImages() response = Manager.ListImages_Response() for image in List: attr = response.images.add() attr.id = image['Id'] for tag in image['RepoTags']: attr.repoTags.append(tag) attr.created = image['Created'] attr.size = int(image['Size']) attr.author = image['Author'] return response
def check_exit(src, limit=4): count = 0 while True: c.screenshot(tmp_file) time.sleep(1) pos = ImageUtils.find_position(tmp_file, img_path + "/" + src) count = count + 1 if pos is not None: print '[' + str(count) + ']' + str(pos) return pos elif count == limit: print '[' + str(count) + '] %s Not Found' % src return None
def cropFaces2(imagePath): #Loading the image to be tested result_data = None image_raw = ImageUtils.createImageFromPath(imagePath) # image_raw = resizeImage(image_raw) if (image_raw is not None): cloned_image = ImageUtils.cloneImage(image_raw) predictor_path = Constants.DATA_ROOT_PATH + '/' + Constants.PROGRAM_DATA_PATH + '/' + 'shape_predictor_68_face_landmarks.dat' face_rec_model_path = Constants.DATA_ROOT_PATH + '/' + Constants.PROGRAM_DATA_PATH + '/' + 'dlib_face_recognition_resnet_model_v1.dat' # prepare predict sp = dlib.shape_predictor(predictor_path) facerec = dlib.face_recognition_model_v1(face_rec_model_path) detector = dlib.get_frontal_face_detector() croppedImage_list = [] feature_list = [] dets = detector(image_raw, 1) for k, d in enumerate(dets): x, y, w, h = d.left(), d.top(), d.width(), d.height() croppedImage = image_raw[y:(y + h), x:(x + w)] croppedImage_list.append(croppedImage) cv.rectangle(cloned_image, (x, y), (x + w, y + h), (0, 255, 0), 2) shape = sp(cloned_image, d) face_descriptor = facerec.compute_face_descriptor(image_raw, shape) v = np.array(face_descriptor) print('--------------------------') print(str(imagePath) + ':' + str(k)) print(v) print('--------------------------') feature_list.append(v) result_data = {} result_data['croppedImageList'] = croppedImage_list result_data['croppedFeatureList'] = feature_list result_data['imageHighlighed'] = cloned_image return result_data
def GetImage(self, request, context): response = Manager.GetImage_Response() try: image = ImageUtils.GetImage(image_id=request.image_id) except docker.errors.ImageNotFound: response.exit_code = Manager.GetImage_Response.ExitCode.NOTFOUND return response response.exit_code = Manager.GetImage_Response.ExitCode.SUCCESS response.image_attr.id = image['Id'] for tag in image['RepoTags']: temp = response.image_attr.repoTags.add() temp = tag response.image_attr.created = image['Created'] response.image_attr.size = int(image['Size']) response.image_attr.author = image['Author'] return response
def start_recognize_faces_stream(): capture = cv2.VideoCapture(0) while True: _, frame = capture.read() pil_frame = ImageUtils.cv2_to_pillow_image(frame) time_label = [] current_time = time.time() faces, bounding_boxes = FaceExtracter.extracts(pil_frame, return_bounding_boxes=True) extract_time = time.time() - current_time time_label.append("extract_time: {}".format(extract_time)) if faces: for bounding_box in bounding_boxes: left, top, right, bottom = bounding_box.astype(numpy.int) cv2.rectangle(frame, (left, top), (right, bottom), (255, 255, 255)) current_time = time.time() faces_embeddings = ImageEmbedder.embeds(faces) embed_time = time.time() - current_time time_label.append("embed_time: {}".format(embed_time)) current_time = time.time() labels, confidents = FaceClassifier.classifies(faces_embeddings) classify_time = time.time() - current_time time_label.append("classify_time: {}".format(classify_time)) for (label, confident, bounding_box) in zip(labels, confidents, bounding_boxes): left, top, right, bottom = bounding_box.astype(numpy.int) cv2.putText(frame, f"{label}[{confident}]", (left, max(top - 5, 0)), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255)) cv2.putText(frame, ",".join(time_label), (8, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) cv2.imshow("Video Stream", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break # When everything done, release the capture capture.release() cv2.destroyAllWindows()
def handle(self, message, from_name_full, msg_obj): args = ' '.join(message[1:]) res = self.client.get_query(args) for pod in res.pods: print(pod.id) notify_message = "%s, This is what I found for you:" % from_name_full for pod in res.pods: if pod.img is not None: img_url = pod.img pod_id = pod.id # download the image to see its size img_file_name = str(uuid.uuid1()) + '.gif' urllib.urlretrieve(img_url, img_file_name) (width, height) = ImageUtils.get_image_size(img_file_name) print "Width: %d Height: %d" % (width, height) if width is not None and height is not None and height < MAX_IMG_HEIGHT: notify_message += "<br><strong>%s</strong><br><img src='%s'/>" % (pod_id, img_url) os.remove(img_file_name) self.bot.notify_room_html(notify_message, msg_obj['from'].bare) return
def __init__(self, application, request, **kwargs): super().__init__(application, request, **kwargs) self.exception = Response(system_config.response_def_map) self.executor = ThreadPoolExecutor(workers) self.image_utils = ImageUtils(system_config)
def post(self): uid = str(uuid.uuid1()) param_key = None start_time = time.time() if interface_manager.total == 0: logger.info( 'There is currently no model deployment and services are not available.' ) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "", self.status_bool_key: False, self.status_code_key: -999 })) bytes_batch, response = self.image_utils.get_bytes_batch( self.request.body) if not bytes_batch: logger.error('Response[{}] - {} ms'.format( response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return self.finish( json_encode({ self.message_key: "", self.status_bool_key: False, self.status_code_key: 999 })) exec_map = interface.model_conf.exec_map if exec_map and len(exec_map.keys()) > 1: logger.info( '[{}] - [{} {}] | [{}] - Size[{}] - Error[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, interface.name, size_string, "The model is configured with ExecuteMap, but the api do not support this param.", round((time.time() - start_time) * 1000))) return self.finish( json_encode({ self.message_key: "the api do not support [ExecuteMap].", self.status_bool_key: False, self.status_code_key: 474 })) elif exec_map and len(exec_map.keys()) == 1: param_key = list(interface.model_conf.exec_map.keys())[0] image_batch, response = ImageUtils.get_image_batch( interface.model_conf, bytes_batch, param_key=param_key) if not image_batch: logger.error( '[{}] - [{}] | [{}] - Size[{}] - Response[{}] - {} ms'.format( uid, self.request.remote_ip, interface.name, size_string, response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) result = interface.predict_batch(image_batch, None) logger.info( '[{}] - [{}] | [{}] - Size[{}] - Predict[{}] - {} ms'.format( uid, self.request.remote_ip, interface.name, size_string, result, (time.time() - start_time) * 1000)) response[self.uid_key] = uid response[self.message_key] = result return self.write( json.dumps(response, ensure_ascii=False).replace("</", "<\\/"))
def post(self): uid = str(uuid.uuid1()) start_time = time.time() data = self.parse_param() request_def_map = system_config.request_def_map input_data_key = request_def_map['InputData'] model_name_key = request_def_map['ModelName'] if input_data_key not in data.keys(): raise tornado.web.HTTPError(400) model_name = ParamUtils.filter(data.get(model_name_key)) output_split = ParamUtils.filter(data.get('output_split')) need_color = ParamUtils.filter(data.get('need_color')) param_key = ParamUtils.filter(data.get('param_key')) request_incr = self.request_incr request_count = " - Count[{}]".format(request_incr) log_params = " - ParamKey[{}]".format(param_key) if param_key else "" log_params += " - NeedColor[{}]".format( need_color) if need_color else "" if interface_manager.total == 0: logger.info( 'There is currently no model deployment and services are not available.' ) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "", self.status_bool_key: False, self.status_code_key: -999 })) bytes_batch, response = self.image_utils.get_bytes_batch( data[input_data_key]) if not bytes_batch: logger.error('[{}] - [{} {}] | - Response[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) # auxiliary_result = None image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if request_limit != -1 and request_incr > request_limit: logger.info( '[{}] - [{} {}] | Size[{}]{}{} - Error[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, size_string, request_count, log_params, "Maximum number of requests exceeded", round((time.time() - start_time) * 1000))) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "The maximum number of requests has been exceeded", self.status_bool_key: False, self.status_code_key: -444 })) if model_name_key in data and data[model_name_key]: interface = interface_manager.get_by_name(model_name) else: interface = interface_manager.get_by_size(size_string) if not interface: logger.info('Service is not ready!') return self.finish( json_encode({ self.uid_key: uid, self.message_key: "", self.status_bool_key: False, self.status_code_key: 999 })) output_split = output_split if 'output_split' in data else interface.model_conf.output_split if need_color: bytes_batch = [ color_extract.separate_color(_, color_map[need_color]) for _ in bytes_batch ] if interface.model_conf.corp_params: bytes_batch = corp_to_multi.parse_multi_img( bytes_batch, interface.model_conf.corp_params) if interface.model_conf.exec_map and not param_key: logger.info( '[{}] - [{} {}] | [{}] - Size[{}]{}{} - Error[{}] - {} ms'. format( uid, self.request.remote_ip, self.request.uri, interface.name, size_string, request_count, log_params, "The model is missing the param_key parameter because the model is configured with ExecuteMap.", round((time.time() - start_time) * 1000))) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "Missing the parameter [param_key].", self.status_bool_key: False, self.status_code_key: 474 })) if interface.model_conf.external_model and interface.model_conf.corp_params: result = [] len_of_result = [] pre_corp_num = 0 for corp_param in interface.model_conf.corp_params: corp_size = corp_param['corp_size'] corp_num_list = corp_param['corp_num'] corp_num = corp_num_list[0] * corp_num_list[1] sub_bytes_batch = bytes_batch[pre_corp_num:pre_corp_num + corp_num] pre_corp_num = corp_num size_string = "{}x{}".format(corp_size[0], corp_size[1]) sub_interface = interface_manager.get_by_size(size_string) image_batch, response = ImageUtils.get_image_batch( sub_interface.model_conf, sub_bytes_batch, param_key=param_key) text = yield self.predict(sub_interface, image_batch, output_split, size_string, start_time, log_params, request_count, uid=uid) result.append(text) len_of_result.append( len(result[0].split( sub_interface.model_conf.category_split))) response[ self.message_key] = interface.model_conf.output_split.join( result) if interface.model_conf.corp_params and interface.model_conf.output_coord: # final_result = auxiliary_result + "," + response[self.message_key] # if auxiliary_result else response[self.message_key] final_result = response[self.message_key] response[self.message_key] = corp_to_multi.get_coordinate( label=final_result, param_group=interface.model_conf.corp_params, title_index=[i for i in range(len_of_result[0])]) return self.finish( json.dumps(response, ensure_ascii=False).replace("</", "<\\/")) else: image_batch, response = ImageUtils.get_image_batch( interface.model_conf, bytes_batch, param_key=param_key) # if interface.model_conf.batch_model: # auxiliary_index = list(interface.model_conf.batch_model.keys())[0] # auxiliary_name = list(interface.model_conf.batch_model.values())[0] # auxiliary_interface = interface_manager.get_by_name(auxiliary_name) # auxiliary_image_batch, response = ImageUtils.get_image_batch( # auxiliary_interface.model_conf, # bytes_batch, # param_key=param_key # ) # auxiliary_result = yield self.predict( # auxiliary_interface, # auxiliary_image_batch[auxiliary_index: auxiliary_index+1], # output_split, # size_string, # start_time # ) # image_batch = np.delete(image_batch, auxiliary_index, axis=0).tolist() if not image_batch: logger.error( '[{}] - [{} {}] | [{}] - Size[{}] - Response[{}] - {} ms'. format(uid, self.request.remote_ip, self.request.uri, interface.name, size_string, response, round((time.time() - start_time) * 1000))) response[self.uid_key] = uid return self.finish(json_encode(response)) response[self.message_key] = yield self.predict(interface, image_batch, output_split, size_string, start_time, log_params, request_count, uid=uid) response[self.uid_key] = uid self.executor.submit(self.save_image, uid, response[self.message_key], bytes_batch[0]) # if interface.model_conf.corp_params and interface.model_conf.output_coord: # # final_result = auxiliary_result + "," + response[self.message_key] # # if auxiliary_result else response[self.message_key] # final_result = response[self.message_key] # response[self.message_key] = corp_to_multi.get_coordinate( # label=final_result, # param_group=interface.model_conf.corp_params, # title_index=[0] # ) return self.finish( json.dumps(response, ensure_ascii=False).replace("</", "<\\/"))
def __init__(self, **kwargs): super().__init__(**kwargs) self.image_utils = ImageUtils(system_config)
def post(self): uid = str(uuid.uuid1()) start_time = time.time() data = self.parse_param() request_def_map = system_config.request_def_map input_data_key = request_def_map['InputData'] model_name_key = request_def_map['ModelName'] if input_data_key not in data.keys(): raise tornado.web.HTTPError(400) model_name = ParamUtils.filter(data.get(model_name_key)) output_split = ParamUtils.filter(data.get('output_split')) need_color = ParamUtils.filter(data.get('need_color')) param_key = ParamUtils.filter(data.get('param_key')) extract_rgb = ParamUtils.filter(data.get('extract_rgb')) request_incr = self.request_incr global_count = self.global_request_incr request_count = " - Count[{}]".format(request_incr) log_params = " - ParamKey[{}]".format(param_key) if param_key else "" log_params += " - NeedColor[{}]".format( need_color) if need_color else "" if interface_manager.total == 0: self.request_desc() self.global_request_desc() logger.info( 'There is currently no model deployment and services are not available.' ) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "", self.status_bool_key: False, self.status_code_key: -999 })) bytes_batch, response = self.image_utils.get_bytes_batch( data[input_data_key]) if not bytes_batch: logger.error('[{}] - [{} {}] | - Response[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, response, (time.time() - start_time) * 1000)) return self.finish(json_encode(response)) image_sample = bytes_batch[0] image_size = ImageUtils.size_of_image(image_sample) size_string = "{}x{}".format(image_size[0], image_size[1]) if system_config.request_size_limit and size_string not in system_config.request_size_limit: self.request_desc() self.global_request_desc() logger.info( '[{}] - [{} {}] | Size[{}] - [{}][{}] - Error[{}] - {} ms'. format(uid, self.request.remote_ip, self.request.uri, size_string, global_count, log_params, "Image size is invalid.", round((time.time() - start_time) * 1000))) msg = system_config.request_size_limit.get("msg") msg = msg if msg else "The size of the picture is wrong. " \ "Only the original image is supported. " \ "Please do not take a screenshot!" return self.finish( json.dumps( { self.uid_key: uid, self.message_key: msg, self.status_bool_key: False, self.status_code_key: -250 }, ensure_ascii=False)) if system_config.use_whitelist: assert_whitelist = self.match_whitelist(self.request.remote_ip) if not assert_whitelist: logger.info( '[{}] - [{} {}] | Size[{}]{}{} - Error[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, size_string, request_count, log_params, "Whitelist limit", round((time.time() - start_time) * 1000))) return self.finish( json.dumps( { self.uid_key: uid, self.message_key: "Only allow IP access in the whitelist", self.status_bool_key: False, self.status_code_key: -111 }, ensure_ascii=False)) if global_request_limit != -1 and global_count > global_request_limit: logger.info( '[{}] - [{} {}] | Size[{}]{}{} - Error[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, size_string, global_count, log_params, "Maximum number of requests exceeded (G)", round((time.time() - start_time) * 1000))) return self.finish( json.dumps( { self.uid_key: uid, self.message_key: system_config.exceeded_msg, self.status_bool_key: False, self.status_code_key: -555 }, ensure_ascii=False)) assert_blacklist = self.match_blacklist(self.request.remote_ip) if assert_blacklist: logger.info( '[{}] - [{} {}] | Size[{}]{}{} - Error[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, size_string, request_count, log_params, "The ip is on the risk blacklist (IP)", round((time.time() - start_time) * 1000))) return self.finish( json.dumps( { self.uid_key: uid, self.message_key: system_config.exceeded_msg, self.status_bool_key: False, self.status_code_key: -110 }, ensure_ascii=False)) if request_limit != -1 and request_incr > request_limit: self.risk_ip_count(self.request.remote_ip) assert_blacklist_trigger = system_config.blacklist_trigger_times != -1 if self.risk_ip( self.request.remote_ip ) > system_config.blacklist_trigger_times and assert_blacklist_trigger: if self.request.remote_ip not in blacklist(): set_blacklist(self.request.remote_ip) update_blacklist() logger.info( '[{}] - [{} {}] | Size[{}]{}{} - Error[{}] - {} ms'.format( uid, self.request.remote_ip, self.request.uri, size_string, request_count, log_params, "Maximum number of requests exceeded (IP)", round((time.time() - start_time) * 1000))) return self.finish( json.dumps( { self.uid_key: uid, self.message_key: system_config.exceeded_msg, self.status_bool_key: False, self.status_code_key: -444 }, ensure_ascii=False)) if model_name_key in data and data[model_name_key]: interface = interface_manager.get_by_name(model_name) else: interface = interface_manager.get_by_size(size_string) if not interface: self.request_desc() self.global_request_desc() logger.info('Service is not ready!') return self.finish( json_encode({ self.uid_key: uid, self.message_key: "", self.status_bool_key: False, self.status_code_key: 999 })) output_split = output_split if 'output_split' in data else interface.model_conf.output_split if interface.model_conf.corp_params: bytes_batch = corp_to_multi.parse_multi_img( bytes_batch, interface.model_conf.corp_params) exec_map = interface.model_conf.exec_map if exec_map and len(exec_map.keys()) > 1 and not param_key: self.request_desc() self.global_request_desc() logger.info( '[{}] - [{} {}] | [{}] - Size[{}]{}{} - Error[{}] - {} ms'. format( uid, self.request.remote_ip, self.request.uri, interface.name, size_string, request_count, log_params, "The model is missing the param_key parameter because the model is configured with ExecuteMap.", round((time.time() - start_time) * 1000))) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "Missing the parameter [param_key].", self.status_bool_key: False, self.status_code_key: 474 })) elif exec_map and param_key and param_key not in exec_map: self.request_desc() self.global_request_desc() logger.info( '[{}] - [{} {}] | [{}] - Size[{}]{}{} - Error[{}] - {} ms'. format(uid, self.request.remote_ip, self.request.uri, interface.name, size_string, request_count, log_params, "The param_key parameter is not support in the model.", round((time.time() - start_time) * 1000))) return self.finish( json_encode({ self.uid_key: uid, self.message_key: "Not support the parameter [param_key].", self.status_bool_key: False, self.status_code_key: 474 })) elif exec_map and len(exec_map.keys()) == 1: param_key = list(interface.model_conf.exec_map.keys())[0] if interface.model_conf.external_model and interface.model_conf.corp_params: result = [] len_of_result = [] pre_corp_num = 0 for corp_param in interface.model_conf.corp_params: corp_size = corp_param['corp_size'] corp_num_list = corp_param['corp_num'] corp_num = corp_num_list[0] * corp_num_list[1] sub_bytes_batch = bytes_batch[pre_corp_num:pre_corp_num + corp_num] pre_corp_num = corp_num size_string = "{}x{}".format(corp_size[0], corp_size[1]) sub_interface = interface_manager.get_by_size(size_string) image_batch, response = ImageUtils.get_image_batch( sub_interface.model_conf, sub_bytes_batch, param_key=param_key) text = yield self.predict(sub_interface, image_batch, output_split, size_string, start_time, log_params, request_count, uid=uid) result.append(text) len_of_result.append( len(result[0].split( sub_interface.model_conf.category_split))) response[ self.message_key] = interface.model_conf.output_split.join( result) if interface.model_conf.corp_params and interface.model_conf.output_coord: # final_result = auxiliary_result + "," + response[self.message_key] # if auxiliary_result else response[self.message_key] final_result = response[self.message_key] response[self.message_key] = corp_to_multi.get_coordinate( label=final_result, param_group=interface.model_conf.corp_params, title_index=[i for i in range(len_of_result[0])]) return self.finish( json.dumps(response, ensure_ascii=False).replace("</", "<\\/")) else: image_batch, response = ImageUtils.get_image_batch( interface.model_conf, bytes_batch, param_key=param_key, extract_rgb=extract_rgb) if not image_batch: self.request_desc() self.global_request_desc() logger.error( '[{}] - [{} {}] | [{}] - Size[{}] - Response[{}] - {} ms'. format(uid, self.request.remote_ip, self.request.uri, interface.name, size_string, response, round((time.time() - start_time) * 1000))) response[self.uid_key] = uid return self.finish(json_encode(response)) predict_result = yield self.predict(interface, image_batch, output_split) # if need_color: # # only support six label and size [90x35]. # color_batch = np.resize(image_batch[0], (90, 35, 3)) # need_index = color_extract.predict_color(image_batch=[color_batch], color=color_map[need_color]) # predict_result = "".join([v for i, v in enumerate(predict_result) if i in need_index]) uid_str = "[{}] - ".format(uid) logger.info( '{}[{} {}] | [{}] - Size[{}]{}{} - Predict[{}] - {} ms'.format( uid_str, self.request.remote_ip, self.request.uri, interface.name, size_string, request_count, log_params, predict_result, round((time.time() - start_time) * 1000))) response[self.message_key] = predict_result response[self.uid_key] = uid self.executor.submit(self.save_image, uid, response[self.message_key], bytes_batch[0]) if interface.model_conf.corp_params and interface.model_conf.output_coord: # final_result = auxiliary_result + "," + response[self.message_key] # if auxiliary_result else response[self.message_key] final_result = response[self.message_key] response[self.message_key] = corp_to_multi.get_coordinate( label=final_result, param_group=interface.model_conf.corp_params, title_index=[0]) return self.finish( json.dumps(response, ensure_ascii=False).replace("</", "<\\/"))
conf_path = 'config.yaml' model_path = 'model' graph_path = 'graph' system_config = Config(conf_path=conf_path, model_path=model_path, graph_path=graph_path) route_map = {i['Class']: i['Route'] for i in system_config.route_map} sign.set_auth([{ 'accessKey': system_config.access_key, 'secretKey': system_config.secret_key }]) logger = system_config.logger interface_manager = InterfaceManager() image_utils = ImageUtils(system_config) @app.after_request def after_request(response): response.headers['Access-Control-Allow-Origin'] = '*' return response @app.errorhandler(400) def server_error(error=None): message = "Bad Request" return jsonify(message=message, code=error.code, success=False) @app.errorhandler(500)
def Convert(actionPath, example, action, test_set, id, tiny_set): print("Started: ", example) examplePath = os.path.join(actionPath, example) frames = [] images = [] compressedFlowImages = [] for frame in sorted(glob(examplePath + "/*.jpg")): im = open(frame, 'rb').read() frames.append(im) images.append(np.array(Image.open(io.BytesIO(im)))) if not os.path.exists(os.path.join(flowDir, action, example)): os.makedirs(os.path.join(flowDir, action, example)) flowFrames = ImageUtils.ComputeOpticalFlow( np.array(images), os.path.join(flowDir, action, example)) for i, ff in enumerate(flowFrames): r, buf = cv2.imencode('.jpg', ff) compressedFlowImages.append(buf.tostring()) if id in test_set: ex = test.create_group(example) else: ex = train.create_group(example) if debug: pdb.set_trace() ex.create_dataset("rgb", data=frames) ex.create_dataset("flow", data=compressedFlowImages) annots = ex.create_group("annot") if example not in annot_mapping: print("EXCEPTION: ", example) return example_id = annot_mapping[example] annots.create_dataset( 'action', data=annotations['annot'][0][example_id][2][0][0][2][0][0]) annots.create_dataset( 'startFrame', data=annotations['annot'][0][example_id][2][0][0][1][0][0]) annots.create_dataset( 'endFrame', data=annotations['annot'][0][example_id][2][0][0][0][0][0]) annots.create_dataset('bboxes', data=annotations['annot'][0][example_id][2][0][0][3]) if tiny_set: tiny_ex = tiny_datset.create_group(example) tiny_ex.create_dataset("rgb", data=frames) tiny_ex.create_dataset("flow", data=compressedFlowImages) tiny_annots = tiny_ex.create_group("annot") tiny_annots.create_dataset( 'action', data=annotations['annot'][0][example_id][2][0][0][2][0][0]) tiny_annots.create_dataset( 'startFrame', data=annotations['annot'][0][example_id][2][0][0][1][0][0]) tiny_annots.create_dataset( 'endFrame', data=annotations['annot'][0][example_id][2][0][0][0][0][0]) tiny_annots.create_dataset( 'bboxes', data=annotations['annot'][0][example_id][2][0][0][3]) print(example, ", IsTrain: ", id in test_set)
import time import cv2 import numpy as np import airsim from utils import ImageUtils DEFAULT_FPS = 8 utils = ImageUtils() class Gym: def __init__(self, show_cam=True): # connect to the AirSim simulator self.client = airsim.CarClient() self.client.confirmConnection() self.client.enableApiControl(True) self.car_controls = airsim.CarControls() self.episode_start = time.time() self.SHOW_CAM = show_cam self.fps = DEFAULT_FPS self.period = 1 / DEFAULT_FPS self.previous_action_time = None self.step_num = 0 self.previous_distance = None def reset(self): self.client.reset() time.sleep(0.1)
import module as _module import numpy as np import constant import sys sys.path.append('../') import utils.ImageUtils as IGU utils = IGU.ImageUtils() random_image = np.random.rand(1, 400, 400, 3) predict = _module.build_model.predict(random_image) y_predict = utils.getlistargmax(predict) y_predict_label = utils.getLabel(constant.root, constant.filename, np.absolute(y_predict)) print(y_predict_label)
def PruneImages(self, request, context): ImageUtils.PruneImages() return Manager.PruneImages_Response()
def RemoveImage(self, request, context): ImageUtils.RemoveImage(image_id=request.image_id, force=request.force) return Manager.RemoveImage_Response()
import utils.ImageUtils as iu # 顔にモザイクをかける # 検出器を生成 # カスケードファイルを生成 cascade_file = "../download/haarcascade_frontalface_alt.xml" # カスケードインスタンスを生成 cascade = cv2.CascadeClassifier(cascade_file) # 画像をグレイスケールに変換 img = cv2.imread("subaru.jpg") img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 顔認識を実行 face_list = cascade.detectMultiScale(img_gray) # 結果を確認 if len(face_list) == 0: print("失敗") quit() # 認識した部分に印をつける for (x, y, w, h) in face_list: img = iu.mosaic(img, (x, y, x + w, y + h), 10) # 画像を出力 cv2.imwrite("opencv/face_match.jpg", img) plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) plt.show()