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}