def filter_convolve(data, filters, filter_rot=False, method='scipy'):
r"""Filter convolve
This method convolves the input image with the wavelet filters.
Parameters
----------
data : numpy.ndarray
Input data, 2D array
filters : numpy.ndarray
Wavelet filters, 3D array
filter_rot : bool, optional
Option to rotate wavelet filters (default is `False`)
method : {'astropy', 'scipy'}, optional
Convolution method (default is 'scipy')
Returns
-------
numpy.ndarray
Convolved data
Examples
--------
>>> from modopt.signal.wavelet import filter_convolve
>>> x = np.arange(9).reshape(3, 3).astype(float)
>>> y = np.arange(36).reshape(4, 3, 3).astype(float)
>>> filter_convolve(x, y)
array([[[ 174., 165., 174.],
[ 93., 84., 93.],
[ 174., 165., 174.]],
<BLANKLINE>
[[ 498., 489., 498.],
[ 417., 408., 417.],
[ 498., 489., 498.]],
<BLANKLINE>
[[ 822., 813., 822.],
[ 741., 732., 741.],
[ 822., 813., 822.]],
<BLANKLINE>
[[ 1146., 1137., 1146.],
[ 1065., 1056., 1065.],
[ 1146., 1137., 1146.]]])
>>> filter_convolve(y, y, filter_rot=True)
array([[ 14550., 14586., 14550.],
[ 14874., 14910., 14874.],
[ 14550., 14586., 14550.]])
"""
if filter_rot:
return np.sum([
convolve(coef, f, method=method)
for coef, f in zip(data, rotate_stack(filters))
],
axis=0)
else:
return np.array([convolve(data, f, method=method) for f in filters])
def test_convolve_astropy(self):
"""Test convolve using astropy."""
npt.assert_allclose(
convolve.convolve(self.data1[0], self.data2[0], method='astropy'),
np.array([
[210.0, 201.0, 210.0],
[129.0, 120.0, 129.0],
[210.0, 201.0, 210.0],
]),
err_msg='Incorrect convolution: astropy',
)
npt.assert_raises(
ValueError,
convolve.convolve,
self.data1[0],
self.data2,
)
npt.assert_raises(
ValueError,
convolve.convolve,
self.data1[0],
self.data2[0],
method='bla',
)
def find_n_pc(u_vec, factor=0.5):
"""Find number of principal components.
This method finds the minimum number of principal components required.
Parameters
----------
u_vec : numpy.ndarray
Left singular vector of the original data
factor : float, optional
Factor for testing the auto correlation (default is ``0.5``)
Returns
-------
int
Number of principal components
Raises
------
ValueError
Invalid left singular vector
Examples
--------
>>> import numpy as np
>>> from scipy.linalg import svd
>>> from modopt.signal.svd import find_n_pc
>>> x = np.arange(18).reshape(9, 2).astype(float)
>>> find_n_pc(svd(x)[0])
1
"""
if np.sqrt(u_vec.shape[0]) % 1:
raise ValueError(
'Invalid left singular vector. The size of the first '
+ 'dimenion of ``u_vec`` must be perfect square.',
)
# Get the shape of the array
array_shape = np.repeat(np.int(np.sqrt(u_vec.shape[0])), 2)
# Find the auto correlation of the left singular vector.
u_auto = [
convolve(
elem.reshape(array_shape),
np.rot90(elem.reshape(array_shape), 2),
)
for elem in u_vec.T
]
# Return the required number of principal components.
return np.sum([
(
u_val[tuple(zip(array_shape // 2))] ** 2 <= factor
* np.sum(u_val ** 2),
)
for u_val in u_auto
])
def test_convolve_scipy(self):
"""Test convolve using scipy."""
npt.assert_allclose(
convolve.convolve(self.data1[0], self.data2[0], method='scipy'),
np.array([
[14.0, 35.0, 38.0],
[57.0, 120.0, 111.0],
[110.0, 197.0, 158.0],
]),
err_msg='Incorrect convolution: scipy',
)
def psf_convolve(data, psf, psf_rot=False, psf_type='fixed', method='scipy'):
"""Convolve data with PSF
This method convolves an image with a PSF
Parameters
----------
data : np.ndarray
Input data array, normally an array of 2D images
psf : np.ndarray
Input PSF array, normally either a single 2D PSF or an array of 2D
PSFs
psf_rot: bool
Option to rotate PSF by 180 degrees
psf_type : str {'fixed', 'obj_var'}, optional
PSF type (default is 'fixed')
method : str {'astropy', 'scipy'}, optional
Convolution method (default is 'astropy')
'fixed':
The PSF is fixed, i.e. it is the same for each image
'obj_var':
The PSF is object variant, i.e. it is different for each image
Returns
-------
np.ndarray convolved data
Raises
------
ValueError
If `psf_type` is not 'fixed' or 'obj_var'
"""
if psf_type not in ('fixed', 'obj_var'):
raise ValueError('Invalid PSF type. Options are "fixed" or "obj_var"')
if psf_rot and psf_type == 'fixed':
psf = rotate(psf)
elif psf_rot:
psf = rotate_stack(psf)
if psf_type == 'fixed':
return np.array([convolve(data_i, psf, method=method) for data_i in
data])
elif psf_type == 'obj_var':
return convolve_stack(data, psf, method=method)
def psf_convolve(data, psf, psf_rot=False, psf_type='fixed', method='scipy'):
"""Convolve data with PSF
This method convolves an image with a PSF
Parameters
----------
data : np.ndarray
Input data array, normally an array of 2D images
psf : np.ndarray
Input PSF array, normally either a single 2D PSF or an array of 2D
PSFs
psf_rot: bool
Option to rotate PSF by 180 degrees
psf_type : str {'fixed', 'obj_var'}, optional
PSF type (default is 'fixed')
method : str {'astropy', 'scipy'}, optional
Convolution method (default is 'astropy')
'fixed':
The PSF is fixed, i.e. it is the same for each image
'obj_var':
The PSF is object variant, i.e. it is different for each image
Returns
-------
np.ndarray convolved data
Raises
------
ValueError
If `psf_type` is not 'fixed' or 'obj_var'
"""
if psf_type not in ('fixed', 'obj_var'):
raise ValueError('Invalid PSF type. Options are "fixed" or "obj_var"')
if psf_rot and psf_type == 'fixed':
psf = rotate(psf)
elif psf_rot:
psf = rotate_stack(psf)
if psf_type == 'fixed':
return np.array(
[convolve(data_i, psf, method=method) for data_i in data])
elif psf_type == 'obj_var':
return convolve_stack(data, psf, method=method)
def psf_convolve(data, psf, psf_rot=False):
"""PSF Convolution.
Parameters
----------
data : np.ndarray
Input data, 2D image
psf : np.ndarray
Input PSF, 2D image
psf_rot : bool, optional
Option to rotate the input PSF (default is False)
Returns
-------
np.ndarray convolved image
"""
if psf_rot:
psf = rotate(psf)
return convolve(data, psf)
def find_n_pc(u, factor=0.5):
"""Find number of principal components
This method finds the minimum number of principal components required
Parameters
----------
u : np.ndarray
Left singular vector of the original data
factor : float, optional
Factor for testing the auto correlation (default is '0.5')
Returns
-------
int number of principal components
Examples
--------
>>> from scipy.linalg import svd
>>> from modopt.signal.svd import find_n_pc
>>> x = np.arange(18).reshape(9, 2).astype(float)
>>> find_n_pc(svd(x)[0])
array([3])
"""
if np.sqrt(u.shape[0]) % 1:
raise ValueError('Invalid left singular value. The size of the first '
'dimenion of u must be perfect square.')
# Get the shape of the array
array_shape = np.repeat(np.int(np.sqrt(u.shape[0])), 2)
# Find the auto correlation of the left singular vector.
u_auto = [convolve(a.reshape(array_shape),
np.rot90(a.reshape(array_shape), 2)) for a in u.T]
# Return the required number of principal components.
return np.sum((a[list(zip(array_shape // 2))] ** 2 <= factor *
np.sum(a ** 2)) for a in u_auto)[0]
"""
import numpy as np
from pysap import Image
from pysap.data import get_sample_data
from pysap.plugins.astro.deconvolve.deconvolve import sparse_deconv_condatvu
from modopt.signal.noise import add_noise
from modopt.math.convolve import convolve
# Load the example images
galaxy = get_sample_data('astro-galaxy')
psf = get_sample_data('astro-psf')
# Show the clean galaxy image
galaxy.show()
# Generate a noisy observed image
obs_data = add_noise(convolve(galaxy.data, psf.data), sigma=0.0005)
image_obs = Image(data=np.abs(obs_data))
image_obs.show()
# Deconvolve the observed image
deconv_data = sparse_deconv_condatvu(obs_data, psf.data, n_iter=3000)
image_rec = Image(data=np.abs(deconv_data))
image_rec.show()
# Show the residual
residual = Image(data=np.abs(galaxy.data - deconv_data))
residual.show()
