Beispiel #1
0
def test_elastic_transform_interpolation(monkeypatch, interpolation):
    image = np.random.randint(low=0,
                              high=256,
                              size=(100, 100, 3),
                              dtype=np.uint8)
    mask = np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8)
    monkeypatch.setattr(
        'albumentations.augmentations.transforms.ElasticTransform.get_params',
        lambda *_: {'random_state': 1111})
    aug = A.ElasticTransform(alpha=1,
                             sigma=50,
                             alpha_affine=50,
                             interpolation=interpolation,
                             p=1)
    data = aug(image=image, mask=mask)
    expected_image = F.elastic_transform(
        image,
        alpha=1,
        sigma=50,
        alpha_affine=50,
        interpolation=interpolation,
        border_mode=cv2.BORDER_REFLECT_101,
        random_state=np.random.RandomState(1111))
    expected_mask = F.elastic_transform(
        mask,
        alpha=1,
        sigma=50,
        alpha_affine=50,
        interpolation=cv2.INTER_NEAREST,
        border_mode=cv2.BORDER_REFLECT_101,
        random_state=np.random.RandomState(1111))
    assert np.array_equal(data['image'], expected_image)
    assert np.array_equal(data['mask'], expected_mask)
def create_cotton_wool_mask(size=128):
    iterations = 25
    num_circles = 10
    acc = np.zeros((size, size), dtype=np.float32)

    for i in range(iterations):
        img = np.zeros_like(acc)
        for j in range(num_circles):
            r = int(random.uniform(5, 25))
            r2 = int(random.uniform(5, 25))

            a = random.uniform(0, 180)

            x = int(random.gauss(size // 2, size // 8))
            y = int(random.gauss(size // 2, size // 8))

            pt = int(x), int(y)
            cv2.ellipse(img,
                        pt, (r, r2),
                        a,
                        0,
                        360,
                        color=1,
                        thickness=cv2.FILLED)
            # cv2.circle(img, pt, r, color=1, thickness=cv2.FILLED)

        acc += img

    acc /= iterations

    acc = (acc * 255).astype(np.uint8)
    acc_blur = cv2.GaussianBlur(acc,
                                ksize=(9, 9),
                                sigmaX=5,
                                borderType=cv2.BORDER_CONSTANT)
    acc_sharp = cv2.addWeighted(acc, 1.2, acc_blur, -0.2, 0, dtype=cv2.CV_8U)
    acc = acc_sharp

    acc = elastic_transform(acc,
                            alpha=15,
                            sigma=12,
                            alpha_affine=50,
                            border_mode=cv2.BORDER_CONSTANT)

    # cv2.imshow('acc', acc)
    # cv2.waitKey(30)

    return acc
def create_microaneurisms(image,
                          center=(256, 256),
                          radius=140,
                          color=(100, 255, 0),
                          num=5,
                          aneurism_radius=(1, 3),
                          alpha=0.2):
    # mask = image.copy()
    aneurism_mask = np.zeros_like(image)
    for i in range(num):
        x = int(random.gauss(center[0], radius))
        y = int(random.gauss(center[0], radius))

        x = min(max(x, center[0] - radius), center[1] + radius)
        y = min(max(y, center[1] - radius), center[1] + radius)

        r = int(random.uniform(aneurism_radius[0], aneurism_radius[1]))
        cv2.circle(aneurism_mask, (x, y),
                   r,
                   color,
                   thickness=cv2.FILLED,
                   lineType=cv2.LINE_AA)

        # cv2.circle(mask, (x, y), r, (0, 0, 0), thickness=cv2.FILLED, lineType=cv2.LINE_AA)

    aneurism_mask = elastic_transform(aneurism_mask,
                                      alpha=5,
                                      sigma=2,
                                      alpha_affine=0)
    cv2.GaussianBlur(aneurism_mask, ksize=(5, 5), sigmaX=0, dst=aneurism_mask)
    aneurism_mask = 1.0 - aneurism_mask / 255.

    overlay = cv2.addWeighted(image, (1 - alpha),
                              image * aneurism_mask,
                              alpha,
                              0,
                              dtype=cv2.CV_8U)

    return overlay
 def __call__(self, sample):
     # print('grid', np.random.uniform(0.0, 1.0))
     
     if np.random.uniform(0.0, 1.0) < self.p:
         return sample
     h, w, _ = sample["img"].shape
     
     # grid_distortion
     if np.random.uniform(0.0, 1.0) < self.p:
         num_steps=15
         distort_limit=[-0.05,0.05]
         stepsx = [1 + random.uniform(distort_limit[0], distort_limit[1]) for i in
                           range(num_steps + 1)]
         stepsy = [1 + random.uniform(distort_limit[0], distort_limit[1]) for i in
                           range(num_steps + 1)]
         sample["img"]=albumentations.grid_distortion(sample["img"],5,stepsx, stepsy)
     # elastic_transform
     else:
         sample["img"]=albumentations.elastic_transform(sample["img"], alpha=5, sigma=1, alpha_affine=random.uniform(0,2), 
                                         interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_REFLECT_101,)
     
     if np.random.uniform(0.0, 1.0) < self.p-0.2:
         sample["img"]=albumentations.jpeg_compression(sample["img"], random.randint(20, 100))
     return sample