the system time and an increasing number. This ensures the subfolders are
in the same order as the original data.
Command line arguments:
* `folder_main`: folder containing RAW (and JPEG, if available) files which
should be split into subfolders.
* `blocksize`: the number of files to put in each folder (e.g. 10, 15).
"""
from sys import argv
from shutil import move
import os
from time import time
from spectacle import io
folder_main = io.path_from_input(argv[:2])
root = io.find_root_folder(folder_main)
camera = io.load_metadata(root)
raw_pattern = f"*{camera.image.raw_extension}"
blocksize = int(argv[2])
files = list(folder_main.glob(raw_pattern))
files = sorted(files)
blocks = len(files) // blocksize
for i in range(blocks):
foldername = str(int(time() * 10000)) + str(i % 10)
total_path = folder_main / foldername
print(total_path)
os.mkdir(total_path)
files_block = files[blocksize * i:blocksize * (i + 1)]
for file in files_block:
Command line arguments:
* `folder`: folder containing NPY stacks of dark-current data taken at
different exposure times.
To do:
* Save maps for all ISOs and use these in the calibration process.
* Generic filenames, if data are not labelled by ISO.
"""
import numpy as np
from sys import argv
from spectacle import io, dark
# Get the data folder from the command line
folder = io.path_from_input(argv)
root = io.find_root_folder(folder)
# Load Camera object
camera = io.load_camera(root)
print(f"Loaded Camera object: {camera}")
# Save location based on camera name
save_to_normalised = camera.filename_calibration("dark_current_normalised.npy")
# Get the ISO speed at which the data were taken from the folder name
ISO = io.split_iso(folder)
save_to_ADU = camera.filename_intermediaries(
"dark_current/dark_current_iso{ISO}.npy", makefolders=True)
# Load the data
import numpy as np
from sys import argv
from spectacle import io, calibrate
from matplotlib import pyplot as plt
folder, wvl = io.path_from_input(argv)
wvl = wvl.stem
root = io.find_root_folder(folder)
camera = io.load_metadata(root)
m = np.load(folder / f"{wvl}_mean.npy")
m = calibrate.correct_bias(root, m)
s = np.load(folder / f"{wvl}_stds.npy")
s[s < 0.001] = -1 # prevent infinities
SNR = m / s
m_RGBG, s_RGBG, SNR_RGBG = camera.demosaick(m, s, SNR)
mean_stack = m_RGBG.mean(axis=(1, 2))
std_stack = m_RGBG.std(axis=(1, 2))
SNR_stack = mean_stack / std_stack
for j, c in enumerate("RGBG"):
SNR_here = SNR_RGBG[j].ravel()
mean_here = m_RGBG[j].ravel()
plt.figure(figsize=(10, 3))
plt.hist(SNR_here, bins=np.arange(0, 100, 1), color=c)
plt.xlabel("SNR")
plt.axvline(3, c='k', ls="--")
Analyse dark current maps (in normalised ADU/s) generated using the calibration
functions. The dark current is converted from normalised ADU/s to electrons/s
using a gain map.
Command line arguments:
* `file`: the location of the dark current map to be analysed. This map
should be an NPY file generated using ../calibration/dark_current.py.
"""
import numpy as np
from sys import argv
from spectacle import io
# Get the data file from the command line
file = io.path_from_input(argv)
root = io.find_root_folder(file)
# Load Camera object
camera = io.load_camera(root)
print(f"Loaded Camera object: {camera}")
# Save locations
savefolder = camera.filename_analysis("dark_current", makefolders=True)
save_to_maps = savefolder/"dark_current_map_electrons.pdf"
save_to_histogram = savefolder/"dark_current_histogram_electrons.pdf"
# Load the data
dark_current_normADU = np.load(file)
print("Loaded data")
These calculations are all done for each individual pixel.
Command line arguments:
* `folder`: the folder containing linearity data stacks. These should be
NPY stacks taken at different exposure conditions, with the same ISO speed.
* `gamma`: the gamma value of the sRGB model to compare to the data. Any
number of gamma values can be provided.
"""
import numpy as np
from sys import argv
from spectacle import io, linearity as lin
# Get the data folder from the command line
folder, *gammas = io.path_from_input(argv)
gammas = [float(str(gamma)) for gamma in gammas]
root = io.find_root_folder(folder)
# Load Camera object
camera = io.load_camera(root)
print(f"Loaded Camera object: {camera}")
# Save locations
savefolder = camera.filename_intermediaries("flatfield", makefolders=True)
# Load the data
intensities_with_errors, jmeans = io.load_jmeans(folder, retrieve_value=lin.filename_to_intensity)
intensities, intensity_errors = intensities_with_errors.T
print("Loaded data")
monochromator. The data are expected to be in subfolders of a main folder, each
subfolder corresponding to a monochromator setting (e.g. filter/grating).
Command line arguments:
* `folder`: folder containing subfolders with monochromator data. The sub-
folders correspond to different monochromator settings (e.g. gratings or
filters). Each subfolder in turn contains NPY stacks of monochromator data
taken at different wavelengths.
"""
import numpy as np
from sys import argv
from spectacle import io, spectral
# Get the data folder and minimum and maximum wavelengths from the command line
folder, wvl1, wvl2 = io.path_from_input(argv)
wvl1 = float(wvl1.stem)
wvl2 = float(wvl2.stem)
root = io.find_root_folder(folder)
# Get the camera metadata
camera = io.load_metadata(root)
print("Loaded metadata")
# Get the subfolders in the given data folder
folders = io.find_subfolders(folder)
# Load the data from each subfolder
spectra = [
spectral.load_monochromator_data(root, subfolder) for subfolder in folders
]
* `file2`: the location of the second flat-field map.
These flat-field maps should be NPY stacks generated using
../calibration/flatfield.py
To do:
* Input labels for plots
"""
import numpy as np
from sys import argv
from spectacle import io, analyse, plot
from spectacle.general import RMS
from matplotlib import pyplot as plt
# Get the data folder from the command line
file1, file2 = io.path_from_input(argv)
root = io.find_root_folder(file1)
label = "comparison_" + file1.stem + "_X_" + file2.stem
# Load Camera object
camera = io.load_camera(root)
print(f"Loaded Camera object: {camera}")
# Save locations
savefolder = camera.filename_analysis("flatfield", makefolders=True)
save_to_histogram = savefolder / f"{label}_histogram.pdf"
save_to_histogram_RGB = savefolder / f"{label}_histogram_RGB.pdf"
save_to_maps = savefolder / f"{label}_map.pdf"
save_to_combined_map = savefolder / f"{label}_map_combined.pdf"
# Load the data
* `file_raw`: the file containing the Pearson r map to be analysed. This r
map should be an NPY stack generated using linearity_raw.py.
Optional:
* `file_jpeg`: the file containing the JPEG Pearson r map to be analysed.
This r map should be an NPY stacks generated using linearity_jpeg.py.
"""
import numpy as np
from sys import argv
from matplotlib import pyplot as plt
from spectacle import io, analyse, plot
# Get the data folder from the command line
# Use JPEG data if these are provided
try:
file_raw, file_jpeg = io.path_from_input(argv)
except TypeError:
file_raw = io.path_from_input(argv)
jpeg_data_available = False
else:
jpeg_data_available = True
root = io.find_root_folder(file_raw)
if jpeg_data_available:
print("JPEG data have been provided")
else:
print("JPEG data are not available")
# Load Camera object
camera = io.load_camera(root)
print(f"Loaded Camera object: {camera}")
"""
Compare stacked images to WISP data.
"""
import numpy as np
from sys import argv
from spectacle import plot, io, wavelength, raw, general, calibrate
from ispex import general as ispex_general, plot as ispex_plot, validation
from matplotlib import pyplot as plt
from pathlib import Path
# Get the filenames from the command line
filename_ispex, filename_wisp = io.path_from_input(argv)
# For iSPEX, get the grey card, sky, and water filenames
# For now, assume the given filename was for the grey card
label_dataset = filename_ispex.parents[1].stem
parent_ispex = filename_ispex.parent
filename_grey = filename_ispex
filename_sky = parent_ispex / (filename_grey.stem.replace("grey", "sky") +
filename_grey.suffix)
filename_water = parent_ispex / (filename_grey.stem.replace("grey", "water") +
filename_grey.suffix)
filenames_ispex = [filename_grey, filename_sky, filename_water]
# Get the std filenames from the mean filenames
filenames_ispex_std = [
parent_ispex / (filename.stem.replace("mean", "stds") + filename.suffix)
for filename in filenames_ispex
]
