def main(args):
import os
from pypeit.core.gui.skysub_regions import SkySubGUI
from pypeit.core import flexure
from pypeit.scripts import utils
from pypeit import masterframe
from pypeit.images import buildimage
# Generate a utilities class
info = utils.Utilities(None, pypeit_file=args.file, det=args.det)
# Interactively select a science frame
sciIdx = info.select_science_frame(standard=args.standard)
# Load the spectrograph and parset
info.load_spectrograph_parset(sciIdx)
# Get the master key and directory
mdir, mkey = info.get_master_dirkey()
# Load the image data
frame = info.load_frame(sciIdx)
# Load the slits information
slits = utils.get_slits(mkey, mdir)
spat_flexure = None
if args.flexure:
spat_flexure = flexure.spat_flexure_shift(frame, slits)
# Derive an appropriate output filename
file_base = info.get_basename(sciIdx)
prefix = os.path.splitext(file_base)
if prefix[1] == ".gz":
outname = os.path.splitext(prefix[0])[0]
else:
outname = prefix[0]
ext = buildimage.SkyRegions.master_file_format
regfile = masterframe.construct_file_name(buildimage.SkyRegions, master_key=mkey,
master_dir=mdir)
regfile = regfile.replace(".{0:s}".format(ext), "_{0:s}.{1:s}".format(outname, ext))
#outname = "{0:s}/MasterSkyRegions_{1:s}_{2:s}.fits.gz".format(mdir, mkey, outname)
# Finally, initialise the GUI
skyreg = SkySubGUI.initialize(args.det, frame, slits, info.spectrograph.pypeline,
info.spectrograph.name, outname=regfile,
overwrite=args.overwrite, runtime=False, printout=True,
initial=args.initial, flexure=spat_flexure)
# Get the results
skyreg.get_result()
def main(args):
# Generate a utilities class
info = utils.Utilities(args.file, args.det)
# Interactively select a science frame
sciIdx = info.select_science_frame()
# Load the spectrograph and parset
info.load_spectrograph_parset(sciIdx)
# Get the master key and directory
mdir, mkey = info.get_master_dirkey()
# Load the image data
frame = info.load_frame(sciIdx)
# Load the slits information
slits = utils.get_slits(mkey, mdir)
spat_flexure = None
if args.flexure:
spat_flexure = flexure.spat_flexure_shift(frame, slits)
# Derive an appropriate output filename
file_base = info.get_basename(sciIdx)
prefix = os.path.splitext(file_base)
if prefix[1] == ".gz":
outname = os.path.splitext(prefix[0])[0]
else:
outname = prefix[0]
outname = "{0:s}/MasterSkyRegions_{1:s}_{2:s}.fits.gz".format(
mdir, mkey, outname)
# Finally, initialise the GUI
skyreg = SkySubGUI.initialize(args.det,
frame,
slits,
info.spectrograph.pypeline,
outname=outname,
overwrite=args.overwrite,
runtime=False,
printout=True,
initial=args.initial,
flexure=spat_flexure)
# Get the results
skyreg.get_result()
def process(self,
par,
bpm=bpm,
flatimages=None,
bias=None,
slits=None,
debug=False,
dark=None):
"""
Process the image
Note: The processing step order is currently 'frozen' as is.
We may choose to allow optional ordering
Here are the allowed steps, in the order they will be applied:
subtract_overscan -- Analyze the overscan region and subtract from the image
trim -- Trim the image down to the data (i.e. remove the overscan)
orient -- Orient the image in the PypeIt orientation (spec, spat) with blue to red going down to up
subtract_bias -- Subtract a bias image
apply_gain -- Convert to counts, amp by amp
flatten -- Divide by the pixel flat and (if provided) the illumination flat
extras -- Generate the RN2 and IVAR images
crmask -- Generate a CR mask
Args:
par (:class:`pypeit.par.pypeitpar.ProcessImagesPar`):
Parameters that dictate the processing of the images. See
:class:`pypeit.par.pypeitpar.ProcessImagesPar` for the
defaults.
bpm (`numpy.ndarray`_, optional):
flatimages (:class:`pypeit.flatfield.FlatImages`):
bias (`numpy.ndarray`_, optional):
Bias image
slits (:class:`pypeit.slittrace.SlitTraceSet`, optional):
Used to calculate spatial flexure between the image and the slits
Returns:
:class:`pypeit.images.pypeitimage.PypeItImage`:
"""
self.par = par
self._bpm = bpm
# Get started
# Standard order
# -- May need to allow for other order some day..
if par['use_pattern']: # Note, this step *must* be done before use_overscan
self.subtract_pattern()
if par['use_overscan']:
self.subtract_overscan()
if par['trim']:
self.trim()
if par['orient']:
self.orient()
if par['use_biasimage']: # Bias frame, if it exists, is *not* trimmed nor oriented
self.subtract_bias(bias)
if par['use_darkimage']: # Dark frame, if it exists, is TODO:: check: trimmed, oriented (and oscan/bias subtracted?)
self.subtract_dark(dark)
if par['apply_gain']:
self.apply_gain()
# This needs to come after trim, orient
# Calculate flexure -- May not be used, but always calculated when slits are provided
if slits is not None and self.par['spat_flexure_correct']:
self.spat_flexure_shift = flexure.spat_flexure_shift(
self.image, slits)
# Generate the illumination flat, as needed
illum_flat = None
if self.par['use_illumflat']:
if flatimages is None:
msgs.error(
"Cannot illumflatten, no such image generated. Add one or more illumflat images to your PypeIt file!!"
)
if slits is None:
msgs.error("Need to provide slits to create illumination flat")
illum_flat = flatimages.fit2illumflat(
slits, flexure_shift=self.spat_flexure_shift)
if debug:
left, right = slits.select_edges(
flexure=self.spat_flexure_shift)
viewer, ch = display.show_image(illum_flat,
chname='illum_flat')
display.show_slits(viewer, ch, left, right) # , slits.id)
#
orig_image = self.image.copy()
viewer, ch = display.show_image(orig_image,
chname='orig_image')
display.show_slits(viewer, ch, left, right) # , slits.id)
# Apply the relative spectral illumination
spec_illum = 1.0
if self.par['use_specillum']:
if flatimages is None or flatimages.get_spec_illum() is None:
msgs.error(
"Spectral illumination correction desired but not generated/provided."
)
else:
spec_illum = flatimages.get_spec_illum().copy()
# Flat field -- We cannot do illumination flat without a pixel flat (yet)
if self.par['use_pixelflat'] or self.par['use_illumflat']:
if flatimages is None or flatimages.get_pixelflat() is None:
msgs.error("Flat fielding desired but not generated/provided.")
else:
self.flatten(flatimages.get_pixelflat() * spec_illum,
illum_flat=illum_flat,
bpm=self.bpm)
# Fresh BPM
bpm = self.spectrograph.bpm(self.filename,
self.det,
shape=self.image.shape)
# Extras
self.build_rn2img()
self.build_ivar()
# Generate a PypeItImage
pypeitImage = pypeitimage.PypeItImage(
self.image,
ivar=self.ivar,
rn2img=self.rn2img,
bpm=bpm,
detector=self.detector,
spat_flexure=self.spat_flexure_shift,
PYP_SPEC=self.spectrograph.spectrograph)
pypeitImage.rawheadlist = self.headarr
pypeitImage.process_steps = [
key for key in self.steps.keys() if self.steps[key]
]
# Mask(s)
if par['mask_cr']:
pypeitImage.build_crmask(self.par)
#
nonlinear_counts = self.spectrograph.nonlinear_counts(
self.detector, apply_gain=self.par['apply_gain'])
# Build
pypeitImage.build_mask(saturation=nonlinear_counts)
# Return
return pypeitImage
