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
