def test_augment_polygons__kernel_size_is_two__no_keep_size(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage ps = [Polygon([(1.5, 1.5), (5.5, 1.5), (5.5, 5.5)])] psoi = PolygonsOnImage(ps, shape=(6, 6, 3)) expected = PolygonsOnImage([ Polygon([(1.5/2, 1.5/2), (5.5/2, 1.5/2), (5.5/2, 5.5/2)]) ], shape=(3, 3, 3)) self._test_augment_cbaoi__kernel_size_is_two__no_keep_size( psoi, expected, "augment_polygons")
def test_empty_polygons(self): from imgaug.augmentables.polys import PolygonsOnImage psoi = PolygonsOnImage([], shape=(5, 6, 3)) aug = self.augmenter(3, keep_size=False) psoi_aug = aug.augment_polygons(psoi) expected = psoi.deepcopy() expected.shape = (2, 2, 3) assert_cbaois_equal(psoi_aug, expected)
def aug_img_anns(img, anns): augments = AUGS.to_deterministic() polygons = [] kps = [] for ann in anns: polygons.append( Polygon( np.float32(ann['segmentation'][0]).reshape(-1, 2), ann['category_id'])) if ann.get('keypoints'): for ki in range(ann['num_keypoints']): kps.append( Polygon([[ ann['keypoints'][ki * 3], ann['keypoints'][ki * 3 + 1] ]], label=(ki, len(polygons) - 1, ann['keypoints'][ki * 3 + 2]))) polygons = PolygonsOnImage(polygons, img.shape) kps = PolygonsOnImage(kps, img.shape) img = augments.augment_image(img) polygons = augments.augment_polygons(polygons).polygons kps = augments.augment_polygons(kps).polygons kps_on_instance = [[] for i in range(len(polygons))] for kp in kps: kps_on_instance[kp.label[1]].append(kp) map(lambda x: x.sort(key=lambda kp: kp.label[0]), kps_on_instance) anns = [] for p, kps in zip(polygons, kps_on_instance): seg = p.exterior.reshape(-1).tolist() xs = seg[::2] ys = seg[1::2] if len([x for x in xs if x >= img.shape[1] - 1 or x <= 0]) > 0: continue if len([y for y in ys if y >= img.shape[0] - 1 or y <= 0]) > 0: continue x1 = min(xs) y1 = min(ys) w = max(xs) - x1 h = max(ys) - y1 anns.append({ 'area': w * h, 'bbox': [x1, y1, w, h], 'category_id': p.label, 'iscrowd': 0, 'segmentation': [seg] }) if len(kps): anns[-1]['keypoints'] = [] anns[-1]['num_keypoints'] = len(kps) for kp in kps: anns[-1]['keypoints'].append(float(kp.exterior[0][0])) anns[-1]['keypoints'].append(float(kp.exterior[0][1])) anns[-1]['keypoints'].append(kp.label[2]) return img, anns
def test_polygon_alignment(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage polys = [Polygon([(10, 10), (30, 10), (30, 30)])] psoi = PolygonsOnImage(polys, shape=(40, 40, 1)) psoi_empty = PolygonsOnImage([], shape=(40, 40, 1)) self._test_cbaoi_alignment(psoi, psoi_empty, [[(10 / 2, 10 / 2), (30 / 2, 10 / 2), (30 / 2, 30 / 2)]], [[(10, 10), (30, 10), (30, 30)]], "augment_polygons")
def quokka_polygons(size=None, extract=None): """ Returns example polygons on the standard example quokke image. The result contains one polygon, covering the quokka's outline. Added in 0.5.0. (Moved from ``imgaug.imgaug``.) Parameters ---------- size : None or float or tuple of int or tuple of float, optional Size of the output image on which the polygons are placed. If ``None``, then the polygons are not projected to any new size (positions on the original image are used). ``float`` s lead to relative size changes, ``int`` s to absolute sizes in pixels. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage Subarea to extract from the image. See :func:`~imgaug.imgaug.quokka`. Returns ------- imgaug.augmentables.polys.PolygonsOnImage Example polygons on the quokka image. """ # TODO get rid of this deferred import from imgaug.augmentables.polys import Polygon, PolygonsOnImage left, top = 0, 0 if extract is not None: bb_extract = _quokka_normalize_extract(extract) left = bb_extract.x1 top = bb_extract.y1 with open(_QUOKKA_ANNOTATIONS_FP, "r") as f: json_dict = json.load(f) polygons = [] for poly_json in json_dict["polygons"]: polygons.append( Polygon([(point["x"] - left, point["y"] - top) for point in poly_json["keypoints"]]) ) if extract is not None: shape = (bb_extract.height, bb_extract.width, 3) else: shape = (643, 960, 3) psoi = PolygonsOnImage(polygons, shape=shape) if size is not None: shape_resized = _compute_resized_shape(shape, size) psoi = psoi.on(shape_resized) return psoi
def test_augment_polygons__kernel_size_is_two__no_keep_size(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage ps = [Polygon([(1.5, 1.5), (5.5, 1.5), (5.5, 5.5)])] psoi = PolygonsOnImage(ps, shape=(6, 6, 3)) aug = self.augmenter(2, keep_size=False) psoi_aug = aug.augment_polygons(psoi) expected = PolygonsOnImage([ Polygon([(1.5 / 2, 1.5 / 2), (5.5 / 2, 1.5 / 2), (5.5 / 2, 5.5 / 2)]) ], shape=(3, 3, 3)) assert_cbaois_equal(psoi_aug, expected)
def get_data(self, idx): img = cv2.imread(self.data[idx][0]) anns = self.data[idx][1] polygons = [] for ann_id, ann in enumerate(anns): for seg in ann['segmentation']: if len(seg) > 4: polygons.append( Polygon( np.float32(seg).reshape(-1, 2), { 'category_id': self.classes_hash[ann['category_id']], 'instance_id': ann_id })) elif len(seg) == 2: # point polygons.append( Polygon( np.float32([ seg[0] - POINTS_WH / 2, seg[1] - POINTS_WH / 2, seg[0] - POINTS_WH / 2, seg[1] + POINTS_WH / 2, seg[0] + POINTS_WH / 2, seg[1] + POINTS_WH / 2, seg[0] + POINTS_WH / 2, seg[1] - POINTS_WH / 2 ]).reshape(-1, 2), { 'category_id': self.classes_hash[ann['category_id']], 'instance_id': ann_id })) else: print('segmentation with 2 points is not supported: {}'. format(seg)) polygons = PolygonsOnImage(polygons, img.shape) return img, polygons
def augmentation(self): polygons = [] for polygon in self.y: polygons.append(Polygon(polygon['points'])) polygon['points'] = [] pps = PolygonsOnImage(polygons, shape=self.x.shape) # Augment. self.x, pps = self.augmentationseq(image=self.x, polygons=pps) # self.x = cv2.cvtColor(self.x,cv2.COLOR_RGB2GRAY) # print("{}".format(self.x.shape)) for i, polygon in enumerate(self.y): for (x, y) in pps[i]: if x <= 0: x = 0 if y <= 0: y = 0 if x >= WIDTH: x = WIDTH - 1 if y >= HEIGHT: y = HEIGHT - 1 polygon['points'].append([x, y])
def test_aug(): im=cv2.imread('/media/wsl/SB@data/dataset/瓶盖分类/dataset/单字检测/聪明盖/0_0.jpg') bboxes=read_labelme('/media/wsl/SB@data/dataset/瓶盖分类/dataset/单字检测/聪明盖/0_0.json') poly_on_img=PolygonsOnImage([Polygon(bbox) for bbox in bboxes],shape=im.shape) st = lambda aug: iaa.Sometimes(1, aug) seq = iaa.Sequential([ #st(iaa.Pad(percent=((0, 0.2), (0, 0.2), (0, 0.2), (0, 0.2)), keep_size=False)), # # # st(iaa.Crop(percent=([0.0, 0.3], [0.00, 0.1], [0.0, 0.3], [0.0, 0.1]), keep_size=False)), st(iaa.Affine(scale=(0.9, 1.0), rotate=(-45, 45), shear=(-5, 5), translate_px={"x": (-16, 16), "y": (-10, 10)}, fit_output=True)), st(iaa.Add(value=(-10, 10), per_channel=True)), # st(iaa.PerspectiveTransform((0,0.1),fit_output=True)), # st(iaa.MultiplyAndAddToBrightness(mul=(0.6, 1.5), add=(0, 30))), st(iaa.ChangeColorTemperature(kelvin=(3000, 9100))), st(iaa.Sharpen(0, 0.1)), st(iaa.GaussianBlur((0, 1))), st(iaa.AddToHueAndSaturation((-2, 2))), st(iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.2), per_channel=True)), # add gaussian noise to images ]) for i in range(10): imgs_aug,poly_on_img_aug=seq(image=im,polygons=poly_on_img) res=poly_on_img_aug.draw_on_image(imgs_aug) a=poly_on_img_aug.to_xy_array() print(a.shape) cv2.imshow('a',res) cv2.waitKey(0)
def augment_image(self, img, gt, completed_groups): # Note: Running as groups directly is cheaper than running individually using run_augment() if self.shuffle: # TODO: Move to top-level augmentor? random.shuffle(self.augmentors) polygons = [ Polygon(element['points'], element['label']) for element in gt["data"] ] polygons = PolygonsOnImage(polygons, shape=img.shape) for aug in self.augmentors: if random.random() < aug.p and len( gt["augs_done"]) < self.max_augmentations_per_image: if aug.name in self.augname2groups: if self.augname2groups[aug.name].intersection( completed_groups): continue else: completed_groups.update(self.augname2groups[aug.name]) img, polygons = aug(image=img, polygons=polygons) gt["augs_done"].append(aug.name) # Put back polygons into GT for element, pg in zip(gt["data"], polygons): element['points'] = [pt.tolist() for pt in pg.exterior] return img, gt
def __remove_out_of_image(cls, img_aug_polys: ImgAugPolygons, fully: bool = True, partly: bool = False) -> ImgAugPolygons: result = img_aug_polys.copy() result.remove_out_of_image(fully=fully, partly=partly) return result
def _test_augment_polygons__kernel_size_differs(self, shape, shape_exp): from imgaug.augmentables.polys import Polygon, PolygonsOnImage polys = [Polygon([(1.5, 5.5), (5.5, 1.5), (5.5, 5.5)])] psoi = PolygonsOnImage(polys, shape=shape) aug = self.augmenter( (iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) psoi_aug = aug.augment_polygons(psoi) expected = PolygonsOnImage( [Polygon([ ((1.5/shape[1])*shape_exp[1], (5.5/shape[0])*shape_exp[0]), ((5.5/shape[1])*shape_exp[1], (1.5/shape[0])*shape_exp[0]), ((5.5/shape[1])*shape_exp[1], (5.5/shape[0])*shape_exp[0]) ])], shape=shape_exp) assert_cbaois_equal(psoi_aug, expected)
def test_augment_polygons__kernel_size_is_two__keep_size(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage polys = [Polygon([(0, 0), (2, 0), (2, 2)])] psoi = PolygonsOnImage(polys, shape=(6, 6, 3)) aug = self.augmenter(2, keep_size=True) psoi_aug = aug.augment_polygons(psoi) assert_cbaois_equal(psoi_aug, psoi)
def test_empty_polygons(self): from imgaug.augmentables.polys import PolygonsOnImage psoi = PolygonsOnImage([], shape=(5, 6, 3)) aug = self.augmenter(3, keep_size=False) psoi_aug = aug.augment_polygons(psoi) assert psoi_aug.shape == (2, 2, 3) assert len(psoi_aug.polygons) == 0
def get_data(self, idx): img = cv2.imread(self.data[idx][0]) polygons = [] for c, xmin, ymin, xmax, ymax in self.data[idx][1]: polygons.append( Polygon( np.float32( [xmin, ymin, xmin, ymax, xmax, ymax, xmax, ymin]).reshape(-1, 2), c)) polygons = PolygonsOnImage(polygons, img.shape)
def get_data(self, idx): img = cv2.imread(self.data[idx][0]) anns = self.data[idx][1] polygons = [] for ann in anns: polygons.append( Polygon( np.float32(ann['segmentation']).reshape(-1, 2), ann['category_id'])) polygons = PolygonsOnImage(polygons, img.shape) return img, polygons
def __call__(self, *args, **kwargs) -> typing.Tuple[np.ndarray, typing.List[Polygon]]: if self.is_training: resize = iaa.Resize(size=dict(longer_side=self.long_sizes, width='keep-aspect-ratio')) rotate = iaa.Rotate(rotate=self.angles, fit_output=True) resize_height = iaa.Resize(size=dict(height=self.height_ratios, width='keep')) crop = iaa.CropToFixedSize(width=self.cropped_size[0], height=self.cropped_size[1]) fix_resize = iaa.Resize(size=self.output_size) # blur = iaa.GaussianBlur() # blur = iaa.Sometimes(p=self.blur_prob, # then_list=blur) brightness = iaa.MultiplyBrightness((0.5, 1.5)) brightness = iaa.Sometimes(self.color_jitter_prob, then_list=brightness) saturation = iaa.MultiplySaturation((0.5, 1.5)) saturation = iaa.Sometimes(self.color_jitter_prob, then_list=saturation) contrast = iaa.LinearContrast(0.5) contrast = iaa.Sometimes(self.color_jitter_prob, then_list=contrast) hue = iaa.MultiplyHue() hue = iaa.Sometimes(self.color_jitter_prob, then_list=hue) augs = [resize, rotate, resize_height, crop, fix_resize, brightness, saturation, contrast, hue] ia = iaa.Sequential(augs) else: fix_resize = iaa.Resize(size=self.output_size) ia = iaa.Sequential([fix_resize]) image = args[0] polygons = args[1] polygon_list = [] for i in range(polygons.shape[0]): polygon_list.append(Polygon(polygons[i].tolist())) polygons_on_image = PolygonsOnImage(polygon_list, shape=image.shape) image_aug, polygons_aug = ia(image=image, polygons=polygons_on_image) return image_aug, polygons_aug.polygons
def aug(self,im,bboxes,viz=True): assert len(bboxes.shape)==3 assert bboxes.shape[1]==4 poly_on_img = PolygonsOnImage([Polygon(bbox) for bbox in bboxes], shape=im.shape) if viz: res = poly_on_img.draw_on_image(im) cv2.imshow('ori', res) cv2.waitKey(0) imgs_aug, poly_on_img_aug = self.seq(image=im, polygons=poly_on_img,) res_bboxes=poly_on_img_aug.to_xy_array() if bboxes.shape[0]*bboxes.shape[1]!=res_bboxes.shape[0]: print('aug error','before:',bboxes.shape,' after:',res_bboxes.shape) return im,bboxes #print('before:',bboxes.shape,' after:',res_bboxes.shape) res_bboxes=np.reshape(res_bboxes,bboxes.shape) if viz: res = poly_on_img_aug.draw_on_image(imgs_aug) cv2.imshow('a', res) cv2.waitKey(0) return imgs_aug,res_bboxes
def run_augment(aug, img, gt): polygons = [ Polygon(element['points'], element['label']) for element in gt ] polygons = PolygonsOnImage(polygons, shape=img.shape) img, polygons = aug(image=img, polygons=polygons) # Put back polygons into GT for element, pg in zip(gt, polygons): element['points'] = [pt.tolist() for pt in pg.exterior] return img, gt
def test_polygon_alignment(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage aug = self.augmenter((1, 2), keep_size=False) image = np.zeros((40, 40, 1), dtype=np.uint8) polys = [Polygon([(10, 10), (30, 10), (30, 30)])] psoi = PolygonsOnImage(polys, shape=image.shape) psoi_empty = PolygonsOnImage([], shape=image.shape) images_batch = [image, image, image, image] psoi_batch = [psoi, psoi, psoi_empty, psoi] nb_iterations = 10 for _ in sm.xrange(nb_iterations): images_aug, psois_aug = aug(images=images_batch, polygons=psoi_batch) for index in [0, 1, 3]: image_aug = images_aug[index] psoi_aug = psois_aug[index] assert image_aug.shape == psoi_aug.shape if image_aug.shape == (20, 20, 1): assert np.allclose(psoi_aug.items[0].coords, [(10 / 2, 10 / 2), (30 / 2, 10 / 2), (30 / 2, 30 / 2)]) else: assert np.allclose(psoi_aug.items[0].coords, [(10, 10), (30, 10), (30, 30)]) for index in [2]: image_aug = images_aug[index] psoi_aug = psois_aug[index] assert psoi_aug.shape == image_aug.shape assert len(psoi_aug.polygons) == 0
def test_augment_polygons__kernel_size_differs(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage polys = [Polygon([(1.5, 5.5), (5.5, 1.5), (5.5, 5.5)])] psoi = PolygonsOnImage(polys, shape=(6, 6, 3)) aug = self.augmenter( (iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) psoi_aug = aug.augment_polygons(psoi) assert psoi_aug.shape == (2, 3, 3) assert np.allclose(psoi_aug.polygons[0].exterior, [[(1.5/6)*3, (5.5/6)*2], [(5.5/6)*3, (1.5/6)*2], [(5.5/6)*3, (5.5/6)*2]])
def get_data(self, idx): img = cv2.imread(self.data[idx][0]) anns = self.data[idx][1] polygons = [] for ann in anns: polygons.append( Polygon( np.float32(ann['segmentation']).reshape(-1, 2), ann['category_id'])) polygons = PolygonsOnImage(polygons, img.shape) h, w, c = img.shape # augment if self.det_augments is not None: augments = self.det_augments.to_deterministic() img = augments.augment_image(img) polygons = augments.augment_polygons(polygons) for i in range(len(polygons.polygons)): polygon = random.choice(polygons.polygons) p = polygon.exterior.reshape(-1, 2).astype(np.int32) # p = p.clip(0, 1) if p[:, 0].min() < 0 or p[:, 1].min() < 0 or p[:, 0].max( ) >= img.shape[1] or p[:, 1].max() >= img.shape[0] or p[:, 0].max( ) - p[:, 0].min() < 50 or p[:, 1].max() - p[:, 1].min() < 50: continue break x1 = random.randint(p[:, 0].min() - 100, p[:, 0].min()) x1 = max(0, x1) x2 = random.randint(p[:, 0].max(), p[:, 0].max() + 100) x2 = min(img.shape[1], x2) y1 = random.randint(p[:, 1].min() - 100, p[:, 1].min()) y1 = max(0, y1) y2 = random.randint(p[:, 1].max(), p[:, 1].max() + 100) y2 = min(img.shape[0], y2) cimg = img[y1:y2, x1:x2] if cimg.size > 0: img = cimg p[:, 0] -= x1 p[:, 1] -= y1 seg = np.zeros([img.shape[0], img.shape[1]], dtype=np.uint8) seg = cv2.fillPoly(seg, [p], polygon.label + 1, 0) seg = SegmentationMapsOnImage(seg, shape=img.shape) return img, seg
def test_transform(): data_root = '/home/luning/dev/data/SynthText800k/detection/' img_fn = 'desert_78_83' gt_fn = data_root + 'gt.mat' targets = {} targets = sio.loadmat(gt_fn, targets, squeeze_me=True, struct_as_record=False, variable_names=['imnames', 'wordBB', 'txt']) imageNames = targets['imnames'] wordBBoxes = targets['wordBB'] transcripts = targets['txt'] mask = [True if img_fn in i else False for i in imageNames] index = np.where(mask)[0][0] print(index) img_fn = imageNames[index] img_fn = data_root + '/imgs/' + img_fn img = cv2.imread(img_fn) boxes = wordBBoxes[index] transcripts = transcripts[index] transcripts = [word for line in transcripts for word in line.split()] boxes = np.expand_dims(boxes, axis=2) if (boxes.ndim == 2) else boxes _, _, numOfWords = boxes.shape # boxes = boxes.reshape([8, numOfWords]).T # num_words * 8 # boxes = boxes.reshape([numOfWords, 4, 2]) boxes = boxes.transpose((2, 1, 0)) polys = [] for i in range(numOfWords): # box = boxes[:, :, i].T box = boxes[i] polys.append(Polygon(box.tolist())) polys_on_image = PolygonsOnImage(polygons=polys, shape=img.shape) image_before_aug = polys_on_image.draw_on_image(img) cv2.imwrite('before_aug.jpg', image_before_aug) transform = Transform() image_aug, polygons_aug = transform(img, boxes) polygons_on_image = PolygonsOnImage(polygons=polygons_aug, shape=image_aug.shape) image_aug = polygons_on_image.draw_on_image(image_aug) cv2.imwrite('aug.jpg', image_aug)
def main(): nb_checked = 0 augs = iaa.SomeOf((1, None), [ iaa.Resize({ "height": (1, 100), "width": (1, 100) }), iaa.Affine(scale=(0.01, 2.0), rotate=(-360, 360), shear=(-360, 360), translate_px={ "x": (-50, 50), "y": (-50, 50) }), iaa.PerspectiveTransform((0.01, 0.2)) ]) height, width = 100, 200 while True: poly = create_random_polygon(height, width, nb_checked) psoi = PolygonsOnImage([poly], shape=(height, width, 3)) psoi_aug = augs.augment_polygons(psoi) if not poly.is_valid or not psoi_aug.polygons[0].is_valid: print("poly: ", poly, poly.is_valid) print("poly_aug: ", psoi_aug.polygons[0], psoi_aug.polygons[0].is_valid) assert poly.is_valid assert psoi_aug.polygons[0].is_valid nb_checked += 1 if nb_checked % 100 == 0: print("Checked %d..." % (nb_checked, )) if nb_checked > 100000: break
def AugmentData(d, input_dir, augmentations_dict, new_image_id, new_ann_id): TOTAL_IMAGES = len(d['images']) TOTAL_AUG = len(augmentations_dict.items()) CURRENT_AUG_ITER = 1 print('Applying a total of {} augmentations to a total of {} images'.format(TOTAL_AUG, TOTAL_IMAGES)) for aug in augmentations_dict: prefix = augmentations_dict[aug] print('APPLYING AUGMENTATION {}. PREFIX = {}'.format(CURRENT_AUG_ITER, prefix)) CURRENT_AUG_ITER += 1 for CURRENT_IMAGE_ITER in range(TOTAL_IMAGES): print('Working on Image {}'.format(CURRENT_IMAGE_ITER+1)) image_name = (d['images'][CURRENT_IMAGE_ITER]['file_name']) image_id = d['images'][CURRENT_IMAGE_ITER]['id'] width = d['images'][CURRENT_IMAGE_ITER]['width'] height = d['images'][CURRENT_IMAGE_ITER]['height'] image = imageio.imread(os.path.join(input_dir, image_name)) annotations = [] for c in d['annotations']: if c['image_id']==image_id: annotations.append(c) segments = {i:[] for i in range(len(annotations))} categories = {} ids = {} bboxes = {} areas = {} for i in range(0, len(annotations)): for j in range(0, len(annotations[i]['segmentation'])): current_seg = [] for k in range(0, len(annotations[i]['segmentation'][j]), 2): [x, y] = [annotations[i]['segmentation'][j][k], annotations[i]['segmentation'][j][k+1]] current_seg = current_seg + [[x, y]] segments[i] = segments[i] + [current_seg] categories[i] = annotations[i]['category_id'] ids[i] = annotations[i]['id'] bboxes[i] = convertBboxStyle(annotations[i]['bbox']) areas[i] = annotations[i]['area'] num_annotations = len(annotations) POLYGONS = [] for i in segments: for L in segments[i]: POLYGONS.append(Polygon(L)) psoi = PolygonsOnImage(POLYGONS, shape=image.shape) bbsoi = BoundingBoxesOnImage( [BoundingBox(x1 = bboxes[i][0], y1= bboxes[i][1], x2 = bboxes[i][2], y2=bboxes[i][3]) for i in bboxes], shape=image.shape ) image_aug, psoi_aug = aug(image=image, polygons=psoi) _, bbsoi_aug = aug(image=image, bounding_boxes = bbsoi) bboxes_converted = bbsoi_aug.items #List of bounding boxes #is there a need to do this? #not really sure. May remove this later. polygons_converted = [psoi_aug.polygons[i].exterior for i in range(len(psoi_aug.polygons))] #Generating coco_entry for the same. image_data = { "id":new_image_id, "width": width, "height": height, "file_name": '{}{}'.format(prefix,image_name), "license": 0 } annotations_data = [] polygon_index = 0 for i in range(num_annotations): #to retreive: segments, bboxes num_segments = len(segments[i]) SEGMENTATION = [] AREA = 0 for j in range(num_segments): #p = polygons_converted[polygon_index + j] current_polygon = psoi_aug.polygons[polygon_index +j] if(current_polygon.is_valid): if(current_polygon.is_fully_within_image(image_aug)): polygons_list = [current_polygon] print("WITHIN") else: try: print("NOTWITHIN") polygons_list = current_polygon.clip_out_of_image(image_aug) #now this is a list of polyogns that the current polygon may have split into. except AssertionError: print("Assertion Error occured. Ignoring. Can't guarantee that final dataset will be accurate.") polygons_list = [current_polygon] #add this to the SEGMENTATION s = [] for P in polygons_list: AREA += P.area p = P.exterior for k in range(len(p)): [x,y] = p[k] s.append(int(x)) s.append(int(y)) s.append(s[0]) s.append(s[1]) SEGMENTATION = SEGMENTATION + [s] else: print("Polygon Invalid, skiiping: ", current_polygon) polygon_index = polygon_index + j + 1 bboxes_converted[i].clip_out_of_image_(image_aug) #bbox = [bboxes_converted[i].x1_int, bboxes_converted[i].y1_int, int(bboxes_converted[i].width), int(bboxes_converted[i].height)] #bbox = convertBboxStyle(bbox, "s") bbox = getBoundingBox(SEGMENTATION) if(len(SEGMENTATION) > 0): A = { "id":new_ann_id, "image_id": new_image_id, "category_id": categories[i], "segmentation": (SEGMENTATION), "area": int(AREA), "bbox": (bbox), "iscrowd": 0 } annotations_data.append(A) new_ann_id += 1 new_image_id += 1 d['images'].append(image_data) d['annotations'] += annotations_data imageio.imwrite(os.path.join(input_dir, '{}{}'.format(prefix, image_name)), image_aug) return d
def test_empty_polygons(self): from imgaug.augmentables.polys import PolygonsOnImage cbaoi = PolygonsOnImage([], shape=(5, 6, 3)) self._test_empty_cbaoi(cbaoi, "augment_polygons")
def test_augment_polygons__kernel_size_is_two__keep_size(self): from imgaug.augmentables.polys import Polygon, PolygonsOnImage polys = [Polygon([(0, 0), (2, 0), (2, 2)])] psoi = PolygonsOnImage(polys, shape=(6, 6, 3)) self._test_augment_cbaoi__kernel_size_is_two__keep_size( psoi, "augment_polygons")
def _test_augment_polygons__kernel_size_is_noop(self, kernel_size): from imgaug.augmentables.polys import Polygon, PolygonsOnImage ps = [Polygon([(1, 1), (2, 1), (2, 2)])] psoi = PolygonsOnImage(ps, shape=(6, 6, 3)) self._test_augment_cbaoi__kernel_size_is_noop(kernel_size, psoi, "augment_polygons")
def normalize_polygons(inputs, shapes=None): # TODO get rid of this deferred import from imgaug.augmentables.polys import Polygon, PolygonsOnImage shapes = _preprocess_shapes(shapes) ntype = estimate_polygons_norm_type(inputs) _assert_exactly_n_shapes_partial = functools.partial( _assert_exactly_n_shapes, from_ntype=ntype, to_ntype="List[PolygonsOnImage]", shapes=shapes) if ntype == "None": return None elif ntype in ["array[float]", "array[int]", "array[uint]"]: _assert_single_array_ndim(inputs, 4, "(N,#polys,#points,2)", "PolygonsOnImage") _assert_single_array_last_dim_exactly(inputs, 2, "PolygonsOnImage") _assert_exactly_n_shapes_partial(n=len(inputs)) return [ PolygonsOnImage( [Polygon(poly_points) for poly_points in attr_i], shape=shape) for attr_i, shape in zip(inputs, shapes) ] elif ntype == "Polygon": _assert_exactly_n_shapes_partial(n=1) return [PolygonsOnImage([inputs], shape=shapes[0])] elif ntype == "PolygonsOnImage": return [inputs] elif ntype == "iterable[empty]": return None elif ntype in ["iterable-array[float]", "iterable-array[int]", "iterable-array[uint]"]: _assert_many_arrays_ndim(inputs, 3, "(#polys,#points,2)", "PolygonsOnImage") _assert_many_arrays_last_dim_exactly(inputs, 2, "PolygonsOnImage") _assert_exactly_n_shapes_partial(n=len(inputs)) return [ PolygonsOnImage([Polygon(poly_points) for poly_points in attr_i], shape=shape) for attr_i, shape in zip(inputs, shapes) ] elif ntype == "iterable-tuple[number,size=2]": _assert_exactly_n_shapes_partial(n=1) return [PolygonsOnImage([Polygon(inputs)], shape=shapes[0])] elif ntype == "iterable-Keypoint": _assert_exactly_n_shapes_partial(n=1) return [PolygonsOnImage([Polygon(inputs)], shape=shapes[0])] elif ntype == "iterable-Polygon": _assert_exactly_n_shapes_partial(n=1) return [PolygonsOnImage(inputs, shape=shapes[0])] elif ntype == "iterable-PolygonsOnImage": return inputs elif ntype == "iterable-iterable[empty]": return None elif ntype in ["iterable-iterable-array[float]", "iterable-iterable-array[int]", "iterable-iterable-array[uint]"]: _assert_many_arrays_ndim(inputs, 2, "(#points,2)", "PolygonsOnImage") _assert_many_arrays_last_dim_exactly(inputs, 2, "PolygonsOnImage") _assert_exactly_n_shapes_partial(n=len(inputs)) return [ PolygonsOnImage( [Polygon(poly_points) for poly_points in attr_i], shape=shape) for attr_i, shape in zip(inputs, shapes) ] elif ntype == "iterable-iterable-tuple[number,size=2]": _assert_exactly_n_shapes_partial(n=1) return [ PolygonsOnImage([Polygon(attr_i) for attr_i in inputs], shape=shapes[0]) ] elif ntype == "iterable-iterable-Keypoint": _assert_exactly_n_shapes_partial(n=1) return [ PolygonsOnImage([Polygon(attr_i) for attr_i in inputs], shape=shapes[0]) ] elif ntype == "iterable-iterable-Polygon": _assert_exactly_n_shapes_partial(n=len(inputs)) return [ PolygonsOnImage(attr_i, shape=shape) for attr_i, shape in zip(inputs, shapes) ] elif ntype == "iterable-iterable-iterable[empty]": return None else: assert ntype in ["iterable-iterable-iterable-tuple[number,size=2]", "iterable-iterable-iterable-Keypoint"] _assert_exactly_n_shapes_partial(n=len(inputs)) return [ PolygonsOnImage( [Polygon(poly_points) for poly_points in attr_i], shape=shape) for attr_i, shape in zip(inputs, shapes) ]
def mapper(self, dataset_dict, train_type: str = 'kpt'): if train_type != 'kpt': for item in dataset_dict["annotations"]: if 'keypoints' in item: del item['keypoints'] image = utils.read_image(dataset_dict["file_name"], format="BGR") img_h, img_w = image.shape[:2] num_pixels = img_w * img_h ann_dict = Detectron2_Annotation_Dict.from_dict(dataset_dict) bbox_list = [ann.bbox for ann in ann_dict.annotations] # if train_type == 'seg': # printj.purple(len(ann_dict.annotations)) # for ann in ann_dict.annotations: # seg = ann.segmentation # mask = seg.to_mask() # tranformed = self.aug(mask=mask) # mask = tranformed['mask'] # image = tranformed['image'] # else: image = self.aug(image=np.array(image))['image'] seq_aug_for_no_seg = almost_always(iaa.Sequential( [ # iaa.Rot90(ia.ALL, keep_size=False) ] )) seq_aug_for_seg = sometimes(iaa.Sequential( [ iaa.Rot90(ia.ALL, keep_size=False), iaa.Affine( scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)}, rotate=(-180, 180), order=[0, 1], # cval=(0, 255), cval=255, mode=ia.ALL ) ] )) imgaug_kpts = KeypointsOnImage(keypoints=[], shape=image.shape) imgaug_bboxes = BoundingBoxesOnImage( bounding_boxes=[], shape=image.shape) imgaug_polys = PolygonsOnImage(polygons=[], shape=image.shape) num_ann = len(ann_dict.annotations) num_kpts = None seg_len_list = [] for ann in ann_dict.annotations: if num_kpts is None: num_kpts = len(ann.keypoints) if len(ann.keypoints.to_imgaug(img_shape=image.shape).keypoints) != len(ann_dict.annotations[0].keypoints): printj.red( f'len(ann.keypoints.to_imgaug(img_shape=image.shape).keypoints) == {len(ann.keypoints.to_imgaug(img_shape=image.shape).keypoints)} != {len(ann_dict.annotations[0].keypoints)} == len(ann_dict.annotations[0].keypoints)') raise Exception imgaug_kpts.keypoints.extend( ann.keypoints.to_imgaug(img_shape=image.shape).keypoints) if ann.bbox.to_imgaug() is None: printj.red(f'ann.bbox.to_imgaug() is None') printj.red(f'ann.bbox: {ann.bbox}') raise Exception imgaug_bboxes.bounding_boxes.append(ann.bbox.to_imgaug()) if ann.segmentation.to_imgaug(img_shape=image.shape).polygons is None: printj.red( f'ann.segmentation.to_imgaug(img_shape=image.shape).polygons is None') printj.red(f'ann.segmentation:\n{ann.segmentation}') raise Exception seg_len_list.append(len(ann.segmentation)) imgaug_polys.polygons.extend( ann.segmentation.to_imgaug(img_shape=image.shape).polygons) if len(imgaug_polys.polygons) > 0: if num_kpts > 0: image, imgaug_kpts_aug, imgaug_polys_aug = seq_aug_for_seg( image=image, keypoints=imgaug_kpts, polygons=imgaug_polys) else: image, imgaug_polys_aug = seq_aug_for_seg( image=image, polygons=imgaug_polys) imgaug_kpts_aug = None imgaug_bboxes_aug = None else: if num_kpts > 0: image, imgaug_kpts_aug, imgaug_bboxes_aug = seq_aug_for_no_seg( image=image, keypoints=imgaug_kpts, bounding_boxes=imgaug_bboxes) else: image, imgaug_bboxes_aug = seq_aug_for_no_seg( image=image, bounding_boxes=imgaug_bboxes) imgaug_kpts_aug = None imgaug_polys_aug = None kpts_aug0 = Keypoint2D_List.from_imgaug( imgaug_kpts=imgaug_kpts_aug) if num_kpts > 0 else Keypoint2D_List() kpts_aug_list = kpts_aug0.to_numpy(demarcation=True)[:, :2].reshape( num_ann, num_kpts, 2) if num_kpts > 0 else [] kpts_aug_list = [[[x, y, 2] for x, y in kpts_aug] for kpts_aug in kpts_aug_list] kpts_aug_list = [Keypoint2D_List.from_list( kpts_aug, demarcation=True) for kpts_aug in kpts_aug_list] if imgaug_polys_aug is not None and imgaug_bboxes_aug is None: poly_aug_list = [Polygon.from_imgaug( imgaug_polygon) for imgaug_polygon in imgaug_polys_aug.polygons] poly_aug_list_list = unflatten_list( poly_aug_list, part_sizes=seg_len_list) seg_aug_list = [Segmentation(poly_aug_list) for poly_aug_list in poly_aug_list_list] bbox_aug_list = [seg_aug.to_bbox() for seg_aug in seg_aug_list] # Adjust BBoxes when Segmentation BBox does not contain all keypoints for i in range(len(bbox_aug_list)): kpt_points_aug = [ kpt_aug.point for kpt_aug in kpts_aug_list[i]] if num_kpts > 0 else [] kpt_points_aug_contained = [kpt_point_aug.within( bbox_aug_list[i]) for kpt_point_aug in kpt_points_aug] if len(kpt_points_aug) > 0: if not np.any(np.array(kpt_points_aug_contained)): printj.red( f"Keypoints not contained in corresponding bbox.") elif not np.all(np.array(kpt_points_aug_contained)): pass else: break elif imgaug_polys_aug is None and imgaug_bboxes_aug is not None: bbox_aug_list = [BBox.from_imgaug( bbox_aug) for bbox_aug in imgaug_bboxes_aug.bounding_boxes] seg_aug_list = [None] * len(bbox_aug_list) else: printj.red(f'Unexpected error') raise Exception if num_kpts > 0: for ann, kpts_aug, bbox_aug, seg_aug in zip(ann_dict.annotations, kpts_aug_list, bbox_aug_list, seg_aug_list): ann.keypoints = kpts_aug ann.bbox = bbox_aug ann.segmentation = seg_aug if seg_aug is not None else Segmentation.from_list([ ]) else: for ann, bbox_aug, seg_aug in zip(ann_dict.annotations, bbox_aug_list, seg_aug_list): ann.keypoints = Keypoint2D_List() ann.bbox = bbox_aug ann.segmentation = seg_aug if seg_aug is not None else Segmentation.from_list([ ]) dataset_dict = ann_dict.to_dict() image, transforms = T.apply_transform_gens([], image) annots = [] for item in dataset_dict["annotations"]: if 'keypoints' in item and num_kpts == 0: del item['keypoints'] elif 'keypoints' in item: item['keypoints'] = np.array( item['keypoints']).reshape(-1, 3).tolist() annots.append(item) dataset_dict["image"] = torch.as_tensor( image.transpose(2, 0, 1).astype("float32")) instances = utils.annotations_to_instances(annots, image.shape[:2]) dataset_dict["instances"] = utils.filter_empty_instances( instances, by_box=True, by_mask=False) # if True: # vis_img = image.copy() # bbox_list = [BBox.from_list(vals) for vals in dataset_dict["instances"].gt_boxes.tensor.numpy().tolist()] # seg_list = [Segmentation([Polygon.from_list(poly.tolist(), demarcation=False) for poly in seg_polys]) for seg_polys in dataset_dict["instances"].gt_masks.polygons] # kpts_list = [Keypoint2D_List.from_numpy(arr, demarcation=True) for arr in dataset_dict["instances"].gt_keypoints.tensor.numpy()] if hasattr(dataset_dict["instances"], 'gt_keypoints') else [] # for seg in seg_list: # vis_img = draw_segmentation(img=vis_img, segmentation=seg, transparent=True) # for bbox in bbox_list: # vis_img = draw_bbox(img=vis_img, bbox=bbox) # for kpts in kpts_list: # vis_img = draw_keypoints(img=vis_img, keypoints=kpts.to_numpy(demarcation=True)[:, :2].tolist(), radius=6) # aug_visualizer.step(vis_img) return dataset_dict