def main_alignImages():
path1 = '/Users/giuliacarla/Documents/INAF/Lavoro/Progetti/ARGOS/20161019/images_reduced/trimmed/NGC2419_K_dither_%d_trim.pkl'
path2 = ' /Users/giuliacarla/Documents/INAF/Lavoro/Progetti/ARGOS/20161019/coordinates_for_alignment/trimmed/coords_NGC2419_K_dither%d.pkl'
path3 = '/Users/giuliacarla/Documents/INAF/Lavoro/Progetti/ARGOS/20161019/images_alignment/trimmed/NGC2419_K_dither%d_on_1.pkl) '
n_init = 1
n_fin = 13
imas = [path1 % idx for idx in np.arange(n_init, n_fin + 1)]
n_imas = len(imas)
c_list = []
for i in range(n_imas):
se = select_stars.StarsSelector(imas[i])
se.find_star_centroid(0)
c1 = se.find_star_centroid
se.find_star_centroid(1)
c2 = se.find_star_centroid
se.find_star_centroid(2)
c3 = se.find_star_centroid
coords = [c1, c2, c3]
sandbox.saveObjectListToFile(coords, path2 % (i + 1))
c_list.append(coords)
ima_al_list = []
for i in range(n_imas):
al = image_aligner.ImageAligner(c_list[0], c_list[i + 1])
ima_al = al.applyTransformationOnIma(imas[i + 1])
sandbox.saveObjectListToFile(ima_al, path3 % (i + 1))
ima_al_list.append(ima_al)
ima_comb = Combiner(ima_al_list)
ima_final = ima_comb.average_combine()
def test_combiner_minmax_min():
ccd_list = [CCDData(np.zeros((10, 10)), unit=u.adu),
CCDData(np.zeros((10, 10)) - 1000, unit=u.adu),
CCDData(np.zeros((10, 10)) + 1000, unit=u.adu)]
c = Combiner(ccd_list)
c.minmax_clipping(min_clip=-500, max_clip=None)
assert c.data_arr[1].mask.all()
def test_1Dweights():
ccd_list = [CCDData(np.zeros((10, 10)), unit=u.adu),
CCDData(np.zeros((10, 10)) - 1000, unit=u.adu),
CCDData(np.zeros((10, 10)) + 1000, unit=u.adu)]
c = Combiner(ccd_list)
c.weights = np.array([1, 5, 10])
ccd = c.average_combine()
np.testing.assert_almost_equal(ccd.data, 312.5)
def test_combiner_minmax():
ccd_list = [CCDData(np.zeros((10, 10)), unit=u.adu),
CCDData(np.zeros((10, 10)) - 1000, unit=u.adu),
CCDData(np.zeros((10, 10)) + 1000, unit=u.adu)]
c = Combiner(ccd_list)
c.minmax_clipping(min_clip=-500, max_clip=500)
ccd = c.median_combine()
assert ccd.data.mean() == 0
def test_combiner_sum():
ccd_data = ccd_data_func()
ccd_list = [ccd_data, ccd_data, ccd_data]
c = Combiner(ccd_list)
ccd = c.sum_combine()
assert isinstance(ccd, CCDData)
assert ccd.shape == (100, 100)
assert ccd.unit == u.adu
assert ccd.meta['NCOMBINE'] == len(ccd_list)
def test_combine_average_ccddata():
fitsfile = get_pkg_data_filename('data/a8280271.fits')
ccd = CCDData.read(fitsfile, unit=u.adu)
ccd_list = [ccd] * 3
c = Combiner(ccd_list)
ccd_by_combiner = c.average_combine()
avgccd = combine(ccd_list, output_file=None, method='average', unit=u.adu)
# averaging same ccdData should give back same images
np.testing.assert_array_almost_equal(avgccd.data, ccd_by_combiner.data)
def test_combiner_uncertainty_average():
ccd_list = [CCDData(np.ones((10, 10)), unit=u.adu),
CCDData(np.ones((10, 10)) * 2, unit=u.adu)]
c = Combiner(ccd_list)
ccd = c.average_combine()
# Just the standard deviation of ccd data.
ref_uncertainty = np.ones((10, 10)) / 2
# Correction because we combined two images.
ref_uncertainty /= np.sqrt(2)
np.testing.assert_array_almost_equal(ccd.uncertainty.array,
ref_uncertainty)
def test_combiner_mask_sum():
data = np.zeros((10, 10))
data[5, 5] = 1
mask = (data == 0)
ccd = CCDData(data, unit=u.adu, mask=mask)
ccd_list = [ccd, ccd, ccd]
c = Combiner(ccd_list)
ccd = c.sum_combine()
assert ccd.data[0, 0] == 0
assert ccd.data[5, 5] == 3
assert ccd.mask[0, 0]
assert not ccd.mask[5, 5]
def test_clip_extrema_3d():
ccdlist = [CCDData(np.ones((3, 3, 3)) * 90., unit="adu"),
CCDData(np.ones((3, 3, 3)) * 20., unit="adu"),
CCDData(np.ones((3, 3, 3)) * 10., unit="adu"),
CCDData(np.ones((3, 3, 3)) * 40., unit="adu"),
CCDData(np.ones((3, 3, 3)) * 25., unit="adu"),
CCDData(np.ones((3, 3, 3)) * 35., unit="adu"),
]
c = Combiner(ccdlist)
c.clip_extrema(nlow=1, nhigh=1)
result = c.average_combine()
expected = CCDData(np.ones((3, 3, 3)) * 30, unit="adu")
np.testing.assert_array_equal(result, expected)
def test_sum_combine_uncertainty():
ccd_data = ccd_data_func()
ccd_list = [ccd_data, ccd_data, ccd_data]
c = Combiner(ccd_list)
ccd = c.sum_combine(uncertainty_func=np.sum)
uncert_ref = np.sum(c.data_arr, 0) * np.sqrt(3)
np.testing.assert_almost_equal(ccd.uncertainty.array, uncert_ref)
# Compare this also to the "combine" call
ccd2 = combine(ccd_list, method='sum', combine_uncertainty_function=np.sum)
np.testing.assert_array_equal(ccd.data, ccd2.data)
np.testing.assert_array_equal(
ccd.uncertainty.array, ccd2.uncertainty.array)
def test_combiner_sigmaclip_low():
ccd_list = [CCDData(np.zeros((10, 10)), unit=u.adu),
CCDData(np.zeros((10, 10)) - 10, unit=u.adu),
CCDData(np.zeros((10, 10)) + 10, unit=u.adu),
CCDData(np.zeros((10, 10)) - 10, unit=u.adu),
CCDData(np.zeros((10, 10)) + 10, unit=u.adu),
CCDData(np.zeros((10, 10)) - 1000, unit=u.adu)]
c = Combiner(ccd_list)
# using mad for more robust statistics vs. std
c.sigma_clipping(high_thresh=None, low_thresh=3, func=np.ma.median,
dev_func=mad)
assert c.data_arr[5].mask.all()
def test_combiner_dtype():
ccd_data = ccd_data_func()
ccd_list = [ccd_data, ccd_data, ccd_data]
c = Combiner(ccd_list, dtype=np.float32)
assert c.data_arr.dtype == np.float32
avg = c.average_combine()
# dtype of average should match input dtype
assert avg.dtype == c.dtype
med = c.median_combine()
# dtype of median should match dtype of input
assert med.dtype == c.dtype
result_sum = c.sum_combine()
# dtype of sum should match dtype of input
assert result_sum.dtype == c.dtype
def test_combiner_3d():
data1 = CCDData(3 * np.ones((5, 5, 5)), unit=u.adu)
data2 = CCDData(2 * np.ones((5, 5, 5)), unit=u.adu)
data3 = CCDData(4 * np.ones((5, 5, 5)), unit=u.adu)
ccd_list = [data1, data2, data3]
c = Combiner(ccd_list)
assert c.data_arr.shape == (3, 5, 5, 5)
assert c.data_arr.mask.shape == (3, 5, 5, 5)
ccd = c.average_combine()
assert ccd.shape == (5, 5, 5)
np.testing.assert_array_almost_equal(ccd.data, data1, decimal=4)
def test_combiner_uncertainty_sum_mask():
mask = np.zeros((10, 10), dtype=np.bool_)
mask[5, 5] = True
ccd_with_mask = CCDData(np.ones((10, 10)), unit=u.adu, mask=mask)
ccd_list = [ccd_with_mask,
CCDData(np.ones((10, 10)) * 2, unit=u.adu),
CCDData(np.ones((10, 10)) * 3, unit=u.adu)]
c = Combiner(ccd_list)
ccd = c.sum_combine()
# Just the standard deviation of ccd data.
ref_uncertainty = np.ones((10, 10)) * np.std([1, 2, 3])
ref_uncertainty *= np.sqrt(3)
ref_uncertainty[5, 5] = np.std([2, 3]) * np.sqrt(2)
np.testing.assert_array_almost_equal(ccd.uncertainty.array,
ref_uncertainty)
def test_combine_limitedmem_scale_fitsimages():
fitsfile = get_pkg_data_filename('data/a8280271.fits')
ccd = CCDData.read(fitsfile, unit=u.adu)
ccd_list = [ccd] * 5
c = Combiner(ccd_list)
# scale each array to the mean of the first image
scale_by_mean = lambda x: ccd.data.mean() / np.ma.average(x)
c.scaling = scale_by_mean
ccd_by_combiner = c.average_combine()
fitsfilename_list = [fitsfile] * 5
avgccd = combine(fitsfilename_list, output_file=None, method='average',
mem_limit=1e6, scale=scale_by_mean, unit=u.adu)
np.testing.assert_array_almost_equal(
avgccd.data, ccd_by_combiner.data, decimal=4)
def test_writeable_after_combine(tmpdir, comb_func):
ccd_data = ccd_data_func()
tmp_file = tmpdir.join('tmp.fits')
from ..combiner import Combiner
combined = Combiner([ccd_data for _ in range(3)])
ccd2 = getattr(combined, comb_func)()
# This should not fail because the resulting uncertainty has a mask
ccd2.write(tmp_file.strpath)
def test_combine_numpyndarray():
""" Test of numpy ndarray implementation: #493
Test the average combine using ``Combiner`` and ``combine`` with input
``img_list`` in the format of ``numpy.ndarray``.
"""
fitsfile = get_pkg_data_filename('data/a8280271.fits')
ccd = CCDData.read(fitsfile, unit=u.adu)
ccd_list = [ccd] * 3
c = Combiner(ccd_list)
ccd_by_combiner = c.average_combine()
fitsfilename_list = np.array([fitsfile] * 3)
avgccd = combine(fitsfilename_list, output_file=None,
method='average', unit=u.adu)
# averaging same fits images should give back same fits image
np.testing.assert_array_almost_equal(avgccd.data, ccd_by_combiner.data)
def test_3d_combiner_with_scaling():
ccd_data = ccd_data_func()
# The factors below are not particularly important; just avoid anything
# whose average is 1.
ccd_data = CCDData(np.ones((5, 5, 5)), unit=u.adu)
ccd_data_lower = CCDData(3 * np.ones((5, 5, 5)), unit=u.adu)
ccd_data_higher = CCDData(0.9 * np.ones((5, 5, 5)), unit=u.adu)
combiner = Combiner([ccd_data, ccd_data_higher, ccd_data_lower])
# scale each array to the mean of the first image
scale_by_mean = lambda x: ccd_data.data.mean() / np.ma.average(x)
combiner.scaling = scale_by_mean
avg_ccd = combiner.average_combine()
# Does the mean of the scaled arrays match the value to which it was
# scaled?
np.testing.assert_almost_equal(avg_ccd.data.mean(),
ccd_data.data.mean())
assert avg_ccd.shape == ccd_data.shape
median_ccd = combiner.median_combine()
# Does median also scale to the correct value?
np.testing.assert_almost_equal(np.median(median_ccd.data),
np.median(ccd_data.data))
# Set the scaling manually...
combiner.scaling = [scale_by_mean(combiner.data_arr[i]) for i in range(3)]
avg_ccd = combiner.average_combine()
np.testing.assert_almost_equal(avg_ccd.data.mean(),
ccd_data.data.mean())
assert avg_ccd.shape == ccd_data.shape
def test_combiner_gen():
ccd_data = ccd_data_func()
def create_gen():
yield ccd_data
yield ccd_data
yield ccd_data
c = Combiner(create_gen())
assert c.data_arr.shape == (3, 100, 100)
assert c.data_arr.mask.shape == (3, 100, 100)
def test_clip_extrema():
ccdlist = [CCDData(np.ones((3, 5)) * 90., unit="adu"),
CCDData(np.ones((3, 5)) * 20., unit="adu"),
CCDData(np.ones((3, 5)) * 10., unit="adu"),
CCDData(np.ones((3, 5)) * 40., unit="adu"),
CCDData(np.ones((3, 5)) * 25., unit="adu"),
CCDData(np.ones((3, 5)) * 35., unit="adu"),
]
ccdlist[0].data[0, 1] = 3.1
ccdlist[1].data[1, 2] = 100.1
ccdlist[1].data[2, 0] = 100.1
c = Combiner(ccdlist)
c.clip_extrema(nlow=1, nhigh=1)
result = c.average_combine()
expected = [[30.0, 22.5, 30.0, 30.0, 30.0],
[30.0, 30.0, 47.5, 30.0, 30.0],
[47.5, 30.0, 30.0, 30.0, 30.0]]
np.testing.assert_array_equal(result, expected)
def test_combiner_uncertainty_median_mask():
mad_to_sigma = 1.482602218505602
mask = np.zeros((10, 10), dtype=np.bool_)
mask[5, 5] = True
ccd_with_mask = CCDData(np.ones((10, 10)), unit=u.adu, mask=mask)
ccd_list = [ccd_with_mask,
CCDData(np.ones((10, 10)) * 2, unit=u.adu),
CCDData(np.ones((10, 10)) * 3, unit=u.adu)]
c = Combiner(ccd_list)
ccd = c.median_combine()
# Just the standard deviation of ccd data.
ref_uncertainty = np.ones((10, 10)) * mad_to_sigma * mad([1, 2, 3])
# Correction because we combined two images.
ref_uncertainty /= np.sqrt(3) # 0.855980789955
ref_uncertainty[5, 5] = mad_to_sigma * \
mad([2, 3]) / np.sqrt(2) # 0.524179041254
np.testing.assert_array_almost_equal(ccd.uncertainty.array,
ref_uncertainty)
def test_combiner_mask():
data = np.zeros((10, 10))
data[5, 5] = 1
mask = (data == 0)
ccd = CCDData(data, unit=u.adu, mask=mask)
ccd_list = [ccd, ccd, ccd]
c = Combiner(ccd_list)
assert c.data_arr.shape == (3, 10, 10)
assert c.data_arr.mask.shape == (3, 10, 10)
assert not c.data_arr.mask[0, 5, 5]
def test_combiner_sigmaclip_single_pix():
ccd_list = [CCDData(np.zeros((10, 10)), unit=u.adu),
CCDData(np.zeros((10, 10)) - 10, unit=u.adu),
CCDData(np.zeros((10, 10)) + 10, unit=u.adu),
CCDData(np.zeros((10, 10)) - 10, unit=u.adu),
CCDData(np.zeros((10, 10)) + 10, unit=u.adu),
CCDData(np.zeros((10, 10)) - 10, unit=u.adu)]
c = Combiner(ccd_list)
# add a single pixel in another array to check that
# that one gets rejected
c.data_arr[0, 5, 5] = 0
c.data_arr[1, 5, 5] = -5
c.data_arr[2, 5, 5] = 5
c.data_arr[3, 5, 5] = -5
c.data_arr[4, 5, 5] = 25
c.sigma_clipping(high_thresh=3, low_thresh=None, func=np.ma.median,
dev_func=mad)
assert c.data_arr.mask[4, 5, 5]
def test_clip_extrema_with_other_rejection():
ccdlist = [CCDData(np.ones((3, 5)) * 90., unit="adu"),
CCDData(np.ones((3, 5)) * 20., unit="adu"),
CCDData(np.ones((3, 5)) * 10., unit="adu"),
CCDData(np.ones((3, 5)) * 40., unit="adu"),
CCDData(np.ones((3, 5)) * 25., unit="adu"),
CCDData(np.ones((3, 5)) * 35., unit="adu"),
]
ccdlist[0].data[0, 1] = 3.1
ccdlist[1].data[1, 2] = 100.1
ccdlist[1].data[2, 0] = 100.1
c = Combiner(ccdlist)
# Reject ccdlist[1].data[1,2] by other means
c.data_arr.mask[1, 1, 2] = True
# Reject ccdlist[1].data[1,2] by other means
c.data_arr.mask[3, 0, 0] = True
c.clip_extrema(nlow=1, nhigh=1)
result = c.average_combine()
expected = [[80. / 3., 22.5, 30., 30., 30.],
[30., 30., 47.5, 30., 30.],
[47.5, 30., 30., 30., 30.]]
np.testing.assert_array_equal(result, expected)
def test_ccddata_combiner_size():
ccd_data = ccd_data_func()
ccd_large = CCDData(np.zeros((200, 100)), unit=u.adu)
ccd_list = [ccd_data, ccd_data, ccd_large]
with pytest.raises(TypeError):
Combiner(ccd_list) # arrays of different sizes should fail
def test_ccddata_combiner_units():
ccd_data = ccd_data_func()
ccd_large = CCDData(np.zeros((100, 100)), unit=u.second)
ccd_list = [ccd_data, ccd_data, ccd_large]
with pytest.raises(TypeError):
Combiner(ccd_list)
def test_combiner_create():
ccd_data = ccd_data_func()
ccd_list = [ccd_data, ccd_data, ccd_data]
c = Combiner(ccd_list)
assert c.data_arr.shape == (3, 100, 100)
assert c.data_arr.mask.shape == (3, 100, 100)
def test_ccddata_combiner_objects():
ccd_data = ccd_data_func()
ccd_list = [ccd_data, ccd_data, None]
with pytest.raises(TypeError):
Combiner(ccd_list) # different objects should fail
def test_weights():
ccd_data = ccd_data_func()
ccd_list = [ccd_data, ccd_data, ccd_data]
c = Combiner(ccd_list)
with pytest.raises(TypeError):
c.weights = 1
def test_combiner_scaling_fails():
ccd_data = ccd_data_func()
combiner = Combiner([ccd_data, ccd_data.copy()])
# Should fail unless scaling is set to a function or list-like
with pytest.raises(TypeError):
combiner.scaling = 5
