def solve_and_refine(x, w, refine=True, **tv_args):
opt = tv1_2d(x, w[0], **tv_args)
if refine: # Should we improve it with isotonic regression.
opt = TotalVariationBase._refine(opt, x, w, w)
return opt
def forward(self, x, w):
r"""Solve the total variation problem and return the solution.
Arguments
---------
x: :class:`torch:torch.Tensor`
A tensor with shape ``(m, n)`` holding the input signal.
weights_row: :class:`torch:torch.Tensor`
The horizontal edge weights.
Tensor of shape ``(m, n - 1)``, or ``(1,)`` if all weights
are equal.
weights_col: :class:`torch:torch.Tensor`
The vertical edge weights.
Tensor of shape ``(m - 1, n)``, or ``(1,)`` if all weights
are equal.
Returns
-------
:class:`torch:torch.Tensor`
The solution to the total variation problem, of shape ``(m, n)``.
"""
assert w.size() == (1, )
opt = tv1_2d(x.numpy(), w.numpy()[0], **self.tv_args)
if self.refine: # Should we improve it with isotonic regression.
opt = self._refine(opt, x, w, w)
opt = torch.Tensor(opt).view_as(x)
self.save_for_backward(opt)
return opt
def reconstruct_images_TV(P_stacked, coefs, lam):
# Reconstruct using TV regularization
# We use the proxTV toolbox for this: https://github.com/albarji/proxTV
import prox_tv as ptv
lr = 0.5
n_iter = 400
x = np.zeros([IMAGE_DIM**2, coefs.shape[1]])
for i in range(n_iter):
delta = coefs - P_stacked.dot(x)
x += lr * (P_stacked.T).dot(delta)
for img in range(coefs.shape[1]):
# Do each image separately
x[:, img] = (ptv.tv1_2d(x[:, img].reshape((IMAGE_DIM, IMAGE_DIM)),
lam * lr)).flatten()
# Each image should be between 0 and 1 so we enforce this constraint
x[x < 0] = 0
x[x > 1] = 1
if (i % 100 == 0):
print('Number of iterations: ' + str(i))
# Some code to manipulate and organize the reconstructions
recons = np.zeros([coefs.shape[1], IMAGE_DIM, IMAGE_DIM])
for i in range(coefs.shape[1]):
vec_img = x[:, i]
recon = vec_img.reshape((IMAGE_DIM, IMAGE_DIM))
recons[i, :, :] = recon
return recons
def tde_tosubspace(I, A, lam = 0):
#(Matt Berger wrote part of this function)
N = I.shape[1]
P = I.shape[0]
s_dim = A
I_mean = (1.0/N)*I.dot(np.ones(N))
I_centered = I - np.asarray([I_mean]*N).T
# first, compute subspace for I, and corresponding subspace representations
print 'forming input covariance matrix: ',
start_time = time.time()
input_covariance = I_centered.T.dot(I_centered)
end_time = time.time()
print end_time-start_time, " seconds"
print 'computing data subspace: ',
start_time = time.time()
[data_eigenvalues, data_eigenvectors] = linalg.eigh(input_covariance)
print 'input eigenvalues:',data_eigenvalues
end_time = time.time()
print end_time-start_time, " seconds"
max_s_dim = N
for idx,eigenvalue in enumerate(data_eigenvalues):
if eigenvalue > 1e-12:
break
max_s_dim=max_s_dim-1
if max_s_dim < A:
s_dim = max_s_dim
print 'subspace of dimensionality:',s_dim,'NOT',A
data_subspace = I_centered.dot(data_eigenvectors[0:N,-s_dim:])
data_subspace = data_subspace/np.sqrt(np.sum(data_subspace**2, 0))
#print 'data eigenvalues:',data_eigenvalues
if lam > 0:
import prox_tv as ptv
#Perform total variation denoising on the subspace columns
#TODO: This is no longer an orthogonal subspace
for i in range(data_subspace.shape[1]-A, data_subspace.shape[1]):
print "Doing i = %i"%i
v = np.reshape(data_subspace[:, i], IDims)
vnew = np.zeros(v.shape)
for k in range(3):
vnew[:, :, k] = ptv.tv1_2d(v[:, :, k], lam)
plt.subplot(121)
v = np.reshape(data_subspace[:, i], IDims)
plt.imshow(v/np.max(v))
plt.title("Component %i"%i)
plt.subplot(122)
plt.imshow(vnew/np.max(vnew))
plt.savefig("TV%i.png"%i, dpi=200)
data_subspace[:, i] = vnew.flatten()
# project data
print 'projecting data...'
s_I = data_subspace.T.dot(I_centered)
return (data_subspace, s_I)
def tde_tosubspace(I, A, lam=0):
#(Matt Berger wrote part of this function)
N = I.shape[1]
P = I.shape[0]
s_dim = A
I_mean = (1.0 / N) * I.dot(np.ones(N))
I_centered = I - np.asarray([I_mean] * N).T
# first, compute subspace for I, and corresponding subspace representations
print 'forming input covariance matrix: ',
start_time = time.time()
input_covariance = I_centered.T.dot(I_centered)
end_time = time.time()
print end_time - start_time, " seconds"
print 'computing data subspace: ',
start_time = time.time()
[data_eigenvalues, data_eigenvectors] = linalg.eigh(input_covariance)
print 'input eigenvalues:', data_eigenvalues
end_time = time.time()
print end_time - start_time, " seconds"
max_s_dim = N
for idx, eigenvalue in enumerate(data_eigenvalues):
if eigenvalue > 1e-12:
break
max_s_dim = max_s_dim - 1
if max_s_dim < A:
s_dim = max_s_dim
print 'subspace of dimensionality:', s_dim, 'NOT', A
data_subspace = I_centered.dot(data_eigenvectors[0:N, -s_dim:])
data_subspace = data_subspace / np.sqrt(np.sum(data_subspace**2, 0))
#print 'data eigenvalues:',data_eigenvalues
if lam > 0:
import prox_tv as ptv
#Perform total variation denoising on the subspace columns
#TODO: This is no longer an orthogonal subspace
for i in range(data_subspace.shape[1] - A, data_subspace.shape[1]):
print "Doing i = %i" % i
v = np.reshape(data_subspace[:, i], IDims)
vnew = np.zeros(v.shape)
for k in range(3):
vnew[:, :, k] = ptv.tv1_2d(v[:, :, k], lam)
plt.subplot(121)
v = np.reshape(data_subspace[:, i], IDims)
plt.imshow(v / np.max(v))
plt.title("Component %i" % i)
plt.subplot(122)
plt.imshow(vnew / np.max(vnew))
plt.savefig("TV%i.png" % i, dpi=200)
data_subspace[:, i] = vnew.flatten()
# project data
print 'projecting data...'
s_I = data_subspace.T.dot(I_centered)
return (data_subspace, s_I)
def test_tv1_tvp_2d():
"""Tests that 2D-TVp == 2D-TV1 when p=1"""
for _ in range(20):
x = _generate2D()
w = 20 * np.random.rand()
solution1 = tv1_2d(x, w, max_iters=5000)
solutionp = tvp_2d(x, w, w, 1, 1, max_iters=5000)
assert np.allclose(solution1, solutionp, atol=1e-3)
def test_tv1_tvp_2d():
"""Tests that 2D-TVp == 2D-TV1 when p=1"""
for _ in range(20):
x = _generate2d()
w = 20*np.random.rand()
solution1 = tv1_2d(x, w, max_iters=5000)
solutionp = tvp_2d(x, w, w, 1, 1, max_iters=5000)
assert np.allclose(solution1, solutionp, atol=1e-3)
def test_tvgen_2d():
"""Tests that the general solver returns correct 2d solutions"""
for _ in range(20):
x = _generate2d()
w = 20*np.random.rand()
specific = tv1_2d(x, w, max_iters=1000)
general = tvgen(x, [w, w], [1, 2], [1, 1], max_iters=1000)
assert np.allclose(specific, general, atol=1e-2)
def test_tvgen_2d():
"""Tests that the general solver returns correct 2d solutions"""
for _ in range(20):
x = _generate2D()
w = 20 * np.random.rand()
specific = tv1_2d(x, w, max_iters=1000)
general = tvgen(x, [w, w], [1, 2], [1, 1], max_iters=1000)
assert np.allclose(specific, general, atol=1e-2)
def test_tv1w_2d_emengd():
r"""Issue reported by emengd
Make the solver fail due to missing checks on integer arguments
"""
a = -np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])/10.
sol1 = tv1w_2d(a, np.array([[1, 1, 1], [1, 1, 1]]),
np.array([[1, 1], [1, 1], [1, 1]]), max_iters=100)
sol2 = tv1_2d(a, 1)
assert np.allclose(sol1, sol2, atol=1e-3)
def processInput(x, **kwargs):
"""
Processes images based on the given input 1) List of filenames 2) z-index of stack mem-map
if x is [str] the input to the script is assumed to be a folder of multiple .png/.tif image files
if x is [int] the input to the script is assumed to be single tif stack
"""
if isinstance(x, str):
file_in = os.path.join(inputfolder, x)
sys.stdout.write('Loading: ' + str(file_in) + ' -> ')
name, extension = os.path.splitext(x)
img = cv2.imread(file_in, cv2.IMREAD_UNCHANGED)
file_out = os.path.join(outputfolder, str(name + '.png'))
elif isinstance(x, int):
mem_map_path = kwargs['mmap']
stack_arr = load(mem_map_path, mmap_mode='r')
sys.stdout.write('Loading: image layer no. ' + str(x + 1) + ' -> ')
img = stack_arr[x, :, :]
name_with_path, extension = os.path.splitext(inputfolder)
out_name = str(
os.path.basename(name_with_path)) + "_" + str(x + 1) + ".png"
file_out = os.path.join(outputfolder, out_name)
else:
raise ValueError("Input supplied is incompatible")
sys.stdout.write('Type: ' + str(img.dtype) + '\n')
# Check 3rd dimension here, if loaded as RGB, remove 3rd dimension here
if len(img.shape) > 2:
# print('Converting RGB to grey level image')
img = img[:, :, 0]
try:
img = skimage.util.img_as_float(img)
except:
img = skimage.img_as_float64(img)
# remove extreme outlier pixels before denoising
img = skimage.exposure.rescale_intensity(img,
in_range=(np.percentile(img, 1),
np.percentile(img, 99)),
out_range=(0, 1))
sigma_est1 = skimage.restoration.estimate_sigma(skimage.img_as_float(img))
img = ptv.tv1_2d(img, sigma_est1 / 2, n_threads=num_threads)
# img = skimage.restoration.denoise_tv_chambolle(img, weight=sigma_est1/2, multichannel=False)
# img = skimage.restoration.denoise_tv_bregman(img, weight=sigma_est1/2, max_iter=100, eps=0.001, isotropic=True);
img = skimage.exposure.rescale_intensity(
img,
in_range=(np.percentile(img,
cutperc), np.percentile(img, 100 - cutperc)),
out_range=(0, 1))
sigma_est2 = skimage.restoration.estimate_sigma(skimage.img_as_float(img))
# sys.stdout.write(file_out + ": Estimated Gaussian noise stdev before " + str(sigma_est1) + " vs after denoising = " + str(sigma_est2))
sys.stdout.write('Saving: ' + str(file_out) + '\n')
img = 255 * img
img = img.astype(np.uint8)
cv2.imwrite(file_out, img)
def test_tv1w_2d_uniform_weights():
for _ in range(20):
x = _generate2d()
rows = len(x)
cols = len(x[0])
w1 = np.random.rand()
w_rows = np.ones([rows-1, cols]) * w1
w_cols = np.ones([rows, cols-1]) * w1
solw = tv1w_2d(x, w_rows, w_cols, max_iters=5000)
solw1 = tv1_2d(x, w1, max_iters=5000)
assert np.allclose(solw, solw1, atol=1e-3)
def test_tv1_2d():
"""Tests that all 2D-TV methods produce equivalent results"""
methods = ('yang', 'condat', 'chambolle-pock', 'kolmogorov', 'pd', 'dr')
for _ in range(20):
x = _generate2d()
w = 20*np.random.rand()
solutions = [tv1_2d(x, w, method=method, max_iters=5000)
for method in methods]
for i in range(1, len(solutions)):
print(methods[i], ":", solutions[i])
assert np.allclose(solutions[i], solutions[0], atol=1e-3)
def test_tv1w_2d_uniform_weights():
for _ in range(20):
rows = np.random.randint(1e1, 3e1)
cols = np.random.randint(1e1, 3e1)
x = 100 * np.random.randn(rows, cols)
w1 = np.random.rand()
w_rows = np.ones([rows - 1, cols]) * w1
w_cols = np.ones([rows, cols - 1]) * w1
solw = tv1w_2d(x, w_rows, w_cols, max_iters=5000)
solw1 = tv1_2d(x, w1, max_iters=5000)
assert np.allclose(solw, solw1, atol=1e-3)
def test_tv1w_2d_uniform_weights():
for _ in range(20):
rows = np.random.randint(1e1, 3e1)
cols = np.random.randint(1e1, 3e1)
x = 100*np.random.randn(rows, cols)
w1 = np.random.rand()
w_rows = np.ones([rows-1, cols]) * w1
w_cols = np.ones([rows, cols-1]) * w1
solw = tv1w_2d(x, w_rows, w_cols, max_iters=5000)
solw1 = tv1_2d(x, w1, max_iters=5000)
assert np.allclose(solw, solw1, atol=1e-3)
def denoiseManual(inputFile, lamb):
start = time.time()
F = ptv.tv1_2d(inputFile, lamb, 1, 2)
end = time.time()
print('Time to denoise ' + str(end - start))
return F
def test_tvgen_multireg():
"""Test applying several regularizers on same dimension"""
for _ in range(20):
x = _generate2D()
w = 20 * np.random.rand()
specific = tv1_2d(x, w, max_iters=1000)
general = tvgen(x, [w / 2., w / 2., w / 3., w / 3., w / 3.],
[1, 1, 2, 2, 2], [1, 1, 1, 1, 1],
max_iters=1000)
print("Max diff: " + str((specific - general).max()))
assert np.allclose(specific, general, atol=1e-2)
def test_tv1w_2d_uniform_weights():
for _ in range(20):
x = _generate2D()
rows = len(x)
cols = len(x[0])
w1 = np.random.rand()
w_rows = np.ones([rows - 1, cols]) * w1
w_cols = np.ones([rows, cols - 1]) * w1
solw = tv1w_2d(x, w_rows, w_cols, max_iters=5000)
solw1 = tv1_2d(x, w1, max_iters=5000)
assert np.allclose(solw, solw1, atol=1e-3)
def denoise(inputFile):
print("Starting denoising")
start = time.time()
F = ptv.tv1_2d(inputFile, args.lamb, 1, 3)
end = time.time()
print('Time to denoise ' + str(end - start))
return F
def test_tv1_tv1w_2d():
"""Tests that 2D-TV1w == 2D-TV1 for unit weights"""
for _ in range(20):
x = _generate2d()
rows = len(x)
cols = len(x[0])
w = 20*np.random.rand()
w_cols = w * np.ones((rows-1, cols))
w_rows = w * np.ones((rows, cols-1))
solution1 = tv1_2d(x, w, max_iters=5000)
solutionp = tv1w_2d(x, w_cols, w_rows, max_iters=5000)
assert np.allclose(solution1, solutionp, atol=1e-3)
def test_tv1w_2d_emengd():
r"""Issue reported by emengd
Make the solver fail due to missing checks on integer arguments
"""
a = -np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) / 10.
sol1 = tv1w_2d(a,
np.array([[1, 1, 1], [1, 1, 1]]),
np.array([[1, 1], [1, 1], [1, 1]]),
max_iters=100)
sol2 = tv1_2d(a, 1)
assert np.allclose(sol1, sol2, atol=1e-3)
def test_tv1_tv1w_2d():
"""Tests that 2D-TV1w == 2D-TV1 for unit weights"""
for _ in range(20):
x = _generate2D()
rows = len(x)
cols = len(x[0])
w = 20 * np.random.rand()
w_cols = w * np.ones((rows - 1, cols))
w_rows = w * np.ones((rows, cols - 1))
solution1 = tv1_2d(x, w, max_iters=5000)
solutionp = tv1w_2d(x, w_cols, w_rows, max_iters=5000)
assert np.allclose(solution1, solutionp, atol=1e-3)
def test_tv1_2d():
"""Tests that all 2D-TV methods produce equivalent results"""
methods = ('yang', 'condat', 'chambolle-pock', 'kolmogorov', 'pd', 'dr')
for _ in range(20):
x = _generate2D()
w = 20 * np.random.rand()
solutions = [
tv1_2d(x, w, method=method, max_iters=5000) for method in methods
]
for i in range(1, len(solutions)):
print(methods[i], ":", solutions[i])
assert np.allclose(solutions[i], solutions[0], atol=1e-3)
def test_tvgen_multireg():
"""Test applying several regularizers on same dimension"""
for _ in range(20):
x = _generate2d()
w = 20*np.random.rand()
specific = tv1_2d(x, w, max_iters=1000)
general = tvgen(
x,
[w/2., w/2., w/3., w/3., w/3.],
[1, 1, 2, 2, 2],
[1, 1, 1, 1, 1],
max_iters=1000
)
print("Max diff: " + str((specific-general).max()))
assert np.allclose(specific, general, atol=1e-2)
def test_tv1_2d():
methods = ('yang', 'condat', 'chambolle-pock')
for _ in range(20):
rows = np.random.randint(1e1, 3e1)
cols = np.random.randint(1e1, 3e1)
x = 100*np.random.randn(rows, cols)
w = 20*np.random.rand()
solutions = [tv1_2d(x, w, method=method, max_iters=5000)
for method in methods]
solutions.append([tvp_2d(x, w, w, 1, 1, max_iters=5000)])
w_cols = w * np.ones((rows-1, cols))
w_rows = w * np.ones((rows, cols-1))
solutions.append(tv1w_2d(x, w_cols, w_rows, max_iters=5000))
for i in range(1, len(solutions)):
assert np.allclose(solutions[i], solutions[0], atol=1e-3)
def test_tv1_2d():
methods = ('yang', 'condat', 'chambolle-pock')
for _ in range(20):
rows = np.random.randint(1e1, 3e1)
cols = np.random.randint(1e1, 3e1)
x = 100 * np.random.randn(rows, cols)
w = 20 * np.random.rand()
solutions = [
tv1_2d(x, w, method=method, max_iters=5000) for method in methods
]
solutions.append([tvp_2d(x, w, w, 1, 1, max_iters=5000)])
w_cols = w * np.ones((rows - 1, cols))
w_rows = w * np.ones((rows, cols - 1))
solutions.append(tv1w_2d(x, w_cols, w_rows, max_iters=5000))
for i in range(1, len(solutions)):
assert np.allclose(solutions[i], solutions[0], atol=1e-3)
def demo():
# Load image
here = os.path.dirname(os.path.abspath(__file__))
X = io.imread(here + '/small.png')
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Filter using 2D TV-L1
lam = 0.005
print('Filtering image with 2D TV-L1...')
start = time.time()
F = ptv.tv1_2d(X, lam, 1, 3)
end = time.time()
print('Elapsed time ' + str(end - start))
io.imshow(X)
plt.show()
io.imshow(F)
plt.show()
def ist_reconstruction(Y,
x_init,
lamda=0.01,
step=0.01,
n_iter=100,
verbose=1,
lamda_rate=1.):
""" Iterative Shrinkage and Thresholding Based reconstruction from sparse views CT.
Inputs:
`Y` : Measured sparse views data
`lamda` : Regularization parameter
`n_iter`: Number of iterations
`x_init`: Initialization
`step` : step size for gradient update
`verbose`:
`lamda_rate`: Reduce the value of `lamda` by this amount per iteration.
"""
# assert X.measurement != None, 'Please specify the low view measurement'
x = x_init.copy()
theta = np.linspace(0., 179., Y.shape[1])
for i in range(n_iter):
z = Y - radon(x, theta, circle=False)
grad = -iradon(z, theta, circle=False, filter=None)
x = prox_tv.tv1_2d(x - step * grad, lamda)
lamda = lamda * lamda_rate
if verbose == 1 and i % 10 == 0:
print('Loss = ', la.norm(z))
x_est = x
return x_est
def tv_denoise(noisy_im, sigma):
if sigma == 2:
weight = 0.38828571428571435
elif sigma == 5:
weight = 1.7
elif sigma == 10:
weight = 4.228571428571429
elif sigma == 20:
weight = 10.857142857142858
elif sigma == 30:
weight = 19.142857142857142
elif sigma == 40:
weight = 24.857142857142858
elif sigma == 60:
weight = 38.857142857142854
elif sigma == 80:
weight = 48.857142857142854
elif sigma == 100:
weight = 56.0
else:
print('false')
im_est = ptv.tv1_2d(noisy_im, w=weight)
return im_est
# Load image
X = io.imread('QRbig.png')
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Introduce noise
noiseLevel = 0.2
N = util.random_noise(X, mode='gaussian', var=noiseLevel)
# Iterate over number of threads
lam=50./255.
times = []
for threads in THREADS:
print('Filtering image with ' + str(threads) + ' threads...');
start = time.time()
F = ptv.tv1_2d(N, lam, n_threads=threads)
end = time.time()
times.append(end-start)
print('Elapsed time ' + str(end-start))
# Plot filtering results
plt.subplot(1, 3, 1)
io.imshow(X)
plt.xlabel('Original')
plt.subplot(1, 3, 2)
io.imshow(N)
plt.title('2D TVL1 filtering')
plt.xlabel('Noisy')
plt.subplot(1, 3, 3)
import os
import cv2
import math
import prox_tv as ptv
from utils import add_gaussian_noise
here = os.path.dirname(os.path.abspath(__file__))
im = cv2.imread(here + '/colors.png', cv2.IMREAD_GRAYSCALE)
sigma = 30
noisy_im = add_gaussian_noise(im, sigma)
im_h, im_w = noisy_im.shape
lam = (sigma / 255) * math.sqrt(math.log(im_h * im_w))
print(lam)
res_im = ptv.tv1_2d(noisy_im, lam)
cv2.imwrite('res_im.png', res_im)
action='store_true',
help='Show plot')
args = parser.parse_args(sys.argv[1:])
input = args.input
lam = args.lam
output = args.output
show_flag = args.show
# Load image
X = io.imread(input)
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Filter using 2D TV-L1
print('Filtering image with 2D TV-L1... lambda:', str(lam))
start = time.time()
F = ptv.tv1_2d(X, lam)
end = time.time()
print('Elapsed time ' + str(end - start))
if show_flag:
# Plot results
plt.subplot(1, 2, 1)
io.imshow(X)
plt.xlabel('Original')
plt.subplot(1, 2, 2)
io.imshow(F)
plt.xlabel('Filtered')
plt.show()
from skimage import data, io, filters, color, util
# Load image
X = io.imread('colors.png')
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Introduce noise
noiseLevel = 0.01
N = util.random_noise(X, mode='speckle', var=noiseLevel)
# Filter using 2D TV-L1
lam=0.15;
print('Filtering image with 2D TV-L1...')
start = time.time()
F = ptv.tv1_2d(N, lam)
end = time.time()
print('Elapsed time ' + str(end-start))
# Plot results
plt.subplot(1, 3, 1)
io.imshow(X)
plt.xlabel('Original')
plt.subplot(1, 3, 2)
io.imshow(N)
plt.title('2D TVL1 filtering')
plt.xlabel('Noisy')
plt.subplot(1, 3, 3)
io.imshow(F)
from skimage import data, io, filters, color, util
# Load image
X = io.imread('colors.png')
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Introduce noise
noiseLevel = 0.01
N = util.random_noise(X, mode='speckle', var=noiseLevel)
# Filter using 2D TV-L1
lam = 0.15
print('Filtering image with 2D TV-L1...')
start = time.time()
F = ptv.tv1_2d(N, lam)
end = time.time()
print('Elapsed time ' + str(end - start))
# Plot results
plt.subplot(1, 3, 1)
io.imshow(X)
plt.xlabel('Original')
plt.subplot(1, 3, 2)
io.imshow(N)
plt.title('2D TVL1 filtering')
plt.xlabel('Noisy')
plt.subplot(1, 3, 3)
io.imshow(F)
def bm3d_2nd_step(sigma, img_noisy, img_basic, nWien, kWien, NWien, pWien,
tauMatch, useSD, tau_2D, lam):
height, width = img_noisy.shape[0], img_noisy.shape[1]
row_ind = ind_initialize(height - kWien + 1, nWien, pWien)
column_ind = ind_initialize(width - kWien + 1, nWien, pWien)
kaiserWindow = get_kaiserWindow(kWien)
ri_rj_N__ni_nj, threshold_count = precompute_BM(img_basic,
kHW=kWien,
NHW=NWien,
nHW=nWien,
tauMatch=tauMatch)
group_len = int(np.sum(threshold_count))
group_3D_table = np.zeros((group_len, kWien, kWien))
weight_table = np.ones((height, width))
noisy_patches = image2patches(img_noisy, k=kWien,
p=pWien) # i_j_ipatch_jpatch__v
basic_patches = image2patches(img_basic, k=kWien,
p=pWien) # i_j_ipatch_jpatch__v
if tau_2D == 'DCT':
fre_noisy_patches = dct_2d_forward(noisy_patches)
fre_basic_patches = dct_2d_forward(basic_patches)
elif tau_2D == 'BIOR': # 'BIOR'
fre_noisy_patches = bior_2d_forward(noisy_patches)
fre_basic_patches = bior_2d_forward(basic_patches)
else:
fre_noisy_patches = np.zeros_like(noisy_patches)
for i, patch in enumerate(noisy_patches):
fre_noisy_patches[i] = ptv.tv1_2d(patch, lam)
fre_basic_patches = np.zeros_like(basic_patches)
for i, patch in enumerate(basic_patches):
fre_basic_patches[i] = ptv.tv1_2d(patch, lam)
fre_basic_patches = fre_basic_patches.reshape(
(height - kWien + 1, height - kWien + 1, kWien, kWien))
acc_pointer = 0
for i_r in row_ind:
for j_r in column_ind:
nSx_r = threshold_count[i_r, j_r]
group_3D_est = build_3D_group(fre_basic_patches,
ri_rj_N__ni_nj[i_r, j_r], nSx_r)
group_3D = group_3D_est
group_3D = group_3D.transpose((2, 0, 1))
group_3D_table[acc_pointer:acc_pointer + nSx_r] = group_3D
acc_pointer += nSx_r
if useSD:
weight = sd_weighting(group_3D)
weight_table[i_r, j_r] = weight
if tau_2D == 'DCT':
group_3D_table = dct_2d_reverse(group_3D_table)
elif tau_2D == 'BIOR': # 'BIOR'
group_3D_table = bior_2d_reverse(group_3D_table)
else:
pass
# for i in range(1000):
# patch = group_3D_table[i]
# print(i, '----------------------------')
# print(patch)
# cv2.imshow('', patch.astype(np.uint8))
# cv2.waitKey()
group_3D_table *= kaiserWindow
numerator = np.zeros_like(img_noisy, dtype=np.float64)
denominator = np.zeros_like(img_noisy, dtype=np.float64)
acc_pointer = 0
for i_r in row_ind:
for j_r in column_ind:
if i_r == 264 and j_r == 264:
print()
nSx_r = threshold_count[i_r, j_r]
N_ni_nj = ri_rj_N__ni_nj[i_r, j_r]
group_3D = group_3D_table[acc_pointer:acc_pointer + nSx_r]
acc_pointer += nSx_r
weight = weight_table[i_r, j_r]
for n in range(nSx_r):
ni, nj = N_ni_nj[n]
patch = group_3D[n]
numerator[ni:ni + kWien, nj:nj + kWien] += patch * weight
denominator[ni:ni + kWien,
nj:nj + kWien] += kaiserWindow * weight
img_denoised = numerator / denominator
return img_denoised
# Load image
X = io.imread('QRbig.png')
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Introduce noise
noiseLevel = 0.2
N = util.random_noise(X, mode='gaussian', var=noiseLevel)
# Iterate over number of threads
lam = 50. / 255.
times = []
for threads in THREADS:
print('Filtering image with ' + str(threads) + ' threads...')
start = time.time()
F = ptv.tv1_2d(N, lam, n_threads=threads)
end = time.time()
times.append(end - start)
print('Elapsed time ' + str(end - start))
# Plot filtering results
plt.subplot(1, 3, 1)
io.imshow(X)
plt.xlabel('Original')
plt.subplot(1, 3, 2)
io.imshow(N)
plt.title('2D TVL1 filtering')
plt.xlabel('Noisy')
plt.subplot(1, 3, 3)
