def test_save_a_layer_to_file():
metad = metadata.MetaData()
metad.create_a_new_layer(
'dummy_layer',
[['OHOHOH', 'IHIHIH'], ['S150', 'S10'], ['km/s', 'h/(2pi)']],
[['0', '1'], ['59', '41']])
metad.save_a_layer_to_file('./', 'dummy_metadata.fits', 'dummy_layer')
metad2 = metadata.MetaData()
metad2.load_all_metadata('./', 'dummy_metadata.fits')
assert metad2.dummy_layer[1].keys() == ['OHOHOH', 'IHIHIH']
def test_update_reduction_metadata_headers_summary_with_new_images():
setup = mock.MagicMock()
reduction_metadata = metadata.MetaData()
pipeline_config = stage0.read_the_config_file('../../Config/', log=None)
stage0.update_reduction_metadata_with_config_file(reduction_metadata, pipeline_config, log=None)
inst_config_dictionnary = {'OBSTYPE': {"comment": "tres bon",
"value": "OBJECT",
"format": "S200",
"unit": ""}}
stage0.update_reduction_metadata_with_inst_config_file(reduction_metadata, inst_config_dictionnary, log=None)
reduction_metadata.data_architecture[1] = {'IMAGES_PATH': ['./']}
image_bad_pixel_mask = np.zeros((3, 3))
image_bad_pixel_mask += 89
header = fits.Header(('OBJECT', 'HUNGRY'))
header['OBJECT'] = 'NDG'
image = fits.PrimaryHDU(image_bad_pixel_mask, header=header)
hdulist = fits.HDUList([image])
hdulist.writeto('Leia.fits', overwrite=True)
stage0.update_reduction_metadata_headers_summary_with_new_images(setup,
reduction_metadata,
['Leia.fits'], log=None)
assert reduction_metadata.headers_summary[1]['IMAGES'][0] == 'Leia.fits'
assert reduction_metadata.headers_summary[1]['OBSTYPE'][0] == 'NDG'
os.remove('Leia.fits')
def test_update_reduction_metadata_stamps():
setup = mock.MagicMock()
reduction_metadata = metadata.MetaData()
image = np.zeros((300, 300))
image = fits.PrimaryHDU(image)
stage0.update_reduction_metadata_stamps(setup, reduction_metadata, image,
stamp_size=None, arcseconds_stamp_size=(60, 60),
pixel_scale=0.51, number_of_overlaping_pixels=25,
log=None)
expected_values = np.array([[0., 0., 142., 0., 142.],
[1., 0., 142., 92., 259.],
[2., 0., 142., 300., 376.],
[3., 92., 259., 0., 142.],
[4., 92., 259., 92., 259.],
[5., 92., 259., 300., 376.],
[6., 300., 376., 0., 142.],
[7., 300., 376., 92., 259.],
[8., 300., 376., 300., 376.]])
assert reduction_metadata.stamps[0]['NAME'] == 'stamps'
assert np.allclose(reduction_metadata.stamps[1]['PIXEL_INDEX'].data.astype(float), expected_values[:,0])
assert np.allclose(reduction_metadata.stamps[1]['Y_MIN'].data.astype(float), expected_values[:,1])
assert np.allclose(reduction_metadata.stamps[1]['Y_MAX'].data.astype(float), expected_values[:, 2])
assert np.allclose(reduction_metadata.stamps[1]['X_MIN'].data.astype(float), expected_values[:, 3])
assert np.allclose(reduction_metadata.stamps[1]['X_MAX'].data.astype(float), expected_values[:, 4])
def convert_red_metadata():
"""Function to convert the configuration parameter files and trendlogs
from an (IDL) DanDIA reduction into the metadata structure used by
pyDANDIA."""
config = get_config()
meta = metadata.MetaData()
event_info = read_event_info(config)
meta.set_pars(event_info)
meta.set_reduction_paths(config['red_dir'])
red_config = read_red_config(config)
for key, value in red_config.items():
meta.set_pars(red_config)
meta.inventory = read_data_inventory(config)
meta.imred = read_imred_trendlog(config['imred'])
meta.gimred = read_gimred_trendlog(config['gimred'])
meta.write()
def read_star_catalog(red_dir, log):
"""Function to extract the star catalog from a given reduction of a single
dataset, using the information in that reduction's metadata file.
Inputs:
:param str red_dir: Path to the reduction directory
:param logger log: Script's own logging object
Returns:
:param Table catalog: Catalog of objects from a single reduction
"""
meta_file = os.path.join(red_dir, 'pyDANDIA_metadata.fits')
catalog = None
if os.path.isfile(meta_file):
m = metadata.MetaData()
m.load_a_layer_from_file(red_dir, 'pyDANDIA_metadata.fits',
'star_catalog')
catalog = m.star_catalog[1]
log.info('Read star catalog from metadata for '+\
os.path.basename(red_dir))
return catalog
def test_plot_ref_mag_errors():
"""Function to test the plotting function"""
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'star_catalog')
idx = reduction_metadata.star_catalog[1]['star_index'].data
x = reduction_metadata.star_catalog[1]['x_pixel'].data
y = reduction_metadata.star_catalog[1]['y_pixel'].data
ra = reduction_metadata.star_catalog[1]['RA_J2000'].data
dec = reduction_metadata.star_catalog[1]['DEC_J2000'].data
mag = reduction_metadata.star_catalog[1]['Instr_mag'].data
merr = reduction_metadata.star_catalog[1]['Instr_mag_err'].data
ref_star_catalog = []
for i in range(0, len(idx), 1):
ref_star_catalog.append(
[idx[i], x[i], y[i], ra[i], dec[i], mag[i], merr[i]])
ref_star_catalog = np.array(ref_star_catalog)
photometry.plot_ref_mag_errors(setup, ref_star_catalog)
plot_file = os.path.join(setup.red_dir, 'ref', 'ref_image_phot_errors.png')
assert os.path.isfile(plot_file)
def test_model_sky_background():
"""Function to test the function to model the sky background of an image"""
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
log = logs.start_stage_log(cwd, 'test_psf_selection')
detected_sources_file = path.join(
TEST_DATA, 'lsc1m005-fl15-20170701-0144-e91_cropped_sources.txt')
detected_sources = catalog_utils.read_source_catalog(detected_sources_file)
ref_star_catalog = np.zeros([len(detected_sources), 13])
ref_star_catalog[:, 0] = detected_sources[:, 0]
ref_star_catalog[:, 1] = detected_sources[:, 1]
ref_star_catalog[:, 2] = detected_sources[:, 2]
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
reduction_metadata.ref_image_path = path.join(
TEST_DATA, 'lsc1m005-fl15-20170701-0144-e91_cropped.fits')
log.info('Read metadata')
sky_background.model_sky_background(setup, reduction_metadata, log,
ref_star_catalog)
logs.close_log(log)
def test_update_reduction_metadata_with_inst_config_file():
reduction_metadata = metadata.MetaData()
pipeline_config = stage0.read_the_config_file('../../Config/', log=None)
stage0.update_reduction_metadata_with_config_file(reduction_metadata, pipeline_config, log=None)
inst_config_dictionnary = {'fromage': {"comment": "tres bon",
"value": "camembert",
"format": "S200",
"unit": ""}
, 'dessert': {"comment": "moins bon",
"value": "pomme",
"format": "S200",
"unit": ""}}
stage0.update_reduction_metadata_with_inst_config_file(reduction_metadata, inst_config_dictionnary, log=None)
assert 'FROMAGE' in reduction_metadata.reduction_parameters[1].keys()
assert reduction_metadata.reduction_parameters[1]['FROMAGE'] == 'camembert'
assert reduction_metadata.reduction_parameters[1]['FROMAGE'].dtype == 'S200'
assert reduction_metadata.reduction_parameters[1]['FROMAGE'].unit == ''
assert 'DESSERT' in reduction_metadata.reduction_parameters[1].keys()
assert reduction_metadata.reduction_parameters[1]['DESSERT'] == 'pomme'
assert reduction_metadata.reduction_parameters[1]['DESSERT'].dtype == 'S200'
assert reduction_metadata.reduction_parameters[1]['DESSERT'].unit == ''
def add(url):
if contains(url):
return get_by_url(url).id
m = metadata.MetaData(url)
db[url] = m
id_to_url[m.id] = url
return m.id
def test_id_crowded_stars():
"""Function to test the exclusion of crowded stars from the PSF star
selection process"""
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
log = logs.start_stage_log( cwd, 'test_psf_selection' )
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
log.info('Read metadata')
nstars = 10
bright = 16.0
faint = 23.0
ref_star_catalog = np.zeros([nstars,13])
ref_star_catalog[:,0] = range(0,nstars,1)
istar = -1
for j in range(0,7,1):
istar += 1
ref_star_catalog[istar,1] = abs(random.normalvariate(100.0,100.0))
ref_star_catalog[istar,2] = abs(random.normalvariate(100.0,100.0))
ref_star_catalog[istar,5] = abs(random.normalvariate(16.0,0.5))
exclude = []
for j in range(istar,nstars,1):
i = random.randint(0,2)
xstar = ref_star_catalog[i,1]
ystar = ref_star_catalog[i,2]
ref_star_catalog[j,1] = random.normalvariate(xstar,1.0)
ref_star_catalog[j,2] = random.normalvariate(ystar,1.0)
ref_star_catalog[j,5] = abs(random.normalvariate(17.0,0.5))
exclude.append(i)
ref_star_catalog[:,3] = random.normalvariate(17.0*15.0,20.0)
ref_star_catalog[:,4] = random.normalvariate(-27.0,10.0)
ref_star_catalog[:,6] = 0.005 + ref_star_catalog[:,4]*0.05
psf_stars_idx = np.array([1]*nstars)
psf_stars_idx = psf_selection.id_crowded_stars(setup,reduction_metadata,log,
ref_star_catalog,psf_stars_idx)
psf_selection.plot_ref_star_catalog_positions(setup,reduction_metadata,log,
ref_star_catalog, psf_stars_idx)
star_index = np.where(psf_stars_idx == 1)[0]
for j in exclude:
assert j not in star_index
logs.close_log(log)
def test_update_reduction_metadata_with_config_file():
reduction_metadata = metadata.MetaData()
pipeline_config = stage0.read_the_config_file('../../Config/', log=None)
stage0.update_reduction_metadata_with_config_file(reduction_metadata, pipeline_config, log=None)
assert len(reduction_metadata.reduction_parameters[1]) != 0
def test_update_column_to_layer():
metad = metadata.MetaData()
metad.create_a_new_layer('dummy_layer', [['OHOHOH'], ['S150'], ['km/s']],
[['0', '59']])
metad.update_row_to_layer('dummy_layer', 'OHOHOH', ['89', '-98'])
assert metad.dummy_layer[1]['OHOHOH'][0] == '89'
assert metad.dummy_layer[1]['OHOHOH'][1] == '-98'
def test_load_a_layer_from_file():
metad = metadata.MetaData()
metad.load_a_layer_from_file('./', 'dummy_metadata.fits', 'data_inventory')
assert metad.data_inventory[1].keys() == [
'IMAGES', 'STAGE_0', 'STAGE_1', 'STAGE_2', 'STAGE_3', 'STAGE_4',
'STAGE_5', 'STAGE_6', 'STAGE_7'
]
assert len(metad.data_inventory[1]) == 0
def main():
print("Read values for IMG_0613.mp4")
file = "./IMG_0613.mp4"
md = metadata.MetaData(file)
# Print metadata values
print("codecs: ", md.get_codecs())
print("height: ", md.get_height())
print("width: ", md.get_width())
print("fps: ", md.get_fps())
print("Read values for IMG_0753.MOV")
file = "./IMG_0753.MOV"
md = metadata.MetaData(file)
# Print metadata values
print("codecs: ", md.get_codecs())
print("height: ", md.get_height())
print("width: ", md.get_width())
print("fps: ", md.get_fps())
def test_transform_2D_table_to_dictionary():
metad = metadata.MetaData()
metad.create_a_new_layer(
'dummy_layer',
[['OHOHOH', 'IHIHIH'], ['S150', 'S10'], ['km/s', 'h/(2pi)']],
[['0'], ['59']])
dico = metad.transform_2D_table_to_dictionary('dummy_layer')
assert len(dico._fields) == 2
assert getattr(dico, 'OHOHOH') == '0'
assert getattr(dico, 'IHIHIH') == '59'
def test_id_mid_range_stars():
"""Function to test the selection of stars in the reference image, excluding
the brightest and faintest N% of those detected"""
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
log = logs.start_stage_log( cwd, 'test_psf_selection' )
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
log.info('Read metadata')
# Generating test catalog with columns:
# idx x y ra dec inst_mag inst_mag_err J Jerr H Herr K Kerr
nstars = 10
bright = 16.0
faint = 23.0
ref_star_catalog = np.zeros([nstars,13])
ref_star_catalog[:,0] = range(0,nstars,1)
ref_star_catalog[:,1] = random.normalvariate(100.0,100.0)
ref_star_catalog[:,2] = random.normalvariate(100.0,100.0)
ref_star_catalog[:,3] = random.normalvariate(17.0*15.0,20.0)
ref_star_catalog[:,4] = random.normalvariate(-27.0,10.0)
ref_star_catalog[:,5] = np.arange(bright,faint,(faint-bright)/float(nstars))
ref_star_catalog[:,6] = 0.005 + ref_star_catalog[:,4]*0.05
psf_stars_idx = np.array([1]*nstars)
psf_range_thresh = reduction_metadata.reduction_parameters[1]['PSF_RANGE_THRESH'][0]
log.info('Read psf range threshold = '+str(psf_range_thresh))
nstar_cut = int(float(nstars) * (psf_range_thresh/100.0))
istart = nstar_cut
iend = len(ref_star_catalog) - nstar_cut
test_psf_stars_idx = np.ones(nstars)
test_psf_stars_idx[0:nstar_cut] = 0
test_psf_stars_idx[(-1*nstar_cut):] = 0
psf_stars_idx = psf_selection.id_mid_range_stars(setup,reduction_metadata,
log,
ref_star_catalog,
psf_stars_idx)
assert psf_stars_idx.all() == test_psf_stars_idx.all()
logs.close_log(log)
def __init__(self):
self.mData = metadata.MetaData()
self.mData.load()
size = (880, 600)
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption("Painter")
self.clock = pygame.time.Clock()
self.im = CImage(self.mData)
self.brush = Brush(self.screen, self.im)
self.menu = Menu(self.screen)
self.menu.set_brush(self.brush)
self.board = Board(self.screen)
self.process = None
self.queue = Queue()
def test_add_row_to_layer():
metad = metadata.MetaData()
metad.create_a_new_layer(
'dummy_layer',
[['OHOHOH', 'IHIHIH'], ['S150', 'S10'], ['km/s', 'h/(2pi)']],
[['0'], ['59']])
new_row = ['purple', 'orange']
metad.add_row_to_layer('dummy_layer', new_row)
assert metad.dummy_layer[1]['OHOHOH'][0] == '0'
assert metad.dummy_layer[1]['OHOHOH'][1] == 'purple'
assert metad.dummy_layer[1]['IHIHIH'][0] == '59'
assert metad.dummy_layer[1]['IHIHIH'][1] == 'orange'
def test_extract_parameters_stage3():
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'images_stats')
reduction_metadata.reference_image_path = os.path.join(
setup.red_dir, 'lsc1m005-fl15-20170418-0131-e91_cropped.fits')
meta_pars = stage3.extract_parameters_stage3(reduction_metadata)
print meta_pars
def test_update_2D_table_with_dictionary():
metad = metadata.MetaData()
metad.create_a_new_layer(
'dummy_layer',
[['OHOHOH', 'IHIHIH'], ['S150', 'S10'], ['km/s', 'h/(2pi)']],
[['0'], ['59']])
dictionary = collections.namedtuple('dummy_dictionary',
['OHOHOH', 'IHIHIH'])
setattr(dictionary, 'OHOHOH', 'monalisa')
setattr(dictionary, 'IHIHIH', 'batistuta')
metad.update_2D_table_with_dictionary('dummy_layer', dictionary)
assert metad.dummy_layer[1]['OHOHOH'] == 'monalisa'
assert metad.dummy_layer[1]['IHIHIH'] == 'batistuta'
def test_build_psf():
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
log = logs.start_stage_log(cwd, 'test_build_psf')
log.info(setup.summary())
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
reduction_metadata.reference_image_path = os.path.join(
TEST_DATA, 'lsc1m005-fl15-20170701-0144-e91_cropped.fits')
reduction_metadata.background_type = 'constant'
star_catalog_file = os.path.join(TEST_DATA, 'star_catalog.fits')
ref_star_catalog = catalog_utils.read_ref_star_catalog_file(
star_catalog_file)
log.info('Read in catalog of ' + str(len(ref_star_catalog)) + ' stars')
psf_stars_idx = np.zeros(len(ref_star_catalog))
psf_stars_idx[400:500] = 1
ref_star_catalog[:, 13] = psf_stars_idx
ref_image = fits.getdata(reduction_metadata.reference_image_path)
log.info('Loaded reference image')
sky_model = psf.ConstantBackground()
sky_model.constant = 1345.0
sky_model.background_parameters.constant = 1345.0
(psf_model, status) = psf.build_psf(setup,
reduction_metadata,
log,
ref_image,
ref_star_catalog,
sky_model,
diagnostics=True)
logs.close_log(log)
def readAngularDistFile(self):
angleRotLabel = md.MDL_ANGLE_ROT
angleTiltLabel = md.MDL_ANGLE_TILT
anglePsiLabel = md.MDL_ANGLE_PSI
mdAngDist = md.MetaData(self.angularDistFile)
if not mdAngDist.containsLabel(md.MDL_ANGLE_PSI):
anglePsiLabel = None
if mdAngDist.containsLabel(md.RLN_ORIENT_PSI):
angleRotLabel = md.RLN_ORIENT_ROT
angleTiltLabel = md.RLN_ORIENT_TILT
anglePsiLabel = md.RLN_ORIENT_PSI
if not mdAngDist.containsLabel(md.MDL_WEIGHT):
mdAngDist.fillConstant(md.MDL_WEIGHT, 1.)
maxweight = mdAngDist.aggregateSingle(md.AGGR_MAX, md.MDL_WEIGHT)
minweight = mdAngDist.aggregateSingle(md.AGGR_MIN, md.MDL_WEIGHT)
interval = maxweight - minweight
self.angulardist = []
x2 = self.xdim / 2
y2 = self.ydim / 2
z2 = self.zdim / 2
#cofr does not seem to work!
#self.angulardist.append('cofr %d,%d,%d'%(x2,y2,z2))
for id in mdAngDist:
rot = mdAngDist.getValue(angleRotLabel, id)
tilt = mdAngDist.getValue(angleTiltLabel, id)
psi = mdAngDist.getValue(anglePsiLabel, id) if anglePsiLabel else 0
weight = mdAngDist.getValue(md.MDL_WEIGHT, id)
weight = 0 if interval == 0 else (
weight - minweight) / interval #avoid cero division
weight = weight + 0.5 #add 0.5 to avoid cero weight
x, y, z = xmipp.Euler_direction(rot, tilt, psi)
radius = weight * self.spheresMaxRadius
x = x * self.spheresDistance + x2
y = y * self.spheresDistance + y2
z = z * self.spheresDistance + z2
command = 'shape sphere radius %s center %s,%s,%s color %s ' % (
radius, x, y, z, self.spheresColor)
self.angulardist.append(command)
def test_model_sky_background():
"""Function to test the fitting of a sky background model to a masked
real star image."""
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
log = logs.start_stage_log(cwd, 'test_sky_background')
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'images_stats')
log.info('Read metadata')
# Need to check where these parameters come from
reduction_metadata.reference_image_path = os.path.join(
cwd, 'data', 'lsc1m005-fl15-20170701-0144-e91_cropped.fits')
reduction_metadata.background_type = 'constant'
ref_star_catalog_file = os.path.join(cwd, 'data', 'star_catalog.fits')
ref_star_catalog = catalog_utils.read_ref_star_catalog_file(
ref_star_catalog_file)
log.info('Read reference image star catalog from ' + ref_star_catalog_file)
sky_model = sky_background.model_sky_background(setup, reduction_metadata,
log, ref_star_catalog)
log.info('Fit image sky background with '+\
reduction_metadata.background_type+' model, parameters:')
for key in sky_model.model:
log.info(key + ' = ' +
str(getattr(sky_model.background_parameters, key)))
logs.close_log(log)
def test_add_column_to_layer():
metad = metadata.MetaData()
metad.create_a_new_layer(
'dummy_layer',
[['OHOHOH', 'IHIHIH'], ['S150', 'S10'], ['km/s', 'h/(2pi)']],
[['0'], ['59']])
new_column_name = 'LOL'
new_column_data = [42]
new_column_format = 'float64'
new_column_unit = 'N/c'
metad.add_column_to_layer('dummy_layer', new_column_name, new_column_data,
new_column_format, new_column_unit)
assert metad.dummy_layer[1]['LOL'] == 42
assert metad.dummy_layer[1]['LOL'].dtype == 'float64'
assert metad.dummy_layer[1]['LOL'].unit == 'N/c'
def plotAngularDistributionFromMd(self, mdFile, title, **kwargs):
""" Read the values of rot, tilt and weights from
the medata and plot the angular distribution.
ANGLES are in DEGREES
In the metadata:
rot: MDL_ANGLE_ROT
tilt: MDL_ANGLE_TILT
weight: MDL_WEIGHT
"""
angMd = md.MetaData(mdFile)
rot = []
tilt = []
weight = []
for row in md.iterRows(angMd):
rot.append(radians(row.getValue(md.MDL_ANGLE_ROT)))
tilt.append(row.getValue(md.MDL_ANGLE_TILT))
weight.append(row.getValue(md.MDL_WEIGHT))
return self.plotAngularDistribution(title, rot, tilt, weight, **kwargs)
def test_parse_the_image_header():
setup = mock.MagicMock()
reduction_metadata = metadata.MetaData()
pipeline_config = stage0.read_the_config_file('../../Config/', log=None)
stage0.update_reduction_metadata_with_config_file(reduction_metadata, pipeline_config, log=None)
inst_config_dictionnary = {'OBSTYPE': {"comment": "tres bon",
"value": "OBJECT",
"format": "S200",
"unit": ""}}
stage0.update_reduction_metadata_with_inst_config_file(reduction_metadata, inst_config_dictionnary, log=None)
image = stage0.open_an_image(setup, '../tests/data/proc/ROME-FIELD-0002_lsc-doma-1m0-05-fl15_ip/data',
'lsc1m005-fl15-20170418-0131-e91_cropped.fits')
values = stage0.parse_the_image_header(reduction_metadata, image)
assert values[0][1] == 'ROME-FIELD-02'
def test_load_metadata_from_file():
metad = metadata.MetaData()
metad.load_all_metadata('./', 'dummy_metadata.fits')
assert metad.stamps == [None, None]
assert metad.reduction_parameters == [None, None]
assert metad.headers_summary == [None, None]
assert metad.data_inventory[1].keys() == [
'IMAGES', 'STAGE_0', 'STAGE_1', 'STAGE_2', 'STAGE_3', 'STAGE_4',
'STAGE_5', 'STAGE_6', 'STAGE_7'
]
assert len(metad.data_inventory[1]) == 0
assert metad.data_architecture[1].keys() == [
'METADATA_NAME', 'OUTPUT_DIRECTORY'
]
assert metad.data_architecture[1]['METADATA_NAME'] == 'dummy_metadata.fits'
assert metad.data_architecture[1]['OUTPUT_DIRECTORY'] == './'
assert len(metad.data_architecture[1]) == 1
def test_create_a_new_layer():
metad = metadata.MetaData()
metad.create_a_new_layer(
'dummy_layer',
[['OHOHOH', 'IHIHIH'], ['S150', 'S10'], ['km/s', 'h/(2pi)']],
[['0', '1'], ['59', '41']])
new_layer = metad.dummy_layer
assert new_layer[1].keys() == ['OHOHOH', 'IHIHIH']
assert new_layer[1]['OHOHOH'].dtype == 'S150'
assert new_layer[1]['IHIHIH'].dtype == 'S10'
assert new_layer[1]['OHOHOH'].unit == 'km/s'
assert new_layer[1]['IHIHIH'].unit == 'h/(2pi)'
assert new_layer[1]['OHOHOH'][0] == '0'
assert new_layer[1]['OHOHOH'][1] == '1'
assert new_layer[1]['IHIHIH'][0] == '59'
assert new_layer[1]['IHIHIH'][1] == '41'
def add_package(self, path, repo_uri):
package = Package(path, 'r')
# extract control files
util.clean_dir(ctx.config.install_dir())
package.extract_PISI_files(ctx.config.install_dir())
md = metadata.MetaData()
md.read(os.path.join(ctx.config.install_dir(), ctx.const.metadata_xml))
md.package.packageSize = long(os.path.getsize(path))
if ctx.config.options and ctx.config.options.absolute_uris:
# FIXME: the name "absolute_uris" does not seem to fit below :/
md.package.packageURI = os.path.realpath(path)
else: # create relative path by default
# TODO: in the future well do all of this with purl/pfile/&helpers
# really? heheh -- future exa
md.package.packageURI = util.removepathprefix(repo_uri, path)
# check package semantics
errs = md.errors()
if md.errors():
ctx.ui.error(_('Package %s: metadata corrupt, skipping...') % md.package.name)
ctx.ui.error(unicode(Error(*errs)))
else:
self.packages.append(md.package)
def test_run_iterative_PSF_photometry():
"""Function to test the PSF-fitting photometry module for a single image"""
setup = pipeline_setup.pipeline_setup({'red_dir': TEST_DIR})
log = logs.start_stage_log(cwd, 'test_photometry')
reduction_metadata = metadata.MetaData()
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'reduction_parameters')
reduction_metadata.load_a_layer_from_file(setup.red_dir,
'pyDANDIA_metadata.fits',
'images_stats')
log.info('Read metadata')
# NOTE: Once stage 2 is complete, the reference image path should be
# extracted directly from the metadata.
reduction_metadata.reference_image_path = os.path.join(
TEST_DIR, 'data', 'lsc1m005-fl15-20170418-0131-e91_cropped.fits')
image_path = reduction_metadata.reference_image_path
log.info('Performing PSF fitting photometry on ' +
os.path.basename(image_path))
phot_data = photometry.run_iterative_PSF_photometry(setup,
reduction_metadata,
image_path,
log,
diagnostics=True)
test_output = Table()
assert type(phot_data) == type(test_output)
logs.close_log(log)
