def plotStars(ff, x2, y2):
""" Plots detected stars on the input image.
"""
# Plot image with adjusted levels to better see stars
plt.imshow(Image.adjustLevels(ff.avepixel, 0, 1.3, 255), cmap='gray')
# Plot stars
for star in zip(list(y2), list(x2)):
y, x = star
c = plt.Circle((x, y), 5, fill=False, color='r')
plt.gca().add_patch(c)
plt.show()
plt.clf()
plt.close()
def plotStars(ff, x2, y2):
""" Plots detected stars on the input image.
"""
# Plot image with adjusted levels to better see stars
plt.imshow(Image.adjustLevels(ff.avepixel, 0, 1.3, 255), cmap='gray')
# Plot stars
for star in zip(list(y2), list(x2)):
y, x = star
c = plt.Circle((x, y), 5, fill=False, color='r')
plt.gca().add_patch(c)
plt.show()
plt.clf()
plt.close()
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 getThresholdedStripe3DPoints(config, img_handle, frame_min, frame_max, rho, theta, mask, flat_struct, \
dark, stripe_width_factor=1.0, centroiding=False, point1=None, point2=None, debug=False):
""" Threshold the image and get a list of pixel positions and frames of threshold passers.
This function handles all input types of data.
Arguments;
config: [config object] configuration object (loaded from the .config file).
img_handle: [FrameInterface instance] Object which has a common interface to various input files.
frame_min: [int] First frame to process.
frame_max: [int] Last frame to process.
rho: [float] Line distance from the center in HT space (pixels).
theta: [float] Angle in degrees in HT space.
mask: [ndarray] Image mask.
flat_struct: [Flat struct] Structure containing the flat field. None by default.
dark: [ndarray] Dark frame.
Keyword arguments:
stripe_width_factor: [float] Multipler by which the default stripe width will be multiplied. Default
is 1.0
centroiding: [bool] If True, the indices will be returned in the centroiding mode, which means
that point1 and point2 arguments must be given.
point1: [list] (x, y, frame) Of the first reference point of the detection.
point2: [list] (x, y, frame) Of the second reference point of the detection.
debug: [bool] If True, extra debug messages and plots will be shown.
Return:
xs, ys, zs: [tuple of lists] Indices of (x, y, frame) of threshold passers for every frame.
"""
# Get indices of stripe pixels around the line of the meteor
img_h, img_w = img_handle.ff.maxpixel.shape
stripe_indices = getStripeIndices(
rho, theta, stripe_width_factor * config.stripe_width, img_h, img_w)
# If centroiding should be done, prepare everything for cutting out parts of the image for photometry
if centroiding:
# Compute the unit vector which describes the motion of the meteor in the image domain
point1 = np.array(point1)
point2 = np.array(point2)
motion_vect = point2[:2] - point1[:2]
motion_vect_unit = vectNorm(motion_vect)
# Get coordinates of 2 points that describe the line
x1, y1, z1 = point1
x2, y2, z2 = point2
# Compute the average angular velocity in px per frame
ang_vel = np.sqrt((x2 - x1)**2 + (y2 - y1)**2) / (z2 - z1)
# Compute the vector describing the length and direction of the meteor per frame
motion_vect = ang_vel * motion_vect_unit
# If the FF files is given, extract the points from FF after threshold
if img_handle.input_type == 'ff':
# Threshold the FF file
img_thres = Image.thresholdFF(img_handle.ff, config.k1_det, config.j1_det, mask=mask, \
mask_ave_bright=False)
# Extract the thresholded image by min and max frames from FF file
img = selectFFFrames(np.copy(img_thres), img_handle.ff, frame_min,
frame_max)
# Remove lonely pixels
img = morph.clean(img)
# Extract the stripe from the thresholded image
stripe = np.zeros(img.shape, img.dtype)
stripe[stripe_indices] = img[stripe_indices]
# Show stripe
# show2("stripe", stripe*255)
# Show 3D could
# show3DCloud(ff, stripe)
# Get stripe positions (x, y, frame)
stripe_positions = stripe.nonzero()
xs = stripe_positions[1]
ys = stripe_positions[0]
zs = img_handle.ff.maxframe[stripe_positions]
return xs, ys, zs
# If video frames are available, extract indices on all frames in the given range
else:
xs_array = []
ys_array = []
zs_array = []
# Go through all frames in the frame range
for fr in range(frame_min, frame_max + 1):
# Break the loop if outside frame size
if fr == (img_handle.total_frames - 1):
break
# Set the frame number
img_handle.setFrame(fr)
# Load the frame
fr_img = img_handle.loadFrame()
# Apply the dark frame
if dark is not None:
fr_img = Image.applyDark(fr_img, dark)
# Apply the flat to frame
if flat_struct is not None:
fr_img = Image.applyFlat(fr_img, flat_struct)
# Mask the image
fr_img = MaskImage.applyMask(fr_img, mask)
# Threshold the frame
img_thres = Image.thresholdImg(fr_img, img_handle.ff.avepixel, img_handle.ff.stdpixel, \
config.k1_det, config.j1_det, mask=mask, mask_ave_bright=False)
# Remove lonely pixels
img_thres = morph.clean(img_thres)
# Extract the stripe from the thresholded image
stripe = np.zeros(img_thres.shape, img_thres.dtype)
stripe[stripe_indices] = img_thres[stripe_indices]
# Include more pixels for centroiding and photometry and mask out per frame pixels
if centroiding:
# Dilate the pixels in the stripe twice, to include more pixels for photometry
stripe = morph.dilate(stripe)
stripe = morph.dilate(stripe)
# Get indices of the stripe that is perpendicular to the meteor, and whose thickness is the
# length of the meteor on this particular frame - this is called stripe_indices_motion
# Compute the previous, current, and the next linear model position of the meteor on the
# image
model_pos_prev = point1[:2] + (fr - 1 - z1) * motion_vect
model_pos = point1[:2] + (fr - z1) * motion_vect
model_pos_next = point1[:2] + (fr + 1 - z1) * motion_vect
# Get the rho, theta of the line perpendicular to the meteor line
x_inters, y_inters = model_pos
# Check if the previous, current or the next centroids are outside bounds, and if so, skip the
# frame
if (not checkCentroidBounds(model_pos_prev, img_w, img_h)) or \
(not checkCentroidBounds(model_pos, img_w, img_h)) or \
(not checkCentroidBounds(model_pos_next, img_w, img_h)):
continue
# Get parameters of the perpendicular line to the meteor line
rho2, theta2 = htLinePerpendicular(rho, theta, x_inters,
y_inters, img_h, img_w)
# Compute the image indices of this position which will be the intersection with the stripe
# The width of the line will be 2x the angular velocity
stripe_length = 6 * ang_vel
if stripe_length < stripe_width_factor * config.stripe_width:
stripe_length = stripe_width_factor * config.stripe_width
stripe_indices_motion = getStripeIndices(
rho2, theta2, stripe_length, img_h, img_w)
# Mark only those parts which overlap both lines, which effectively creates a mask for
# photometry an centroiding, excluding other influences
stripe_new = np.zeros_like(stripe)
stripe_new[stripe_indices_motion] = stripe[
stripe_indices_motion]
stripe = stripe_new
if debug:
# Show the extracted stripe
img_stripe = np.zeros_like(stripe)
img_stripe[stripe_indices] = 1
final_stripe = np.zeros_like(stripe)
final_stripe[stripe_indices_motion] = img_stripe[
stripe_indices_motion]
plt.imshow(final_stripe)
plt.show()
if debug and centroiding:
print(fr)
print('mean stdpixel3:', np.mean(img_handle.ff.stdpixel))
print('mean avepixel3:', np.mean(img_handle.ff.avepixel))
print('mean frame:', np.mean(fr_img))
fig, (ax1, ax2) = plt.subplots(nrows=2,
sharex=True,
sharey=True)
fr_img_noavg = Image.applyDark(fr_img, img_handle.ff.avepixel)
#fr_img_noavg = fr_img
# Auto levels
min_lvl = np.percentile(fr_img_noavg[2:, :], 1)
max_lvl = np.percentile(fr_img_noavg[2:, :], 99.0)
# Adjust levels
fr_img_autolevel = Image.adjustLevels(fr_img_noavg, min_lvl,
1.0, max_lvl)
ax1.imshow(stripe, cmap='gray')
ax2.imshow(fr_img_autolevel, cmap='gray')
plt.show()
pass
# Get stripe positions (x, y, frame)
stripe_positions = stripe.nonzero()
xs = stripe_positions[1]
ys = stripe_positions[0]
zs = np.zeros_like(xs) + fr
# Add the points to the list
xs_array.append(xs)
ys_array.append(ys)
zs_array.append(zs)
if debug:
print('---')
print(stripe.nonzero())
print(xs, ys, zs)
if len(xs_array) > 0:
# Flatten the arrays
xs_array = np.concatenate(xs_array)
ys_array = np.concatenate(ys_array)
zs_array = np.concatenate(zs_array)
else:
xs_array = np.array(xs_array)
ys_array = np.array(ys_array)
zs_array = np.array(zs_array)
return xs_array, ys_array, zs_array
def getThresholdedStripe3DPoints(config, img_handle, frame_min, frame_max, rho, theta, mask, flat_struct, \
dark, stripe_width_factor=1.0, centroiding=False, point1=None, point2=None, debug=False):
""" Threshold the image and get a list of pixel positions and frames of threshold passers.
This function handles all input types of data.
Arguments;
config: [config object] configuration object (loaded from the .config file).
img_handle: [FrameInterface instance] Object which has a common interface to various input files.
frame_min: [int] First frame to process.
frame_max: [int] Last frame to process.
rho: [float] Line distance from the center in HT space (pixels).
theta: [float] Angle in degrees in HT space.
mask: [ndarray] Image mask.
flat_struct: [Flat struct] Structure containing the flat field. None by default.
dark: [ndarray] Dark frame.
Keyword arguments:
stripe_width_factor: [float] Multipler by which the default stripe width will be multiplied. Default
is 1.0
centroiding: [bool] If True, the indices will be returned in the centroiding mode, which means
that point1 and point2 arguments must be given.
point1: [list] (x, y, frame) Of the first reference point of the detection.
point2: [list] (x, y, frame) Of the second reference point of the detection.
debug: [bool] If True, extra debug messages and plots will be shown.
Return:
xs, ys, zs: [tuple of lists] Indices of (x, y, frame) of threshold passers for every frame.
"""
# Get indices of stripe pixels around the line of the meteor
img_h, img_w = img_handle.ff.maxpixel.shape
stripe_indices = getStripeIndices(rho, theta, stripe_width_factor*config.stripe_width, img_h, img_w)
# If centroiding should be done, prepare everything for cutting out parts of the image for photometry
if centroiding:
# Compute the unit vector which describes the motion of the meteor in the image domain
point1 = np.array(point1)
point2 = np.array(point2)
motion_vect = point2[:2] - point1[:2]
motion_vect_unit = vectNorm(motion_vect)
# Get coordinates of 2 points that describe the line
x1, y1, z1 = point1
x2, y2, z2 = point2
# Compute the average angular velocity in px per frame
ang_vel = np.sqrt((x2 - x1)**2 + (y2 - y1)**2)/(z2 - z1)
# Compute the vector describing the length and direction of the meteor per frame
motion_vect = ang_vel*motion_vect_unit
# If the FF files is given, extract the points from FF after threshold
if img_handle.input_type == 'ff':
# Threshold the FF file
img_thres = Image.thresholdFF(img_handle.ff, config.k1_det, config.j1_det, mask=mask, \
mask_ave_bright=False)
# Extract the thresholded image by min and max frames from FF file
img = selectFFFrames(np.copy(img_thres), img_handle.ff, frame_min, frame_max)
# Remove lonely pixels
img = morph.clean(img)
# Extract the stripe from the thresholded image
stripe = np.zeros(img.shape, img.dtype)
stripe[stripe_indices] = img[stripe_indices]
# Show stripe
# show2("stripe", stripe*255)
# Show 3D could
# show3DCloud(ff, stripe)
# Get stripe positions (x, y, frame)
stripe_positions = stripe.nonzero()
xs = stripe_positions[1]
ys = stripe_positions[0]
zs = img_handle.ff.maxframe[stripe_positions]
return xs, ys, zs
# If video frames are available, extract indices on all frames in the given range
else:
xs_array = []
ys_array = []
zs_array = []
# Go through all frames in the frame range
for fr in range(frame_min, frame_max + 1):
# Break the loop if outside frame size
if fr == (img_handle.total_frames - 1):
break
# Set the frame number
img_handle.setFrame(fr)
# Load the frame
fr_img = img_handle.loadFrame()
# Apply the dark frame
if dark is not None:
fr_img = Image.applyDark(fr_img, dark)
# Apply the flat to frame
if flat_struct is not None:
fr_img = Image.applyFlat(fr_img, flat_struct)
# Mask the image
fr_img = MaskImage.applyMask(fr_img, mask)
# Threshold the frame
img_thres = Image.thresholdImg(fr_img, img_handle.ff.avepixel, img_handle.ff.stdpixel, \
config.k1_det, config.j1_det, mask=mask, mask_ave_bright=False)
# Remove lonely pixels
img_thres = morph.clean(img_thres)
# Extract the stripe from the thresholded image
stripe = np.zeros(img_thres.shape, img_thres.dtype)
stripe[stripe_indices] = img_thres[stripe_indices]
# Include more pixels for centroiding and photometry and mask out per frame pixels
if centroiding:
# Dilate the pixels in the stripe twice, to include more pixels for photometry
stripe = morph.dilate(stripe)
stripe = morph.dilate(stripe)
# Get indices of the stripe that is perpendicular to the meteor, and whose thickness is the
# length of the meteor on this particular frame - this is called stripe_indices_motion
# Compute the previous, current, and the next linear model position of the meteor on the
# image
model_pos_prev = point1[:2] + (fr - 1 - z1)*motion_vect
model_pos = point1[:2] + (fr - z1)*motion_vect
model_pos_next = point1[:2] + (fr + 1 - z1)*motion_vect
# Get the rho, theta of the line perpendicular to the meteor line
x_inters, y_inters = model_pos
# Check if the previous, current or the next centroids are outside bounds, and if so, skip the
# frame
if (not checkCentroidBounds(model_pos_prev, img_w, img_h)) or \
(not checkCentroidBounds(model_pos, img_w, img_h)) or \
(not checkCentroidBounds(model_pos_next, img_w, img_h)):
continue
# Get parameters of the perpendicular line to the meteor line
rho2, theta2 = htLinePerpendicular(rho, theta, x_inters, y_inters, img_h, img_w)
# Compute the image indices of this position which will be the intersection with the stripe
# The width of the line will be 2x the angular velocity
stripe_length = 6*ang_vel
if stripe_length < stripe_width_factor*config.stripe_width:
stripe_length = stripe_width_factor*config.stripe_width
stripe_indices_motion = getStripeIndices(rho2, theta2, stripe_length, img_h, img_w)
# Mark only those parts which overlap both lines, which effectively creates a mask for
# photometry an centroiding, excluding other influences
stripe_new = np.zeros_like(stripe)
stripe_new[stripe_indices_motion] = stripe[stripe_indices_motion]
stripe = stripe_new
if debug:
# Show the extracted stripe
img_stripe = np.zeros_like(stripe)
img_stripe[stripe_indices] = 1
final_stripe = np.zeros_like(stripe)
final_stripe[stripe_indices_motion] = img_stripe[stripe_indices_motion]
plt.imshow(final_stripe)
plt.show()
if debug and centroiding:
print(fr)
print('mean stdpixel3:', np.mean(img_handle.ff.stdpixel))
print('mean avepixel3:', np.mean(img_handle.ff.avepixel))
print('mean frame:', np.mean(fr_img))
fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True, sharey=True)
fr_img_noavg = Image.applyDark(fr_img, img_handle.ff.avepixel)
#fr_img_noavg = fr_img
# Auto levels
min_lvl = np.percentile(fr_img_noavg[2:, :], 1)
max_lvl = np.percentile(fr_img_noavg[2:, :], 99.0)
# Adjust levels
fr_img_autolevel = Image.adjustLevels(fr_img_noavg, min_lvl, 1.0, max_lvl)
ax1.imshow(stripe, cmap='gray')
ax2.imshow(fr_img_autolevel, cmap='gray')
plt.show()
pass
# Get stripe positions (x, y, frame)
stripe_positions = stripe.nonzero()
xs = stripe_positions[1]
ys = stripe_positions[0]
zs = np.zeros_like(xs) + fr
# Add the points to the list
xs_array.append(xs)
ys_array.append(ys)
zs_array.append(zs)
if debug:
print('---')
print(stripe.nonzero())
print(xs, ys, zs)
if len(xs_array) > 0:
# Flatten the arrays
xs_array = np.concatenate(xs_array)
ys_array = np.concatenate(ys_array)
zs_array = np.concatenate(zs_array)
else:
xs_array = np.array(xs_array)
ys_array = np.array(ys_array)
zs_array = np.array(zs_array)
return xs_array, ys_array, zs_array
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 updateImage(self):
""" Updates the current plot. """
# Reset circle patches
self.circle_aperature = None
self.circle_aperature_outer = None
# Reset centroid patch
self.centroid_handle = None
# Reset photometry coloring
self.photometry_coloring_handle = None
# Save the previous zoom
if self.current_image is not None:
self.prev_xlim = plt.gca().get_xlim()
self.prev_ylim = plt.gca().get_ylim()
plt.clf()
# PNG mode
if self.png_mode:
# Get path to current PNG image
self.png_img_path = os.path.join(
self.png_dir, self.png_list[int(self.current_frame)])
# Read the image
img = scipy.misc.imread(self.png_img_path)
# FF mode
else:
# If FF is given, reconstruct frames
if self.ff is not None:
# Take the current frame from FF file
img = np.copy(self.ff.avepixel)
frame_mask = np.where(
self.ff.maxframe == int(self.current_frame))
img[frame_mask] = self.ff.maxpixel[frame_mask]
# Otherwise, create a blank background with the size enough to fit the FR bin
else:
# Get the maximum extent of the meteor frames
y_size = max(max(np.array(self.fr.yc[i]) + np.array(self.fr.size[i])//2) for i in \
range(self.fr.lines))
x_size = max(max(np.array(self.fr.xc[i]) + np.array(self.fr.size[i])//2) for i in \
range(self.fr.lines))
# Make the image square
img_size = max(y_size, x_size)
img = np.zeros((img_size, img_size), np.uint8)
# If FR is given, paste the raw frame onto the image
if self.fr is not None:
# Compute the index of the frame in the FR bin structure
frame_indx = int(
self.current_frame) - self.fr.t[self.current_line][0]
# Reconstruct the frame if it is within the bounds
if (frame_indx < self.fr.frameNum[self.current_line]) and (
frame_indx >= 0):
# Get the center position of the detection on the current frame
yc = self.fr.yc[self.current_line][frame_indx]
xc = self.fr.xc[self.current_line][frame_indx]
# # Get the frame number
# t = self.fr.t[self.current_line][frame_indx]
# Get the size of the window
size = self.fr.size[self.current_line][frame_indx]
# Paste the frames onto the big image
y_img = np.arange(yc - size // 2, yc + size // 2)
x_img = np.arange(xc - size // 2, xc + size // 2)
Y_img, X_img = np.meshgrid(y_img, x_img)
y_frame = np.arange(len(y_img))
x_frame = np.arange(len(x_img))
Y_frame, X_frame = np.meshgrid(y_frame, x_frame)
img[Y_img, X_img] = self.fr.frames[
self.current_line][frame_indx][Y_frame, X_frame]
# Save the limits of the FR
self.fr_xmin = np.min(x_img)
self.fr_xmax = np.max(x_img)
self.fr_ymin = np.max(y_img)
self.fr_ymax = np.min(y_img)
# Draw a red rectangle around the pasted frame
rect_x = np.min(x_img)
rect_y = np.max(y_img)
rect_w = np.max(x_img) - rect_x
rect_h = np.min(y_img) - rect_y
plt.gca().add_patch(mpatches.Rectangle((rect_x, rect_y), rect_w, rect_h, fill=None, \
edgecolor='red', alpha=0.5))
# Apply the deinterlace
if self.deinterlace_mode > -1:
# Set the deinterlace index to handle proper deinterlacing order
if self.deinterlace_mode == 0:
deinter_indx = 0
else:
deinter_indx = 1
# Deinterlace the image using the appropriate method
if (self.current_frame + deinter_indx * 0.5) % 1 == 0:
img = Image.deinterlaceOdd(img)
else:
img = Image.deinterlaceEven(img)
# Current image without adjustments
self.current_image = np.copy(img)
### Adjust image levels
# Guess the bit depth from the array type
bit_depth = 8 * img.itemsize
img = Image.adjustLevels(img, 0, self.img_gamma, (2**bit_depth - 1),
bit_depth)
###
plt.imshow(img, cmap='gray', vmin=0, vmax=255)
if (self.prev_xlim is not None) and (self.prev_ylim is not None):
# Restore previous zoom
plt.xlim(self.prev_xlim)
plt.ylim(self.prev_ylim)
self.drawText()
# Don't draw the picks in the photometry coloring more
if not self.photometry_coloring_mode:
# Plot image pick
self.drawPicks(update_plot=False)
# Plot the photometry coloring
self.drawPhotometryColoring(update_plot=False)
plt.gcf().canvas.draw()