uploaded filtered keck files made splits made utils

GBI-16-2D.py

@@ -13,6 +13,8 @@ from huggingface_hub import hf_hub_download
 import datasets
 from datasets import DownloadManager
 
+from utils import read_lris
+
 
 _DESCRIPTION = (
     """SBI-16-2D is a dataset which is part of the AstroCompress project. """
@@ -167,529 +169,4 @@ class GBI_16_2D(datasets.GeneratorBasedBuilder):
                 else:
                     data = hdul[0].data
                 image_data = data[:, :]
-                yield task_instance_key, {**{"image": image_data}, **item}
-
-
-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 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")
-
-
-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 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)
+                yield task_instance_key, {**{"image": image_data}, **item}