def rotationWrtHorizon(platepar):
""" Given the platepar, compute the rotation of the FOV with respect to the horizon.
Arguments:
pletepar: [Platepar object] Input platepar.
Return:
rot_angle: [float] Rotation w.r.t. horizon (degrees).
"""
# Image coordiantes of the center
img_mid_w = platepar.X_res / 2
img_mid_h = platepar.Y_res / 2
# Image coordinate slighty right of the center (horizontal)
img_up_w = img_mid_w + 10
img_up_h = img_mid_h
# Compute apparent alt/az in the epoch of date from X,Y
jd_arr, ra_arr, dec_arr, _ = xyToRaDecPP(2*[jd2Date(platepar.JD)], [img_mid_w, img_up_w], \
[img_mid_h, img_up_h], [1, 1], platepar, extinction_correction=False)
azim_mid, alt_mid = trueRaDec2ApparentAltAz(np.radians(ra_arr[0]), np.radians(dec_arr[0]), jd_arr[0], \
np.radians(platepar.lat), np.radians(platepar.lon), platepar.refraction)
azim_up, alt_up = trueRaDec2ApparentAltAz(np.radians(ra_arr[1]), np.radians(dec_arr[1]), jd_arr[1], \
np.radians(platepar.lat), np.radians(platepar.lon), platepar.refraction)
# Compute the rotation wrt horizon (deg)
rot_angle = np.degrees(np.arctan2(alt_up - alt_mid, azim_up - azim_mid))
# Wrap output to <-180, 180] range
if rot_angle > 180:
rot_angle -= 360
return rot_angle
def rotationWrtStandard(platepar):
""" Given the platepar, compute the rotation from the celestial meridian passing through the centre of
the FOV.
Arguments:
pletepar: [Platepar object] Input platepar.
Return:
rot_angle: [float] Rotation from the meridian (degrees).
"""
# Image coordiantes of the center
img_mid_w = platepar.X_res / 2
img_mid_h = platepar.Y_res / 2
# Image coordinate slighty right of the centre
img_up_w = img_mid_w + 10
img_up_h = img_mid_h
# Compute ra/dec
_, ra, dec, _ = xyToRaDecPP(2*[jd2Date(platepar.JD)], [img_mid_w, img_up_w], [img_mid_h, img_up_h], \
2*[1], platepar)
ra_mid = ra[0]
dec_mid = dec[0]
ra_up = ra[1]
dec_up = dec[1]
# Compute the equatorial orientation
rot_angle = np.degrees(np.arctan2(np.radians(dec_mid) - np.radians(dec_up), \
np.radians(ra_mid) - np.radians(ra_up)))
# Wrap output to 0-360 range
rot_angle = rot_angle % 360
return rot_angle
def computeFOVSize(platepar):
""" Computes the size of the FOV in deg from the given platepar.
Arguments:
platepar: [Platepar instance]
Return:
fov_h: [float] Horizontal FOV in degrees.
fov_v: [float] Vertical FOV in degrees.
"""
# Construct poinits on the middle of every side of the image
time_data = np.array(4 * [jd2Date(platepar.JD)])
x_data = np.array(
[0, platepar.X_res, platepar.X_res / 2, platepar.X_res / 2])
y_data = np.array(
[platepar.Y_res / 2, platepar.Y_res / 2, 0, platepar.Y_res])
level_data = np.ones(4)
# Compute RA/Dec of the points
_, ra_data, dec_data, _ = xyToRaDecPP(time_data, x_data, y_data,
level_data, platepar)
ra1, ra2, ra3, ra4 = ra_data
dec1, dec2, dec3, dec4 = dec_data
# Compute horizontal FOV
fov_h = np.degrees(angularSeparation(np.radians(ra1), np.radians(dec1), np.radians(ra2), \
np.radians(dec2)))
# Compute vertical FOV
fov_v = np.degrees(angularSeparation(np.radians(ra3), np.radians(dec3), np.radians(ra4), \
np.radians(dec4)))
return fov_h, fov_v
def loadFromDict(self, platepar_dict, use_flat=None):
""" Load the platepar from a dictionary. """
# Parse JSON into an object with attributes corresponding to dict keys
self.__dict__ = platepar_dict
# Add the version if it was not in the platepar (v1 platepars didn't have a version)
if not 'version' in self.__dict__:
self.version = 1
# Add UT correction if it was not in the platepar
if not 'UT_corr' in self.__dict__:
self.UT_corr = 0
# Add the gamma if it was not in the platepar
if not 'gamma' in self.__dict__:
self.gamma = 1.0
# Add the vignetting coefficient if it was not in the platepar
if not 'vignetting_coeff' in self.__dict__:
self.vignetting_coeff = None
# Add the default vignetting coeff
self.addVignettingCoeff(use_flat=use_flat)
# Add the list of calibration stars if it was not in the platepar
if not 'star_list' in self.__dict__:
self.star_list = []
# If v1 only the backward distorsion coeffs were fitted, so use load them for both forward and
# reverse if nothing else is available
if not 'x_poly_fwd' in self.__dict__:
self.x_poly_fwd = np.array(self.x_poly)
self.x_poly_rev = np.array(self.x_poly)
self.y_poly_fwd = np.array(self.y_poly)
self.y_poly_rev = np.array(self.y_poly)
# Convert lists to numpy arrays
self.x_poly_fwd = np.array(self.x_poly_fwd)
self.x_poly_rev = np.array(self.x_poly_rev)
self.y_poly_fwd = np.array(self.y_poly_fwd)
self.y_poly_rev = np.array(self.y_poly_rev)
# Set polynomial parameters used by the old code
self.x_poly = self.x_poly_fwd
self.y_poly = self.y_poly_fwd
# Add rotation from horizontal
if not 'rotation_from_horiz' in self.__dict__:
self.rotation_from_horiz = RMS.Astrometry.ApplyAstrometry.rotationWrtHorizon(self)
# Calculate the datetime
self.time = jd2Date(self.JD, dt_obj=True)
def loadFromDict(self, platepar_dict):
""" Load the platepar from a dictionary. """
# Parse JSON into an object with attributes corresponding to dict keys
self.__dict__ = platepar_dict
# Add the version if it was not in the platepar (v1 platepars didn't have a version)
if not 'version' in self.__dict__:
self.version = 1
# Add UT correction if it was not in the platepar
if not 'UT_corr' in self.__dict__:
self.UT_corr = 0
# Add the gamma if it was not in the platepar
if not 'gamma' in self.__dict__:
self.gamma = 1.0
# Add the list of calibration stars if it was not in the platepar
if not 'star_list' in self.__dict__:
self.star_list = []
# If v1 only the backward distorsion coeffs were fitted, so use load them for both forward and
# reverse if nothing else is available
if not 'x_poly_fwd' in self.__dict__:
self.x_poly_fwd = np.array(self.x_poly)
self.x_poly_rev = np.array(self.x_poly)
self.y_poly_fwd = np.array(self.y_poly)
self.y_poly_rev = np.array(self.y_poly)
# Convert lists to numpy arrays
self.x_poly_fwd = np.array(self.x_poly_fwd)
self.x_poly_rev = np.array(self.x_poly_rev)
self.y_poly_fwd = np.array(self.y_poly_fwd)
self.y_poly_rev = np.array(self.y_poly_rev)
# Set polynomial parameters used by the old code
self.x_poly = self.x_poly_fwd
self.y_poly = self.y_poly_fwd
# Add rotation from horizontal
if not 'rotation_from_horiz' in self.__dict__:
self.rotation_from_horiz = RMS.Astrometry.ApplyAstrometry.rotationWrtHorizon(self)
# Calculate the datetime
self.time = jd2Date(self.JD, dt_obj=True)
def extinctionCorrectionApparentToTrue(mags, x_data, y_data, jd, platepar):
""" Compute true magnitudes by applying extinction correction to apparent magnitudes.
Arguments:
mags: [list] A list of apparent magnitudes.
x_data: [list] A list of pixel columns.
y_data: [list] A list of pixel rows.
jd: [float] Julian date.
platepar: [Platepar object]
Return:
corrected_mags: [list] A list of extinction corrected mangitudes.
"""
### Compute star elevations above the horizon (epoch of date, true) ###
# Compute RA/Dec in J2000
_, ra_data, dec_data, _ = xyToRaDecPP(len(x_data)*[jd2Date(jd)], x_data, y_data, len(x_data)*[1], \
platepar, extinction_correction=False)
# Compute elevation above the horizon
elevation_data = []
for ra, dec in zip(ra_data, dec_data):
# Precess to epoch of date
ra, dec = equatorialCoordPrecession(J2000_JD.days, jd, np.radians(ra),
np.radians(dec))
# Compute elevation
_, elev = raDec2AltAz(np.degrees(ra), np.degrees(dec), jd,
platepar.lat, platepar.lon)
if elev < 0:
elev = 0
elevation_data.append(elev)
### ###
# Correct catalog magnitudes for extinction
extinction_correction = atmosphericExtinctionCorrection(np.array(elevation_data), platepar.elev) \
- atmosphericExtinctionCorrection(90, platepar.elev)
corrected_mags = np.array(
mags) - platepar.extinction_scale * extinction_correction
return corrected_mags
def getPairedStarsSkyPositions(img_x, img_y, jd, platepar):
""" Compute RA, Dec of all paired stars on the image given the platepar.
Arguments:
img_x: [ndarray] Array of column values of the stars.
img_y: [ndarray] Array of row values of the stars.
jd: [float] Julian date for transformation.
platepar: [Platepar instance] Platepar object.
Return:
(ra_array, dec_array): [tuple of ndarrays] Arrays of RA and Dec of stars on the image.
"""
# Compute RA, Dec of image stars
img_time = jd2Date(jd)
_, ra_array, dec_array, _ = xyToRaDecPP(len(img_x)*[img_time], img_x,
img_y, len(img_x)*[1], platepar, extinction_correction=False)
return ra_array, dec_array
def xyHt2Geo(platepar, x, y, area_ht, indicate_limit=False, elev_limit=5):
""" Given pixel coordiantes on the image and a height above sea level, compute geo coordiantes of the
point. The elevation is limited to 5 deg above horizon.
Arguments:
platepar: [Platepar object]
x: [float] Image X coordinate.
y: [float] Image Y coordiante.
area_ht: [float] Height above sea level (meters).
Keyword arguments:
indicate_limit: [bool] Indicate that the elevation was below the limit of 5 deg by setting the
height to -1. False by default.
elev_limit: [float] Limit of elevation above horizon (deg). 5 degrees by default.
Return:
(r, lat, lon, ht): [tuple of floats] range in meters, latitude and longitude in degrees, \
WGS84 height in meters
"""
# Compute RA/Dec in J2000 of the image point, at J2000 epoch time so we don't have to precess
_, ra, dec, _ = xyToRaDecPP([jd2Date(J2000_JD.days)], [x], [y], [1], platepar, \
extinction_correction=False)
# Compute alt/az of the point
azim, elev = raDec2AltAz(ra[0], dec[0], J2000_JD.days, platepar.lat,
platepar.lon)
# Limit the elevation to elev_limit degrees above the horizon
limit_hit = False
if elev < elev_limit:
elev = elev_limit
limit_hit = True
# Compute the geo location of the point along the line of sight
p_r, p_lat, p_lon, p_ht = AEH2LatLonAlt(azim, elev, area_ht, platepar.lat, platepar.lon, \
platepar.elev)
# If the elevation limit was hit, and the indicate flag is True, set the elevation to -1
if indicate_limit and limit_hit:
p_ht = -1
return p_r, p_lat, p_lon, p_ht
def computeFOVSize(platepar):
""" Computes the size of the FOV in deg from the given platepar.
Arguments:
platepar: [Platepar instance]
Return:
fov_h: [float] Horizontal FOV in degrees.
fov_v: [float] Vertical FOV in degrees.
"""
# Construct poinits on the middle of every side of the image
x_data = np.array([
0, platepar.X_res, platepar.X_res / 2, platepar.X_res / 2,
platepar.X_res / 2.0
])
y_data = np.array([
platepar.Y_res / 2, platepar.Y_res / 2, 0, platepar.Y_res,
platepar.Y_res / 2.0
])
time_data = np.array(len(x_data) * [jd2Date(platepar.JD)])
level_data = np.ones(len(x_data))
# Compute RA/Dec of the points
_, ra_data, dec_data, _ = xyToRaDecPP(time_data, x_data, y_data, level_data, platepar, \
extinction_correction=False)
ra1, ra2, ra3, ra4, ra_mid = ra_data
dec1, dec2, dec3, dec4, dec_mid = dec_data
# Compute horizontal FOV
fov_hl = np.degrees(angularSeparation(np.radians(ra1), np.radians(dec1), np.radians(ra_mid), \
np.radians(dec_mid)))
fov_hr = np.degrees(angularSeparation(np.radians(ra2), np.radians(dec2), np.radians(ra_mid), \
np.radians(dec_mid)))
fov_h = fov_hl + fov_hr
# Compute vertical FOV
fov_vu = np.degrees(angularSeparation(np.radians(ra3), np.radians(dec3), np.radians(ra_mid), \
np.radians(dec_mid)))
fov_vd = np.degrees(angularSeparation(np.radians(ra4), np.radians(dec4), np.radians(ra_mid), \
np.radians(dec_mid)))
fov_v = fov_vu + fov_vd
return fov_h, fov_v
def getFOVSelectionRadius(platepar):
""" Get a radius around the centre of the FOV which includes the FOV, but excludes stars outside the FOV.
Arguments:
platepar: [Platepar instance]
Return:
fov_radius: [float] Radius in degrees.
"""
# Construct poinits on the middle of every side of the image
x_data = np.array(
[0, platepar.X_res, platepar.X_res, 0, platepar.X_res / 2.0])
y_data = np.array(
[0, platepar.Y_res, 0, platepar.Y_res, platepar.Y_res / 2.0])
time_data = np.array(len(x_data) * [jd2Date(platepar.JD)])
level_data = np.ones(len(x_data))
# Compute RA/Dec of the points
_, ra_data, dec_data, _ = xyToRaDecPP(time_data, x_data, y_data, level_data, platepar, \
extinction_correction=False)
ra1, ra2, ra3, ra4, ra_mid = ra_data
dec1, dec2, dec3, dec4, dec_mid = dec_data
# Angular separation between the centre of the FOV and corners
ul_sep = np.degrees(
angularSeparation(np.radians(ra1), np.radians(dec1),
np.radians(ra_mid), np.radians(dec_mid)))
lr_sep = np.degrees(
angularSeparation(np.radians(ra2), np.radians(dec2),
np.radians(ra_mid), np.radians(dec_mid)))
ur_sep = np.degrees(
angularSeparation(np.radians(ra3), np.radians(dec3),
np.radians(ra_mid), np.radians(dec_mid)))
ll_sep = np.degrees(
angularSeparation(np.radians(ra4), np.radians(dec4),
np.radians(ra_mid), np.radians(dec_mid)))
# Take the average radius
fov_radius = np.mean([ul_sep, lr_sep, ur_sep, ll_sep])
return fov_radius
def updateAzAltGrid(grid, platepar):
"""
Updates the values of grid to form an azimuth and altitude grid on a pyqtgraph plot.
Arguments:
grid: [pg.PlotCurveItem]
platepar: [Platepar object]
"""
### COMPUTE FOV CENTRE ###
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(platepar.JD)], [platepar.X_res/2], [platepar.Y_res/2], [1], \
platepar, extinction_correction=False)
# Compute alt/az of FOV centre
azim_centre, alt_centre = trueRaDec2ApparentAltAz(RA_c[0], dec_c[0], platepar.JD, platepar.lat, \
platepar.lon)
### ###
# Compute FOV size
fov_radius = getFOVSelectionRadius(platepar)
# Determine gridline frequency (double the gridlines if the number is < 4eN)
grid_freq = 10**np.floor(np.log10(2 * fov_radius))
if 10**(np.log10(2 * fov_radius) - np.floor(np.log10(2 * fov_radius))) < 4:
grid_freq /= 2
# Set a maximum grid frequency of 15 deg
if grid_freq > 15:
grid_freq = 15
# Grid plot density
plot_dens = grid_freq / 100
# Generate a grid of all azimuths and altitudes
alt_grid_arr = np.arange(0, 90, grid_freq)
az_grid_arr = np.arange(0, 360, grid_freq)
x = []
y = []
cuts = []
# Altitude lines
for alt_grid in alt_grid_arr:
# Keep the altitude fixed and plot all azimuth lines
az_grid_plot = np.arange(0, 360, plot_dens)
alt_grid_plot = np.zeros_like(az_grid_plot) + alt_grid
# Filter out all lines outside the FOV
filter_arr = np.degrees(angularSeparation(np.radians(azim_centre), np.radians(alt_centre), \
np.radians(az_grid_plot), np.radians(alt_grid_plot))) <= fov_radius
az_grid_plot = az_grid_plot[filter_arr]
alt_grid_plot = alt_grid_plot[filter_arr]
# Compute image coordinates
ra_grid_plot, dec_grid_plot = apparentAltAz2TrueRADec(az_grid_plot, alt_grid_plot, platepar.JD, \
platepar.lat, platepar.lon, platepar.refraction)
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, platepar.JD,
platepar)
# Filter out all points outside the image
filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (
y_grid >= 0) & (y_grid <= platepar.Y_res)
x_grid = x_grid[filter_arr]
y_grid = y_grid[filter_arr]
x.extend(x_grid)
y.extend(y_grid)
cuts.append(len(x) - 1)
# Azimuth lines
for az_grid in az_grid_arr:
# Keep the azimuth fixed and plot all altitude lines
alt_grid_plot = np.arange(0, 90 + plot_dens, plot_dens)
az_grid_plot = np.zeros_like(alt_grid_plot) + az_grid
# Filter out all lines outside the FOV
filter_arr = np.degrees(angularSeparation(np.radians(azim_centre), np.radians(alt_centre), \
np.radians(az_grid_plot), np.radians(alt_grid_plot))) <= fov_radius
az_grid_plot = az_grid_plot[filter_arr]
alt_grid_plot = alt_grid_plot[filter_arr]
# Compute image coordinates
ra_grid_plot, dec_grid_plot = apparentAltAz2TrueRADec(az_grid_plot, alt_grid_plot, platepar.JD, \
platepar.lat, platepar.lon, platepar.refraction)
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, platepar.JD,
platepar)
# Filter out all points outside the image
filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (
y_grid >= 0) & (y_grid <= platepar.Y_res)
x_grid = x_grid[filter_arr]
y_grid = y_grid[filter_arr]
x.extend(x_grid)
y.extend(y_grid)
cuts.append(len(x) - 1)
r = 15 # adjust this parameter if you see extraneous lines
# disconnect lines that are distant (unfinished circles had straight lines completing them)
for i in range(len(x) - 1):
if (x[i] - x[i + 1])**2 + (y[i] - y[i + 1])**2 > r**2:
cuts.append(i)
connect = np.full(len(x), 1)
for i in cuts[:-1]:
connect[i] = 0
grid.setData(x=x, y=y, connect=connect)
def generateCalibrationReport(config, night_dir_path, match_radius=2.0, platepar=None, show_graphs=False):
""" Given the folder of the night, find the Calstars file, check the star fit and generate a report
with the quality of the calibration. The report contains information about both the astrometry and
the photometry calibration. Graphs will be saved in the given directory of the night.
Arguments:
config: [Config instance]
night_dir_path: [str] Full path to the directory of the night.
Keyword arguments:
match_radius: [float] Match radius for star matching between image and catalog stars (px).
platepar: [Platepar instance] Use this platepar instead of finding one in the folder.
show_graphs: [bool] Show the graphs on the screen. False by default.
Return:
None
"""
# Find the CALSTARS file in the given folder
calstars_file = None
for calstars_file in os.listdir(night_dir_path):
if ('CALSTARS' in calstars_file) and ('.txt' in calstars_file):
break
if calstars_file is None:
print('CALSTARS file could not be found in the given directory!')
return None
# Load the calstars file
star_list = readCALSTARS(night_dir_path, calstars_file)
### Load recalibrated platepars, if they exist ###
# Find recalibrated platepars file per FF file
platepars_recalibrated_file = None
for file_name in os.listdir(night_dir_path):
if file_name == config.platepars_recalibrated_name:
platepars_recalibrated_file = file_name
break
# Load all recalibrated platepars if the file is available
recalibrated_platepars = None
if platepars_recalibrated_file:
with open(os.path.join(night_dir_path, platepars_recalibrated_file)) as f:
recalibrated_platepars = json.load(f)
print('Loaded recalibrated platepars JSON file for the calibration report...')
### ###
### Load the platepar file ###
# Find the platepar file in the given directory if it was not given
if platepar is None:
# Find the platepar file
platepar_file = None
for file_name in os.listdir(night_dir_path):
if file_name == config.platepar_name:
platepar_file = file_name
break
if platepar_file is None:
print('The platepar cannot be found in the night directory!')
return None
# Load the platepar file
platepar = Platepar()
platepar.read(os.path.join(night_dir_path, platepar_file))
### ###
night_name = os.path.split(night_dir_path.strip(os.sep))[1]
# Go one mag deeper than in the config
lim_mag = config.catalog_mag_limit + 1
# Load catalog stars (load one magnitude deeper)
catalog_stars, mag_band_str, config.star_catalog_band_ratios = StarCatalog.readStarCatalog(\
config.star_catalog_path, config.star_catalog_file, lim_mag=lim_mag, \
mag_band_ratios=config.star_catalog_band_ratios)
### Take only those CALSTARS entires for which FF files exist in the folder ###
# Get a list of FF files in the folder\
ff_list = []
for file_name in os.listdir(night_dir_path):
if validFFName(file_name):
ff_list.append(file_name)
# Filter out calstars entries, generate a star dictionary where the keys are JDs of FFs
star_dict = {}
ff_dict = {}
for entry in star_list:
ff_name, star_data = entry
# Check if the FF from CALSTARS exists in the folder
if ff_name not in ff_list:
continue
dt = getMiddleTimeFF(ff_name, config.fps, ret_milliseconds=True)
jd = date2JD(*dt)
# Add the time and the stars to the dict
star_dict[jd] = star_data
ff_dict[jd] = ff_name
### ###
# If there are no FF files in the directory, don't generate a report
if len(star_dict) == 0:
print('No FF files from the CALSTARS file in the directory!')
return None
# If the recalibrated platepars file exists, take the one with the most stars
max_jd = 0
if recalibrated_platepars is not None:
max_stars = 0
for ff_name_temp in recalibrated_platepars:
# Compute the Julian date of the FF middle
dt = getMiddleTimeFF(ff_name_temp, config.fps, ret_milliseconds=True)
jd = date2JD(*dt)
# Check that this file exists in CALSTARS and the list of FF files
if (jd not in star_dict) or (jd not in ff_dict):
continue
# Check if the number of stars on this FF file is larger than the before
if len(star_dict[jd]) > max_stars:
max_jd = jd
max_stars = len(star_dict[jd])
# Set a flag to indicate if using recalibrated platepars has failed
if max_jd == 0:
using_recalib_platepars = False
else:
print('Using recalibrated platepars, file:', ff_dict[max_jd])
using_recalib_platepars = True
# Select the platepar where the FF file has the most stars
platepar_dict = recalibrated_platepars[ff_dict[max_jd]]
platepar = Platepar()
platepar.loadFromDict(platepar_dict)
filtered_star_dict = {max_jd: star_dict[max_jd]}
# Match stars on the image with the stars in the catalog
n_matched, avg_dist, cost, matched_stars = matchStarsResiduals(config, platepar, catalog_stars, \
filtered_star_dict, match_radius, ret_nmatch=True, lim_mag=lim_mag)
max_matched_stars = n_matched
# Otherwise take the optimal FF file for evaluation
if (recalibrated_platepars is None) or (not using_recalib_platepars):
# If there are more than a set number of FF files to evaluate, choose only the ones with most stars on
# the image
if len(star_dict) > config.calstars_files_N:
# Find JDs of FF files with most stars on them
top_nstars_indices = np.argsort([len(x) for x in star_dict.values()])[::-1][:config.calstars_files_N \
- 1]
filtered_star_dict = {}
for i in top_nstars_indices:
filtered_star_dict[list(star_dict.keys())[i]] = list(star_dict.values())[i]
star_dict = filtered_star_dict
# Match stars on the image with the stars in the catalog
n_matched, avg_dist, cost, matched_stars = matchStarsResiduals(config, platepar, catalog_stars, \
star_dict, match_radius, ret_nmatch=True, lim_mag=lim_mag)
# If no recalibrated platepars where found, find the image with the largest number of matched stars
if (not using_recalib_platepars) or (max_jd == 0):
max_jd = 0
max_matched_stars = 0
for jd in matched_stars:
_, _, distances = matched_stars[jd]
if len(distances) > max_matched_stars:
max_jd = jd
max_matched_stars = len(distances)
# If there are no matched stars, use the image with the largest number of detected stars
if max_matched_stars <= 2:
max_jd = max(star_dict, key=lambda x: len(star_dict[x]))
distances = [np.inf]
# Take the FF file with the largest number of matched stars
ff_name = ff_dict[max_jd]
# Load the FF file
ff = readFF(night_dir_path, ff_name)
img_h, img_w = ff.avepixel.shape
dpi = 200
plt.figure(figsize=(ff.avepixel.shape[1]/dpi, ff.avepixel.shape[0]/dpi), dpi=dpi)
# Take the average pixel
img = ff.avepixel
# Slightly adjust the levels
img = Image.adjustLevels(img, np.percentile(img, 1.0), 1.2, np.percentile(img, 99.99))
plt.imshow(img, cmap='gray', interpolation='nearest')
legend_handles = []
# Plot detected stars
for img_star in star_dict[max_jd]:
y, x, _, _ = img_star
rect_side = 5*match_radius
square_patch = plt.Rectangle((x - rect_side/2, y - rect_side/2), rect_side, rect_side, color='g', \
fill=False, label='Image stars')
plt.gca().add_artist(square_patch)
legend_handles.append(square_patch)
# If there are matched stars, plot them
if max_matched_stars > 2:
# Take the solution with the largest number of matched stars
image_stars, matched_catalog_stars, distances = matched_stars[max_jd]
# Plot matched stars
for img_star in image_stars:
x, y, _, _ = img_star
circle_patch = plt.Circle((y, x), radius=3*match_radius, color='y', fill=False, \
label='Matched stars')
plt.gca().add_artist(circle_patch)
legend_handles.append(circle_patch)
### Plot match residuals ###
# Compute preducted positions of matched image stars from the catalog
x_predicted, y_predicted = raDecToXYPP(matched_catalog_stars[:, 0], \
matched_catalog_stars[:, 1], max_jd, platepar)
img_y, img_x, _, _ = image_stars.T
delta_x = x_predicted - img_x
delta_y = y_predicted - img_y
# Compute image residual and angle of the error
res_angle = np.arctan2(delta_y, delta_x)
res_distance = np.sqrt(delta_x**2 + delta_y**2)
# Calculate coordinates of the beginning of the residual line
res_x_beg = img_x + 3*match_radius*np.cos(res_angle)
res_y_beg = img_y + 3*match_radius*np.sin(res_angle)
# Calculate coordinates of the end of the residual line
res_x_end = img_x + 100*np.cos(res_angle)*res_distance
res_y_end = img_y + 100*np.sin(res_angle)*res_distance
# Plot the 100x residuals
for i in range(len(x_predicted)):
res_plot = plt.plot([res_x_beg[i], res_x_end[i]], [res_y_beg[i], res_y_end[i]], color='orange', \
lw=0.5, label='100x residuals')
legend_handles.append(res_plot[0])
### ###
else:
distances = [np.inf]
# If there are no matched stars, plot large text in the middle of the screen
plt.text(img_w/2, img_h/2, "NO MATCHED STARS!", color='r', alpha=0.5, fontsize=20, ha='center',
va='center')
### Plot positions of catalog stars to the limiting magnitude of the faintest matched star + 1 mag ###
# Find the faintest magnitude among matched stars
if max_matched_stars > 2:
faintest_mag = np.max(matched_catalog_stars[:, 2]) + 1
else:
# If there are no matched stars, use the limiting magnitude from config
faintest_mag = config.catalog_mag_limit + 1
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(max_jd)], [platepar.X_res/2], [platepar.Y_res/2], [1],
platepar)
RA_c = RA_c[0]
dec_c = dec_c[0]
fov_radius = np.hypot(*computeFOVSize(platepar))
# Get stars from the catalog around the defined center in a given radius
_, extracted_catalog = subsetCatalog(catalog_stars, RA_c, dec_c, fov_radius, faintest_mag)
ra_catalog, dec_catalog, mag_catalog = extracted_catalog.T
# Compute image positions of all catalog stars that should be on the image
x_catalog, y_catalog = raDecToXYPP(ra_catalog, dec_catalog, max_jd, platepar)
# Filter all catalog stars outside the image
temp_arr = np.c_[x_catalog, y_catalog, mag_catalog]
temp_arr = temp_arr[temp_arr[:, 0] >= 0]
temp_arr = temp_arr[temp_arr[:, 0] <= ff.avepixel.shape[1]]
temp_arr = temp_arr[temp_arr[:, 1] >= 0]
temp_arr = temp_arr[temp_arr[:, 1] <= ff.avepixel.shape[0]]
x_catalog, y_catalog, mag_catalog = temp_arr.T
# Plot catalog stars on the image
cat_stars_handle = plt.scatter(x_catalog, y_catalog, c='none', marker='D', lw=1.0, alpha=0.4, \
s=((4.0 + (faintest_mag - mag_catalog))/3.0)**(2*2.512), edgecolor='r', label='Catalog stars')
legend_handles.append(cat_stars_handle)
### ###
# Add info text
info_text = ff_dict[max_jd] + '\n' \
+ "Matched stars: {:d}/{:d}\n".format(max_matched_stars, len(star_dict[max_jd])) \
+ "Median distance: {:.2f} px\n".format(np.median(distances)) \
+ "Catalog limiting magnitude: {:.1f}".format(lim_mag)
plt.text(10, 10, info_text, bbox=dict(facecolor='black', alpha=0.5), va='top', ha='left', fontsize=4, \
color='w')
legend = plt.legend(handles=legend_handles, prop={'size': 4}, loc='upper right')
legend.get_frame().set_facecolor('k')
legend.get_frame().set_edgecolor('k')
for txt in legend.get_texts():
txt.set_color('w')
plt.axis('off')
plt.gca().get_xaxis().set_visible(False)
plt.gca().get_yaxis().set_visible(False)
plt.xlim([0, ff.avepixel.shape[1]])
plt.ylim([ff.avepixel.shape[0], 0])
# Remove the margins
plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
plt.savefig(os.path.join(night_dir_path, night_name + '_calib_report_astrometry.jpg'), \
bbox_inches='tight', pad_inches=0, dpi=dpi)
if show_graphs:
plt.show()
else:
plt.clf()
plt.close()
if max_matched_stars > 2:
### Plot the photometry ###
plt.figure(dpi=dpi)
# Take only those stars which are inside the 3/4 of the shorter image axis from the center
photom_selection_radius = np.min([img_h, img_w])/3
filter_indices = ((image_stars[:, 0] - img_h/2)**2 + (image_stars[:, 1] \
- img_w/2)**2) <= photom_selection_radius**2
star_intensities = image_stars[filter_indices, 2]
catalog_mags = matched_catalog_stars[filter_indices, 2]
# Plot intensities of image stars
#star_intensities = image_stars[:, 2]
plt.scatter(-2.5*np.log10(star_intensities), catalog_mags, s=5, c='r')
# Fit the photometry on automated star intensities
photom_offset, fit_stddev, _ = photometryFit(np.log10(star_intensities), catalog_mags)
# Plot photometric offset from the platepar
x_min, x_max = plt.gca().get_xlim()
y_min, y_max = plt.gca().get_ylim()
x_min_w = x_min - 3
x_max_w = x_max + 3
y_min_w = y_min - 3
y_max_w = y_max + 3
photometry_info = 'Platepar: {:+.2f}LSP {:+.2f} +/- {:.2f} \nGamma = {:.2f}'.format(platepar.mag_0, \
platepar.mag_lev, platepar.mag_lev_stddev, platepar.gamma)
# Plot the photometry calibration from the platepar
logsum_arr = np.linspace(x_min_w, x_max_w, 10)
plt.plot(logsum_arr, logsum_arr + platepar.mag_lev, label=photometry_info, linestyle='--', \
color='k', alpha=0.5)
# Plot the fitted photometry calibration
fit_info = "Fit: {:+.2f}LSP {:+.2f} +/- {:.2f}".format(-2.5, photom_offset, fit_stddev)
plt.plot(logsum_arr, logsum_arr + photom_offset, label=fit_info, linestyle='--', color='red',
alpha=0.5)
plt.legend()
plt.ylabel("Catalog magnitude ({:s})".format(mag_band_str))
plt.xlabel("Uncalibrated magnitude")
# Set wider axis limits
plt.xlim(x_min_w, x_max_w)
plt.ylim(y_min_w, y_max_w)
plt.gca().invert_yaxis()
plt.gca().invert_xaxis()
plt.grid()
plt.savefig(os.path.join(night_dir_path, night_name + '_calib_report_photometry.png'), dpi=150)
if show_graphs:
plt.show()
else:
plt.clf()
plt.close()
def writeEv(dir_path,
file_name,
ev_array,
plate,
multi,
ast_input=False,
vidinfo=None):
""" Write an UWO ASGARD style event file.
Arguments:
dir_path: [str] Path to directory where the file will be saved to.
file_name: [str] Name of the ev file.
ev_array: [ndarray] Array where columns are: frame number, sequence number, JD, intensity, x, y,
azimuth (deg), altitude (deg), magnitude
plate: [?] Platepar or AST plate.
multi: identifier for simultaneous detections, 0 = 'A', 1 = 'B', etc.
Keyword arguments:
ast_input: [bool] True if AST plate if given, False if platepar is given (default).
vidinfo: [?] metadata from a UWO .vid file, if available
"""
# ASGARD default site if we can't get a matching site number from another source
site = 0
stream = 'Z'
# AST plate used for input
if ast_input:
# AST files don't populate the 'st' field so we can't get site info from here
# station_code = plate.sitename
lat = np.degrees(plate.lat)
lon = np.degrees(plate.lon)
elev = plate.elev
X_res = plate.wid
Y_res = plate.ht
text = plate.sitename
plate_text = plate.text
# Platepar used for input
else:
station_code = plate.station_code
lat = plate.lat
lon = plate.lon
elev = plate.elev
X_res = plate.X_res
Y_res = plate.Y_res
text = ''
plate_text = 'RMS_SkyFit'
# valid ASGARD site ids can only be exactly two digits followed by one letter (ex. 02A)
# if the first two characters are digits, use that as the site number
# if the third character is a letter, use that as the stream, otherwise fall back on 'A'
# if the station code doesn't match at all, use the defaults
if len(station_code) == 3:
if station_code[:2].isdigit() and station_code[2].isalpha():
site = station_code[:2]
stream = station_code[2].upper()
elif len(station_code) == 2:
if station_code[:2].isdigit():
site = station_code[:2]
stream = 'A'
# If a .vid file was used and we have vidinfo, prefer site info and descriptive text from
# the .vid file itself
if vidinfo is not None:
site = vidinfo.station_id
stream = chr(ord('A') + vidinfo.str_num)
text = vidinfo.text
with open(os.path.join(dir_path, file_name), 'w') as f:
frame_array, seq_array, jd_array, intensity_array, x_array, y_array, azim_array, alt_array, \
mag_array = ev_array.T
seq_array = seq_array.astype(np.uint32)
# Get the Julian date of the peak
jd_peak = jd_array[mag_array.argmin()]
# Get the sequence number of the peak
seq_peak = int(seq_array[mag_array.argmin()])
### Write the header
f.write('#\n')
f.write('# version : RMS_Detection\n')
f.write("# num_fr : {:d}\n".format(len(ev_array)))
f.write("# num_tr : 0\n")
f.write("# time : {:s} UTC\n".format(
jd2Date(jd_peak, dt_obj=True).strftime('%Y%m%d %H:%M:%S.%f')[:-3]))
f.write("# unix : {:.6f}\n".format(jd2UnixTime(jd_peak)))
f.write("# ntp : LOCK 0 0 0\n")
f.write("# seq : {:d}\n".format(seq_peak))
f.write("# mul : {:d} [{:c}]\n".format(multi, ord('A') + multi))
f.write("# site : {:02d}\n".format(site))
f.write("# latlon : {:.4f} {:.4f} {:.1f}\n".format(lat, lon, elev))
f.write("# text : {:s}\n".format(text))
f.write("# stream : {:s}\n".format(stream))
f.write("# plate : {:s}\n".format(plate_text))
f.write("# geom : {:d} {:d}\n".format(X_res, Y_res))
f.write("# filter : 0\n")
f.write("#\n")
f.write(
"# fr time sum seq cx cy th phi lsp mag flag bak max\n"
)
###
# Go through all centroids and write them to file
for i, entry in enumerate(ev_array):
frame, seq_num, jd, intensity, x, y, azim, alt, mag = entry
# Compute the relative time in seconds
t_rel = (jd - jd_peak) * 86400
# Compute theta and phi
theta = 90 - alt
phi = (90 - azim) % 360
f.write("{:5d} {:7.3f} {:10d} {:7d} {:8.3f} {:8.3f} {:7.3f} {:8.3f} {:7.3f} {:6.2f} 0000 0.0 0.0\n".format(int(31 + int(seq_num) - seq_array[0]), \
t_rel, int(intensity), int(seq_num), x, y, theta, phi, -2.5*np.log10(intensity), mag))
def updateRaDecGrid(grid, platepar):
"""
Updates the values of grid to form a right ascension and declination grid
Arguments:
grid: [pg.PlotCurveItem]
platepar: [Platepar object]
"""
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(platepar.JD)],
[platepar.X_res / 2], [platepar.Y_res / 2],
[1],
platepar,
extinction_correction=False)
# azim_centre, alt_centre = trueRaDec2ApparentAltAz(RA_c, dec_c, platepar.JD, platepar.lat, platepar.lon)
# Compute FOV size
fov_radius = np.hypot(*computeFOVSize(platepar))
# Determine gridline frequency (double the gridlines if the number is < 4eN)
grid_freq = 10**np.floor(np.log10(fov_radius))
if 10**(np.log10(fov_radius) - np.floor(np.log10(fov_radius))) < 4:
grid_freq /= 2
# Set a maximum grid frequency of 15 deg
if grid_freq > 15:
grid_freq = 15
# Grid plot density
plot_dens = grid_freq / 100
ra_grid_arr = np.arange(0, 360, grid_freq)
dec_grid_arr = np.arange(-90, 90, grid_freq)
x = []
y = []
cuts = []
# Plot the celestial parallel grid (circles)
for dec_grid in dec_grid_arr:
ra_grid_plot = np.arange(0, 360, plot_dens)
dec_grid_plot = np.zeros_like(ra_grid_plot) + dec_grid
# Compute alt/az
az_grid_plot, alt_grid_plot = trueRaDec2ApparentAltAz(
ra_grid_plot, dec_grid_plot, platepar.JD, platepar.lat,
platepar.lon, platepar.refraction)
# Filter out points below the horizon and outside the FOV
filter_arr = (alt_grid_plot > 0) # & (angularSeparation(alt_centre,
# azim_centre,
# alt_grid_plot,
# az_grid_plot) < fov_radius)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Compute image coordinates for every grid celestial parallel
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, platepar.JD,
platepar)
filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (
y_grid >= 0) & (y_grid <= platepar.Y_res)
x_grid = x_grid[filter_arr]
y_grid = y_grid[filter_arr]
x.extend(x_grid)
y.extend(y_grid)
cuts.append(len(x) - 1)
# Plot the celestial meridian grid (outward lines)
for ra_grid in ra_grid_arr:
dec_grid_plot = np.arange(-90, 90, plot_dens) # how close to horizon
ra_grid_plot = np.zeros_like(dec_grid_plot) + ra_grid
# Compute alt/az
az_grid_plot, alt_grid_plot = trueRaDec2ApparentAltAz(
ra_grid_plot, dec_grid_plot, platepar.JD, platepar.lat,
platepar.lon, platepar.refraction)
# Filter out points below the horizon
filter_arr = (alt_grid_plot > 0) #& (angularSeparation(alt_centre,
# azim_centre,
# alt_grid_plot,
# az_grid_plot) < fov_radius)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Compute image coordinates for every grid celestial parallel
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, platepar.JD,
platepar)
filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (
y_grid >= 0) & (y_grid <= platepar.Y_res)
x_grid = x_grid[filter_arr]
y_grid = y_grid[filter_arr]
x.extend(x_grid)
y.extend(y_grid)
cuts.append(len(x) - 1)
# horizon
az_horiz_arr = np.arange(0, 360, plot_dens)
alt_horiz_arr = np.zeros_like(az_horiz_arr)
ra_horiz_plot, dec_horiz_plot = apparentAltAz2TrueRADec(
az_horiz_arr, alt_horiz_arr, platepar.JD, platepar.lat, platepar.lon,
platepar.refraction)
x_horiz, y_horiz = raDecToXYPP(ra_horiz_plot, dec_horiz_plot, platepar.JD,
platepar)
filter_arr = (x_horiz >= 0) & (x_horiz <= platepar.X_res) & (
y_horiz >= 0) & (y_horiz <= platepar.Y_res)
x_horiz = x_horiz[filter_arr]
y_horiz = y_horiz[filter_arr]
x.extend(x_horiz)
y.extend(y_horiz)
cuts.append(len(x) - 1)
r = 15 # adjust this parameter if you see extraneous lines
# disconnect lines that are distant (unfinished circles had straight lines completing them)
for i in range(len(x) - 1):
if (x[i] - x[i + 1])**2 + (y[i] - y[i + 1])**2 > r**2:
cuts.append(i)
# convert cuts into connect
connect = np.full(len(x), 1)
if len(connect) > 0:
for i in cuts:
connect[i] = 0
grid.setData(x=x, y=y, connect=connect)
def updateRaDecGrid(grid, platepar):
"""
Updates the values of grid to form a right ascension and declination grid on a pyqtgraph plot.
Arguments:
grid: [pg.PlotCurveItem]
platepar: [Platepar object]
"""
### COMPUTE FOV CENTRE ###
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(platepar.JD)], [platepar.X_res/2], [platepar.Y_res/2], [1], \
platepar, extinction_correction=False)
# Compute alt/az of FOV centre
azim_centre, alt_centre = trueRaDec2ApparentAltAz(RA_c[0], dec_c[0], platepar.JD, platepar.lat, \
platepar.lon)
### ###
# Compute FOV size
fov_radius = getFOVSelectionRadius(platepar)
# Determine gridline frequency (double the gridlines if the number is < 4eN)
grid_freq = 10**np.floor(np.log10(2 * fov_radius))
if 10**(np.log10(2 * fov_radius) - np.floor(np.log10(2 * fov_radius))) < 4:
grid_freq /= 2
# Set a maximum grid frequency of 15 deg
if grid_freq > 15:
grid_freq = 15
# Grid plot density
plot_dens = grid_freq / 100
# Make an array of RA and Dec
ra_grid_arr = np.arange(0, 360, grid_freq)
dec_grid_arr = np.arange(-90, 90, grid_freq)
x = []
y = []
cuts = []
# Generate points for the celestial parallels grid
for dec_grid in dec_grid_arr:
# Keep the declination fixed and evaluate all right ascensions
ra_grid_plot = np.arange(0, 360, plot_dens)
dec_grid_plot = np.zeros_like(ra_grid_plot) + dec_grid
# Compute alt/az
az_grid_plot, alt_grid_plot = trueRaDec2ApparentAltAz(ra_grid_plot, dec_grid_plot, platepar.JD, \
platepar.lat, platepar.lon, platepar.refraction)
# Filter out points below the horizon and outside the FOV
filter_arr = (alt_grid_plot >= 0) & (np.degrees(angularSeparation(np.radians(azim_centre), \
np.radians(alt_centre), np.radians(az_grid_plot), np.radians(alt_grid_plot))) <= fov_radius)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Compute image coordinates for every grid celestial parallel
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, platepar.JD,
platepar)
# Filter out all points outside the image
filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (
y_grid >= 0) & (y_grid <= platepar.Y_res)
x_grid = x_grid[filter_arr]
y_grid = y_grid[filter_arr]
# Add points to the list
x.extend(x_grid)
y.extend(y_grid)
cuts.append(len(x) - 1)
# Generate points for the celestial meridian grid
for ra_grid in ra_grid_arr:
# Keep the RA fixed and evaluate all declinations
dec_grid_plot = np.arange(-90, 90 + plot_dens, plot_dens)
ra_grid_plot = np.zeros_like(dec_grid_plot) + ra_grid
# Compute alt/az
az_grid_plot, alt_grid_plot = trueRaDec2ApparentAltAz(ra_grid_plot, dec_grid_plot, platepar.JD, \
platepar.lat, platepar.lon, platepar.refraction)
# Filter out points below the horizon
filter_arr = (alt_grid_plot >= 0) & (np.degrees(angularSeparation(np.radians(azim_centre), \
np.radians(alt_centre), np.radians(az_grid_plot), np.radians(alt_grid_plot))) <= fov_radius)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Compute image coordinates for every grid celestial parallel
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, platepar.JD,
platepar)
# Filter out points outside the image
filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (
y_grid >= 0) & (y_grid <= platepar.Y_res)
x_grid = x_grid[filter_arr]
y_grid = y_grid[filter_arr]
x.extend(x_grid)
y.extend(y_grid)
cuts.append(len(x) - 1)
# Generate points for the horizon
az_horiz_arr = np.arange(0, 360, plot_dens)
alt_horiz_arr = np.zeros_like(az_horiz_arr)
ra_horiz_plot, dec_horiz_plot = apparentAltAz2TrueRADec(az_horiz_arr, alt_horiz_arr, platepar.JD, \
platepar.lat, platepar.lon, platepar.refraction)
# Filter out all horizon points outside the FOV
filter_arr = np.degrees(angularSeparation(np.radians(alt_centre), np.radians(azim_centre), \
np.radians(alt_horiz_arr), np.radians(az_horiz_arr))) <= fov_radius
ra_horiz_plot = ra_horiz_plot[filter_arr]
dec_horiz_plot = dec_horiz_plot[filter_arr]
# Compute image coordinates of the horizon
x_horiz, y_horiz = raDecToXYPP(ra_horiz_plot, dec_horiz_plot, platepar.JD,
platepar)
# Filter out all horizon points outside the image
filter_arr = (x_horiz >= 0) & (x_horiz <= platepar.X_res) & (
y_horiz >= 0) & (y_horiz <= platepar.Y_res)
x_horiz = x_horiz[filter_arr]
y_horiz = y_horiz[filter_arr]
x.extend(x_horiz)
y.extend(y_horiz)
cuts.append(len(x) - 1)
r = 15 # adjust this parameter if you see extraneous lines
# disconnect lines that are distant (unfinished circles had straight lines completing them)
for i in range(len(x) - 1):
if (x[i] - x[i + 1])**2 + (y[i] - y[i + 1])**2 > r**2:
cuts.append(i)
# convert cuts into connect
connect = np.full(len(x), 1)
if len(connect) > 0:
for i in cuts:
connect[i] = 0
grid.setData(x=x, y=y, connect=connect)
def computeFlux(config, dir_path, ftpdetectinfo_path, shower_code, dt_beg, dt_end, timebin, mass_index, \
timebin_intdt=0.25, ht_std_percent=5.0, mask=None):
""" Compute flux using measurements in the given FTPdetectinfo file.
Arguments:
config: [Config instance]
dir_path: [str] Path to the working directory.
ftpdetectinfo_path: [str] Path to a FTPdetectinfo file.
shower_code: [str] IAU shower code (e.g. ETA, PER, SDA).
dt_beg: [Datetime] Datetime object of the observation beginning.
dt_end: [Datetime] Datetime object of the observation end.
timebin: [float] Time bin in hours.
mass_index: [float] Cumulative mass index of the shower.
Keyword arguments:
timebin_intdt: [float] Time step for computing the integrated collection area in hours. 15 minutes by
default. If smaller than that, only one collection are will be computed.
ht_std_percent: [float] Meteor height standard deviation in percent.
mask: [Mask object] Mask object, None by default.
"""
# Get a list of files in the night folder
file_list = sorted(os.listdir(dir_path))
# Find and load the platepar file
if config.platepar_name in file_list:
# Load the platepar
platepar = Platepar.Platepar()
platepar.read(os.path.join(dir_path, config.platepar_name), use_flat=config.use_flat)
else:
print("Cannot find the platepar file in the night directory: ", config.platepar_name)
return None
# # Load FTPdetectinfos
# meteor_data = []
# for ftpdetectinfo_path in ftpdetectinfo_list:
# if not os.path.isfile(ftpdetectinfo_path):
# print('No such file:', ftpdetectinfo_path)
# continue
# meteor_data += readFTPdetectinfo(*os.path.split(ftpdetectinfo_path))
# Load meteor data from the FTPdetectinfo file
meteor_data = readFTPdetectinfo(*os.path.split(ftpdetectinfo_path))
if not len(meteor_data):
print("No meteors in the FTPdetectinfo file!")
return None
# Find and load recalibrated platepars
if config.platepars_recalibrated_name in file_list:
with open(os.path.join(dir_path, config.platepars_recalibrated_name)) as f:
recalibrated_platepars_dict = json.load(f)
print("Recalibrated platepars loaded!")
# If the file is not available, apply the recalibration procedure
else:
recalibrated_platepars_dict = applyRecalibrate(ftpdetectinfo_path, config)
print("Recalibrated platepar file not available!")
print("Recalibrating...")
# Convert the dictionary of recalibrated platepars to a dictionary of Platepar objects
recalibrated_platepars = {}
for ff_name in recalibrated_platepars_dict:
pp = Platepar.Platepar()
pp.loadFromDict(recalibrated_platepars_dict[ff_name], use_flat=config.use_flat)
recalibrated_platepars[ff_name] = pp
# Compute nighly mean of the photometric zero point
mag_lev_nightly_mean = np.mean([recalibrated_platepars[ff_name].mag_lev \
for ff_name in recalibrated_platepars])
# Locate and load the mask file
if config.mask_file in file_list:
mask_path = os.path.join(dir_path, config.mask_file)
mask = loadMask(mask_path)
print("Using mask:", mask_path)
else:
print("No mask used!")
mask = None
# Compute the population index using the classical equation
population_index = 10**((mass_index - 1)/2.5)
### SENSOR CHARACTERIZATION ###
# Computes FWHM of stars and noise profile of the sensor
# File which stores the sensor characterization profile
sensor_characterization_file = "flux_sensor_characterization.json"
sensor_characterization_path = os.path.join(dir_path, sensor_characterization_file)
# Load sensor characterization file if present, so the procedure can be skipped
if os.path.isfile(sensor_characterization_path):
# Load the JSON file
with open(sensor_characterization_path) as f:
data = " ".join(f.readlines())
sensor_data = json.loads(data)
# Remove the info entry
if '-1' in sensor_data:
del sensor_data['-1']
else:
# Run sensor characterization
sensor_data = sensorCharacterization(config, dir_path)
# Save to file for posterior use
with open(sensor_characterization_path, 'w') as f:
# Add an explanation what each entry means
sensor_data_save = dict(sensor_data)
sensor_data_save['-1'] = {"FF file name": ['median star FWHM', 'median background noise stddev']}
# Convert collection areas to JSON
out_str = json.dumps(sensor_data_save, indent=4, sort_keys=True)
# Save to disk
f.write(out_str)
# Compute the nighly mean FWHM and noise stddev
fwhm_nightly_mean = np.mean([sensor_data[key][0] for key in sensor_data])
stddev_nightly_mean = np.mean([sensor_data[key][1] for key in sensor_data])
### ###
# Perform shower association
associations, shower_counts = showerAssociation(config, [ftpdetectinfo_path], shower_code=shower_code, \
show_plot=False, save_plot=False, plot_activity=False)
# If there are no shower association, return nothing
if not associations:
print("No meteors associated with the shower!")
return None
# Print the list of used meteors
peak_mags = []
for key in associations:
meteor, shower = associations[key]
if shower is not None:
# Compute peak magnitude
peak_mag = np.min(meteor.mag_array)
peak_mags.append(peak_mag)
print("{:.6f}, {:3s}, {:+.2f}".format(meteor.jdt_ref, shower.name, peak_mag))
print()
# Init the flux configuration
flux_config = FluxConfig()
### COMPUTE COLLECTION AREAS ###
# Make a file name to save the raw collection areas
col_areas_file_name = generateColAreaJSONFileName(platepar.station_code, flux_config.side_points, \
flux_config.ht_min, flux_config.ht_max, flux_config.dht, flux_config.elev_limit)
# Check if the collection area file exists. If yes, load the data. If not, generate collection areas
if col_areas_file_name in os.listdir(dir_path):
col_areas_ht = loadRawCollectionAreas(dir_path, col_areas_file_name)
print("Loaded collection areas from:", col_areas_file_name)
else:
# Compute the collecting areas segments per height
col_areas_ht = collectingArea(platepar, mask=mask, side_points=flux_config.side_points, \
ht_min=flux_config.ht_min, ht_max=flux_config.ht_max, dht=flux_config.dht, \
elev_limit=flux_config.elev_limit)
# Save the collection areas to file
saveRawCollectionAreas(dir_path, col_areas_file_name, col_areas_ht)
print("Saved raw collection areas to:", col_areas_file_name)
### ###
# Compute the pointing of the middle of the FOV
_, ra_mid, dec_mid, _ = xyToRaDecPP([jd2Date(J2000_JD.days)], [platepar.X_res/2], [platepar.Y_res/2], \
[1], platepar, extinction_correction=False)
azim_mid, elev_mid = raDec2AltAz(ra_mid[0], dec_mid[0], J2000_JD.days, platepar.lat, platepar.lon)
# Compute the range to the middle point
ref_ht = 100000
r_mid, _, _, _ = xyHt2Geo(platepar, platepar.X_res/2, platepar.Y_res/2, ref_ht, indicate_limit=True, \
elev_limit=flux_config.elev_limit)
### Compute the average angular velocity to which the flux variation throught the night will be normalized
# The ang vel is of the middle of the FOV in the middle of observations
# Middle Julian date of the night
jd_night_mid = (datetime2JD(dt_beg) + datetime2JD(dt_end))/2
# Compute the apparent radiant
ra, dec, v_init = shower.computeApparentRadiant(platepar.lat, platepar.lon, jd_night_mid)
# Compute the radiant elevation
radiant_azim, radiant_elev = raDec2AltAz(ra, dec, jd_night_mid, platepar.lat, platepar.lon)
# Compute the angular velocity in the middle of the FOV
rad_dist_night_mid = angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev),
np.radians(azim_mid), np.radians(elev_mid))
ang_vel_night_mid = v_init*np.sin(rad_dist_night_mid)/r_mid
###
# Compute the average limiting magnitude to which all flux will be normalized
# Standard deviation of star PSF, nightly mean (px)
star_stddev = fwhm_nightly_mean/2.355
# Compute the theoretical stellar limiting magnitude (nightly average)
star_sum = 2*np.pi*(config.k1_det*stddev_nightly_mean + config.j1_det)*star_stddev**2
lm_s_nightly_mean = -2.5*np.log10(star_sum) + mag_lev_nightly_mean
# A meteor needs to be visible on at least 4 frames, thus it needs to have at least 4x the mass to produce
# that amount of light. 1 magnitude difference scales as -0.4 of log of mass, thus:
frame_min_loss = np.log10(config.line_minimum_frame_range_det)/(-0.4)
lm_s_nightly_mean += frame_min_loss
# Compute apparent meteor magnitude
lm_m_nightly_mean = lm_s_nightly_mean - 5*np.log10(r_mid/1e5) - 2.5*np.log10( \
np.degrees(platepar.F_scale*v_init*np.sin(rad_dist_night_mid)/(config.fps*r_mid*fwhm_nightly_mean)) \
)
#
print("Stellar lim mag using detection thresholds:", lm_s_nightly_mean)
print("Apparent meteor limiting magnitude:", lm_m_nightly_mean)
### Apply time-dependent corrections ###
sol_data = []
flux_lm_6_5_data = []
# Go through all time bins within the observation period
total_time_hrs = (dt_end - dt_beg).total_seconds()/3600
nbins = int(np.ceil(total_time_hrs/timebin))
for t_bin in range(nbins):
# Compute bin start and end time
bin_dt_beg = dt_beg + datetime.timedelta(hours=timebin*t_bin)
bin_dt_end = bin_dt_beg + datetime.timedelta(hours=timebin)
if bin_dt_end > dt_end:
bin_dt_end = dt_end
# Compute bin duration in hours
bin_hours = (bin_dt_end - bin_dt_beg).total_seconds()/3600
# Convert to Julian date
bin_jd_beg = datetime2JD(bin_dt_beg)
bin_jd_end = datetime2JD(bin_dt_end)
# Only select meteors in this bin
bin_meteors = []
bin_ffs = []
for key in associations:
meteor, shower = associations[key]
if shower is not None:
if (shower.name == shower_code) and (meteor.jdt_ref > bin_jd_beg) \
and (meteor.jdt_ref <= bin_jd_end):
bin_meteors.append([meteor, shower])
bin_ffs.append(meteor.ff_name)
if len(bin_meteors) > 0:
### Compute the radiant elevation at the middle of the time bin ###
jd_mean = (bin_jd_beg + bin_jd_end)/2
# Compute the mean solar longitude
sol_mean = np.degrees(jd2SolLonSteyaert(jd_mean))
print()
print()
print("-- Bin information ---")
print("Bin beg:", bin_dt_beg)
print("Bin end:", bin_dt_end)
print("Sol mid: {:.5f}".format(sol_mean))
print("Meteors:", len(bin_meteors))
# Compute the apparent radiant
ra, dec, v_init = shower.computeApparentRadiant(platepar.lat, platepar.lon, jd_mean)
# Compute the mean meteor height
meteor_ht_beg = heightModel(v_init, ht_type='beg')
meteor_ht_end = heightModel(v_init, ht_type='end')
meteor_ht = (meteor_ht_beg + meteor_ht_end)/2
# Compute the standard deviation of the height
meteor_ht_std = meteor_ht*ht_std_percent/100.0
# Init the Gaussian height distribution
meteor_ht_gauss = scipy.stats.norm(meteor_ht, meteor_ht_std)
# Compute the radiant elevation
radiant_azim, radiant_elev = raDec2AltAz(ra, dec, jd_mean, platepar.lat, platepar.lon)
### ###
### Weight collection area by meteor height distribution ###
# Determine weights for each height
weight_sum = 0
weights = {}
for ht in col_areas_ht:
wt = meteor_ht_gauss.pdf(float(ht))
weight_sum += wt
weights[ht] = wt
# Normalize the weights so that the sum is 1
for ht in weights:
weights[ht] /= weight_sum
### ###
# Compute the angular velocity in the middle of the FOV
rad_dist_mid = angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev),
np.radians(azim_mid), np.radians(elev_mid))
ang_vel_mid = v_init*np.sin(rad_dist_mid)/r_mid
### Compute the limiting magnitude ###
# Compute the mean star FWHM in the given bin
fwhm_bin_mean = np.mean([sensor_data[ff_name][0] for ff_name in bin_ffs])
# Compute the mean background stddev in the given bin
stddev_bin_mean = np.mean([sensor_data[ff_name][1] for ff_name in bin_ffs])
# Compute the mean photometric zero point in the given bin
mag_lev_bin_mean = np.mean([recalibrated_platepars[ff_name].mag_lev for ff_name in bin_ffs if ff_name in recalibrated_platepars])
# Standard deviation of star PSF, nightly mean (px)
star_stddev = fwhm_bin_mean/2.355
# Compute the theoretical stellar limiting magnitude (nightly average)
star_sum = 2*np.pi*(config.k1_det*stddev_bin_mean + config.j1_det)*star_stddev**2
lm_s = -2.5*np.log10(star_sum) + mag_lev_bin_mean
lm_s += frame_min_loss
# Compute apparent meteor magnitude
lm_m = lm_s - 5*np.log10(r_mid/1e5) - 2.5*np.log10( \
np.degrees(platepar.F_scale*v_init*np.sin(rad_dist_mid)/(config.fps*r_mid*fwhm_bin_mean))\
)
### ###
# Final correction area value (height-weightned)
collection_area = 0
# Go through all heights and segment blocks
for ht in col_areas_ht:
for img_coords in col_areas_ht[ht]:
x_mean, y_mean = img_coords
# Unpack precomputed values
area, azim, elev, sensitivity_ratio, r = col_areas_ht[ht][img_coords]
# Compute the angular velocity (rad/s) in the middle of this block
rad_dist = angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev),
np.radians(azim), np.radians(elev))
ang_vel = v_init*np.sin(rad_dist)/r
# Compute the range correction
range_correction = (1e5/r)**2
#ang_vel_correction = ang_vel/ang_vel_mid
# Compute angular velocity correction relative to the nightly mean
ang_vel_correction = ang_vel/ang_vel_night_mid
### Apply corrections
correction_ratio = 1.0
# Correct the area for vignetting and extinction
correction_ratio *= sensitivity_ratio
# Correct for the range
correction_ratio *= range_correction
# Correct for the radiant elevation
correction_ratio *= np.sin(np.radians(radiant_elev))
# Correct for angular velocity
correction_ratio *= ang_vel_correction
# Add the collection area to the final estimate with the height weight
# Raise the correction to the mass index power
collection_area += weights[ht]*area*correction_ratio**(mass_index - 1)
# Compute the flux at the bin LM (meteors/1000km^2/h)
flux = 1e9*len(bin_meteors)/collection_area/bin_hours
# Compute the flux scaled to the nightly mean LM
flux_lm_nightly_mean = flux*population_index**(lm_m_nightly_mean - lm_m)
# Compute the flux scaled to +6.5M
flux_lm_6_5 = flux*population_index**(6.5 - lm_m)
print("-- Sensor information ---")
print("Star FWHM: {:5.2f} px".format(fwhm_bin_mean))
print("Bkg stddev: {:4.1f} ADU".format(stddev_bin_mean))
print("Photom ZP: {:+6.2f} mag".format(mag_lev_bin_mean))
print("Stellar LM: {:+.2f} mag".format(lm_s))
print("-- Flux ---")
print("Col area: {:d} km^2".format(int(collection_area/1e6)))
print("Ang vel: {:.2f} deg/s".format(np.degrees(ang_vel_mid)))
print("LM app: {:+.2f} mag".format(lm_m))
print("Flux: {:.2f} meteors/1000km^2/h".format(flux))
print("to {:+.2f}: {:.2f} meteors/1000km^2/h".format(lm_m_nightly_mean, flux_lm_nightly_mean))
print("to +6.50: {:.2f} meteors/1000km^2/h".format(flux_lm_6_5))
sol_data.append(sol_mean)
flux_lm_6_5_data.append(flux_lm_6_5)
# Print the results
print("Solar longitude, Flux at LM +6.5:")
for sol, flux_lm_6_5 in zip(sol_data, flux_lm_6_5_data):
print("{:9.5f}, {:8.4f}".format(sol, flux_lm_6_5))
# Plot a histogram of peak magnitudes
plt.hist(peak_mags, cumulative=True)
plt.show()
def matchStarsResiduals(config,
platepar,
catalog_stars,
star_dict,
match_radius,
ret_nmatch=False):
""" Match the image and catalog stars with the given astrometry solution and estimate the residuals
between them.
Arguments:
config: [Config structure]
platepar: [Platepar structure] Astrometry parameters.
catalog_stars: [ndarray] An array of catalog stars (ra, dec, mag).
star_dict: [ndarray] A dictionary where the keys are JDs when the stars were recorded and values are
2D list of stars, each entry is (X, Y, bg_level, level).
match_radius: [float] Maximum radius for star matching (pixels).
min_matched_stars: [int] Minimum number of matched stars on the image for the image to be accepted.
Keyword arguments:
ret_nmatch: [bool] If True, the function returns the number of matched stars and the average
deviation. False by defualt.
Return:
cost: [float] The cost function which weights the number of matched stars and the average deviation.
"""
# Estimate the FOV radius
fov_w = platepar.X_res / platepar.F_scale
fov_h = platepar.Y_res / platepar.F_scale
fov_radius = np.sqrt((fov_w / 2)**2 + (fov_h / 2)**2)
# print('fscale', platepar.F_scale)
# print('FOV w:', fov_w)
# print('FOV h:', fov_h)
# print('FOV radius:', fov_radius)
# Dictionary containing the matched stars, the keys are JDs of every image
matched_stars = {}
# Go through every FF image and its stars
for jd in star_dict:
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = XY2CorrectedRADecPP([jd2Date(jd)],
[platepar.X_res / 2],
[platepar.Y_res / 2], [0],
platepar)
RA_c = RA_c[0]
dec_c = dec_c[0]
# Get stars from the catalog around the defined center in a given radius
_, extracted_catalog = subsetCatalog(catalog_stars, RA_c, dec_c,
fov_radius,
config.catalog_mag_limit)
ra_catalog, dec_catalog, mag_catalog = extracted_catalog.T
# Extract stars for the given Julian date
stars_list = star_dict[jd]
stars_list = np.array(stars_list)
# Convert all catalog stars to image coordinates
cat_x_array, cat_y_array = raDecToCorrectedXYPP(
ra_catalog, dec_catalog, jd, platepar)
# Take only those stars which are within the FOV
x_indices = np.argwhere((cat_x_array >= 0)
& (cat_x_array < platepar.X_res))
y_indices = np.argwhere((cat_y_array >= 0)
& (cat_y_array < platepar.Y_res))
cat_good_indices = np.intersect1d(x_indices,
y_indices).astype(np.uint32)
# cat_x_array = cat_x_array[good_indices]
# cat_y_array = cat_y_array[good_indices]
# # Plot image stars
# im_y, im_x, _, _ = stars_list.T
# plt.scatter(im_y, im_x, facecolors='none', edgecolor='g')
# # Plot catalog stars
# plt.scatter(cat_y_array[cat_good_indices], cat_x_array[cat_good_indices], c='r', s=20, marker='+')
# plt.show()
# Match image and catalog stars
matched_indices = matchStars(stars_list, cat_x_array, cat_y_array,
cat_good_indices, match_radius)
# Skip this image is no stars were matched
if len(matched_indices) < config.min_matched_stars:
continue
matched_indices = np.array(matched_indices)
matched_img_inds, matched_cat_inds, dist_list = matched_indices.T
# Extract data from matched stars
matched_img_stars = stars_list[matched_img_inds.astype(np.int)]
matched_cat_stars = extracted_catalog[matched_cat_inds.astype(np.int)]
# Put the matched stars to a dictionary
matched_stars[jd] = [matched_img_stars, matched_cat_stars, dist_list]
# # Plot matched stars
# im_y, im_x, _, _ = matched_img_stars.T
# cat_y = cat_y_array[matched_cat_inds.astype(np.int)]
# cat_x = cat_x_array[matched_cat_inds.astype(np.int)]
# plt.scatter(im_x, im_y, c='r', s=5)
# plt.scatter(cat_x, cat_y, facecolors='none', edgecolor='g')
# plt.xlim([0, platepar.X_res])
# plt.ylim([platepar.Y_res, 0])
# plt.show()
# Extract all distances
global_dist_list = []
# level_list = []
# mag_list = []
for jd in matched_stars:
# matched_img_stars, matched_cat_stars, dist_list = matched_stars[jd]
_, _, dist_list = matched_stars[jd]
global_dist_list += dist_list.tolist()
# # TEST
# level_list += matched_img_stars[:, 3].tolist()
# mag_list += matched_cat_stars[:, 2].tolist()
# # Plot levels vs. magnitudes
# plt.scatter(mag_list, np.log10(level_list))
# plt.xlabel('Magnitude')
# plt.ylabel('Log10 level')
# plt.show()
# Number of matched stars
n_matched = len(global_dist_list)
if n_matched == 0:
if ret_nmatch:
return 0, 9999.0, 9999.0, {}
else:
return 9999.0
# Calculate the average distance
avg_dist = np.mean(global_dist_list)
cost = (avg_dist**2) * (1.0 / np.sqrt(n_matched + 1))
print('Matched {:d} stars with radius of {:.2f} px'.format(
n_matched, match_radius))
print('Avg dist', avg_dist)
print('Cost:', cost)
print('-----')
if ret_nmatch:
return n_matched, avg_dist, cost, matched_stars
else:
return cost
def alignPlatepar(config, platepar, calstars_time, calstars_coords, scale_update=False, show_plot=False):
""" Align the platepar using FFT registration between catalog stars and the given list of image stars.
Arguments:
config:
platepar: [Platepar instance] Initial platepar.
calstars_time: [list] A list of (year, month, day, hour, minute, second, millisecond) of the middle of
the FF file used for alignment.
calstars_coords: [ndarray] A 2D numpy array of (x, y) coordinates of image stars.
Keyword arguments:
scale_update: [bool] Update the platepar scale. False by default.
show_plot: [bool] Show the comparison between the reference and image synthetic images.
Return:
platepar_aligned: [Platepar instance] The aligned platepar.
"""
# Try to optimize the catalog limiting magnitude until the number of image and catalog stars are matched
maxiter = 10
search_fainter = True
mag_step = 0.2
for inum in range(maxiter):
# Load the catalog stars
catalog_stars, _, _ = StarCatalog.readStarCatalog(config.star_catalog_path, config.star_catalog_file, \
lim_mag=config.catalog_mag_limit, mag_band_ratios=config.star_catalog_band_ratios)
# Get the RA/Dec of the image centre
_, ra_centre, dec_centre, _ = ApplyAstrometry.xyToRaDecPP([calstars_time], [platepar.X_res/2], \
[platepar.Y_res/2], [1], platepar)
ra_centre = ra_centre[0]
dec_centre = dec_centre[0]
# Calculate the FOV radius in degrees
fov_y, fov_x = ApplyAstrometry.computeFOVSize(platepar)
fov_radius = np.sqrt(fov_x**2 + fov_y**2)
# Take only those stars which are inside the FOV
filtered_indices, _ = subsetCatalog(catalog_stars, ra_centre, dec_centre, \
fov_radius, config.catalog_mag_limit)
# Take those catalog stars which should be inside the FOV
ra_catalog, dec_catalog, _ = catalog_stars[filtered_indices].T
jd = date2JD(*calstars_time)
catalog_xy = ApplyAstrometry.raDecToXYPP(ra_catalog, dec_catalog, jd, platepar)
catalog_x, catalog_y = catalog_xy
catalog_xy = np.c_[catalog_x, catalog_y]
# Cut all stars that are outside image coordinates
catalog_xy = catalog_xy[catalog_xy[:, 0] > 0]
catalog_xy = catalog_xy[catalog_xy[:, 0] < config.width]
catalog_xy = catalog_xy[catalog_xy[:, 1] > 0]
catalog_xy = catalog_xy[catalog_xy[:, 1] < config.height]
# If there are more catalog than image stars, this means that the limiting magnitude is too faint
# and that the search should go in the brighter direction
if len(catalog_xy) > len(calstars_coords):
search_fainter = False
else:
search_fainter = True
# print('Catalog stars:', len(catalog_xy), 'Image stars:', len(calstars_coords), \
# 'Limiting magnitude:', config.catalog_mag_limit)
# Search in mag_step magnitude steps
if search_fainter:
config.catalog_mag_limit += mag_step
else:
config.catalog_mag_limit -= mag_step
print('Final catalog limiting magnitude:', config.catalog_mag_limit)
# Find the transform between the image coordinates and predicted platepar coordinates
res = findStarsTransform(config, calstars_coords, catalog_xy, show_plot=show_plot)
angle, scale, translation_x, translation_y = res
### Update the platepar ###
platepar_aligned = copy.deepcopy(platepar)
# Correct the rotation
platepar_aligned.pos_angle_ref = (platepar_aligned.pos_angle_ref - angle)%360
# Update the scale if needed
if scale_update:
platepar_aligned.F_scale *= scale
# Compute the new reference RA and Dec
# _, ra_centre_new, dec_centre_new, _ = ApplyAstrometry.xyToRaDecPP([jd2Date(platepar.JD)], \
# [platepar.X_res/2 - translation_x], [platepar.Y_res/2 - translation_y], [1], platepar)
_, ra_centre_new, dec_centre_new, _ = ApplyAstrometry.xyToRaDecPP([jd2Date(platepar.JD)], \
[platepar.X_res/2 - platepar.x_poly_fwd[0] - translation_x], \
[platepar.Y_res/2 - platepar.y_poly_fwd[0] - translation_y], [1], platepar)
# Correct RA/Dec
platepar_aligned.RA_d = ra_centre_new[0]
platepar_aligned.dec_d = dec_centre_new[0]
# # Update the reference time and hour angle
# platepar_aligned.JD = jd
# platepar_aligned.Ho = JD2HourAngle(jd)
# Recompute the FOV centre in Alt/Az and update the rotation
platepar_aligned.az_centre, platepar_aligned.alt_centre = ApplyAstrometry.raDec2AltAz(platepar.JD, \
platepar.lon, platepar.lat, platepar.RA_d, platepar.dec_d)
platepar_aligned.rotation_from_horiz = ApplyAstrometry.rotationWrtHorizon(platepar_aligned)
# Indicate that the platepar has been automatically updated
platepar_aligned.auto_check_fit_refined = True
###
return platepar_aligned
def write(self, file_path, fmt=None):
""" Write platepar to file.
Arguments:
file_path: [str] Path and the name of the platepar to write.
Keyword arguments:
fmt: [str] Format of the platepar file. 'json' for JSON format and 'txt' for the usual CMN textual
format. The format is JSON by default.
Return:
fmt: [str]
"""
# Set JSON to be the defualt format
if fmt is None:
fmt = 'json'
# If the format is JSON, write a JSON file
if fmt == 'json':
# Make a copy of the platepar object, which will be modified for writing
self2 = copy.deepcopy(self)
# Convert numpy arrays to list, which can be serialized
self2.x_poly = self.x_poly.tolist()
self2.y_poly = self.y_poly.tolist()
del self2.time
out_str = json.dumps(self2,
default=lambda o: o.__dict__,
indent=4,
sort_keys=True)
with open(file_path, 'w') as f:
f.write(out_str)
else:
with open(file_path, 'w') as f:
# Write geo coords
f.write('{:9.6f} {:9.6f} {:04d}\n'.format(
self.lon, self.lat, int(self.elev)))
# Calculate referent time from referent JD
Y, M, D, h, m, s, ms = list(map(int, jd2Date(self.JD)))
# Write the referent time
f.write('{:02d} {:02d} {:04d} {:02d} {:02d} {:02d}\n'.format(
D, M, Y, h, m, s))
# Write resolution and focal length
f.write('{:d} {:d} {:f}\n'.format(int(self.X_res),
int(self.Y_res),
self.focal_length))
# Write referent RA
self.RA_H = int(self.RA_d / 15)
self.RA_M = int((self.RA_d / 15 - self.RA_H) * 60)
self.RA_S = int(
((self.RA_d / 15 - self.RA_H) * 60 - self.RA_M) * 60)
f.write("{:7.3f} {:02d} {:02d} {:02d}\n".format(
self.RA_d, self.RA_H, self.RA_M, self.RA_S))
# Write referent Dec
self.dec_D = int(self.dec_d)
self.dec_M = int((self.dec_d - self.dec_D) * 60)
self.dec_S = int(
((self.dec_d - self.dec_D) * 60 - self.dec_M) * 60)
f.write("{:+7.3f} {:02d} {:02d} {:02d}\n".format(
self.dec_d, self.dec_D, self.dec_M, self.dec_S))
# Write rotation parameter
f.write('{:<7.3f}\n'.format(self.pos_angle_ref))
# Write F scale
f.write('{:<5.1f}\n'.format(3600 / self.F_scale))
# Write magnitude fit
f.write("{:.3f} {:.3f}\n".format(self.mag_0, self.mag_lev))
# Write X distorsion polynomial
for x_elem in self.x_poly:
f.write('{:+E}\n'.format(x_elem))
# Write y distorsion polynomial
for y_elem in self.y_poly:
f.write('{:+E}\n'.format(y_elem))
# Write station code
f.write(str(self.station_code) + '\n')
return fmt
def write(self, file_path, fmt=None, fov=None, ret_written=False):
""" Write platepar to file.
Arguments:
file_path: [str] Path and the name of the platepar to write.
Keyword arguments:
fmt: [str] Format of the platepar file. 'json' for JSON format and 'txt' for the usual CMN textual
format. The format is JSON by default.
fov: [tuple] Tuple of horizontal and vertical FOV size in degree. None by default.
ret_written: [bool] If True, the JSON string of the platepar instead of writing it to disk.
Return:
fmt: [str] Platepar format.
"""
# If the FOV size was given, store it
if fov is not None:
self.fov_h, self.fov_v = fov
# Set JSON to be the defualt format
if fmt is None:
fmt = 'json'
# If the format is JSON, write a JSON file
if fmt == 'json':
out_str = self.jsonStr()
with open(file_path, 'w') as f:
f.write(out_str)
if ret_written:
return fmt, out_str
else:
with open(file_path, 'w') as f:
# Write geo coords
f.write('{:9.6f} {:9.6f} {:04d}\n'.format(self.lon, self.lat, int(self.elev)))
# Calculate reference time from reference JD
Y, M, D, h, m, s, ms = list(map(int, jd2Date(self.JD)))
# Write the reference time
f.write('{:02d} {:02d} {:04d} {:02d} {:02d} {:02d}\n'.format(D, M, Y, h, m, s))
# Write resolution and focal length
f.write('{:d} {:d} {:f}\n'.format(int(self.X_res), int(self.Y_res), self.focal_length))
# Write reference RA
self.RA_H = int(self.RA_d/15)
self.RA_M = int((self.RA_d/15 - self.RA_H)*60)
self.RA_S = int(((self.RA_d/15 - self.RA_H)*60 - self.RA_M)*60)
f.write("{:7.3f} {:02d} {:02d} {:02d}\n".format(self.RA_d, self.RA_H, self.RA_M, self.RA_S))
# Write reference Dec
self.dec_D = int(self.dec_d)
self.dec_M = int((self.dec_d - self.dec_D)*60)
self.dec_S = int(((self.dec_d - self.dec_D)*60 - self.dec_M)*60)
f.write("{:+7.3f} {:02d} {:02d} {:02d}\n".format(self.dec_d, self.dec_D, self.dec_M, self.dec_S))
# Write rotation parameter
f.write('{:<7.3f}\n'.format(self.pos_angle_ref))
# Write F scale
f.write('{:<5.1f}\n'.format(3600/self.F_scale))
# Write magnitude fit
f.write("{:.3f} {:.3f}\n".format(self.mag_0, self.mag_lev))
# Write X distorsion polynomial
for x_elem in self.x_poly_fwd:
f.write('{:+E}\n'.format(x_elem))
# Write y distorsion polynomial
for y_elem in self.y_poly_fwd:
f.write('{:+E}\n'.format(y_elem))
# Write station code
f.write(str(self.station_code) + '\n')
if ret_written:
with open(file_path) as f:
out_str = "\n".join(f.readlines())
return fmt, out_str
return fmt
def matchStarsResiduals(config, platepar, catalog_stars, star_dict, match_radius, ret_nmatch=False, \
sky_coords=False, lim_mag=None, verbose=False):
""" Match the image and catalog stars with the given astrometry solution and estimate the residuals
between them.
Arguments:
config: [Config structure]
platepar: [Platepar structure] Astrometry parameters.
catalog_stars: [ndarray] An array of catalog stars (ra, dec, mag).
star_dict: [ndarray] A dictionary where the keys are JDs when the stars were recorded and values are
2D list of stars, each entry is (X, Y, bg_level, level, fwhm).
match_radius: [float] Maximum radius for star matching (pixels).
min_matched_stars: [int] Minimum number of matched stars on the image for the image to be accepted.
Keyword arguments:
ret_nmatch: [bool] If True, the function returns the number of matched stars and the average
deviation. False by default.
sky_coords: [bool] If True, sky coordinate residuals in RA, dec will be used to compute the cost,
function, not image coordinates.
lim_mag: [float] Override the limiting magnitude from config. None by default.
verbose: [bool] Print results. True by default.
Return:
cost: [float] The cost function which weights the number of matched stars and the average deviation.
"""
if lim_mag is None:
lim_mag = config.catalog_mag_limit
# Estimate the FOV radius
fov_radius = getFOVSelectionRadius(platepar)
# Dictionary containing the matched stars, the keys are JDs of every image
matched_stars = {}
# Go through every FF image and its stars
for jd in star_dict:
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(jd)], [platepar.X_res/2], [platepar.Y_res/2], [1], \
platepar, extinction_correction=False)
RA_c = RA_c[0]
dec_c = dec_c[0]
# Get stars from the catalog around the defined center in a given radius
_, extracted_catalog = subsetCatalog(catalog_stars, RA_c, dec_c, jd, platepar.lat, platepar.lon, \
fov_radius, lim_mag)
ra_catalog, dec_catalog, mag_catalog = extracted_catalog.T
# Extract stars for the given Julian date
stars_list = star_dict[jd]
stars_list = np.array(stars_list)
# Convert all catalog stars to image coordinates
cat_x_array, cat_y_array = raDecToXYPP(ra_catalog, dec_catalog, jd,
platepar)
# Take only those stars which are within the FOV
x_indices = np.argwhere((cat_x_array >= 0)
& (cat_x_array < platepar.X_res))
y_indices = np.argwhere((cat_y_array >= 0)
& (cat_y_array < platepar.Y_res))
cat_good_indices = np.intersect1d(x_indices,
y_indices).astype(np.uint32)
# cat_x_array = cat_x_array[good_indices]
# cat_y_array = cat_y_array[good_indices]
# # Plot image stars
# im_y, im_x, _, _ = stars_list.T
# plt.scatter(im_y, im_x, facecolors='none', edgecolor='g')
# # Plot catalog stars
# plt.scatter(cat_y_array[cat_good_indices], cat_x_array[cat_good_indices], c='r', s=20, marker='+')
# plt.show()
# Match image and catalog stars
matched_indices = matchStars(stars_list, cat_x_array, cat_y_array,
cat_good_indices, match_radius)
# Skip this image is no stars were matched
if len(matched_indices) < config.min_matched_stars:
continue
matched_indices = np.array(matched_indices)
matched_img_inds, matched_cat_inds, dist_list = matched_indices.T
# Extract data from matched stars
matched_img_stars = stars_list[matched_img_inds.astype(np.int)]
matched_cat_stars = extracted_catalog[matched_cat_inds.astype(np.int)]
# Put the matched stars to a dictionary
matched_stars[jd] = [matched_img_stars, matched_cat_stars, dist_list]
# # Plot matched stars
# im_y, im_x, _, _ = matched_img_stars.T
# cat_y = cat_y_array[matched_cat_inds.astype(np.int)]
# cat_x = cat_x_array[matched_cat_inds.astype(np.int)]
# plt.scatter(im_x, im_y, c='r', s=5)
# plt.scatter(cat_x, cat_y, facecolors='none', edgecolor='g')
# plt.xlim([0, platepar.X_res])
# plt.ylim([platepar.Y_res, 0])
# plt.show()
# If residuals on the image should be computed
if not sky_coords:
unit_label = 'px'
# Extract all distances
global_dist_list = []
# level_list = []
# mag_list = []
for jd in matched_stars:
# matched_img_stars, matched_cat_stars, dist_list = matched_stars[jd]
_, _, dist_list = matched_stars[jd]
global_dist_list += dist_list.tolist()
# # TEST
# level_list += matched_img_stars[:, 3].tolist()
# mag_list += matched_cat_stars[:, 2].tolist()
# # Plot levels vs. magnitudes
# plt.scatter(mag_list, np.log10(level_list))
# plt.xlabel('Magnitude')
# plt.ylabel('Log10 level')
# plt.show()
# Compute the residuals on the sky
else:
unit_label = 'arcmin'
global_dist_list = []
# Go through all matched stars
for jd in matched_stars:
matched_img_stars, matched_cat_stars, dist_list = matched_stars[jd]
# Go through all stars on the image
for img_star_entry, cat_star_entry in zip(matched_img_stars,
matched_cat_stars):
# Extract star coords
star_y = img_star_entry[0]
star_x = img_star_entry[1]
cat_ra = cat_star_entry[0]
cat_dec = cat_star_entry[1]
# Convert image coordinates to RA/Dec
_, star_ra, star_dec, _ = xyToRaDecPP([jd2Date(jd)], [star_x], [star_y], [1], \
platepar, extinction_correction=False)
# Compute angular distance between the predicted and the catalog position
ang_dist = np.degrees(angularSeparation(np.radians(cat_ra), np.radians(cat_dec), \
np.radians(star_ra[0]), np.radians(star_dec[0])))
# Store the angular separation in arc minutes
global_dist_list.append(ang_dist * 60)
# Number of matched stars
n_matched = len(global_dist_list)
if n_matched == 0:
if verbose:
print(
'No matched stars with radius {:.1f} px!'.format(match_radius))
if ret_nmatch:
return 0, 9999.0, 9999.0, {}
else:
return 9999.0
# Calculate the average distance
avg_dist = np.median(global_dist_list)
cost = (avg_dist**2) * (1.0 / np.sqrt(n_matched + 1))
if verbose:
print()
print("Matched {:d} stars with radius of {:.1f} px".format(
n_matched, match_radius))
print(" Average distance = {:.3f} {:s}".format(
avg_dist, unit_label))
print(" Cost function = {:.5f}".format(cost))
if ret_nmatch:
return n_matched, avg_dist, cost, matched_stars
else:
return cost
def matchStarsResiduals(config, platepar, catalog_stars, star_dict, match_radius, ret_nmatch=False, \
sky_coords=False, lim_mag=None, verbose=False):
""" Match the image and catalog stars with the given astrometry solution and estimate the residuals
between them.
Arguments:
config: [Config structure]
platepar: [Platepar structure] Astrometry parameters.
catalog_stars: [ndarray] An array of catalog stars (ra, dec, mag).
star_dict: [ndarray] A dictionary where the keys are JDs when the stars were recorded and values are
2D list of stars, each entry is (X, Y, bg_level, level).
match_radius: [float] Maximum radius for star matching (pixels).
min_matched_stars: [int] Minimum number of matched stars on the image for the image to be accepted.
Keyword arguments:
ret_nmatch: [bool] If True, the function returns the number of matched stars and the average
deviation. False by default.
sky_coords: [bool] If True, sky coordinate residuals in RA, dec will be used to compute the cost,
function, not image coordinates.
lim_mag: [float] Override the limiting magnitude from config. None by default.
verbose: [bool] Print results. True by default.
Return:
cost: [float] The cost function which weights the number of matched stars and the average deviation.
"""
if lim_mag is None:
lim_mag = config.catalog_mag_limit
# Estimate the FOV radius
fov_w = platepar.X_res/platepar.F_scale
fov_h = platepar.Y_res/platepar.F_scale
fov_radius = np.sqrt((fov_w/2)**2 + (fov_h/2)**2)
# print('fscale', platepar.F_scale)
# print('FOV w:', fov_w)
# print('FOV h:', fov_h)
# print('FOV radius:', fov_radius)
# Dictionary containing the matched stars, the keys are JDs of every image
matched_stars = {}
# Go through every FF image and its stars
for jd in star_dict:
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(jd)], [platepar.X_res/2], [platepar.Y_res/2], [1],
platepar)
RA_c = RA_c[0]
dec_c = dec_c[0]
# Get stars from the catalog around the defined center in a given radius
_, extracted_catalog = subsetCatalog(catalog_stars, RA_c, dec_c, fov_radius, lim_mag)
ra_catalog, dec_catalog, mag_catalog = extracted_catalog.T
# Extract stars for the given Julian date
stars_list = star_dict[jd]
stars_list = np.array(stars_list)
# Convert all catalog stars to image coordinates
cat_x_array, cat_y_array = raDecToXYPP(ra_catalog, dec_catalog, jd, platepar)
# Take only those stars which are within the FOV
x_indices = np.argwhere((cat_x_array >= 0) & (cat_x_array < platepar.X_res))
y_indices = np.argwhere((cat_y_array >= 0) & (cat_y_array < platepar.Y_res))
cat_good_indices = np.intersect1d(x_indices, y_indices).astype(np.uint32)
# cat_x_array = cat_x_array[good_indices]
# cat_y_array = cat_y_array[good_indices]
# # Plot image stars
# im_y, im_x, _, _ = stars_list.T
# plt.scatter(im_y, im_x, facecolors='none', edgecolor='g')
# # Plot catalog stars
# plt.scatter(cat_y_array[cat_good_indices], cat_x_array[cat_good_indices], c='r', s=20, marker='+')
# plt.show()
# Match image and catalog stars
matched_indices = matchStars(stars_list, cat_x_array, cat_y_array, cat_good_indices, match_radius)
# Skip this image is no stars were matched
if len(matched_indices) < config.min_matched_stars:
continue
matched_indices = np.array(matched_indices)
matched_img_inds, matched_cat_inds, dist_list = matched_indices.T
# Extract data from matched stars
matched_img_stars = stars_list[matched_img_inds.astype(np.int)]
matched_cat_stars = extracted_catalog[matched_cat_inds.astype(np.int)]
# Put the matched stars to a dictionary
matched_stars[jd] = [matched_img_stars, matched_cat_stars, dist_list]
# # Plot matched stars
# im_y, im_x, _, _ = matched_img_stars.T
# cat_y = cat_y_array[matched_cat_inds.astype(np.int)]
# cat_x = cat_x_array[matched_cat_inds.astype(np.int)]
# plt.scatter(im_x, im_y, c='r', s=5)
# plt.scatter(cat_x, cat_y, facecolors='none', edgecolor='g')
# plt.xlim([0, platepar.X_res])
# plt.ylim([platepar.Y_res, 0])
# plt.show()
# If residuals on the image should be computed
if not sky_coords:
unit_label = 'px'
# Extract all distances
global_dist_list = []
# level_list = []
# mag_list = []
for jd in matched_stars:
# matched_img_stars, matched_cat_stars, dist_list = matched_stars[jd]
_, _, dist_list = matched_stars[jd]
global_dist_list += dist_list.tolist()
# # TEST
# level_list += matched_img_stars[:, 3].tolist()
# mag_list += matched_cat_stars[:, 2].tolist()
# # Plot levels vs. magnitudes
# plt.scatter(mag_list, np.log10(level_list))
# plt.xlabel('Magnitude')
# plt.ylabel('Log10 level')
# plt.show()
# Compute the residuals on the sky
else:
unit_label = 'arcmin'
global_dist_list = []
# Go through all matched stars
for jd in matched_stars:
matched_img_stars, matched_cat_stars, dist_list = matched_stars[jd]
# Go through all stars on the image
for img_star_entry, cat_star_entry in zip(matched_img_stars, matched_cat_stars):
# Extract star coords
star_y = img_star_entry[0]
star_x = img_star_entry[1]
cat_ra = cat_star_entry[0]
cat_dec = cat_star_entry[1]
# Convert image coordinates to RA/Dec
_, star_ra, star_dec, _ = xyToRaDecPP([jd2Date(jd)], [star_x], [star_y], [1], \
platepar)
# Compute angular distance between the predicted and the catalog position
ang_dist = np.degrees(angularSeparation(np.radians(cat_ra), np.radians(cat_dec), \
np.radians(star_ra[0]), np.radians(star_dec[0])))
# Store the angular separation in arc minutes
global_dist_list.append(ang_dist*60)
# Number of matched stars
n_matched = len(global_dist_list)
if n_matched == 0:
if verbose:
print('No matched stars with radius {:.2f} px!'.format(match_radius))
if ret_nmatch:
return 0, 9999.0, 9999.0, {}
else:
return 9999.0
# Calculate the average distance
avg_dist = np.mean(global_dist_list)
cost = (avg_dist**2)*(1.0/np.sqrt(n_matched + 1))
if verbose:
print('Matched {:d} stars with radius of {:.2f} px'.format(n_matched, match_radius))
print('Avg dist', avg_dist, unit_label)
print('Cost:', cost)
print('-----')
if ret_nmatch:
return n_matched, avg_dist, cost, matched_stars
else:
return cost
def addEquatorialGrid(plt_handle, platepar, jd):
""" Given the plot handle containing the image, the function plots an equatorial grid.
Arguments:
plt_handle: [pyplot instance]
platepar: [Platepar object]
jd: [float] Julian date of the image.
Return:
plt_handle: [pyplot instance] Pyplot instance with the added grid.
"""
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(jd)], [platepar.X_res / 2],
[platepar.Y_res / 2], [1],
platepar,
extinction_correction=False)
RA_c = RA_c[0]
dec_c = dec_c[0]
# Compute FOV centre alt/az
azim_centre, alt_centre = raDec2AltAz(RA_c, dec_c, jd, platepar.lat,
platepar.lon)
# Compute FOV size
fov_h, fov_v = computeFOVSize(platepar)
fov_radius = np.hypot(*computeFOVSize(platepar))
# Determine gridline frequency (double the gridlines if the number is < 4eN)
grid_freq = 10**np.floor(np.log10(fov_radius))
if 10**(np.log10(fov_radius) - np.floor(np.log10(fov_radius))) < 4:
grid_freq /= 2
# Set a maximum grid frequency of 15 deg
if grid_freq > 15:
grid_freq = 15
# Grid plot density
plot_dens = grid_freq / 100
# Compute the range of declinations to consider
dec_min = platepar.dec_d - fov_radius / 2
if dec_min < -90:
dec_min = -90
dec_max = platepar.dec_d + fov_radius / 2
if dec_max > 90:
dec_max = 90
ra_grid_arr = np.arange(0, 360, grid_freq)
dec_grid_arr = np.arange(-90, 90, grid_freq)
# Filter out the dec grid for min/max declination
dec_grid_arr = dec_grid_arr[(dec_grid_arr >= dec_min)
& (dec_grid_arr <= dec_max)]
# Plot the celestial parallel grid
for dec_grid in dec_grid_arr:
ra_grid_plot = np.arange(0, 360, plot_dens)
dec_grid_plot = np.zeros_like(ra_grid_plot) + dec_grid
# Compute alt/az
az_grid_plot, alt_grid_plot = raDec2AltAz_vect(ra_grid_plot, dec_grid_plot, jd, platepar.lat, \
platepar.lon)
# Filter out points below the horizon and outside the FOV
filter_arr = (alt_grid_plot > 0) & (np.degrees(angularSeparation(np.radians(alt_centre), \
np.radians(azim_centre), np.radians(alt_grid_plot), np.radians(az_grid_plot))) < fov_radius)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Find gaps in continuity and break up plotting individual lines
gap_indices = np.argwhere(
np.abs(ra_grid_plot[1:] - ra_grid_plot[:-1]) > fov_radius)
if len(gap_indices):
ra_grid_plot_list = []
dec_grid_plot_list = []
# Separate gridlines with large gaps
prev_gap_indx = 0
for entry in gap_indices:
gap_indx = entry[0]
ra_grid_plot_list.append(ra_grid_plot[prev_gap_indx:gap_indx +
1])
dec_grid_plot_list.append(
dec_grid_plot[prev_gap_indx:gap_indx + 1])
prev_gap_indx = gap_indx
# Add the last segment
ra_grid_plot_list.append(ra_grid_plot[prev_gap_indx + 1:-1])
dec_grid_plot_list.append(dec_grid_plot[prev_gap_indx + 1:-1])
else:
ra_grid_plot_list = [ra_grid_plot]
dec_grid_plot_list = [dec_grid_plot]
# Plot all grid segments
for ra_grid_plot, dec_grid_plot in zip(ra_grid_plot_list,
dec_grid_plot_list):
# Compute image coordinates for every grid celestial parallel
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, jd,
platepar)
# Plot the grid
plt_handle.plot(x_grid,
y_grid,
color='w',
alpha=0.2,
zorder=2,
linewidth=0.5,
linestyle='dotted')
# Plot the celestial meridian grid
for ra_grid in ra_grid_arr:
dec_grid_plot = np.arange(-90, 90, plot_dens)
ra_grid_plot = np.zeros_like(dec_grid_plot) + ra_grid
# Filter out the dec grid
filter_arr = (dec_grid_plot >= dec_min) & (dec_grid_plot <= dec_max)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Compute alt/az
az_grid_plot, alt_grid_plot = raDec2AltAz_vect(ra_grid_plot, dec_grid_plot, jd, platepar.lat, \
platepar.lon)
# Filter out points below the horizon
filter_arr = (alt_grid_plot > 0) & (np.degrees(angularSeparation(np.radians(alt_centre), \
np.radians(azim_centre), np.radians(alt_grid_plot), np.radians(az_grid_plot))) < fov_radius)
ra_grid_plot = ra_grid_plot[filter_arr]
dec_grid_plot = dec_grid_plot[filter_arr]
# Compute image coordinates for every grid celestial parallel
x_grid, y_grid = raDecToXYPP(ra_grid_plot, dec_grid_plot, jd, platepar)
# # Filter out everything outside the FOV
# filter_arr = (x_grid >= 0) & (x_grid <= platepar.X_res) & (y_grid >= 0) & (y_grid <= platepar.Y_res)
# x_grid = x_grid[filter_arr]
# y_grid = y_grid[filter_arr]
# Plot the grid
plt_handle.plot(x_grid,
y_grid,
color='w',
alpha=0.2,
zorder=2,
linewidth=0.5,
linestyle='dotted')
return plt_handle
def read(self, file_name, fmt=None):
""" Read the platepar.
Arguments:
file_name: [str] Path and the name of the platepar to read.
Keyword arguments:
fmt: [str] Format of the platepar file. 'json' for JSON format and 'txt' for the usual CMN textual
format.
Return:
fmt: [str]
"""
# Check if platepar exists
if not os.path.isfile(file_name):
return False
# Determine the type of the platepar if it is not given
if fmt is None:
with open(file_name) as f:
data = " ".join(f.readlines())
# Try parsing the file as JSON
try:
json.loads(data)
fmt = 'json'
except:
fmt = 'txt'
# Load the file as JSON
if fmt == 'json':
# Load the JSON file
with open(file_name) as f:
data = " ".join(f.readlines())
# Parse JSON into an object with attributes corresponding to dict keys
self.__dict__ = json.loads(data)
# Add UT correction if it was not in the platepar
if not 'UT_corr' in self.__dict__:
self.UT_corr = 0
# Convert lists to numpy arrays
self.x_poly = np.array(self.x_poly)
self.y_poly = np.array(self.y_poly)
# Calculate the datetime
self.time = jd2Date(self.JD, dt_obj=True)
# Load the file as TXT
else:
with open(file_name) as f:
# Parse latitude, longitude, elevation
self.lon, self.lat, self.elev = self.parseLine(f)
# Parse date and time as int
D, M, Y, h, m, s = map(int, f.readline().split())
# Calculate the datetime of the platepar time
self.time = datetime.datetime(Y, M, D, h, m, s)
# Convert time to JD
self.JD = date2JD(Y, M, D, h, m, s)
# Calculate the referent hour angle
T = (self.JD - 2451545.0) / 36525.0
self.Ho = (280.46061837 + 360.98564736629 *
(self.JD - 2451545.0) + 0.000387933 * T**2 -
T**3 / 38710000.0) % 360
# Parse camera parameters
self.X_res, self.Y_res, self.focal_length = self.parseLine(f)
# Parse the right ascension of the image centre
self.RA_d, self.RA_H, self.RA_M, self.RA_S = self.parseLine(f)
# Parse the declination of the image centre
self.dec_d, self.dec_D, self.dec_M, self.dec_S = self.parseLine(
f)
# Parse the rotation parameter
self.pos_angle_ref = self.parseLine(f)[0]
# Parse the sum of image scales per each image axis (arcsec per px)
self.F_scale = self.parseLine(f)[0]
self.w_pix = 50 * self.F_scale / 3600
self.F_scale = 3600 / self.F_scale
# Load magnitude slope parameters
self.mag_0, self.mag_lev = self.parseLine(f)
# Load X axis polynomial parameters
self.x_poly = np.zeros(shape=(12, ), dtype=np.float64)
for i in range(12):
self.x_poly[i] = self.parseLine(f)[0]
# Load Y axis polynomial parameters
self.y_poly = np.zeros(shape=(12, ), dtype=np.float64)
for i in range(12):
self.y_poly[i] = self.parseLine(f)[0]
# Read station code
self.station_code = f.readline().replace('\r',
'').replace('\n', '')
return fmt
def writeCAL(night_dir, config, platepar):
""" Write the CAL file.
Arguments:
night_dir: [str] Path of the night directory where the file will be saved. This folder will be used
to construct the name of CAL file.
config: [Config]
platepar: [Platepar]
Return:
file_name: [str] Name of the CAL file.
"""
# Remove the last slash, if it exists
if night_dir[-1] == os.sep:
night_dir = night_dir[:-1]
# Extract time from night name
_, night_name = os.path.split(night_dir)
night_time = "_".join(night_name.split('_')[1:4])[:-3]
# Construct the CAL file name
file_name = "CAL_{:06d}_{:s}.txt".format(config.cams_code, night_time)
# If there was no platepar, don't create a CAL file
if platepar is None:
print("No Platepar available to create a CAL file!")
return None
# Make a copy of the platepar that can be modified
platepar = copy.deepcopy(platepar)
# Compute rotations (must be done before distortion correction)
rot_horiz = rotationWrtHorizon(platepar)
rot_std = rotationWrtStandard(platepar)
if platepar.distortion_type == "poly3+radial":
# CAMS code for the distortion type
distortion_code = "201"
# Switch ry in Y coeffs
platepar.y_poly_fwd[11], platepar.y_poly_fwd[10] = platepar.y_poly_fwd[10], platepar.y_poly_fwd[11]
# Correct distortion parameters so they are CAMS compatible
platepar.x_poly_fwd[ 1] = +platepar.x_poly_fwd[ 1] + 1.0
platepar.x_poly_fwd[ 2] = -platepar.x_poly_fwd[ 2]
platepar.x_poly_fwd[ 4] = -platepar.x_poly_fwd[ 4]
platepar.x_poly_fwd[ 7] = -platepar.x_poly_fwd[ 7]
platepar.x_poly_fwd[ 9] = -platepar.x_poly_fwd[ 9]
platepar.x_poly_fwd[11] = -platepar.x_poly_fwd[11]
platepar.y_poly_fwd[ 2] = -platepar.y_poly_fwd[ 2] - 1.0
platepar.y_poly_fwd[ 4] = -platepar.y_poly_fwd[ 4]
platepar.y_poly_fwd[ 7] = -platepar.y_poly_fwd[ 7]
platepar.y_poly_fwd[ 9] = -platepar.y_poly_fwd[ 9]
platepar.y_poly_fwd[11] = -platepar.y_poly_fwd[11]
else:
if platepar.distortion_type == "radial3-odd":
distortion_code = "203"
elif platepar.distortion_type == "radial3-all":
distortion_code = "204"
elif platepar.distortion_type == "radial5-odd":
distortion_code = "205"
elif platepar.distortion_type == "radial4-all":
distortion_code = "206"
elif platepar.distortion_type == "radial7-odd":
distortion_code = "207"
elif platepar.distortion_type == "radial5-all":
distortion_code = "208"
elif platepar.distortion_type == "radial9-odd":
distortion_code = "209"
else:
distortion_code = "201"
# Reset the distortion to zero out all distortion params
platepar.setDistortionType("poly3+radial")
# Compute scale in arcmin/px
arcminperpixel = 60/platepar.F_scale
# Correct scaling and rotation
for k in range(12):
x_prime = platepar.x_poly_fwd[k]*math.radians(arcminperpixel/60.0)
y_prime = platepar.y_poly_fwd[k]*math.radians(arcminperpixel/60.0)
platepar.x_poly_fwd[k] = math.cos(math.radians(platepar.pos_angle_ref))*x_prime \
+ math.sin(math.radians(platepar.pos_angle_ref))*y_prime
platepar.y_poly_fwd[k] = math.sin(math.radians(platepar.pos_angle_ref))*x_prime \
- math.cos(math.radians(platepar.pos_angle_ref))*y_prime
# Compute WGS84 height
height_wgs84 = mslToWGS84Height(math.radians(platepar.lat), math.radians(platepar.lon),
platepar.elev, config)
print(platepar.lat, platepar.lon, platepar.elev)
print("Height wgs84 = ", height_wgs84)
# Open the file
with open(os.path.join(night_dir, file_name), 'w') as f:
# Construct calibration date and time
calib_dt = jd2Date(platepar.JD, dt_obj=True)
calib_date = calib_dt.strftime("%m/%d/%Y")
calib_time = calib_dt.strftime("%H:%M:%S.%f")[:-3]
s =" Camera number = {:d}\n".format(config.cams_code)
s +=" Calibration date = {:s}\n".format(calib_date)
s +=" Calibration time (UT) = {:s}\n".format(calib_time)
s +=" Longitude +west (deg) = {:9.5f}\n".format(-platepar.lon)
s +=" Latitude +north (deg) = {:9.5f}\n".format(platepar.lat)
s +=" Height above WGS84 (km) = {:8.4f}\n".format(height_wgs84/1000)
s +=" FOV dimension hxw (deg) = {:.2f} x {:.2f}\n".format(platepar.fov_v, platepar.fov_h)
s +=" Plate scale (arcmin/pix) = {:8.3f}\n".format(arcminperpixel)
s +=" Plate roll wrt Std (deg) = {:8.3f}\n".format(rot_std)
s +=" Cam tilt wrt Horiz (deg) = {:8.3f}\n".format(rot_horiz)
s +=" Frame rate (Hz) = {:8.3f}\n".format(config.fps)
s +=" Cal center RA (deg) = {:8.3f}\n".format(platepar.RA_d)
s +=" Cal center Dec (deg) = {:8.3f}\n".format(platepar.dec_d)
s +=" Cal center Azim (deg) = {:8.3f}\n".format(platepar.az_centre)
s +=" Cal center Elev (deg) = {:8.3f}\n".format(platepar.alt_centre)
s +=" Cal center col (colcen) = {:8.3f}\n".format(platepar.X_res/2)
s +=" Cal center row (rowcen) = {:8.3f}\n".format(platepar.Y_res/2)
s +=" Cal fit order = {:>4s}\n".format(distortion_code)
s +="\n"
s +=" Camera description = None\n"
s +=" Lens description = None\n"
s +=" Focal length (mm) = 0.000\n"
s +=" Focal ratio = 0.000\n"
s +=" Pixel pitch H (um) = 0.000\n"
s +=" Pixel pitch V (um) = 0.000\n"
s +=" Spectral response B = {:8.3f}\n".format(config.star_catalog_band_ratios[0])
s +=" Spectral response V = {:8.3f}\n".format(config.star_catalog_band_ratios[1])
s +=" Spectral response R = {:8.3f}\n".format(config.star_catalog_band_ratios[2])
s +=" Spectral response I = {:8.3f}\n".format(config.star_catalog_band_ratios[3])
s +=" Vignetting coef(deg/pix) = 0.000\n"
s +=" Gamma = {:8.3f}\n".format(config.gamma)
s +="\n"
s +=" Xstd, Ystd = Radialxy2Standard( col, row, colcen, rowcen, Xcoef, Ycoef )\n"
s +=" x = col - colcen\n"
s +=" y = rowcen - row\n"
s +="\n"
s +=" Term Xcoef Ycoef \n"
s +=" ---- --------------- ---------------\n"
s +=" 1 {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[0], platepar.y_poly_fwd[0])
s +=" x {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[1], platepar.y_poly_fwd[1])
s +=" y {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[2], platepar.y_poly_fwd[2])
s +=" xx {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[3], platepar.y_poly_fwd[3])
s +=" xy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[4], platepar.y_poly_fwd[4])
s +=" yy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[5], platepar.y_poly_fwd[5])
s +=" xxx {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[6], platepar.y_poly_fwd[6])
s +=" xxy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[7], platepar.y_poly_fwd[7])
s +=" xyy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[8], platepar.y_poly_fwd[8])
s +=" yyy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[9], platepar.y_poly_fwd[9])
s +=" rx {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[10], platepar.y_poly_fwd[10])
s +=" ry {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[11], platepar.y_poly_fwd[11])
s +=" ---- --------------- ---------------\n"
s +="\n"
s +=" Mean O-C = 0.000 +- 0.000 arcmin\n"
s +="\n"
s +=" Magnitude = A + B (logI-logVig) fit mV vs. -2.5 (logI-logVig), B-V < 1.20, mV < 6.60\n"
s +=" A = {:8.3f} \n".format(platepar.mag_lev)
s +=" B = -2.50 \n"
s +="\n"
s +=" Magnitude = -2.5 ( C + D (logI-logVig) ) fit logFlux vs. Gamma (logI-logVig), mV < 6.60\n"
s +=" C = {:8.3f} \n".format(platepar.mag_lev/(-2.5))
s +=" D = 1.00 \n"
s +="\n"
s +=" logVig = log( cos( Vignetting_coef * Rpixels * pi/180 )^4 )\n"
s +="\n"
s +="\n"
s +=" Star RA (deg) DEC (deg) row col V B-V R IR logInt logVig logFlux O-C arcmin \n"
s +=" ---- --------- --------- ------- ------- ------ ------ ------ ------ ------ ------ ------- ---------- \n"
# Write CAL content
f.write(s)
return file_name
def writeCAL(night_dir, config, platepar):
""" Write the CAL file.
Arguments:
night_dir: [str] Path of the night directory where the file will be saved. This folder will be used
to construct the name of CAL file.
config: [Config]
platepar: [Platepar]
Return:
file_name: [str] Name of the CAL file.
"""
# Remove the last slash, if it exists
if night_dir[-1] == os.sep:
night_dir = night_dir[:-1]
# Extract time from night name
_, night_name = os.path.split(night_dir)
night_time = "_".join(night_name.split('_')[1:4])[:-3]
# Construct the CAL file name
file_name = "CAL_{:06d}_{:s}.txt".format(config.cams_code, night_time)
# If there was no platepar, init an empty one
if platepar is None:
platepar = Platepar()
# Make a copy of the platepar that can be modified
platepar = copy.deepcopy(platepar)
# Compute rotations (must be done before distorsion correction)
rot_horiz = rotationWrtHorizon(platepar)
rot_std = rotationWrtStandard(platepar)
# Switch ry in Y coeffs
platepar.y_poly_fwd[11], platepar.y_poly_fwd[10] = platepar.y_poly_fwd[10], platepar.y_poly_fwd[11]
# Correct distorsion parameters so they are CAMS compatible
platepar.x_poly_fwd[ 1] = +platepar.x_poly_fwd[ 1] + 1.0
platepar.x_poly_fwd[ 2] = -platepar.x_poly_fwd[ 2]
platepar.x_poly_fwd[ 4] = -platepar.x_poly_fwd[ 4]
platepar.x_poly_fwd[ 7] = -platepar.x_poly_fwd[ 7]
platepar.x_poly_fwd[ 9] = -platepar.x_poly_fwd[ 9]
platepar.x_poly_fwd[11] = -platepar.x_poly_fwd[11]
platepar.y_poly_fwd[ 2] = -platepar.y_poly_fwd[ 2] - 1.0
platepar.y_poly_fwd[ 4] = -platepar.y_poly_fwd[ 4]
platepar.y_poly_fwd[ 7] = -platepar.y_poly_fwd[ 7]
platepar.y_poly_fwd[ 9] = -platepar.y_poly_fwd[ 9]
platepar.y_poly_fwd[11] = -platepar.y_poly_fwd[11]
# Compute scale in arcmin/px
arcminperpixel = 60/platepar.F_scale
# Correct scaling and rotation
for k in range(12):
x_prime = platepar.x_poly_fwd[k]*math.radians(arcminperpixel/60.0)
y_prime = platepar.y_poly_fwd[k]*math.radians(arcminperpixel/60.0)
platepar.x_poly_fwd[k] = math.cos(math.radians(platepar.pos_angle_ref))*x_prime \
+ math.sin(math.radians(platepar.pos_angle_ref))*y_prime
platepar.y_poly_fwd[k] = math.sin(math.radians(platepar.pos_angle_ref))*x_prime \
- math.cos(math.radians(platepar.pos_angle_ref))*y_prime
# Open the file
with open(os.path.join(night_dir, file_name), 'w') as f:
# Construct calibration date and time
calib_dt = jd2Date(platepar.JD, dt_obj=True)
calib_date = calib_dt.strftime("%m/%d/%Y")
calib_time = calib_dt.strftime("%H:%M:%S.%f")[:-3]
s =" Camera number = {:d}\n".format(config.cams_code)
s +=" Calibration date = {:s}\n".format(calib_date)
s +=" Calibration time (UT) = {:s}\n".format(calib_time)
s +=" Longitude +west (deg) = {:9.5f}\n".format(-platepar.lon)
s +=" Latitude +north (deg) = {:9.5f}\n".format(platepar.lat)
s +=" Height above WGS84 (km) = {:8.5f}\n".format(platepar.elev/1000)
s +=" FOV dimension hxw (deg) = {:.2f} x {:.2f}\n".format(platepar.fov_v, platepar.fov_h)
s +=" Plate scale (arcmin/pix) = {:8.3f}\n".format(arcminperpixel)
s +=" Plate roll wrt Std (deg) = {:8.3f}\n".format(rot_std)
s +=" Cam tilt wrt Horiz (deg) = {:8.3f}\n".format(rot_horiz)
s +=" Frame rate (Hz) = {:8.3f}\n".format(config.fps)
s +=" Cal center RA (deg) = {:8.3f}\n".format(platepar.RA_d)
s +=" Cal center Dec (deg) = {:8.3f}\n".format(platepar.dec_d)
s +=" Cal center Azim (deg) = {:8.3f}\n".format(platepar.az_centre)
s +=" Cal center Elev (deg) = {:8.3f}\n".format(platepar.alt_centre)
s +=" Cal center col (colcen) = {:8.3f}\n".format(platepar.X_res/2)
s +=" Cal center row (rowcen) = {:8.3f}\n".format(platepar.Y_res/2)
s +=" Cal fit order = 201\n" # 201 = RMS 3rd order poly with radial terms
s +="\n"
s +=" Camera description = None\n"
s +=" Lens description = None\n"
s +=" Focal length (mm) = 0.000\n"
s +=" Focal ratio = 0.000\n"
s +=" Pixel pitch H (um) = 0.000\n"
s +=" Pixel pitch V (um) = 0.000\n"
s +=" Spectral response B = {:8.3f}\n".format(config.star_catalog_band_ratios[0])
s +=" Spectral response V = {:8.3f}\n".format(config.star_catalog_band_ratios[1])
s +=" Spectral response R = {:8.3f}\n".format(config.star_catalog_band_ratios[2])
s +=" Spectral response I = {:8.3f}\n".format(config.star_catalog_band_ratios[3])
s +=" Vignetting coef(deg/pix) = 0.000\n"
s +=" Gamma = {:8.3f}\n".format(config.gamma)
s +="\n"
s +=" Xstd, Ystd = Radialxy2Standard( col, row, colcen, rowcen, Xcoef, Ycoef )\n"
s +=" x = col - colcen\n"
s +=" y = rowcen - row\n"
s +="\n"
s +=" Term Xcoef Ycoef \n"
s +=" ---- --------------- ---------------\n"
s +=" 1 {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[0], platepar.y_poly_fwd[0])
s +=" x {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[1], platepar.y_poly_fwd[1])
s +=" y {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[2], platepar.y_poly_fwd[2])
s +=" xx {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[3], platepar.y_poly_fwd[3])
s +=" xy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[4], platepar.y_poly_fwd[4])
s +=" yy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[5], platepar.y_poly_fwd[5])
s +=" xxx {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[6], platepar.y_poly_fwd[6])
s +=" xxy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[7], platepar.y_poly_fwd[7])
s +=" xyy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[8], platepar.y_poly_fwd[8])
s +=" yyy {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[9], platepar.y_poly_fwd[9])
s +=" rx {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[10], platepar.y_poly_fwd[10])
s +=" ry {:+.7e} {:+.7e} \n".format(platepar.x_poly_fwd[11], platepar.y_poly_fwd[11])
s +=" ---- --------------- ---------------\n"
s +="\n"
s +=" Mean O-C = 0.000 +- 0.000 arcmin\n"
s +="\n"
s +=" Magnitude = A + B (logI-logVig) fit mV vs. -2.5 (logI-logVig), B-V < 1.20, mV < 6.60\n"
s +=" A = {:8.3f} \n".format(platepar.mag_lev)
s +=" B = -2.50 \n"
s +="\n"
s +=" Magnitude = -2.5 ( C + D (logI-logVig) ) fit logFlux vs. Gamma (logI-logVig), mV < 6.60\n"
s +=" C = {:8.3f} \n".format(platepar.mag_lev/(-2.5))
s +=" D = 1.00 \n"
s +="\n"
s +=" logVig = log( cos( Vignetting_coef * Rpixels * pi/180 )^4 )\n"
s +="\n"
s +="\n"
s +=" Star RA (deg) DEC (deg) row col V B-V R IR logInt logVig logFlux O-C arcmin \n"
s +=" ---- --------- --------- ------- ------- ------ ------ ------ ------ ------ ------ ------- ---------- \n"
# Write CAL content
f.write(s)
return file_name
def write(self, file_path, fmt=None, fov=None, ret_written=False):
""" Write platepar to file.
Arguments:
file_path: [str] Path and the name of the platepar to write.
Keyword arguments:
fmt: [str] Format of the platepar file. 'json' for JSON format and 'txt' for the usual CMN textual
format. The format is JSON by default.
fov: [tuple] Tuple of horizontal and vertical FOV size in degree. None by default.
ret_written: [bool] If True, the JSON string of the platepar instead of writing it to disk.
Return:
fmt: [str] Platepar format.
"""
# If the FOV size was given, store it
if fov is not None:
self.fov_h, self.fov_v = fov
# Set JSON to be the defualt format
if fmt is None:
fmt = 'json'
# If the format is JSON, write a JSON file
if fmt == 'json':
out_str = self.jsonStr()
with open(file_path, 'w') as f:
f.write(out_str)
if ret_written:
return fmt, out_str
# Old CMN format
else:
with open(file_path, 'w') as f:
# Write geo coords
f.write('{:9.6f} {:9.6f} {:04d}\n'.format(self.lon, self.lat, int(self.elev)))
# Calculate reference time from reference JD
Y, M, D, h, m, s, ms = list(map(int, jd2Date(self.JD)))
# Write the reference time
f.write('{:02d} {:02d} {:04d} {:02d} {:02d} {:02d}\n'.format(D, M, Y, h, m, s))
# Write resolution and focal length
f.write('{:d} {:d} {:f}\n'.format(int(self.X_res), int(self.Y_res), self.focal_length))
# Write reference RA
self.RA_H = int(self.RA_d/15)
self.RA_M = int((self.RA_d/15 - self.RA_H)*60)
self.RA_S = int(((self.RA_d/15 - self.RA_H)*60 - self.RA_M)*60)
f.write("{:7.3f} {:02d} {:02d} {:02d}\n".format(self.RA_d, self.RA_H, self.RA_M, self.RA_S))
# Write reference Dec
self.dec_D = int(self.dec_d)
self.dec_M = int((self.dec_d - self.dec_D)*60)
self.dec_S = int(((self.dec_d - self.dec_D)*60 - self.dec_M)*60)
f.write("{:+7.3f} {:02d} {:02d} {:02d}\n".format(self.dec_d, self.dec_D, self.dec_M, self.dec_S))
# Write rotation parameter
f.write('{:<7.3f}\n'.format(self.pos_angle_ref))
# Write F scale
f.write('{:<5.1f}\n'.format(3600/self.F_scale))
# Write magnitude fit
f.write("{:.3f} {:.3f}\n".format(self.mag_0, self.mag_lev))
# Write X distortion polynomial
for x_elem in self.x_poly_fwd:
f.write('{:+E}\n'.format(x_elem))
# Write y distortion polynomial
for y_elem in self.y_poly_fwd:
f.write('{:+E}\n'.format(y_elem))
# Write station code
f.write(str(self.station_code) + '\n')
if ret_written:
with open(file_path) as f:
out_str = "\n".join(f.readlines())
return fmt, out_str
return fmt
print()
print('Shower ranking:')
for shower, count in shower_counts:
if shower is None:
shower_name = '...'
else:
shower_name = shower.name
print(shower_name, count)
ftpdetectinfo_base_name = ftpdetectinfo_name.replace('FTPdetectinfo_', '').replace('.txt', '')
assoc_name = ftpdetectinfo_base_name + '_assocs.txt'
print('Creating association file')
with open(os.path.join(dir_path, assoc_name), 'w') as outf:
for key in associations:
meteor_obj, shower = associations[key]
jdt = jd2Date(meteor_obj.jdt_ref, dt_obj=True)
outf.write('{:s},{:d},{:d},{:d},{:d},{:d},{:.2f},'.format(statID, jdt.year, jdt.month, jdt.day,
jdt.hour, jdt.minute, jdt.second + jdt.microsecond / 1000000.0))
if shower is None:
outf.write('SPO\n')
else:
outf.write(shower.name + '\n')
exit(0)
else:
print("No meteors!")
with open(os.path.join(dir_path, 'nometeors'), 'w') as outf:
outf.write('no meteors\n')
exit(1)
def showerAssociation(config, ftpdetectinfo_list, shower_code=None, show_plot=False, save_plot=False, \
plot_activity=False):
""" Do single station shower association based on radiant direction and height.
Arguments:
config: [Config instance]
ftpdetectinfo_list: [list] A list of paths to FTPdetectinfo files.
Keyword arguments:
shower_code: [str] Only use this one shower for association (e.g. ETA, PER, SDA). None by default,
in which case all active showers will be associated.
show_plot: [bool] Show the plot on the screen. False by default.
save_plot: [bool] Save the plot in the folder with FTPdetectinfos. False by default.
plot_activity: [bool] Whether to plot the shower activity plot of not. False by default.
Return:
associations, shower_counts: [tuple]
- associations: [dict] A dictionary where the FF name and the meteor ordinal number on the FF
file are keys, and the associated Shower object are values.
- shower_counts: [list] A list of shower code and shower count pairs.
"""
# Load the list of meteor showers
shower_list = loadShowers(config.shower_path, config.shower_file_name)
# Load FTPdetectinfos
meteor_data = []
for ftpdetectinfo_path in ftpdetectinfo_list:
if not os.path.isfile(ftpdetectinfo_path):
print('No such file:', ftpdetectinfo_path)
continue
meteor_data += readFTPdetectinfo(*os.path.split(ftpdetectinfo_path))
if not len(meteor_data):
return {}, []
# Dictionary which holds FF names as keys and meteor measurements + associated showers as values
associations = {}
for meteor in meteor_data:
ff_name, cam_code, meteor_No, n_segments, fps, hnr, mle, binn, px_fm, rho, phi, meteor_meas = meteor
# Skip very short meteors
if len(meteor_meas) < 4:
continue
# Check if the data is calibrated
if not meteor_meas[0][0]:
print(
'Data is not calibrated! Meteors cannot be associated to showers!'
)
break
# Init container for meteor observation
meteor_obj = MeteorSingleStation(cam_code, config.latitude,
config.longitude, ff_name)
# Infill the meteor structure
for entry in meteor_meas:
calib_status, frame_n, x, y, ra, dec, azim, elev, inten, mag = entry
# Compute the Julian data of every point
jd = datetime2JD(
filenameToDatetime(ff_name) +
datetime.timedelta(seconds=float(frame_n) / fps))
meteor_obj.addPoint(jd, ra, dec, mag)
# Fit the great circle and compute the geometrical parameters
meteor_obj.fitGC()
# Skip all meteors with beginning heights below 15 deg
if meteor_obj.beg_alt < 15:
continue
# Go through all showers in the list and find the best match
best_match_shower = None
best_match_dist = np.inf
for shower_entry in shower_list:
# Extract shower parameters
shower = Shower(shower_entry)
# If the shower code was given, only check this one shower
if shower_code is not None:
if shower.name.lower() != shower_code.lower():
continue
### Solar longitude filter
# If the shower doesn't have a stated beginning or end, check if the meteor is within a preset
# threshold solar longitude difference
if np.any(np.isnan([shower.lasun_beg, shower.lasun_end])):
shower.lasun_beg = (shower.lasun_max -
config.shower_lasun_threshold) % 360
shower.lasun_end = (shower.lasun_max +
config.shower_lasun_threshold) % 360
# Filter out all showers which are not active
if not isAngleBetween(np.radians(shower.lasun_beg),
np.radians(meteor_obj.lasun),
np.radians(shower.lasun_end)):
continue
### ###
### Radiant filter ###
# Assume a fixed meteor height for an approximate apparent radiant
meteor_fixed_ht = 100000 # 100 km
shower.computeApparentRadiant(config.latitude, config.longitude, meteor_obj.jdt_ref, \
meteor_fixed_ht=meteor_fixed_ht)
# Compute the angle between the meteor radiant and the great circle normal
radiant_separation = meteor_obj.angularSeparationFromGC(
shower.ra, shower.dec)
# Make sure the meteor is within the radiant distance threshold
if radiant_separation > config.shower_max_radiant_separation:
continue
# Compute angle between the meteor's beginning and end, and the shower radiant
shower.radiant_vector = vectNorm(
raDec2Vector(shower.ra, shower.dec))
begin_separation = np.degrees(angularSeparationVect(shower.radiant_vector, \
meteor_obj.meteor_begin_cartesian))
end_separation = np.degrees(angularSeparationVect(shower.radiant_vector, \
meteor_obj.meteor_end_cartesian))
# Make sure the beginning of the meteor is closer to the radiant than it's end
if begin_separation > end_separation:
continue
### ###
### Height filter ###
# Estimate the limiting meteor height from the velocity (meters)
filter_beg_ht = heightModel(shower.v_init, ht_type='beg')
filter_end_ht = heightModel(shower.v_init, ht_type='end')
### Estimate the meteor beginning height with +/- 1 frame, otherwise some short meteor may get
### rejected
meteor_obj_orig = copy.deepcopy(meteor_obj)
# Shorter
meteor_obj_m1 = copy.deepcopy(meteor_obj_orig)
meteor_obj_m1.duration -= 1.0 / config.fps
meteor_beg_ht_m1 = estimateMeteorHeight(config, meteor_obj_m1,
shower)
# Nominal
meteor_beg_ht = estimateMeteorHeight(config, meteor_obj_orig,
shower)
# Longer
meteor_obj_p1 = copy.deepcopy(meteor_obj_orig)
meteor_obj_p1.duration += 1.0 / config.fps
meteor_beg_ht_p1 = estimateMeteorHeight(config, meteor_obj_p1,
shower)
meteor_obj = meteor_obj_orig
### ###
# If all heights (even those with +/- 1 frame) are outside the height range, reject the meteor
if ((meteor_beg_ht_p1 < filter_end_ht) or (meteor_beg_ht_p1 > filter_beg_ht)) and \
((meteor_beg_ht < filter_end_ht) or (meteor_beg_ht > filter_beg_ht)) and \
((meteor_beg_ht_m1 < filter_end_ht) or (meteor_beg_ht_m1 > filter_beg_ht)):
continue
### ###
# Compute the radiant elevation above the horizon
shower.azim, shower.elev = raDec2AltAz(shower.ra, shower.dec, meteor_obj.jdt_ref, \
config.latitude, config.longitude)
# Take the shower that's closest to the great circle if there are multiple candidates
if radiant_separation < best_match_dist:
best_match_dist = radiant_separation
best_match_shower = copy.deepcopy(shower)
# If a shower is given and the match is not this shower, skip adding the meteor to the list
# If no specific shower is give for association, add all meteors
if ((shower_code is not None) and
(best_match_shower is not None)) or (shower_code is None):
# Store the associated shower
associations[(ff_name,
meteor_No)] = [meteor_obj, best_match_shower]
# Find shower frequency and sort by count
shower_name_list_temp = []
shower_list_temp = []
for key in associations:
_, shower = associations[key]
if shower is None:
shower_name = '...'
else:
shower_name = shower.name
shower_name_list_temp.append(shower_name)
shower_list_temp.append(shower)
_, unique_showers_indices = np.unique(shower_name_list_temp,
return_index=True)
unique_shower_names = np.array(
shower_name_list_temp)[unique_showers_indices]
unique_showers = np.array(shower_list_temp)[unique_showers_indices]
shower_counts = [[shower_obj, shower_name_list_temp.count(shower_name)] for shower_obj, \
shower_name in zip(unique_showers, unique_shower_names)]
shower_counts = sorted(shower_counts, key=lambda x: x[1], reverse=True)
# Create a plot of showers
if show_plot or save_plot:
# Generate consistent colours
colors_by_name = makeShowerColors(shower_list)
def get_shower_color(shower):
try:
return colors_by_name[shower.name] if shower else "0.4"
except KeyError:
return 'gray'
# Init the figure
plt.figure()
# Init subplots depending on if the activity plot is done as well
if plot_activity:
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
ax_allsky = plt.subplot(gs[0], facecolor='black')
ax_activity = plt.subplot(gs[1], facecolor='black')
else:
ax_allsky = plt.subplot(111, facecolor='black')
# Init the all-sky plot
allsky_plot = AllSkyPlot(ax_handle=ax_allsky)
# Plot all meteors
for key in associations:
meteor_obj, shower = associations[key]
### Plot the observed meteor points ###
color = get_shower_color(shower)
allsky_plot.plot(meteor_obj.ra_array,
meteor_obj.dec_array,
color=color,
linewidth=1,
zorder=4)
# Plot the peak of shower meteors a different color
peak_color = 'blue'
if shower is not None:
peak_color = 'tomato'
allsky_plot.scatter(meteor_obj.ra_array[-1], meteor_obj.dec_array[-1], c=peak_color, marker='+', \
s=5, zorder=5)
### ###
### Plot fitted great circle points ###
# Find the GC phase angle of the beginning of the meteor
gc_beg_phase = meteor_obj.findGCPhase(
meteor_obj.ra_array[0], meteor_obj.dec_array[0])[0] % 360
# If the meteor belongs to a shower, find the GC phase which ends at the shower
if shower is not None:
gc_end_phase = meteor_obj.findGCPhase(shower.ra,
shower.dec)[0] % 360
# Fix 0/360 wrap
if abs(gc_end_phase - gc_beg_phase) > 180:
if gc_end_phase > gc_beg_phase:
gc_end_phase -= 360
else:
gc_beg_phase -= 360
gc_alpha = 1.0
else:
# If it's a sporadic, find the direction to which the meteor should extend
gc_end_phase = meteor_obj.findGCPhase(meteor_obj.ra_array[-1], \
meteor_obj.dec_array[-1])[0]%360
# Find the correct direction
if (gc_beg_phase - gc_end_phase) % 360 > (gc_end_phase -
gc_beg_phase) % 360:
gc_end_phase = gc_beg_phase - 170
else:
gc_end_phase = gc_beg_phase + 170
gc_alpha = 0.7
# Store great circle beginning and end phase
meteor_obj.gc_beg_phase = gc_beg_phase
meteor_obj.gc_end_phase = gc_end_phase
# Get phases 180 deg before the meteor
phase_angles = np.linspace(gc_end_phase, gc_beg_phase, 100) % 360
# Compute RA/Dec of points on the great circle
ra_gc, dec_gc = meteor_obj.sampleGC(phase_angles)
# Cull all points below the horizon
azim_gc, elev_gc = raDec2AltAz(ra_gc, dec_gc, meteor_obj.jdt_ref, config.latitude, \
config.longitude)
temp_arr = np.c_[ra_gc, dec_gc]
temp_arr = temp_arr[elev_gc > 0]
ra_gc, dec_gc = temp_arr.T
# Plot the great circle fitted on the radiant
gc_color = get_shower_color(shower)
allsky_plot.plot(ra_gc,
dec_gc,
linestyle='dotted',
color=gc_color,
alpha=gc_alpha,
linewidth=1)
# Plot the point closest to the shower radiant
if shower is not None:
allsky_plot.plot(ra_gc[0],
dec_gc[0],
color='r',
marker='+',
ms=5,
mew=1)
# Store shower radiant point
meteor_obj.radiant_ra = ra_gc[0]
meteor_obj.radiant_dec = dec_gc[0]
### ###
### Plot all showers ###
# Find unique showers and their apparent radiants computed at highest radiant elevation
# (otherwise the apparent radiants can be quite off)
shower_dict = {}
for key in associations:
meteor_obj, shower = associations[key]
if shower is None:
continue
# If the shower name is in dict, find the shower with the highest radiant elevation
if shower.name in shower_dict:
if shower.elev > shower_dict[shower.name].elev:
shower_dict[shower.name] = shower
else:
shower_dict[shower.name] = shower
# Plot the location of shower radiants
for shower_name in shower_dict:
shower = shower_dict[shower_name]
heading_arr = np.linspace(0, 360, 50)
# Compute coordinates on a circle around the given RA, Dec
ra_circle, dec_circle = sphericalPointFromHeadingAndDistance(shower.ra, shower.dec, \
heading_arr, config.shower_max_radiant_separation)
# Plot the shower circle
allsky_plot.plot(ra_circle,
dec_circle,
color=colors_by_name[shower_name])
# Plot the shower name
x_text, y_text = allsky_plot.raDec2XY(shower.ra, shower.dec)
allsky_plot.ax.text(x_text, y_text, shower.name, color='w', size=8, va='center', \
ha='center', zorder=6)
# Plot station name and solar longiutde range
allsky_plot.ax.text(-180,
89,
"{:s}".format(cam_code),
color='w',
family='monospace')
# Get a list of JDs of meteors
jd_list = [associations[key][0].jdt_ref for key in associations]
if len(jd_list):
# Get the range of solar longitudes
jd_min = min(jd_list)
sol_min = np.degrees(jd2SolLonSteyaert(jd_min))
jd_max = max(jd_list)
sol_max = np.degrees(jd2SolLonSteyaert(jd_max))
# Plot the date and solar longitude range
date_sol_beg = u"Beg: {:s} (sol = {:.2f}\u00b0)".format(
jd2Date(jd_min, dt_obj=True).strftime("%Y%m%d %H:%M:%S"),
sol_min)
date_sol_end = u"End: {:s} (sol = {:.2f}\u00b0)".format(
jd2Date(jd_max, dt_obj=True).strftime("%Y%m%d %H:%M:%S"),
sol_max)
allsky_plot.ax.text(-180,
85,
date_sol_beg,
color='w',
family='monospace')
allsky_plot.ax.text(-180,
81,
date_sol_end,
color='w',
family='monospace')
allsky_plot.ax.text(-180,
77,
"-" * len(date_sol_end),
color='w',
family='monospace')
# Plot shower counts
for i, (shower, count) in enumerate(shower_counts):
if shower is not None:
shower_name = shower.name
else:
shower_name = "..."
allsky_plot.ax.text(-180, 73 - i*4, "{:s}: {:d}".format(shower_name, count), color='w', \
family='monospace')
### ###
# Plot yearly meteor shower activity
if plot_activity:
# Plot the activity diagram
generateActivityDiagram(config, shower_list, ax_handle=ax_activity, \
sol_marker=[sol_min, sol_max], colors=colors_by_name)
# Save plot and text file
if save_plot:
dir_path, ftpdetectinfo_name = os.path.split(ftpdetectinfo_path)
ftpdetectinfo_base_name = ftpdetectinfo_name.replace(
'FTPdetectinfo_', '').replace('.txt', '')
plot_name = ftpdetectinfo_base_name + '_radiants.png'
# Increase figure size
allsky_plot.fig.set_size_inches(18, 9, forward=True)
allsky_plot.beautify()
plt.savefig(os.path.join(dir_path, plot_name),
dpi=100,
facecolor='k')
# Save the text file with shower info
if len(jd_list):
with open(
os.path.join(dir_path, ftpdetectinfo_base_name +
"_radiants.txt"), 'w') as f:
# Print station code
f.write("# RMS single station association\n")
f.write("# \n")
f.write("# Station: {:s}\n".format(cam_code))
# Print date range
f.write(
"# Beg | End \n"
)
f.write(
"# -----------------------------------------------------\n"
)
f.write("# Date | {:24s} | {:24s} \n".format(jd2Date(jd_min, \
dt_obj=True).strftime("%Y%m%d %H:%M:%S.%f"), jd2Date(jd_max, \
dt_obj=True).strftime("%Y%m%d %H:%M:%S.%f")))
f.write("# Sol | {:>24.2f} | {:>24.2f} \n".format(
sol_min, sol_max))
# Write shower counts
f.write("# \n")
f.write("# Shower counts:\n")
f.write("# --------------\n")
f.write("# Code, Count, IAU link\n")
for i, (shower, count) in enumerate(shower_counts):
if shower is not None:
shower_name = shower.name
# Create link to the IAU database of showers
iau_link = "https://www.ta3.sk/IAUC22DB/MDC2007/Roje/pojedynczy_obiekt.php?kodstrumienia={:05d}".format(
shower.iau_code)
else:
shower_name = "..."
iau_link = "None"
f.write("# {:>4s}, {:>5d}, {:s}\n".format(
shower_name, count, iau_link))
f.write("# \n")
f.write("# Meteor parameters:\n")
f.write("# ------------------\n")
f.write(
"# Date And Time, Beg Julian date, La Sun, Shower, RA beg, Dec beg, RA end, Dec end, RA rad, Dec rad, GC theta0, GC phi0, GC beg phase, GC end phase, Mag\n"
)
# Create a sorted list of meteor associations by time
associations_list = [
associations[key] for key in associations
]
associations_list = sorted(associations_list,
key=lambda x: x[0].jdt_ref)
# Write out meteor parameters
for meteor_obj, shower in associations_list:
# Find peak magnitude
if np.any(meteor_obj.mag_array):
peak_mag = "{:+.1f}".format(
np.min(meteor_obj.mag_array))
else:
peak_mag = "None"
if shower is not None:
f.write("{:24s}, {:20.12f}, {:>10.6f}, {:>6s}, {:6.2f}, {:+7.2f}, {:6.2f}, {:+7.2f}, {:6.2f}, {:+7.2f}, {:9.3f}, {:8.3f}, {:12.3f}, {:12.3f}, {:4s}\n".format(jd2Date(meteor_obj.jdt_ref, dt_obj=True).strftime("%Y%m%d %H:%M:%S.%f"), \
meteor_obj.jdt_ref, meteor_obj.lasun, shower.name, \
meteor_obj.ra_array[0]%360, meteor_obj.dec_array[0], \
meteor_obj.ra_array[-1]%360, meteor_obj.dec_array[-1], \
meteor_obj.radiant_ra%360, meteor_obj.radiant_dec, \
np.degrees(meteor_obj.theta0), np.degrees(meteor_obj.phi0), \
meteor_obj.gc_beg_phase, meteor_obj.gc_end_phase, peak_mag))
else:
f.write("{:24s}, {:20.12f}, {:>10.6f}, {:>6s}, {:6.2f}, {:+7.2f}, {:6.2f}, {:+7.2f}, {:>6s}, {:>7s}, {:9.3f}, {:8.3f}, {:12.3f}, {:12.3f}, {:4s}\n".format(jd2Date(meteor_obj.jdt_ref, dt_obj=True).strftime("%Y%m%d %H:%M:%S.%f"), \
meteor_obj.jdt_ref, meteor_obj.lasun, '...', meteor_obj.ra_array[0]%360, \
meteor_obj.dec_array[0], meteor_obj.ra_array[-1]%360, \
meteor_obj.dec_array[-1], "None", "None", np.degrees(meteor_obj.theta0), \
np.degrees(meteor_obj.phi0), meteor_obj.gc_beg_phase, \
meteor_obj.gc_end_phase, peak_mag))
if show_plot:
allsky_plot.show()
else:
plt.clf()
plt.close()
return associations, shower_counts
def loadFromDict(self, platepar_dict, use_flat=None):
""" Load the platepar from a dictionary. """
# Parse JSON into an object with attributes corresponding to dict keys
self.__dict__ = platepar_dict
# Add the version if it was not in the platepar (v1 platepars didn't have a version)
if not 'version' in self.__dict__:
self.version = 1
# If the refraction was not used for the fit, assume it is disabled
if not 'refraction' in self.__dict__:
self.refraction = False
# Add equal aspect
if not 'equal_aspect' in self.__dict__:
self.equal_aspect = False
if not 'force_distribution_centre' in self.__dict__:
self.force_distortion_centre = False
# Add the distortion type if not present (assume it's the polynomal type with the radial term)
if not 'distortion_type' in self.__dict__:
# Check if the variable with the typo was used and correct it
if 'distortion_type' in self.__dict__:
self.distortion_type = self.distortion_type
del self.distortion_type
# Otherwise, assume the polynomial type
else:
self.distortion_type = "poly3+radial"
self.setDistortionType(self.distortion_type, reset_params=False)
# Add UT correction if it was not in the platepar
if not 'UT_corr' in self.__dict__:
self.UT_corr = 0
# Add the gamma if it was not in the platepar
if not 'gamma' in self.__dict__:
self.gamma = 1.0
# Add the vignetting coefficient if it was not in the platepar
if not 'vignetting_coeff' in self.__dict__:
self.vignetting_coeff = None
# Add the default vignetting coeff
self.addVignettingCoeff(use_flat=use_flat)
# Add extinction scale
if not 'extinction_scale' in self.__dict__:
self.extinction_scale = 1.0
# Add the list of calibration stars if it was not in the platepar
if not 'star_list' in self.__dict__:
self.star_list = []
# If v1 only the backward distortion coeffs were fitted, so use load them for both forward and
# reverse if nothing else is available
if not 'x_poly_fwd' in self.__dict__:
self.x_poly_fwd = np.array(self.x_poly)
self.x_poly_rev = np.array(self.x_poly)
self.y_poly_fwd = np.array(self.y_poly)
self.y_poly_rev = np.array(self.y_poly)
# Convert lists to numpy arrays
self.x_poly_fwd = np.array(self.x_poly_fwd)
self.x_poly_rev = np.array(self.x_poly_rev)
self.y_poly_fwd = np.array(self.y_poly_fwd)
self.y_poly_rev = np.array(self.y_poly_rev)
# Set polynomial parameters used by the old code
self.x_poly = self.x_poly_fwd
self.y_poly = self.y_poly_fwd
# Add rotation from horizontal
if not 'rotation_from_horiz' in self.__dict__:
self.rotation_from_horiz = rotationWrtHorizon(self)
# Calculate the datetime
self.time = jd2Date(self.JD, dt_obj=True)
def writeEv(dir_path, file_name, ev_array, plate, ast_input=False):
""" Write an UWO ASGARD style event file.
Arguments:
dir_path: [str] Path to directory where the file will be saved to.
file_name: [str] Name of the ev file.
ev_array: [ndarray] Array where columns are: frame number, sequence number, JD, intensity, x, y,
azimuth (deg), altitude (deg), magnitude
plate: [?] Platepar or AST plate.
Keyword arguments:
ast_input: [bool] True if AST plate if given, False if platepar is given (default).
"""
# AST plate used for input
if ast_input:
station_code = plate.sitename
lat = np.degrees(plate.lat)
lon = np.degrees(plate.lon)
elev = plate.elev
X_res = plate.wid
Y_res = plate.ht
# Platepar used for input
else:
station_code = plate.station_code
lat = plate.lat
lon = plate.lon
elev = plate.elev
X_res = plate.X_res
Y_res = plate.Y_res
with open(os.path.join(dir_path, file_name), 'w') as f:
frame_array, seq_array, jd_array, intensity_array, x_array, y_array, azim_array, alt_array, \
mag_array = ev_array.T
seq_array = seq_array.astype(np.uint32)
# Get the Julian date of the peak
jd_peak = jd_array[mag_array.argmin()]
# Get the sequence number of the peak
seq_peak = int(seq_array[mag_array.argmin()])
# Extract the site number and stream
if len(station_code) == 3:
site = station_code[:2]
stream = station_code[2]
else:
site = station_code
stream = 'A'
### Write the header
f.write('#\n')
f.write('# version : RMS Detection\n')
f.write("# num_fr : {:d}\n".format(len(ev_array)))
f.write("# num_tr : 0\n")
f.write("# time : {:s} UTC\n".format(jd2Date(jd_peak, dt_obj=True).strftime('%Y%m%d %H:%M:%S.%f')[:-3]))
f.write("# unix : {:.6f}\n".format(jd2UnixTime(jd_peak)))
f.write("# ntp : LOCK 0 0 0\n")
f.write("# seq : {:d}\n".format(seq_peak))
f.write("# mul : 0 [A]\n")
f.write("# site : {:s}\n".format(site))
f.write("# latlon : {:.4f} {:.4f} {:.1f}\n".format(lat, lon, elev))
f.write("# text : \n")
f.write("# stream : {:s}\n".format(stream))
f.write("# plate : RMS_SkyFit\n")
f.write("# geom : {:d} {:d}\n".format(X_res, Y_res))
f.write("# filter : 0\n")
f.write("#\n")
f.write("# fr time sum seq cx cy th phi lsp mag flag bak max\n")
###
# Go through all centroids and write them to file
for i, entry in enumerate(ev_array):
frame, seq_num, jd, intensity, x, y, azim, alt, mag = entry
# Compute the relative time in seconds
t_rel = (jd - jd_peak)*86400
# Compute theta and phi
theta = 90 - alt
phi = (90 - azim)%360
f.write("{:5d} {:7.3f} {:10d} {:7d} {:8.3f} {:8.3f} {:7.3f} {:8.3f} {:7.3f} {:6.2f} 0000 0.0 0.0\n".format(int(31 + int(seq_num) - seq_array[0]), \
t_rel, int(intensity), int(seq_num), x, y, theta, phi, -2.5*np.log10(intensity), mag))
def fovArea(platepar, mask=None, area_ht=100000, side_points=10):
""" Given a platepar file and a mask file, compute geo points of the FOV at the given height.
Arguments:
platepar: [Platepar object]
Keyword arguments:
mask: [Mask object] Mask object, None by default.
area_ht: [float] Height in meters of the computed area.
side_points: [int] How many points to use to evaluate the FOV on seach side of the image. Normalized
to the longest side.
Return:
[list] A list points for every side of the image, and every side is a list of (lat, lon, elev)
describing the sides of the FOV area. Values are in degrees and meters.
"""
# If the mask is not given, make a dummy mask with all white pixels
if mask is None:
mask = MaskStructure(255 + np.zeros(
(platepar.Y_res, platepar.X_res), dtype=np.uint8))
# Compute the number of points for the sizes
longer_side_points = side_points
shorter_side_points = int(
np.ceil(side_points * platepar.Y_res / platepar.X_res))
# Define operations for each side (number of points, axis of sampling, sampling start, direction of sampling, reverse sampling direction)
side_operations = [
[shorter_side_points, 'y', 0, 1, False], # left
[longer_side_points, 'x', platepar.Y_res - 1, -1, False], # bottom
[shorter_side_points, 'y', platepar.X_res - 1, -1, True], # right
[longer_side_points, 'x', 0, 1, True]
] # up
# Sample the points on image borders
side_points_list = []
for n_sample, axis, c0, sampling_direction, reverse_sampling in side_operations:
# Reverse some ordering to make the sampling counter-clockwise, starting in the top-left corner
sampling_offsets = range(n_sample + 1)
if reverse_sampling:
sampling_offsets = reversed(sampling_offsets)
# Sample points on every side
side_points = []
for i_sample in sampling_offsets:
# Compute x, y coordinate of the sampled pixel
if axis == 'x':
axis_side = platepar.X_res
other_axis_side = platepar.Y_res
x0 = int((i_sample / n_sample) * (axis_side - 1))
y0 = c0
else:
axis_side = platepar.Y_res
other_axis_side = platepar.X_res
x0 = c0
y0 = int((i_sample / n_sample) * (axis_side - 1))
# Find a pixel position along the axis that is not masked using increments of 10 pixels
unmasked_point_found = False
# Make a list of points to sample
for mask_offset in np.arange(0, other_axis_side, 10):
# Compute the current pixel position
if axis == 'x':
x = x0
y = y0 + sampling_direction * mask_offset
else:
x = x0 + sampling_direction * mask_offset
y = y0
# If the position is not masked, stop searching for unmasked point
if mask.img[y, x] > 0:
unmasked_point_found = True
break
# Find azimuth and altitude at the given pixel, if a found unmask pixel was found along this
# line
if unmasked_point_found:
# Compute RA/Dec in J2000 of the image point, at J2000 epoch time so we don't have to precess
_, ra, dec, _ = xyToRaDecPP([jd2Date(J2000_JD.days)], [x], [y], [1], platepar, \
extinction_correction=False)
# Compute alt/az of the point
azim, alt = raDec2AltAz(ra[0], dec[0], J2000_JD.days,
platepar.lat, platepar.lon)
# Limit the elevation to 5 degrees above the horizon
if alt < 5:
alt = 5
# Compute the geo location of the point along the line of sight
p_lat, p_lon, p_elev = AEH2LatLonAlt(azim, alt, area_ht, platepar.lat, platepar.lon, \
platepar.elev)
side_points.append([x, y, p_lat, p_lon, p_elev])
# Add points from every side to the list (store a copy)
side_points_list.append(list(side_points))
# Postprocess the point list by removing points which intersect points on the previous side
side_points_list_filtered = []
for i, (n_sample, axis, c0, sampling_direction,
reverse_sampling) in enumerate(side_operations):
# Get the current and previous points list
side_points = side_points_list[i]
side_points_prev = side_points_list[i - 1]
# Remove all points from the list that intersect points on the previous side
side_points_filtered = []
for x, y, p_lat, p_lon, p_elev in side_points:
# Check all points from the previous side
skip_point = False
for entry_prev in side_points_prev:
x_prev, y_prev = entry_prev[:2]
# # Skip duplicates
# if (x == x_prev) and (y == y_prev):
# skip_point = True
# break
if axis == 'x':
if reverse_sampling:
if (y_prev < y) and (x_prev < x):
skip_point = True
break
else:
if (y_prev > y) and (x_prev > x):
skip_point = True
break
else:
if reverse_sampling:
if (y_prev < y) and (x_prev > x):
skip_point = True
break
else:
if (y_prev > y) and (x_prev < x):
skip_point = True
break
# If the point should not be skipped, add it to the final list
if not skip_point:
side_points_filtered.append([p_lat, p_lon, p_elev])
# print("ADDING = {:4d}, {:4d}, {:10.6f}, {:11.6f}, {:.2f}".format(int(x), int(y), p_lat, p_lon, p_elev))
# else:
# print("SKIPPING = {:4d}, {:4d}, {:10.6f}, {:11.6f}, {:.2f}".format(int(x), int(y), p_lat, p_lon, p_elev))
side_points_list_filtered.append(side_points_filtered)
return side_points_list_filtered
def alignPlatepar(config,
platepar,
calstars_time,
calstars_coords,
scale_update=False,
show_plot=False):
""" Align the platepar using FFT registration between catalog stars and the given list of image stars.
Arguments:
config:
platepar: [Platepar instance] Initial platepar.
calstars_time: [list] A list of (year, month, day, hour, minute, second, millisecond) of the middle of
the FF file used for alignment.
calstars_coords: [ndarray] A 2D numpy array of (x, y) coordinates of image stars.
Keyword arguments:
scale_update: [bool] Update the platepar scale. False by default.
show_plot: [bool] Show the comparison between the reference and image synthetic images.
Return:
platepar_aligned: [Platepar instance] The aligned platepar.
"""
# Create a copy of the config not to mess with the original config parameters
config = copy.deepcopy(config)
# Try to optimize the catalog limiting magnitude until the number of image and catalog stars are matched
maxiter = 10
search_fainter = True
mag_step = 0.2
for inum in range(maxiter):
# Load the catalog stars
catalog_stars, _, _ = StarCatalog.readStarCatalog(config.star_catalog_path, config.star_catalog_file, \
lim_mag=config.catalog_mag_limit, mag_band_ratios=config.star_catalog_band_ratios)
# Get the RA/Dec of the image centre
_, ra_centre, dec_centre, _ = ApplyAstrometry.xyToRaDecPP([calstars_time], [platepar.X_res/2], \
[platepar.Y_res/2], [1], platepar, extinction_correction=False)
ra_centre = ra_centre[0]
dec_centre = dec_centre[0]
# Compute Julian date
jd = date2JD(*calstars_time)
# Calculate the FOV radius in degrees
fov_y, fov_x = ApplyAstrometry.computeFOVSize(platepar)
fov_radius = np.sqrt(fov_x**2 + fov_y**2)
# Take only those stars which are inside the FOV
filtered_indices, _ = subsetCatalog(catalog_stars, ra_centre, dec_centre, jd, platepar.lat, \
platepar.lon, fov_radius, config.catalog_mag_limit)
# Take those catalog stars which should be inside the FOV
ra_catalog, dec_catalog, _ = catalog_stars[filtered_indices].T
catalog_xy = ApplyAstrometry.raDecToXYPP(ra_catalog, dec_catalog, jd,
platepar)
catalog_x, catalog_y = catalog_xy
catalog_xy = np.c_[catalog_x, catalog_y]
# Cut all stars that are outside image coordinates
catalog_xy = catalog_xy[catalog_xy[:, 0] > 0]
catalog_xy = catalog_xy[catalog_xy[:, 0] < config.width]
catalog_xy = catalog_xy[catalog_xy[:, 1] > 0]
catalog_xy = catalog_xy[catalog_xy[:, 1] < config.height]
# If there are more catalog than image stars, this means that the limiting magnitude is too faint
# and that the search should go in the brighter direction
if len(catalog_xy) > len(calstars_coords):
search_fainter = False
else:
search_fainter = True
# print('Catalog stars:', len(catalog_xy), 'Image stars:', len(calstars_coords), \
# 'Limiting magnitude:', config.catalog_mag_limit)
# Search in mag_step magnitude steps
if search_fainter:
config.catalog_mag_limit += mag_step
else:
config.catalog_mag_limit -= mag_step
print('Final catalog limiting magnitude:', config.catalog_mag_limit)
# Find the transform between the image coordinates and predicted platepar coordinates
res = findStarsTransform(config,
calstars_coords,
catalog_xy,
show_plot=show_plot)
angle, scale, translation_x, translation_y = res
### Update the platepar ###
platepar_aligned = copy.deepcopy(platepar)
# Correct the rotation
platepar_aligned.pos_angle_ref = (platepar_aligned.pos_angle_ref -
angle) % 360
# Update the scale if needed
if scale_update:
platepar_aligned.F_scale *= scale
# Compute the new reference RA and Dec
_, ra_centre_new, dec_centre_new, _ = ApplyAstrometry.xyToRaDecPP([jd2Date(platepar.JD)], \
[platepar.X_res/2 - platepar.x_poly_fwd[0] - translation_x], \
[platepar.Y_res/2 - platepar.y_poly_fwd[0] - translation_y], [1], platepar, \
extinction_correction=False)
# Correct RA/Dec
platepar_aligned.RA_d = ra_centre_new[0]
platepar_aligned.dec_d = dec_centre_new[0]
# # Update the reference time and hour angle
# platepar_aligned.JD = jd
# platepar_aligned.Ho = JD2HourAngle(jd)
# Recompute the FOV centre in Alt/Az and update the rotation
platepar_aligned.az_centre, platepar_aligned.alt_centre = raDec2AltAz(platepar.RA_d, \
platepar.dec_d, platepar.JD, platepar.lat, platepar.lon)
platepar_aligned.rotation_from_horiz = ApplyAstrometry.rotationWrtHorizon(
platepar_aligned)
###
return platepar_aligned
def collectingArea(platepar, mask=None, side_points=20, ht_min=60, ht_max=130, dht=2, elev_limit=10):
""" Compute the collecting area for the range of given heights.
Arguments:
platepar: [Platepar object]
Keyword arguments:
mask: [Mask object] Mask object, None by default.
side_points: [int] How many points to use to evaluate the FOV on seach side of the image. Normalized
to the longest side.
ht_min: [float] Minimum height (km).
ht_max: [float] Maximum height (km).
dht: [float] Height delta (km).
elev_limit: [float] Limit of elevation above horizon (deg). 10 degrees by default.
Return:
col_areas_ht: [dict] A dictionary where the keys are heights of area evaluation, and values are
segment dictionaries. Segment dictionaries have keys which are tuples of (x, y) coordinates of
segment midpoints, and values are segment collection areas corrected for sensor effects.
"""
# If the mask is not given, make a dummy mask with all white pixels
if mask is None:
mask = MaskStructure(255 + np.zeros((platepar.Y_res, platepar.X_res), dtype=np.uint8))
# Compute the number of samples for every image axis
longer_side_points = side_points
shorter_side_points = int(np.ceil(side_points*platepar.Y_res/platepar.X_res))
# Compute pixel delta for every side
longer_dpx = int(platepar.X_res//longer_side_points)
shorter_dpx = int(platepar.Y_res//shorter_side_points)
# Distionary of collection areas per height
col_areas_ht = collections.OrderedDict()
# Estimate the collection area for a given range of heights
for ht in np.arange(ht_min, ht_max + dht, dht):
# Convert the height to meters
ht = 1000*ht
print(ht/1000, "km")
total_area = 0
# Dictionary of computed sensor-corrected collection areas where X and Y are keys
col_areas_xy = collections.OrderedDict()
# Sample the image
for x0 in np.linspace(0, platepar.X_res, longer_side_points, dtype=np.int, endpoint=False):
for y0 in np.linspace(0, platepar.Y_res, shorter_side_points, dtype=np.int, endpoint=False):
# Compute lower right corners of the segment
xe = x0 + longer_dpx
ye = y0 + shorter_dpx
# Compute geo coordinates of the image corners (if the corner is below the elevation limit,
# the *_elev value will be -1)
_, ul_lat, ul_lon, ul_ht = xyHt2Geo(platepar, x0, y0, ht, indicate_limit=True, \
elev_limit=elev_limit)
_, ll_lat, ll_lon, ll_ht = xyHt2Geo(platepar, x0, ye, ht, indicate_limit=True, \
elev_limit=elev_limit)
_, lr_lat, lr_lon, lr_ht = xyHt2Geo(platepar, xe, ye, ht, indicate_limit=True, \
elev_limit=elev_limit)
_, ur_lat, ur_lon, ur_ht = xyHt2Geo(platepar, xe, y0, ht, indicate_limit=True, \
elev_limit=elev_limit)
# Skip the block if all corners are hitting the lower apparent elevation limit
if np.all([ul_ht < 0, ll_ht < 0, lr_ht < 0, ur_ht < 0]):
continue
# Make a polygon (clockwise direction)
lats = [ul_lat, ll_lat, lr_lat, ur_lat]
lons = [ul_lon, ll_lon, lr_lon, ur_lon]
# Compute the area of the polygon
area = areaGeoPolygon(lats, lons, ht)
### Apply sensitivity corrections to the area ###
# Compute ratio of masked portion of the segment
mask_segment = mask.img[y0:ye, x0:xe]
unmasked_ratio = 1 - np.count_nonzero(~mask_segment)/mask_segment.size
## Compute the pointing direction and the vignetting and extinction loss for the mean location
x_mean = (x0 + xe)/2
y_mean = (y0 + ye)/2
# Use a test pixel sum
test_px_sum = 400
# Compute the pointing direction and magnitude corrected for vignetting and extinction
_, ra, dec, mag = xyToRaDecPP([jd2Date(J2000_JD.days)], [x_mean], [y_mean], [test_px_sum], \
platepar)
azim, elev = raDec2AltAz(ra[0], dec[0], J2000_JD.days, platepar.lat, platepar.lon)
# Compute the pixel sum back assuming no corrections
rev_level = 10**((mag[0] - platepar.mag_lev)/(-2.5))
# Compute the sensitivty loss due to vignetting and extinction
sensitivity_ratio = test_px_sum/rev_level
# print(np.abs(np.hypot(x_mean - platepar.X_res/2, y_mean - platepar.Y_res/2)), sensitivity_ratio, mag[0])
##
# Compute the range correction (w.r.t 100 km) to the mean point
r, _, _, _ = xyHt2Geo(platepar, x_mean, y_mean, ht, indicate_limit=True, \
elev_limit=elev_limit)
# Correct the area for the masked portion
area *= unmasked_ratio
### ###
# Store the raw masked segment collection area, sensivitiy, and the range
col_areas_xy[(x_mean, y_mean)] = [area, azim, elev, sensitivity_ratio, r]
total_area += area
# Store segments to the height dictionary (save a copy so it doesn't get overwritten)
col_areas_ht[float(ht)] = dict(col_areas_xy)
print("SUM:", total_area/1e6, "km^2")
# Compare to total area computed from the whole area
side_points_list = fovArea(platepar, mask=mask, area_ht=ht, side_points=side_points, \
elev_limit=elev_limit)
lats = []
lons = []
for side in side_points_list:
for entry in side:
lats.append(entry[0])
lons.append(entry[1])
print("DIR:", areaGeoPolygon(lats, lons, ht)/1e6)
return col_areas_ht
def computeFlux(config, dir_path, ftpdetectinfo_path, shower_code, dt_beg, dt_end, timebin, mass_index, \
timebin_intdt=0.25, ht_std_percent=5.0, mask=None, show_plots=True):
""" Compute flux using measurements in the given FTPdetectinfo file.
Arguments:
config: [Config instance]
dir_path: [str] Path to the working directory.
ftpdetectinfo_path: [str] Path to a FTPdetectinfo file.
shower_code: [str] IAU shower code (e.g. ETA, PER, SDA).
dt_beg: [Datetime] Datetime object of the observation beginning.
dt_end: [Datetime] Datetime object of the observation end.
timebin: [float] Time bin in hours.
mass_index: [float] Cumulative mass index of the shower.
Keyword arguments:
timebin_intdt: [float] Time step for computing the integrated collection area in hours. 15 minutes by
default. If smaller than that, only one collection are will be computed.
ht_std_percent: [float] Meteor height standard deviation in percent.
mask: [Mask object] Mask object, None by default.
show_plots: [bool] Show flux plots. True by default.
Return:
[tuple] sol_data, flux_lm_6_5_data
- sol_data: [list] Array of solar longitudes (in degrees) of time bins.
- flux_lm6_5_data: [list] Array of meteoroid flux at the limiting magnitude of +6.5 in
meteors/1000km^2/h.
"""
# Get a list of files in the night folder
file_list = sorted(os.listdir(dir_path))
# Find and load the platepar file
if config.platepar_name in file_list:
# Load the platepar
platepar = Platepar.Platepar()
platepar.read(os.path.join(dir_path, config.platepar_name), use_flat=config.use_flat)
else:
print("Cannot find the platepar file in the night directory: ", config.platepar_name)
return None
# # Load FTPdetectinfos
# meteor_data = []
# for ftpdetectinfo_path in ftpdetectinfo_list:
# if not os.path.isfile(ftpdetectinfo_path):
# print('No such file:', ftpdetectinfo_path)
# continue
# meteor_data += readFTPdetectinfo(*os.path.split(ftpdetectinfo_path))
# Load meteor data from the FTPdetectinfo file
meteor_data = readFTPdetectinfo(*os.path.split(ftpdetectinfo_path))
if not len(meteor_data):
print("No meteors in the FTPdetectinfo file!")
return None
# Find and load recalibrated platepars
if config.platepars_recalibrated_name in file_list:
with open(os.path.join(dir_path, config.platepars_recalibrated_name)) as f:
recalibrated_platepars_dict = json.load(f)
print("Recalibrated platepars loaded!")
# If the file is not available, apply the recalibration procedure
else:
recalibrated_platepars_dict = applyRecalibrate(ftpdetectinfo_path, config)
print("Recalibrated platepar file not available!")
print("Recalibrating...")
# Convert the dictionary of recalibrated platepars to a dictionary of Platepar objects
recalibrated_platepars = {}
for ff_name in recalibrated_platepars_dict:
pp = Platepar.Platepar()
pp.loadFromDict(recalibrated_platepars_dict[ff_name], use_flat=config.use_flat)
recalibrated_platepars[ff_name] = pp
# Compute nighly mean of the photometric zero point
mag_lev_nightly_mean = np.mean([recalibrated_platepars[ff_name].mag_lev \
for ff_name in recalibrated_platepars])
# Locate and load the mask file
if config.mask_file in file_list:
mask_path = os.path.join(dir_path, config.mask_file)
mask = loadMask(mask_path)
print("Using mask:", mask_path)
else:
print("No mask used!")
mask = None
# Compute the population index using the classical equation
population_index = 10**((mass_index - 1)/2.5) # Found to be more consistent when comparing fluxes
#population_index = 10**((mass_index - 1)/2.3) # TEST !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
### SENSOR CHARACTERIZATION ###
# Computes FWHM of stars and noise profile of the sensor
# File which stores the sensor characterization profile
sensor_characterization_file = "flux_sensor_characterization.json"
sensor_characterization_path = os.path.join(dir_path, sensor_characterization_file)
# Load sensor characterization file if present, so the procedure can be skipped
if os.path.isfile(sensor_characterization_path):
# Load the JSON file
with open(sensor_characterization_path) as f:
data = " ".join(f.readlines())
sensor_data = json.loads(data)
# Remove the info entry
if '-1' in sensor_data:
del sensor_data['-1']
else:
# Run sensor characterization
sensor_data = sensorCharacterization(config, dir_path)
# Save to file for posterior use
with open(sensor_characterization_path, 'w') as f:
# Add an explanation what each entry means
sensor_data_save = dict(sensor_data)
sensor_data_save['-1'] = {"FF file name": ['median star FWHM', 'median background noise stddev']}
# Convert collection areas to JSON
out_str = json.dumps(sensor_data_save, indent=4, sort_keys=True)
# Save to disk
f.write(out_str)
# Compute the nighly mean FWHM and noise stddev
fwhm_nightly_mean = np.mean([sensor_data[key][0] for key in sensor_data])
stddev_nightly_mean = np.mean([sensor_data[key][1] for key in sensor_data])
### ###
# Perform shower association
associations, _ = showerAssociation(config, [ftpdetectinfo_path], shower_code=shower_code, \
show_plot=False, save_plot=False, plot_activity=False)
# Init the flux configuration
flux_config = FluxConfig()
# Remove all meteors which begin below the limit height
filtered_associations = {}
for key in associations:
meteor, shower = associations[key]
if meteor.beg_alt > flux_config.elev_limit:
print("Rejecting:", meteor.jdt_ref)
filtered_associations[key] = [meteor, shower]
associations = filtered_associations
# If there are no shower association, return nothing
if not associations:
print("No meteors associated with the shower!")
return None
# Print the list of used meteors
peak_mags = []
for key in associations:
meteor, shower = associations[key]
if shower is not None:
# Compute peak magnitude
peak_mag = np.min(meteor.mag_array)
peak_mags.append(peak_mag)
print("{:.6f}, {:3s}, {:+.2f}".format(meteor.jdt_ref, shower.name, peak_mag))
print()
### COMPUTE COLLECTION AREAS ###
# Make a file name to save the raw collection areas
col_areas_file_name = generateColAreaJSONFileName(platepar.station_code, flux_config.side_points, \
flux_config.ht_min, flux_config.ht_max, flux_config.dht, flux_config.elev_limit)
# Check if the collection area file exists. If yes, load the data. If not, generate collection areas
if col_areas_file_name in os.listdir(dir_path):
col_areas_ht = loadRawCollectionAreas(dir_path, col_areas_file_name)
print("Loaded collection areas from:", col_areas_file_name)
else:
# Compute the collecting areas segments per height
col_areas_ht = collectingArea(platepar, mask=mask, side_points=flux_config.side_points, \
ht_min=flux_config.ht_min, ht_max=flux_config.ht_max, dht=flux_config.dht, \
elev_limit=flux_config.elev_limit)
# Save the collection areas to file
saveRawCollectionAreas(dir_path, col_areas_file_name, col_areas_ht)
print("Saved raw collection areas to:", col_areas_file_name)
### ###
# Compute the raw collection area at the height of 100 km
col_area_100km_raw = 0
col_areas_100km_blocks = col_areas_ht[100000.0]
for block in col_areas_100km_blocks:
col_area_100km_raw += col_areas_100km_blocks[block][0]
print("Raw collection area at height of 100 km: {:.2f} km^2".format(col_area_100km_raw/1e6))
# Compute the pointing of the middle of the FOV
_, ra_mid, dec_mid, _ = xyToRaDecPP([jd2Date(J2000_JD.days)], [platepar.X_res/2], [platepar.Y_res/2], \
[1], platepar, extinction_correction=False)
azim_mid, elev_mid = raDec2AltAz(ra_mid[0], dec_mid[0], J2000_JD.days, platepar.lat, platepar.lon)
# Compute the range to the middle point
ref_ht = 100000
r_mid, _, _, _ = xyHt2Geo(platepar, platepar.X_res/2, platepar.Y_res/2, ref_ht, indicate_limit=True, \
elev_limit=flux_config.elev_limit)
print("Range at 100 km in the middle of the image: {:.2f} km".format(r_mid/1000))
### Compute the average angular velocity to which the flux variation throught the night will be normalized
# The ang vel is of the middle of the FOV in the middle of observations
# Middle Julian date of the night
jd_night_mid = (datetime2JD(dt_beg) + datetime2JD(dt_end))/2
# Compute the apparent radiant
ra, dec, v_init = shower.computeApparentRadiant(platepar.lat, platepar.lon, jd_night_mid)
# Compute the radiant elevation
radiant_azim, radiant_elev = raDec2AltAz(ra, dec, jd_night_mid, platepar.lat, platepar.lon)
# Compute the angular velocity in the middle of the FOV
rad_dist_night_mid = angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev),
np.radians(azim_mid), np.radians(elev_mid))
ang_vel_night_mid = v_init*np.sin(rad_dist_night_mid)/r_mid
###
# Compute the average limiting magnitude to which all flux will be normalized
# Standard deviation of star PSF, nightly mean (px)
star_stddev = fwhm_nightly_mean/2.355
# # Compute the theoretical stellar limiting magnitude (nightly average)
# star_sum = 2*np.pi*(config.k1_det*stddev_nightly_mean + config.j1_det)*star_stddev**2
# lm_s_nightly_mean = -2.5*np.log10(star_sum) + mag_lev_nightly_mean
# Compute the theoretical stellar limiting magnitude using an empirical model (nightly average)
lm_s_nightly_mean = stellarLMModel(mag_lev_nightly_mean)
# A meteor needs to be visible on at least 4 frames, thus it needs to have at least 4x the mass to produce
# that amount of light. 1 magnitude difference scales as -0.4 of log of mass, thus:
# frame_min_loss = np.log10(config.line_minimum_frame_range_det)/(-0.4)
frame_min_loss = 0.0 # TEST !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11
print("Frame min loss: {:.2} mag".format(frame_min_loss))
lm_s_nightly_mean += frame_min_loss
# Compute apparent meteor magnitude
lm_m_nightly_mean = lm_s_nightly_mean - 5*np.log10(r_mid/1e5) - 2.5*np.log10( \
np.degrees(platepar.F_scale*v_init*np.sin(rad_dist_night_mid)/(config.fps*r_mid*fwhm_nightly_mean)) \
)
#
print("Stellar lim mag using detection thresholds:", lm_s_nightly_mean)
print("Apparent meteor limiting magnitude:", lm_m_nightly_mean)
### Apply time-dependent corrections ###
# Track values used for flux
sol_data = []
flux_lm_6_5_data = []
meteor_num_data = []
effective_collection_area_data = []
radiant_elev_data = []
radiant_dist_mid_data = []
ang_vel_mid_data = []
lm_s_data = []
lm_m_data = []
sensitivity_corr_data = []
range_corr_data = []
radiant_elev_corr_data = []
ang_vel_corr_data = []
total_corr_data = []
# Go through all time bins within the observation period
total_time_hrs = (dt_end - dt_beg).total_seconds()/3600
nbins = int(np.ceil(total_time_hrs/timebin))
for t_bin in range(nbins):
for subbin in range(flux_config.sub_time_bins):
# Compute bin start and end time
bin_dt_beg = dt_beg + datetime.timedelta(hours=(timebin*t_bin + timebin*subbin/flux_config.sub_time_bins))
bin_dt_end = bin_dt_beg + datetime.timedelta(hours=timebin)
if bin_dt_end > dt_end:
bin_dt_end = dt_end
# Compute bin duration in hours
bin_hours = (bin_dt_end - bin_dt_beg).total_seconds()/3600
# Convert to Julian date
bin_jd_beg = datetime2JD(bin_dt_beg)
bin_jd_end = datetime2JD(bin_dt_end)
jd_mean = (bin_jd_beg + bin_jd_end)/2
# Compute the mean solar longitude
sol_mean = np.degrees(jd2SolLonSteyaert(jd_mean))
### Compute the radiant elevation at the middle of the time bin ###
# Compute the apparent radiant
ra, dec, v_init = shower.computeApparentRadiant(platepar.lat, platepar.lon, jd_mean)
# Compute the mean meteor height
meteor_ht_beg = heightModel(v_init, ht_type='beg')
meteor_ht_end = heightModel(v_init, ht_type='end')
meteor_ht = (meteor_ht_beg + meteor_ht_end)/2
# Compute the standard deviation of the height
meteor_ht_std = meteor_ht*ht_std_percent/100.0
# Init the Gaussian height distribution
meteor_ht_gauss = scipy.stats.norm(meteor_ht, meteor_ht_std)
# Compute the radiant elevation
radiant_azim, radiant_elev = raDec2AltAz(ra, dec, jd_mean, platepar.lat, platepar.lon)
# Only select meteors in this bin and not too close to the radiant
bin_meteors = []
bin_ffs = []
for key in associations:
meteor, shower = associations[key]
if shower is not None:
if (shower.name == shower_code) and (meteor.jdt_ref > bin_jd_beg) \
and (meteor.jdt_ref <= bin_jd_end):
# Filter out meteors ending too close to the radiant
if np.degrees(angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev), \
np.radians(meteor.end_azim), np.radians(meteor.end_alt))) >= flux_config.rad_dist_min:
bin_meteors.append([meteor, shower])
bin_ffs.append(meteor.ff_name)
### ###
print()
print()
print("-- Bin information ---")
print("Bin beg:", bin_dt_beg)
print("Bin end:", bin_dt_end)
print("Sol mid: {:.5f}".format(sol_mean))
print("Radiant elevation: {:.2f} deg".format(radiant_elev))
print("Apparent speed: {:.2f} km/s".format(v_init/1000))
# If the elevation of the radiant is below the limit, skip this bin
if radiant_elev < flux_config.rad_elev_limit:
print("!!! Mean radiant elevation below {:.2f} deg threshold, skipping time bin!".format(flux_config.rad_elev_limit))
continue
# The minimum duration of the time bin should be larger than 50% of the given dt
if bin_hours < 0.5*timebin:
print("!!! Time bin duration of {:.2f} h is shorter than 0.5x of the time bin!".format(bin_hours))
continue
if len(bin_meteors) >= flux_config.meteros_min:
print("Meteors:", len(bin_meteors))
### Weight collection area by meteor height distribution ###
# Determine weights for each height
weight_sum = 0
weights = {}
for ht in col_areas_ht:
wt = meteor_ht_gauss.pdf(float(ht))
weight_sum += wt
weights[ht] = wt
# Normalize the weights so that the sum is 1
for ht in weights:
weights[ht] /= weight_sum
### ###
col_area_meteor_ht_raw = 0
for ht in col_areas_ht:
for block in col_areas_ht[ht]:
col_area_meteor_ht_raw += weights[ht]*col_areas_ht[ht][block][0]
print("Raw collection area at meteor heights: {:.2f} km^2".format(col_area_meteor_ht_raw/1e6))
# Compute the angular velocity in the middle of the FOV
rad_dist_mid = angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev),
np.radians(azim_mid), np.radians(elev_mid))
ang_vel_mid = v_init*np.sin(rad_dist_mid)/r_mid
### Compute the limiting magnitude ###
# Compute the mean star FWHM in the given bin
fwhm_bin_mean = np.mean([sensor_data[ff_name][0] for ff_name in bin_ffs])
# Compute the mean background stddev in the given bin
stddev_bin_mean = np.mean([sensor_data[ff_name][1] for ff_name in bin_ffs])
# Compute the mean photometric zero point in the given bin
mag_lev_bin_mean = np.mean([recalibrated_platepars[ff_name].mag_lev for ff_name in bin_ffs if ff_name in recalibrated_platepars])
# # Standard deviation of star PSF, nightly mean (px)
# star_stddev = fwhm_bin_mean/2.355
# Compute the theoretical stellar limiting magnitude (bin average)
# star_sum = 2*np.pi*(config.k1_det*stddev_bin_mean + config.j1_det)*star_stddev**2
# lm_s = -2.5*np.log10(star_sum) + mag_lev_bin_mean
# Use empirical LM calculation
lm_s = stellarLMModel(mag_lev_bin_mean)
lm_s += frame_min_loss
# ### TEST !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11
# # Artificialy increase limiting magnitude
# lm_s += 1.2
# #####
# Compute apparent meteor magnitude
lm_m = lm_s - 5*np.log10(r_mid/1e5) - 2.5*np.log10( \
np.degrees(platepar.F_scale*v_init*np.sin(rad_dist_mid)/(config.fps*r_mid*fwhm_bin_mean)))
### ###
# Final correction area value (height-weightned)
collection_area = 0
# Keep track of the corrections
sensitivity_corr_arr = []
range_corr_arr = []
radiant_elev_corr_arr = []
ang_vel_corr_arr = []
total_corr_arr = []
col_area_raw_arr = []
col_area_eff_arr = []
col_area_eff_block_dict = {}
# Go through all heights and segment blocks
for ht in col_areas_ht:
for img_coords in col_areas_ht[ht]:
x_mean, y_mean = img_coords
# Unpack precomputed values
area, azim, elev, sensitivity_ratio, r = col_areas_ht[ht][img_coords]
# Compute the angular velocity (rad/s) in the middle of this block
rad_dist = angularSeparation(np.radians(radiant_azim), np.radians(radiant_elev),
np.radians(azim), np.radians(elev))
ang_vel = v_init*np.sin(rad_dist)/r
# If the angular distance from the radiant is less than 15 deg, don't use the block
# in the effective collection area
if np.degrees(rad_dist) < flux_config.rad_dist_min:
area = 0.0
# Compute the range correction
range_correction = (1e5/r)**2
#ang_vel_correction = ang_vel/ang_vel_mid
# Compute angular velocity correction relative to the nightly mean
ang_vel_correction = ang_vel/ang_vel_night_mid
### Apply corrections
correction_ratio = 1.0
# Correct the area for vignetting and extinction
sensitivity_corr_arr.append(sensitivity_ratio)
correction_ratio *= sensitivity_ratio
# Correct for the range (cap to an order of magnitude correction)
range_correction = max(range_correction, 0.1)
range_corr_arr.append(range_correction)
correction_ratio *= range_correction
# Correct for the radiant elevation (cap to an order of magnitude correction)
radiant_elev_correction = np.sin(np.radians(radiant_elev))
radiant_elev_correction = max(radiant_elev_correction, 0.1)
radiant_elev_corr_arr.append(radiant_elev_correction)
correction_ratio *= radiant_elev_correction
# Correct for angular velocity (cap to an order of magnitude correction)
ang_vel_correction = min(max(ang_vel_correction, 0.1), 10)
correction_ratio *= ang_vel_correction
ang_vel_corr_arr.append(ang_vel_correction)
# Add the collection area to the final estimate with the height weight
# Raise the correction to the mass index power
total_correction = correction_ratio**(mass_index - 1)
total_correction = min(max(total_correction, 0.1), 10)
collection_area += weights[ht]*area*total_correction
total_corr_arr.append(total_correction)
col_area_raw_arr.append(weights[ht]*area)
col_area_eff_arr.append(weights[ht]*area*total_correction)
if img_coords not in col_area_eff_block_dict:
col_area_eff_block_dict[img_coords] = []
col_area_eff_block_dict[img_coords].append(weights[ht]*area*total_correction)
# Compute mean corrections
sensitivity_corr_avg = np.mean(sensitivity_corr_arr)
range_corr_avg = np.mean(range_corr_arr)
radiant_elev_corr_avg = np.mean(radiant_elev_corr_arr)
ang_vel_corr_avg = np.mean(ang_vel_corr_arr)
total_corr_avg = np.median(total_corr_arr)
col_area_raw_sum = np.sum(col_area_raw_arr)
col_area_eff_sum = np.sum(col_area_eff_arr)
print("Raw collection area at meteor heights (CHECK): {:.2f} km^2".format(col_area_raw_sum/1e6))
print("Eff collection area at meteor heights (CHECK): {:.2f} km^2".format(col_area_eff_sum/1e6))
# ### PLOT HOW THE CORRECTION VARIES ACROSS THE FOV
# x_arr = []
# y_arr = []
# col_area_eff_block_arr = []
# for img_coords in col_area_eff_block_dict:
# x_mean, y_mean = img_coords
# #if x_mean not in x_arr:
# x_arr.append(x_mean)
# #if y_mean not in y_arr:
# y_arr.append(y_mean)
# col_area_eff_block_arr.append(np.sum(col_area_eff_block_dict[img_coords]))
# x_unique = np.unique(x_arr)
# y_unique = np.unique(y_arr)
# # plt.pcolormesh(x_arr, y_arr, np.array(col_area_eff_block_arr).reshape(len(x_unique), len(y_unique)).T, shading='auto')
# plt.title("TOTAL = " + str(np.sum(col_area_eff_block_arr)/1e6))
# plt.scatter(x_arr, y_arr, c=np.array(col_area_eff_block_arr)/1e6)
# #plt.pcolor(np.array(x_arr).reshape(len(x_unique), len(y_unique)), np.array(y_arr).reshape(len(x_unique), len(y_unique)), np.array(col_area_eff_block_arr).reshape(len(x_unique), len(y_unique))/1e6)
# plt.colorbar(label="km^2")
# plt.gca().invert_yaxis()
# plt.show()
# ###
# Compute the flux at the bin LM (meteors/1000km^2/h)
flux = 1e9*len(bin_meteors)/collection_area/bin_hours
# Compute the flux scaled to the nightly mean LM
flux_lm_nightly_mean = flux*population_index**(lm_m_nightly_mean - lm_m)
# Compute the flux scaled to +6.5M
flux_lm_6_5 = flux*population_index**(6.5 - lm_m)
print("-- Sensor information ---")
print("Star FWHM: {:5.2f} px".format(fwhm_bin_mean))
print("Bkg stddev: {:4.1f} ADU".format(stddev_bin_mean))
print("Photom ZP: {:+6.2f} mag".format(mag_lev_bin_mean))
print("Stellar LM: {:+.2f} mag".format(lm_s))
print("-- Flux ---")
print("Meteors: {:d}".format(len(bin_meteors)))
print("Col area: {:d} km^2".format(int(collection_area/1e6)))
print("Ang vel: {:.2f} deg/s".format(np.degrees(ang_vel_mid)))
print("LM app: {:+.2f} mag".format(lm_m))
print("Flux: {:.2f} meteors/1000km^2/h".format(flux))
print("to {:+.2f}: {:.2f} meteors/1000km^2/h".format(lm_m_nightly_mean, flux_lm_nightly_mean))
print("to +6.50: {:.2f} meteors/1000km^2/h".format(flux_lm_6_5))
sol_data.append(sol_mean)
flux_lm_6_5_data.append(flux_lm_6_5)
meteor_num_data.append(len(bin_meteors))
effective_collection_area_data.append(collection_area)
radiant_elev_data.append(radiant_elev)
radiant_dist_mid_data.append(np.degrees(rad_dist_mid))
ang_vel_mid_data.append(np.degrees(ang_vel_mid))
lm_s_data.append(lm_s)
lm_m_data.append(lm_m)
sensitivity_corr_data.append(sensitivity_corr_avg)
range_corr_data.append(range_corr_avg)
radiant_elev_corr_data.append(radiant_elev_corr_avg)
ang_vel_corr_data.append(ang_vel_corr_avg)
total_corr_data.append(total_corr_avg)
# Print the results
print("Solar longitude, Flux at LM +6.5:")
for sol, flux_lm_6_5 in zip(sol_data, flux_lm_6_5_data):
print("{:9.5f}, {:8.4f}".format(sol, flux_lm_6_5))
if show_plots and len(sol_data):
# Plot a histogram of peak magnitudes
plt.hist(peak_mags, cumulative=True, log=True, bins=len(peak_mags), density=True)
# Plot population index
r_intercept = -0.7
x_arr = np.linspace(np.min(peak_mags), np.percentile(peak_mags, 60))
plt.plot(x_arr, 10**(np.log10(population_index)*x_arr + r_intercept))
plt.title("r = {:.2f}".format(population_index))
plt.show()
# Plot how the derived values change throughout the night
fig, axes \
= plt.subplots(nrows=4, ncols=2, sharex=True, figsize=(10, 8))
((ax_met, ax_lm),
(ax_rad_elev, ax_corrs),
(ax_rad_dist, ax_col_area),
(ax_ang_vel, ax_flux)) = axes
fig.suptitle("{:s}, s = {:.2f}, r = {:.2f}".format(shower_code, mass_index, population_index))
ax_met.scatter(sol_data, meteor_num_data)
ax_met.set_ylabel("Meteors")
ax_rad_elev.plot(sol_data, radiant_elev_data)
ax_rad_elev.set_ylabel("Radiant elev (deg)")
ax_rad_dist.plot(sol_data, radiant_dist_mid_data)
ax_rad_dist.set_ylabel("Radiant dist (deg)")
ax_ang_vel.plot(sol_data, ang_vel_mid_data)
ax_ang_vel.set_ylabel("Ang vel (deg/s)")
ax_ang_vel.set_xlabel("La Sun (deg)")
ax_lm.plot(sol_data, lm_s_data, label="Stellar")
ax_lm.plot(sol_data, lm_m_data, label="Meteor")
ax_lm.set_ylabel("LM")
ax_lm.legend()
ax_corrs.plot(sol_data, sensitivity_corr_data, label="Sensitivity")
ax_corrs.plot(sol_data, range_corr_data, label="Range")
ax_corrs.plot(sol_data, radiant_elev_corr_data, label="Rad elev")
ax_corrs.plot(sol_data, ang_vel_corr_data, label="Ang vel")
ax_corrs.plot(sol_data, total_corr_data, label="Total (median)")
ax_corrs.set_ylabel("Corrections")
ax_corrs.legend()
ax_col_area.plot(sol_data, np.array(effective_collection_area_data)/1e6)
ax_col_area.plot(sol_data, len(sol_data)*[col_area_100km_raw/1e6], color='k', \
label="Raw col area at 100 km")
ax_col_area.plot(sol_data, len(sol_data)*[col_area_meteor_ht_raw/1e6], color='k', linestyle='dashed', \
label="Raw col area at met ht")
ax_col_area.set_ylabel("Eff. col. area (km^2)")
ax_col_area.legend()
ax_flux.scatter(sol_data, flux_lm_6_5_data)
ax_flux.set_ylabel("Flux@+6.5M (met/1000km^2/h)")
ax_flux.set_xlabel("La Sun (deg)")
plt.tight_layout()
plt.show()
return sol_data, flux_lm_6_5_data
def generateCalibrationReport(config,
night_dir_path,
match_radius=2.0,
platepar=None,
show_graphs=False):
""" Given the folder of the night, find the Calstars file, check the star fit and generate a report
with the quality of the calibration. The report contains information about both the astrometry and
the photometry calibration. Graphs will be saved in the given directory of the night.
Arguments:
config: [Config instance]
night_dir_path: [str] Full path to the directory of the night.
Keyword arguments:
match_radius: [float] Match radius for star matching between image and catalog stars (px).
platepar: [Platepar instance] Use this platepar instead of finding one in the folder.
show_graphs: [bool] Show the graphs on the screen. False by default.
Return:
None
"""
# Find the CALSTARS file in the given folder
calstars_file = None
for calstars_file in os.listdir(night_dir_path):
if ('CALSTARS' in calstars_file) and ('.txt' in calstars_file):
break
if calstars_file is None:
print('CALSTARS file could not be found in the given directory!')
return None
# Load the calstars file
star_list = readCALSTARS(night_dir_path, calstars_file)
### Load recalibrated platepars, if they exist ###
# Find recalibrated platepars file per FF file
platepars_recalibrated_file = None
for file_name in os.listdir(night_dir_path):
if file_name == config.platepars_recalibrated_name:
platepars_recalibrated_file = file_name
break
# Load all recalibrated platepars if the file is available
recalibrated_platepars = None
if platepars_recalibrated_file:
with open(os.path.join(night_dir_path,
platepars_recalibrated_file)) as f:
recalibrated_platepars = json.load(f)
print(
'Loaded recalibrated platepars JSON file for the calibration report...'
)
### ###
### Load the platepar file ###
# Find the platepar file in the given directory if it was not given
if platepar is None:
# Find the platepar file
platepar_file = None
for file_name in os.listdir(night_dir_path):
if file_name == config.platepar_name:
platepar_file = file_name
break
if platepar_file is None:
print('The platepar cannot be found in the night directory!')
return None
# Load the platepar file
platepar = Platepar()
platepar.read(os.path.join(night_dir_path, platepar_file),
use_flat=config.use_flat)
### ###
night_name = os.path.split(night_dir_path.strip(os.sep))[1]
# Go one mag deeper than in the config
lim_mag = config.catalog_mag_limit + 1
# Load catalog stars (load one magnitude deeper)
catalog_stars, mag_band_str, config.star_catalog_band_ratios = StarCatalog.readStarCatalog(\
config.star_catalog_path, config.star_catalog_file, lim_mag=lim_mag, \
mag_band_ratios=config.star_catalog_band_ratios)
### Take only those CALSTARS entires for which FF files exist in the folder ###
# Get a list of FF files in the folder
ff_list = []
for file_name in os.listdir(night_dir_path):
if validFFName(file_name):
ff_list.append(file_name)
# Filter out calstars entries, generate a star dictionary where the keys are JDs of FFs
star_dict = {}
ff_dict = {}
for entry in star_list:
ff_name, star_data = entry
# Check if the FF from CALSTARS exists in the folder
if ff_name not in ff_list:
continue
dt = getMiddleTimeFF(ff_name, config.fps, ret_milliseconds=True)
jd = date2JD(*dt)
# Add the time and the stars to the dict
star_dict[jd] = star_data
ff_dict[jd] = ff_name
### ###
# If there are no FF files in the directory, don't generate a report
if len(star_dict) == 0:
print('No FF files from the CALSTARS file in the directory!')
return None
# If the recalibrated platepars file exists, take the one with the most stars
max_jd = 0
using_recalib_platepars = False
if recalibrated_platepars is not None:
max_stars = 0
for ff_name_temp in recalibrated_platepars:
# Compute the Julian date of the FF middle
dt = getMiddleTimeFF(ff_name_temp,
config.fps,
ret_milliseconds=True)
jd = date2JD(*dt)
# Check that this file exists in CALSTARS and the list of FF files
if (jd not in star_dict) or (jd not in ff_dict):
continue
# Check if the number of stars on this FF file is larger than the before
if len(star_dict[jd]) > max_stars:
max_jd = jd
max_stars = len(star_dict[jd])
# Set a flag to indicate if using recalibrated platepars has failed
if max_jd == 0:
using_recalib_platepars = False
else:
print('Using recalibrated platepars, file:', ff_dict[max_jd])
using_recalib_platepars = True
# Select the platepar where the FF file has the most stars
platepar_dict = recalibrated_platepars[ff_dict[max_jd]]
platepar = Platepar()
platepar.loadFromDict(platepar_dict, use_flat=config.use_flat)
filtered_star_dict = {max_jd: star_dict[max_jd]}
# Match stars on the image with the stars in the catalog
n_matched, avg_dist, cost, matched_stars = matchStarsResiduals(config, platepar, catalog_stars, \
filtered_star_dict, match_radius, ret_nmatch=True, lim_mag=lim_mag)
max_matched_stars = n_matched
# Otherwise take the optimal FF file for evaluation
if (recalibrated_platepars is None) or (not using_recalib_platepars):
# If there are more than a set number of FF files to evaluate, choose only the ones with most stars on
# the image
if len(star_dict) > config.calstars_files_N:
# Find JDs of FF files with most stars on them
top_nstars_indices = np.argsort([len(x) for x in star_dict.values()])[::-1][:config.calstars_files_N \
- 1]
filtered_star_dict = {}
for i in top_nstars_indices:
filtered_star_dict[list(star_dict.keys())[i]] = list(
star_dict.values())[i]
star_dict = filtered_star_dict
# Match stars on the image with the stars in the catalog
n_matched, avg_dist, cost, matched_stars = matchStarsResiduals(config, platepar, catalog_stars, \
star_dict, match_radius, ret_nmatch=True, lim_mag=lim_mag)
# If no recalibrated platepars where found, find the image with the largest number of matched stars
if (not using_recalib_platepars) or (max_jd == 0):
max_jd = 0
max_matched_stars = 0
for jd in matched_stars:
_, _, distances = matched_stars[jd]
if len(distances) > max_matched_stars:
max_jd = jd
max_matched_stars = len(distances)
# If there are no matched stars, use the image with the largest number of detected stars
if max_matched_stars <= 2:
max_jd = max(star_dict, key=lambda x: len(star_dict[x]))
distances = [np.inf]
# Take the FF file with the largest number of matched stars
ff_name = ff_dict[max_jd]
# Load the FF file
ff = readFF(night_dir_path, ff_name)
img_h, img_w = ff.avepixel.shape
dpi = 200
plt.figure(figsize=(ff.avepixel.shape[1] / dpi,
ff.avepixel.shape[0] / dpi),
dpi=dpi)
# Take the average pixel
img = ff.avepixel
# Slightly adjust the levels
img = Image.adjustLevels(img, np.percentile(img, 1.0), 1.3,
np.percentile(img, 99.99))
plt.imshow(img, cmap='gray', interpolation='nearest')
legend_handles = []
# Plot detected stars
for img_star in star_dict[max_jd]:
y, x, _, _ = img_star
rect_side = 5 * match_radius
square_patch = plt.Rectangle((x - rect_side/2, y - rect_side/2), rect_side, rect_side, color='g', \
fill=False, label='Image stars')
plt.gca().add_artist(square_patch)
legend_handles.append(square_patch)
# If there are matched stars, plot them
if max_matched_stars > 2:
# Take the solution with the largest number of matched stars
image_stars, matched_catalog_stars, distances = matched_stars[max_jd]
# Plot matched stars
for img_star in image_stars:
x, y, _, _ = img_star
circle_patch = plt.Circle((y, x), radius=3*match_radius, color='y', fill=False, \
label='Matched stars')
plt.gca().add_artist(circle_patch)
legend_handles.append(circle_patch)
### Plot match residuals ###
# Compute preducted positions of matched image stars from the catalog
x_predicted, y_predicted = raDecToXYPP(matched_catalog_stars[:, 0], \
matched_catalog_stars[:, 1], max_jd, platepar)
img_y, img_x, _, _ = image_stars.T
delta_x = x_predicted - img_x
delta_y = y_predicted - img_y
# Compute image residual and angle of the error
res_angle = np.arctan2(delta_y, delta_x)
res_distance = np.sqrt(delta_x**2 + delta_y**2)
# Calculate coordinates of the beginning of the residual line
res_x_beg = img_x + 3 * match_radius * np.cos(res_angle)
res_y_beg = img_y + 3 * match_radius * np.sin(res_angle)
# Calculate coordinates of the end of the residual line
res_x_end = img_x + 100 * np.cos(res_angle) * res_distance
res_y_end = img_y + 100 * np.sin(res_angle) * res_distance
# Plot the 100x residuals
for i in range(len(x_predicted)):
res_plot = plt.plot([res_x_beg[i], res_x_end[i]], [res_y_beg[i], res_y_end[i]], color='orange', \
lw=0.5, label='100x residuals')
legend_handles.append(res_plot[0])
### ###
else:
distances = [np.inf]
# If there are no matched stars, plot large text in the middle of the screen
plt.text(img_w / 2,
img_h / 2,
"NO MATCHED STARS!",
color='r',
alpha=0.5,
fontsize=20,
ha='center',
va='center')
### Plot positions of catalog stars to the limiting magnitude of the faintest matched star + 1 mag ###
# Find the faintest magnitude among matched stars
if max_matched_stars > 2:
faintest_mag = np.max(matched_catalog_stars[:, 2]) + 1
else:
# If there are no matched stars, use the limiting magnitude from config
faintest_mag = config.catalog_mag_limit + 1
# Estimate RA,dec of the centre of the FOV
_, RA_c, dec_c, _ = xyToRaDecPP([jd2Date(max_jd)], [platepar.X_res / 2],
[platepar.Y_res / 2], [1], platepar)
RA_c = RA_c[0]
dec_c = dec_c[0]
fov_radius = np.hypot(*computeFOVSize(platepar))
# Get stars from the catalog around the defined center in a given radius
_, extracted_catalog = subsetCatalog(catalog_stars, RA_c, dec_c,
fov_radius, faintest_mag)
ra_catalog, dec_catalog, mag_catalog = extracted_catalog.T
# Compute image positions of all catalog stars that should be on the image
x_catalog, y_catalog = raDecToXYPP(ra_catalog, dec_catalog, max_jd,
platepar)
# Filter all catalog stars outside the image
temp_arr = np.c_[x_catalog, y_catalog, mag_catalog]
temp_arr = temp_arr[temp_arr[:, 0] >= 0]
temp_arr = temp_arr[temp_arr[:, 0] <= ff.avepixel.shape[1]]
temp_arr = temp_arr[temp_arr[:, 1] >= 0]
temp_arr = temp_arr[temp_arr[:, 1] <= ff.avepixel.shape[0]]
x_catalog, y_catalog, mag_catalog = temp_arr.T
# Plot catalog stars on the image
cat_stars_handle = plt.scatter(x_catalog, y_catalog, c='none', marker='D', lw=1.0, alpha=0.4, \
s=((4.0 + (faintest_mag - mag_catalog))/3.0)**(2*2.512), edgecolor='r', label='Catalog stars')
legend_handles.append(cat_stars_handle)
### ###
# Add info text in the corner
info_text = ff_dict[max_jd] + '\n' \
+ "Matched stars within {:.1f} px radius: {:d}/{:d} \n".format(match_radius, max_matched_stars, \
len(star_dict[max_jd])) \
+ "Median distance = {:.2f} px\n".format(np.median(distances)) \
+ "Catalog lim mag = {:.1f}".format(lim_mag)
plt.text(10, 10, info_text, bbox=dict(facecolor='black', alpha=0.5), va='top', ha='left', fontsize=4, \
color='w', family='monospace')
legend = plt.legend(handles=legend_handles,
prop={'size': 4},
loc='upper right')
legend.get_frame().set_facecolor('k')
legend.get_frame().set_edgecolor('k')
for txt in legend.get_texts():
txt.set_color('w')
### Add FOV info (centre, size) ###
# Mark FOV centre
plt.scatter(platepar.X_res / 2,
platepar.Y_res / 2,
marker='+',
s=20,
c='r',
zorder=4)
# Compute FOV centre alt/az
azim_centre, alt_centre = raDec2AltAz(max_jd, platepar.lon, platepar.lat,
RA_c, dec_c)
# Compute FOV size
fov_h, fov_v = computeFOVSize(platepar)
# Compute the rotation wrt. horizon
rot_horizon = rotationWrtHorizon(platepar)
fov_centre_text = "Azim = {:6.2f}$\\degree$\n".format(azim_centre) \
+ "Alt = {:6.2f}$\\degree$\n".format(alt_centre) \
+ "Rot h = {:6.2f}$\\degree$\n".format(rot_horizon) \
+ "FOV h = {:6.2f}$\\degree$\n".format(fov_h) \
+ "FOV v = {:6.2f}$\\degree$".format(fov_v) \
plt.text(10, platepar.Y_res - 10, fov_centre_text, bbox=dict(facecolor='black', alpha=0.5), \
va='bottom', ha='left', fontsize=4, color='w', family='monospace')
### ###
# Plot RA/Dec gridlines #
addEquatorialGrid(plt, platepar, max_jd)
plt.axis('off')
plt.gca().get_xaxis().set_visible(False)
plt.gca().get_yaxis().set_visible(False)
plt.xlim([0, ff.avepixel.shape[1]])
plt.ylim([ff.avepixel.shape[0], 0])
# Remove the margins
plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
plt.savefig(os.path.join(night_dir_path, night_name + '_calib_report_astrometry.jpg'), \
bbox_inches='tight', pad_inches=0, dpi=dpi)
if show_graphs:
plt.show()
else:
plt.clf()
plt.close()
if max_matched_stars > 2:
### PHOTOMETRY FIT ###
# If a flat is used, set the vignetting coeff to 0
if config.use_flat:
platepar.vignetting_coeff = 0.0
# Extact intensities and mangitudes
star_intensities = image_stars[:, 2]
catalog_mags = matched_catalog_stars[:, 2]
# Compute radius of every star from image centre
radius_arr = np.hypot(image_stars[:, 0] - img_h / 2,
image_stars[:, 1] - img_w / 2)
# Fit the photometry on automated star intensities (use the fixed vignetting coeff, use robust fit)
photom_params, fit_stddev, fit_resid, star_intensities, radius_arr, catalog_mags = \
photometryFitRobust(star_intensities, radius_arr, catalog_mags, \
fixed_vignetting=platepar.vignetting_coeff)
photom_offset, _ = photom_params
### ###
### PLOT PHOTOMETRY ###
# Note: An almost identical code exists in RMS.Astrometry.SkyFit in the PlateTool.photometry function
dpi = 130
fig_p, (ax_p, ax_r) = plt.subplots(nrows=2, facecolor=None, figsize=(6.0, 7.0), dpi=dpi, \
gridspec_kw={'height_ratios':[2, 1]})
# Plot raw star intensities
ax_p.scatter(-2.5 * np.log10(star_intensities),
catalog_mags,
s=5,
c='r',
alpha=0.5,
label="Raw")
# If a flat is used, disregard the vignetting
if not config.use_flat:
# Plot intensities of image stars corrected for vignetting
lsp_corr_arr = np.log10(correctVignetting(star_intensities, radius_arr, \
platepar.vignetting_coeff))
ax_p.scatter(-2.5*lsp_corr_arr, catalog_mags, s=5, c='b', alpha=0.5, \
label="Corrected for vignetting")
# Plot photometric offset from the platepar
x_min, x_max = ax_p.get_xlim()
y_min, y_max = ax_p.get_ylim()
x_min_w = x_min - 3
x_max_w = x_max + 3
y_min_w = y_min - 3
y_max_w = y_max + 3
photometry_info = "Platepar: {:+.1f}*LSP + {:.2f} +/- {:.2f}".format(platepar.mag_0, \
platepar.mag_lev, platepar.mag_lev_stddev) \
+ "\nVignetting coeff = {:.5f}".format(platepar.vignetting_coeff) \
+ "\nGamma = {:.2f}".format(platepar.gamma)
# Plot the photometry calibration from the platepar
logsum_arr = np.linspace(x_min_w, x_max_w, 10)
ax_p.plot(logsum_arr, logsum_arr + platepar.mag_lev, label=photometry_info, linestyle='--', \
color='k', alpha=0.5)
# Plot the fitted photometry calibration
fit_info = "Fit: {:+.1f}*LSP + {:.2f} +/- {:.2f}".format(
-2.5, photom_offset, fit_stddev)
ax_p.plot(logsum_arr,
logsum_arr + photom_offset,
label=fit_info,
linestyle='--',
color='b',
alpha=0.75)
ax_p.legend()
ax_p.set_ylabel("Catalog magnitude ({:s})".format(mag_band_str))
ax_p.set_xlabel("Uncalibrated magnitude")
# Set wider axis limits
ax_p.set_xlim(x_min_w, x_max_w)
ax_p.set_ylim(y_min_w, y_max_w)
ax_p.invert_yaxis()
ax_p.invert_xaxis()
ax_p.grid()
### Plot photometry vs radius ###
img_diagonal = np.hypot(img_h / 2, img_w / 2)
# Plot photometry residuals (including vignetting)
ax_r.scatter(radius_arr, fit_resid, c='b', alpha=0.75, s=5, zorder=3)
# Plot a zero line
ax_r.plot(np.linspace(0, img_diagonal, 10), np.zeros(10), linestyle='dashed', alpha=0.5, \
color='k')
# Plot only when no flat is used
if not config.use_flat:
# Plot radius from centre vs. fit residual
fit_resids_novignetting = catalog_mags - photomLine((np.array(star_intensities), \
np.array(radius_arr)), photom_offset, 0.0)
ax_r.scatter(radius_arr,
fit_resids_novignetting,
s=5,
c='r',
alpha=0.5,
zorder=3)
px_sum_tmp = 1000
radius_arr_tmp = np.linspace(0, img_diagonal, 50)
# Plot vignetting loss curve
vignetting_loss = 2.5*np.log10(px_sum_tmp) \
- 2.5*np.log10(correctVignetting(px_sum_tmp, radius_arr_tmp, \
platepar.vignetting_coeff))
ax_r.plot(radius_arr_tmp,
vignetting_loss,
linestyle='dotted',
alpha=0.5,
color='k')
ax_r.grid()
ax_r.set_ylabel("Fit residuals (mag)")
ax_r.set_xlabel("Radius from centre (px)")
ax_r.set_xlim(0, img_diagonal)
### ###
plt.tight_layout()
plt.savefig(os.path.join(night_dir_path,
night_name + '_calib_report_photometry.png'),
dpi=150)
if show_graphs:
plt.show()
else:
plt.clf()
plt.close()
def trackStack(dir_path,
config,
border=5,
background_compensation=True,
hide_plot=False):
""" Generate a stack with aligned stars, so the sky appears static. The folder should have a
platepars_all_recalibrated.json file.
Arguments:
dir_path: [str] Path to the directory with image files.
config: [Config instance]
Keyword arguments:
border: [int] Border around the image to exclude (px).
background_compensation: [bool] Normalize the background by applying a median filter to avepixel and
use it as a flat field. Slows down the procedure and may sometimes introduce artifacts. True
by default.
"""
# Load recalibrated platepars, if they exist ###
# Find recalibrated platepars file per FF file
platepars_recalibrated_file = None
for file_name in os.listdir(dir_path):
if file_name == config.platepars_recalibrated_name:
platepars_recalibrated_file = file_name
break
# Load all recalibrated platepars if the file is available
recalibrated_platepars = None
if platepars_recalibrated_file is not None:
with open(os.path.join(dir_path, platepars_recalibrated_file)) as f:
recalibrated_platepars = json.load(f)
print(
'Loaded recalibrated platepars JSON file for the calibration report...'
)
# ###
# If the recalib platepars is not found, stop
if recalibrated_platepars is None:
print("The {:s} file was not found!".format(
config.platepars_recalibrated_name))
return False
# Get a list of FF files in the folder
ff_list = []
for file_name in os.listdir(dir_path):
if validFFName(file_name):
ff_list.append(file_name)
# Take the platepar with the middle time as the reference one
ff_found_list = []
jd_list = []
for ff_name_temp in recalibrated_platepars:
if ff_name_temp in ff_list:
# Compute the Julian date of the FF middle
dt = getMiddleTimeFF(ff_name_temp,
config.fps,
ret_milliseconds=True)
jd = date2JD(*dt)
jd_list.append(jd)
ff_found_list.append(ff_name_temp)
if len(jd_list) < 2:
print("Not more than 1 FF image!")
return False
# Take the FF file with the middle JD
jd_list = np.array(jd_list)
jd_middle = np.mean(jd_list)
jd_mean_index = np.argmin(np.abs(jd_list - jd_middle))
ff_mid = ff_found_list[jd_mean_index]
# Load the middle platepar as the reference one
pp_ref = Platepar()
pp_ref.loadFromDict(recalibrated_platepars[ff_mid],
use_flat=config.use_flat)
# Try loading the mask
mask_path = None
if os.path.exists(os.path.join(dir_path, config.mask_file)):
mask_path = os.path.join(dir_path, config.mask_file)
# Try loading the default mask
elif os.path.exists(config.mask_file):
mask_path = os.path.abspath(config.mask_file)
# Load the mask if given
mask = None
if mask_path is not None:
mask = loadMask(mask_path)
print("Loaded mask:", mask_path)
# If the shape of the mask doesn't fit, init an empty mask
if mask is not None:
if (mask.img.shape[0] != pp_ref.Y_res) or (mask.img.shape[1] !=
pp_ref.X_res):
print("Mask is of wrong shape!")
mask = None
if mask is None:
mask = MaskStructure(255 + np.zeros(
(pp_ref.Y_res, pp_ref.X_res), dtype=np.uint8))
# Compute the middle RA/Dec of the reference platepar
_, ra_temp, dec_temp, _ = xyToRaDecPP([jd2Date(jd_middle)],
[pp_ref.X_res / 2],
[pp_ref.Y_res / 2], [1],
pp_ref,
extinction_correction=False)
ra_mid, dec_mid = ra_temp[0], dec_temp[0]
# Go through all FF files and find RA/Dec of image corners to find the size of the stack image ###
# List of corners
x_corns = [0, pp_ref.X_res, 0, pp_ref.X_res]
y_corns = [0, 0, pp_ref.Y_res, pp_ref.Y_res]
ra_list = []
dec_list = []
for ff_temp in ff_found_list:
# Load the recalibrated platepar
pp_temp = Platepar()
pp_temp.loadFromDict(recalibrated_platepars[ff_temp],
use_flat=config.use_flat)
for x_c, y_c in zip(x_corns, y_corns):
_, ra_temp, dec_temp, _ = xyToRaDecPP(
[getMiddleTimeFF(ff_temp, config.fps, ret_milliseconds=True)],
[x_c], [y_c], [1],
pp_ref,
extinction_correction=False)
ra_c, dec_c = ra_temp[0], dec_temp[0]
ra_list.append(ra_c)
dec_list.append(dec_c)
# Compute the angular separation from the middle equatorial coordinates of the reference image to all
# RA/Dec corner coordinates
ang_sep_list = []
for ra_c, dec_c in zip(ra_list, dec_list):
ang_sep = np.degrees(
angularSeparation(np.radians(ra_mid), np.radians(dec_mid),
np.radians(ra_c), np.radians(dec_c)))
ang_sep_list.append(ang_sep)
# Find the maximum angular separation and compute the image size using the plate scale
# The image size will be resampled to 1/2 of the original size to avoid interpolation
scale = 0.5
ang_sep_max = np.max(ang_sep_list)
img_size = int(scale * 2 * ang_sep_max * pp_ref.F_scale)
#
# Create the stack platepar with no distortion and a large image size
pp_stack = copy.deepcopy(pp_ref)
pp_stack.resetDistortionParameters()
pp_stack.X_res = img_size
pp_stack.Y_res = img_size
pp_stack.F_scale *= scale
pp_stack.refraction = False
# Init the image
avg_stack_sum = np.zeros((img_size, img_size), dtype=float)
avg_stack_count = np.zeros((img_size, img_size), dtype=int)
max_deaveraged = np.zeros((img_size, img_size), dtype=np.uint8)
# Load individual FFs and map them to the stack
for i, ff_name in enumerate(ff_found_list):
print("Stacking {:s}, {:.1f}% done".format(
ff_name, 100 * i / len(ff_found_list)))
# Read the FF file
ff = readFF(dir_path, ff_name)
# Load the recalibrated platepar
pp_temp = Platepar()
pp_temp.loadFromDict(recalibrated_platepars[ff_name],
use_flat=config.use_flat)
# Make a list of X and Y image coordinates
x_coords, y_coords = np.meshgrid(
np.arange(border, pp_ref.X_res - border),
np.arange(border, pp_ref.Y_res - border))
x_coords = x_coords.ravel()
y_coords = y_coords.ravel()
# Map image pixels to sky
jd_arr, ra_coords, dec_coords, _ = xyToRaDecPP(
len(x_coords) *
[getMiddleTimeFF(ff_name, config.fps, ret_milliseconds=True)],
x_coords,
y_coords,
len(x_coords) * [1],
pp_temp,
extinction_correction=False)
# Map sky coordinates to stack image coordinates
stack_x, stack_y = raDecToXYPP(ra_coords, dec_coords, jd_middle,
pp_stack)
# Round pixel coordinates
stack_x = np.round(stack_x, decimals=0).astype(int)
stack_y = np.round(stack_y, decimals=0).astype(int)
# Cut the image to limits
filter_arr = (stack_x > 0) & (stack_x < img_size) & (stack_y > 0) & (
stack_y < img_size)
x_coords = x_coords[filter_arr].astype(int)
y_coords = y_coords[filter_arr].astype(int)
stack_x = stack_x[filter_arr]
stack_y = stack_y[filter_arr]
# Apply the mask to maxpixel and avepixel
maxpixel = copy.deepcopy(ff.maxpixel)
maxpixel[mask.img == 0] = 0
avepixel = copy.deepcopy(ff.avepixel)
avepixel[mask.img == 0] = 0
# Compute deaveraged maxpixel
max_deavg = maxpixel - avepixel
# Normalize the backgroud brightness by applying a large-kernel median filter to avepixel
if background_compensation:
# # Apply a median filter to the avepixel to get an estimate of the background brightness
# avepixel_median = scipy.ndimage.median_filter(ff.avepixel, size=101)
avepixel_median = cv2.medianBlur(ff.avepixel, 301)
# Make sure to avoid zero division
avepixel_median[avepixel_median < 1] = 1
# Normalize the avepixel by subtracting out the background brightness
avepixel = avepixel.astype(float)
avepixel /= avepixel_median
avepixel *= 50 # Normalize to a good background value, which is usually 50
avepixel = np.clip(avepixel, 0, 255)
avepixel = avepixel.astype(np.uint8)
# plt.imshow(avepixel, cmap='gray', vmin=0, vmax=255)
# plt.show()
# Add the average pixel to the sum
avg_stack_sum[stack_y, stack_x] += avepixel[y_coords, x_coords]
# Increment the counter image where the avepixel is not zero
ones_img = np.ones_like(avepixel)
ones_img[avepixel == 0] = 0
avg_stack_count[stack_y, stack_x] += ones_img[y_coords, x_coords]
# Set pixel values to the stack, only take the max values
max_deaveraged[stack_y, stack_x] = np.max(np.dstack(
[max_deaveraged[stack_y, stack_x], max_deavg[y_coords, x_coords]]),
axis=2)
# Compute the blended avepixel background
stack_img = avg_stack_sum
stack_img[avg_stack_count > 0] /= avg_stack_count[avg_stack_count > 0]
stack_img += max_deaveraged
stack_img = np.clip(stack_img, 0, 255)
stack_img = stack_img.astype(np.uint8)
# Crop image
non_empty_columns = np.where(stack_img.max(axis=0) > 0)[0]
non_empty_rows = np.where(stack_img.max(axis=1) > 0)[0]
crop_box = (np.min(non_empty_rows), np.max(non_empty_rows),
np.min(non_empty_columns), np.max(non_empty_columns))
stack_img = stack_img[crop_box[0]:crop_box[1] + 1,
crop_box[2]:crop_box[3] + 1]
# Plot and save the stack ###
dpi = 200
plt.figure(figsize=(stack_img.shape[1] / dpi, stack_img.shape[0] / dpi),
dpi=dpi)
plt.imshow(stack_img,
cmap='gray',
vmin=0,
vmax=256,
interpolation='nearest')
plt.axis('off')
plt.gca().get_xaxis().set_visible(False)
plt.gca().get_yaxis().set_visible(False)
plt.xlim([0, stack_img.shape[1]])
plt.ylim([stack_img.shape[0], 0])
# Remove the margins (top and right are set to 0.9999, as setting them to 1.0 makes the image blank in
# some matplotlib versions)
plt.subplots_adjust(left=0,
bottom=0,
right=0.9999,
top=0.9999,
wspace=0,
hspace=0)
filenam = os.path.join(dir_path,
os.path.basename(dir_path) + "_track_stack.jpg")
plt.savefig(filenam, bbox_inches='tight', pad_inches=0, dpi=dpi)
#
if hide_plot is False:
plt.show()