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

hyper_py/data_output.py

@@ -0,0 +1,132 @@
+import os
+from astropy.table import Table
+
+
+def write_tables(data_dict, output_dir, config, sigma_thres, real_rms, base_filename="hyper_output"):
+
+    '''
+    Write photometry results into formatted ECSV and IPAC tables,
+    preserving numeric data types and precision.
+
+    Parameters
+    ----------
+    data_dict : dict
+        Dictionary of columns for the output table.
+    output_dir : str
+        Directory where the file will be written.
+    base_filename : str
+        Base name for the output file (without extension).
+    '''
+
+    if config.get('units', 'convert_mJy'):
+        flux_units = 'mJy'
+        flux_units_beam = 'mJy/beam'
+    else:
+        flux_units_beam = 'Jy/beam'
+        flux_units = 'Jy/beam'
+        
+    units = {
+        'MAP_ID': '', 'HYPER_ID': '', 'BAND': 'GHz',
+        'RA': 'deg', 'DEC': 'deg', 'GLON': 'deg', 'GLAT': 'deg',
+        'FLUX': flux_units, 'FLUX_ERR': flux_units,
+        'FLUX_PEAK': flux_units_beam, 
+        'RESIDUALS': flux_units,
+        'FWHM_1': 'arcsec', 'FWHM_2': 'arcsec',
+        'PA': 'deg', 'NMSE': '', 'CHI2_RED': '',
+        'POLYN': '', 'STATUS': '', 'DEBLEND': '', 'CLUSTER': '',
+    }
+
+    descriptions = {
+        'MAP_ID':    'Map identifier',
+        'HYPER_ID':  'Source identifier',
+        'FLUX_PEAK': 'Peak flux (' + flux_units_beam + ')',
+        'FLUX':      'Integrated flux density (' + flux_units + ')',
+        'FLUX_ERR':  'Flux density uncertainty (' + flux_units + ')',
+        'RESIDUALS': 'Mean background level (' + flux_units + ')',
+        'POLYN':     'Polynomial background order',
+        'NMSE':      'Normalized Mean Squared Error of fit: scale-independent metric of model-data agreement',
+        'CHI2_RED':  'Reduced chi-squared of Gaussian + background fit (valid only if residuals are Gaussian-distributed with constant variance)',
+        'BIC':       'Bayesian Information Criterion: model selection metric that penalizes overfitting; lower BIC indicates better trade-off between goodness of fit and model complexity',
+        'FWHM_1':    'First axis FWHM (arcsec)',
+        'FWHM_2':    'Second axis FWHM (arcsec)',
+        'PA':        'Position angle (deg East of North)',
+        'STATUS':    'Fit status flag: 1 = fit succeeded, 0 = fit failed',
+        'GLON':      'Galactic longitude (deg)',
+        'GLAT':      'Galactic latitude (deg)',
+        'RA':        'Right Ascension (deg, J2000)',
+        'DEC':       'Declination (deg, J2000)',
+        'DEBLEND':   'Deblending flag',
+        'CLUSTER':   'Cluster flag',
+    }
+    
+
+    format_dict = {
+        'MAP_ID': 's', 'HYPER_ID': 'd', 'RA': '.5f', 'DEC': '.5f', 'GLON': '.5f', 'GLAT': '.5f',
+        'FLUX': '.3f', 'FLUX_ERR': '.3f', 'FLUX_PEAK': '.5f',
+        'FLUX_PEAK_JY': '.4f', 'RESIDUALS': '.5f',
+        'FWHM_1': '.3f', 'FWHM_2': '.3f', 'PA': '.1f',
+        'NMSE': '.3f', 'CHI2_RED': '.3f', 'BIC': '.2f', 'POLYN': 'd',
+        'STATUS': 'd', 'DEBLEND': 'd', 'CLUSTER': 'd',
+    }
+    
+
+    # Original numeric table
+    table = Table(data_dict)    
+
+    # Set units, descriptions, and numeric formats
+    for col in table.colnames:
+        if col in units and units[col]:
+            table[col].unit = units[col]
+        if col in descriptions:
+            table[col].description = descriptions[col]
+        if col in format_dict:
+            table[col].format = format_dict[col]
+            
+            
+    # Create your custom header lines explicitly
+    if config.get('units', 'convert_mJy'): 
+        rms_sentence = f"Estimated r.m.s. to identify sources: {real_rms:.5f} mJy"
+    else:
+        rms_sentence = f"Estimated r.m.s. to identify sources: {real_rms:.5f} Jy"    
+
+    custom_header_lines = [
+        " ****************** Hyper photometry ******************",
+        f"Survey code: {config.get('survey', 'survey_code')}",
+        f"Detection threshold: {sigma_thres} sigma",
+        # f"Pixel size: {pix_dim:.3f} arcsec",
+        # f"Background type: {'none' if background_type == 'none' else background_type}",
+        f"Convert from MJy/sr: {config.get('units', 'convert_Jy')}",
+        f"Convert from Jy/beam: {config.get('units', 'convert_beam_Jy')}",
+        f"Convert to mJy: {config.get('units', 'convert_mJy')}",
+        rms_sentence,
+        " ******************************************************"
+    ]
+
+    # Add custom header to table metadata (ECSV)
+    table.meta['comments'] = custom_header_lines + table.meta.get('comments', [])
+
+    # Write ECSV table with custom header
+    csv_output_path = os.path.join(output_dir, base_filename + ".csv")
+    table.write(csv_output_path, format="ascii.ecsv", overwrite=True)
+
+    # For IPAC, explicitly copy rows to preserve compatibility
+    ipac_table = Table(names=table.colnames, dtype=[table[col].dtype for col in table.colnames])
+
+    for row in table:
+        ipac_table.add_row(row)
+
+    # Copy formatting, units, and descriptions again explicitly to IPAC table
+    for col in ipac_table.colnames:
+        ipac_table[col].format = table[col].format
+        ipac_table[col].unit = table[col].unit
+        ipac_table[col].description = table[col].description
+
+    # Add custom header lines explicitly to IPAC table comments
+    ipac_table.meta['comments'] = custom_header_lines + [
+        f"{col} = {ipac_table[col].description}" for col in ipac_table.colnames
+    ]
+
+    # Write IPAC table explicitly with custom headers
+    ipac_output_path = os.path.join(output_dir, base_filename + ".txt")
+    ipac_table.write(ipac_output_path, format="ipac", overwrite=True)
+            

hyper_py/detection.py

@@ -0,0 +1,142 @@
+import numpy as np
+from astropy.stats import sigma_clipped_stats
+from photutils.detection import DAOStarFinder
+from scipy.ndimage import convolve
+from astropy.table import Table
+from astropy.wcs import WCS
+
+
+
+def select_channel_map(map_struct):
+    beam_dim_ref = map_struct["beam_dim"]
+    pix_dim_ref = map_struct["pix_dim"]
+    FWHM_pix = beam_dim_ref / pix_dim_ref
+        
+    return map_struct, FWHM_pix
+
+
+def high_pass_filter(image, kernel_dim=9):
+    ny, nx = image.shape
+    kdim = min(kernel_dim, ny, nx)
+    if kdim % 2 == 0:
+        kdim -= 1
+
+    kernel = np.full((kdim, kdim), -1.0)
+    kernel[kdim // 2, kdim // 2] = kdim**2 - 1.0
+    filtered = convolve(image.astype(float), kernel, mode='nearest')
+    filtered[filtered < 0] = 0.0
+    return filtered
+
+
+def normalize_filtered_image(filtered):
+    # Step 1: Make a copy to avoid modifying input in-place
+    filtered = np.array(filtered, copy=True)
+    
+    # Step 2: Set all values ≤ 0 to 0
+    filtered[filtered <= 0] = 0.0
+
+    # Step 3: Normalize to peak = 100 (only if peak > 0)
+    peak = np.nanmax(filtered)
+    normalized = (filtered / peak) * 100.0 if peak > 0 else filtered
+
+    return normalized
+
+
+# --- low values to get as many sources as possible in this first filter stage --- #
+def estimate_rms(image, sigma_clip=3.0):
+    values = image[image > 0]
+    if len(values) == 0:
+        return 0.0
+    _, _, sigma = sigma_clipped_stats(values, sigma=sigma_clip, maxiters=10, mask_value=0.0)
+    
+    return sigma
+
+
+def detect_peaks(filtered_image, threshold, fwhm_pix, roundlim=(-1.0, 1.0), sharplim=(-1.0, 2.0)):
+    finder = DAOStarFinder(
+        threshold=threshold,
+        fwhm=fwhm_pix,
+        roundlo=roundlim[0], roundhi=roundlim[1],
+        sharplo=sharplim[0], sharphi=sharplim[1]
+    )
+    return finder(filtered_image)
+
+
+def filter_peaks(peaks_table, fwhm_pix, image_shape, min_dist_pix, aper_sup):
+    if min_dist_pix is None:
+        min_dist_pix = fwhm_pix
+
+    ny, nx = image_shape
+    margin = int(fwhm_pix)*aper_sup
+    
+    
+    # Step 1: remove peaks too close to image border
+    valid = (
+        (peaks_table['xcentroid'] > margin) &
+        (peaks_table['xcentroid'] < nx - margin) &
+        (peaks_table['ycentroid'] > margin) &
+        (peaks_table['ycentroid'] < ny - margin)
+    )
+    peaks = peaks_table[valid]
+
+    # Step 2: remove close neighbors (keep brightest)
+    coords = np.vstack([peaks['xcentroid'], peaks['ycentroid']]).T
+    keep = np.ones(len(peaks), dtype=bool)
+
+    for i in range(len(peaks)):
+        if not keep[i]:
+            continue
+        for j in range(i + 1, len(peaks)):
+            if not keep[j]:
+                continue
+            dx = coords[i][0] - coords[j][0]
+            dy = coords[i][1] - coords[j][1]
+            dist = np.hypot(dx, dy)
+            if dist < min_dist_pix:
+                if peaks[i]['peak'] >= peaks[j]['peak']:
+                    keep[j] = False
+                else:
+                    keep[i] = False
+                    
+    return peaks[keep]
+
+
+# --- save only sources above a sigma-clipped rms estimation in the maps, or use a manual value ---
+def filter_by_snr(peaks_table, real_map, rms_real, snr_threshold):
+    keep = []
+    for row in peaks_table:
+        x = int(round(row['xcentroid']))
+        y = int(round(row['ycentroid']))
+        if 0 <= y < real_map.shape[0] and 0 <= x < real_map.shape[1]:            
+            peak_val = real_map[y, x] 
+            snr = peak_val / rms_real if rms_real > 0 else 0
+            keep.append(snr >= snr_threshold)
+        else:
+            keep.append(False)
+            
+    return peaks_table[keep]
+
+
+def detect_sources(map_struct_list, dist_limit_arcsec, real_map, rms_real, snr_threshold, roundlim, sharplim, config):
+    map_struct, FWHM_pix = select_channel_map(map_struct_list)
+    image = map_struct["map"]
+    pix_dim_ref = map_struct["pix_dim"]
+    beam_dim_ref = map_struct["beam_dim"]
+    aper_sup=config.get("photometry", "aper_sup")
+
+    my_dist_limit_arcsec = beam_dim_ref if dist_limit_arcsec == 0 else dist_limit_arcsec
+    dist_limit_pix = my_dist_limit_arcsec / pix_dim_ref
+
+
+    # --- identify multiple peaks in filtered image and save good peaks with real snr threshold --- #
+    filtered = high_pass_filter(image)
+    norm_filtered = normalize_filtered_image(filtered)
+        
+    filtered_rms_detect = estimate_rms(norm_filtered)
+    filtered_threshold = 2. * filtered_rms_detect
+        
+    peaks = detect_peaks(norm_filtered, filtered_threshold, FWHM_pix, roundlim=roundlim, sharplim=sharplim)
+    good_peaks = filter_peaks(peaks, FWHM_pix, image.shape, dist_limit_pix, aper_sup)
+    final_sources = filter_by_snr(good_peaks, real_map, rms_real, snr_threshold)
+
+    return final_sources

hyper_py/extract_cubes.py

@@ -0,0 +1,42 @@
+def extract_maps_from_cube(cube_names, dir_slices_out, dir_maps_in):
+    """
+    Extract 2D slices from 3D datacubes and return list of 2D FITS file paths.
+    """
+    from astropy.io import fits
+    from astropy.wcs import WCS
+    import os
+
+
+    extracted_maps = []
+
+    for cube_name in cube_names:
+        cube_path = os.path.join(dir_maps_in, cube_name)
+        with fits.open(cube_path) as hdul:
+            data = hdul[0].data
+            cube_header = hdul[0].header
+            wcs = WCS(cube_header)
+
+            if data.ndim != 3:
+                raise ValueError(f"{cube_name} is not a 3D datacube.")
+
+            # Ensure output directory exists
+            os.makedirs(dir_slices_out, exist_ok=True)
+
+            for i in range(data.shape[0]):
+                slice_data = data[i, :, :]
+                slice_header = cube_header.copy()
+                slice_header['CRPIX3'] = i + 1  # track the slice index
+                slice_header['NAXIS'] = 2  # force 2D output
+                for key in list(slice_header.keys()):
+                    if key.startswith('NAXIS') and key != 'NAXIS1' and key != 'NAXIS2':
+                        del slice_header[key]
+                    if key.startswith('CRVAL3') or key.startswith('CDELT3') or key.startswith('CTYPE3'):
+                        del slice_header[key]
+
+                out_name = f"{os.path.splitext(cube_name)[0]}_slice_{i+1:03d}.fits"
+                out_path = os.path.join(dir_slices_out, out_name)
+
+                fits.writeto(out_path, slice_data, slice_header, overwrite=True)
+                extracted_maps.append(out_name)
+
+    return extracted_maps, cube_header