def visualise_annotations(dataset, n_instances= None):
'''
dataset : hsDataset
n_instances : Number of images. Default is 'None'. When it is None takes entire dataset
n_instances must be in between 1 and the size of the dataset.
'''
if n_instances == None:
size = len(dataset.image_ids)
else:
size = n_instances
for image_id in range(size):
image = dataset.load_image(image_id)
if image.shape[-1] == 4: # PNG images have alpha channel as the 4th channel.
image = image[..., :3] # Drop the 4th channel
mask, class_ids = dataset.load_mask(image_id)
bbox = utils.extract_bboxes(mask)
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
ax = get_ax(1)
try:
visualize.display_instances(image, bbox, mask, class_ids, dataset.class_names, ax=ax)
except ValueError:
print("Image size and Mask size does not match")
def compare_bbox_rbbox_from_annotations(annotation, image_dir):
for elem in annotation:
img_ext = elem.split('.')[-1]
img_name = elem.replace(img_ext, 'jpg')
image = cv2.imread(os.path.join(image_dir, img_name))
width, height = image.shape[:2]
# print('[INFO] working on {}'.format(img_name))
bbox_ABI = []
bbox_AUI = []
rbbox_ABI = []
rbbox_AUI = []
try:
masks = load_masks_from_annotation(annotation[elem],
width=width,
height=height)
bboxes = extract_bboxes(masks)
# print('[DEBUG] Number of objects : {}'.format(len(bboxes)))
(a, b, c,
d) = rbb_utils.get_bbox_rbbox_values(image, masks, bboxes)
# print('[INFO] Average useful information on image : - hbbox : {} | rbbox : {}'.format(a,b))
# print('[INFO] Average percentage of intersection between boxes on image : - hbbox : {} | rbbox : {}'.format(c,d))
# print('')
bbox_ABI.append(a)
rbbox_ABI.append(b)
bbox_AUI.append(c)
rbbox_AUI.append(d)
except AssertionError:
continue
return (np.mean(bbox_ABI), np.mean(rbbox_ABI), np.mean(bbox_AUI),
np.mean(rbbox_AUI))
def compute_gt_stats(gt_bbox, gt_mask):
# Compute statistics for all the ground truth things.
hw = gt_bbox[:,2:] - gt_bbox[:,:2]
hw = hw*1.
min_side = np.min(hw,1)[:,np.newaxis]
max_side = np.max(hw,1)[:,np.newaxis]
aspect_ratio = np.max(hw, 1) / np.min(hw, 1)
aspect_ratio = aspect_ratio[:,np.newaxis]
log_aspect_ratio = np.log(aspect_ratio)
box_area = np.prod(hw, 1)[:,np.newaxis]
log_box_area = np.log(box_area)
sqrt_box_area = np.sqrt(box_area)
modal_area = np.sum(np.sum(gt_mask, 0), 0)[:,np.newaxis]*1.
log_modal_area = np.log(modal_area)
sqrt_modal_area = np.sqrt(modal_area)
# Number of distinct components
ov_connected = sqrt_box_area*1.
for i in range(gt_mask.shape[2]):
aa = skimage.measure.label(gt_mask[:,:,i], background=0)
sz = np.bincount(aa.ravel())[1:]
biggest = np.argmax(sz)+1
big_comp = utilslib.extract_bboxes(aa[:,:,np.newaxis]==biggest)
ov_connected[i,0] = utilslib.compute_overlaps(big_comp, gt_bbox[i:i+1,:])
a = np.concatenate([min_side, max_side, aspect_ratio, log_aspect_ratio,
box_area, log_box_area, sqrt_box_area, modal_area, log_modal_area,
sqrt_modal_area, ov_connected], 1)
n = ['min_side', 'max_side', 'aspect_ratio', 'log_aspect_ratio', 'box_area',
'log_box_area', 'sqrt_box_area', 'modal_area', 'log_modal_area',
'sqrt_modal_area', 'ov_connected']
return a, n
def createClipedImage():
for item in Path(basePath + "/masks3").rglob('*.png'):
filePath = str(item)
img_id, img_class, class_instance = filePath.split(
os.sep)[-1].split("_")
img_file_name = filePath.split(os.sep)[-1]
img_mask_data = cv2.imread(filePath)
img_mask_data = img_mask_data[:, :, [0]]
bbox = utils.extract_bboxes(img_mask_data.astype(np.uint8))[0]
scaleX, scaleY = 2100 / 576, 1400 / 384
y1, x1, y2, x2 = int(bbox[0] * scaleY), int(bbox[1] * scaleX), int(
bbox[2] * scaleY), int(bbox[3] * scaleX)
width = x2 - x1
height = y2 - y1
if width / height < 0.4 or width / height > 2.5:
continue
if width < 25 or height < 18:
continue
img = cv2.imread(basePath + "train_images/" + img_id + ".jpg")
clippedImg = img[y1:y2, x1:x2, :]
if width < height:
clippedImg = np.transpose(clippedImg, axes=(1, 0, 2))
clippedImg = cv2.resize(clippedImg, (576, 384))
cropped_img_file_name = basePath + "/train_class_images/" + img_file_name
print(cropped_img_file_name)
cv2.imwrite(cropped_img_file_name, clippedImg)
def plot_sun_rgb():
image_ids = random.choices(dataset_rgb.image_ids, k=10)
for image_id in image_ids:
print(image_id)
image = dataset_rgb.load_image(image_id)
mask, class_ids = dataset_rgb.load_mask(image_id)
bbox = utils.extract_bboxes(mask)
_, ground_truth = visualize.display_instances(image, bbox, mask,
class_ids,
dataset_rgb.class_names)
_, result_rgb = plot_inference(model_rgb, dataset_rgb, image_id, image)
_, result_d3 = plot_inference(model_d3, dataset_d3, image_id, image)
_, result_rgbd = plot_inference(model_rgbd, dataset_rgbd, image_id,
image)
_, result_rgbd_fusenet = plot_inference(model_rgbd_fusenet,
dataset_rgbd_fusenet, image_id,
image)
ground_truth.savefig("inference_" + str(image_id) +
"_ground_truth.png")
result_rgb.savefig("inference_" + str(image_id) + "_sun_rgb.png")
result_d3.savefig("inference_" + str(image_id) + "_sun_d3.png")
result_rgbd.savefig("inference_" + str(image_id) + "_sun_rgbd.png")
result_rgbd_fusenet.savefig("inference_" + str(image_id) +
"_sun_rgbd_fusenet.png")
def load_and_display_random_sample(dataset, datacfg, N=2):
"""Load and display random samples
"""
log.info("load_and_display_random_sample::-------------------------------->")
image_ids = np.random.choice(dataset.image_ids, N)
class_names = dataset.class_names
log.debug("dataset: len(image_ids): {}\nimage_ids: {}".format(len(image_ids), image_ids))
log.debug("dataset: len(class_names): {}\nclass_names: {}".format(len(class_names), class_names))
for image_id in image_ids:
image = dataset.load_image(image_id, datacfg)
mask, class_ids, keys, values = dataset.load_mask(image_id, datacfg)
log.debug("keys: {}".format(keys))
log.debug("values: {}".format(values))
log.debug("class_ids: {}".format(class_ids))
## Display image and instances
visualize.display_top_masks(image, mask, class_ids, class_names)
## Compute Bounding box
bbox = utils.extract_bboxes(mask)
log.debug("bbox: {}".format(bbox))
visualize.display_instances(image, bbox, mask, class_ids, class_names)
def visualise_annotation_by_pos(dataset, position):
'''
dataset : hsDataset
position : Index of the desired image
'''
image = dataset.load_image(position)
if image.shape[-1] == 4:
image = image[..., :3]
mask, class_ids = dataset.load_mask(position)
bbox = utils.extract_bboxes(mask)
print("image_id ", position, dataset.image_reference(position))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
ax = get_ax(1)
try:
visualize.display_instances(image, bbox, mask, class_ids, dataset.class_names, ax=ax)
except ValueError:
print("Image size and Mask size does not match")
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 display_dataset(num_of_random_samples):
# Load and display random samples
if num_of_random_samples >= len(dataset.image_ids):
print(
"The number of samples cannot be larger than the amount of samples available"
)
print("\nSetting the amount of equal to the amount of samples")
num_of_random_samples = len(dataset.image_ids) - 1
image_ids = np.random.choice(dataset.image_ids, num_of_random_samples)
for image_id in image_ids:
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
visualize.display_top_masks(image, mask, class_ids,
dataset.class_names)
# Load random image and mask.
image_id = random.choice(dataset.image_ids)
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
# Display image and instances
visualize.display_instances(image, bbox, mask, class_ids,
dataset.class_names)
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 load_image_gt_without_resizing(dataset, datacfg, config, image_id):
"""Inspired from load_image_gt, but does not re-size the image
"""
# Load image and mask
image = dataset.load_image(image_id, datacfg, config)
mask, class_ids, keys, values = dataset.load_mask(image_id, datacfg,
config)
# Note that some boxes might be all zeros if the corresponding mask got cropped out.
# and here is to filter them out
_idx = np.sum(mask, axis=(0, 1)) > 0
mask = mask[:, :, _idx]
class_ids = class_ids[_idx]
# 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 = utils.extract_bboxes(mask)
# Active classes
# Different datasets have different classes, so track the
# classes supported in the dataset of this image.
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
# return image, class_ids, bbox, mask
return image, class_ids, bbox, mask, active_class_ids
def bbox_show(image, mask):
"""Apply bbox and show"""
if mask.shape[-1] > 0:
# mask = (np.sum(mask, -1, keepdims=True) >= 1)
bbox = utils.extract_bboxes(mask)
class_ids = np.array([1 for i in range(bbox.shape[0])])
visualize.display_instances(image, bbox, mask, class_ids,
['BG', 'GARBAGE'])
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)
# 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())
# bbox
mask, class_ids = BoxDataset.load_mask(file_name)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
visualize.display_instances(image, bbox, mask, class_ids,
BoxDataset.class_names)
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 run_map(out_path, num2_1, num2_2):
dataset_val = ExpressDataset()
dataset_val.out_path(out_path)
dataset_val.set_dataset_class('val')
dataset_val.set_dataset_exit_flag(True)
dataset_val.load_shapes(num2_1, num2_2, 0)
dataset_val.prepare()
class InferenceConfig(ExpressConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
inference_config = InferenceConfig()
# Recreate the model in inference mode
model = modellib.MaskRCNN(mode="inference",
config=inference_config,
model_dir=MODEL_DIR)
# Get path to saved weights
# Either set a specific path or find last trained weights
# model_path = os.path.join(ROOT_DIR, ".h5 file name here")
#model_path = '/home/kingqi/proj/Mask_RCNN/log/express20190424T1751/mask_rcnn_express_0006.h5'
model_path = model.find_last()
# Load trained weights
print("Loading weights from ", model_path)
model.load_weights(model_path, by_name=True)
image_ids = np.random.choice(dataset_val.image_ids, num2_1 + num2_2 * 6)
APs = []
for image_id in image_ids:
# Load image and ground truth data
image, image_meta, gt_class_id, gt_bbox, gt_mask = modellib.load_image_gt(
dataset_val, inference_config, image_id, use_mini_mask=False)
molded_images = np.expand_dims(
modellib.mold_image(image, inference_config), 0)
image1 = dataset_val.load_image(image_id)
mask1, class_ids1 = dataset_val.load_mask(image_id)
bbox = utils.extract_bboxes(mask1)
# visualize.display_top_masks(image, mask, class_ids, dataset_train.class_names)
#visualize.display_instances(image1, bbox, mask1, class_ids1, dataset_val.class_names)
# Run object detection
results = model.detect([image], verbose=0)
r = results[0]
# visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'],
# dataset_val.class_names, r['scores'])
# Compute AP
AP, precisions, recalls, overlaps = utils.compute_ap(
gt_bbox, gt_class_id, gt_mask, r["rois"], r["class_ids"],
r["scores"], r['masks'])
APs.append(AP)
print("mAP: ", np.mean(APs))
def evaluation(image_ids, y_pred, dataset):
import matplotlib.pyplot as plt
def get_ax(rows=1, cols=1, size=16):
_, ax = plt.subplots(rows, cols, figsize=(size * cols, size * rows))
return ax
y_true = []
for i in image_ids:
mask, class_ids = dataset.load_mask(i)
bbox = utils.extract_bboxes(mask)
y_true.append([bbox, class_ids, mask])
pickle.dump(y_true, open('y_true', 'wb'))
ax = get_ax(len(image_ids), 2)
if len(image_ids) <= 3:
for index, i in enumerate(image_ids):
image = dataset.load_image(i)
visualize.display_instances(image,
y_true[i][0],
y_true[i][2],
y_true[i][1],
dataset.class_names,
ax=ax[0],
title="True")
visualize.display_instances(image,
y_pred[i]['rois'],
y_pred[i]['masks'],
y_pred[i]['class_ids'],
dataset.class_names,
y_pred[i]['scores'],
ax=ax[1],
title="Predicted")
plt.show()
image = dataset.load_image(i)
w, h = image.shape[0], image.shape[1]
print(w, h)
mask_pred = Image.new('1', (w, h))
mask_true = Image.new('1', (w, h))
bah = []
currentIoU = 0
for index_true, i in enumerate(y_true[0][0]):
bah.append([])
for index_pred, j in enumerate(y_pred[0]['rois']):
currentIoU = IoU(i, j, mask_pred, mask_true)
bah[index_true].append((currentIoU, y_true[0][1][index_true],
y_pred[0]['class_ids'][index_pred]))
return bah
def displayImage(self):
image_id = '00010'
image = train_set.load_image(int(image_id))
print(image.shape)
# load image mask
mask, class_ids = train_set.load_mask(int(image_id))
bbox = extract_bboxes(mask)
print('final box- ' + str(bbox))
# display image with masks and bounding boxes
display_instances(image, bbox, mask, class_ids, train_set.class_names)
def combineSameBBoxMask():
maskdicts = {}
for item in Path(basePath + "/masks_seperated").rglob('*.png'):
filePath = str(item)
img_id, img_class, class_instance = item.name.split("_")
img_mask_data = cv2.imread(filePath)
img_mask_data = img_mask_data[:, :, [0]]
cur_bbox = utils.extract_bboxes(img_mask_data.astype(np.uint8))[0]
y1, x1, y2, x2 = cur_bbox[0], cur_bbox[1], cur_bbox[2], cur_bbox[3]
cur_area = (x2 - x1) * (y2 - y1)
if img_id not in maskdicts.keys():
img_inst = {}
maskdicts[img_id] = img_inst
if img_class not in img_inst.keys():
img_cls = []
img_inst[img_class] = img_cls
if len(img_cls) == 0:
new_Inst = {"path": [filePath], "bbox": cur_bbox, "ambi": False}
img_cls.append(new_Inst)
else:
findInstance = False
for instance in img_cls:
inst_bbox = instance["bbox"]
_y1, _x1, _y2, _x2 = inst_bbox[0], inst_bbox[1], inst_bbox[
2], inst_bbox[3]
if (abs(y1 - _y1) < 10
or abs(y2 - _y2) < 10) and (abs(x2 - _x1) < 60
or abs(x1 - _x2) < 60):
instance["bbox"] = boxU(cur_bbox, inst_bbox)
instance["path"].append(filePath)
findInstance = True
if not findInstance:
new_Inst = {
"path": [filePath],
"bbox": cur_bbox,
"ambi": False
}
img_cls.append(new_Inst)
for id in maskdicts:
imgs = maskdicts[id]
for cls_name in imgs:
cls_insts = imgs[cls_name]
for idx, inst in enumerate(cls_insts):
img_data = np.zeros([384, 576])
for path in inst["path"]:
data = cv2.imread(path)
img_data = np.logical_or(img_data, data[:, :, 0])
img_data = img_data * 255
_img_id, _img_class, _class_instance = inst["path"][0].split(
os.sep)[-1].split("_")
new_mask_file = _img_id + "_" + _img_class + "_" + str(idx)
cv2.imwrite(
basePath + "masks_seperated2/" + new_mask_file + ".png",
img_data.astype(np.uint8))
print(basePath + "masks_seperated2/" + new_mask_file + ".png")
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 test2(model):
""" Test the model on input dataset """
dataset = SidelobeDataset()
dataset.load_dataset(args.dataset)
dataset.prepare()
for index, image_id in enumerate(dataset.image_ids):
# - Load image
image = dataset.load_image(image_id)
image_path = dataset.image_info[index]['path']
image_path_base = os.path.basename(image_path)
image_path_base_noext = os.path.splitext(image_path_base)[0]
# - Load mask
mask_gt = dataset.load_gt_mask(image_id)
mask_gt_chan3 = np.broadcast_to(mask_gt, image.shape)
image_masked_gt = np.copy(image)
image_masked_gt[np.where(
(mask_gt_chan3 == [True, True,
True]).all(axis=2))] = [255, 255, 0]
outfile = 'gtmask_' + image_path_base_noext + '.png'
skimage.io.imsave(outfile, image_masked_gt)
# - Extract true bounding box from true mask
bboxes_gt = utils.extract_bboxes(mask_gt)
# Detect objects
r = model.detect([image], verbose=0)[0]
mask = r['masks']
bboxes = r['rois']
##bboxes= utils.extract_bboxes(mask)
class_labels = r['class_ids']
nobjects = mask.shape[-1]
if nobjects <= 0:
print("INFO: No object mask found for image %s ..." %
image_path_base)
continue
# Save image with masks
outfile = 'out_' + image_path_base_noext + '.png'
visualize.display_instances(image,
r['rois'],
r['masks'],
r['class_ids'],
dataset.class_names,
r['scores'],
show_bbox=True,
show_mask=True,
title="Predictions")
plt.savefig(outfile)
def score():
image_path = "static/downloaded.jpg"
image = skimage.io.imread(image_path)
r = model.detect([image], verbose=1)
r = r[0]
mask, class_ids, scores = r['masks'], r['class_ids'], r['scores']
bbox = utils.extract_bboxes(mask)
classes = ["BG", "flat", "dome", "tree", "N", "NE", "E", "SE", "S", "SW", "W", "NW"]
display_instances(image, bbox, mask, class_ids, classes, scores)
return url_for("static", filename='scored.jpg')
def deleteAbnormalMask():
moveToPath = basePath + "/masktoremove"
for item in Path(basePath + "/masks_seperated2").rglob('*.png'):
filePath = str(item)
img_mask_data = cv2.imread(filePath)
img_mask_data = img_mask_data[:, :, [0]]
bbox = utils.extract_bboxes(img_mask_data.astype(np.uint8))
y1, x1, y2, x2 = bbox[0][0], bbox[0][1], bbox[0][2], bbox[0][3]
width = x2 - x1
height = y2 - y1
print(filePath)
if width * height < 2000:
imgName = filePath.split(os.sep)[-1]
shutil.move(filePath, moveToPath + "/" + imgName)
def data_split(file, number, left=True):
"""
3D scan generate ROI, ROI mask and weights
:param file:scan
:param left:if the scan is left or not
:return:ROI,ROI_mask,weights
"""
scan = np.array(file['scan'])
CartTM = np.array(file['CartTM'])
pred = ROI1[number]
if left is False:
scan = reverse(scan)
CartTM = reverse(CartTM)
scan = np.lib.pad(scan, 2, padwithzeros)
CartTM = np.lib.pad(CartTM, 2, padwithzeros)
CartTM_cor = np.array(np.where(CartTM > 0)).T
print(len(CartTM_cor))
# x = int(round(max(np.array(CartTM_cor.T[0])) + min(np.array(CartTM_cor.T[0])))/2)
# y = int(round(max(np.array(CartTM_cor.T[1])) + min(np.array(CartTM_cor.T[1])))/2)
# z = int(round(max(np.array(CartTM_cor.T[2])) + min(np.array(CartTM_cor.T[2])))/2)
x = int(round((pred[0] + pred[1]) / 2))
y = int(round((pred[2] + pred[3]) / 2))
z = int(round((pred[4] + pred[5]) / 2))
# print(x,y,z)
ROI = scan[x - 16:x + 16, y - 40:y + 40, z - 24:z + 24]
ROI_mask = CartTM[x - 16:x + 16, y - 40:y + 40, z - 24:z + 24]
print(scan.shape)
print(CartTM.shape)
bbx = utils.extract_bboxes(CartTM)
print(bbx.shape)
# ROI = scan[x-8:x+8, y-32:y+32, z-16:z+16]
# ROI_mask = CartTM[x-8:x+8, y-32:y+32, z-16:z+16]
# print(ROI_mask.shape)
cart_cor = np.array(np.where(ROI_mask > 0)).T
# back_cor = np.array(np.where(ROI_mask == 0)).T
print(ROI.shape)
print(len(cart_cor))
print(len(cart_cor) / len(CartTM_cor))
print(len(cart_cor) / ROI.size)
# print(back_cor.shape)
# ROI_mask = np.array([np.array(np.where(ROI_mask > 0))*8, np.array(np.where(ROI_mask ==0))])
ROI = ROI[..., np.newaxis]
ROI_mask = onehot(ROI_mask).reshape(ROI.size, 2)
weights = np.zeros((ROI.size))
for i in range(ROI.size):
if ROI_mask[i][0] == 0:
weights[i] = 1 - len(cart_cor) / ROI.size
else:
weights[i] = len(cart_cor) / ROI.size
return ROI, ROI_mask, weights
def getCenteredClassBboxes(datasetPath: str,
imageName: str,
classToCenter: str,
image_size=1024,
imageFormat="jpg",
allow_oversized=True,
config: Config = None,
verbose=0):
"""
Computes and returns bboxes of all masks of the given image and class
:param datasetPath: path to the dataset containing the image folder
:param imageName: the image name
:param classToCenter: the class to center and get the bbox from
:param image_size: the minimal height and width of the bboxes
:param imageFormat: the image format to use to get original image
:param allow_oversized: if False, masks that does not fit image_size will be skipped
:param config: if given, config file is used to know if mini_masks are used
:param verbose: level of verbosity
:return: (N, 4) ndarray of [y1, x1, y2, x2] matching bboxes
"""
imagePath = os.path.join(datasetPath, imageName, 'images',
f'{imageName}.{imageFormat}')
image = cv2.imread(imagePath, cv2.IMREAD_COLOR)
image_shape = image.shape[:2]
classDirPath = os.path.join(datasetPath, imageName, classToCenter)
maskList = os.listdir(classDirPath)
classBboxes = np.zeros((len(maskList), 4), dtype=int)
toDelete = []
for idx, mask in enumerate(maskList):
maskPath = os.path.join(classDirPath, mask)
if config is not None and config.is_using_mini_mask():
bbox = getBboxFromName(mask)
else:
maskImage = cv2.imread(maskPath, cv2.IMREAD_GRAYSCALE)
bbox = utils.extract_bboxes(maskImage)
if not allow_oversized:
h, w = bbox[2:] - bbox[:2]
if h > image_size or w > image_size:
if verbose > 1:
print(
f"{mask} mask could not fit into {(image_size, image_size)} image"
)
toDelete.append(idx)
classBboxes[idx] = center_mask(bbox,
image_shape,
min_output_shape=image_size,
verbose=verbose)
classBboxes = np.delete(classBboxes, toDelete, axis=0)
return classBboxes
def display_samples(self):
"""
Display 20 samples with their masks
"""
for i in range(20):
# define image id
image_id = i
# load the image
image = self.train_set.load_image(image_id)
# load the masks and the class ids
mask, class_ids = self.train_set.load_mask(image_id)
# extract bounding boxes from the masks
bbox = extract_bboxes(mask)
# display image with masks and bounding boxes
display_instances(image, bbox, mask, class_ids, self.train_set.class_names)
def loadOnlyMask(imagePath, imageShape):
mask = cv2.imread(imagePath, cv2.IMREAD_UNCHANGED)
if mask.shape[0] != imageShape[0] or mask.shape[1] != imageShape[1]:
# Finding bbox coordinates from image name
bbox = getBboxFromName(imagePath)
shifted = shift_bbox(bbox)
y1, x1, y2, x2 = shifted
# Expanding mask to its real size
mask = expand_mask(shifted, mask, image_shape=shifted[2:])
mask = mask.astype(np.uint8) * 255
else:
# Extracting bbox of
bbox = extract_bboxes(mask)
y1, x1, y2, x2 = bbox
return mask[y1:y2, x1:x2, ...], bbox
def show_image(dataset: Dataset) -> NoReturn:
"""
Позволяет просматривать изображения в наборах данных
:param dataset:
:return:
"""
# define image id
image_id = 1
# load the image
image = dataset.load_image(image_id)
# load the masks and the class ids
mask, class_ids = dataset.load_mask(image_id)
# extract bounding boxes from the masks
bbox = extract_bboxes(mask)
# display image with masks and bounding boxes
display_instances(image, bbox, mask, class_ids, dataset.class_names)
def load_mask(self, image_id_):
""" Generate instance masks for cells of the given image ID. """
info = self.image_info[image_id_]
info = info.get("id")
path = os.path.join('data', info)
# Counting masks for current image
number_of_masks = 0
masks_dir_list = {p: self.__CLASS_ASSOCIATION[format_text(p)] for p in os.listdir(path)
if format_text(p) in self.__CLASS_ASSOCIATION}
for masks_dir in masks_dir_list:
temp_DIR = os.path.join(path, masks_dir)
# https://stackoverflow.com/a/2632251/9962046
number_of_masks += len([name_ for name_ in os.listdir(temp_DIR)
if os.path.isfile(os.path.join(temp_DIR, name_))])
if self.__CONFIG.get_param().get('resize', None) is not None:
masks_shape = tuple(self.__CONFIG.get_param().get('resize', None)) + (number_of_masks,)
elif self.__CONFIG.is_using_mini_mask():
masks_shape = self.__CONFIG.get_mini_mask_shape() + (number_of_masks,)
else:
masks_shape = (self.__IMAGE_INFO["HEIGHT"], self.__IMAGE_INFO["WIDTH"], number_of_masks)
masks = np.zeros(masks_shape, dtype=np.uint8)
bboxes = np.zeros((number_of_masks, 4), dtype=np.int32)
iterator = 0
class_ids = np.zeros((number_of_masks,), dtype=int)
for masks_dir, mask_class in masks_dir_list.items():
temp_class_id = self.__CUSTOM_CLASS_NAMES.index(mask_class) + 1
masks_dir_path = os.path.join(path, masks_dir)
for mask_file in os.listdir(masks_dir_path):
mask = imread(os.path.join(masks_dir_path, mask_file))
mask = np.where(mask > 220, 255, 0).astype(np.uint8)
masks[:, :, iterator] = mask
if self.__CONFIG.is_using_mini_mask():
bboxes[iterator] = getBboxFromName(mask_file)
else:
bboxes[iterator] = utils.extract_bboxes(mask)
class_ids[iterator] = temp_class_id
iterator += 1
# Handle occlusions /!\ In our case there is no possible occlusion (part of object that
# is hidden), all objects are complete (some are parts of other)
if self.__ENABLE_OCCLUSION:
occlusion = np.logical_not(masks[:, :, -1]).astype(np.uint8)
for i in range(number_of_masks - 2, -1, -1):
masks[:, :, i] = masks[:, :, i] * occlusion
occlusion = np.logical_and(occlusion, np.logical_not(masks[:, :, i]))
return masks, class_ids.astype(np.int32), bboxes
def main():
dataset = elevator_rgbd.ElevatorRGBDDataset()
dataset.load_elevator_rgbd(args.input, "train")
dataset.prepare()
# Load random image and mask.
image_ids = np.random.choice(dataset.image_ids, 10)
i = 0
for image_id in image_ids:
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
# Display image and instances
blank = np.zeros((512, 512, 3), image.dtype)
print(blank.shape)
print(image.shape)
msk_image = visualize.display_instances(blank, bbox, mask, class_ids,
dataset.class_names)
rgb_image = image[:, :, 0:3]
dpt_image = image[:, :, 3]
fig = skimage.io.imshow(rgb_image)
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.show()
fig = skimage.io.imshow(dpt_image)
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.show()
print(msk_image.shape)
print(msk_image.dtype)
skimage.io.imsave("elevator_dataset_sample_" + str(i) + "_mask.png",
msk_image.astype(np.uint8))
skimage.io.imsave("elevator_dataset_sample_" + str(i) + "_rgb.png",
rgb_image)
skimage.io.imsave("elevator_dataset_sample_" + str(i) + "_dpt.png",
dpt_image)
i += 1
def display_bbox(image_id):
# Load random image and mask.
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bboxes = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bboxes)
# Display image and instances
# 显示 instance 的 bbox 和 mask
visualize.display_instances(image, bboxes, mask, class_ids,
dataset.class_names)