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_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_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
