def _stack(nimages, im_shape, parang):
im_new = None
parang_new = None
if self.m_stacking is not None:
frames = memory_frames(self.m_stacking, nimages)
nimages_new = np.size(frames) - 1
if parang is None:
parang_new = None
else:
parang_new = np.zeros(nimages_new)
im_new = np.zeros((nimages_new, im_shape[1], im_shape[2]))
for i in range(nimages_new):
progress(i, nimages_new, "Running StackAndSubsetModule...")
if parang is not None:
parang_new[i] = np.mean(parang[frames[i]:frames[i +
1]])
im_new[i, ] = np.mean(
self.m_image_in_port[frames[i]:frames[i + 1], ],
axis=0)
im_shape = im_new.shape
else:
if parang is not None:
parang_new = np.copy(parang)
return im_shape, im_new, parang_new
def run(self) -> None:
"""
Run method of the module. Simple background subtraction with a constant index offset.
Returns
-------
NoneType
None
"""
nframes = self.m_image_in_port.get_shape()[0]
subtract = self.m_image_in_port[0] - self.m_image_in_port[(0 + self.m_shift) % nframes]
if self.m_image_in_port.tag == self.m_image_out_port.tag:
self.m_image_out_port[0] = subtract
else:
self.m_image_out_port.set_all(subtract, data_dim=3)
start_time = time.time()
for i in range(1, nframes):
progress(i, nframes, 'Subtracting background...', start_time)
subtract = self.m_image_in_port[i] - self.m_image_in_port[(i + self.m_shift) % nframes]
if self.m_image_in_port.tag == self.m_image_out_port.tag:
self.m_image_out_port[i] = subtract
else:
self.m_image_out_port.append(subtract)
history = f'shift = {self.m_shift}'
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.add_history('SimpleBackgroundSubtractionModule', history)
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Looks for all HDF5 files in the input directory and reads the
datasets that are provided in the tag dictionary.
Returns
-------
NoneType
None
"""
# create list of files to be read
files = []
tmp_dir = os.path.join(self.m_input_location, '')
# check if a single input file is given
if self.m_filename is not None:
# create file path + filename
assert(os.path.isfile((tmp_dir + str(self.m_filename)))), \
f'Error: Input file does not exist. Input requested: {self.m_filename}'
files.append((tmp_dir + str(self.m_filename)))
else:
# look for all HDF5 files in the directory
for tmp_file in os.listdir(self.m_input_location):
if tmp_file.endswith('.hdf5') or tmp_file.endswith('.h5'):
files.append(tmp_dir + str(tmp_file))
start_time = time.time()
for i, tmp_file in enumerate(files):
progress(i, len(files), 'Reading HDF5 file...', start_time)
self.read_single_hdf5(tmp_file)
def run(self) -> None:
"""
Run method of the module. Rotates all images by a constant angle.
Returns
-------
NoneType
None
"""
memory = self._m_config_port.get_attribute('MEMORY')
nimages = self.m_image_in_port.get_shape()[0]
frames = memory_frames(memory, nimages)
start_time = time.time()
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), 'Rotating images...', start_time)
images = self.m_image_in_port[frames[i]:frames[i + 1], ]
for j in range(frames[i + 1] - frames[i]):
im_tmp = images[j, ]
# ndimage.rotate rotates in clockwise direction for positive angles
im_tmp = rotate(im_tmp, self.m_angle, reshape=False)
self.m_image_out_port.append(im_tmp, data_dim=3)
history = f'angle [deg] = {self.m_angle}'
self.m_image_out_port.add_history('RotateImagesModule', history)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Applies a Gaussian filter to the spatial dimensions of the
images.
Returns
-------
NoneType
None
"""
memory = self._m_config_port.get_attribute('MEMORY')
pixscale = self._m_config_port.get_attribute('PIXSCALE')
nimages = self.m_image_in_port.get_shape()[0]
frames = memory_frames(memory, nimages)
sigma = (self.m_fwhm / pixscale) / (2. * math.sqrt(2. * math.log(2.))
) # [pix]
start_time = time.time()
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), 'Applying Gaussian filter...',
start_time)
images = self.m_image_in_port[frames[i]:frames[i + 1], ]
im_filter = gaussian_filter(images, (0, sigma, sigma))
self.m_image_out_port.append(im_filter, data_dim=3)
history = f'fwhm [arcsec] = {self.m_fwhm}'
self.m_image_out_port.add_history('GaussianFilterModule', history)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Removes the lines given by *lines* from each frame.
Returns
-------
NoneType
None
"""
memory = self._m_config_port.get_attribute('MEMORY')
nimages = self.m_image_in_port.get_shape()[0]
frames = memory_frames(memory, nimages)
start_time = time.time()
for i in range(len(frames[:-1])):
progress(i, len(frames[:-1]), 'Removing lines...', start_time)
image_in = self.m_image_in_port[frames[i]:frames[i + 1], ]
image_out = image_in[:,
int(self.m_lines[2]):image_in.shape[1] -
int(self.m_lines[3]),
int(self.m_lines[0]):image_in.shape[2] -
int(self.m_lines[1])]
self.m_image_out_port.append(image_out, data_dim=3)
history = f'number of lines = {self.m_lines}'
self.m_image_out_port.add_history('RemoveLinesModule', history)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.close_port()
def run(self):
"""
Run method of the module. Create list of time stamps, get sky and science images, and
subtract the sky images from the science images.
:return: None
"""
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
self._create_time_stamp_list()
for i, time_entry in enumerate(self.m_time_stamps):
progress(i, len(self.m_time_stamps),
"Running NoddingBackgroundModule...")
if time_entry.m_im_type == "SKY":
continue
sky = self.calc_sky_frame(i)
science = self.m_science_in_port[time_entry.m_index, ]
self.m_image_out_port.append(science - sky[None, ], data_dim=3)
sys.stdout.write("Running NoddingBackgroundModule... [DONE]\n")
sys.stdout.flush()
history = "mode = " + self.m_mode
self.m_image_out_port.copy_attributes_from_input_port(
self.m_science_in_port)
self.m_image_out_port.add_history_information(
"NoddingBackgroundModule", history)
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Uses the NFRAMES attribute to select the images of each cube,
calculates the mean or median of each cube, and saves the data and attributes.
Returns
-------
NoneType
None
"""
if self.m_image_in_port.tag == self.m_image_out_port.tag:
raise ValueError('Input and output port should have a different tag.')
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
non_static = self.m_image_in_port.get_all_non_static_attributes()
nframes = self.m_image_in_port.get_attribute('NFRAMES')
if 'PARANG' in non_static:
parang = self.m_image_in_port.get_attribute('PARANG')
else:
parang = None
current = 0
parang_new = []
start_time = time.time()
for i, frames in enumerate(nframes):
progress(i, len(nframes), 'Stacking images per FITS cube...', start_time)
if self.m_combine == 'mean':
im_stack = np.mean(self.m_image_in_port[current:current+frames, ], axis=0)
elif self.m_combine == 'median':
im_stack = np.median(self.m_image_in_port[current:current+frames, ], axis=0)
self.m_image_out_port.append(im_stack, data_dim=3)
if parang is not None:
parang_new.append(np.mean(parang[current:current+frames]))
current += frames
nimages = np.size(nframes)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
if 'INDEX' in non_static:
index = np.arange(0, nimages, 1, dtype=np.int)
self.m_image_out_port.add_attribute('INDEX', index, static=False)
if 'NFRAMES' in non_static:
nframes = np.ones(nimages, dtype=np.int)
self.m_image_out_port.add_attribute('NFRAMES', nframes, static=False)
if 'PARANG' in non_static:
self.m_image_out_port.add_attribute('PARANG', parang_new, static=False)
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Create list of time stamps, get sky and science images, and
subtract the sky images from the science images.
Returns
-------
NoneType
None
"""
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
self._create_time_stamp_list()
start_time = time.time()
for i, time_entry in enumerate(self.m_time_stamps):
progress(i, len(self.m_time_stamps), 'Running NoddingBackgroundModule...', start_time)
if time_entry.m_im_type == 'SKY':
continue
sky = self.calc_sky_frame(i)
science = self.m_science_in_port[time_entry.m_index, ]
self.m_image_out_port.append(science - sky[None, ], data_dim=3)
sys.stdout.write('Running NoddingBackgroundModule... [DONE]\n')
sys.stdout.flush()
history = f'mode = {self.m_mode}'
self.m_image_out_port.copy_attributes(self.m_science_in_port)
self.m_image_out_port.add_history('NoddingBackgroundModule', history)
self.m_image_out_port.close_port()
def _run_single_processing(self, star_reshape, im_shape, indices):
"""
Internal function to create the residuals, derotate the images, and write the output
using a single process.
Returns
-------
NoneType
None
"""
for i, pca_number in enumerate(self.m_components):
progress(i, len(self.m_components), "Creating residuals...")
parang = -1. * self.m_star_in_port.get_attribute(
"PARANG") + self.m_extra_rot
residuals, res_rot = pca_psf_subtraction(images=star_reshape,
angles=parang,
pca_number=pca_number,
pca_sklearn=self.m_pca,
im_shape=im_shape,
indices=indices)
hist = "max PC number = " + str(np.amax(self.m_components))
# 1.) derotated residuals
if self.m_res_arr_out_ports is not None:
self.m_res_arr_out_ports[pca_number].set_all(res_rot)
self.m_res_arr_out_ports[pca_number].copy_attributes(
self.m_star_in_port)
self.m_res_arr_out_ports[pca_number].add_history(
"PcaPsfSubtractionModule", hist)
# 2.) mean residuals
if self.m_res_mean_out_port is not None:
stack = combine_residuals(method="mean", res_rot=res_rot)
self.m_res_mean_out_port.append(stack, data_dim=3)
# 3.) median residuals
if self.m_res_median_out_port is not None:
stack = combine_residuals(method="median", res_rot=res_rot)
self.m_res_median_out_port.append(stack, data_dim=3)
# 4.) noise-weighted residuals
if self.m_res_weighted_out_port is not None:
stack = combine_residuals(method="weighted",
res_rot=res_rot,
residuals=residuals,
angles=parang)
self.m_res_weighted_out_port.append(stack, data_dim=3)
# 5.) clipped mean residuals
if self.m_res_rot_mean_clip_out_port is not None:
stack = combine_residuals(method="clipped", res_rot=res_rot)
self.m_res_rot_mean_clip_out_port.append(stack, data_dim=3)
sys.stdout.write("Creating residuals... [DONE]\n")
sys.stdout.flush()
def run(self) -> None:
"""
Run method of the module. Repeats the stack of input images a specified number of times.
Returns
-------
NoneType
None
"""
self.m_image_out_port.del_all_attributes()
self.m_image_out_port.del_all_data()
nimages = self.m_image_in_port.get_shape()[0]
memory = self._m_config_port.get_attribute('MEMORY')
frames = memory_frames(memory, nimages)
start_time = time.time()
for i in range(self.m_repeat):
progress(i, self.m_repeat, 'Running RepeatImagesModule...', start_time)
for j, _ in enumerate(frames[:-1]):
images = self.m_image_in_port[frames[j]:frames[j+1], ]
self.m_image_out_port.append(images, data_dim=3)
sys.stdout.write('Running RepeatImagesModule... [DONE]\n')
sys.stdout.flush()
history = f'repeat = {self.m_repeat}'
self.m_image_out_port.add_history('RepeatImagesModule', history)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.close_port()
def run(self):
"""
Run method of the module. Looks for all HDF5 files in the input directory and reads them
using the internal function _read_single_hdf5().
:return: None
"""
# create list of files to be read
files = []
tmp_dir = os.path.join(self.m_input_location, '')
# check if a single input file is given
if self.m_filename is not None:
# create file path + filename
assert(os.path.isfile((tmp_dir + str(self.m_filename)))), \
"Error: Input file does not exist. Input requested: %s" % str(self.m_filename)
files.append((tmp_dir + str(self.m_filename)))
else:
# look for all HDF5 files in the directory
for tmp_file in os.listdir(self.m_input_location):
if tmp_file.endswith('.hdf5') or tmp_file.endswith('.h5'):
files.append(tmp_dir + str(tmp_file))
for i, tmp_file in enumerate(files):
progress(i, len(files), "Running Hdf5ReadingModule...")
self._read_single_hdf5(tmp_file)
sys.stdout.write("Running Hdf5ReadingModule... [DONE]\n")
sys.stdout.flush()
def run(self) -> None:
"""
Run method of the module. Creates a master dark with the same shape as the science
data and subtracts the dark frame from the science data.
Returns
-------
NoneType
None
"""
memory = self._m_config_port.get_attribute('MEMORY')
nimages = self.m_image_in_port.get_shape()[0]
frames = memory_frames(memory, nimages)
dark = self.m_dark_in_port.get_all()
master = _master_frame(data=np.mean(dark, axis=0),
im_shape=self.m_image_in_port.get_shape())
start_time = time.time()
for i in range(len(frames[:-1])):
progress(i, len(frames[:-1]), 'Subtracting the dark current...',
start_time)
images = self.m_image_in_port[frames[i]:frames[i + 1], ]
self.m_image_out_port.append(images - master, data_dim=3)
history = f'dark_in_tag = {self.m_dark_in_port.tag}'
self.m_image_out_port.add_history('DarkCalibrationModule', history)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Subtracts the images from the second database tag from the images
of the first database tag, on a frame-by-frame basis.
Returns
-------
NoneType
None
"""
if self.m_image_in1_port.get_shape(
) != self.m_image_in2_port.get_shape():
raise ValueError(
'The shape of the two input tags has to be the same.')
memory = self._m_config_port.get_attribute('MEMORY')
nimages = self.m_image_in1_port.get_shape()[0]
frames = memory_frames(memory, nimages)
start_time = time.time()
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), 'Subtracting images...', start_time)
images1 = self.m_image_in1_port[frames[i]:frames[i + 1], ]
images2 = self.m_image_in2_port[frames[i]:frames[i + 1], ]
self.m_image_out_port.append(self.m_scaling * (images1 - images2),
data_dim=3)
history = f'scaling = {self.m_scaling}'
self.m_image_out_port.add_history('SubtractImagesModule', history)
self.m_image_out_port.copy_attributes(self.m_image_in1_port)
self.m_image_out_port.close_port()
def run(self):
"""
Run method of the module. Removes every NDIT+1 frame and saves the data and attributes.
Returns
-------
NoneType
None
"""
if self.m_image_out_port.tag == self.m_image_in_port.tag:
raise ValueError(
'Input and output port should have a different tag.')
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
ndit = self.m_image_in_port.get_attribute('NDIT')
nframes = self.m_image_in_port.get_attribute('NFRAMES')
index = self.m_image_in_port.get_attribute('INDEX')
nframes_new = []
index_new = []
start_time = time.time()
for i, item in enumerate(ndit):
progress(i, len(ndit), 'Running RemoveLastFrameModule...',
start_time)
if nframes[i] != item + 1:
warnings.warn(
f'Number of frames ({nframes[i]}) is not equal to NDIT+1.')
frame_start = np.sum(nframes[0:i])
frame_end = np.sum(nframes[0:i + 1]) - 1
nframes_new.append(nframes[i] - 1)
index_new.extend(index[frame_start:frame_end])
images = self.m_image_in_port[frame_start:frame_end, ]
self.m_image_out_port.append(images)
nframes_new = np.asarray(nframes_new, dtype=np.int)
index_new = np.asarray(index_new, dtype=np.int)
sys.stdout.write('Running RemoveLastFrameModule... [DONE]\n')
sys.stdout.flush()
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.add_attribute('NFRAMES',
nframes_new,
static=False)
self.m_image_out_port.add_attribute('INDEX', index_new, static=False)
history = 'frames removed = NDIT+1'
self.m_image_out_port.add_history('RemoveLastFrameModule', history)
self.m_image_out_port.close_port()
def run(self):
"""
Run method of the module. Calculates the minimum, maximum, sum, mean, median, and standard
deviation of the pixel values of each image separately. NaNs are ignored for each
calculation. The values are calculated for either the full images or a circular
subsection of the images.
Returns
-------
NoneType
None
"""
self.m_stat_out_port.del_all_data()
self.m_stat_out_port.del_all_attributes()
memory = self._m_config_port.get_attribute("MEMORY")
pixscale = self.m_image_in_port.get_attribute("PIXSCALE")
if self.m_position is not None:
self.m_position = (
int(self.m_position[1]), # y position
int(self.m_position[0]), # x position
self.m_position[2] / pixscale) # radius (pix)
nimages = self.m_image_in_port.get_shape()[0]
im_shape = self.m_image_in_port.get_shape()[1:]
frames = memory_frames(memory, nimages)
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), "Running ImageStatisticsModule...")
images = self.m_image_in_port[frames[i]:frames[i + 1], ]
images = np.reshape(images,
(images.shape[0], im_shape[0] * im_shape[1]))
if self.m_position is not None:
rr_grid = pixel_distance(im_shape, self.m_position)
indices = np.where(rr_grid <= self.m_position[2])[0]
images = images[:, indices]
nmin = np.nanmin(images, axis=1)
nmax = np.nanmax(images, axis=1)
nsum = np.nansum(images, axis=1)
mean = np.nanmean(images, axis=1)
median = np.nanmedian(images, axis=1)
std = np.nanstd(images, axis=1)
result = np.column_stack((nmin, nmax, nsum, mean, median, std))
self.m_stat_out_port.append(result)
sys.stdout.write("Running ImageStatisticsModule... [DONE]\n")
sys.stdout.flush()
history = "number of images = " + str(nimages)
self.m_stat_out_port.copy_attributes(self.m_image_in_port)
self.m_stat_out_port.add_history("ImageStatisticsModule", history)
self.m_stat_out_port.close_port()
def _run_single_processing(self, star_reshape: np.ndarray,
im_shape: Tuple[int, int, int],
indices: np.ndarray) -> None:
"""
Internal function to create the residuals, derotate the images, and write the output
using a single process.
"""
start_time = time.time()
for i, pca_number in enumerate(self.m_components):
progress(i, len(self.m_components), 'Creating residuals...',
start_time)
parang = -1. * self.m_star_in_port.get_attribute(
'PARANG') + self.m_extra_rot
residuals, res_rot = pca_psf_subtraction(
images=star_reshape,
angles=parang,
pca_number=int(pca_number),
pca_sklearn=self.m_pca,
im_shape=im_shape,
indices=indices)
hist = f'max PC number = {np.amax(self.m_components)}'
# 1.) derotated residuals
if self.m_res_arr_out_ports is not None:
self.m_res_arr_out_ports[pca_number].set_all(res_rot)
self.m_res_arr_out_ports[pca_number].copy_attributes(
self.m_star_in_port)
self.m_res_arr_out_ports[pca_number].add_history(
'PcaPsfSubtractionModule', hist)
# 2.) mean residuals
if self.m_res_mean_out_port is not None:
stack = combine_residuals(method='mean', res_rot=res_rot)
self.m_res_mean_out_port.append(stack, data_dim=3)
# 3.) median residuals
if self.m_res_median_out_port is not None:
stack = combine_residuals(method='median', res_rot=res_rot)
self.m_res_median_out_port.append(stack, data_dim=3)
# 4.) noise-weighted residuals
if self.m_res_weighted_out_port is not None:
stack = combine_residuals(method='weighted',
res_rot=res_rot,
residuals=residuals,
angles=parang)
self.m_res_weighted_out_port.append(stack, data_dim=3)
# 5.) clipped mean residuals
if self.m_res_rot_mean_clip_out_port is not None:
stack = combine_residuals(method='clipped', res_rot=res_rot)
self.m_res_rot_mean_clip_out_port.append(stack, data_dim=3)
def run(self) -> None:
"""
Run method of the module. Applies a frame selection on the derotated residuals from the
PSF subtraction. The pixels within an annulus (e.g. at the separation of an expected
planet) are selected and the standard deviation is calculated. The chosen percentage
of images with the lowest standard deviation are stored as output.
Returns
-------
NoneType
None
"""
pixscale = self.m_image_in_port.get_attribute('PIXSCALE')
nimages = self.m_image_in_port.get_shape()[0]
npix = self.m_image_in_port.get_shape()[-1]
rr_grid, _, _ = pixel_distance((npix, npix), position=None)
pixel_select = np.where((rr_grid > self.m_annulus_radii[0] / pixscale)
&
(rr_grid < self.m_annulus_radii[1] / pixscale))
start_time = time.time()
phot_annulus = np.zeros(nimages)
for i in range(nimages):
progress(i, nimages, 'Aperture photometry...', start_time)
phot_annulus[i] = np.sum(
np.abs(self.m_image_in_port[i][pixel_select]))
print(
f'Minimum, maximum = {np.amin(phot_annulus):.2f}, {np.amax(phot_annulus):.2f}'
)
print(
f'Mean, median = {np.nanmean(phot_annulus):.2f}, {np.nanmedian(phot_annulus):.2f}'
)
print(f'Standard deviation = {np.nanstd(phot_annulus):.2f}')
n_select = int(nimages * self.m_percentage / 100.)
index_del = np.argsort(phot_annulus)[n_select:]
write_selected_data(memory=self._m_config_port.get_attribute('MEMORY'),
indices=index_del,
image_in_port=self.m_image_in_port,
selected_out_port=self.m_selected_out_port,
removed_out_port=self.m_removed_out_port)
write_selected_attributes(indices=index_del,
image_in_port=self.m_image_in_port,
selected_out_port=self.m_selected_out_port,
removed_out_port=self.m_removed_out_port,
module_type='ResidualSelectionModule',
history=f'frames removed = {index_del.size}')
self.m_image_in_port.close_port()
def run(self) -> None:
"""
Run method of the module. Removes the frames and corresponding attributes, updates the
NFRAMES attribute, and saves the data and attributes.
Returns
-------
NoneType
None
"""
self._initialize()
memory = self._m_config_port.get_attribute('MEMORY')
nimages = self.m_image_in_port.get_shape()[0]
frames = memory_frames(memory, nimages)
if memory == 0 or memory >= nimages:
memory = nimages
start_time = time.time()
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), 'Running RemoveFramesModule...', start_time)
images = self.m_image_in_port[frames[i]:frames[i+1], ]
index_del = np.where(np.logical_and(self.m_frames >= frames[i],
self.m_frames < frames[i+1]))
write_selected_data(images,
self.m_frames[index_del] % memory,
self.m_selected_out_port,
self.m_removed_out_port)
sys.stdout.write('Running RemoveFramesModule... [DONE]\n')
sys.stdout.flush()
history = 'frames removed = '+str(np.size(self.m_frames))
if self.m_selected_out_port is not None:
# Copy attributes before write_selected_attributes is used
self.m_selected_out_port.copy_attributes(self.m_image_in_port)
self.m_selected_out_port.add_history('RemoveFramesModule', history)
if self.m_removed_out_port is not None:
# Copy attributes before write_selected_attributes is used
self.m_removed_out_port.copy_attributes(self.m_image_in_port)
self.m_removed_out_port.add_history('RemoveFramesModule', history)
write_selected_attributes(self.m_frames,
self.m_image_in_port,
self.m_selected_out_port,
self.m_removed_out_port)
self.m_image_in_port.close_port()
def star_positions(
input_port: InputPort,
fwhm: Optional[int],
position: Optional[Union[Tuple[int, int, float], Tuple[None, None, float],
Tuple[int, int, None]]] = None
) -> np.ndarray:
"""
Function to return the position of the star in each image.
Parameters
----------
input_port : pynpoint.core.dataio.InputPort
Input port where the images are stored.
fwhm : int, None
The FWHM (pix) of the Gaussian kernel that is used to smooth the images before the
brightest pixel is located. No smoothing is applied if set to None.
position : tuple(int, int, int), None
Subframe that is selected to search for the star. The tuple contains the center (pix)
and size (pix) (pos_x, pos_y, size). Setting `position` to None will use the full
image to search for the star. If `position=(None, None, size)` then the center of the
image will be used. If `position=(pos_x, pos_y, None)` then a fixed position is used
for the aperture.
Returns
-------
numpy.ndarray
Positions (y, x) of the brightest pixel.
"""
nimages = input_port.get_shape()[0]
starpos = np.zeros((nimages, 2), dtype=np.int64)
if position is not None and position[2] is None:
# [y. x] position
starpos[:, 0] = position[1]
starpos[:, 1] = position[0]
else:
center = None
width = None
if position is not None:
width = position[2]
if position[0] is not None and position[1] is not None:
center = position[0:2]
start_time = time.time()
for i in range(nimages):
progress(i, nimages, 'Locating stellar position...', start_time)
# [y. x] position
starpos[i, :] = locate_star(input_port[i, ], center, width, fwhm)
return starpos
def run(self):
"""
Run method of the module. Removes every NDIT+1 frame and saves the data and attributes.
:return: None
"""
if self.m_image_out_port.tag == self.m_image_in_port.tag:
raise ValueError(
"Input and output port should have a different tag.")
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
ndit = self.m_image_in_port.get_attribute("NDIT")
nframes = self.m_image_in_port.get_attribute("NFRAMES")
index = self.m_image_in_port.get_attribute("INDEX")
nframes_new = []
index_new = []
for i, item in enumerate(ndit):
progress(i, len(ndit), "Running RemoveLastFrameModule...")
if nframes[i] != item + 1:
warnings.warn("Number of frames (%s) is not equal to NDIT+1." %
nframes[i])
frame_start = np.sum(nframes[0:i])
frame_end = np.sum(nframes[0:i + 1]) - 1
nframes_new.append(nframes[i] - 1)
index_new.extend(index[frame_start:frame_end])
images = self.m_image_in_port[frame_start:frame_end, ]
self.m_image_out_port.append(images)
nframes_new = np.asarray(nframes_new, dtype=np.int)
index_new = np.asarray(index_new, dtype=np.int)
sys.stdout.write("Running RemoveLastFrameModule... [DONE]\n")
sys.stdout.flush()
self.m_image_out_port.copy_attributes_from_input_port(
self.m_image_in_port)
self.m_image_out_port.add_attribute("NFRAMES",
nframes_new,
static=False)
self.m_image_out_port.add_attribute("INDEX", index_new, static=False)
history = "frames removed = NDIT+1"
self.m_image_out_port.add_history_information("RemoveLastFrameModule",
history)
self.m_image_out_port.close_port()
def run(self):
"""
Run method of the module. Shifts the reference PSF to the location of the fake planet
with an additional correction for the parallactic angle and writes the stack with images
with the injected planet signal.
:return: None
"""
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
parang = self.m_image_in_port.get_attribute("PARANG")
pixscale = self.m_image_in_port.get_attribute("PIXSCALE")
self.m_position = (self.m_position[0] / pixscale, self.m_position[1])
psf, ndim_psf, ndim, frames = self._init()
for j, _ in enumerate(frames[:-1]):
progress(j, len(frames[:-1]), "Running FakePlanetModule...")
images = np.copy(self.m_image_in_port[frames[j]:frames[j + 1]])
angles = parang[frames[j]:frames[j + 1]]
if ndim_psf == 3:
psf = np.copy(images)
im_fake = fake_planet(images,
psf,
angles,
self.m_position,
self.m_magnitude,
self.m_psf_scaling,
interpolation="spline")
if ndim == 2:
self.m_image_out_port.set_all(im_fake)
elif ndim == 3:
self.m_image_out_port.append(im_fake, data_dim=3)
sys.stdout.write("Running FakePlanetModule... [DONE]\n")
sys.stdout.flush()
self.m_image_out_port.copy_attributes_from_input_port(
self.m_image_in_port)
self.m_image_out_port.add_history_information("FakePlanetModule",
"(sep, angle, mag) = " + "(" + \
"{0:.2f}".format(self.m_position[0]* \
pixscale)+", "+ \
"{0:.2f}".format(self.m_position[1])+", "+ \
"{0:.2f}".format(self.m_magnitude)+")")
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Normalizes the images for the different filter widths,
upscales the images, and crops the images to the initial image shape in order to
align the PSF patterns.
Returns
-------
NoneType
None
"""
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
wvl_factor = self.m_line_wvl / self.m_cnt_wvl
width_factor = self.m_line_width / self.m_cnt_width
nimages = self.m_image_in_port.get_shape()[0]
start_time = time.time()
for i in range(nimages):
progress(i, nimages, 'Running SDIpreparationModule...', start_time)
image = self.m_image_in_port[i, ]
im_scale = width_factor * scale_image(image, wvl_factor,
wvl_factor)
if i == 0:
npix_del = im_scale.shape[-1] - image.shape[-1]
if npix_del % 2 == 0:
npix_del_a = int(npix_del / 2)
npix_del_b = int(npix_del / 2)
else:
npix_del_a = int((npix_del - 1) / 2)
npix_del_b = int((npix_del + 1) / 2)
im_crop = im_scale[npix_del_a:-npix_del_b, npix_del_a:-npix_del_b]
if npix_del % 2 == 1:
im_crop = shift_image(im_crop, (-0.5, -0.5),
interpolation='spline')
self.m_image_out_port.append(im_crop, data_dim=3)
sys.stdout.write('Running SDIpreparationModule... [DONE]\n')
sys.stdout.flush()
history = f'(line, continuum) = ({self.m_line_wvl}, {self.m_cnt_wvl})'
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.add_history('SDIpreparationModule', history)
self.m_image_in_port.close_port()
def run(self):
"""
Run method of the module. Removes the frames and corresponding attributes, updates the
NFRAMES attribute, and saves the data and attributes.
:return: None
"""
self._initialize()
memory = self._m_config_port.get_attribute("MEMORY")
nimages = number_images_port(self.m_image_in_port)
frames = memory_frames(memory, nimages)
if memory == 0 or memory >= nimages:
memory = nimages
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), "Running RemoveFramesModule...")
images = self.m_image_in_port[frames[i]:frames[i + 1], ]
index_del = np.where(np.logical_and(self.m_frames >= frames[i], \
self.m_frames < frames[i+1]))
write_selected_data(images, self.m_frames[index_del] % memory,
self.m_selected_out_port,
self.m_removed_out_port)
sys.stdout.write("Running RemoveFramesModule... [DONE]\n")
sys.stdout.flush()
history = "frames removed = " + str(np.size(self.m_frames))
if self.m_selected_out_port is not None:
# Copy attributes before write_selected_attributes is used
self.m_selected_out_port.copy_attributes_from_input_port(
self.m_image_in_port)
self.m_selected_out_port.add_history_information(
"RemoveFramesModule", history)
if self.m_removed_out_port is not None:
# Copy attributes before write_selected_attributes is used
self.m_removed_out_port.copy_attributes_from_input_port(
self.m_image_in_port)
self.m_removed_out_port.add_history_information(
"RemoveFramesModule", history)
write_selected_attributes(self.m_frames, self.m_image_in_port,
self.m_selected_out_port,
self.m_removed_out_port)
self.m_image_in_port.close_port()
def run(self) -> None:
"""
Run method of the module. Calculates the parallactic angles of each frame by linearly
interpolating between the start and end values of the data cubes. The values are written
as attributes to *data_tag*. A correction of 360 deg is applied when the start and end
values of the angles change sign at +/-180 deg.
Returns
-------
NoneType
None
"""
parang_start = self.m_data_in_port.get_attribute('PARANG_START')
parang_end = self.m_data_in_port.get_attribute('PARANG_END')
steps = self.m_data_in_port.get_attribute('NFRAMES')
if 'NDIT' in self.m_data_in_port.get_all_non_static_attributes():
ndit = self.m_data_in_port.get_attribute('NDIT')
if not np.all(ndit == steps):
warnings.warn(
'There is a mismatch between the NDIT and NFRAMES values. The '
'parallactic angles are calculated with a linear interpolation by '
'using NFRAMES steps. A frame selection should be applied after '
'the parallactic angles are calculated.')
new_angles = []
start_time = time.time()
for i, _ in enumerate(parang_start):
progress(i, len(parang_start),
'Running AngleInterpolationModule...', start_time)
if parang_start[i] < -170. and parang_end[i] > 170.:
parang_start[i] += 360.
elif parang_end[i] < -170. and parang_start[i] > 170.:
parang_end[i] += 360.
if steps[i] == 1:
new_angles = np.append(
new_angles, [(parang_start[i] + parang_end[i]) / 2.])
elif steps[i] != 1:
new_angles = np.append(
new_angles,
np.linspace(parang_start[i], parang_end[i], num=steps[i]))
sys.stdout.write('Running AngleInterpolationModule... [DONE]\n')
sys.stdout.flush()
self.m_data_out_port.add_attribute('PARANG', new_angles, static=False)
def run(self):
"""
Run method of the module. Looks for all FITS files in the input directory and imports the
images into the database. Note that previous database information is overwritten if
``overwrite=True``. The filenames are stored as attributes.
Returns
-------
NoneType
None
"""
files = []
if isinstance(self.m_filenames, str):
files = self._txt_file_list()
location = os.getcwd()
elif isinstance(self.m_filenames, (list, tuple)):
files = self.m_filenames
location = os.getcwd()
elif isinstance(self.m_filenames, type(None)):
location = os.path.join(self.m_input_location, '')
for filename in os.listdir(location):
if filename.endswith(
'.fits') and not filename.startswith('._'):
files.append(filename)
assert (
files), 'No FITS files found in %s.' % self.m_input_location
files.sort()
overwrite_tags = []
for i, fits_file in enumerate(files):
progress(i, len(files), "Running FitsReadingModule...")
header, shape = self._read_single_file(fits_file, location,
overwrite_tags)
self._static_attributes(fits_file, header)
self._non_static_attributes(header)
self._extra_attributes(fits_file, location, shape)
self.m_image_out_port.flush()
sys.stdout.write("Running FitsReadingModule... [DONE]\n")
sys.stdout.flush()
self.m_image_out_port.close_port()
def run(self) -> None:
"""
Run method of the module. Removes every NDIT+1 frame and saves the data and attributes.
Returns
-------
NoneType
None
"""
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
ndit = self.m_image_in_port.get_attribute('NDIT')
nframes = self.m_image_in_port.get_attribute('NFRAMES')
index = self.m_image_in_port.get_attribute('INDEX')
nframes_new = []
index_new = []
start_time = time.time()
for i, item in enumerate(ndit):
progress(i, len(ndit),
'Removing the last image of each FITS cube...',
start_time)
if nframes[i] != item + 1:
warnings.warn(
f'Number of frames ({nframes[i]}) is not equal to NDIT+1.')
frame_start = np.sum(nframes[0:i])
frame_end = np.sum(nframes[0:i + 1]) - 1
nframes_new.append(nframes[i] - 1)
index_new.extend(index[frame_start:frame_end])
self.m_image_out_port.append(
self.m_image_in_port[frame_start:frame_end, ])
nframes_new = np.asarray(nframes_new, dtype=np.int)
index_new = np.asarray(index_new, dtype=np.int)
self.m_image_out_port.copy_attributes(self.m_image_in_port)
self.m_image_out_port.add_attribute('NFRAMES',
nframes_new,
static=False)
self.m_image_out_port.add_attribute('INDEX', index_new, static=False)
history = 'frames removed = NDIT+1'
self.m_image_out_port.add_history('RemoveLastFrameModule', history)
self.m_image_out_port.close_port()
def run(self):
"""
Run method of the module. Uses the NFRAMES attribute to select the images of each cube,
calculates the mean of each cube, and saves the data and attributes.
:return: None
"""
if self.m_image_in_port.tag == self.m_image_out_port.tag:
raise ValueError(
"Input and output port should have a different tag.")
non_static = self.m_image_in_port.get_all_non_static_attributes()
nframes = self.m_image_in_port.get_attribute("NFRAMES")
self.m_image_out_port.del_all_data()
self.m_image_out_port.del_all_attributes()
current = 0
for i, frames in enumerate(nframes):
progress(i, len(nframes), "Running MeanCubeModule...")
mean_frame = np.mean(self.m_image_in_port[current:current +
frames, ],
axis=0)
self.m_image_out_port.append(mean_frame, data_dim=3)
current += frames
sys.stdout.write("Running MeanCubeModule... [DONE]\n")
sys.stdout.flush()
nimages = np.size(nframes)
self.m_image_out_port.copy_attributes_from_input_port(
self.m_image_in_port)
if "INDEX" in non_static:
index = np.arange(0, nimages, 1, dtype=np.int)
self.m_image_out_port.add_attribute("INDEX", index, static=False)
if "NFRAMES" in non_static:
nframes = np.ones(nimages, dtype=np.int)
self.m_image_out_port.add_attribute("NFRAMES",
nframes,
static=False)
self.m_image_out_port.close_port()
def write_selected_data(memory: Union[int, np.int64],
indices: np.ndarray,
image_in_port: InputPort,
selected_out_port: Optional[OutputPort],
removed_out_port: Optional[OutputPort]) -> None:
"""
Function to write the selected and removed data.
Parameters
----------
memory : int
Number of images that is simultaneously loaded into the memory.
indices : numpy.ndarray
Image indices that will be removed.
image_in_port : pynpoint.core.dataio.InputPort
Port to the input images.
selected_out_port : pynpoint.core.dataio.OutputPort, None
Port to store the selected images. No data is written if set to None.
removed_out_port : pynpoint.core.dataio.OutputPort, None
Port to store the removed images. No data is written if set to None.
Returns
-------
NoneType
None
"""
nimages = image_in_port.get_shape()[0]
frames = memory_frames(memory, nimages)
if memory == 0 or memory >= nimages:
memory = nimages
start_time = time.time()
for i, _ in enumerate(frames[:-1]):
progress(i, len(frames[:-1]), 'Writing selected data...', start_time)
images = image_in_port[frames[i]:frames[i+1], ]
subset_del = np.where(np.logical_and(indices >= frames[i], indices < frames[i+1]))[0]
index_del = indices[subset_del] % memory
index_sel = np.ones(images.shape[0], np.bool)
index_sel[index_del] = False
if selected_out_port is not None and index_sel.size > 0:
selected_out_port.append(images[index_sel])
if removed_out_port is not None and index_del.size > 0:
removed_out_port.append(images[index_del])
def uncompress(self) -> None:
"""
Method to check if the input directory contains compressed files ending with .fits.Z.
If this is the case, the files will be uncompressed using multithreading. The number
of threads can be set with the ``CPU`` parameter in the configuration file.
Returns
-------
NoneType
None
"""
cpu = self._m_config_port.get_attribute('CPU')
# list all files ending with .fits.Z in the input location
files = []
for item in os.listdir(self.m_input_location):
if item.endswith('.fits.Z'):
files.append(os.path.join(self.m_input_location, item))
if files:
# subdivide the file indices by number of CPU
indices = memory_frames(cpu, len(files))
start_time = time.time()
for i, _ in enumerate(indices[:-1]):
progress(i, len(indices[:-1]), 'Uncompressing NEAR data...',
start_time)
# select subset of compressed files
subset = files[indices[i]:indices[i + 1]]
# create a list of threads to uncompress CPU number of files
# each file is processed by a different thread
threads = []
for filename in subset:
thread = threading.Thread(target=self._uncompress_file,
args=(filename, ))
threads.append(thread)
# start the threads
for item in threads:
item.start()
# join the threads
for item in threads:
item.join()
sys.stdout.write('Uncompressing NEAR data... [DONE]\n')
sys.stdout.flush()
