Beispiel #1
0
def chapter_augmenters_cutout():
    aug = iaa.Cutout(nb_iterations=2)
    run_and_save_augseq("arithmetic/cutout_nb_iterations_2.jpg",
                        aug,
                        [ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
                        cols=4,
                        rows=2)

    aug = iaa.Cutout(nb_iterations=(1, 5), size=0.2, squared=False)
    run_and_save_augseq("arithmetic/cutout_non_square.jpg",
                        aug,
                        [ia.quokka(size=(128, 170)) for _ in range(3 * 2)],
                        cols=3,
                        rows=2)

    aug = iaa.Cutout(fill_mode="constant", cval=255)
    run_and_save_augseq("arithmetic/cutout_cval_255.jpg",
                        aug,
                        [ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
                        cols=4,
                        rows=2)

    aug = iaa.Cutout(fill_mode="constant", cval=(0, 255), fill_per_channel=0.5)
    run_and_save_augseq("arithmetic/cutout_rgb.jpg",
                        aug,
                        [ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
                        cols=4,
                        rows=2)

    aug = iaa.Cutout(fill_mode="gaussian", fill_per_channel=True)
    run_and_save_augseq("arithmetic/cutout_gaussian.jpg",
                        aug,
                        [ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
                        cols=4,
                        rows=2)
Beispiel #2
0
 def __init__(self,num_of_augms=0):
     self.num_of_augms=num_of_augms
     self.aug=iaa.OneOf([
         iaa.Sequential([
             iaa.LinearContrast(alpha=(0.75, 1.5)),
             iaa.Fliplr(0.5)
         ]),
         iaa.Sequential([
             iaa.Grayscale(alpha=(0.1, 0.9)),
             iaa.Affine(
                 translate_percent={"y": (-0.15, 0.15)}
             )
         ]),
         iaa.Sequential([
             iaa.LinearContrast((0.6, 1.4)),
             iaa.ShearX((-10, 10))
         ]),
         iaa.Sequential([
             iaa.GaussianBlur(sigma=(0, 1)),
             iaa.ShearY((-10, 10))
         ]),
         iaa.Sequential([
             iaa.Cutout(nb_iterations=(1, 2), size=0.1, squared=False),
             iaa.Multiply((0.8, 1.2), per_channel=0.25),
             iaa.Fliplr(0.5),
         ]),
         iaa.Sequential([
             iaa.LinearContrast((0.6, 1.4)),
             iaa.Affine(
                 translate_percent={"x": (-0.25, 0.25)}
             )
         ]),
         iaa.Sequential([
             iaa.Cutout(nb_iterations=(1, 5), size=0.1, squared=False),
             iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 15), per_channel=0.5),
             iaa.Affine(
                 scale={"x": (0.9, 1.1), "y": (0.9, 1.1)},
             )
         ]),
         iaa.Sequential([
             iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25)),
             iaa.GaussianBlur(sigma=(0, 2)),
             iaa.Affine(
                 scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}
             )])
         # iaa.Sequential([
         #     iaa.Cutout(nb_iterations=(1, 5), size=0.05, squared=False),
         #     iaa.Grayscale(alpha=(0.0, 0.50)),
         #     iaa.ScaleX((0.75, 1.25))
         # ]),
         # iaa.Sequential([
         #     iaa.LinearContrast((0.8, 1.2), per_channel=True),
         #     iaa.PerspectiveTransform(scale=(0.01, 0.15))
         # ])
     ])
Beispiel #3
0
 def __call__(self, x, y, choice):
     if choice:
         if self.fillcolor:
             aug = iaa.Cutout(size=0.5,
                              fill_mode='constant',
                              cval=(0, 255),
                              fill_per_channel=0.5)
         else:
             aug = iaa.Cutout(size=0.5, fill_mode='constant', cval=0)
         x = aug.augment_image(x)
     return x, y
Beispiel #4
0
    def setup_augmentation(self):
        # Augmentation
        # aug = iaa.Sequential([
        #     #iaa.Sometimes(0.5, iaa.PerspectiveTransform(0.05)),
        #     #iaa.Sometimes(0.5, iaa.CropAndPad(percent=(-0.05, 0.1))),
        #     #iaa.Sometimes(0.5, iaa.Affine(scale=(1.0, 1.2))),
        #     iaa.Sometimes(0.5, iaa.CoarseDropout( p=0.05, size_percent=0.01) ),F
        #     iaa.Sometimes(0.5, iaa.GaussianBlur(1.2*np.random.rand())),
        #     iaa.Sometimes(0.5, iaa.Add((-0.1, 0.1), per_channel=0.3)),
        #     iaa.Sometimes(0.3, iaa.Invert(0.2, per_channel=True)),
        #     iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4), per_channel=0.5)),
        #     iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4))),
        #     iaa.Sometimes(0.5, iaa.ContrastNormalization((0.5, 2.2), per_channel=0.3))],
        #                      random_order=False)
        # aug = iaa.Sequential([
        #     #iaa.Sometimes(0.5, iaa.CoarseDropout( p=0.25, size_percent=0.02) ),
        #     iaa.Sometimes(0.5, iaa.GaussianBlur(1.2*np.random.rand())),
        #     iaa.Sometimes(0.5, iaa.Add((-60, 60), per_channel=0.3)),
        #     iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4), per_channel=0.5)),
        #     iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4))),
        #     iaa.Sometimes(0.5, iaa.ContrastNormalization((0.5, 2.2), per_channel=0.3))],
        #                      random_order=False)

        aug = iaa.Sequential(
            [
                #iaa.Sometimes(0.5, PerspectiveTransform(0.05)),
                #iaa.Sometimes(0.5, CropAndPad(percent=(-0.05, 0.1))),
                iaa.Sometimes(0.5, iaa.Affine(scale=(1.0, 1.2))),
                #iaa.Sometimes(0.5, iaa.CoarseDropout( p=0.2, size_percent=0.05) ),
                iaa.Sometimes(
                    0.5,
                    iaa.SomeOf(2, [
                        iaa.CoarseDropout(p=0.2, size_percent=0.05),
                        iaa.Cutout(fill_mode="constant",
                                   cval=(0, 255),
                                   fill_per_channel=0.5),
                        iaa.Cutout(fill_mode="constant", cval=(255)),
                        iaa.CoarseSaltAndPepper(0.05, size_px=(4, 16)),
                        iaa.CoarseSalt(0.05, size_percent=(0.01, 0.1))
                    ])),
                iaa.Sometimes(0.5, iaa.GaussianBlur(1.2 * np.random.rand())),
                iaa.Sometimes(0.5, iaa.Add((-25, 25), per_channel=0.3)),
                iaa.Sometimes(0.3, iaa.Invert(0.2, per_channel=True)),
                iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4), per_channel=0.5)),
                iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4))),
                iaa.Sometimes(
                    0.5, iaa.ContrastNormalization(
                        (0.5, 2.2), per_channel=0.3))
            ],
            random_order=False)
        return aug
def main():
    aug = iaa.Cutout(fill_mode=["gaussian", "constant"],
                     cval=(0, 255),
                     fill_per_channel=0.5)
    image = ia.quokka()
    images_aug = aug(images=[image] * 16)
    ia.imshow(ia.draw_grid(images_aug, cols=4, rows=4))
Beispiel #6
0
    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
Beispiel #7
0
 def __init__(self):
     self.aug = iaa.Sequential([
         iaa.Sometimes(
             0.15,
             iaa.OneOf([
                 iaa.GammaContrast(gamma=(0, 1.75)),
                 iaa.pillike.Autocontrast(cutoff=(0, 15.0))
             ])),
         iaa.Sometimes(
             0.15,
             iaa.OneOf([
                 iaa.HistogramEqualization(),
                 iaa.pillike.Equalize(),
             ])),
         iaa.Sometimes(0.1, iaa.Grayscale(alpha=(0.05, 1.0))),
         iaa.Sometimes(0.2, iaa.JpegCompression(compression=(70, 99))),
         iaa.Sometimes(0.1,
                       iaa.UniformColorQuantizationToNBits(nb_bits=(2, 8))),
         iaa.Sometimes(
             0.3,
             iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30))),
         iaa.Sometimes(
             0.2,
             iaa.Cutout(
                 fill_mode="constant", cval=(0, 255), fill_per_channel=0.5))
     ],
                               random_order=True)
Beispiel #8
0
def cutout_bbox(magnitude: int, **kwargs) -> iaa.BlendAlphaBoundingBoxes:
    """
    Only apply cutout to the bounding box area. Passing the
    height and width of the image as integers and as keywords
    will scale the bounding box according to the policy. Note, the
    cutout location is chosen randomly and will only appear if it
    falls within the bounding box.

    :type magnitude: int
    :param magnitude: magnitude of cutout
    :param kwargs:
        height: height of the image as int
        width: width of the image as int
    :rtype: iaa.BlendAlphaBoundingBoxes
    :return: Method to apply cutout only to bounding boxes
    """
    level = int((magnitude / _MAX_MAGNITUDE) * CUTOUT_BBOX)
    cutout_args = {}
    if 'height' in kwargs and 'width' in kwargs:
        size = tuple(
            np.clip([level / kwargs['height'], level / kwargs['width']], 0.0,
                    1.0))
        cutout_args['size'] = size
    return iaa.BlendAlphaBoundingBoxes(None,
                                       foreground=iaa.Cutout(**cutout_args))
Beispiel #9
0
    def __call__(self, img, labels, mode=None):
        aug_labels = labels.copy()
        if random.random() < self.p:
            aug = iaa.Cutout(**self.params)
            img = aug.augment_image(img)

        return img, labels
def img_aug(img_name, base_dir):
    image = mpimg.imread(Path(base_dir, 'datasets', 'images', img_name))

    ran = random.randint(1, 5)
    if ran == 1:
        aug = iaa.Sequential([
            iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge"),
            iaa.AddToHueAndSaturation((-60, 60)),
            iaa.ElasticTransformation(alpha=90, sigma=9),
            iaa.Cutout()
        ],
                             random_order=True)
        image = aug(image=image)
    elif ran == 2:
        aug = iaa.BlendAlphaRegularGrid(nb_rows=2,
                                        nb_cols=2,
                                        foreground=iaa.Multiply(0.0),
                                        background=iaa.AveragePooling(8),
                                        alpha=[0.0, 0.0, 1.0])
        image = aug(image=image)

    elif ran == 3:
        image = tf.image.adjust_brightness(image, 0.4)
    elif ran == 4:
        image = tf.image.random_flip_left_right(image)
        image = tf.image.rot90(image)
        image = tf.image.random_flip_up_down(image)
    elif ran == 5:
        image = tf.image.central_crop(image, central_fraction=0.5)
    return image
Beispiel #11
0
def cutout(magnitude: int, **kwargs) -> iaa.Cutout:
    """
    Apply cutout anywhere in the image. Passing the height and width
    of the image as integers and as keywords will scale the bounding
    box according to the policy

    Tensorflow Policy Equivalent: cutout

    The cutout value in the policies is at a pixel level. The imgaug cutout
    augmentation method requires the cutout to be a percentage of the image.
    Passing the image height and width as kwargs will scale the cutout to
    the appropriate percentage. Otherwise the imgaug default of 20% will be
    used.

    :type magnitude: int
    :param magnitude: magnitude of cutout
    :param kwargs:
        height: height of the image as int
        width: width of the image as int
    :rtype: iaa.Cutout
    :return: Method to apply cutout to image
    """
    level = int((magnitude / _MAX_MAGNITUDE) * CUTOUT_CONST)
    cutout_args = {}
    if 'height' in kwargs and 'width' in kwargs:
        size = tuple(
            np.clip([(level / kwargs['height']) * 2,
                     (level / kwargs['width']) * 2], 0.0, 1.0))
        cutout_args['size'] = size
    return iaa.Cutout(**cutout_args)
Beispiel #12
0
def aug_image(image):

    seq = iaa.Sequential([
        iaa.Fliplr(0.5),

        iaa.Affine(rotate= (-8, 8),
                   shear = (-8, 8),
                   mode='edge'),

        iaa.SomeOf((0, 2),
                   [
                       iaa.GaussianBlur((0, 0.3)),
                       iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.01 * 255), per_channel=0.5),
                       iaa.AddToHueAndSaturation((-5, 5)),  # change hue and saturation
                       iaa.PiecewiseAffine(scale=(0.01, 0.03)),
                       iaa.PerspectiveTransform(scale=(0.01, 0.1)),
                       iaa.JpegCompression(20, 40)
                   ],
                   random_order=True
                   ),

        iaa.Cutout(nb_iterations=1, size=(0.02, 0.2), squared=False)
    ])

    image = seq.augment_image(image)
    return image
Beispiel #13
0
 def __init__(self, agumentation={}):
     try:
         self.aug = iaa.Sequential([
             iaa.Resize((224, 224)),
             iaa.Sometimes(
                 float(agumentation['GaussianBlur_P']),
                 iaa.GaussianBlur(
                     sigma=(agumentation["GaussianBlur_sigma"]))),
             iaa.Sometimes(
                 float(agumentation['MedianBlur_P']),
                 iaa.imgcorruptlike.MotionBlur(
                     severity=agumentation['MedianBlur_Severity'])),
             iaa.Sometimes(
                 agumentation['DefocusBlur_P'],
                 iaa.imgcorruptlike.DefocusBlur(
                     severity=agumentation['DefocusBlur_Severity'])),
             iaa.Sometimes(
                 agumentation['Cutout_P'],
                 iaa.Cutout(
                     nb_iterations=agumentation['Cutout_cum_of_cuts']),
             ),
             iaa.ChannelShuffle(agumentation['ChannelSuffle_P']),
             iaa.Sometimes(
                 agumentation['ElasticTransformation_P'],
                 iaa.ElasticTransformation(
                     alpha=agumentation['ElasticTransformation_alpha'],
                     sigma=agumentation['ElasticTransformation_sigma']),
             ),
             iaa.Sometimes(
                 agumentation['PerspectiveTransform_P'],
                 iaa.PerspectiveTransform(
                     scale=agumentation['PerspectiveTransform_scale']),
             ),
         ],
                                   random_order=True)
     except:
         self.aug = iaa.Sequential([
             iaa.Resize((224, 224)),
             iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 3.0))),
             iaa.Fliplr(0.5),
             iaa.Affine(rotate=(-20, 20), mode='symmetric'),
             iaa.Dropout2d(p=0.5),
             iaa.Sometimes(0.5, iaa.Cutout(nb_iterations=2)),
             iaa.Sometimes(0.25, iaa.Invert(0.25, per_channel=0.5)),
             iaa.Sometimes(0.25, iaa.Add((-40, 40))),
             iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)
         ])
 def __init__(self, nb_iterations=(3, 8), size=0.1, determint=False):
     self.nb_iterations = nb_iterations
     self.size = size
     self.determint = determint
     self.func = iaa.Cutout(nb_iterations=nb_iterations,
                            size=size,
                            squared=False,
                            fill_mode="gaussian")
def generate_cutout():
    ia.seed(1)

    image = ia.quokka((128, 128))
    images_aug = []

    images_aug.append(image)
    images_aug.extend(iaa.Cutout()(images=[image] * 7))

    images_aug.append(image)
    images_aug.extend(
        iaa.Cutout(nb_iterations=2,
                   cval=(0, 255),
                   fill_mode=["constant", "gaussian"],
                   fill_per_channel=0.8)(images=[image] * 7))

    _save("cutout.jpg", ia.draw_grid(images_aug, cols=7, rows=2))
Beispiel #16
0
def get_preview(images, augmentationList):
    """
    Accepts a list of images and augmentationList as input.
    Provides a list of augmented images in that order as ouptut.
    """
    augmented = []
    for image in images:
        for augmentation in augmentationList:
            aug_id = augmentation['id']
            params = augmentation['params']
            if (aug_id == 1):
                image = iaa.SaltAndPepper(p=params[0],
                                          per_channel=params[1])(image=image)
            elif (aug_id == 2):
                image = iaa.imgcorruptlike.GaussianNoise(
                    severity=(params[0], params[1]))(image=image)
            elif (aug_id == 3):
                image = iaa.Rain(speed=(params[0], params[1]),
                                 drop_size=(params[2], params[3]))(image=image)
            elif (aug_id == 4):
                image = iaa.imgcorruptlike.Fog(
                    severity=(params[0], params[1]))(image=image)
            elif (aug_id == 5):
                image = iaa.imgcorruptlike.Snow(
                    severity=(params[0], params[1]))(image=image)
            elif (aug_id == 6):
                image = iaa.imgcorruptlike.Spatter(
                    severity=(params[0], params[1]))(image=image)
            elif (aug_id == 7):
                image = iaa.BlendAlphaSimplexNoise(
                    iaa.EdgeDetect(1))(image=image)
            elif (aug_id == 8):
                image = iaa.Rotate(rotate=(params[0], params[1]))(image=image)
            elif (aug_id == 9):
                image = iaa.Affine()(image=image)  #to be implemented
            elif (aug_id == 10):
                image = iaa.MotionBlur(k=params[0],
                                       angle=(params[1],
                                              params[2]))(image=image)
            elif (aug_id == 11):
                image = iaa.imgcorruptlike.ZoomBlur(
                    severity=(params[0], params[1]))(image=image)
            elif (aug_id == 12):
                image = iaa.AddToBrightness()(image=image)  #to be implemented
            elif (aug_id == 13):
                image = iaa.ChangeColorTemperature(
                    kelvin=(params[0], params[1]))(image=image)
            elif (aug_id == 14):
                image = iaa.SigmoidContrast()(image=image)  #to be implemented
            elif (aug_id == 15):
                image = iaa.Cutout(nb_iterations=(params[0], params[1]),
                                   size=params[2],
                                   squared=params[3])(image=image)
            else:
                print("Not implemented")
        augmented.append(image)
    return augmented
 def fit(self, X: Dict[str, Any], y: Any = None) -> BaseImageAugmenter:
     if self.use_augmenter:
         self.augmenter: Augmenter = iaa.Sometimes(
             self.p,
             iaa.Cutout(nb_iterations=(1, 10),
                        size=(0.1, 0.5),
                        random_state=self.random_state),
             name=self.get_properties()['name'])
     return self
Beispiel #18
0
    def __init__(self, train_file, class_list, batch_size=1, shuffle=True, transform=None, augment = False, crops_per_snapshot = 8, crop_size = (512,512), debug=False):

        self.train_file = train_file
        self.class_list = class_list
        self.transform = transform

        #region parse the provided class file
        try:
            with open(self.class_list, 'r', newline='') as file:
                self.classes = self.load_classes(csv.reader(file, delimiter=','))
        except ValueError as e:
            raise (ValueError('invalid CSV class file: {}: {}'.format(self.class_list, e)))

        self.labels = {}
        for key, value in self.classes.items():
            self.labels[value] = key
        #endregion

        #region parse annotations csv file
        # lines should be of format "img_path, x1, y1, x2, y2, x3, y3, class_name"
        try:
            with open(self.train_file, 'r', newline='') as file:
                self.image_data = self._read_annotations(csv.reader(file, delimiter=','), self.classes)
        except ValueError as e:
            raise (ValueError('invalid CSV annotations file: {}: {}'.format(self.train_file, e)))
        #endregion

        self.image_names = list(self.image_data.keys())
        self.obj_indices = np.arange(len(self.image_names))

        self.batch_size = batch_size
        self.shuffle = shuffle
        self.augment = augment
        self.debug = debug
        self.lock = threading.Lock()  # mutex for input path
        self.yield_lock = threading.Lock()  # mutex for generator yielding of batch
        self.init_count = 0
        self.objects_id_generator = threadsafe_iter(get_objects_i_generator(len(self.image_names)))
        self.crops_per_snapshot = crops_per_snapshot
        self.crop_size = crop_size
        self.cache = {}

        if self.augment:
            self.seq = iaa.Sequential([iaa.Fliplr(0.5),
                                       iaa.Flipud(0.5),
                                       iaa.GaussianBlur(sigma=(0, 5)),
                                       iaa.Affine(rotate=(-180, 180),
                                                  translate_percent={'x': (-0.1, 0.1), 'y': (-0.1, 0.1)},
                                                  shear={'x': (-15, 15), 'y': (-15, 15)})],
                                      random_order=True)
            self.crop = iaa.CropToFixedSize(self.crop_size[0], self.crop_size[1])
            self.crop_augmentations = iaa.Sequential([iaa.Cutout(nb_iterations=(1, 3), size=0.3, squared=False, cval=0),
                                                      iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25))],
                                                     random_order=True)
        else:
            self.seq = iaa.Identity()
Beispiel #19
0
def img_pro(old_path, new_path):
    img_list = os.listdir(old_path)
    num = 1
    for img in img_list:
        old_img = old_path + img
        img_save = new_path + img
        old_img = imageio.imread(old_img)
        aug = iaa.Cutout(nb_iterations=250, size=[0.03, 0.04], cval=0)
        img_mask = aug.augment_image(old_img)
        print("img number:", num, 'processing img_name:', img)
        num += 1
        imageio.imwrite(img_save, img_mask)
Beispiel #20
0
def augment_merged(image, N=100):
    """
    Given An Image Create Augment N augmented copies of the image
    Since we prefer lists or numpy arrays, it is suggested to use OpenCV for opening images
    """
    images = np.array([image for _ in range(N)], dtype=np.uint8)

    seq = iaa.Sequential(
        [
            #iaa.Fliplr(0.5), # horizontal flips
            #iaa.Flipud(0.5),
            #iaa.CropAndPad(percent=(-0.10, 0.10),
            #               pad_mode=["constant", "mean","maximum"],
            #               pad_cval=(0, 128)), # random crops
            # Small gaussian blur with random sigma between 0 and 0.5.
            # But we only blur about 50% of all images.
            #iaa.Sometimes(0.25,
            #              iaa.GaussianBlur(sigma=(0, 0.5))),
            #iaa.CoarseDropout((0.0, 0.15), size_percent=(0.02, 0.15)),
            # Strengthen or weaken the contrast in each image.
            iaa.ContrastNormalization((0.7, 1.50)),
            # 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),
            #iaa.PiecewiseAffine(scale=(0.01, 0.07)),
            # Make some images brighter and some darker.
            # In 20% of all cases, we sample the multiplier once per channel,
            # which can end up changing the color of the images.
            iaa.Multiply((0.75, 1.25), per_channel=.35),
            #iaa.ChannelShuffle(0.5),
            iaa.Cutout(nb_iterations=(1, 3),
                       size=(0.15, 0.25),
                       squared=False,
                       fill_mode="constant",
                       cval=(0, 255),
                       fill_per_channel=0.5)
            # Apply affine transformations to each image.
            # Scale/zoom them, translate/move them, rotate them and shear them.
            #iaa.Affine(
            #    scale={"x": (0.75, 1.5), "y": (0.75, 1.5)},
            #    translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
            #    rotate=(-20, 20),
            #    shear=(-8, 8)
            #)
        ],
        random_order=True)  # apply augmenters in random order

    images_aug = seq(images=images)
    return images_aug
Beispiel #21
0
def post_composition_augmentation(image_array):
    aug = iaa.Cutout(fill_mode="constant",
                     cval=(0, 255),
                     fill_per_channel=0.5,
                     nb_iterations=(1, 5),
                     size=0.25,
                     squared=False)

    image_array = aug(image=image_array)

    enhancer = ImageEnhance.Brightness(Image.fromarray(image_array))

    return enhancer.enhance(random.uniform(0.3, 1))
Beispiel #22
0
 def __init__(self,
              thresh: float,
              n: int = 3,
              size: float = 0.3,
              squared: bool = False):
     self.name = "cutout"
     assert 0.0 <= thresh <= 1.0
     assert 0.0 <= size <= 1.0
     self.thresh = thresh
     self.transform = iaa.Cutout(nb_iterations=n,
                                 size=size,
                                 squared=squared,
                                 cval=0)
Beispiel #23
0
def init_augmenter(img_mode="color"):
    """Initializes the augmenters used in the training dataset
    :param config: the config object that contains all the 
    """
    ia.seed(10)

    if img_mode == 'color':
        return iaa.Sequential([
            sometimes(iaa.Fliplr()),
            iaa.MultiplyBrightness((0.6, 1.4)),
            # TODO: try no ChangeColor or Brightness
            sometimes(iaa.ChangeColorTemperature((5000, 7000))),
            iaa.Crop(percent=(
                (0, 0.50),
                (0, 0.50),
                (0, 0.50),
                (0, 0.50)
            )),
            sometimes(iaa.OneOf([
                iaa.Cutout(nb_iterations=(1, 4), size=0.2,
                           squared=False, cval=(0, 255), fill_mode="constant"),
                iaa.Cutout(nb_iterations=(1, 4), size=0.2, squared=False, cval=(
                    0, 255), fill_mode="gaussian", fill_per_channel=True),
                iaa.AdditiveGaussianNoise(scale=(0, 0.1*255))
            ]))
        ])
    else:
        return iaa.Sequential([
            sometimes(iaa.Fliplr()),
            iaa.Crop(percent=(
                (0, 0.40),
                (0, 0.40),
                (0, 0.40),
                (0, 0.40)
            ))
        ])
Beispiel #24
0
    def __init__(self, augmentation_ratio=1.0,
                 flip_probability=0.5,
                 contrast_probability=0.2,
                 defocus_probability=0.1,
                 motion_blur_probability=0.2,
                 cutout_probability=0.2,
                 scale_probability=0.1,
                 shift_probability=0.2,
                 fog_probability=0.1):
        rot = iaa.Rot90(ia.ALL)
        shift = iaa.Affine(translate_percent=(-0.2, 0.2))
        flip = iaa.OneOf([iaa.Fliplr(1), iaa.Flipud(1)])
        scale = iaa.Affine(scale=(0.75, 1.25))
        motion_blur = iaa.MotionBlur()
        cutout = iaa.Cutout(
            nb_iterations=(1, 3),
            size=(0.01, 0.1),
            squared=False)
        fog = iaa.imgcorruptlike.Fog(severity=1)
        defocus = iaa.imgcorruptlike.DefocusBlur(severity=1)
        contrast = iaa.imgcorruptlike.Contrast(severity=1)

        aug_weather = iaa.Sequential([
            iaa.Sometimes(augmentation_ratio * fog_probability, fog),
        ], random_order=True)

        aug_initial = iaa.Sequential([
            rot,
            iaa.Sometimes(flip_probability, flip),
            iaa.Sometimes(augmentation_ratio * contrast_probability, contrast)
        ], random_order=True)

        aug_camera = iaa.Sequential([
            iaa.Sometimes(augmentation_ratio * defocus_probability, defocus),
            iaa.Sometimes(augmentation_ratio *
                          motion_blur_probability, motion_blur),
        ], random_order=False)

        aug_obstacles = iaa.Sequential([
            iaa.Sometimes(augmentation_ratio * cutout_probability, cutout),
            iaa.Sometimes(augmentation_ratio * scale_probability, scale),
            iaa.Sometimes(shift_probability, shift)
        ], random_order=False)

        self.augmentation_pipeline = iaa.Sequential(
            [aug_weather, aug_initial, aug_camera, aug_obstacles],
            random_order=False)
Beispiel #25
0
def img_aug(image, method):
    # image = mpimg.imread(
    #     Path(config.base_dir, 'datasets', 'images', img_path))
    # print('original image')
    # ia.imshow(image)

    # sequential
    if method == 'seq':
        aug = iaa.Sequential([
            iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge"),
            iaa.AddToHueAndSaturation((-60, 60)),
            iaa.ElasticTransformation(alpha=90, sigma=9),
            iaa.Cutout(),
        ],
                             random_order=True)

        image = aug(image=image)
        # print("water-like")
        # ia.imshow(image)

    # blend alpha
    elif method == 'ba':
        aug = iaa.BlendAlphaVerticalLinearGradient(iaa.AveragePooling(11),
                                                   start_at=(0.0, 1.0),
                                                   end_at=(0.0, 1.0))
        image = aug(image=image)
        # print('blend alpha')
        # ia.imshow(image)

    # mosaic
    elif method == 'ba_box':
        aug = iaa.BlendAlphaRegularGrid(nb_rows=2,
                                        nb_cols=2,
                                        foreground=iaa.Multiply(0.0),
                                        background=iaa.AveragePooling(8),
                                        alpha=[0.0, 0.0, 1.0])
        image = aug(image=image)
        # print('blend_alpha with boxes')
        # ia.imshow(image)
    return image
Beispiel #26
0
    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.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))
        return {'img': img_aug, 'annot': annot_aug}
def getImageAug():
    seq = iaa.Sequential(
        [
            iaa.SomeOf(
                (0, 2),
                [
                    iaa.Identity(),
                    iaa.AverageBlur(k=((3, 5), (5, 7))),
                    iaa.Rotate((-45, 45)),
                    iaa.Affine(scale=(0.5, 0.95)),
                    iaa.Multiply((0.50, 1.1))
                    #,iaa.BlendAlphaRegularGrid(nb_rows=(4, 6), nb_cols=(1, 4),
                    #                        foreground=iaa.Multiply(0.0))
                    #,iaa.Cartoon()
                    ,
                    iaa.Cutout(
                        nb_iterations=(1, 3), size=0.2, squared=False, cval=0),
                    iaa.Affine(shear=(-48, 48)),
                    iaa.Affine(translate_px={
                        "x": (-42, 42),
                        "y": (-36, 36)
                    }),
                    iaa.KeepSizeByResize(
                        iaa.Resize({
                            "height": (0.70, 0.90),
                            "width": (0.70, 0.90)
                        })),
                    iaa.CropAndPad(percent=(-0.2, 0.2))
                    #,iaa.PiecewiseAffine(scale=(0.01, 0.05))
                    ,
                    iaa.PerspectiveTransform(scale=(0.01, 0.1))
                    #,iaa.WithPolarWarping(iaa.CropAndPad(percent=(-0.1, 0.1)))
                    #,iaa.ElasticTransformation(alpha=(0, 3.0), sigma=0.5)
                ])
            #,iaa.SaveDebugImageEveryNBatches(folder_path, 100)
        ],
        random_order=True)
    return seq
Beispiel #28
0
def augment1(txt_path, save_txt_path):
    """
    Augment data from the txt file.
    """
    seq = iaa.Sequential(
        [iaa.ElasticTransformation(alpha=90, sigma=9),
         iaa.Cutout()],
        random_order=False)

    with open(txt_path, 'r') as fp:
        lines = fp.readlines()

    new_lines = []
    for line in tqdm.tqdm(lines):
        new_line = ""

        cat_id, img_path = line.rstrip().split(' ')
        new_line += cat_id

        image = imageio.imread(img_path)
        images_aug = seq(images=[image])[0]

        img_path = img_path.replace('cloudy', 'augment').replace(
            'dusky', 'augment').replace('foggy',
                                        'augment').replace('sunny', 'augment')
        new_line += ' ' + img_path + '\n'
        new_lines.append(new_line)

        images_aug = Image.fromarray(images_aug)
        images_aug.save(img_path)

    with open(save_txt_path, 'a+') as fp:
        fp.writelines(new_lines)


# augment1("data/weather/train.txt", "data/weather/augment.txt")
# get_chips_augment(txt_path="data/weather/test.txt", save_name="chips_test", save_txt_path="data/weather/chips_test.txt")
# create_gif("C:/Users/18917/Documents/Python Scripts/pytorch/Lab/Pix2Pix-forlab/data-blur/6")
Beispiel #29
0
def cutout_fraction(magnitude: int, **kwargs) -> iaa.Cutout:
    """
    Applies cutout to the image according to bbox information. This will
    apply only to a single bounding box in the image. For the augmentation
    to apply the policy correctly the image height and width along with the
    bounding box height and width are required as keyword arguments.

    Tensorflow Policy Equivalent: bbox_cutout

    The cutout size is determined as a fraction of the bounding box size.
    The cutout value in the policies is at a pixel level. The imgaug cutout
    augmentation method requires the cutout to be a percentage of the image.
    Passing the image height and width as kwargs will scale the cutout to the
    appropriate percentage. Otherwise the imgaug default of 20% will be used.

    Note: the cutout may not always be present in the bounding box dut to
    randomness in the location of the cutout centre

    :type magnitude: int
    :param magnitude: magnitude of cutout
    :param kwargs:
        height: height of the image as int
        width: width of the image as int
        height_bbox: height of the bounding box as int
        width_bbox: width of the bounding box as int
    :rtype: iaa.Cutout
    :return: Method to apply cutout to bounding boxes
    """
    level = (magnitude / _MAX_MAGNITUDE) * CUTOUT_MAX_PAD_FRACTION
    cutout_args = {}
    if all(i in kwargs
           for i in ['height', 'width', 'height_bbox', 'width_bbox']):
        size = tuple([(level * kwargs['height_bbox']) / kwargs['height'],
                      (level * kwargs['width_bbox']) / kwargs['width']])
        cutout_args['size'] = size
    return iaa.Cutout(**cutout_args)
Beispiel #30
0
    def __init__(self, da):
        assert check_data_aug(da), 'Parameters for custom data augmentation missing. Should have: {}'.format(
                                    keys_data_aug)

        aug_geometric = [iaa.Affine(scale=(da['scalem'], da['scaleM']),
                                    translate_percent={'x': (-da['trans'], da['trans']),
                                                       'y': (-da['trans'], da['trans'])},
                                    rotate=(-da['rot'], da['rot']),
                                    shear=(-da['shear'], da['shear']),
                                    cval=FILL_COLOR),
                         iaa.PerspectiveTransform(scale=(0, da['pers']),
                                                  cval=FILL_COLOR, keep_size=True)]

        aug_camera = [iaa.GaussianBlur(sigma=(0, da['sigma'])),
                      iaa.MotionBlur(k=(da['mot_km'], da['mot_kM']),
                                     angle=(-da['mot_an'], da['mot_an']),
                                     direction=(da['mot_dm'], da['mot_dM'])),
                      iaa.JpegCompression(compression=(da['jpegm'], da['jpegM'])),
                      iaa.LinearContrast(alpha=(da['con_alpham'], da['con_alphaM']),
                                         per_channel=da['con_chan']),
                      iaa.MultiplyHueAndSaturation(mul=(da['col_mulm'], da['col_mulM']),
                                                   per_channel=da['col_chan'],
                                                   from_colorspace='BGR'),
                      iaa.AddToHueAndSaturation((da['col_addm'], da['col_addM']),
                                                per_channel=da['col_chan'])
                      ]

        cutout = iaa.Cutout(nb_iterations=(0, da['co_num']),
                            size=(da['co_sm'], da['co_sM']),
                            squared=False,
                            cval=FILL_COLOR)

        # Create a mix of all others
        self.augmenter = iaa.Sequential([iaa.SomeOf((0, 1), aug_geometric),  # none or 1
                                         iaa.SomeOf((0, len(aug_camera) - 2), aug_camera),  # from none to all-2
                                         cutout], random_order=True)  # mix the apply order