def setUp(self):
self.input_file = 'input_image.fits'
self.mask_file = 'rolloff_defects_mask.fits'
self.image_file = 'my_temp_mask_image.fits'
self.outer_edge_width = 10
self.bloom_stop_width = 5
self.signal = 10
self.amp_geoms \
= (AmplifierGeometry(amp_loc=amp_loc['E2V']),
AmplifierGeometry(prescan=3, nx=509, ny=2000,
amp_loc=amp_loc['ITL'], vendor='ITL'))
def setUpClass(cls):
cls.amp_geom = AmplifierGeometry()
cls.bias_image = afwImage.ImageF(cls.amp_geom.full_segment)
imarr = cls.bias_image.getArray()
ny, nx = imarr.shape
yvals = np.arange(0, ny, dtype=np.float)
bias_func = BiasFunc(cls.bias_slope, cls.bias_intercept)
for x in range(nx):
imarr[:, x] += bias_func(yvals)
ccd = sim_tools.CCD(exptime=cls.exptime,
gain=cls.gain,
geometry=cls.amp_geom)
for amp in ccd.segments:
ccd.segments[amp].image += cls.bias_image
ccd.writeto(cls.image_file)
cls.mean_bias_image = afwImage.ImageF(cls.amp_geom.full_segment)
imarr = cls.mean_bias_image.getArray()
ny, nx = imarr.shape
mu, sig = 27316.92, 6.53
for x in range(nx):
imarr[:, x] += np.random.normal(mu, sig, ny)
ccd = sim_tools.CCD(exptime=cls.exptime,
gain=cls.gain,
geometry=cls.amp_geom)
for amp in ccd.segments:
ccd.segments[amp].image += cls.mean_bias_image
ccd.writeto(cls.mean_image_file)
def setUp(self):
self.e2v = AmplifierGeometry(prescan=10,
nx=512,
ny=2002,
detxsize=4336,
detysize=4044,
amp_loc=amp_loc['E2V'])
self.e2v_test_file = 'test_e2v_image.fits'
ccd0 = sim_tools.CCD(geometry=self.e2v)
ccd0.writeto(self.e2v_test_file, bitpix=16)
self.itl = AmplifierGeometry(prescan=3,
nx=509,
ny=2000,
amp_loc=amp_loc['ITL'])
self.itl_test_file = 'test_itl_image.fits'
ccd1 = sim_tools.CCD(geometry=self.itl)
ccd1.writeto(self.itl_test_file, bitpix=16)
def setUp(self):
self.input_file = 'input_image.fits'
self.mask_file = 'rolloff_defects_mask.fits'
self.image_file = 'my_temp_mask_image.fits'
self.outer_edge_width = 10
self.bloom_stop_width = 5
self.signal = 10
ccd = sim_tools.CCD(geometry=AmplifierGeometry(amp_loc=amp_loc['E2V']))
ccd.writeto(self.input_file, bitpix=16)
class SegmentExposureTestCase(unittest.TestCase):
amp_geom = AmplifierGeometry()
bias_method = 'row'
def setUp(self):
self.seg = sim_tools.SegmentExposure(exptime=100, gain=1, ccdtemp=-100,
geometry=self.amp_geom)
self.intensity = 100
self.full_well = 1.5e5
def tearDown(self):
pass
def test_expose_flat(self):
times = np.arange(0, 1000, self.seg.exptime)
for i, time in enumerate(times):
image = imutils.unbias_and_trim(im=self.seg.image,
overscan=self.amp_geom.serial_overscan,
bias_method=self.bias_method,
imaging=self.amp_geom.imaging)
image_mean = imutils.mean(image)
illum = i*self.intensity*self.seg.exptime/self.seg.gain
if i != 0:
self.assertTrue((illum - image_mean)/illum < 3e-4)
self.seg.expose_flat(intensity=self.intensity)
def test_full_well(self):
self.seg.full_well = self.full_well
times = np.arange(0, 2000, self.seg.exptime)
for i, time in enumerate(times):
image = imutils.unbias_and_trim(im=self.seg.image,
overscan=self.amp_geom.serial_overscan,
bias_method=self.bias_method,
imaging=self.amp_geom.imaging)
Ne_mean = imutils.mean(image)*self.seg.gain
self.assertTrue(Ne_mean <= self.full_well)
self.seg.expose_flat(intensity=self.intensity)
class BiasHandlingTestCase(unittest.TestCase):
bias_slope = 1e-3
bias_intercept = 0.5
exptime = 1
gain = 1
kwargs = {
'fit_order': 1,
'k': 3,
's': 8000,
't': None,
'imaging': AmplifierGeometry().imaging
}
image_file = 'test_image.fits'
mean_image_file = 'test_mean_image.fits'
@classmethod
def setUpClass(cls):
cls.amp_geom = AmplifierGeometry()
cls.bias_image = afwImage.ImageF(cls.amp_geom.full_segment)
imarr = cls.bias_image.getArray()
ny, nx = imarr.shape
yvals = np.arange(0, ny, dtype=np.float)
bias_func = BiasFunc(cls.bias_slope, cls.bias_intercept)
for x in range(nx):
imarr[:, x] += bias_func(yvals)
ccd = sim_tools.CCD(exptime=cls.exptime,
gain=cls.gain,
geometry=cls.amp_geom)
for amp in ccd.segments:
ccd.segments[amp].image += cls.bias_image
ccd.writeto(cls.image_file)
cls.mean_bias_image = afwImage.ImageF(cls.amp_geom.full_segment)
imarr = cls.mean_bias_image.getArray()
ny, nx = imarr.shape
mu, sig = 27316.92, 6.53
for x in range(nx):
imarr[:, x] += np.random.normal(mu, sig, ny)
ccd = sim_tools.CCD(exptime=cls.exptime,
gain=cls.gain,
geometry=cls.amp_geom)
for amp in ccd.segments:
ccd.segments[amp].image += cls.mean_bias_image
ccd.writeto(cls.mean_image_file)
@classmethod
def tearDownClass(cls):
os.remove(cls.image_file)
os.remove(cls.mean_image_file)
def test_bias_func(self):
bias_func = BiasFunc(self.bias_slope, self.bias_intercept)
ccd = MaskedCCD(self.image_file)
for amp in ccd:
bf_i = imutils.bias_func(ccd[amp].getImage(),
self.amp_geom.serial_overscan,
**self.kwargs)
bf_m = imutils.bias_func(ccd[amp], self.amp_geom.serial_overscan,
**self.kwargs)
for y in range(2022):
self.assertEqual(bf_i(y), bf_m(y))
self.assertAlmostEqual(bias_func(y), bf_m(y))
# Test that row-by-row median operates.
row_bias = imutils.bias_row(ccd[amp],
self.amp_geom.serial_overscan)
for y in range(2022):
self.assertAlmostEqual(bf_i(y), row_bias(y), places=5)
def test_bias_image(self):
ccd = MaskedCCD(self.image_file)
overscan = makeAmplifierGeometry(self.image_file)
ccd_mean = MaskedCCD(self.mean_image_file)
overscan_mean = makeAmplifierGeometry(self.mean_image_file)
for amp in ccd:
for method in ['mean', 'row', 'func', 'spline']:
if method == 'mean':
my_bias_image = imutils.bias_image(
ccd_mean[amp],
overscan_mean.serial_overscan,
bias_method=method,
**self.kwargs)
fracdiff = ((self.mean_bias_image.getArray() -
my_bias_image.getArray()) /
self.mean_bias_image.getArray())
self.assertTrue(max(np.abs(fracdiff.flat)) < 1.5e-3)
else:
my_bias_image = imutils.bias_image(
ccd[amp],
overscan.serial_overscan,
bias_method=method,
**self.kwargs)
fracdiff = ((self.bias_image.getArray() -
my_bias_image.getArray()) /
self.bias_image.getArray())
self.assertTrue(max(np.abs(fracdiff.flat)) < 1e-6)
my_bias_image = imutils.bias_image(ccd[amp],
self.amp_geom.serial_overscan)
fracdiff = (
(self.bias_image.getArray() - my_bias_image.getArray()) /
self.bias_image.getArray())
self.assertTrue(max(np.abs(fracdiff.flat)) < 1e-6)
def test_unbias_and_trim(self):
ccd = MaskedCCD(self.image_file)
overscan = makeAmplifierGeometry(self.image_file)
for amp in ccd:
for method in ['mean', 'row', 'func', 'spline']:
image = imutils.unbias_and_trim(ccd[amp],
overscan.serial_overscan,
bias_method=method,
**self.kwargs)
imarr = image.getImage().getArray()
if method == 'mean':
self.assertTrue(max(np.abs(imarr.flat)) < 2)
else:
self.assertTrue(max(np.abs(imarr.flat)) < 1e-6)
#
# Test of corresponding MaskedCCD method.
#
image = ccd.unbiased_and_trimmed_image(
amp, overscan.serial_overscan, **self.kwargs)
imarr = image.getImage().getArray()
self.assertTrue(max(np.abs(imarr.flat)) < 1e-6)
def test_bias_row(self):
ccd = MaskedCCD(self.image_file)
overscan = makeAmplifierGeometry(self.image_file)
for amp in ccd:
# Unmasked image
br_i = imutils.bias_row(ccd[amp].getImage(),
overscan.serial_overscan)
# Masked image
br_m = imutils.bias_row(ccd[amp], overscan.serial_overscan)
for ii in range(2022):
self.assertEqual(br_i(ii), br_m(ii))
def test_bias_spline(self):
ccd = MaskedCCD(self.image_file)
overscan = makeAmplifierGeometry(self.image_file)
for amp in ccd:
# Unmasked image
bs_i = imutils.bias_spline(ccd[amp].getImage(),
overscan.serial_overscan)
# Masked image
bs_m = imutils.bias_spline(ccd[amp], overscan.serial_overscan)
ny = len(bs_i)
for ii in range(ny):
self.assertEqual(interpolate.splev(ii, bs_i),
interpolate.splev(ii, bs_m))
def test_stack(self):
ccd = MaskedCCD(self.image_file)
overscan = makeAmplifierGeometry(self.image_file)
for method in ['mean', 'row', 'func']:
corrected = []
for image in ccd.values():
corrected.append(
imutils.unbias_and_trim(image,
overscan.serial_overscan,
bias_method=method,
**self.kwargs).getImage())
stacked = imutils.stack(corrected)
imarr = stacked.getArray()
if method == 'mean':
self.assertTrue(max(np.abs(imarr.flat)) < 2)
else:
self.assertTrue(max(np.abs(imarr.flat)) < 1e-6)