def _interp_preds_as_impl(num_classes, im_size, pred_stride, imh, imw, pred):
imh0, imw0 = im_size
pred = pred.astype(np.single, copy=False)
input_h, input_w = pred.shape[0] * pred_stride, pred.shape[1] * pred_stride
assert pred_stride >= 1.
this_interp_pred = np.array(Image.fromarray(pred).resize((input_w, input_h), Image.CUBIC))
if imh0 == imh:
interp_pred = this_interp_pred[:imh, :imw]
else:
interp_method = util.get_interp_method(imh, imw, imh0, imw0)
interp_pred = np.array(Image.fromarray(this_interp_pred[:imh, :imw]).resize((imw0, imh0), interp_method))
return interp_pred
def _interp_preds_as_impl(num_classes, im_size, pred_stride, imh, imw, pred):
imh0, imw0 = im_size
pred = pred.astype(np.single, copy=False)
input_h, input_w = pred.shape[0] * pred_stride, pred.shape[1] * pred_stride
assert pred_stride >= 1.
this_interp_pred = np.array(Image.fromarray(pred).resize((input_w, input_h), Image.CUBIC))
if imh0 == imh:
interp_pred = this_interp_pred[:imh, :imw]
else:
interp_method = util.get_interp_method(imh, imw, imh0, imw0)
interp_pred = np.array(Image.fromarray(this_interp_pred[:imh, :imw]).resize((imw0, imh0), interp_method))
return interp_pred
def _read(self, db_inds):
max_h, max_w = self._meta['max_shape']
label_2_id = self._meta['label_2_id']
target_size_range = [
int(_ * self._origin_size) for _ in self._scale_rate_range
]
min_rate = 1. * target_size_range[0] / max(max_h, max_w)
target_crop_size = self._crop_size
max_crop_size = int(target_crop_size / min_rate)
label_size = target_crop_size // self._label_stride
assert label_size * self._label_stride == target_crop_size
label_per_image = label_size**2
locs_per_crop = self._label_steps**2
output = []
for _ in xrange(locs_per_crop * self._crops_per_image):
output_data = np.zeros(
(self._batch_images, 3, target_crop_size, target_crop_size),
np.single)
output_label = np.zeros((self._batch_images, label_per_image),
np.single)
output.append([output_data, output_label])
for i, db_ind in enumerate(db_inds):
# load an image
im = np.array(
load_image_with_cache(self._image_list[db_ind],
self._cache).convert('RGB'))
h, w = im.shape[:2]
assert h <= max_h and w <= max_w
# randomize the following cropping
target_size = npr.randint(target_size_range[0],
target_size_range[1] + 1)
rate = 1. * target_size / max(h, w)
crop_size = int(target_crop_size / rate)
label_stride = self._label_stride / rate
# make sure there is a all-zero border
d0 = max(1, int(label_stride // 2))
# allow shifting within the grid between the used adjacent labels
d1 = max(0, int(label_stride - d0))
# prepare the image
nim_size = max(max_crop_size, max_h, max_w) + d1 + d0
nim = np.zeros((nim_size, nim_size, 3), np.single)
nim += self._data_mean
nim[d0:d0 + h, d0:d0 + w, :] = im
# label
nlabel = self._ignore_label * np.ones(
(nim_size, nim_size), np.uint8)
label = np.array(
load_image_with_cache(self._label_list[db_ind], self._cache))
if label_2_id is not None:
label = label_2_id[label]
nlabel[d0:d0 + h, d0:d0 + w] = label
# crop
real_label_stride = label_stride / self._label_steps
sy = npr.randint(0,
max(1, real_label_stride, d0 + h - crop_size + 1),
self._crops_per_image)
sx = npr.randint(0,
max(1, real_label_stride, d0 + w - crop_size + 1),
self._crops_per_image)
dyx = np.arange(0, label_stride, real_label_stride).astype(
np.int32)[:self._label_steps].tolist()
dy = dyx * self._label_steps
dx = sum([[_] * self._label_steps for _ in dyx], [])
for k in xrange(self._crops_per_image):
do_flipping = npr.randint(2) == 0
for j in xrange(locs_per_crop):
# cropping & resizing image
tim = nim[sy[k] + dy[j]:sy[k] + dy[j] + crop_size,
sx[k] + dx[j]:sx[k] + dx[j] +
crop_size, :].astype(np.uint8)
assert tim.shape[0] == tim.shape[1] == crop_size
interp_method = get_interp_method(crop_size, crop_size,
target_crop_size,
target_crop_size)
rim = Image.fromarray(tim).resize(
(target_crop_size, target_crop_size), interp_method)
rim = np.array(rim)
# cropping & resizing label
tlabel = nlabel[sy[k] + dy[j]:sy[k] + dy[j] + crop_size,
sx[k] + dx[j]:sx[k] + dx[j] + crop_size]
assert tlabel.shape[0] == tlabel.shape[1] == crop_size
rlabel = Image.fromarray(tlabel).resize(
(target_crop_size, target_crop_size), Image.NEAREST)
lsy = self._label_stride / 2
lsx = self._label_stride / 2
rlabel = np.array(
rlabel)[lsy:target_crop_size:self._label_stride,
lsx:target_crop_size:self._label_stride]
# flipping
if do_flipping:
rim = rim[:, ::-1, :]
rlabel = rlabel[:, ::-1]
# transformers
if self._transformer_image is not None:
rim = self._transformer_image(rim)
else:
rim -= self._data_mean
# assign
output[k * locs_per_crop + j][0][i, :] = rim.transpose(
2, 0, 1)
output[k * locs_per_crop + j][1][i, :] = rlabel.flatten()
return output
def _read(self, db_inds):
label_2_id_src = self._meta['label_2_id_src']
label_2_id_tgt = self._meta['label_2_id_tgt']
mine_port = self._meta['mine_port']
mine_id = self._meta['mine_id']
mine_id_priority = self._meta['mine_id_priority']
##
target_crop_size = self._crop_size
label_size = target_crop_size // self._label_stride
assert label_size * self._label_stride == target_crop_size
label_per_image = label_size**2
locs_per_crop = self._label_steps**2
output = []
for _ in xrange(locs_per_crop * self._crops_per_image):
output_data = np.zeros(
(self._batch_images, 3, target_crop_size, target_crop_size),
np.single)
output_label = np.zeros((self._batch_images, label_per_image),
np.single)
output.append([output_data, output_label])
for i, db_ind in enumerate(db_inds):
if self._origin_list[db_ind] == 0:
max_h, max_w = self._meta['max_shape_src']
target_size_range = [
int(_ * self._origin_size) for _ in self._scale_rate_range
]
min_rate = 1. * target_size_range[0] / max(max_h, max_w)
max_crop_size = int(target_crop_size / min_rate)
elif self._origin_list[db_ind] == 1:
max_h, max_w = self._meta['max_shape_tgt']
target_size_range = [
int(_ * self._origin_size_tgt)
for _ in self._scale_rate_range
]
min_rate = 1. * target_size_range[0] / max(max_h, max_w)
max_crop_size = int(target_crop_size / min_rate)
# load an image
im = np.array(
load_image_with_cache(self._image_list[db_ind],
self._cache).convert('RGB'))
h, w = im.shape[:2]
target_size = npr.randint(target_size_range[0],
target_size_range[1] + 1)
#######################
rate = 1. * target_size / max(max_h, max_w)
#######################
crop_size = int(target_crop_size / rate)
label_stride = self._label_stride / rate
# make sure there is a all-zero border
d0 = max(1, int(label_stride // 2))
# allow shifting within the grid between the used adjacent labels
d1 = max(0, int(label_stride - d0))
# prepare the image
##########
nim_size = max(max_crop_size, h, w) + d1 + d0
##########
nim = np.zeros((nim_size, nim_size, 3), np.single)
nim += self._data_mean
nim[d0:d0 + h, d0:d0 + w, :] = im
# label
nlabel = self._ignore_label * np.ones(
(nim_size, nim_size), np.uint8)
##########
label = np.array(
load_image_with_cache(self._label_list[db_ind], self._cache))
# label = olabel[shift_h:shift_h + h, shift_w:shift_w + w]
##########
if self._origin_list[db_ind] == 0:
label = label_2_id_src[label]
elif self._origin_list[db_ind] == 1:
label = label_2_id_tgt[label]
nlabel[d0:d0 + h, d0:d0 + w] = label
# crop
real_label_stride = label_stride / self._label_steps
mine_flag = npr.rand(1) < mine_port
sel_mine_id = 0
########## few class patch mining
if mine_flag:
mlabel = self._ignore_label * np.ones(
(nim_size, nim_size), np.uint8)
mlabel[
d0 +
int(crop_size / 2):max(1, real_label_stride, d0 + h -
int(crop_size / 2) - 1), d0 +
int(crop_size /
2):max(1, real_label_stride, d0 + w -
int(crop_size / 2) - 1)] = nlabel[
d0 +
int(crop_size /
2):max(1, real_label_stride, d0 + h -
int(crop_size / 2) - 1), d0 +
int(crop_size /
2):max(1, real_label_stride, d0 + w -
int(crop_size / 2) - 1)]
label_unique = np.unique(mlabel)
mine_id_priority_temp = np.array(
[a for a in mine_id_priority if a in label_unique])
if mine_id_priority_temp.size != 0:
mine_id_exist = mine_id_priority_temp
else:
mine_id_temp = np.array(
[a for a in mine_id if a in label_unique])
mine_id_exist = np.array([b for b in mine_id_temp])
mine_id_exist_size = mine_id_exist.size
if mine_id_exist_size == 0:
sy = npr.randint(
0, max(1, real_label_stride, d0 + h - crop_size + 1),
self._crops_per_image)
sx = npr.randint(
0, max(1, real_label_stride, d0 + w - crop_size + 1),
self._crops_per_image)
else:
sel_mine_loc = int(
np.floor(npr.uniform(0, mine_id_exist_size)))
sel_mine_id = mine_id_exist[sel_mine_loc]
mine_id_loc = np.where(mlabel == sel_mine_id) # tuple
mine_id_len = len(mine_id_loc[0])
seed_loc = npr.randint(0, mine_id_len,
self._crops_per_image)
if self._crops_per_image == 1:
sy = mine_id_loc[0][seed_loc]
sx = mine_id_loc[1][seed_loc]
else:
sy = int(np.ones(self._crops_per_image))
sx = int(np.ones(self._crops_per_image))
for i in np.arange(self._crops_per_image):
sy[i] = mine_id_loc[0][seed_loc[i]]
sx[i] = mine_id_loc[1][seed_loc[i]]
########## few class patch mining
else:
sy = npr.randint(
0, max(1, real_label_stride, d0 + h - crop_size + 1),
self._crops_per_image)
sx = npr.randint(
0, max(1, real_label_stride, d0 + w - crop_size + 1),
self._crops_per_image)
dyx = np.arange(0, label_stride, real_label_stride).astype(
np.int32)[:self._label_steps].tolist()
dy = dyx * self._label_steps
dx = sum([[_] * self._label_steps for _ in dyx], [])
for k in xrange(self._crops_per_image):
do_flipping = npr.randint(2) == 0
for j in xrange(locs_per_crop):
# cropping & resizing image
if mine_flag and mine_id_exist_size != 0:
remain_minus = crop_size - int(crop_size / 2)
tim = nim[sy[k] + dy[j] - int(crop_size / 2):sy[k] +
dy[j] + remain_minus,
sx[k] + dx[j] - int(crop_size / 2):sx[k] +
dx[j] + remain_minus, :].astype(np.uint8)
assert tim.shape[0] == tim.shape[1] == crop_size
tlabel = nlabel[sy[k] + dy[j] -
int(crop_size / 2):sy[k] + dy[j] +
remain_minus, sx[k] + dx[j] -
int(crop_size / 2):sx[k] + dx[j] +
remain_minus]
assert tlabel.shape[0] == tlabel.shape[1] == crop_size
else:
tim = nim[sy[k] + dy[j]:sy[k] + dy[j] + crop_size,
sx[k] + dx[j]:sx[k] + dx[j] +
crop_size, :].astype(np.uint8)
assert tim.shape[0] == tim.shape[1] == crop_size
tlabel = nlabel[sy[k] + dy[j]:sy[k] + dy[j] +
crop_size, sx[k] + dx[j]:sx[k] +
dx[j] + crop_size]
assert tlabel.shape[0] == tlabel.shape[1] == crop_size
interp_method = get_interp_method(crop_size, crop_size,
target_crop_size,
target_crop_size)
rim = Image.fromarray(tim).resize(
(target_crop_size, target_crop_size), interp_method)
rim = np.array(rim)
# cropping & resizing label
rlabel = Image.fromarray(tlabel).resize(
(target_crop_size, target_crop_size), Image.NEAREST)
slabel = np.array(rlabel).copy()
lsy = self._label_stride / 2
lsx = self._label_stride / 2
rlabel = np.array(
rlabel)[lsy:target_crop_size:self._label_stride,
lsx:target_crop_size:self._label_stride]
# flipping
if do_flipping:
rim = rim[:, ::-1, :]
rlabel = rlabel[:, ::-1]
# for debug
#output_patch = 'patch_debug/'
#_make_dirs(output_patch)
#save_time = str(time.time())
#output_patch_cls = osp.join(output_patch,str(sel_mine_id))
#_make_dirs(output_patch_cls)
#sample_name = osp.splitext(osp.basename(self._image_list[db_ind]))[0]
#Image.fromarray(rim).save(osp.join(output_patch_cls,sample_name + '_img.png'))
#Image.fromarray(slabel).save(osp.join(output_patch_cls,sample_name + '_label.png'))
# transformers
if self._transformer_image is not None:
rim = self._transformer_image(rim)
else:
rim -= self._data_mean
# assign
output[k * locs_per_crop + j][0][i, :] = rim.transpose(
2, 0, 1)
output[k * locs_per_crop + j][1][i, :] = rlabel.flatten()
return output
