def _rect_to_bbox(rect: Rect) -> BoundingBox:
return BoundingBox(
x1=max(rect[0][1], 0),
y1=max(rect[0][0], 0),
x2=rect[0][1] + rect[1][1],
y2=rect[0][0] + rect[1][0],
)
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(
labels=unique_labels,
foreground=iaa.AllChannelsHistogramEqualization())
img_aug, bbs_aug = aug(image=(img * 255.).astype('uint8'),
bounding_boxes=bbs)
img_aug = img_aug.astype('float32') / 255.
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
return {'img': img_aug, 'annot': annot_aug}
def augment(self, img, masks=None, classes=None, boxes=None):
returns = []
aug_det = self.augmenters.to_deterministic()
# augment image
input_size = img.shape
img = aug_det.augment_image(img)
returns.append(img)
# augment masks
new_masks = aug_det.augment_image(masks)
null_masks = new_masks.sum(axis=0).sum(axis=0) == 0
new_masks = new_masks[:, :, ~null_masks]
returns.append(new_masks)
# if removed any mask, remove corresponding class
if classes is not None:
classes = classes[~null_masks]
returns.append(classes)
if boxes is not None:
# augment boxes
bboxes = BoundingBoxesOnImage([BoundingBox(*box) for box in boxes],
input_size)
new_bboxes = aug_det.augment_bounding_boxes([bboxes])[0]
new_bboxes = new_bboxes.remove_out_of_image().cut_out_of_image()
boxes = [[box.x1, box.y1, box.x2, box.y2]
for box in new_bboxes.bounding_boxes]
boxes = np.array(boxes)
returns.append(boxes)
return tuple(returns)
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(
labels=unique_labels,
foreground=iaa.pillike.Solarize(threshold=0.))
img_aug, bbs_aug = aug(image=(img * 2. - 1.), bounding_boxes=bbs)
img_aug = (img_aug + 1.) / 2
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
return {'img': img_aug, 'annot': annot_aug}
def __call__(self, sample):
img, annot = sample.image, sample.annotation
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(labels=unique_labels,
foreground=iaa.Cutout(
nb_iterations=int(round(self.v)),
size=0.05,
fill_mode="gaussian"))
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(labels=unique_labels,
foreground=iaa.pillike.EnhanceColor(
self.v))
img_aug, bbs_aug = aug(image=(img * 255.).astype('uint8'),
bounding_boxes=bbs)
img_aug = img_aug.astype('float32') / 255.
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
rotate_degree = random.uniform(-1 * self.degree, self.degree)
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(
labels=unique_labels,
foreground=iaa.geometric.TranslateY(percent=0.1))
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
# drawn_img = bbs_aug.draw_on_image(img_aug * 255, size=2, color=[0, 255., 0])
# import skimage
# skimage.io.imsave('draw.png', drawn_img)
# img = img.rotate(rotate_degree, Image.BILINEAR)
# mask = mask.rotate(rotate_degree, Image.NEAREST)
sample.image = img_aug
sample.annotation = bbs_aug
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
bbs = BoundingBoxesOnImage([BoundingBox(x1=ann[0], y1=ann[1], x2=ann[2], y2=ann[3], label=str(int(ann[4]))) for ann in annot], shape=img.shape)
aug = iaa.geometric.TranslateY(percent=0.1)
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array([[bb.x1, bb.y1, bb.x2, bb.y2, np.float32(bb.label)] for bb in bbs_aug])
return {'image': img_aug, 'annot': annot_aug}
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
unique_labels = np.unique(annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([BoundingBox(x1=ann[0], y1=ann[1], x2=ann[2], y2=ann[3], label=str(int(ann[4]))) for ann in annot], shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(labels=unique_labels, foreground=iaa.geometric.TranslateY(percent=0.1))
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array([[bb.x1, bb.y1, bb.x2, bb.y2, np.float32(bb.label)] for bb in bbs_aug])
# drawn_img = bbs_aug.draw_on_image(img_aug * 255, size=2, color=[0, 255., 0])
# import skimage
# skimage.io.imsave('draw.png', drawn_img)
return {'image': img_aug, 'annot': annot_aug}
def augment_image(image, bbs, image_size=640):
bbs = [BoundingBox(*bb) for bb in bbs]
bbs = BoundingBoxesOnImage(bbs, shape=image.shape)
resize = iaa.Sequential([
iaa.Resize({
"longer-side": image_size,
"shorter-side": "keep-aspect-ratio"
}),
iaa.PadToFixedSize(width=image_size, height=image_size)
])
seq = iaa.Sequential(
[
iaa.Fliplr(0.5), # horizontal flips
# iaa.Crop(percent=(0, 0.05)), # random crops
# Gaussian blur with random sigma between 0 and 0.2.
iaa.GaussianBlur(sigma=(0, 0.2)),
# Strengthen or weaken the contrast in each image.
iaa.LinearContrast((0.8, 1.2)),
# Add gaussian noise.
# For 50% of all images, we sample the noise once per pixel.
# For the other 50% of all images, we sample the noise per pixel AND
# channel. This can change the color (not only brightness) of the
# pixels.
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
# Make some images brighter and some darker.
# In 30% of all cases, we sample the multiplier once per channel,
# which can end up changing the color of the images.
iaa.Multiply((0.8, 1.2), per_channel=0.3),
# Apply affine transformations to each image.
# Scale/zoom them, translate/move them, rotate them and shear them.
iaa.Affine(
scale={
"x": (1, 1.1),
"y": (1, 1.1)
},
# translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)},
rotate=[90, -90, 180, 88, -92, 178, 182],
shear={
"x": (-5, 5),
"y": (-5, 5)
},
cval=(0, 255)),
],
random_order=True) # apply augmenters in order
image, bbs = resize(image=image, bounding_boxes=bbs)
image, bbs = seq(image=image, bounding_boxes=bbs)
bbs = bbs.remove_out_of_image().clip_out_of_image()
return image, bbs
def __call__(self, sample):
img, annot = sample.image, sample.annotation
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(
labels=unique_labels,
foreground=iaa.geometric.TranslateX(percent=self.v))
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
masks = []
if sample.masks_and_category is not None:
for index in sample.masks_and_category:
masks.append(index[0])
mask_aug = []
if masks is not None:
for mask in masks:
mask = SegmentationMapsOnImage(mask, shape=img.shape).arr
segmap, _ = aug(image=mask, bounding_boxes=bbs)
mask_aug.append(segmap)
# back to 2D array
mask_result = []
for mask in mask_aug:
mask_result.append(mask[:, :, 0])
for i, index in enumerate(sample.masks_and_category):
index[0] = mask_result[i]
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
aug = iaa.ShearY(self.v)
img_aug = aug(image=img)
annot_aug = []
if annot is not None:
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
bbs_aug = aug(bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
masks = []
if sample.masks_and_category is not None:
for index in sample.masks_and_category:
masks.append(index[0])
mask_aug = []
if masks != []:
for mask in masks:
mask = SegmentationMapsOnImage(mask, shape=img.shape).arr
segmap = aug(image=mask)
mask_aug.append(segmap)
# back to 2D array
mask_result = []
for mask in mask_aug:
mask_result.append(mask[:, :, 0])
for i, index in enumerate(sample.masks_and_category):
index[0] = mask_result[i]
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.Fliplr()
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.ShearY(self.v)
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
return {'img': img_aug, 'annot': annot_aug}
def __call__(self, sample):
img, annot = sample.image, sample.annotation
aug = iaa.geometric.TranslateY(percent=self.v)
img_aug = aug(image=img)
annot_aug = []
if annot is not None:
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
bbs_aug = aug(bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
masks = []
if sample.masks_and_category is not None:
for index in sample.masks_and_category:
masks.append(index[0])
segmap = []
if masks != []:
for mask in masks:
segmap.append(SegmentationMapsOnImage(mask, shape=img.shape))
mask_aug = aug(segmentation_maps=segmap)
# reshape back to 2D
for mask in mask_aug:
mask.arr = mask.arr[:, :, 0]
for i, index in enumerate(sample.masks_and_category):
index[0] = mask_aug[i].arr
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.pillike.Solarize(threshold=self.v)
img_aug, bbs_aug = aug(image=(img * 2. - 1.), bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
img_aug = (img_aug + 1.) / 2
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
aug = iaa.ElasticTransformation(alpha=self.alpha, sigma=self.sigma)
img_aug = aug(image=img)
annot_aug = []
if annot is not None:
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
bbs_aug = aug(bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def __call__(self, sample):
img, annot = sample.image, sample.annotation
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.AllChannelsHistogramEqualization()
img_aug, bbs_aug = aug(image=(img * 255.).astype('uint8'),
bounding_boxes=bbs)
img_aug = img_aug.astype('float32') / 255.
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def main(args):
print("Hello world!")
dataset_name = args.dataset
dataset = os.path.join('/home/ubuntu/workspace_aihub/data/raw/',
dataset_name)
class_wise = glob(os.path.join(dataset, '*'))
for per_class_dir in tqdm(class_wise):
datas = glob(os.path.join(per_class_dir, '*'))
for file in tqdm(datas):
if file.split('.')[-1] != 'json':
continue
base_name = file.strip('.json')
image_file = None
if os.path.isfile(base_name + '.jpg'):
image_file = base_name + '.jpg'
if os.path.isfile(base_name + '.JPG'):
image_file = base_name + '.JPG'
if image_file is None:
print('no image')
continue
conf = OmegaConf.create()
image = cv2.imread(image_file)
if image is None:
print('no image!')
continue
if len(image.shape) != 3:
print('this image dose not have 3 chennels')
with open(file) as json_file:
json_data = json.load(json_file)
if len(json_data['regions']) != 1:
print('this regin has more than 1 bbx')
print(json_data['regions'])
conf['regions'] = json_data['regions']
x1 = json_data['regions'][0]['boxcorners'][0]
y1 = json_data['regions'][0]['boxcorners'][1]
x2 = json_data['regions'][0]['boxcorners'][2]
y2 = json_data['regions'][0]['boxcorners'][3]
bbs = BoundingBoxesOnImage(
[BoundingBox(x1=x1, y1=y1, x2=x2, y2=y2)],
shape=image.shape)
if image.shape[0] > image.shape[1]:
seq = iaa.Sequential([
iaa.Resize({
"height": 480,
"width": "keep-aspect-ratio"
}),
iaa.CenterPadToFixedSize(
height=480,
width=640,
)
])
else:
seq = iaa.Sequential([
iaa.Resize({
"width": 640,
"height": "keep-aspect-ratio"
}),
iaa.CenterPadToFixedSize(
height=480,
width=640,
)
])
#image = np.transpose(image, (1,0,2))
image_aug, bbs_aug = seq(image=image, bounding_boxes=bbs)
x1 = int(bbs_aug[0].x1)
y1 = int(bbs_aug[0].y1)
x2 = int(bbs_aug[0].x2)
y2 = int(bbs_aug[0].y2)
conf['bbox'] = {}
conf['bbox']['x1'] = x1
conf['bbox']['y1'] = y1
conf['bbox']['x2'] = x2
conf['bbox']['y2'] = y2
rand_number = random.randint(0, 9)
if rand_number == 0:
mode = 'test2'
elif rand_number == 1:
mode = 'val2'
else:
mode = 'train2'
base_name = (os.path.basename(base_name)).replace('-', '_')
label = base_name.split('_')[0]
dst_path = os.path.join(
'/home/ubuntu/workspace_aihub/data/refined', mode, label)
if not os.path.isdir(dst_path):
os.mkdir(dst_path)
OmegaConf.save(
conf,
os.path.join(dst_path,
f'{os.path.basename(base_name)}.yaml'))
cv2.imwrite(
os.path.join(dst_path,
f'{os.path.basename(base_name)}.jpg'),
image_aug)
def __call__(self, sample):
# , sample['mask_category']
img, annot = sample.image, sample.annotation
annot_aug = []
aug = iaa.Rotate(rotate=self.v)
if annot is not None:
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
bbs_aug = aug(bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
img_aug = aug(image=img)
masks = []
if sample.masks_and_category is not None:
for index in sample.masks_and_category:
masks.append(index[0])
segmap = []
if masks != []:
for mask in masks:
segmap.append(SegmentationMapsOnImage(mask, shape=img.shape))
mask_aug = aug(segmentation_maps=segmap)
# reshape back to 2D
for mask in mask_aug:
mask.arr = mask.arr[:, :, 0]
new_bbox = []
for i, index in enumerate(sample.masks_and_category):
index[0] = mask_aug[i].arr
binary_mask = np.array(index[0], np.uint8)
contours, hierarchy = cv2.findContours(binary_mask,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
if contours == []:
continue
areas = []
for cnt in contours:
area = cv2.contourArea(cnt)
areas.append(area)
idx = areas.index(np.max(areas))
x, y, w, h = cv2.boundingRect(contours[idx])
bounding_box = [x, y, x + w, y + h]
temp = [x, y, x + w, y + h, np.float32(index[1])]
new_bbox.append(temp)
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
if masks != []:
sample.annotation = np.array(new_bbox)
def __call__(self, input_dataframe):
return input_dataframe.assign(
bounding_box=lambda df: df[["x1", "y1", "x2", "y2"]].apply(lambda row: BoundingBox(**row), axis=1)
)
def __call__(self, input_dataframe):
return (input_dataframe.assign(
bounding_box=lambda df: df[['x1', 'y1', 'x2', 'y2']].apply(
lambda row: BoundingBox(**row), axis=1)))
def main(args):
df = pd.DataFrame()
df_count = 0
fold = args.fold
dataset_name = args.dataset
dataset = os.path.join('/home/ubuntu/workspace_aihub/data/refined/',
dataset_name)
class_wise = glob(os.path.join(dataset, '*'))
classes_per_batch = 65
st = fold * classes_per_batch
en = fold * classes_per_batch + classes_per_batch
if fold != 15:
class_wise = class_wise[st:en]
else:
class_wise = class_wise[st:]
print('# classes:', len(class_wise))
dst_root = os.path.join('/home/ubuntu/workspace_aihub/data/refined/v3/',
dataset_name)
if not os.path.isdir(dst_root):
os.mkdir(dst_root)
dst_root = os.path.join(dst_root, str(fold))
if not os.path.isdir(dst_root):
os.mkdir(dst_root)
for per_class_dir in tqdm(class_wise):
datas = glob(os.path.join(per_class_dir, '*'))
for file in tqdm(datas):
if file.split('.')[-1] != 'yaml':
continue
base_name = file.strip('.yaml')
image_file = base_name + '.jpg'
# print(image_file)
image = cv2.imread(image_file)
config = OmegaConf.load(file)
if image is None:
print('no image!')
continue
x1 = config.bbox.x1
y1 = config.bbox.y1
x2 = config.bbox.x2
y2 = config.bbox.y2
bbs = BoundingBoxesOnImage(
[BoundingBox(x1=x1, y1=y1, x2=x2, y2=y2)], shape=image.shape)
transform = get_transform(image)
image_aug, bbs_aug = transform(image=image, bounding_boxes=bbs)
x1 = int(bbs_aug[0].x1)
y1 = int(bbs_aug[0].y1)
x2 = int(bbs_aug[0].x2)
y2 = int(bbs_aug[0].y2)
config['bbox'] = {}
config['bbox']['x1'] = x1
config['bbox']['y1'] = y1
config['bbox']['x2'] = x2
config['bbox']['y2'] = y2
label = config['regions'][0]['tags'][1].split(':')[-1]
dst_path = os.path.join(dst_root, label)
if not os.path.isdir(dst_path):
os.mkdir(dst_path)
OmegaConf.save(
config,
os.path.join(dst_path, f'{os.path.basename(base_name)}.yaml'))
cv2.imwrite(
os.path.join(dst_path, f'{os.path.basename(base_name)}.jpg'),
image_aug)
df.loc[df_count, 'bbox_x1'] = x1
df.loc[df_count, 'bbox_y1'] = y1
df.loc[df_count, 'bbox_x2'] = x2
df.loc[df_count, 'bbox_y2'] = y2
df.loc[df_count, 'image_width'] = image_aug.shape[1]
df.loc[df_count, 'image_height'] = image_aug.shape[0]
df.loc[df_count, 'class'] = label
df.loc[df_count, 'yaml_path'] = os.path.join(
dst_path, f'{os.path.basename(base_name)}.yaml')
df.loc[df_count, 'image_path'] = os.path.join(
dst_path, f'{os.path.basename(base_name)}.jpg')
df_count += 1
df.to_csv(f'{dataset_name}_dataframe_fold{fold}.csv')
def _get_x_y(self, indices: List[int], autoscale: bool = True, use_masks: bool = True, do_preprocessing: bool = False, downscale: bool = False):
batch_of_input_images = []
batch_of_target_masks = []
batch_of_target_labels = []
# Iterate over num batches
for batch_item in indices:
r = random()
# Load image, masks and labels
image = self.load_image(batch_item)
masks, labels = self.load_mask(batch_item, as_box=not use_masks)
initial_shape = image.shape
initial_width = image.shape[1]
initial_height = image.shape[0]
indicated_initial_width = self.__image_info[batch_item]['width']
indicated_initial_height = self.__image_info[batch_item]['height']
masks = np.multiply(masks, initial_width / indicated_initial_width)
# print('Actual width: ', initial_width, 'indicated:', indicated_initial_width)
has_crop = False
# Apply augmentations if specified
if self.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
# Store shapes before augmentation to compare
image_shape = image.shape
mask_shape = masks.shape
# start_total = start = time()
# print('======================')
# print('Starting Augmentation at 0.0')
# Make augmenters deterministic to apply similarly to images and masks
for child_augmenter in self.augmentation.get_all_children():
if isinstance(child_augmenter, CropToFixedSize):
has_crop = True
min_side = min(*image.shape[:2])
child_augmenter.size = (min_side, min_side)
det = self.augmentation.to_deterministic()
# print('-- Applying Augmentation to image: {}'.format(det.__class__))
image = det.augment_image(image.astype(np.uint8))
# Change mask to np.uint8 because imgaug doesn't support np.bool
# took = time() - start
# print('-- Done after ', took)
# start = time()
# for mask in masks:
# print([(m[0], m[1], m[2], m[3]) for m in masks])
if use_masks:
masks = det.augment_image(masks.astype(np.uint8), hooks=imgaug.HooksImages(activator=hook))
else:
# print('-- Applying Augmentation to mask: {}'.format(det.__class__))
bbs = BoundingBoxesOnImage([
BoundingBox(x1=m[0], x2=m[2], y1=m[1], y2=m[3]) for m in masks
], shape=initial_shape)
aug_boxes = []
w, h = image.shape[1], image.shape[0]
for b in det.augment_bounding_boxes(bbs).bounding_boxes:
x1 = max(0, min(w, b.x1))
y1 = max(0, min(h, b.y1))
x2 = max(0, min(w, b.x2))
y2 = max(0, min(h, b.y2))
# Discard boxes with either 0 widht or 0 height
if x2 - x1 > 0 and y2 - y1 > 0:
aug_boxes.append(
[
max(0, min(w, b.x1)),
max(0, min(h, b.y1)),
max(0, min(w, b.x2)),
max(0, min(h, b.y2)),
]
)
masks = np.array(aug_boxes)
# took = time() - start
# print('-- Done after\n\n', took)
# Verify that shapes didn't change
# assert image.shape == image_shape, "Augmentation shouldn't change image size"
# assert masks.shape == mask_shape, "Augmentation shouldn't change mask size"
# Change mask back to bool
# ret_mask = ret_mask.astype(np.bool)
# If max image side length was specified, resize image and masks
if (self.max_image_side_length is not None or self.min_image_side_length is not None) and autoscale:
old_height, old_width = image.shape[0], image.shape[1]
ratio = old_height / old_width
if self.image_scale_mode == 'squash':
image = cv2.resize(image, (self.max_image_side_length, self.max_image_side_length))
s_w = image.shape[1] / old_width
s_h = image.shape[0] / old_height
if use_masks:
raise RuntimeError('Squashin masks is not implemented')
else:
masks[:, 0] = np.multiply(masks[:, 0], s_w)
masks[:, 2] = np.multiply(masks[:, 2], s_w)
masks[:, 1] = np.multiply(masks[:, 1], s_h)
masks[:, 3] = np.multiply(masks[:, 3], s_h)
image, w, scale, p, c = resize_image(
image, max_dim=self.max_image_side_length, min_dim=self.min_image_side_length, downscale=downscale
)
# box_scale = scale * (initial_width / indicated_initial_width)
if use_masks:
masks = resize_mask(
masks, scale=scale, padding=p
)
else:
# masks2 = []
# print(masks)
masks = np.multiply(masks, scale)
if self.image_scale_mode == 'square':
if p[0][0] > 0:
masks[:, 1] += p[0][0]
masks[:, 3] += p[0][0]
if p[1][0] > 0:
masks[:, 0] += p[1][0]
masks[:, 2] += p[1][0]
# if p[0][0] > 0:
# try:
# masks[:, 1] += p[0][0]
# masks[:, 3] += p[0][0]
# except BaseException:
# print('MAS FAL')
# print(masks.shape)
if has_crop:
masks[:, 0] += p[1][0]
masks[:, 2] += p[1][0]
masks[:, 1] += p[0][0]
masks[:, 3] += p[0][0]
# for mask in masks:
# masks2.append(
# [mask[0] - w[1], mask[1] - w[0], mask[2] - w[1], mask[3] - w[0]]
# )
#
# masks = np.array(masks2)
if autoscale and self.image_scale_mode == 'just':
new_width = int((initial_width * scale))
new_height = int((initial_height * scale))
remove_width = int((image.shape[1] - new_width) / 2)
remove_height = int((image.shape[0] - new_height) / 2)
image = image[remove_height:image.shape[0] - remove_height, remove_width:image.shape[1] - remove_width, :]
if use_masks:
masks = masks[remove_height:image.shape[0] - remove_height, remove_width:masks.shape[1] - remove_width, :]
if do_preprocessing:
if self.center_color_to_imagenet:
image = image.astype(np.float64)
image[..., 0] -= 123.68 # R
image[..., 1] -= 116.779 # G
image[..., 2] -= 103.939 # B
else:
image /= 255.0
# Append to batch
batch_of_input_images.append(image)
batch_of_target_masks.append(masks)
batch_of_target_labels.append(labels)
self._cur_img_idx += 1
if use_masks:
batch_of_target_bboxes = np.zeros((1, batch_of_target_masks[0].shape[2], 4))
for batch, mask_set in enumerate(batch_of_target_masks):
batch_of_target_bboxes[batch, :mask_set.shape[2]] = extract_bboxes(mask_set)[:mask_set.shape[2]]
for b, box in enumerate(batch_of_target_bboxes[batch]):
y1, x1, y2, x2 = box
batch_of_target_bboxes[batch][b] = np.array((x1, y1, x2, y2))
else:
batch_of_target_bboxes = batch_of_target_masks
# batch_of_input_images = np.asarray(batch_of_input_images, dtype=np.float32)
return batch_of_input_images, batch_of_target_masks, batch_of_target_bboxes, batch_of_target_labels, self._num_classes
def to_bounding_boxes_on_image(m_image: MetaImage) -> BoundingBoxesOnImage:
bounding_boxes: List[BoundingBox] = []
for lbox in m_image.labeled_boxes:
bounding_boxes.append(
BoundingBox(lbox.x1, lbox.y1, lbox.x2, lbox.y2, lbox.label))
return BoundingBoxesOnImage(bounding_boxes, m_image.data.shape)