import os import random from glob import glob import json from huggingface_hub import hf_hub_download from tqdm import tqdm import numpy as np from astropy.io import fits from astropy.wcs import WCS import datasets from datasets import DownloadManager from fsspec.core import url_to_fs _DESCRIPTION = ( """SBI-16-3D is a dataset which is part of the AstroCompress project. """ """It contains data assembled from the James Webb Space Telescope (JWST). """ """Describe data format""" ) _HOMEPAGE = "https://google.github.io/AstroCompress" _LICENSE = "CC BY 4.0" _URL = "https://huggingface.co/datasets/AstroCompress/SBI-16-3D/resolve/main/" _URLS = { "tiny": { "train": "./splits/tiny_train.jsonl", "test": "./splits/tiny_test.jsonl", }, "full": { "train": "./splits/full_train.jsonl", "test": "./splits/full_test.jsonl", }, } _REPO_ID = "AstroCompress/SBI-16-3D" class SBI_16_3D(datasets.GeneratorBasedBuilder): """SBI-16-3D Dataset""" VERSION = datasets.Version("1.0.3") BUILDER_CONFIGS = [ datasets.BuilderConfig( name="tiny", version=VERSION, description="A small subset of the data, to test downsteam workflows.", ), datasets.BuilderConfig( name="full", version=VERSION, description="The full dataset", ), ] DEFAULT_CONFIG_NAME = "tiny" def __init__(self, **kwargs): super().__init__(version=self.VERSION, **kwargs) def _info(self): return datasets.DatasetInfo( description=_DESCRIPTION, features=datasets.Features( { "image": datasets.Array3D(shape=(None, 2048, 2048), dtype="uint16"), "ra": datasets.Value("float64"), "dec": datasets.Value("float64"), "pixscale": datasets.Value("float64"), "ntimes": datasets.Value("int64"), "image_id": datasets.Value("string"), } ), supervised_keys=None, homepage=_HOMEPAGE, license=_LICENSE, citation="TBD", ) def _split_generators(self, dl_manager: DownloadManager): ret = [] base_path = dl_manager._base_path locally_run = not base_path.startswith(datasets.config.HF_ENDPOINT) _, path = url_to_fs(base_path) for split in ["train", "test"]: if locally_run: split_file_location = os.path.normpath( os.path.join(path, _URLS[self.config.name][split]) ) split_file = dl_manager.download_and_extract(split_file_location) else: split_file = hf_hub_download( repo_id=_REPO_ID, filename=_URLS[self.config.name][split], repo_type="dataset", ) with open(split_file, encoding="utf-8") as f: data_filenames = [] data_metadata = [] for line in f: item = json.loads(line) data_filenames.append(item["image"]) data_metadata.append( { "ra": item["ra"], "dec": item["dec"], "pixscale": item["pixscale"], "ntimes": item["ntimes"], "image_id": item["image_id"], } ) if locally_run: data_urls = [ os.path.normpath(os.path.join(path, data_filename)) for data_filename in data_filenames ] data_files = [ dl_manager.download(data_url) for data_url in data_urls ] else: data_urls = data_filenames data_files = [ hf_hub_download( repo_id=_REPO_ID, filename=data_url, repo_type="dataset" ) for data_url in data_urls ] ret.append( datasets.SplitGenerator( name=( datasets.Split.TRAIN if split == "train" else datasets.Split.TEST ), gen_kwargs={ "filepaths": data_files, "split_file": split_file, "split": split, "data_metadata": data_metadata, }, ), ) return ret def _generate_examples(self, filepaths, split_file, split, data_metadata): """Generate GBI-16-4D examples""" for idx, (filepath, item) in enumerate(zip(filepaths, data_metadata)): task_instance_key = f"{self.config.name}-{split}-{idx}" with fits.open(filepath, memmap=False) as hdul: # the first axis is integrations one, so we take the first element # the second axis is the groups (time) axis and varies between images image_data = hdul["SCI"].data[0, :, :, :] # .tolist() yield task_instance_key, {**{"image": image_data}, **item} def get_fits_footprint(fits_path): """ Process a FITS file to extract WCS information and calculate the footprint. Parameters: fits_path (str): Path to the FITS file. Returns: tuple: A tuple containing the WCS footprint coordinates. """ with fits.open(fits_path) as hdul: hdul[1].data = hdul[1].data[0, 0] wcs = WCS(hdul[1].header) shape = sorted(tuple(wcs.pixel_shape))[:2] footprint = wcs.calc_footprint(axes=shape) coords = list(footprint.flatten()) return coords def calculate_pixel_scale(header): """ Calculate the pixel scale in arcseconds per pixel from a FITS header. Parameters: header (astropy.io.fits.header.Header): The FITS header containing WCS information. Returns: Mean of the pixel scales in x and y. """ # Calculate the pixel scales in arcseconds per pixel pixscale_x = header.get("CDELT1", np.nan) pixscale_y = header.get("CDELT2", np.nan) return np.mean([pixscale_x, pixscale_y]) def make_split_jsonl_files( config_type="tiny", data_dir="./data", outdir="./splits", seed=42 ): """ Create jsonl files for the SBI-16-3D 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="...") with fits.open(file, memmap=False) as hdul: image_id = os.path.basename(file).split(".fits")[0] ra = hdul["SCI"].header.get("CRVAL1", 0) dec = hdul["SCI"].header.get("CRVAL2", 0) pixscale = calculate_pixel_scale(hdul["SCI"].header) footprint = get_fits_footprint(file) # get the number of groups per int ntimes = hdul["SCI"].data.shape[1] item = { "image_id": image_id, "image": file, "ra": ra, "dec": dec, "pixscale": pixscale, "ntimes": ntimes, "footprint": footprint, } 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")