def predict(image_fps, filepath='submission.csv', min_conf=config.DETECTION_MIN_CONFIDENCE): resize_factor = ORIG_SIZE / config.IMAGE_SHAPE[0] with open(filepath, 'w') as file: file.write("ImageId,EncodedPixels\n") for fp in tqdm_notebook(image_fps): image_id = fp.split('/')[-1][:-4] maks_written = 0 if image_id in positives.index: ds = pydicom.read_file(fp) image = ds.pixel_array if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image,) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) results = model.detect([image]) r = results[0] n_positives = positives.loc[image_id].N num_instances = min(len(r['rois']), n_positives) for i in range(num_instances): if r['scores'][i] > min_conf and np.sum(r['masks'][...,i]) > 1: mask = r['masks'][...,i].T*255 mask, _,_,_,_ = utils.resize_image( np.stack((mask,) * 3, -1), min_dim=ORIG_SIZE, min_scale=config.IMAGE_MIN_SCALE, max_dim=ORIG_SIZE, mode=config.IMAGE_RESIZE_MODE) mask = (mask[...,0] > 0)*255 file.write(image_id + "," + mask2rle(mask, ORIG_SIZE, ORIG_SIZE) + "\n") maks_written += 1 for i in range(n_positives - maks_written): padding = 88750 file.write(image_id + f",{padding} {ORIG_SIZE*ORIG_SIZE - padding*2}\n") maks_written += 1 if maks_written == 0: file.write(image_id + ",-1\n")
def resize_image(image_id): # Load random image and mask. image = dataset.load_image(image_id) mask, class_ids = dataset.load_mask(image_id) original_shape = image.shape # Resize image, window, scale, padding, _ = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) mask = utils.resize_mask(mask, scale, padding) # Compute Bounding box bboxes = utils.extract_bboxes(mask) # Display image and additional stats print("image_id: ", image_id, dataset.image_reference(image_id)) print("Original shape: ", original_shape) log("image", image) log("mask", mask) log("class_ids", class_ids) log("bbox", bboxes) # Display image and instances visualize.display_instances(image, bboxes, mask, class_ids, dataset.class_names)
def img_preprocess(self, img): """Pre-processes the input image. img: Input image of shape (-1,XX,YY,3) Returns: molded_image: Molded imimg_age to be used as model input image_meta: Input image metadata anchors: [N, (y1, x1, y2, x2)]. All generated anchors in one array. Sorted with the same order of the given scales. So, anchors of scale[0] come first, then anchors of scale[1], and so on. window: (y1, x1, y2, x2). If max_dim is provided, padding might be inserted in the returned image. If so, this window is the coordinates of the image part of the full image (excluding the padding). The x2, y2 pixels are not included. """ molded_image, window, scale, padding, crop = utils.resize_image( img, min_dim=self.cococonfig.IMAGE_MIN_DIM, min_scale=self.cococonfig.IMAGE_MIN_SCALE, max_dim=self.cococonfig.IMAGE_MAX_DIM, mode=self.cococonfig.IMAGE_RESIZE_MODE) molded_image = model.mold_image(molded_image, self.cococonfig) image_meta = model.compose_image_meta( 0, img.shape, molded_image.shape, window, scale, np.zeros([self.cococonfig.NUM_CLASSES], dtype=np.int32)) anchors = MaskRCNN('inference', self.cococonfig, None).get_anchors(molded_image.shape) return molded_image, image_meta, anchors, window
def test_image(model, class_names, result_image_path, image_path, config): assert image_path # Image or video? if image_path: # Run model detection and generate the color splash effect print("Running on {}".format(image_path)) # Read image image = skimage.io.imread(image_path) print(image.shape) # Detect objects r = model.detect([image], verbose=1)[0] # print(r) # Color splash display_instances(image, r['rois'], r['masks'], r['class_ids'], class_names, result_image_path, r['scores']) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) #skimage.io.imsave("test.jpg", image) print("window: (y1, x1, y2, x2)=", window) print("scale=", scale) print("padding:[(top, bottom), (left, right), (0, 0)]=", padding) print("crop=", crop) print("Saved to ", result_image_path)
def load_and_resize_images(dataset, datacfg, dnncfg): ''' ## Resize Images To support multiple images per batch, images are resized to one size (1024x1024). Aspect ratio is preserved, though. If an image is not square, then zero padding is added at the top/bottom or right/left. ''' log.info("load_and_resize_images::-------------------------------->") image_id = np.random.choice(dataset.image_ids, 1)[0] image = dataset.load_image(image_id) mask, class_ids, keys, values = dataset.load_mask(image_id, datacfg) original_shape = image.shape # Resize image, window, scale, padding, _ = utils.resize_image( image, min_dim=dnncfg.IMAGE_MIN_DIM, max_dim=dnncfg.IMAGE_MAX_DIM, mode=dnncfg.IMAGE_RESIZE_MODE) mask = utils.resize_mask(mask, scale, padding) # Compute Bounding box bbox = utils.extract_bboxes(mask) # Display image and additional stats log.debug("Original shape: {}".format(original_shape)) # customlog("image", image) # customlog("mask", mask) # customlog("class_ids", class_ids) # customlog("bbox", bbox) ## Display image and instances class_names = dataset.class_names visualize.display_instances(image, bbox, mask, class_ids, class_names)
def extract(self, images, label_map): image_features = [] for image_index, image in enumerate(images): im = np.asarray(transforms.ToPILImage()(image).convert("RGB")) image_resized, _, _, _, _ = utils.resize_image(im, min_dim=self.config.IMAGE_MIN_DIM, min_scale=self.config.IMAGE_MIN_SCALE, max_dim=self.config.IMAGE_MAX_DIM, mode=self.config.IMAGE_RESIZE_MODE) results = self.model.detect([image_resized], verbose=0) # visualize.display_instances(image_resized, r['rois'], r['masks'], r['class_ids'], dataset_val.class_names, # r['scores'], ax=get_ax(), name='predicted.png') feature_list = [] predicted_ids = results[0]['class_ids'] id_names = self.dataset_val.class_names for pred_id in predicted_ids: pred_feature = id_names[pred_id] feature_list.append(pred_feature) image_features.append(list(set(feature_list))) predictions = self.search_for_closest_match(image_features, label_map) return image_features, np.asarray(predictions)
def predict(image_fp, min_conf): for idx, image_id in enumerate(image_fp): #ds = pydicom.read_file(image_id) #image = ds.pixel_array image = cv2.imread(image_id) # If grayscale. Convert to RGB for consistency. resize_factor = ORIG_SIZE / config.IMAGE_SHAPE[0] print(config.IMAGE_SHAPE[0]) if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image, ) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) patient_id = os.path.splitext(os.path.basename(image_id))[0] print(patient_id) results = model.detect([image]) r = results[0] print(idx) print(r) for bbox, scores in zip(r['rois'], r['scores']): print(bbox) x1 = int(bbox[1]) #* resize_factor) y1 = int(bbox[0]) #* resize_factor) x2 = int(bbox[3]) #* resize_factor) y2 = int(bbox[2]) #* resize_factor) print(x1, " ", y1, " ", x2, " ", y2) cv2.rectangle(image, (x1, y1), (x2, y2), (77, 255, 9), 3, 1) text = 'prediction = ' + str(scores) cv2.putText(image, text, (x1 - 50, y1 - 50), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (77, 255, 9), lineType=cv2.LINE_AA, thickness=2) #cv2.imwrite(ROOTDIRECTORY + 'test_jpegs/pos_test339_labeled.jpg' ,image) width = x2 - x1 height = y2 - y1 print("x {} y {} h {} w {}".format(x1, y1, width, height)) #plt.plot(image, cmap=plt.cm.gist_gray) #plt.subplot(1,2,(idx+1)) #plt.plot(image, cmap=plt.cm.gist_gray) #plt.imshow(image, cmap=plt.cm.gist_gray) #cv2.imwrite(ROOTDIRECTORY + 'test_jpegs/pos_test339_labeled.jpg' ,image) #plt.show() #plt.figure() print(image_id) cv2.imwrite( ROOTDIRECTORY + "test_jpegs/" + os.path.splitext(image_id)[0] + '_labeled.jpg', image)
def one_picture_detect(model_main, image_path='dog.png'): first_time = time.time() image = skimage.io.imread(image_path) print(image.shape) if image.shape[-1] == 4: image = image[..., :3] image, _, _, _, _ = utils.resize_image(image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) # If grayscale. Convert to RGB for consistency. # image = np.concatenate((image, image[..., 0][..., np.newaxis]), axis=-1) print(image.shape) print(time.time() - first_time) # # Run object detection results = model_main.detect([image], verbose=0) print(time.time() - first_time) fig = plt.figure() plt.subplot(111) plt.imshow(image) plt.gca().add_patch(patches.Rectangle([1, 1], 10, 10)) im = plt.gca() r = plt.gcf().canvas.get_renderer() plt.gca().draw(r) plt.savefig('suka.png') print(time.time() - first_time)
def predict(image_fps, filepath='submission.csv', min_conf=0.95): # assume square image resize_factor = ORIG_SIZE / config.IMAGE_SHAPE[0] with open(filepath, 'w') as file: file.write("patientId,PredictionString\n") for image_id in tqdm(image_fps): ds = pydicom.read_file(image_id) image = ds.pixel_array # image = signal.medfilt(image, kernel_size=5) # 对图片进行中值滤波 # image = image.astype(np.uint8) # image = cv2.equalizeHist(image) # 对图片进行直方图均衡处理 image, _ = histep(image) # 对图片进行直方图均衡处理 # If grayscale. Convert to RGB for consistency. if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image,) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) patient_id = os.path.splitext(os.path.basename(image_id))[0] ''' results = model.detect([image]) r = results[0] ''' r = choose_intersect(model, config, image, shreshhold=0.2) out_str = "" out_str += patient_id out_str += "," assert( len(r['rois']) == len(r['class_ids']) == len(r['scores']) ) if len(r['rois']) == 0: pass else: num_instances = len(r['rois']) for i in range(num_instances): if r['scores'][i] > min_conf: out_str += ' ' out_str += str(round(r['scores'][i], 2)) out_str += ' ' # x1, y1, width, height x1 = r['rois'][i][1] y1 = r['rois'][i][0] width = r['rois'][i][3] - x1 height = r['rois'][i][2] - y1 bboxes_str = "{} {} {} {}".format(x1*resize_factor, y1*resize_factor, \ width*resize_factor, height*resize_factor) out_str += bboxes_str file.write(out_str+"\n")
def detect_and_color_splash(model, image_path=None, video_path=None): assert image_path or video_path # Image or video? if image_path: # Run model detection and generate the color splash effect print("Running on {}".format(args.image)) # Read image image = skimage.io.imread(args.image) # for the FAPS demonstrator we only have grey images image = skimage.color.gray2rgb(image) image, _, _, _, _ = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) # Detect objects r = model.detect([image], verbose=1)[0] # Color splash splash = color_splash(image, r['masks']) # Save output file_name = "splash_{:%Y%m%dT%H%M%S}.png".format(datetime.datetime.now()) skimage.io.imsave(file_name, splash) elif video_path: import cv2 # Video capture vcapture = cv2.VideoCapture(video_path) width = int(vcapture.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vcapture.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = vcapture.get(cv2.CAP_PROP_FPS) # Define codec and create video writer file_name = "splash_{:%Y%m%dT%H%M%S}.avi".format(datetime.datetime.now()) vwriter = cv2.VideoWriter(file_name, cv2.VideoWriter_fourcc(*'MJPG'), fps, (width, height)) count = 0 success = True while success: print("frame: ", count) # Read next image success, image = vcapture.read() if success: # OpenCV returns images as BGR, convert to RGB image = image[..., ::-1] # Detect objects r = model.detect([image], verbose=0)[0] # Color splash splash = color_splash(image, r['masks']) # RGB -> BGR to save image to video splash = splash[..., ::-1] # Add image to video writer vwriter.write(splash) count += 1 vwriter.release() print("Saved to ", file_name)
def save_masks(model, it, config): """ For self-training。 将训练得到的模型再应用于训练集,得到新一轮的训练标签(masks),并保存下来。 """ for subset in ['train', 'val']: if it == 0: dataset = VertebralDataset() dataset.load_vertebral(args.dataset[:-4], subset) dataset.prepare() else: dataset = VertebralDataset_self_training() dataset.load_vertebral(args.dataset, subset, it) dataset.prepare() FOLDER_PATH = f'/DATA5_DB8/data/sqpeng/data/vertebrae_masks/iter_{it}' if not os.path.exists(FOLDER_PATH): os.mkdir(FOLDER_PATH) for image_id in tqdm(dataset.image_ids): # image, image_meta, gt_class_id, gt_bbox, gt_mask = \ # modellib.load_image_gt(dataset, config, image_id, use_mini_mask=False) image = dataset.load_image(image_id) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) info = dataset.image_info[image_id] print("image ID: {}.{} ({}) {}".format(info["source"], info["id"], image_id, dataset.image_reference(image_id))) # Run object detection results = model.detect([image], verbose=1) # print('rois: ', results[0]['rois']) filtered_roi = roi_filter(dataset, image_id, config, model) r = results[0] count_masks = 0 for i, roi in enumerate(filtered_roi): if np.any(roi): count_masks += 1 mask = np.zeros([image.shape[0], image.shape[1], count_masks], dtype=np.bool) index = 0 for i, roi in enumerate(filtered_roi): if np.any(roi): mask[:, :, index] = r['masks'][:, :, i] index += 1 file_name = os.path.join(FOLDER_PATH, f'{info["id"]}.npy') np.save(file_name, mask) print("Saved to ", file_name)
def predict2(image_fps, min_conf=0.90, augment=False): RESIZE_FACTOR = ORIG_SIZE / inference_config_2.IMAGE_SHAPE[0] prediction={} for image_id in tqdm(image_fps): ds = pydicom.read_file(image_id) image = ds.pixel_array # If grayscale. Convert to RGB for consistency. if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image,) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=inference_config.IMAGE_MIN_DIM, min_scale=inference_config.IMAGE_MIN_SCALE, max_dim=inference_config.IMAGE_MAX_DIM, mode=inference_config.IMAGE_RESIZE_MODE) patient_id = os.path.splitext(os.path.basename(image_id))[0] r = model_2.detect([image]) r = r[0] if augment: r2 = model_2.detect([np.fliplr(image)]) r2 = r2[0] #print(r2['scores']) r = testing_augment(r, r2, min_conf, inference_config) if len(r['rois'])==0: prediction[patient_id]=[] else: prediction[patient_id]=[] for i in range(len(r['rois'])): if r['class_ids'][i]==2 and r['scores'][i] > min_conf: score = r['scores'][i] x = r['rois'][i][1] y = r['rois'][i][0] if x>0 and y>0: width = r['rois'][i][3] - x height = r['rois'][i][2] - y x*=RESIZE_FACTOR y*=RESIZE_FACTOR width*=RESIZE_FACTOR height*=RESIZE_FACTOR prediction[patient_id].append([score, x, y, width, height]) return prediction
def resize(filename): file_path = INPUT_DIR + filename image = io.imread(file_path) molded_image, window, scale, padding, crop = utils.resize_image( image, min_dim=IMAGE_MIN_DIM, max_dim=IMAGE_MAX_DIM, min_scale=IMAGE_MIN_SCALE, mode=IMAGE_RESIZE_MODE) output_path = OUTPUT_DIR + filename io.imsave(output_path, molded_image)
def get_fru_net_results(results_dir: str, dataset: VesicleDataset): WIN_NAME = 'img' cv.namedWindow(WIN_NAME) gt_boxes = [] gt_class_ids = [] gt_masks = [] results = [] images = [] for image_id in dataset.image_ids: origin_img = dataset.load_image(image_id) image, image_meta, gt_class_id, gt_bbox, gt_mask = \ modellib.load_image_gt(dataset, config, image_id, use_mini_mask=False) gt_boxes.append(gt_bbox) gt_class_ids.append(gt_class_id) gt_masks.append(gt_mask) # load masks img_name = dataset.image_info[image_id]['id'] name, ext = img_name.rsplit('.', 1) path = os.path.join(results_dir, f'{name}_labels.{ext}') mask_img = cv.imread(path, cv.IMREAD_GRAYSCALE + cv.IMREAD_ANYDEPTH) n = np.max(mask_img) class_ids = np.ones(n, dtype=np.int32) scores = np.ones(n, dtype=np.float32) mask = get_bin_mask(mask_img) image, window, scale, padding, crop = utils.resize_image( origin_img, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) mask = utils.resize_mask(mask, scale, padding, crop) rois = utils.extract_bboxes(mask) images.append(image) vis_img = image.copy() draw_masks_contours(vis_img, gt_mask, (0, 0, 255)) draw_masks_contours(vis_img, mask, (0, 255, 0)) cv.setWindowTitle(WIN_NAME, img_name) cv.imshow(WIN_NAME, vis_img) cv.waitKey(0) result = { 'class_ids': class_ids, 'scores': scores, 'masks': mask, 'rois': rois } results.append(result) return images, gt_boxes, gt_class_ids, gt_masks, results
def load_image_gt(dataset, config, image_id, augment=False, augmentation=None, use_mini_mask=False): image = dataset.load_image(image_id) mask, class_ids = dataset.load_mask(image_id) original_shape = image.shape image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) mask = utils.resize_mask(mask, scale, padding, crop) if augment: logging.warning("'augment' is deprecated. Use 'augmentation' instead.") if random.randint(0, 1): image = np.fliplr(image) mask = np.fliplr(mask) if augmentation: import imgaug MASK_AUGMENTERS = ["Sequential", "SomeOf", "OneOf", "Sometimes", "Fliplr", "Flipud", "CropAndPad", "Affine", "PiecewiseAffine"] def hook(images, augmenter, parents, default): """Determines which augmenters to apply to masks.""" return augmenter.__class__.__name__ in MASK_AUGMENTERS image_shape = image.shape mask_shape = mask.shape det = augmentation.to_deterministic() image = det.augment_image(image) mask = det.augment_image(mask.astype(np.uint8), hooks=imgaug.HooksImages(activator=hook)) assert image.shape == image_shape, "Augmentation shouldn't change image size" assert mask.shape == mask_shape, "Augmentation shouldn't change mask size" mask = mask.astype(np.bool) _idx = np.sum(mask, axis=(0, 1)) > 0 mask = mask[:, :, _idx] class_ids = class_ids[_idx] bbox = utils.extract_bboxes(mask) active_class_ids = np.zeros([dataset.num_classes], dtype=np.int32) source_class_ids = dataset.source_class_ids[dataset.image_info[image_id]["source"]] active_class_ids[source_class_ids] = 1 if use_mini_mask: mask = utils.minimize_mask(bbox, mask, config.MINI_MASK_SHAPE) image_meta = compose_image_meta(image_id, original_shape, image.shape, window, scale, active_class_ids) return image, image_meta, class_ids, bbox, mask
def runTesting(): config = InferenceConfig() config.NAME = "MyMRCNN_origin_Model" config.display() df = pd.read_excel(WORK_DIR + "/data_val.xlsx") model = modellib.MaskRCNN(mode="inference", config=config, model_dir=MODEL_DIR) model.load_weights(COCO_MODEL_PATH, by_name=True, exclude=[ "mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask" ]) model.load_weights(model.find_last(), by_name=True) trueSum = 0 predSum = 0 intersects = 0 for index, row in df.iterrows(): img_key = row["image_id"] trueclzMasks = [np.full((384, 576, 1), 0) for i in range(4)] predclzMasks = [np.full((576, 576, 1), 0) for i in range(4)] for idx, clz in enumerate(["Gravel", "Sugar", "Fish", "Flower"]): print(WORK_DIR + "/masks_shrinked/" + img_key + "_" + clz + ".png") clzMask = cv2.imread(WORK_DIR + "/masks_shrinked/" + img_key + "_" + clz + ".png") if clzMask is None: continue clzMask = clzMask[:, :, [0]] trueclzMasks[idx] = clzMask image = cv2.imread(WORK_DIR + "/train_image_shrinked/" + img_key + ".jpg") image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) results = model.detect([image], verbose=0) r = results[0] masks, class_ids, scores = r['masks'], r['class_ids'], r['scores'] for idx, clz_id in enumerate(class_ids): mask = masks[:, :, [idx]] predclzMasks[clz_id - 1] = np.logical_or(predclzMasks[clz_id - 1], mask) for i in range(4): predclzMasks[i] = predclzMasks[i][96:480, :, :] trueSum += np.sum(trueclzMasks) predSum += np.sum(predclzMasks) intersects += np.sum( np.logical_and(trueclzMasks, predclzMasks).astype(np.float32)) score = 2 * intersects / (predSum + trueSum) print("The score is ", score)
def predict(image_fps, filepath='submission.csv', min_conf=0.95): # assume square image # resize_factor = ORIG_SIZE / config.IMAGE_SHAPE[0] resize_factor = 0.25 #resize_factor = ORIG_SIZE with open(filepath, 'w') as file: file.write("patientId,PredictionString\n") for image_id in tqdm(image_fps): #ds = pydicom.read_file(image_id) pid = image_id.split('/')[-1].split('.')[0] image = cv2.imread(os.path.join(test_seg_dir, pid + ".png")) #image = trans.resize(image,(1024,1024)) #image = ds.pixel_array # If grayscale. Convert to RGB for consistency. if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image, ) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) patient_id = os.path.splitext(os.path.basename(image_id))[0] results = model.detect([image]) r = results[0] out_str = "" out_str += patient_id out_str += "," assert (len(r['rois']) == len(r['class_ids']) == len(r['scores'])) if len(r['rois']) == 0: pass else: num_instances = len(r['rois']) for i in range(num_instances): if r['scores'][i] > min_conf: out_str += ' ' out_str += str(round(r['scores'][i], 2)) out_str += ' ' # x1, y1, width, height x1 = r['rois'][i][1] y1 = r['rois'][i][0] width = r['rois'][i][3] - x1 height = r['rois'][i][2] - y1 bboxes_str = "{} {} {} {}".format(int(x1*resize_factor), int(y1*resize_factor), \ int(width*resize_factor), int(height*resize_factor)) out_str += bboxes_str file.write(out_str + "\n")
def predict(image_fps, filepath='submission.csv', min_conf=0.96): # assume square image resize_factor = ORIG_SIZE / config.IMAGE_SHAPE[0] #resize_factor = ORIG_SIZE with open(filepath, 'w') as file: file.write("patientId,PredictionString\n") # for image_id in tqdm(image_fps): ds = pydicom.read_file(image_id) image = ds.pixel_array # view_position= getattr(c_dicom, 'ViewPosition', '') # if view_position == 'AP': # min_conf=0.94.5 # else: # min_conf=0.96.5 # If grayscale. Convert to RGB for consistency. if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image,) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) # patient_id = os.path.splitext(os.path.basename(image_id))[0] # results = model.detect([image]) r = results[0] # out_str = "" out_str += patient_id out_str += "," assert( len(r['rois']) == len(r['class_ids']) == len(r['scores']) ) if len(r['rois']) == 0: pass else: num_instances = len(r['rois']) # for i in range(num_instances): if r['scores'][i] > min_conf: out_str += ' ' out_str += str(round(r['scores'][i], 2)) out_str += ' ' # # x1, y1, width, height x1 = r['rois'][i][1] y1 = r['rois'][i][0] width = r['rois'][i][3] - x1 height = r['rois'][i][2] - y1 bboxes_str = "{} {} {} {}".format(x1*resize_factor, y1*resize_factor, \ width*resize_factor, height*resize_factor) out_str += bboxes_str file.write(out_str+"\n")
def load_image(self, filepath): data = pydicom.read_file(filepath, force=True) image = data.pixel_array if len(image.shape) != 3 or image.shape[2] != 3: image = np.stack((image, ) * 3, -1) image, window, scale, padding, crop = utils.resize_image( image, min_dim=inference_config.IMAGE_MIN_DIM, min_scale=inference_config.IMAGE_MIN_SCALE, max_dim=inference_config.IMAGE_MAX_DIM, mode=inference_config.IMAGE_RESIZE_MODE) return image
def take_image(): #image = asfvjadsfkjbnslkasdflkasjflaksflakd # #RESIZE # if len(img.shape) > 2 and img.shape[2] == 4: image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR) image, window, scale, padding, _ = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) detect(image)
def compute_batch_ap(view_ids): max_views = 5 APs = [] APs_range = [] for view_index, view_id in enumerate(view_ids): image_ids = dataset.load_view(max_views, main_image=view_id, rnd_state=0) # skip instance if it has to few views (return of load_views=None) if not image_ids: continue image_ids = image_ids[:config.NUM_VIEWS] # Load image print("processing image {} of {}".format( view_index, view_ids.size)) image, image_meta, gt_class_id, gt_bbox, gt_mask =\ modellib.load_image_gt(dataset, config, image_ids[0], use_mini_mask=False) im = [] Rcam = [] Kmat = dataset.K for image_id in image_ids: image = dataset.load_image(image_id) image, _, _, _, _ = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) im.append(image) Rcam.append(dataset.load_R(image_id)) im = np.stack(im) Rcam = np.stack([Rcam]) Kmat = np.stack([Kmat]) # Run object detection results = model.detect([im], Rcam, Kmat) # Compute AP r = results[0] AP, precisions, recalls, overlaps =\ utils.compute_ap(gt_bbox, gt_class_id, gt_mask, r['rois'], r['class_ids'], r['scores'], r['masks']) #AP_range = utils.compute_ap_range(gt_bbox, gt_class_id, gt_mask, # r['rois'], r['class_ids'], r['scores'], r['masks'], verbose=0) APs.append(AP) #APs_range.append(AP_range) print("meanAP: {}".format(np.mean(APs))) #print("AP_range: {}".format(np.mean(APs_range))) return APs, APs_range
def mold_inputs(self, images): ''' Takes a list of images and modifies them to the format expected as an input to the neural network. - resize to IMAGE_MIN_DIM / IMAGE_MAX_DIM : utils.RESIZE_IMAGE() - subtract mean pixel vals from image pxls : utils.MOLD_IMAGE() - build numpy array of image metadata : utils.COMPOSE_IMAGE_META() images : List of image matricies [height,width,depth]. Images can have different sizes. Returns 3 Numpy matrices: molded_images: [N, h, w, 3]. Images resized and normalized. image_metas : [N, length of meta data]. Details about each image. windows : [N, (y1, x1, y2, x2)]. The portion of the image that has the original image (padding excluded). ''' molded_images = [] image_metas = [] windows = [] for image in images: # Resize image to fit the model expected size # TODO: move resizing to mold_image() molded_image, window, scale, padding = utils.resize_image( image, min_dim=self.config.IMAGE_MIN_DIM, max_dim=self.config.IMAGE_MAX_DIM, padding=self.config.IMAGE_PADDING) # subtract mean pixel values from image pixels molded_image = utils.mold_image(molded_image, self.config) # Build image_meta image_meta = utils.compose_image_meta( 0, image.shape, window, np.zeros([self.config.NUM_CLASSES], dtype=np.int32)) # Append molded_images.append(molded_image) image_metas.append(image_meta) windows.append(window) # Pack into arrays molded_images = np.stack(molded_images) image_metas = np.stack(image_metas) windows = np.stack(windows) return molded_images, image_metas, windows
def get_one_target(category, dataset, config, augmentation=None, target_size_limit=0, max_attempts=10, return_all=False, return_original_size=False): n_attempts = 0 while True: # Get index with corresponding images for each category category_image_index = dataset.category_image_index # Draw a random image random_image_id = np.random.choice(category_image_index[category]) # Load image target_image, target_image_meta, target_class_ids, target_boxes, target_masks = \ modellib.load_image_gt(dataset, config, random_image_id, augmentation=augmentation, use_mini_mask=config.USE_MINI_MASK) # print(random_image_id, category, target_class_ids) if not np.any(target_class_ids == category): continue # try: # box_ind = np.random.choice(np.where(target_class_ids == category)[0]) # except ValueError: # return None box_ind = np.random.choice(np.where(target_class_ids == category)[0]) tb = target_boxes[box_ind, :] target = target_image[tb[0]:tb[2], tb[1]:tb[3], :] original_size = target.shape target, window, scale, padding, crop = utils.resize_image( target, min_dim=config.TARGET_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, #Same scaling as the image max_dim=config.TARGET_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) #Same output format as the image n_attempts = n_attempts + 1 if (min(original_size[:2]) >= target_size_limit) or (n_attempts >= max_attempts): break if return_all: return target, window, scale, padding, crop elif return_original_size: return target, original_size else: return target
def enlarge_mask(image_ori=[], pred=[], gt=[], config=None): if len(list(np.shape(image_ori))) == 2: image_ori = np.stack([image_ori, image_ori, image_ori], axis=-1) image_enlarge, window, scale, padding, crop = utils.resize_image( image_ori, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) pred_enlarge = [] image_enlarge_shape = np.shape(image_enlarge) if pred != []: pred_shape = np.shape(pred) # if len(list(np.shape(pred))) == 2: # pred = np.stack([pred, pred, pred], axis=-1) # if np.shape(pred) != (config.IMAGE_MIN_DIM, config.IMAGE_MAX_DIM, 3): # pred_enlarge = utils.resize_mask(pred, [config.IMAGE_MIN_DIM, config.IMAGE_MAX_DIM], padding) # else: # pred_enlarge = pred # pred_enlarge = pred_enlarge[:, :, 0] if not np.max(pred) == 0: pred = pred / np.max(pred) if pred_shape[:2] != (config.IMAGE_MIN_DIM, config.IMAGE_MAX_DIM): if pred_shape[0] == pred_shape[1]: pred = pred * 255 pred_enlarge = utils.resize_mask( pred, [config.IMAGE_MIN_DIM, config.IMAGE_MAX_DIM], [(0, 0), (0, 0)]) # pred should be 0-255 else: pred_enlarge = utils.rescale_mask( pred, scale, padding) # pred should be 0-1 else: pred_enlarge = pred else: pred_enlarge = np.zeros(image_enlarge_shape[:2], np.uint8) else: # pred_enlarge = np.zeros(image_enlarge_shape[:2], np.uint8) pass gt_enlarge = [] if gt != []: if len(list(np.shape(gt))) == 2: gt = np.stack([gt, gt, gt], axis=-1) if np.shape(gt) != (config.IMAGE_MIN_DIM, config.IMAGE_MAX_DIM, 3): gt_enlarge = utils.rescale_mask(gt, scale, padding) else: gt_enlarge = gt gt_enlarge = gt_enlarge[:, :, 0] return image_enlarge, pred_enlarge, gt_enlarge
def resize_masks(filename): file_path = INPUT_DIR + filename print(file_path) image = np.load(file_path) if image.shape[2] > 0: molded_image, window, scale, padding, crop = utils.resize_image( image, min_dim=IMAGE_MIN_DIM, max_dim=IMAGE_MAX_DIM, min_scale=IMAGE_MIN_SCALE, mode=IMAGE_RESIZE_MODE) else: molded_image = image output_path = OUTPUT_DIR + filename np.save(output_path, molded_image)
def draw_mask(self, num_obj, image_id, mask, mask_folders): info = self.image_info[image_id] for index in range(len(mask_folders)): image = Image.open(mask_folders[index]) image = image.convert("RGB") image = np.array(image, dtype=np.uint8) # 调整到固定大小 image, window, scale, padding = utils.resize_image( image, min_dim=config.IMAGE_MIN_DIM, max_dim=config.IMAGE_MAX_DIM, mode="square") image = image[:,:,0] image[image>0] = 1 mask[:, :, index] = image return mask
def load_depth(self, image_id, config): """returns the depth image of the correpsonding image_id""" depth_path = os.path.join( self.dataset_dir, self.image_info[image_id]["subfolder"], 'depth0/data', str(self.image_info[image_id]["image_sub_id"]) + '.png') depth_image = imageio.imread(depth_path) depth_image = depth_image[:, :, np.newaxis] depth_image, _, _, _, _ = utils.resize_image( depth_image, min_dim=20, min_scale=config.IMAGE_MIN_SCALE, max_dim=20, mode=config.IMAGE_RESIZE_MODE) depth_image = depth_image[:, :, 0] return depth_image
def load_image(path): image = io.imread(path) # If grayscale. Convert to RGB for consistency. if image.ndim != 3: image = skimage.color.gray2rgb(image) # If has an alpha channel, remove it for consistency if image.shape[-1] == 4: image = image[..., :3] original_shape = image.shape image, window, scale, padding, crop = utils.resize_image( image, min_dim=inference_config.IMAGE_MIN_DIM, min_scale=inference_config.IMAGE_MIN_SCALE, max_dim=inference_config.IMAGE_MAX_DIM, mode=inference_config.IMAGE_RESIZE_MODE) return image
def mold_inputs(images): """Takes a list of images and modifies them to the format expected as an input to the neural network. images: List of image matricies [height,width,depth]. Images can have different sizes. Returns 3 Numpy matricies: molded_images: [N, h, w, 3]. Images resized and normalized. image_metas: [N, length of meta data]. Details about each image. windows: [N, (y1, x1, y2, x2)]. The portion of the image that has the original image (padding excluded). """ molded_images = [] image_metas = [] windows = [] #print('IMAGE_PADDING: ',inference_config.IMAGE_RESIZE_MODE) for image in images: # Resize image to fit the model expected size # TODO: move resizing to mold_image() molded_image, window, scale, padding, crop = utils.resize_image( image, min_dim=inference_config.IMAGE_MIN_DIM, max_dim=inference_config.IMAGE_MAX_DIM, mode=inference_config.IMAGE_RESIZE_MODE) #print(image.shape) #print('Image resized at: ', molded_image.shape) #print(window) #print(scale) """Takes RGB images with 0-255 values and subtraces the mean pixel and converts it to float. Expects image colors in RGB order.""" molded_image = mold_image(molded_image, inference_config) #print('Image molded') """Takes attributes of an image and puts them in one 1D array.""" image_meta = compose_image_meta( 0, image.shape, molded_image.shape, window, scale, np.zeros([inference_config.NUM_CLASSES], dtype=np.int32)) #print('Meta of image prepared') # Append molded_images.append(molded_image) windows.append(window) image_metas.append(image_meta) # Pack into arrays molded_images = np.stack(molded_images) image_metas = np.stack(image_metas) windows = np.stack(windows) return molded_images, image_metas, windows
def process_one_image(self, image_path, bbox_ori, class_id): """ """ def resize_bbox(bbx, scale, padding, crop): bbx = [i * scale for i in bbx] bbx[0] += padding[1][0] bbx[2] += padding[1][0] bbx[1] += padding[0][0] bbx[3] += padding[0][0] bbx = [int(i) for i in bbx] return bbx config = self.config # class_id = self.map_source_class_id( "clothes.{}".format(class_id)) class_ids = np.array([class_id]).astype(np.int32) img_img = image.load_img(image_path) img = image.img_to_array(img_img) if img.shape[:2] != (300, 300): print('sa') img_resize, window, scale, padding, crop = utils.resize_image( img, min_dim=config.IMAGE_MIN_DIM, min_scale=config.IMAGE_MIN_SCALE, max_dim=config.IMAGE_MAX_DIM, mode=config.IMAGE_RESIZE_MODE) class_ids = np.array([class_id]).astype(np.int32) # Bounding boxes. Note that some boxes might be all zeros # if the corresponding mask got cropped out. # bbox: [num_instances, (y1, x1, y2, x2)] bbox = resize_bbox(bbox_ori, scale, padding, crop) bbox = np.array([bbox]).astype(np.int32) # Active classes # Different datasets have different classes, so track the # classes supported in the dataset of this image. # if bbox.shape[0]>1: # print("------------bbox num:", bbox.shape[0]) return bbox, class_ids