def detect_sign(contents): """To convert image string into PIL form and perform detection operation""" strng=contents if find_img_type(strng)=='jpeg': type1=strng[23:]#jpeg str2img =Image.open(io.BytesIO(base64.b64decode(type1))) imx=np.array(str2img) # print(imx.shape) img = skimage.transform.resize(imx, (32, 32), mode='constant') img1 = np.reshape(img,[1,32,32,3]) with graph.as_default(): classes = model.predict_classes(img1) for i in dict1.keys(): if i == str(classes): name = dict1[i] print("Image :",name) return name elif find_img_type(strng)=='png': type2=strng[22:]#png str2img =Image.open(io.BytesIO(base64.b64decode(type2))) imx=np.array(str2img) print(imx.shape) Im4=imx[:,:,:-1] img = skimage.transform.resize(Im4, (32, 32), mode='constant') img1 = np.reshape(img,[1,32,32,3]) with graph.as_default(): classes = model.predict_classes(img1) for i in dict1.keys(): if i == str(classes): name = dict1[i] print("Image :",name) return name elif find_img_type(strng)=='octet-stream': type3=strng[37:] #ppm str2img =Image.open(io.BytesIO(base64.b64decode(type3))) imx=np.array(str2img) print(imx.shape) img = skimage.transform.resize(imx, (32, 32), mode='constant') img1 = np.reshape(img,[1,32,32,3]) with graph.as_default(): classes = model.predict_classes(img1) for i in dict1.keys(): if i == str(classes): name = dict1[i] print("Image :",name) return name else: msg="File format not supported.Please upload image with .jpeg/.png/.ppm format only" return msg
def segmentation(string, content, NDVIcontent): global ROIRGB, ROINDVI if string: data = content.encode("utf8").split(b";base64,")[1] NDVIdata = NDVIcontent.encode("utf8").split(b";base64,")[1] img = io.BytesIO() imgNDVI = io.BytesIO() img.write(base64.b64decode(data)) imgNDVI.write(base64.b64decode(NDVIdata)) img.seek(0) imgNDVI.seek(0) i = np.asarray(bytearray(img.read()), dtype=np.uint8) i = cv2.imdecode(i, cv2.IMREAD_COLOR) iNDVI = np.asarray(bytearray(imgNDVI.read()), dtype=np.uint8) iNDVI = cv2.imdecode(iNDVI, cv2.IMREAD_COLOR) mask = parse_jsonstring(string, (i.shape[0],i.shape[1])) ret,thresh = cv2.threshold(np.array(mask, dtype=np.uint8), 0, 255, cv2.THRESH_BINARY) im_floodfill = thresh.copy() h, w = thresh.shape[:2] m = np.zeros((h+2, w+2), np.uint8) cv2.floodFill(im_floodfill, m, (0,0), 255) im_floodfill_inv = cv2.bitwise_not(im_floodfill) im_out = thresh | im_floodfill_inv RGBimg = cv2.bitwise_and(i, i, mask=im_out) RGBimg = cv2.cvtColor(RGBimg, cv2.COLOR_BGR2RGB) target_size = (RGBimg.shape[1],(RGBimg.shape[0])) iNDVI = cv2.resize(iNDVI, target_size) NDVIimg = cv2.bitwise_and(iNDVI, iNDVI, mask=im_out) NDVIimg = cv2.cvtColor(NDVIimg, cv2.COLOR_BGR2RGB) contours = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0] cnts = sorted(contours, key=lambda c: cv2.contourArea(c), reverse=True) # finds the largest selection, which is a limitation to multiple selection (will be changed in the future versions) (x,y,w,h) = cv2.boundingRect(cnts[0]) ROIRGB = RGBimg[y:y+h, x:x+w] ROINDVI = NDVIimg[y:y+h, x:x+w] cv2.imwrite(static_image_route+'RGB_cropped.png', cv2.cvtColor(ROIRGB, cv2.COLOR_RGB2BGR )) cv2.imwrite(static_image_route+'CIR_cropped.png', cv2.cvtColor(ROINDVI, cv2.COLOR_RGB2BGR )) with ZipFile(static_image_route+'cropped.zip', 'w') as zipObj2: zipObj2.write(static_image_route+'RGB_cropped.png') zipObj2.write(static_image_route+'CIR_cropped.png') location = os.path.join(static_image_route,'cropped.zip') else: raise PreventUpdate return array_to_data_url(img_as_ubyte(ROIRGB)), array_to_data_url(img_as_ubyte(ROINDVI)), html.A(html.Button('Download',style={'display':'block' ,'position':'relative', 'top': '45%','left': '45%', 'font-size': '16px', 'padding': '8px 12px', 'border-radius': '4px', 'text-align': 'center', 'align':'center', 'color':'black', 'font-family':'Times New Roman', 'textAlign':'center'}), href=location) #, html.Div([html.Button('Save Image', id='saveImg')])
def classify_image(file): rand = random.Random() with anvil.media.TempFile(file) as filename: img = Image.open(io.BytesIO(file.get_bytes())) bs = io.BytesIO() #img.save(bs, format="JPEG") # save image in upload img.save('/content/cell_images/upload/myphoto.png', 'PNG') final_path = '/content/cell_images/upload/myphoto.png' prediction = "Sick" if getPrediction(CNN, final_path) == 0 else "Healthy" # save image for backup lol = str(randint(1,1000000)) backup_path = "/content/cell_images/backup/"+lol+".png" img.save(backup_path, 'JPEG') return(prediction)
def get_imgs(): ann_id = np.random.choice(ids) img_id = coco.anns[ann_id]['image_id'] img = coco.loadImgs(img_id)[0] print(img) url = img['coco_url'] #flickrurl=img['flickr_url'] #print(url) #print(flickrurl) orig_img = skimage.io.imread(url) plt.axis('off') plt.imshow(orig_img) plt.show() #print(orig_img.shape) response = requests.get(url) img_pil = Image.open(io.BytesIO(response.content)).convert('RGB') transform_test = transforms.Compose([ transforms.Resize(256), # smaller edge of image resized to 256 transforms.RandomCrop(224), # get 224x224 crop from random location transforms.RandomHorizontalFlip( ), # horizontally flip image with probability=0.5 transforms.ToTensor() ]) I_transf = transform_test(img_pil) return orig_img, I_transf.view(1, 3, 224, 224), img
def get_sat(coord): newpath = r'img/{}_{}'.format(*coord) if os.path.exists(newpath): shutil.rmtree(newpath, ignore_errors=True) os.makedirs(newpath) new_url = base_URL + "¢er=" + quote("{}, {}".format(*coord)) new_satellite_url = satellite_URL + "¢er=" + quote("{}, {}".format(*coord)) with urllib.request.urlopen(new_url) as url: f = io.BytesIO(url.read()) img = exposure.rescale_intensity(np.array(Image.open(f))) skimage.io.imsave(newpath + "/mask.png",img) img_satellite = skimage.io.imread(new_satellite_url) skimage.io.imsave(newpath + "/sat.png",img_satellite) cmd = r'matlab -nosplash -nodesktop -r "road_segmentation {}; quit"'.format(newpath) os.system(cmd) p = Path(newpath) for sec_img in p.glob('*/*/*.png'): if sec_img.parts[-1] in ['sat.png']: shutil.copy(os.getcwd() + '/' + '/'.join(sec_img.parts), '{}'.format(':'.join(sec_img.parts)))
def infer_from_img_url(self, img_url): tik = time.time() response = requests.get(img_url, timeout=20) if response.status_code in [403, 404, 500]: return { 'status': 2, 'message': 'Invalid URL', 'elapse': time.time() - tik, 'results': None } else: img_content = response.content import io from PIL import Image img_np = np.array(Image.open(io.BytesIO(img_content))) img = Image.fromarray(img_np.astype(np.uint8)) preprocess = transforms.Compose([ transforms.Resize(227), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) img = preprocess(img) img.unsqueeze_(0) img = img.to(self.device) outputs = self.model.forward(img) outputs = F.softmax(outputs, dim=1) # get TOP-K output labels and corresponding probabilities topK_prob, topK_label = torch.topk(outputs, self.topK) prob = topK_prob.to("cpu").detach().numpy().tolist() _, predicted = torch.max(outputs.data, 1) tok = time.time() return { 'status': 0, 'message': 'success', 'elapse': tok - tik, 'results': [{ 'name': self.key_type[int(topK_label[0][i].to("cpu"))], 'category id': int(topK_label[0][i].data.to("cpu").numpy()) + 1, 'prob': round(prob[0][i], 4) } for i in range(self.topK)] }
def predict_food(): response = {} image = flask.request.files["image"].read() image = Image.open(io.BytesIO(image)) prediction, prob = predict(image) response['prediction'] = prediction response['probability'] = prob return flask.jsonify(response)
def send_file(filename,mime_type=None): try: content = array_to_data_url(img_as_ubyte(ROIRGB)) data = content.encode("utf8").split(b";base64,")[1] imgtowrite = io.BytesIO(base64.decodebytes(data)) c = base64.b64encode(imgtowrite.read()).decode() return dict(content=c, filename=filename,mime_type=mime_type, base64=True) except Exception: pass
def load_image_rwanda_zip(name): archive = zipfile.ZipFile("rwanda.zip", 'r') img_data = archive.read("rwanda/" + name) bytes_io = io.BytesIO(img_data) img = pygame.image.load(bytes_io) img = pygame.surfarray.array3d(img) archive.close() return img
def get_image(location, heading, pitch, fov): image = download_image(location, heading, pitch, fov) # Return image data imagedata = io.BytesIO() skimage.io.imsave(imagedata, image, plugin='pil', format_str='jpeg') imagedata.seek(0) return imagedata
def detect_graph_types_from_iiif(paper_id, pages, learner, debug=False): """Pull images from iiif server """ print(paper_id, pages) url = "http://127.0.0.1:8182/iiif/2/biorxiv:{}.full.pdf/full/560,560/0/default.png?page={}" images = [open_image(io.BytesIO(requests.get(url.format(paper_id, pg)).content)) for pg in range(1, pages+1)] return detect_graph_types_from_list(images, learner)
def preprocess(self, raw, gt_path): img_bytes = io.BytesIO(bytearray(raw)) gt_bytes = open(gt_path, 'rb') img = np.array(Image.open(img_bytes)) gt = np.array(Image.open(gt_bytes)) img = img[:, :, :3] / 255. gt = gt[:, :, :3] / 255. return img, gt
def draw_ferwar_id_on_axis(ID, ax): import bb_utils.visualization import skimage.io import io ID = bb_utils.ids.BeesbookID.from_ferwar(ID) png = bb_utils.visualization.TagArtist().draw(ID.as_bb_binary()) png = io.BytesIO(png) im = skimage.io.imread(png) ax.imshow(im) ax.set_axis_off()
async def sort_endpoint(): image = skimage.io.imread(io.BytesIO(await request.body)) image = await image_function(image, sort) assert isinstance(image, io.BytesIO) response = await make_response(image.getvalue()) response.headers['Status'] = 200 response.headers['Content-Type'] = "image/png" return response
def predict_food(): response = {"success": False} if flask.request.method == "POST": if flask.request.files.get("image"): image = flask.request.files["image"].read() image = Image.open(io.BytesIO(image)) prediction, prob = predict(image) response['prediction'] = prediction response['probability'] = prob response['emissions'] = new_dict[prediction] response["success"] = True return flask.jsonify(response)
def gen_plot(fpr, tpr): """Create a pyplot plot and save to buffer.""" plt.figure() plt.xlabel("FPR", fontsize=14) plt.ylabel("TPR", fontsize=14) plt.title("ROC Curve", fontsize=14) plot = plt.plot(fpr, tpr, linewidth=2) buf = io.BytesIO() plt.savefig(buf, format="jpeg") buf.seek(0) plt.close() return buf
def to_base64(image) -> str: # convert image to bytes with io.BytesIO() as output_bytes: PIL_image = Image.fromarray(skimage.img_as_ubyte(image)) # Note JPG is not a vaild type here if PIL_image.mode in ("RGBA", "P"): PIL_image = PIL_image.convert("RGB") PIL_image.save(output_bytes, 'JPEG') bytes_data = output_bytes.getvalue() # encode bytes to base64 string base64_str = str(base64.b64encode(bytes_data), 'utf-8') return base64_str
def infer_from_img(self, img): import io from PIL import Image img_np = np.array(Image.open(io.BytesIO(img))) img = Image.fromarray(img_np.astype(np.uint8)) preprocess = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) img = preprocess(img) img.unsqueeze_(0) img = img.to(self.device) outputs = self.model(img) outputs = F.softmax(outputs, dim=1) topK_prob, topK_label = torch.topk(outputs, self.topK) prob = topK_prob.to("cpu").detach().numpy().tolist() _, predicted = torch.max(outputs.data, 1) if prob[0][0] >= cfg['thresholds']['skin_disease_recognition']: return { "status": 0, "message": "success", "results": [{ "disease": self.mapping[int(topK_label[0][i].to("cpu"))], "probability": round(prob[0][i], 4), } for i in range(self.topK)] } else: return { "status": 0, "message": "success", "results": [{ "disease": "Unknown", "probability": round(prob[0][0], 4), }] }
def createVectorsFile(self): self.dataset.loadImages() # Create the BlockBlockService that is used to call the Blob service for the storage account azureBlobStorage = BlockBlobService( account_name=self.parameters['azureStorageBucket'], account_key=self.parameters['azureStorageKey'], endpoint_suffix=self.parameters['azureEndpointSuffix']) fieldNames = ["imageId", "url"] for v in range(self.parameters['neuralNetwork']['vectorSize']): fieldNames.append(f'v{v}') with open('db-vectors.csv', 'wt') as f: writer = csv.DictWriter(f, fieldnames=list(fieldNames)) writer.writeheader() for imageId in range(len(LoadedDataset.rawImages)): rawImage = LoadedDataset.rawImages[imageId] buffer = io.BytesIO() skimage.io.imsave(buffer, rawImage) result = azureBlobStorage.create_blob_from_bytes( 'images', f"image-{imageId}.png", buffer.getvalue()) images = self.dataset.getImageDBSet(imageId) # for index, image in enumerate(images): # skimage.io.imsave(f"image{imageId}-{index}.png", image) vectors = self.model.model.predict(numpy.array(images)) vectors = sklearn.preprocessing.normalize(vectors) for vector in vectors: data = { "imageId": imageId, "url": f"{self.parameters['azureStorageUrl']}image-{imageId}.png" } for index, value in enumerate(vector): data[f'v{index}'] = value writer.writerow(data) if imageId % 100 == 0: print( f"Completed {imageId}/{len(LoadedDataset.rawImages)}")
def predict(): # Initialize the data dictionary that will be returned from the view. data = {"success": False} # Ensure an image was properly uploaded to our endpoint. if flask.request.method == 'POST': print("接收到post请求") if flask.request.files.get("image"): print("接收到字节流") # Read the image in PIL format image = flask.request.files["image"].read() import io image = Image.open(io.BytesIO(image))#从字节流还原图片 #print(image.size) image=numpy.array(image) print("正在转换图片") image = transform.resize(image,(256,256),mode='constant')#这里需要resize成你的模型需要的输入大小 image[:,:,0] = (image[:,:,0]-0.485)/0.229 image[:,:,1] = (image[:,:,1]-0.456)/0.224 image[:,:,2] = (image[:,:,2]-0.406)/0.225 #例如([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])就是Imagenet dataset的标准化系数(RGB三个通道对应三组系数)。数据集给出的均值和标准差系数,每个数据集都不同的,都是数据集提供方给出的 image=image.transpose([2,0,1])#调换通道的顺序 image = image[np.newaxis,:]#扩维 #在这之前,整理一下你的输入数据,确保符合模型,变成 [1,w,h,c] 图片个数、宽、高、通道数 image=torch.from_numpy(image).float() if torch.cuda.is_available(): image = Variable(image.cuda()) else: image = Variable(image) print("开始输入模型预测") d1,d2,d3,d4,d5,d6,d7,d8 = model(image)#根据你的模型输出结果,改成你自己的,如果你只返回图片,就用一个变量接受就好了 #---------------------------------- # normalization 这一段是对模型输出做后处理,如果不需要可以直接注释掉 pred = d1[:,0,:,:] pred = normPRED(pred) #---------------------------------- #--------接下来的两步是必须的 pred = pred.squeeze() pred_np = pred.cpu().data.numpy() data['result']=pred_np.tolist() # Indicate that the request was a success. data["success"] = True del d2,d3,d4,d5,d6,d7,d8 #删除没用的变量,防止内存泄漏,这一步可有可无 print("返回结果") # Return the data dictionary as a JSON response. return flask.jsonify(data)
async def colormap_endpoint(): color_arg = f'#{((request.args.get("color") or "7289DA").replace("0x", "#").lstrip("#")):0>6}' color_obj = Color(color_arg) rgb = color_obj.red_int8, color_obj.green_int8, color_obj.blue_int8 image = PILImage.open(io.BytesIO(await request.body)) transformed = await image_function(image, colormap, rgb) assert isinstance(transformed, io.BytesIO) response = await make_response(transformed.getvalue()) response.headers['Status'] = 200 response.headers['Content-Type'] = "image/png" return response
def segmentation(string, content, NDVIcontent): if string: data = content.encode("utf8").split(b";base64,")[1] NDVIdata = NDVIcontent.encode("utf8").split(b";base64,")[1] img = io.BytesIO() imgNDVI = io.BytesIO() img.write(base64.b64decode(data)) imgNDVI.write(base64.b64decode(NDVIdata)) img.seek(0) imgNDVI.seek(0) i = np.asarray(bytearray(img.read()), dtype=np.uint8) i = cv2.imdecode(i, cv2.IMREAD_COLOR) iNDVI = np.asarray(bytearray(imgNDVI.read()), dtype=np.uint8) iNDVI = cv2.imdecode(iNDVI, cv2.IMREAD_COLOR) mask = parse_jsonstring(string, (i.shape[0],i.shape[1])) ret,thresh = cv2.threshold(np.array(mask, dtype=np.uint8), 0, 255, cv2.THRESH_BINARY) im_floodfill = thresh.copy() h, w = thresh.shape[:2] m = np.zeros((h+2, w+2), np.uint8) cv2.floodFill(im_floodfill, m, (0,0), 255) im_floodfill_inv = cv2.bitwise_not(im_floodfill) im_out = thresh | im_floodfill_inv RGBimg = cv2.bitwise_and(i, i, mask=im_out) RGBimg = cv2.cvtColor(RGBimg, cv2.COLOR_BGR2RGB) target_size = (RGBimg.shape[1],(RGBimg.shape[0])) iNDVI = cv2.resize(iNDVI, target_size) NDVIimg = cv2.bitwise_and(iNDVI, iNDVI, mask=im_out) NDVIimg = cv2.cvtColor(NDVIimg, cv2.COLOR_BGR2RGB) contours = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0] cnts = sorted(contours, key=lambda c: cv2.contourArea(c), reverse=True) # finds the largest selection, which is a limitation to multiple selection (will be changed in the future versions) (x,y,w,h) = cv2.boundingRect(cnts[0]) ROIRGB = RGBimg[y:y+h, x:x+w] ROINDVI = NDVIimg[y:y+h, x:x+w] else: raise PreventUpdate return array_to_data_url(img_as_ubyte(ROIRGB)), array_to_data_url(img_as_ubyte(ROINDVI))
def plot_to_image(figure): """Converts the matplotlib plot specified by 'figure' to a PNG image and returns it. The supplied figure is closed and inaccessible after this call.""" # Save the plot to a PNG in memory. buf = io.BytesIO() plt.savefig(buf, format='png') # Closing the figure prevents it from being displayed directly inside # the notebook. plt.close(figure) buf.seek(0) # Convert PNG buffer to TF image image = tf.image.decode_png(buf.getvalue(), channels=4) # Add the batch dimension image = tf.expand_dims(image, 0) return image
def imshow(a, format='png', jpeg_fallback=True): a = np.asarray(a, dtype=np.uint8) str_file = io.BytesIO() PIL.Image.fromarray(a).save(str_file, format) png_data = str_file.getvalue() try: disp = IPython.display.display(IPython.display.Image(png_data)) except IOError: if jpeg_fallback and format != 'jpeg': print('Warning: image was too large to display in format "{}"; ' 'trying jpeg instead.').format(format) return imshow(a, format='jpeg') else: raise return disp
def render_color_images(self, poses, scene , mode, IM_SIZE = 0): if IM_SIZE == 0: IM_SIZE = self.im_size subfolder_save = os.path.join(self.folder_name, mode) scene.show() for i in tqdm(range(len(poses))): camera_extrinsics = lookAt(poses[i], np.array([0, 0, 0])) #trimesh.constants.log.info('Saving image %d', i) # rotate the camera view transform camera_old, _geometry = scene.graph[scene.camera.name] #camera_new = lookAt(poses[i], np.array([0,0,0])) camera_new = camera_extrinsics # apply the new transform scene.graph[scene.camera.name] = camera_new #camera.K = camera_intrinsics_1 #print(np.matmul(scene.camera.K,np.matmul(camera_extrinsics,np.array([0,0,0,1]))[:3])) #aa, bb = scene.graph[scene.camera.name] #print("trimesh renders from \n", aa) #print("intrinsics\n" , scene.camera.K) #scene.show() # saving an image requires an opengl context, so if -nw # is passed don't save the image try: # increment the file name file_name = os.path.join(subfolder_save, os.path.join("B", 'pose_%d.png' % i)) # save a render of the object as a png png = scene.save_image(resolution=[IM_SIZE * self.anti_alias, IM_SIZE * self.anti_alias], visible=True) #image = Image.frombytes("RGB", (IM_SIZE * self.anti_alias, IM_SIZE * self.anti_alias), png, 'raw') image = Image.open(io.BytesIO(png)) # Down sample high resolution version if self.anti_alias > 1: image.thumbnail([IM_SIZE, IM_SIZE], PIL.Image.ANTIALIAS) image.save(file_name, 'PNG') # with open(file_name, 'wb') as f: # f.write(png) # f.close() # except BaseException as E: print("unable to save image", str(E)) time.sleep(0.05)
def load_images_from_zip(path): archive = zipfile.ZipFile(path, 'r') name_list = archive.namelist() images = np.zeros((len(name_list) - 1, 400, 400, 3)) idx = 0 for name in name_list: if (name[len(name) - 1] == '/'): continue img_data = archive.read(name) bytes_io = io.BytesIO(img_data) img = pygame.image.load(bytes_io) img = pygame.surfarray.array3d(img) images[idx] = img idx += 1 archive.close() return images
def predict(request: Request, img_file: bytes=File(...)): data = {"success": False} if request.method == "POST": image = Image.open(io.BytesIO(img_file)) image = prepare_image(image, (int(os.environ.get("IMAGE_WIDTH")), int(os.environ.get("IMAGE_HEIGHT"))) ) # Ensure our NumPy array is C-contiguous as well, otherwise we won't be able to serialize it image = image.copy(order="C") # Generate an ID for the classification then add the classification ID + image to the queue k = str(uuid.uuid4()) image = base64.b64encode(image).decode("utf-8") d = {"id": k, "image": image} db.rpush(os.environ.get("IMAGE_QUEUE"), json.dumps(d)) # Keep looping for CLIENT_MAX_TRIES times num_tries = 0 while num_tries < CLIENT_MAX_TRIES: num_tries += 1 # Attempt to grab the output predictions output = db.get(k) # Check to see if our model has classified the input image if output is not None: # Add the output predictions to our data dictionary so we can return it to the client output = output.decode("utf-8") data["predictions"] = json.loads(output) # Delete the result from the database and break from the polling loop db.delete(k) break # Sleep for a small amount to give the model a chance to classify the input image time.sleep(float(os.environ.get("CLIENT_SLEEP"))) # Indicate that the request was a success data["success"] = True else: raise HTTPException(status_code=400, detail="Request failed after {} tries".format(CLIENT_MAX_TRIES)) # Return the data dictionary as a JSON response return data
def shapes_seg_pair_as_dict(d, key, seg, remove_old=True): """ Stores shapes and segmentation pair in dict d seg is a PIL.Image object if remove_old True, deletes all the old keys and values. """ bytes_to_encode = io.BytesIO() seg.save(bytes_to_encode, format="png") bytes_to_encode.seek(0) data = base64.b64encode(bytes_to_encode.read()).decode() if remove_old: return {key: data} d[key] = data return d
def make_image(tensor): """ Convert an numpy representation image to Image protobuf. Copied from https://github.com/lanpa/tensorboard-pytorch/ """ from PIL import Image _, height, width, channel = tensor.shape image = Image.fromarray(np.squeeze(tensor)) import io output = io.BytesIO() image.save(output, format='PNG') image_string = output.getvalue() output.close() return tf.Summary.Image(height=height, width=width, colorspace=channel, encoded_image_string=image_string)
def predict(): global obj data = {"success": False} if flask.request.method == "POST": if flask.request.files.get("image"): # read the image in PIL format image = flask.request.files["image"].read() image = Image.open(io.BytesIO(image)) x = prepare_image(image) pred = obj.predict(prepare_image(image)) data["predictions"] = pred[0] data["success"] = True return flask.jsonify(data)