Merge branch 'main' of https://huggingface.co/datasets/AstroCompress/SBI-16-3D into main

README.md

@@ -14,7 +14,7 @@ dataset_info:
         shape:
         - 2048
         - 2048
-        dtype: uint16
+        dtype: uint8
   - name: ra
     dtype: float64
   - name: dec
@@ -69,8 +69,16 @@ Then in your python script:
 
 ```python
 from datasets import load_dataset
+import numpy
 dataset = load_dataset("AstroCompress/SBI-16-3D", "tiny")
-ds = dataset.with_format("np")
+ds = dataset.with_format("np", columns=["image"], dtype=numpy.uint8)
+
+# or torch
+import torch
+dst = dataset.with_format("torch", columns=["image"], dtype=torch.uint8)
+
+# or pandas
+dsp = dataset.with_format("pandas", columns=["image"], dtype=numpy.uint8)
 ```
 
 ## Local Use

SBI-16-3D.py

@@ -13,9 +13,9 @@ 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). """
-  """<TODO>Describe data format</TODO>"""
+    """SBI-16-3D is a dataset which is part of the AstroCompress project. """
+    """It contains data assembled from the James Webb Space Telescope (JWST). """
+    """<TODO>Describe data format</TODO>"""
 )
 
 _HOMEPAGE = "https://google.github.io/AstroCompress"
@@ -32,15 +32,16 @@ _URLS = {
     "full": {
         "train": "./splits/full_train.jsonl",
         "test": "./splits/full_test.jsonl",
-    }
+    },
 }
 
 _REPO_ID = "AstroCompress/SBI-16-3D"
 
-class SBI_16_4D(datasets.GeneratorBasedBuilder):
-    """SBI-16-4D Dataset"""
 
-    VERSION = datasets.Version("1.0.1")
+class SBI_16_3D(datasets.GeneratorBasedBuilder):
+    """SBI-16-3D Dataset"""
+
+    VERSION = datasets.Version("1.0.2")
 
     BUILDER_CONFIGS = [
         datasets.BuilderConfig(
@@ -83,39 +84,65 @@ class SBI_16_4D(datasets.GeneratorBasedBuilder):
 
         ret = []
         base_path = dl_manager._base_path
-        locally_run = not base_path.startswith(datasets.config.HF_ENDPOINT) 
+        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_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")
+                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"]})
+                    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]
+                    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]
+                    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},
+                    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
@@ -128,5 +155,105 @@ class SBI_16_4D(datasets.GeneratorBasedBuilder):
             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}
+                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")