def test_convolve2d_adaptive_idkernel(self): kernel = np.zeros((3, 3, 1), dtype="float64") kernel[1, 1, 0] = 1.0 image = np.random.random((10, 10)) # image = np.arange(100, dtype="float64").reshape((10, 10)) conv = varconv.convolve2d_adaptive(image, kernel, 0) self.assertEqual(conv.shape, image.shape) self.assertLess(np.linalg.norm(image - conv), 1E-10)
def test_convolve2d_adaptive_undoing(self): deg = 2 k_side = 3 pol_dof = (deg + 1) * (deg + 2) / 2 kernel = np.random.random((k_side, k_side, pol_dof)) refimage = np.random.random((10, 10)) image = varconv.convolve2d_adaptive(refimage, kernel, deg) mm, b, c = varconv.gen_matrix_system(image, refimage, 0, None, k_side, deg, -1) coeffs = np.linalg.solve(mm, b) result_kernel = coeffs.reshape((k_side, k_side, pol_dof)) opt_ref = varconv.convolve2d_adaptive(refimage, result_kernel, deg) self.assertLess(np.linalg.norm(opt_ref - image, ord=np.inf) / np.linalg.norm(image, ord=np.inf), 1E-8) self.assertLess(np.linalg.norm((kernel - result_kernel).flatten(), ord=np.inf) / np.linalg.norm(kernel.flatten(), ord=np.inf), 1E-8)
def test_convolve2d_adaptive_undoing(self): deg = 2 k_side = 3 pol_dof = (deg + 1) * (deg + 2) // 2 kernel = np.random.random((k_side, k_side, pol_dof)) refimage = np.random.random((10, 10)) image = varconv.convolve2d_adaptive(refimage, kernel, deg) mm, b = varconv.gen_matrix_system(image, refimage, 0, None, k_side, deg, -1) coeffs = np.linalg.solve(mm, b) result_kernel = coeffs.reshape((k_side, k_side, pol_dof)) opt_ref = varconv.convolve2d_adaptive(refimage, result_kernel, deg) self.assertLess(np.linalg.norm(opt_ref - image, ord=np.inf) / np.linalg.norm(image, ord=np.inf), 1E-8) self.assertLess(np.linalg.norm((kernel - result_kernel).flatten(), ord=np.inf) / np.linalg.norm(kernel.flatten(), ord=np.inf), 1E-8)
def test_convolve2d_adaptive_cameraman(self): from PIL import Image this_dir = os.path.abspath(os.path.dirname(__file__)) cameraman_path = os.path.join(this_dir, "cameraman.tif") refimage = np.array(Image.open(cameraman_path), dtype='float64') # degrade reference deg = 2 k_side = 3 pol_dof = (deg + 1) * (deg + 2) / 2 kernel = np.random.random((k_side, k_side, pol_dof)) image = varconv.convolve2d_adaptive(refimage, kernel, deg) mm, b, c = varconv.gen_matrix_system(image, refimage, 0, None, k_side, deg, -1) coeffs = np.linalg.solve(mm, b) result_kernel = coeffs.reshape((k_side, k_side, pol_dof)) opt_ref = varconv.convolve2d_adaptive(refimage, result_kernel, deg) self.assertLess(np.linalg.norm(opt_ref - image, ord=np.inf) / np.linalg.norm(image, ord=np.inf), 1E-8)
def test_convolve2d_adaptive_cameraman(self): from PIL import Image this_dir = os.path.abspath(os.path.dirname(__file__)) cameraman_path = os.path.join(this_dir, "cameraman.tif") refimage = np.array(Image.open(cameraman_path), dtype='float64') # degrade reference deg = 2 k_side = 3 pol_dof = (deg + 1) * (deg + 2) // 2 kernel = np.random.random((k_side, k_side, pol_dof)) image = varconv.convolve2d_adaptive(refimage, kernel, deg) mm, b = varconv.gen_matrix_system(image, refimage, 0, None, k_side, deg, -1) coeffs = np.linalg.solve(mm, b) result_kernel = coeffs.reshape((k_side, k_side, pol_dof)) opt_ref = varconv.convolve2d_adaptive(refimage, result_kernel, deg) self.assertLess(np.linalg.norm(opt_ref - image, ord=np.inf) / np.linalg.norm(image, ord=np.inf), 1E-8)
def convolve2d_adaptive(image, kernel, poly_degree): "Convolve image with the adaptive kernel of `poly_degree` degree." import varconv # Check here for dimensions if image.ndim != 2: raise ValueError("Wrong dimensions for image") if kernel.ndim != 3: raise ValueError("Wrong dimensions for kernel") conv = varconv.convolve2d_adaptive(image, kernel, poly_degree) return conv
def get_optimal_image(self): # AdaptiveBramich has to override this function because it uses a # special type of convolution for optimal_image if self.optimal_image is not None: return self.optimal_image import varconv opt_image = varconv.convolve2d_adaptive(self.refimage, self.get_kernel(), self.poly_deg) if self.bkgdegree is not None: opt_image += self.get_background() if self.badpixmask is not None: self.optimal_image = np.ma.array(opt_image, mask=self.badpixmask) else: self.optimal_image = opt_image return self.optimal_image
def convolve2d_adaptive(image, kernel, poly_degree): import varconv # Check here for dimensions if image.ndim != 2: raise ValueError("Wrong dimensions for image") if kernel.ndim != 3: raise ValueError("Wrong dimensions for kernel") # Check here for types if image.dtype != np.float64: img64 = image.astype('float64') else: img64 = image if kernel.dtype != np.float64: k64 = kernel.astype('float64') else: k64 = kernel conv = varconv.convolve2d_adaptive(img64, k64, poly_degree) return conv
def make_system(self): import varconv # Check here for types if self.image_data.dtype != np.float64: img64 = self.image_data.astype('float64') else: img64 = self.image_data if self.refimage_data.dtype != np.float64: ref64 = self.refimage_data.astype('float64') else: ref64 = self.refimage_data c_bkgdegree = -1 if self.bkgdegree is None else self.bkgdegree m, b, conv = varconv.gen_matrix_system(img64, ref64, self.badpixmask is not None, self.badpixmask, self.k_side, self.poly_deg, c_bkgdegree) coeffs = np.linalg.solve(m, b) poly_dof = (self.poly_deg + 1) * (self.poly_deg + 2) / 2 k_dof = self.k_side * self.k_side * poly_dof ks = self.k_side self.kernel = coeffs[:k_dof].reshape((ks, ks, self.poly_dof)) opt_conv = varconv.convolve2d_adaptive(ref64, self.kernel, self.poly_deg) if self.bkgdegree is not None: self.background = self.coeffstobackground(coeffs[k_dof:]) self.optimal_image = opt_conv + self.background else: self.background = np.zeros(self.image.shape) self.optimal_image = opt_conv if self.badpixmask is not None: self.optimal_image = np.ma.array(self.optimal_image, mask=self.badpixmask) self.difference = self.image - self.optimal_image