def test_throws_when_intensity_range_out_of_range(): with testing.raises(ValueError): random_shapes((1000, 1234), max_shapes=1, multichannel=False, intensity_range=(0, 256)) with testing.raises(ValueError): random_shapes((2, 2), max_shapes=1, intensity_range=((-1, 255),))
def gen_image(imgType, noise=True): if imgType == 'grayscale': img, _ = random_shapes((512, 512), max_shapes=30, intensity_range=(0, 255), min_size=50, multichannel=False, max_size=np.random.randint(50, 150), allow_overlap=False) else: img, _ = random_shapes((512, 512), max_shapes=30, intensity_range=(0, 255), min_size=50, multichannel=False, max_size=np.random.randint(50, 150), allow_overlap=False) img[img == 255] = 0 mask = np.zeros(img.shape, dtype=np.uint8) mask[:, :] = img mask[mask > 0] = 255 if noise: nsImg = random_noise(img) return nsImg, mask
def test_generate_triangle_throws_when_size_too_small(): with testing.raises(ValueError): random_shapes((128, 64), max_shapes=1, min_size=1, max_size=1, shape='triangle')
def test_throws_when_intensity_range_out_of_range(): with testing.raises(ValueError): random_shapes((1000, 1234), max_shapes=1, multichannel=False, intensity_range=(0, 256)) with testing.raises(ValueError): random_shapes((2, 2), max_shapes=1, intensity_range=((-1, 255),))
def test_generate_circle_throws_when_size_too_small(): with testing.raises(ValueError): random_shapes((64, 128), max_shapes=1, min_size=1, max_size=1, shape='circle')
def test_throws_when_intensity_range_out_of_range(): with testing.raises(ValueError): with expected_warnings(["`multichannel` is a deprecated argument"]): random_shapes((1000, 1234), max_shapes=1, multichannel=False, intensity_range=(0, 256)) with testing.raises(ValueError): random_shapes((2, 2), max_shapes=1, intensity_range=((-1, 255), ))
def test_generates_gray_images_with_correct_shape_deprecated_multichannel(): with expected_warnings(["`multichannel` is a deprecated argument"]): image, _ = random_shapes((4567, 123), min_shapes=3, max_shapes=20, multichannel=False) assert image.shape == (4567, 123) # repeat prior test, but check for positional multichannel warning with expected_warnings(["Providing the `multichannel` argument"]): image, _ = random_shapes((4567, 123), 20, 3, 2, None, False) assert image.shape == (4567, 123)
def random_shape_maze(width, height, max_shapes, max_size, allow_overlap, shape=None, seed=None): x, _ = random_shapes([height, width], max_shapes, max_size=max_size, multichannel=False, shape=shape, allow_overlap=allow_overlap, random_seed=seed) x[x == 255] = 0 x[np.nonzero(x)] = 1 # wall x[0, :] = 1 x[-1, :] = 1 x[:, 0] = 1 x[:, -1] = 1 return np.asarray(x, dtype=np.float32)
def test_returns_empty_labels_and_white_image_when_cannot_fit_shape(): # The circle will never fit this. with expected_warnings(['Could not fit']): image, labels = random_shapes( (10000, 10000), max_shapes=1, min_size=10000, shape='circle') assert len(labels) == 0 assert (image == 255).all()
def WorldG(): image2, _ = random_shapes((128, 128), shape='circle', min_shapes=10, max_shapes=15, min_size=20, max_size=25, intensity_range=((100, 254), )) image2 = np.where(image2 == 255, 0, image2) x_1 = np.random.randint(0, 120) y_1 = np.random.randint(0, 120) x_2 = np.random.randint(0, 120) y_2 = np.random.randint(0, 120) while distance(x_1, x_2, y_1, y_2) < 50: x_1 = np.random.randint(0, 120) y_1 = np.random.randint(0, 120) x_2 = np.random.randint(0, 120) y_2 = np.random.randint(0, 120) cv2.circle(image2, (x_1, y_1), 5, (255, 255, 255), thickness=cv2.FILLED) cv2.circle(image2, (x_2, y_2), 5, (255, 255, 255), thickness=cv2.FILLED) cv2.imwrite('test.png', image2) #plt.imshow(image2) #plt.title('my picture1') #plt.show() return image2
def test_generates_white_image_when_min_pixel_intensity_255(): image, labels = random_shapes((128, 128), max_shapes=3, min_pixel_intensity=255, random_seed=42) assert len(labels) > 0 assert (image == 255).all()
def flow_random_shapes(self, ): while True: images = np.empty(self.im_shape) kspaces = np.empty(self.im_shape) for i in range(self.batch_size): image, _ = random_shapes( (self.size, self.size), max_shapes=self.n_shapes, multichannel=False, allow_overlap=True, max_size=self.size, ) image = image.astype('float32') image /= 255 kspace = fft(image) images[i, ..., 0] = image kspaces[i, ..., 0] = kspace mask = gen_mask(kspaces[0, ..., 0], accel_factor=self.af) fourier_mask = np.repeat(mask.astype(np.float), self.size, axis=0) mask_batch = np.repeat(fourier_mask[None, ...], len(kspaces), axis=0)[..., None] kspaces *= mask_batch mask_batch = mask_batch[..., 0] yield (kspaces, mask_batch), images
def random_mask(H, W, mask_size=200): """ mask: ranges in [0,1] """ masked_image = np.zeros([H, W, 3]) mask = random_shapes( [H, W], max_shapes=1, min_shapes=1, max_size=mask_size, min_size=mask_size / 2, multichannel=False, intensity_range=[0, 0], )[0] mask = np.stack((mask, mask, mask), axis=-1) random_state = np.random.RandomState(None) distortion_range = 50 alpha = np.random.rand() * 6 forward_dx = ( gaussian_filter((random_state.rand(H, W) * 2 - 1), distortion_range, mode="constant", cval=0) * alpha * 1000 ) forward_dy = ( gaussian_filter((random_state.rand(H, W) * 2 - 1), distortion_range, mode="constant", cval=0) * alpha * 1000 ) mask = forward_mapping(mask, forward_dy, forward_dx, maxIter=3, precision=1e-3) / 255 mask = 1 - gaussian(mask, sigma=0, preserve_range=True, multichannel=False, anti_aliasing=True) mask = mask[:, :, 0] return mask
def test_returns_empty_labels_and_white_image_when_cannot_fit_shape(): # The circle will never fit this. with expected_warnings(['Could not fit']): image, labels = random_shapes( (10000, 10000), max_shapes=1, min_size=10000, shape='circle') assert len(labels) == 0 assert (image == 255).all()
def generate_rect_mask(mesh, min_shapes=1, max_shapes=1, skimage_labels=False, multichannel=False, intensity_range=((1, 1)), units=False, shape='rectangle',**kargs): image, labels = random_shapes(mesh.shape, min_shapes=min_shapes, shape='rectangle', max_shapes=max_shapes, multichannel=multichannel, intensity_range=intensity_range, **kargs) idx = image == 255 image[idx] = 0 if not skimage_labels: labels = convert_labels(labels, mesh, units=units) return image, labels
def gen_one_image(h=64, w=64): shapes = ('rectangle', 'triangle', 'circle') n_images = 3 #np.random.randint(1, 9) matrix = np.zeros((h, w, n_images)) image = np.zeros((h, w, 3)) mask = np.full((h, w), -1) for i in range(n_images): n_shape = np.random.randint(len(shapes)) tmp_image, _ = random_shapes( (h, w), max_shapes=1, min_shapes=1, shape=shapes[n_shape], # multichannel=True, num_channels=3, min_size=11, max_size=22, allow_overlap=True) matrix[tmp_image[:, :, 0] < 255, i] = 1 mask[tmp_image[:, :, 0] < 255] = n_shape tmp_image[tmp_image == 255] = 0 image[tmp_image[:, :, 0] > 0] = tmp_image[tmp_image[:, :, 0] > 0] image /= 255 image[image == 0] = 1 return image, mask, matrix
def test_random_shapes_is_reproducible_with_seed(): random_seed = 42 labels = [] for _ in range(5): _, l = random_shapes((128, 128), max_shapes=5, random_seed=random_seed) labels.append(l) assert all(other == labels[0] for other in labels[1:])
def _apply_shapes(self, data: np.ndarray) -> np.ndarray: channels, height, width = get_image_dims(data) # Wrap intensity_range in another tuple for color images. User might have provided nested tuple already though, # so don't wrap those again. intensity_range = self.intensity_range if channels > 1 and not isinstance(intensity_range[0], tuple): intensity_range = (intensity_range, ) shapes, _ = random_shapes(image_shape=(height, width), max_shapes=self.max_shapes, max_size=self.max_size, num_channels=channels, intensity_range=intensity_range, allow_overlap=True) alpha = np.random.uniform(self.transparency_range[0], self.transparency_range[1]) # Convert shapes to range [0,1] if image is floating point normalized_shapes = shapes / 255.0 if np.issubdtype( data.dtype, np.floating) else shapes blend = normalized_shapes * alpha + data * (1.0 - alpha) # Combine images without whitening non-shape regions overlay = np.where(shapes < 255, blend, data) return overlay.astype(data.dtype)
def test_generates_white_image_when_intensity_range_255(): image, labels = random_shapes((128, 128), max_shapes=3, intensity_range=((255, 255), ), random_seed=42) assert len(labels) > 0 assert (image == 255).all()
def make_image(): i = np.random.randint(0,255,(200,256,4),dtype='uint8') i[:,:,3] = 0 shape = random_shapes((200, 256), max_shapes=4,allow_overlap=True, intensity_range=((100, 255)),num_channels=1) shape = shape[0].reshape((200,256)) i[:,:,3][shape[:]<255] =255 return i
def generate_shapes(img_size): img_array, labels = random_shapes(img_size, min_shapes=2, max_shapes=10, multichannel=False, allow_overlap=True) img = Image.fromarray(img_array) return img
def test_random_shapes_is_reproducible_with_seed(): random_seed = 42 labels = [] for _ in range(5): _, label = random_shapes((128, 128), max_shapes=5, random_seed=random_seed) labels.append(label) assert all(other == labels[0] for other in labels[1:])
def create_simple_object_detection_dataset(path, n_samples=100, n_objects_max=3, n_objects_min=1, size=(150, 150), min_size=0.2): (path / 'images').mkdir(parents=True, exist_ok=True) (path / 'class_images').mkdir(parents=True, exist_ok=True) min_dimension = size[0] if (size[1] < size[0]): min_dimension = size[1] # create class labels cname = ['red', 'green', 'blue'] color = [(255, 0, 0), (0, 255, 0), (0, 0, 255)] for clr, name in zip(color, cname): img_name = f'{name}' img = np.ones((50, 50, 3), dtype=np.uint8) draw_rectangle(img, start=(0, 0), dimensions=(50, 50), color=clr) save_img(path / 'class_images', img_name, img) type_shapes = ['rectangle', 'circle', 'ellipse'] # create images + annotations annotations = {} images = {} for i in range(n_samples): labels = [] bboxs = [] img_name = f'img_{i}' image, shapes = random_shapes(size, n_objects_max, multichannel=True, shape=type_shapes[randint(0, 2)], min_shapes=n_objects_min, min_size=min_size * min_dimension) for shape in shapes: shape_name = shape[0] rr_0, rr_1 = shape[1][0] cc_0, cc_1 = shape[1][1] middle_x = int((rr_0 + rr_1) / 2) middle_y = int((cc_0 + cc_1) / 2) label = (image[middle_x, middle_y].tolist(), shape_name) bbox = (int(cc_0), int(rr_0), int(cc_1), int(rr_1)) labels.append(label) bboxs.append(bbox) img_file = img_name + ".jpg" images[img_file] = image save_img(path / 'images', img_name, image) annotations[img_file] = {'labels': labels, 'bboxs': bboxs} save_img_annotations(path, annotations) return (images, annotations)
def generateRandShapes(min_s, max_s, min_size, overlap, sizes=(1000, 1000)): image, _ = random_shapes(sizes, min_shapes=min_s, max_shapes=max_s, min_size=min_size, allow_overlap=overlap, num_trials=100) return image
def __generate_random_shapes(self, min_shapes, max_shapes): img, _ = random_shapes(self.shape, max_shapes, min_shapes=min_shapes, multichannel=False, allow_overlap=True, random_seed=np.random.randint(2**32 - 1)) # Numpy random usage for random seed unifies random seed which can be set for repeatability attempt = np.array(img != 255, dtype=bool) return attempt, np.sum(attempt)
def test_can_generate_one_by_one_rectangle(): image, labels = random_shapes((50, 128), max_shapes=1, min_size=1, max_size=1, shape='rectangle', min_pixel_intensity=1) assert len(labels) == 1 _, bbox = labels[0] crop = image[bbox[0][0]:bbox[0][1], bbox[1][0]:bbox[1][1]] assert (crop < 255).sum() == 3 # rgb
def test_can_generate_one_by_one_rectangle(): image, labels = random_shapes((50, 128), max_shapes=1, min_size=1, max_size=1, shape='rectangle') assert len(labels) == 1 _, bbox = labels[0] crop = image[bbox[0][0]:bbox[0][1], bbox[1][0]:bbox[1][1]] # rgb assert (np.shape(crop) == (1, 1, 3) and np.any(crop >= 1) and np.any(crop < 255))
def _create_label_data(): y_true, _ = random_shapes(image_shape=(200, 200), min_shapes=20, max_shapes=30, min_size=10, multichannel=False) y_true[y_true == 255] = 0 y_true, _, _ = relabel_sequential(y_true) y_pred = np.zeros_like(y_true) y_pred[3:, 3:] = y_true[:-3, :-3] return y_true, y_pred
def get_results(shapes, camera_images, num): result = random_shapes((120, 1920), intensity_range=(0, 1), max_shapes=1, min_size=99, max_size=100, shape=shapes, multichannel=False) result_pad = np.pad(result[0], ((480, 480), (0, 0)), mode='constant', constant_values=255) camera_images.append(result_pad) append_single(camera_images, int(num - 1))
def generate_shape(): for i in range (500): image_name = "shape_" + str(i) + ".png" #create shape image with color shape, _ = random_shapes((256,256), min_shapes=5, max_shapes=10, min_size=20, allow_overlap=True) shape_img = Image.fromarray(shape) shape_img.save("shape_color/"+image_name,"PNG") #create mask mask_img = shape_img.convert("L") mask_array = np.asarray(mask_img) mask_array = np.where(mask_array < 255, 0,255) mask_img = Image.fromarray(mask_array.astype(np.uint8)) mask_img.save("shape_mask/"+image_name,"PNG")
def test_can_generate_one_by_one_rectangle(): image, labels = random_shapes( (50, 128), max_shapes=1, min_size=1, max_size=1, shape='rectangle') assert len(labels) == 1 _, bbox = labels[0] crop = image[bbox[0][0]:bbox[0][1], bbox[1][0]:bbox[1][1]] # rgb assert (np.shape(crop) == (1, 1, 3) and np.any(crop >= 1) and np.any(crop < 255))
def generate_level(self): level_setup = random_shapes( image_shape=settings.BRICKS_DIMENSION, min_shapes=10, max_shapes=20, min_size=3, max_size=10, allow_overlap=True, intensity_range=((30, 255),))[0] for x in range(settings.BRICKS_DIMENSION[0]): for y in range(settings.BRICKS_DIMENSION[1]): if all(color != 255 for color in level_setup[x][y]): position = pygame.Vector2(board_left() + settings.BRICKS_POSITION[0] + x * settings.BRICK_SIZE[0], board_top() + settings.BRICKS_POSITION[1] + y * settings.BRICK_SIZE[1]) self.bricks.add(Brick(self.screen, position, level_setup[x][y]))
def test_generated_shape_for_channel_axis(channel_axis): shape = (128, 64) num_channels = 5 image, _ = random_shapes(shape, num_channels=num_channels, min_shapes=3, max_shapes=10, channel_axis=channel_axis) if channel_axis is None: expected_shape = shape else: expected_shape = tuple(np.insert(shape, channel_axis, num_channels)) assert image.shape == expected_shape
def random_mask(image, mask, num_mask=20, min_size=5, max_size=128): """ """ raw, _ = random_shapes(image.shape[:2], num_mask, min_shapes=2, min_size=min_size, max_size=max_size, multichannel=False, allow_overlap=True) mask_raw = 1 - raw / 255. noise = np.random.random(image.shape) image[mask_raw > 0] = noise[mask_raw > 0] * random.randint(0, 255) mask = mask * (mask_raw == 0) return image, mask
def test_generates_correct_bounding_boxes_for_triangles(): image, labels = random_shapes( (128, 128), max_shapes=1, shape='triangle', random_seed=42) assert len(labels) == 1 label, bbox = labels[0] assert label == 'triangle', label crop = image[bbox[0][0]:bbox[0][1], bbox[1][0]:bbox[1][1]] # The crop is filled. assert (crop >= 0).any() and (crop < 255).any() # The crop is complete. image[bbox[0][0]:bbox[0][1], bbox[1][0]:bbox[1][1]] = 255 assert (image == 255).all()
def test_generate_triangle_throws_when_size_too_small(): with testing.raises(ValueError): random_shapes( (128, 64), max_shapes=1, min_size=1, max_size=1, shape='triangle')
def test_generate_circle_throws_when_size_too_small(): with testing.raises(ValueError): random_shapes( (64, 128), max_shapes=1, min_size=1, max_size=1, shape='circle')
def test_generates_color_images_with_correct_shape(): image, _ = random_shapes((128, 128), max_shapes=10) assert image.shape == (128, 128, 3)
def test_generates_white_image_when_intensity_range_255(): image, labels = random_shapes((128, 128), max_shapes=3, intensity_range=((255, 255),), random_seed=42) assert len(labels) > 0 assert (image == 255).all()
def test_generates_gray_images_with_correct_shape(): image, _ = random_shapes( (4567, 123), min_shapes=3, max_shapes=20, multichannel=False) assert image.shape == (4567, 123)
""" ============= Random Shapes ============= Example of generating random shapes with particular properties. """ import matplotlib.pyplot as plt from skimage.draw import random_shapes # Let's start simple and generate a 128x128 image # with a single grayscale rectangle. result = random_shapes((128, 128), max_shapes=1, shape='rectangle', multichannel=False) # We get back a tuple consisting of (1) the image with the generated shapes # and (2) a list of label tuples with the kind of shape (e.g. circle, # rectangle) and ((r0, r1), (c0, c1)) coordinates. image, labels = result print('Image shape: {}\nLabels: {}'.format(image.shape, labels)) # We can visualize the images. fig, axes = plt.subplots(nrows=2, ncols=3) ax = axes.ravel() ax[0].imshow(image, cmap='gray') ax[0].set_title('Grayscale shape') # The generated images can be much more complex. For example, let's try many # shapes of any color. If we want the colors to be particularly light, we can