lightstack 0.1.5__tar.gz → 0.2.0__tar.gz

{lightstack-0.1.5/src/lightstack.egg-info → lightstack-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightstack
-Version: 0.1.5
+Version: 0.2.0
 Summary: Tools for building and processing multi-filter astrophysical datacubes
 Author: Andressa Wille, Thallis Pessi
 License: MIT License
@@ -41,7 +41,7 @@ Requires-Dist: photutils
 
 # Lightstack
 
-Tools for building and processing multi-filter astrophysical datacubes.
+Tools for building and processing multi-filter astrophysical datacubes. 
 
 ## Features
 
@@ -49,8 +49,6 @@ Tools for building and processing multi-filter astrophysical datacubes.
 - Building photometric datacubes  
 - PSF matching  
 
-(Currently supports JWST and HST)
-
 ## Installation
 
 ```bash
@@ -61,4 +59,4 @@ pip install lightstack
 
 https://lightstack.readthedocs.io/en/latest/
 
-See the tutorial notebook!
+See the tutorial notebook (in the "examples" folder)! 

{lightstack-0.1.5 → lightstack-0.2.0}/README.md

@@ -4,7 +4,7 @@
 
 # Lightstack
 
-Tools for building and processing multi-filter astrophysical datacubes.
+Tools for building and processing multi-filter astrophysical datacubes. 
 
 ## Features
 
@@ -12,8 +12,6 @@ Tools for building and processing multi-filter astrophysical datacubes.
 - Building photometric datacubes  
 - PSF matching  
 
-(Currently supports JWST and HST)
-
 ## Installation
 
 ```bash
@@ -24,4 +22,4 @@ pip install lightstack
 
 https://lightstack.readthedocs.io/en/latest/
 
-See the tutorial notebook!
+See the tutorial notebook (in the "examples" folder)! 

{lightstack-0.1.5 → lightstack-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lightstack"
-version = "0.1.5"
+version = "0.2.0"
 description = "Tools for building and processing multi-filter astrophysical datacubes"
 readme = "README.md"
 authors = [{name = "Andressa Wille"}, {name="Thallis Pessi"}]

{lightstack-0.1.5 → lightstack-0.2.0}/src/lightstack/datacube.py

@@ -1,42 +1,58 @@
 import numpy as np
 import os
+import glob
 
 from astropy.io import fits
 from astropy.wcs import WCS
 
 from reproject import reproject_interp, reproject_exact
 
-from .utils import find_ext, infer_filter, get_pixel_scale_from_wcs
+from .utils import find_ext, get_filter, get_pixel_scale_from_wcs
+
+
+def load_image_fits(folder_path):
+
+    fits_files = []
+
+    for f in glob.glob(os.path.join(folder_path, "*.fits")):
+        try:
+            if fits.getval(f, "NAXIS") != 2:
+                continue
+            fits_files.append(f)
+        except Exception:
+            continue
+
+    return fits_files
 
 
 def align_reproject_fits(fits_list, ref_file, method="interp", crop=1):
     """
-    Aligns and reprojects FITS images to a common WCS using a reference FITS file.
+    Align and optionally reproject FITS images to a common WCS.
+    If an image already matches the reference WCS, shape and pixel scale, reprojection is skipped automatically.
+    Area correction is only applied when input and output pixel scales differ.
 
     Parameters
     ----------
     fits_list : list of tuples
-        List in the form [(fits_path, filter_name), ...].
+        [(fits_path, filter_name), ...]
 
     ref_file : str
-        Path to the FITS file used as WCS reference.
+        Reference FITS file.
 
     method : str, optional
         Reprojection method:
-        - "interp" (default): faster, interpolates values
-        - "exact": slower   --> but reproject_exact has precision issues with resolutions below ~0.05 arcsec, so the results may not be accurate.
+        - "interp" (default)
+        - "exact"
 
     crop : int, optional
-        Number of pixels to remove from each border after reprojection
-        (helps remove edge artifacts from interpolation).
+        Pixels to crop from borders after reprojection.
 
     Returns
     -------
     aligned_list : list of tuples
-        List in the form [(aligned_fits_path, filter_name), ...].
+        [(aligned_fits_path, filter_name), ...]
     """
 
-
     # Choose reprojection method
     if method == "exact":
         reproj_func = reproject_exact
@@ -49,18 +65,23 @@ def align_reproject_fits(fits_list, ref_file, method="interp", crop=1):
     with fits.open(ref_file) as hdul_ref:
         ext_ref = find_ext(hdul_ref)
         if ext_ref is None:
-            raise ValueError(f"No valid image data in reference file '{ref_file}'.")
+            raise ValueError(
+                f"No valid image data in reference file '{ref_file}'."
+            )
 
         ref_header = hdul_ref[ext_ref].header
         ref_wcs = WCS(ref_header)
         shape_out = hdul_ref[ext_ref].data.shape
 
-    # Pixel scale of reference
     scale_out = get_pixel_scale_from_wcs(ref_wcs)
-
     aligned_list = []
 
-    # Loop over all FITS
+    # Reference filter name
+    ref_filter_name = next(
+        filt for f, filt in fits_list if f == ref_file
+    )
+
+    # Loop through files
     for fpath, filt in fits_list:
 
         with fits.open(fpath) as hdul:
@@ -73,59 +94,99 @@ def align_reproject_fits(fits_list, ref_file, method="interp", crop=1):
             header = hdul[ext].header
             wcs_in = WCS(header)
 
-            unit = header.get('BUNIT', 'unknown')
-            print(f"Filter {filt}: unit = {unit}")
+            unit = header.get("BUNIT", "unknown")
+            print(f"\nFilter {filt}: unit = {unit}")
 
-            # Pixel scale of input
             scale_in = get_pixel_scale_from_wcs(wcs_in)
+            print(f"Pixel scale in/out: {scale_in:.4f} -> {scale_out:.4f}")
 
-            # Reproject
-            data_aligned, footprint = reproj_func(
-                (data, wcs_in),
-                ref_wcs,
-                shape_out=shape_out)
+            # Check whether reprojection is really needed
+            same_scale = np.isclose(scale_in, scale_out, rtol=1e-6)
+            same_shape = data.shape == shape_out
+            same_wcs = (
+                wcs_in.to_header_string()
+                == ref_wcs.to_header_string()
+            )
 
-            # Area correction
-            area_ratio = (scale_out / scale_in)**2
-            data_aligned *= area_ratio
+            if same_scale and same_shape and same_wcs:
+                print("Already aligned with reference: skipping reprojection.")
 
-            print(f"Pixel scale in/out: {scale_in:.4f} -> {scale_out:.4f}")
-            print(f"Applied area correction: {area_ratio:.4f}")
+                data_aligned = data.copy()
+                wcs_out = wcs_in.deepcopy()
+                reprojected = False
+                area_corrected = False
 
-            # Crop border
-            if crop > 0:
-                data_aligned = data_aligned[crop:-crop, crop:-crop]
+            else:
+                data_aligned, footprint = reproj_func(
+                    (data, wcs_in),
+                    ref_wcs,
+                    shape_out=shape_out
+                )
 
-                # Adjust WCS
                 wcs_out = ref_wcs.deepcopy()
+                reprojected = True
+
+                # Area correction only if pixel scales differ
+                if not same_scale:
+                    area_ratio = (scale_out / scale_in) ** 2
+                    data_aligned *= area_ratio
+                    print(f"Applied area correction: {area_ratio:.4f}")
+                    area_corrected = True
+                else:
+                    print("Pixel scales identical: no area correction applied.")
+                    area_corrected = False
+
+            # Crop borders
+            if crop > 0:
+                data_aligned = data_aligned[crop:-crop, crop:-crop]
                 wcs_out.wcs.crpix -= crop
-            else:
-                wcs_out = ref_wcs
 
-            # Header
+            # Build output header
             header_aligned = wcs_out.to_header()
-            header_aligned['BUNIT'] = unit
+            header_aligned["BUNIT"] = unit
 
-            ref_filter = infer_filter(ref_file)
-            header_aligned.add_history(
-                f"Reprojected to {ref_filter} using {method} method (reproject package)")
-            header_aligned.add_history(
-                "Flux corrected by pixel area ratio")
+            if reprojected:
+                header_aligned.add_history(
+                    f"Reprojected to {ref_filter_name} using "
+                    f"{method} method (reproject package)"
+                )
+            else:
+                header_aligned.add_history(
+                    f"No reprojection needed "
+                    f"(already aligned to {ref_filter_name})"
+                )
+
+            if area_corrected:
+                header_aligned.add_history(
+                    "Flux corrected by pixel area ratio"
+                )
+            else:
+                header_aligned.add_history(
+                    "No area correction applied"
+                )
 
             if crop > 0:
-                header_aligned.add_history(f"Cropped {crop} pixels from each border")
+                header_aligned.add_history(
+                    f"Cropped {crop} pixels from each border"
+                )
 
-            # Save
+            # Save output
             suffix = f"_aligned_{method}"
             out_name = os.path.splitext(fpath)[0] + f"{suffix}.fits"
 
-            fits.PrimaryHDU(data_aligned, header=header_aligned).writeto(
-                out_name, overwrite=True)
+            fits.PrimaryHDU(
+                data_aligned,
+                header=header_aligned
+            ).writeto(out_name, overwrite=True)
 
-            # Flux sanity check
+            # Flux sanity check (only if reprojection happened and input not empty)
             sum_in = np.nansum(data)
             sum_out = np.nansum(data_aligned)
-            print(f"Flux ratio (out/in): {sum_out/sum_in:.4f}")
+
+            if reprojected and sum_in != 0:
+                print(f"Flux ratio (out/in): {sum_out / sum_in:.4f}")
+            elif sum_in == 0:
+                print("Input image is empty: skipping flux ratio check.")
 
             aligned_list.append((out_name, filt))
             print(f"Saved: {out_name}")
@@ -133,31 +194,39 @@ def align_reproject_fits(fits_list, ref_file, method="interp", crop=1):
     return aligned_list
 
     
-    
 def build_datacube(aligned_fits_files, reference_file, output_path):
     """
-    Builds a 3D datacube from aligned 2D FITS images.
+    Build a 3D datacube from aligned 2D FITS images.
 
     Parameters
     ----------
     aligned_fits_files : list of tuples
-        [(filename, filter_name), ...]
+        List in format [(filename, filter_name), ...].
+
     reference_file : str
-        FITS file to define WCS and shape.
+        FITS file used to define WCS and output shape.
+
     output_path : str
-        Path to save the 3D datacube.
-        
+        Path to save the output datacube.
+
     Returns
     -------
     None
-        Saves the cut datacube.
+        Saves the datacube to disk.
     """
-    
-    # Open FITS
+
+    # Safety check
+    if len(aligned_fits_files) == 0:
+        raise ValueError("No aligned FITS files provided.")
+
+    # Reference WCS
     with fits.open(reference_file) as hdul_ref:
         ext_ref = find_ext(hdul_ref)
         if ext_ref is None:
-            raise ValueError(f"No 2D data in reference file {reference_file}.")
+            raise ValueError(
+                f"No valid 2D data in reference file {reference_file}."
+            )
+
         ref_header = hdul_ref[ext_ref].header
         ny, nx = hdul_ref[ext_ref].data.shape
         wcs_2d = WCS(ref_header, naxis=2)
@@ -166,51 +235,71 @@ def build_datacube(aligned_fits_files, reference_file, output_path):
     filter_names = []
     units = []
 
-    # Construct cube
+    # Read aligned images
     for file, filt in aligned_fits_files:
+
         with fits.open(file) as hdul:
             ext = find_ext(hdul)
+
             if ext is None:
-                print(f"No 2D data in {file}. Skipping.")
+                print(f"No valid 2D data in {file}. Skipping.")
                 continue
+
             data = hdul[ext].data
+
             cube_images.append(data)
             filter_names.append(filt)
-            units.append(hdul[ext].header.get('BUNIT', 'unknown'))
+            units.append(
+                hdul[ext].header.get("BUNIT", "unknown")
+            )
+
+    # Safety check after filtering invalid files
+    if len(cube_images) == 0:
+        raise ValueError("No valid 2D FITS images found.")
 
     cube = np.array(cube_images)
 
-    # Write header
+    # Build 3D WCS
     wcs_3d = WCS(naxis=3)
+
+    # Spatial axes
     wcs_3d.wcs.crpix[0] = wcs_2d.wcs.crpix[0]
     wcs_3d.wcs.crpix[1] = wcs_2d.wcs.crpix[1]
+
     wcs_3d.wcs.crval[0] = wcs_2d.wcs.crval[0]
     wcs_3d.wcs.crval[1] = wcs_2d.wcs.crval[1]
+
     wcs_3d.wcs.cdelt[0] = wcs_2d.wcs.cdelt[0]
     wcs_3d.wcs.cdelt[1] = wcs_2d.wcs.cdelt[1]
+
     wcs_3d.wcs.ctype[0] = wcs_2d.wcs.ctype[0]
     wcs_3d.wcs.ctype[1] = wcs_2d.wcs.ctype[1]
+
     wcs_3d.wcs.cunit[0] = wcs_2d.wcs.cunit[0]
     wcs_3d.wcs.cunit[1] = wcs_2d.wcs.cunit[1]
 
+    # Preserve CD matrix if present
     if wcs_2d.wcs.has_cd():
-        cd3 = np.zeros((3,3))
-        cd3[0:2,0:2] = wcs_2d.wcs.cd.copy()
-        cd3[2,2] = 1.0
+        cd3 = np.zeros((3, 3))
+        cd3[0:2, 0:2] = wcs_2d.wcs.cd.copy()
+        cd3[2, 2] = 1.0
         wcs_3d.wcs.cd = cd3
 
+    # Filter axis
     wcs_3d.wcs.crpix[2] = 1
     wcs_3d.wcs.crval[2] = 0
     wcs_3d.wcs.cdelt[2] = 1
-    wcs_3d.wcs.ctype[2] = 'FILTER'
-    wcs_3d.wcs.cunit[2] = ''
+    wcs_3d.wcs.ctype[2] = "FILTER"
+    wcs_3d.wcs.cunit[2] = ""
 
     header = wcs_3d.to_header()
-    header['NAXIS'] = 3
-    header['NAXIS1'] = nx
-    header['NAXIS2'] = ny
-    header['NAXIS3'] = len(filter_names)
-    
+
+    header["NAXIS"] = 3
+    header["NAXIS1"] = nx
+    header["NAXIS2"] = ny
+    header["NAXIS3"] = len(filter_names)
+
+    # Copy HISTORY from first valid file
     with fits.open(aligned_fits_files[0][0]) as hdul0:
         ext0 = find_ext(hdul0)
         header_meta = hdul0[ext0].header
@@ -219,20 +308,26 @@ def build_datacube(aligned_fits_files, reference_file, output_path):
         for h in header_meta["HISTORY"]:
             header.add_history(h)
 
+    # Units
     if all(u == units[0] for u in units):
-        header['BUNIT'] = units[0]
+        header["BUNIT"] = units[0]
     else:
-        header['BUNIT'] = 'unknown'
+        header["BUNIT"] = "unknown"
 
+    # Filter metadata
     for i, filt in enumerate(filter_names):
-        header[f'FILTER{i+1}'] = filt
-        
-    header['NFILTERS'] = len(filter_names)
-    header['FILTERS'] = ",".join(filter_names)
+        header[f"FILTER{i+1}"] = filt
+
+    header["NFILTERS"] = len(filter_names)
+    header["FILTERS"] = ",".join(filter_names)
 
-    # Save datacube
-    fits.PrimaryHDU(cube, header=header).writeto(output_path, overwrite=True)
-    print(f"Datacube saved at {output_path}.")
+    # Save cube
+    fits.PrimaryHDU(
+        cube,
+        header=header
+    ).writeto(output_path, overwrite=True)
+
+    print(f"Datacube saved at {output_path}")
 
 
 def cut_region_datacube(cube_fits_file, x_start, x_end, y_start, y_end, output_path):
@@ -247,7 +342,7 @@ def cut_region_datacube(cube_fits_file, x_start, x_end, y_start, y_end, output_p
         Pixel indices for the x axis.
     y_start, y_end : int
         Pixel indices for the y axis.
-    output_filename : str
+    output_path : str
         Path to the output fits file.
 
     Returns
@@ -255,45 +350,43 @@ def cut_region_datacube(cube_fits_file, x_start, x_end, y_start, y_end, output_p
     None
         Saves the cut datacube.
     """
-    # Open datacube
+    
     with fits.open(cube_fits_file) as hdul:
         ext = find_ext(hdul)
         if ext is None:
             raise ValueError(f"No image data found in {cube_fits_file}")
 
         cube_data = hdul[ext].data
-        cube_header = hdul[ext].header
+        cube_header = hdul[ext].header.copy() 
 
-        # Cut the data array
+        # Cut data
         cut_data = cube_data[:, y_start:y_end, x_start:x_end]
 
-        # Get and update WCS
+        # Update WCS
         wcs_3d = WCS(cube_header)
         wcs_3d.wcs.crpix[0] -= x_start
         wcs_3d.wcs.crpix[1] -= y_start
 
-        # Create new header with updated size and WCS
-        new_header = wcs_3d.to_header()
-        new_header['NAXIS'] = 3
+        # New header
+        new_header = cube_header.copy()
+        new_header.update(wcs_3d.to_header())
+
         new_header['NAXIS1'] = x_end - x_start
         new_header['NAXIS2'] = y_end - y_start
         new_header['NAXIS3'] = cube_data.shape[0]
 
-        # Filter info
-        for key in cube_header:
-            if key.startswith('FILTER'):
-                new_header[key] = cube_header[key]
-
-        # Crop window
+        # Crop window 
         new_header['XMINPIX'] = x_start
         new_header['XMAXPIX'] = x_end
         new_header['YMINPIX'] = y_start
         new_header['YMAXPIX'] = y_end
 
-        # Save cut datacube
+        # Save
         fits.PrimaryHDU(cut_data, header=new_header).writeto(output_path, overwrite=True)
+
         print(f"Cut datacube saved to '{output_path}'")
-        
+
+
 def build_valid_datacube(cube_fits_file, output_cube, threshold=0.0, frac_valid=0.01):
     """
     Remove empty filters in a datacube, saves the new datacube and returns the valid filter names.
@@ -336,33 +429,62 @@ def build_valid_datacube(cube_fits_file, output_cube, threshold=0.0, frac_valid=
     for i, img in enumerate(cube):
         valid = np.isfinite(img)
         n_total = valid.sum()
+    
         if n_total == 0:
             continue
+    
         n_above = np.sum(img[valid] > threshold)
+    
         if (n_above / n_total) >= frac_valid:
             valid_indices.append(i)
-
+    
+    # Stop if all filters are invalid
+    if len(valid_indices) == 0:
+        raise ValueError(
+            f"No valid filters found in {cube_fits_file}. "
+            "Try lowering threshold or frac_valid."
+        )
+    
+    # Report removed filters
+    removed_filters = [
+        filters[i] for i in range(n_filters)
+        if i not in valid_indices
+    ]
+    
+    if removed_filters:
+        print(f"Removed empty/invalid filters: {removed_filters}")
+    
+    # Build filtered cube + valid filter names
     cube_filtered = cube[valid_indices]
     filters_valid = [filters[i] for i in valid_indices]
-    
+
     # Write new header
     new_header = header.copy()
     new_header["NAXIS3"] = len(filters_valid)
-    new_header['NFILTERS'] = len(filters_valid)
-    new_header['FILTERS'] = ",".join(filters_valid)
+    new_header["NFILTERS"] = len(filters_valid)
+    new_header["FILTERS"] = ",".join(filters_valid)
 
     for i, f in enumerate(filters_valid):
         new_header[f"FILTER{i+1}"] = f
 
+    # Remove obsolete FILTER keywords
     for i in range(len(filters_valid), n_filters):
         key = f"FILTER{i+1}"
         if key in new_header:
             del new_header[key]
 
-    # Save filtered datacube 
+    # Add history entry
+    new_header.add_history(
+        f"Removed invalid filters "
+        f"(threshold={threshold}, frac_valid={frac_valid})"
+    )
+
+    # Save filtered datacube
     hdu = fits.PrimaryHDU(cube_filtered, header=new_header)
     hdu.writeto(output_cube, overwrite=True)
+
     print(f"Filtered datacube saved at '{output_cube}'")
+    print(f"Valid filters: {filters_valid}")
 
     return cube_filtered, filters_valid
 
@@ -378,7 +500,7 @@ def remove_filter(cube_fits_file, output_cube, filter_to_remove):
     output_cube : str
         Path to save the new datacube.
     filter_to_remove : str
-        Name of the filter to be removed (e.g., ‘F115W’).
+        Name of the filter to be removed.
     """
 
     # Open FITS
@@ -393,13 +515,20 @@ def remove_filter(cube_fits_file, output_cube, filter_to_remove):
         n_filters = header.get("NAXIS3", cube.shape[0])
         filters = [header[f"FILTER{i+1}"].strip() for i in range(n_filters)]
 
-    # Keep filters
-    keep_indices = [i for i, f in enumerate(filters) if f != filter_to_remove]
+    # Keep filters except selected one
+    keep_indices = [i for i, f in enumerate(filters)
+                    if f != filter_to_remove]
 
     if len(keep_indices) == len(filters):
-        print(f"This filter '{filter_to_remove}' is not in the datacube.")
-    else:
-        print(f"Removing filter: {filter_to_remove}")
+        print(f"Filter '{filter_to_remove}' not found in datacube.")
+        return cube, filters
+
+    if len(keep_indices) == 0:
+        raise ValueError(
+            "Cannot remove all filters. Datacube would be empty."
+        )
+
+    print(f"Removing filter: {filter_to_remove}")
 
     # New cube
     cube_new = cube[keep_indices]
@@ -408,23 +537,33 @@ def remove_filter(cube_fits_file, output_cube, filter_to_remove):
     # Write new header
     new_header = header.copy()
     new_header["NAXIS3"] = len(filters_new)
-    new_header['NFILTERS'] = len(filters_new)
-    new_header['FILTERS'] = ",".join(filters_new)
+    new_header["NFILTERS"] = len(filters_new)
+    new_header["FILTERS"] = ",".join(filters_new)
 
     for i, f in enumerate(filters_new):
         new_header[f"FILTER{i+1}"] = f
 
+    # Remove old FILTER keywords
     for i in range(len(filters_new), n_filters):
         key = f"FILTER{i+1}"
         if key in new_header:
             del new_header[key]
 
+    # Add history
+    new_header.add_history(
+        f"Removed filter {filter_to_remove}"
+    )
+
     # Save
-    hdu = fits.PrimaryHDU(cube_new, header=new_header)
-    hdu.writeto(output_cube, overwrite=True)
-    print(f"New datacube without '{filter_to_remove}' saved at {output_cube}")
-    
+    fits.PrimaryHDU(cube_new, header=new_header).writeto(
+        output_cube,
+        overwrite=True
+    )
+
+    print(f"New datacube saved at {output_cube}")
+
     return cube_new, filters_new
+
     
 def update_cube_header(
     cube_fits_file,
@@ -514,3 +653,4 @@ def update_cube_header(
         hdul.writeto(output_file, overwrite=overwrite)
 
     print(f"Updated header saved to: {output_file}")
+