hyper-py-photometry 0.1.0__py3-none-any.whl

hyper_py/hyper.py

@@ -0,0 +1,150 @@
+import os
+import sys
+from pathlib import Path
+import multiprocessing
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+import numpy as np
+from astropy.io import ascii, fits
+from astropy.table import vstack
+from astropy.wcs import WCS
+
+from hyper_py.single_map import main as single_map
+from hyper_py.config import HyperConfig
+from hyper_py.logger import setup_logger
+from hyper_py.create_background_slices import create_background_cubes
+from .extract_cubes import extract_maps_from_cube
+
+# Set multiprocessing start method
+multiprocessing.set_start_method("spawn", force=True)
+
+def start_hyper(cfg_path):
+    # === Load config ===
+    os.chdir(os.path.dirname(__file__))
+
+    config_path = cfg_path if not None else "config.yaml"
+    
+    if not os.path.exists(config_path):
+        raise FileNotFoundError(f"Config file not found: {config_path}")
+
+    cfg = HyperConfig(config_path)
+
+    # --- Initialize paths --- #
+    # - common - #
+    paths = cfg.get("paths")
+    dir_root = paths["output"]["dir_root"]
+    
+    # # - input - #
+    dir_maps = paths["input"]["dir_maps"]
+    dir_slices_out = Path(dir_root, cfg.get("control")["dir_datacube_slices"])
+    base_table_name = cfg.get("files", "file_table_base")
+    map_names = cfg.get("files", "file_map_name")
+    datacube = cfg.get("control", "datacube", False)
+    fix_min_box = cfg.get("background", "fix_min_box", 3)     # minimum padding value (multiple of FWHM)
+    convert_mjy=cfg.get("units", "convert_mJy")
+    
+    # If it's a path to a .txt file, read it #
+    if isinstance(map_names, str) and map_names.endswith('.txt'):
+        map_list_path = os.path.join(dir_maps, map_names)
+        with open(map_list_path, 'r') as f:
+            map_names = [line.strip() for line in f if line.strip()]
+    # If it's a single string but not a .txt, wrap it in a list
+    elif isinstance(map_names, str):
+        map_names = [map_names]
+        
+    if datacube:
+        map_names, cube_header = extract_maps_from_cube(map_names, dir_slices_out, dir_maps)
+        background_slices = []
+        slice_cutout_header = []
+    
+    # - output - #
+    output_dir = paths["output"]["dir_table_out"]
+    
+    # --- Set up logging for warnings --- #
+    dir_log = paths["output"]["dir_log_out"]
+    file_log = cfg.get("files", "file_log_name")
+    log_path = os.path.join(dir_root, dir_log, file_log)
+    
+    # Ensure the log directory exists
+    log_path_dir = os.path.join(dir_root, dir_log)
+    os.makedirs(log_path_dir, exist_ok=True)
+
+    logger, logger_file_only = setup_logger(log_path, logger_name="HyperLogger", overwrite=True)
+    
+    logger.info("******************* 🔥 Hyper starts !!! *******************")
+    
+    # --- Parallel control ---
+    control_cfg = cfg.get("control", {})
+    use_parallel = control_cfg.get("parallel_maps", False)
+    n_cores = control_cfg.get("n_cores", os.cpu_count())
+
+    # --- Main parallel or serial execution ---
+    logger.info(f"🔄 Starting map analysis using {'multiprocessing' if use_parallel else 'serial'} mode")
+    
+    results = []
+
+    if use_parallel:
+        logger.info(f"📡 Running HYPER on {len(map_names)} maps using {n_cores} cores...")
+        with ProcessPoolExecutor(max_workers=n_cores) as executor:
+            futures = {
+                executor.submit(single_map, name, cfg, dir_root): name
+                for name in map_names
+            }
+            for future in as_completed(futures):
+                map_name = futures[future]
+                try:
+                    suffix, bg_model, cutout_header, initial_header = future.result()
+                    results.append(suffix)
+                    if datacube:
+                        background_slices.append(bg_model)
+                        slice_cutout_header.append(cutout_header)
+                    
+                    logger.info(f"✅ Finished processing {map_name}")
+                except Exception as e:
+                    logger.error(f"❌ Error processing {map_name}: {e}")
+    else:
+        for map_name in map_names:
+            logger.info(f"📡 Running HYPER on: {map_name}")
+            suffix, bg_model, cutout_header, initial_header = single_map(map_name, cfg, dir_root, logger, logger_file_only)
+            results.append(suffix)
+            if datacube:
+                background_slices.append(bg_model)
+                slice_cutout_header.append(cutout_header)
+                
+                            
+    # --- Collect all output tables --- #
+    all_tables = []
+    for suffix in results:
+        try:
+            suffix_clean = Path(suffix).stem  # remove ".fits"
+            output_table_path = os.path.join(dir_root, output_dir, f"{base_table_name}_{suffix_clean}.txt")
+            table = ascii.read(output_table_path, format="ipac")
+            all_tables.append(table)
+        except Exception as e:
+            logger_file_only.error(f"[ERROR] Failed to load table for {suffix}: {e}")
+    
+
+    # === Merge and write combined tables ===
+    final_table = vstack(all_tables)
+    
+    # Keep only the comments (headers) from the first table
+    if hasattr(all_tables[0], 'meta') and 'comments' in all_tables[0].meta:
+        final_table.meta['comments'] = all_tables[0].meta['comments']
+    else:
+        final_table.meta['comments'] = []
+    
+    # Output file paths
+    ipac_path = os.path.join(dir_root, output_dir, f"{base_table_name}_ALL.txt")
+    csv_path = os.path.join(dir_root, output_dir, f"{base_table_name}_ALL.csv")
+    
+    # Write outputs
+    final_table.write(ipac_path, format='ipac', overwrite=True)
+    final_table.write(csv_path, format='csv', overwrite=True)
+    logger_file_only.info(f"\n✅ Final merged table saved to:\n- {ipac_path}\n- {csv_path}")
+    
+    # === Combine all bg_models into a datacube ===
+    if datacube:
+        create_background_cubes(background_slices, slice_cutout_header, cube_header, dir_slices_out, fix_min_box, convert_mjy, logger)
+
+    
+    logger.info("****************** ✅ Hyper finished !!! ******************")

hyper_py/logger.py

@@ -0,0 +1,73 @@
+import logging
+import warnings
+import sys
+from astropy.wcs import FITSFixedWarning
+from astropy.utils.exceptions import AstropyUserWarning
+
+class StreamToLogger:
+    def __init__(self, logger, level=logging.WARNING):
+        self.logger = logger
+        self.level = level
+    def write(self, buf):
+        for line in buf.rstrip().splitlines():
+            self.logger.log(self.level, line.rstrip())
+    def flush(self):
+        pass
+
+class ProcessNameFilter(logging.Filter):
+    def __init__(self, process_name):
+        super().__init__()
+        self.process_name = process_name
+
+    def filter(self, record):
+        record.process_name = self.process_name
+        return True
+
+def setup_logger(log_path="hyper.log", logger_name="HyperLogger", overwrite=True, process_name = ""):
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    # File handler
+    mode = "w" if overwrite else "a"
+    file_handler = logging.FileHandler(log_path, mode=mode, encoding='utf-8')
+    file_handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
+    logger.addHandler(file_handler)
+    
+    # Console handler (only INFO)
+    console_handler = logging.StreamHandler(sys.stdout)
+    logger.addFilter(lambda record: setattr(record, "process_name_suffix", f" ({process_name})" if process_name else "") or True)
+    console_handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s%(process_name_suffix)s'))
+    logger.addFilter(ProcessNameFilter(process_name))
+    logger.addHandler(console_handler)
+    logger.setLevel(logging.INFO)
+        
+    # File-only logger for warnings
+    logger_file_only = logging.getLogger(f"{logger_name}FileOnly")
+    logger_file_only.setLevel(logging.INFO)
+    logger_file_only.propagate = False
+
+    if logger_file_only.hasHandlers():
+        logger_file_only.handlers.clear()
+        
+    logger_file_only.addHandler(file_handler)
+
+    # Redirect warnings
+    sys.stderr = StreamToLogger(logger_file_only, level=logging.WARNING)
+    sys.__stderr__ = StreamToLogger(logger_file_only, level=logging.WARNING)
+
+    def custom_showwarning(message, category, filename, lineno, file=None, line=None):
+        logger_file_only.warning(f"{category.__name__}: {message} (from {filename}:{lineno})")
+
+    warnings.showwarning = custom_showwarning
+    warnings.simplefilter("always")
+    warnings.filterwarnings("always", category=FITSFixedWarning)
+    warnings.filterwarnings("always", category=AstropyUserWarning)
+    warnings.filterwarnings("always", category=ResourceWarning)
+    warnings.filterwarnings("ignore", category=FITSFixedWarning, module="astropy")
+    warnings.filterwarnings("ignore", category=UserWarning, module="uncertainties")
+    
+    return logger, logger_file_only

hyper_py/map_io.py

@@ -0,0 +1,73 @@
+from astropy.io import fits
+from astropy.wcs import WCS
+import numpy as np
+
+
+def read_and_prepare_map(filepath, beam, beam_area_arcsec2, beam_area_sr, convert_mjy=False):
+    '''
+    Load a FITS map and convert units as needed. 
+    Always reduce WCS to 2D (RA, Dec) if higher dimensional axes are present.
+
+    Parameters:
+        filepath (str): Path to the FITS file.
+        beam (float): Beam size in arcsec (FWHM).
+        beam_area_arcsec2 (float): Beam area in arcsec^2.
+        convert_jy_sr (bool): If True, convert from MJy/sr to Jy/pixel.
+        convert_beam_jy (bool): If True, convert from Jy/beam to Jy/pixel.
+        convert_mjy (bool): If True, convert Jy to mJy/pixel.
+
+    Returns:
+        dict: {
+            'map': 2D image array,
+            'header': cleaned FITS header,
+            'pix_dim': pixel size in arcsec,
+            'beam_dim': beam (arcsec),
+            'band': extracted from header or placeholder
+        }
+    '''
+    with fits.open(filepath) as hdul:
+        image_data = hdul[0].data
+        header = hdul[0].header
+
+    # --- Auto-squeeze down to 2D image ---
+    while image_data.ndim > 2:
+        image_data = image_data[0]
+
+
+    # --- Get pixel scale from header ---
+    pix_dim = abs(header.get('CDELT1', header.get('CD1_1', 1))) * 3600.0  # arcsec
+    if pix_dim <= 0:
+        raise ValueError("Invalid pixel scale in FITS header.")
+        
+
+    # --- Strip header down to 2D WCS only ---
+    try:
+        wcs_full = WCS(header)
+        wcs_2d = wcs_full.celestial  # Only RA/DEC axes
+        header = wcs_2d.to_header()
+    except Exception as e:
+        print(f"[WARNING] Could not clean WCS header: {e}")
+
+
+    # --- Unit conversions ---
+    bunit = header.get('BUNIT')
+    if bunit == 'MJy /sr':
+        arcsec_to_rad = np.pi / (180.0 * 3600.0)
+        pix_area_sr = (pix_dim * arcsec_to_rad)**2
+        image_data *= 1e6 * pix_area_sr  # MJy/sr to Jy/pixel
+        
+    if bunit == 'Jy/beam' or bunit == 'beam-1 Jy':    
+        pix_area = pix_dim**2
+        image_data /= (beam_area_arcsec2 / pix_area) # Jy/beam to Jy/pixel
+        
+    if convert_mjy:
+        image_data *= 1e3  # Jy → mJy
+ 
+    return {
+        "map": image_data,
+        "header": header,
+        "pix_dim": pix_dim,
+        "beam_dim": beam,
+        "beam_area_arcsec2": beam_area_arcsec2,
+        "beam_area_sr": beam_area_sr,
+    }

hyper_py/paths_io.py

@@ -0,0 +1,122 @@
+import os
+from pathlib import Path
+
+
+def get_hyper_paths(cfg):
+    """
+    Prepares and returns all relevant I/O paths used in a HYPER run.
+    """  
+    # - Main paths - #
+    paths = cfg.get("paths")
+    dir_root = paths["output"]["dir_root"]
+
+    # - Input - #
+    dir_maps = paths["input"]["dir_maps"]
+    file_map = 'temp'
+    input_map_path = os.path.join(dir_maps, file_map)
+
+    # - Output - #
+    suffix = Path(file_map).stem
+
+    # - Tables - #
+    dir_table_out = paths["output"]["dir_table_out"]
+    output_dir_path = os.path.join(dir_root, dir_table_out)
+    base_name_with_suffix = f"{cfg.get('files', 'file_table_base')}_{suffix}"
+
+    # - Region files - #
+    dir_region_out = paths["output"]["dir_region_out"]
+    region_base = os.path.join(dir_root, dir_region_out, f"{cfg.get('files', 'file_region_base')}_{suffix}")
+    centroids_file = region_base + "_centroids.reg"
+    ellipses_file = region_base + "_ellipses.reg"
+
+    # - Log files - #
+    dir_log = paths["output"]["dir_log_out"]
+    file_log = cfg.get("files", "file_log_name")
+    log_path = os.path.join(dir_root, dir_log, file_log)
+
+
+    return {
+        "dir_root": dir_root,
+        "input_map_path": input_map_path,
+        "suffix": suffix,
+        "output_dir_path": output_dir_path,
+        "base_table_name": cfg.get("files", "file_table_base"),
+        "base_name_with_suffix": base_name_with_suffix,
+        "region_base": region_base,
+        "centroids_file": centroids_file,
+        "ellipses_file": ellipses_file,
+        "log_path": log_path
+    }
+
+
+
+def get_hyper_single_map_paths(cfg, map_name):
+    """
+    Prepares and returns all relevant I/O paths used in a HYPER run.
+    """  
+    
+    if cfg is None:
+        raise ValueError("cfg must be provided")
+
+    # - Main paths - #
+    paths = cfg.get("paths")
+    
+    if paths is None:
+        raise ValueError("Missing 'paths' section in configuration.")
+    
+    dir_root = paths["output"]["dir_root"]
+    if dir_root is None:
+        raise ValueError("Missing 'dir_root' key in paths configuration.")
+
+    # - Input - #
+    dir_maps = paths["input"]["dir_maps"]
+    file_map = map_name
+    input_map_path = os.path.join(dir_maps, file_map)
+
+    # - Output - #
+    suffix = Path(file_map).stem
+
+
+    # - Tables - #
+    dir_table_out = paths["output"]["dir_table_out"]
+    output_dir_path = os.path.join(dir_root, dir_table_out)
+    # Ensure the output directory exists
+    os.makedirs(output_dir_path, exist_ok=True)
+
+
+    base_name_with_suffix = f"{cfg.get('files', 'file_table_base')}_{suffix}"
+
+
+    # - Region files - #
+    dir_region_out = paths["output"]["dir_region_out"]
+    # Ensure the output directory exists
+    output_dir_region_path = os.path.join(dir_root, dir_region_out)
+    os.makedirs(output_dir_region_path, exist_ok=True)
+
+    region_base = os.path.join(dir_root, dir_region_out, f"{cfg.get('files', 'file_region_base')}_{suffix}")
+    centroids_file = region_base + "_centroids.reg"
+    ellipses_file = region_base + "_ellipses.reg"
+
+
+    # - Log files - #
+    dir_log = paths["output"]["dir_log_out"]
+    # Ensure the output directory exists
+    output_dir_log_path = os.path.join(dir_root, dir_table_out)
+    os.makedirs(output_dir_log_path, exist_ok=True)
+    
+    file_log = cfg.get("files", "file_log_name")
+    log_path = os.path.join(dir_root, dir_log, file_log)
+
+
+    return {
+        "dir_root": dir_root,
+        "input_map_path": input_map_path,
+        "suffix": suffix,
+        "output_dir_path": output_dir_path,
+        "base_table_name": cfg.get("files", "file_table_base"),
+        "base_name_with_suffix": base_name_with_suffix,
+        "region_base": region_base,
+        "centroids_file": centroids_file,
+        "ellipses_file": ellipses_file,
+        "log_path": log_path
+    }

hyper_py/photometry.py

@@ -0,0 +1,114 @@
+
+import numpy as np
+from photutils.aperture import EllipticalAperture, aperture_photometry
+from astropy.table import Table
+
+def aperture_photometry_on_sources(image, xcen, ycen, config,
+                                   radius_val_1=None, radius_val_2=None, PA_val=None):
+    '''
+    Perform elliptical aperture photometry on given source positions.
+
+    Parameters:
+        image : 2D array
+        xcen, ycen : 1D arrays of centroid positions (in pixels)
+        config : HyperConfig instance
+        radius_val_1, radius_val_2, PA_val : arrays of ellipse parameters in pixels
+            If None, use values from config.
+
+    Returns:
+        Table with flux and uncertainty
+    '''
+
+
+    if len(radius_val_1) == 1:
+        radius_val_1 = radius_val_1 * len(xcen)
+    if len(radius_val_2) == 1:
+        radius_val_2 = radius_val_2 * len(xcen)
+    if len(PA_val) == 1:
+        PA_val = PA_val * len(xcen)
+
+    fluxes = []
+    errors = []
+
+    for i in range(len(xcen)):   
+        a = radius_val_1[i]
+        b = radius_val_2[i]
+        theta = np.deg2rad(PA_val[i] + 90.)  # rotated only for photometry (x and y axes inverted here)
+        
+        position = (xcen[i], ycen[i])
+        aperture = EllipticalAperture(position, a, b, theta=theta)
+        
+        # print(aperture)    
+        phot_table = aperture_photometry(image, aperture, method='exact')
+        flux = phot_table['aperture_sum']
+        
+        # print(phot_table)
+        
+        # --- Perform area-weighted photometry on an image within an elliptical aperture --- #
+        # flux = area_weighted_photometry(image, xcen[i], ycen[i], a, b, theta)
+         
+        
+        # Estimate noise inside aperture
+        mask = aperture.to_mask(method="exact")
+        data_cutout = mask.cutout(image)
+        if data_cutout is not None:
+            aperture_data = data_cutout * mask.data
+            noise = np.nanstd(aperture_data)
+            error = noise * np.sqrt(np.sum(mask.data**2))
+        else:
+            error = 0.0
+
+        fluxes.append(flux)
+        errors.append(error)
+
+    return Table(data={"x": xcen, "y": ycen, "flux": fluxes, "error": errors})
+
+
+
+
+# --- Function to calculate area-weighted flux inside an elliptical aperture --- #
+def area_weighted_photometry(image, xcen, ycen, a, b, theta, method="exact"):
+    """
+    Perform area-weighted photometry on an image within an elliptical aperture.
+
+    Parameters:
+        image: 2D numpy array of image data
+        xcen, ycen: coordinates of the center of the aperture
+        a, b: semi-major and semi-minor axes of the elliptical aperture
+        theta: position angle of the ellipse
+        method: method used for photometry (not used here but can be extended)
+
+    Returns:
+        total_flux: total flux inside the elliptical aperture
+    """
+    total_flux = 0
+    
+    # Get the shape of the image
+    ysize, xsize = image.shape
+
+    # Create a meshgrid for pixel coordinates (Note the order: y-axis, then x-axis)
+    y, x = np.indices((ysize, xsize))  # y -> rows, x -> columns
+
+
+    # Transform the pixel coordinates to match the elliptical aperture
+    cos_theta = np.cos(np.radians(theta))
+    sin_theta = np.sin(np.radians(theta))
+
+    # Rotate the coordinates according to the position angle
+    x_rot = (x - xcen) * cos_theta + (y - ycen) * sin_theta
+    y_rot = -(x - xcen) * sin_theta + (y - ycen) * cos_theta
+
+    # Check if each pixel lies within the elliptical aperture
+    inside_aperture = (x_rot**2 / a**2 + y_rot**2 / b**2) <= 1
+    
+
+    # Now calculate the weighted flux (sum of fluxes for each pixel inside the aperture)
+    for i in range(ysize):
+        for j in range(xsize):
+            if inside_aperture[i, j]:
+                # For pixels inside the ellipse, add their full flux
+                total_flux += image[i, j]
+                # print(image[i, j])
+    return total_flux
+    
+

hyper_py/run_hyper.py

@@ -0,0 +1,45 @@
+import sys
+import os
+import shutil
+import warnings
+import yaml
+from pathlib import Path
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Block warnings
+warnings.filterwarnings("ignore", message="Using UFloat objects with std_dev==0 may give unexpected results.")
+warnings.filterwarnings("ignore", message=".*Set OBSGEO-L to.*")
+warnings.filterwarnings("ignore", message=".*Wrapping comment lines > 78 characters.*")
+warnings.filterwarnings("ignore", message=".*more axes \(4\) than the image it is associated with \(2\).*")
+warnings.filterwarnings("ignore", message=".*Set MJD-OBS to.*")
+
+from hyper_py.hyper import start_hyper
+
+def update_dir_root(default_config, config_path, new_dir_root):
+    """Create a new config.yaml in the specified directory with updated dir_root."""
+    default_config = Path(default_config)
+    config_path = Path(config_path)      
+    cfg = yaml.safe_load(default_config.read_text(encoding="utf-8")) or {}
+    cfg['paths']['output']['dir_root'] = str(Path(new_dir_root, "output"))
+    config_path.write_text(yaml.safe_dump(cfg, sort_keys=False), encoding="utf-8")
+
+def main():
+    config_path = sys.argv[1] if len(sys.argv) > 1 else "config.yaml"
+    if not os.path.exists(config_path):
+        default_config = os.path.join(os.path.dirname(__file__), "config.yaml")
+        if not os.path.exists(default_config):
+            print("Error: default config.yaml not found.")
+            sys.exit(1)
+
+        config_path = os.path.join(os.getcwd(), "config.yaml")
+
+        update_dir_root(default_config, config_path, os.getcwd())
+        print(f"⚠️  New config.yaml created in {config_path}")
+        print("⚠️  Please edit the configuration file and set the correct parameters and paths before running again.")
+        sys.exit(0)
+
+    start_hyper(config_path)
+
+if __name__ == "__main__":
+    main()