utils/create_splits.py

import os
import random
from glob import glob
import json

import numpy as np
from astropy.io import fits
from astropy.coordinates import Angle
from astropy import units as u
from fsspec.core import url_to_fs

from huggingface_hub import hf_hub_download
import datasets
from datasets import DownloadManager

from tqdm import tqdm

def lris_read_amp(inp, ext, redchip=False, applygain=True):
 """
 Modified from pypeit.spectrographs.keck_lris.lris_read_amp -- Jon Brown, Josh Bloom
 cf. https://github.com/KerryPaterson/Imaging_pipelines
 Read one amplifier of an LRIS multi-extension FITS image

 Parameters
 ----------
 inp: tuple
 (str,int) filename, extension
 (hdu,int) FITS hdu, extension

 Returns
 -------
 data
 predata
 postdata
 x1
 y1

 ;------------------------------------------------------------------------
 function lris_read_amp, filename, ext, $
 linebias=linebias, nobias=nobias, $
 predata=predata, postdata=postdata, header=header, $
 x1=x1, x2=x2, y1=y1, y2=y2, GAINDATA=gaindata
 ;------------------------------------------------------------------------
 ; Read one amp from LRIS mHDU image
 ;------------------------------------------------------------------------
 """
 # Parse input
 if isinstance(inp, str):
 hdu = fits.open(inp)
 else:
 hdu = inp

 # Get the pre and post pix values
 # for LRIS red POSTLINE = 20, POSTPIX = 80, PRELINE = 0, PRECOL = 12
 head0 = hdu[0].header
 precol = head0["precol"]
 postpix = head0["postpix"]

 # Deal with binning
 binning = head0["BINNING"]
 xbin, ybin = [int(ibin) for ibin in binning.split(",")]
 precol = precol // xbin
 postpix = postpix // xbin

 # get entire extension...
 temp = hdu[ext].data.transpose() # Silly Python nrow,ncol formatting
 tsize = temp.shape
 nxt = tsize[0]

 # parse the DETSEC keyword to determine the size of the array.
 header = hdu[ext].header
 detsec = header["DETSEC"]
 x1, x2, y1, y2 = np.array(load_sections(detsec, fmt_iraf=False)).flatten()

 # parse the DATASEC keyword to determine the size of the science region (unbinned)
 datasec = header["DATASEC"]
 xdata1, xdata2, ydata1, ydata2 = np.array(
 load_sections(datasec, fmt_iraf=False)
 ).flatten()

 # grab the components...
 predata = temp[0:precol, :]
 # datasec appears to have the x value for the keywords that are zero
 # based. This is only true in the image header extensions
 # not true in the main header. They also appear inconsistent between
 # LRISr and LRISb!
 # data = temp[xdata1-1:xdata2-1,*]
 # data = temp[xdata1:xdata2+1, :]

 # JB: LRIS-R is windowed differently, so the default pypeit checks fail
 # xshape is calculated from datasec.
 # For blue, its 1024,
 # For red, the chip dimensions are different AND the observations are windowed
 # In windowed mode each amplifier has differently sized data sections
 if not redchip:
 xshape = 1024 // xbin # blue
 else:
 xshape = xdata2 - xdata1 + 1 // xbin # red

 # do some sanity checks
 if (xdata1 - 1) != precol:
 # msgs.error("Something wrong in LRIS datasec or precol")
 errStr = "Something wrong in LRIS datasec or precol"
 print(errStr)

 if (xshape + precol + postpix) != temp.shape[0]:
 # msgs.error("Wrong size for in LRIS detector somewhere. Funny binning?")
 errStr = "Wrong size for in LRIS detector somewhere. Funny binning?"
 print(errStr)

 data = temp[precol : precol + xshape, :]
 postdata = temp[nxt - postpix : nxt, :]

 # flip in X as needed...
 if x1 > x2:
 xt = x2
 x2 = x1
 x1 = xt
 data = np.flipud(data) # reverse(temporary(data),1)

 # flip in Y as needed...
 if y1 > y2:
 yt = y2
 y2 = y1
 y1 = yt
 data = np.fliplr(data)
 predata = np.fliplr(predata)
 postdata = np.fliplr(postdata)

 # dummy gain data since we're keeping as uint16
 gaindata = 0.0 * data + 1.0

 return data, gaindata, predata, postdata, x1, y1


def load_sections(string, fmt_iraf=True):
 """
 Modified from pypit.core.parse.load_sections -- Jon Brown, Josh Bloom
 cf. https://github.com/KerryPaterson/Imaging_pipelines
 From the input string, return the coordinate sections

 Parameters
 ----------
 string : str
 character string of the form [x1:x2,y1:y2]
 x1 = left pixel
 x2 = right pixel
 y1 = bottom pixel
 y2 = top pixel
 fmt_iraf : bool
 Is the variable string in IRAF format (True) or
 python format (False)

 Returns
 -------
 sections : list (or None)
 the detector sections
 """
 xyrng = string.strip("[]()").split(",")
 if xyrng[0] == ":":
 xyarrx = [0, 0]
 else:
 xyarrx = xyrng[0].split(":")
 # If a lower/upper limit on the array slicing is not given (e.g. [:100] has no lower index specified),
 # set the lower/upper limit to be the first/last index.
 if len(xyarrx[0]) == 0:
 xyarrx[0] = 0
 if len(xyarrx[1]) == 0:
 xyarrx[1] = -1
 if xyrng[1] == ":":
 xyarry = [0, 0]
 else:
 xyarry = xyrng[1].split(":")
 # If a lower/upper limit on the array slicing is not given (e.g. [5:] has no upper index specified),
 # set the lower/upper limit to be the first/last index.
 if len(xyarry[0]) == 0:
 xyarry[0] = 0
 if len(xyarry[1]) == 0:
 xyarry[1] = -1
 if fmt_iraf:
 xmin = max(0, int(xyarry[0]) - 1)
 xmax = int(xyarry[1])
 ymin = max(0, int(xyarrx[0]) - 1)
 ymax = int(xyarrx[1])
 else:
 xmin = max(0, int(xyarrx[0]))
 xmax = int(xyarrx[1])
 ymin = max(0, int(xyarry[0]))
 ymax = int(xyarry[1])
 return [[xmin, xmax], [ymin, ymax]]


def sec2slice(
 subarray, one_indexed=False, include_end=False, require_dim=None, transpose=False
):
 """
 Modified from pypit.core.parse.sec2slice -- Jon Brown

 Convert a string representation of an array subsection (slice) into
 a list of slice objects.

 Args:
 subarray (str):
 The string to convert. Should have the form of normal slice
 operation, 'start:stop:step'. The parser ignores whether or
 not the string has the brackets '[]', but the string must
 contain the appropriate ':' and ',' characters.
 one_indexed (:obj:`bool`, optional):
 The string should be interpreted as 1-indexed. Default
 is to assume python indexing.
 include_end (:obj:`bool`, optional):
 **If** the end is defined, adjust the slice such that
 the last element is included. Default is to exclude the
 last element as with normal python slicing.
 require_dim (:obj:`int`, optional):
 Test if the string indicates the slice along the proper
 number of dimensions.
 transpose (:obj:`bool`, optional):
 Transpose the order of the returned slices. The
 following are equivalent::

 tslices = parse_sec2slice('[:10,10:]')[::-1]
 tslices = parse_sec2slice('[:10,10:]', transpose=True)

 Returns:
 tuple: A tuple of slice objects, one per dimension of the
 prospective array.

 Raises:
 TypeError:
 Raised if the input `subarray` is not a string.
 ValueError:
 Raised if the string does not match the required
 dimensionality or if the string does not look like a
 slice.
 """
 # Check it's a string
 if not isinstance(subarray, (str, bytes)):
 raise TypeError("Can only parse string-based subarray sections.")
 # Remove brackets if they're included
 sections = subarray.strip("[]").split(",")
 # Check the dimensionality
 ndim = len(sections)
 if require_dim is not None and ndim != require_dim:
 raise ValueError(
 "Number of slices ({0}) in {1} does not match ".format(ndim, subarray)
 + "required dimensions ({0}).".format(require_dim)
 )
 # Convert the slice of each dimension from a string to a slice
 # object
 slices = []
 for s in sections:
 # Must be able to find the colon
 if ":" not in s:
 raise ValueError("Unrecognized slice string: {0}".format(s))
 # Initial conversion
 _s = [None if x == "" else int(x) for x in s.split(":")]
 if len(_s) > 3:
 raise ValueError(
 "String as too many sections. Must have format 'start:stop:step'."
 )
 if len(_s) < 3:
 # Include step
 _s += [None]
 if one_indexed:
 # Decrement to convert from 1- to 0-indexing
 _s = [None if x is None else x - 1 for x in _s]
 if include_end and _s[1] is not None:
 # Increment to include last
 _s[1] += 1
 # Append the new slice
 slices += [slice(*_s)]
 return tuple(slices[::-1] if transpose else slices)

def read_lris(raw_file, det=None, TRIM=False):
 """
 Modified from pypeit.spectrographs.keck_lris.read_lris -- Jon Brown, Josh Bloom
 cf. https://github.com/KerryPaterson/Imaging_pipelines

 Read a raw LRIS data frame (one or more detectors)
 Packed in a multi-extension HDU
 Based on readmhdufits.pro

 Parameters
 ----------
 raw_file : str
 Filename
 det : int, optional
 Detector number; Default = both
 TRIM : bool, optional
 Trim the image?

 Returns
 -------
 array : ndarray
 Combined image
 header : FITS header
 sections : list
 List of datasec, oscansec, ampsec sections
 """

 hdu = fits.open(raw_file)
 head0 = hdu[0].header

 # Get post, pre-pix values
 precol = head0["PRECOL"]
 postpix = head0["POSTPIX"]
 preline = head0["PRELINE"]
 postline = head0["POSTLINE"]

 # get the detector
 # this just checks if its the blue one and assumes red if not
 # note the red fits headers don't even have this keyword???
 if head0["INSTRUME"] == "LRISBLUE":
 redchip = False
 else:
 redchip = True

 # Setup for datasec, oscansec
 dsec = []
 osec = []
 nxdata_sum = 0

 # get the x and y binning factors...
 binning = head0["BINNING"]
 xbin, ybin = [int(ibin) for ibin in binning.split(",")]

 # First read over the header info to determine the size of the output array...
 n_ext = len(hdu) - 1 # Number of extensions (usually 4)
 xcol = []
 xmax = 0
 ymax = 0
 xmin = 10000
 ymin = 10000
 for i in np.arange(1, n_ext + 1):
 theader = hdu[i].header
 detsec = theader["DETSEC"]
 if detsec != "0":
 # parse the DETSEC keyword to determine the size of the array.
 x1, x2, y1, y2 = np.array(load_sections(detsec, fmt_iraf=False)).flatten()

 # find the range of detector space occupied by the data
 # [xmin:xmax,ymin:ymax]
 xt = max(x2, x1)
 xmax = max(xt, xmax)
 yt = max(y2, y1)
 ymax = max(yt, ymax)

 # find the min size of the array
 xt = min(x1, x2)
 xmin = min(xmin, xt)
 yt = min(y1, y2)
 ymin = min(ymin, yt)
 # Save
 xcol.append(xt)

 # determine the output array size...
 nx = xmax - xmin + 1
 ny = ymax - ymin + 1

 # change size for binning...
 nx = nx // xbin
 ny = ny // ybin

 # Update PRECOL and POSTPIX
 precol = precol // xbin
 postpix = postpix // xbin

 # Deal with detectors
 if det in [1, 2]:
 nx = nx // 2
 n_ext = n_ext // 2
 det_idx = np.arange(n_ext, dtype=np.int) + (det - 1) * n_ext
 elif det is None:
 det_idx = np.arange(n_ext).astype(int)
 else:
 raise ValueError("Bad value for det")

 # change size for pre/postscan...
 if not TRIM:
 nx += n_ext * (precol + postpix)
 ny += preline + postline

 # allocate output array...
 array = np.zeros((nx, ny), dtype="uint16")
 gain_array = np.zeros((nx, ny), dtype="uint16")
 order = np.argsort(np.array(xcol))

 # insert extensions into master image...
 for kk, i in enumerate(order[det_idx]):

 # grab complete extension...
 data, gaindata, predata, postdata, x1, y1 = lris_read_amp(
 hdu, i + 1, redchip=redchip
 )

 # insert components into output array...
 if not TRIM:
 # insert predata...
 buf = predata.shape
 nxpre = buf[0]
 xs = kk * precol
 xe = xs + nxpre

 array[xs:xe, :] = predata
 gain_array[xs:xe, :] = predata

 # insert data...
 buf = data.shape
 nxdata = buf[0]
 nydata = buf[1]

 # JB: have to track the number of xpixels
 xs = n_ext * precol + nxdata_sum
 xe = xs + nxdata

 # now log how many pixels that was
 nxdata_sum += nxdata

 # Data section
 # section = '[{:d}:{:d},{:d}:{:d}]'.format(preline,nydata-postline, xs, xe) # Eliminate lines
 section = "[{:d}:{:d},{:d}:{:d}]".format(
 preline, nydata, xs, xe
 ) # DONT eliminate lines

 dsec.append(section)
 array[xs:xe, :] = data # Include postlines
 gain_array[xs:xe, :] = gaindata # Include postlines

 # ; insert postdata...
 buf = postdata.shape
 nxpost = buf[0]
 xs = nx - n_ext * postpix + kk * postpix
 xe = xs + nxpost
 section = "[:,{:d}:{:d}]".format(xs, xe)
 osec.append(section)

 array[xs:xe, :] = postdata
 gain_array[xs:xe, :] = postdata

 else:
 buf = data.shape
 nxdata = buf[0]
 nydata = buf[1]

 xs = (x1 - xmin) // xbin
 xe = xs + nxdata
 ys = (y1 - ymin) // ybin
 ye = ys + nydata - postline

 yin1 = preline
 yin2 = nydata - postline

 array[xs:xe, ys:ye] = data[:, yin1:yin2]
 gain_array[xs:xe, ys:ye] = gaindata[:, yin1:yin2]

 # make sure BZERO is a valid integer for IRAF
 obzero = head0["BZERO"]
 head0["O_BZERO"] = obzero
 head0["BZERO"] = 32768 - obzero

 # Return, transposing array back to goofy Python indexing
 return array.T, head0


def make_split_jsonl_files(
 config_type="tiny", data_dir="./data", outdir="./splits", seed=42
):
 """
 Create jsonl files for the GBI-16-2D dataset.

 config_type: str, default="tiny"
 The type of split to create. Options are "tiny" and "full".
 data_dir: str, default="./data"
 The directory where the FITS files are located.
 outdir: str, default="./splits"
 The directory where the jsonl files will be created.
 seed: int, default=42
 The seed for the random split.
 """
 random.seed(seed)
 os.makedirs(outdir, exist_ok=True)

 fits_files = glob(os.path.join(data_dir, "*.fits"))
 random.shuffle(fits_files)
 if config_type == "tiny":
 train_files = fits_files[:2]
 test_files = fits_files[2:3]
 elif config_type == "full":
 split_idx = int(0.8 * len(fits_files))
 train_files = fits_files[:split_idx]
 test_files = fits_files[split_idx:]
 else:
 raise ValueError("Unsupported config_type. Use 'tiny' or 'full'.")

 def create_jsonl(files, split_name):
 output_file = os.path.join(outdir, f"{config_type}_{split_name}.jsonl")
 with open(output_file, "w") as out_f:
 for file in tqdm(files):
 #print(file, flush=True, end="...")
 image_id = os.path.basename(file).split(".fits")[0]
 with fits.open(file, memmap=False) as hdul:
 if len(hdul) > 1:
 # multiextension ... paste together
 data, header = read_lris(file)
 dim_1 = data.shape[0]
 dim_2 = data.shape[1]
 header = fits.header.Header(header)
 else:
 dim_1 = hdul[0].header.get("NAXIS1", 0)
 dim_2 = hdul[0].header.get("NAXIS2", 0)
 header = hdul[0].header

 ras = header.get("RA", "0")
 ra = float(
 Angle(f"{ras} hours").to_string(unit=u.degree, decimal=True)
 )
 decs = header.get("DEC", "0")
 dec = float(
 Angle(f"{decs} degrees").to_string(unit=u.degree, decimal=True)
 )
 pixscale = header.get("CD1_2", 0.135)
 rotation = header.get("ROTPOSN", 0.0)
 exposure_time = header.get("TTIME", 0.0)
 item = {
 "image_id": image_id,
 "image": file,
 "ra": ra,
 "dec": dec,
 "pixscale": pixscale,
 "rotation_angle": rotation,
 "dim_1": dim_1,
 "dim_2": dim_2,
 "exposure_time": exposure_time,
 }
 out_f.write(json.dumps(item) + "\n")

 create_jsonl(train_files, "train")
 create_jsonl(test_files, "test")


if __name__ == "__main__":
 make_split_jsonl_files("tiny")
 make_split_jsonl_files("full")