def log_jaccard(im_id: str,
cls: int,
true_mask: np.ndarray,
mask: np.ndarray,
poly_mask: np.ndarray,
true_poly: MultiPolygon,
poly: MultiPolygon,
valid_polygons=False):
assert len(mask.shape) == 2
pixel_jc = utils.mask_tp_fp_fn(mask, true_mask, 0.5)
if valid_polygons:
if not true_poly.is_valid:
true_poly = utils.to_multipolygon(true_poly.buffer(0))
if not poly.is_valid:
poly = utils.to_multipolygon(poly.buffer(0))
tp = true_poly.intersection(poly).area
fn = true_poly.difference(poly).area
fp = poly.difference(true_poly).area
poly_jc = tp, fp, fn
else:
poly_jc = utils.mask_tp_fp_fn(poly_mask, true_mask, 0.5)
logger.info(
'{} cls-{} pixel jaccard: {:.5f}, polygon jaccard: {:.5f}'.format(
im_id, cls, jaccard(pixel_jc), jaccard(poly_jc)))
return pixel_jc, poly_jc
def load_image(self, im_id: str) -> Image:
logger.info('Loading {}'.format(im_id))
im_cache = Path('im_cache')
im_cache.mkdir(exist_ok=True)
im_data_path = im_cache.joinpath('{}.data'.format(im_id))
mask_path = im_cache.joinpath('{}.mask'.format(im_id))
if im_data_path.exists():
im_data = np.load(str(im_data_path))
else:
im_data = self.preprocess_image(utils.load_image(im_id))
with im_data_path.open('wb') as f:
np.save(f, im_data)
pre_buffer = self.hps.pre_buffer
if mask_path.exists() and not pre_buffer:
mask = np.load(str(mask_path))
else:
im_size = im_data.shape[1:]
poly_by_type = utils.load_polygons(im_id, im_size)
if pre_buffer:
structures = 2
poly_by_type[structures] = utils.to_multipolygon(
poly_by_type[structures].buffer(pre_buffer))
mask = np.array([
utils.mask_for_polygons(im_size, poly_by_type[cls + 1])
for cls in range(self.hps.total_classes)
],
dtype=np.uint8)
if not pre_buffer:
with mask_path.open('wb') as f:
np.save(f, mask)
if self.hps.n_channels != im_data.shape[0]:
im_data = im_data[:self.hps.n_channels]
return Image(im_id, im_data, mask[self.hps.classes])
def get_polygons(im_id: str, mask: np.ndarray,
epsilon: float, min_area: float, fix: bool, buffer: float
) -> Tuple[MultiPolygon, MultiPolygon]:
assert len(mask.shape) == 2
polygons = utils.mask_to_polygons(
mask, epsilon=epsilon, min_area=min_area, fix=fix)
if buffer:
polygons = utils.to_multipolygon(polygons.buffer(buffer))
x_scaler, y_scaler = utils.get_scalers(im_id, im_size=mask.shape)
x_scaler = 1 / x_scaler
y_scaler = 1 / y_scaler
return polygons, shapely.affinity.scale(
polygons, xfact=x_scaler, yfact=y_scaler, origin=(0, 0, 0))
