def test_distance_submatrix(self): """ Test distance computation. Test a submatrix is found inside a bigger matrix. """ img = np.array([[64, 2, 3, 61, 60, 6, 7, 57], [9, 55, 54, 12, 13, 51, 50, 16], [17, 47, 46, 20, 21, 43, 42, 24], [40, 26, 27, 37, 1, 1, 1, 33], [32, 34, 35, 29, 1, 1, 1, 25], [41, 23, 22, 44, 1, 1, 1, 48], [49, 15, 14, 52, 53, 11, 10, 56]]) img = np.uint8(gray2rgb(img)) patch = np.array([[26, 27, 37], [34, 35, 29], [23, 22, 44]]) patch = im2double(np.uint8(gray2rgb(patch))) q = Quilt(img, output_size=[20, 20]) result = q.distance(patch, tilesize=3, overlap=2, coord=[1, 1]) expected = zeros((5, 6)) self.assertEqual(expected.shape, result.shape) # check where the min is arg_min = np.where(result == np.min(result)) expected = np.asarray([[3], [1]]) assert_array_equal(expected, arg_min)
def test_distance_candidates(self): """ Test that all the candidates are good choices. """ # eye matrix img = -np.eye(10) * 2 + 1 img = np.asarray(np.dstack((img, img, img))) # parch is similar to a submatrix of img patch = np.asarray([[1, 1, 1, 1.], [1, 1, 1, 1.], [-1, 1, 0, 0.], [1, -1, 0, 0.]]) patch = im2double(gray2rgb(patch)) # compute distance q = Quilt(img, output_size=[20, 20]) distances = q.distance(patch, tilesize=4, overlap=2, coord=[2, 2]) best = np.min(distances) candidates = np.where(distances <= best) # submatrix of img similar to patch expected = np.asarray([[1, 1, 1, 1], [1, 1, 1, 1], [-1, 1, 1, 1], [1, -1, 1, 1]]) for i in range(len(candidates[0])): sub = [candidates[0][i], candidates[1][i]] result = img[sub[0]:sub[0] + 4, sub[1]:sub[1] + 4, 1] assert_array_equal(expected, result)
def test_val2tuple(self): """ Test val2tuple creates the same tuple from different inputs """ expected = [10, 10] result1 = Quilt.val2tuple(10) result2 = Quilt.val2tuple([10]) result3 = Quilt.val2tuple([10, 10]) self.assertEqual(expected, result1) self.assertEqual(expected, result2) self.assertEqual(expected, result3)
def setUpClass(cls): # destination folder if not os.path.isdir(cls.temp_folder): os.makedirs(cls.temp_folder) # load images _size = (60, 60) cls.src = [img2matrix(Image.open(p)) for p in glob(cls.src_paths)] cls.src = [imresize(s, _size) for s in cls.src] cls.imask = img2matrix(imresize(Image.open(cls.imask_path), _size)) cls.cmask = img2matrix(Image.open(cls.cmask_path)) cls.result = os.path.join(cls.temp_folder, 'result.png') cls.dst_size = (50, 20, 3) cls.q = Quilt(cls.src, output_size=cls.dst_size, input_mask=cls.imask, cut_mask=cls.cmask, tilesize=10, overlap=3, big_tilesize=20, big_overlap=5, rotations=0, flip=[0, 0], error=0.02, constraint_start=True, cores=None, result_path=cls.result) cls.q.debug = False cls.q.optimized_compute() cls.results = cls.q.get_result()
def _launch_quilt(debug, final_path, src, **kwargs): """ Launches quilt process with the parsed arguments. """ multi_proc = kwargs.pop('multiprocess') # ------------- quilt -------------- qs = time.time() log.info('Quilt started at {0}'.format(time.strftime("%H:%M:%S"))) try: # compute quilting Quilt.debug = debug q = Quilt(src, **kwargs) if multi_proc: q.optimized_compute() else: q.compute() # get the result result = q.get_result() if debug: show(result) save(result, final_path) except ValueError as err: log.error(err.message) return t = (time.time() - qs) / 60 log.debug('Quilt took {0:0.6f} minutes'.format(t)) log.info('End {0}'.format(time.strftime("%H:%M:%S")))
def test_rotation2(self): """ Test create_rotations with 180 rotation only. """ result = Quilt.create_rotations(self.a, 2) expected = np.asarray([[0, 1, 2, 3], [5, 6, 7, 8], [4, 9, 2, 3], [0, 0, 0, 0], [3, 2, 9, 4], [8, 7, 6, 5], [3, 2, 1, 0]]) np.testing.assert_array_equal(expected, result)
def test_flipV(self): """ Test create_flip with vertical flipping. """ result = Quilt.create_flip(self.a, [1, 0]) expected = np.asarray([[0, 1, 2, 3], [5, 6, 7, 8], [4, 9, 2, 3], [0, 0, 0, 0], [4, 9, 2, 3], [5, 6, 7, 8], [0, 1, 2, 3]]) np.testing.assert_array_equal(expected, result)
def test_flipH(self): """ Test create_flip with horizontal flipping. """ result = Quilt.create_flip(self.a, [0, 1]) expected = np.asarray([[0, 1, 2, 3, 0, 3, 2, 1, 0], [5, 6, 7, 8, 0, 8, 7, 6, 5], [4, 9, 2, 3, 0, 3, 2, 9, 4]]) np.testing.assert_array_equal(expected, result)
def test_chessboard_multiproc(self): """ Test optimized_compute method on the chessboard matrix. Test the final result is still a chessboard matrix with tiles of the same size as the ones in the input. """ q = Quilt(np.float64(self.chessboard), output_size=[16, 16], tilesize=4, overlap=2, error=0, big_tilesize=8, big_overlap=3, constraint_start=True) q.debug = False q.optimized_compute() result = q.get_result()[0] # check the dimension self.assertEqual((16, 16, 3), result.shape) assert_array_equal(result[:, :, 0], result[:, :, 1], result[:, :, 2]) # check the values result = result[:, :, 0] expected = np.asarray([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]) for i in xrange(0, result.shape[0] - 4, 4): for j in xrange(0, result.shape[1] - 4, 4): patch = result[i:i + 4, j:j + 4] assert_array_equal(expected, patch)
def test_flipVH(self): """ Test create_flip with both the flip dimensions activated. """ result = Quilt.create_flip(self.a, [1, 1]) expected = np.asarray([[0, 1, 2, 3, 0, 3, 2, 1, 0], [5, 6, 7, 8, 0, 8, 7, 6, 5], [4, 9, 2, 3, 0, 3, 2, 9, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 9, 2, 3, 0, 3, 2, 9, 4], [5, 6, 7, 8, 0, 8, 7, 6, 5], [0, 1, 2, 3, 0, 3, 2, 1, 0]]) np.testing.assert_array_equal(expected, result)
def test_rotation4(self): """ Test create_rotations with 4 rotations (every 90 degrees) """ result = Quilt.create_rotations(self.a, 4) expected = np.asarray([[0, 1, 2, 3, 0, 3, 8, 3, 0, 4, 5, 0], [5, 6, 7, 8, 0, 2, 7, 2, 0, 9, 6, 1], [4, 9, 2, 3, 0, 1, 6, 9, 0, 2, 7, 2], [0, 0, 0, 0, 0, 0, 5, 4, 0, 3, 8, 3], [3, 2, 9, 4, 0, 0, 0, 0, 0, 0, 0, 0], [8, 7, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0], [3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) np.testing.assert_array_equal(expected, result)
def test_dst_img_mask(self): """ Test the destination image initializes as a zeros matrix of size of the cut_mask if no other size is specified. """ q = Quilt(self.x, cut_mask=zeros((100, 200))) # one layer in the stack self.assertEqual(1, len(q.Y)) # rgb of the required size assert_array_equal((100, 200, 3), q.Y[0].shape) # all zeros expected = zeros((100, 200, 3)) assert_array_equal(expected, q.Y[0])
def test_big_tiles_over(self): """ Test big_tilesize and big_overlap are adjusted on the src image size """ q = Quilt(self.x, output_size=self.x.shape, big_tilesize=200, big_overlap=100) # tilesize expected = self.x.shape[0] - 1 self.assertEqual(expected, q.big_tilesize) # overlap expected = int(q.big_tilesize / 3) self.assertEqual(expected, q.big_overlap)
def test_src_size(self): """ Test the source image is turned to rgb float and is not reshaped. """ q = Quilt(self.x, output_size=self.x.shape) # there is just one image in the stack self.assertEqual(1, len(q.X)) # rgb assert_array_equal((self.x.shape[0], self.x.shape[1], 3), q.X[0].shape) # float self.assertEqual('float', q.X[0].dtype) expected = gray2rgb(im2double(self.x)) assert_array_equal(expected, q.X[0])
def test_rotation4_invert(self): """ Test create_rotations with 4 rotations (every 90 degrees). Test it with a matrix that has height>width """ a = np.rot90(self.a, -1) result = Quilt.create_rotations(a, 4) expected = np.asarray([[0, 1, 2, 3, 0, 3, 8, 3, 0, 4, 5, 0], [5, 6, 7, 8, 0, 2, 7, 2, 0, 9, 6, 1], [4, 9, 2, 3, 0, 1, 6, 9, 0, 2, 7, 2], [0, 0, 0, 0, 0, 0, 5, 4, 0, 3, 8, 3], [3, 2, 9, 4, 0, 0, 0, 0, 0, 0, 0, 0], [8, 7, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0], [3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) np.testing.assert_array_equal(expected, result)
def test_dst_img(self): """ Test the destination image initializes as a zeros matrix of the required size. Test the cut_mask is also resized. """ q = Quilt(self.x, output_size=[100, 200], cut_mask=zeros((100, 300))) # one layer in the stack self.assertEqual(1, len(q.Y)) # rgb of the required size assert_array_equal((100, 200, 3), q.Y[0].shape) # all zeros expected = zeros((100, 200, 3)) assert_array_equal(expected, q.Y[0]) expected = zeros((100, 200)) assert_array_equal(expected, q.Ymask)
def test_stack(self): """ Test the the source images are edited consistently and a same number of destination images is prepared. """ q = Quilt([self.x, self.x, self.x], output_size=[30, 20]) # there are 3 images in the stacks expected_x = gray2rgb(im2double(self.x)) expected_y = zeros((30, 20, 3)) self.assertEqual(3, len(q.X)) self.assertEqual(3, len(q.Y)) for i in xrange(3): # src assert_array_equal((self.x.shape[0], self.x.shape[1], 3), q.X[i].shape) self.assertEqual('float', q.X[i].dtype) assert_array_equal(expected_x, q.X[i]) # dst assert_array_equal((30, 20, 3), q.Y[i].shape) assert_array_equal(expected_y, q.Y[i])
def test_eye(self): """ Test compute method on the known eye matrix. This method is more accurate but it is slower. Test the final result is a composition of eye matrices: for every pixel P, check its neighborhood as following: - if P = 1: 1 .5 .5 - if P = .5: .5 * * .5 P .5 * P * .5 .5 1 * * .5 """ q = Quilt(self.eye, output_size=[10, 10], tilesize=4, overlap=2, error=0, constraint_start=True) q.debug = False q.compute() result = q.get_result()[0] # if there is a 1, its neighborhood must be: 1 .5 .5 # .5 1 .5 # .5 .5 1 self.assertEqual((10, 10, 3), result.shape) assert_array_equal(result[:, :, 0], result[:, :, 1], result[:, :, 2]) result = result[:, :, 0] expected = np.asarray([[1, 0.5, 0.5], [0.5, 1, 0.5], [0.5, 0.5, 1]]) for i in range(1, result.shape[0] - 1): for j in range(1, result.shape[1] - 1): self.assertIn(result[i, j], [1, 0.5]) if result[i, j] == 1: np.testing.assert_array_equal( expected, result[i - 1:i + 2, j - 1:j + 2]) else: try: np.testing.assert_array_equal(0.5, result[i - 1, j - 1]) np.testing.assert_array_equal(0.5, result[i + 1, j + 1]) except AssertionError as err: print err