# Bias correction mean_bias_corrected = calibrate.correct_bias(root, mean_raw) # Normalise the RGBG2 channels to a maximum of 1 each mean_normalised, stds_normalised = flat.normalise_RGBG2( mean_bias_corrected, stds_raw, camera.bayer_map) print("Normalised data") # Calculate the signal-to-noise ratio (SNR) per pixel SNR = mean_normalised / stds_normalised print("Calculated signal-to-noise-ratio") # Make a histogram of the SNR save_to_histogram_SNR = savefolder / f"data_histogram_SNR_{label}.pdf" SNR_top_percentile = analyse.symmetric_percentiles(SNR)[1] bins_SNR = np.linspace(0, SNR_top_percentile, 100) plt.figure(figsize=(4, 2), tight_layout=True) plt.hist(SNR.ravel(), bins=bins_SNR, color='k') plt.xlim(bins_SNR[0], bins_SNR[-1]) plt.xlabel("Signal-to-noise ratio") plt.ylabel("Counts") plt.savefig(save_to_histogram_SNR) plt.close() print(f"Saved histogram of signal-to-noise ratio to '{save_to_histogram_SNR}'") # Make Gaussian maps of the SNR save_to_maps_SNR = savefolder / f"data_SNR_{label}.pdf" camera.plot_gauss_maps(SNR, colorbar_label="Signal-to-noise ratio",
labels = ["Normalisation", "Best fit $\gamma$", "$R^2$"] # Find the number of non-NaN pixels which will be used in the plot number_of_pixels = gammas[...,0].size pixels_not_nan = np.where(~np.isnan(gammas[...,0]))[0] number_of_pixels_not_nan = pixels_not_nan.size percentage_not_nan = 100. * number_of_pixels_not_nan / number_of_pixels print(f"{number_of_pixels_not_nan}/{number_of_pixels} ({percentage_not_nan:.1f}%) of pixels are not NaN.") # Create a figure to hold the plot fig, axs = plt.subplots(ncols=3, figsize=(7,2), sharey=True, tight_layout=True, gridspec_kw={"wspace":0, "hspace":0}) # Loop over the results for ax, result, label in zip(axs, [normalisations, gammas, R2s], labels): # Get bins from the range of data xmin, xmax = analyse.symmetric_percentiles(result) bins = np.linspace(xmin, xmax, 150) # Loop over the RGB channels for j, c in enumerate(plot.rgb): # Flatten the array and remove NaN elements result_c = result[...,j].ravel() result_c = result_c[~np.isnan(result_c)] ax.hist(result_c, bins, color=c, alpha=0.7) # Plot parameters ax.set_xlabel(label) ax.set_xlim(xmin, xmax) # Plot parameters axs[0].set_ylabel("Counts")
# Get metadata camera = io.load_metadata(root) # Load the data dark_current = np.load(file) print("Loaded data") # Convolve the map with a Gaussian kernel and plot an image of the result save_to_maps = save_folder / "dark_current_map_ADU.pdf" camera.plot_gauss_maps(dark_current, colorbar_label="Dark current (norm. ADU/s)", saveto=save_to_maps) print(f"Saved Gauss map to '{save_to_maps}'") # Range on the x axis for the histogram xmin, xmax = analyse.symmetric_percentiles(dark_current, percent=0.001) # Split the data into the RGBG2 filters and make histograms (aggregate and per # filter) save_to_histogram = save_folder / "dark_current_histogram_ADU.pdf" camera.plot_histogram_RGB(dark_current, xmin=xmin, xmax=xmax, xlabel="Dark current (norm. ADU/s)", saveto=save_to_histogram) print(f"Saved RGB histogram to '{save_to_histogram}'") # Check how many pixels are over some threshold in dark current threshold = 50 pixels_over_threshold = np.where(np.abs(dark_current) > threshold) number_over_threshold = len(pixels_over_threshold[0])
# Load Camera object cameras = [io.load_camera(root) for root in roots] print(f"Loaded Camera objects: {cameras}") # Load the data data_all = [np.load(path) for path in files] # Demosaick the data RGBGs_all = [camera.demosaick(data) for data, camera in zip(data_all, cameras)] # Convolve the data with a Gaussian kernel gauss_all = [gaussMd(RGBG, sigma=(0, 5, 5)) for RGBG in RGBGs_all] # Minimum and maximum of colourbars vmin, vmax = analyse.symmetric_percentiles(gauss_all) # Figure to hold the subplots fig, axs = plt.subplots(ncols=4, nrows=len(files), sharex=True, sharey=True, figsize=(7, 1.695 * len(files)), squeeze=False, tight_layout=True, gridspec_kw={ "wspace": 0, "hspace": 0 }) # Loop over the data and plot them
savefolder = camera.filename_analysis("readnoise", makefolders=True) # Load the data isos, stds = io.load_stds(folder, retrieve_value=io.split_iso) # Normalise the data using the ISO look-up table stds_normalised = camera.normalise_iso(isos, stds) # Print statistics at each ISO stats = analyse.statistics(stds_normalised, prefix_column=isos, prefix_column_header="ISO") print(stats) # Range on the x axis for the histograms xmin, xmax = 0., analyse.symmetric_percentiles(stds_normalised)[1] # Loop over the data and make plots at each ISO value for ISO, std in zip(isos, stds_normalised): save_to_histogram = savefolder / f"readnoise_normalised_histogram_iso{ISO}.pdf" save_to_maps = savefolder / f"readnoise_normalised_map_iso{ISO}.pdf" camera.plot_histogram_RGB(std, xmin=xmin, xmax=xmax, xlabel="Read noise (norm. ADU)", saveto=save_to_histogram) camera.plot_gauss_maps(std, colorbar_label="Read noise (norm. ADU)", saveto=save_to_maps)
# Save location based on camera name savefolder = camera.filename_analysis("bias", makefolders=True) # Load the data isos, means = io.load_means(folder, retrieve_value=io.split_iso) print("Loaded data") # Print statistics at each ISO stats = analyse.statistics(means, prefix_column=isos, prefix_column_header="ISO") print(stats) # Range on the x axis for the histograms xmin, xmax = analyse.symmetric_percentiles(means, percent=0.001) # Loop over the data and make plots at each ISO value for ISO, mean in zip(isos, means): save_to_histogram = savefolder / f"bias_histogram_iso{ISO}.pdf" save_to_maps = savefolder / f"bias_map_iso{ISO}.pdf" camera.plot_histogram_RGB(mean, xmin=xmin, xmax=xmax, xlabel="Bias (ADU)", saveto=save_to_histogram) camera.plot_gauss_maps(mean, colorbar_label="Bias (ADU)", saveto=save_to_maps)
print(f"Loaded Camera object: {camera}") # Save locations savefolder = camera.filename_analysis("readnoise", makefolders=True) # Load the data isos, stds = io.load_stds(folder, retrieve_value=io.split_iso) # Print statistics at each ISO stats = analyse.statistics(stds, prefix_column=isos, prefix_column_header="ISO") print(stats) # Range on the x axis for the histograms xmin, xmax = 0., analyse.symmetric_percentiles(stds)[1] # Loop over the data and make plots at each ISO value for ISO, std in zip(isos, stds): save_to_histogram = savefolder / f"readnoise_ADU_histogram_iso{ISO}.pdf" save_to_maps = savefolder / f"readnoise_ADU_map_iso{ISO}.pdf" camera.plot_histogram_RGB(std, xmin=xmin, xmax=xmax, xlabel="Read noise (ADU)", saveto=save_to_histogram) camera.plot_gauss_maps(std, colorbar_label="Read noise (ADU)", saveto=save_to_maps)
save_to_histogram_RAW_JPEG = savefolder/f"histogram_raw_jpeg.pdf" # Load the data r_raw = np.load(file_raw) print("Loaded RAW Pearson r map") if jpeg_data_available: r_jpeg = np.load(file_jpeg) print("Loaded JPEG Pearson r map") # Make Gaussian maps of the RAW data camera.plot_gauss_maps(r_raw, colorbar_label="Pearson $r$", saveto=save_to_maps) print(f"Saved maps of RAW Pearson r to '{save_to_maps}'") # Make a Gaussian map of the JPEG data, if available if jpeg_data_available: vmin, vmax = analyse.symmetric_percentiles(r_jpeg) fig, axs = plt.subplots(ncols=3, sharex=True, sharey=True, figsize=(5,2), tight_layout=True, gridspec_kw={"wspace":0, "hspace":0}, squeeze=True) for data, channel, ax in zip(r_jpeg, plot.rgb, axs): img = ax.imshow(data, vmin=vmin, vmax=vmax, cmap=plot.cmaps[channel]) colorbar_here = plot.colorbar(img) ax.set_xticks([]) ax.set_yticks([]) if ax is axs[1]: colorbar_here.set_label("Pearson $r$") colorbar_here.locator = plot.ticker.MaxNLocator(nbins=4) colorbar_here.update_ticks() plt.savefig(save_to_map_JPEG) plt.close() print(f"Saved map of JPEG Pearson r to '{save_to_map_JPEG}'") # Print comparative statistics on the RAW and JPEG (R/G/B) Pearson r values
# Get the data folder from the command line file = io.path_from_input(argv) root = io.find_root_folder(file) savefolder = root / "analysis/gain/" ISO = io.split_iso(file) # Get metadata camera = io.load_metadata(root) print("Loaded metadata") # Load the data gains = np.load(file) print("Loaded data") # Plot an RGB histogram of the data xmin, xmax = 0, analyse.symmetric_percentiles(gains, percent=0.001)[1] camera.plot_histogram_RGB(gains, xmin=xmin, xmax=xmax, xlabel="Gain (ADU/e$^-$)", saveto=savefolder / f"gain_histogram_iso{ISO}.pdf") print("Made histogram") # Plot Gauss-convolved maps of the data camera.plot_gauss_maps(gains, colorbar_label="Gain (ADU/e$^-$)", saveto=savefolder / f"gain_map_iso{ISO}.pdf") print("Made maps") # Demosaick data by splitting the RGBG2 channels into separate arrays gains_RGBG = camera.demosaick(gains)
ax.set_title(label) # Include a colorbar # Left-most map has a colorbar on the left if ax is axs[0]: loc = "left" # Right-most map has a colorbar on the right elif ax is axs[-1]: loc = "right" # Any other maps have a colorbar on the bottom else: loc = "bottom" cbar = plot.colorbar(im, location=loc, label="Gain (ADU/e$^-$)") # Print the range of gain values found in this map percentile_low, percentile_high = analyse.symmetric_percentiles( data_RGBG) print(label) print(f"{c_label:>2}: {percentile_low:.2f} -- {percentile_high:.2f}") # Save the figure save_to_map_c = save_folder / f"gain_map_{c_label}.pdf" fig.savefig(save_to_map_c) plt.close() print(f"Saved gain map for the {c_label} channel to '{save_to_map_c}'") # Plot a histogram fig, axs = plt.subplots(ncols=len(files), nrows=4, figsize=(3 * len(files), 3), tight_layout=True, gridspec_kw={