Spec7DT 0.9.0__tar.gz

spec7dt-0.9.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.2
+Name: Spec7DT
+Version: 0.9.0
+Summary: Spectral image handling package for 7-Dimensional Telescope users by Won-Hyeong Lee
+Home-page: https://github.com/Yicircle/Spec7DT
+Author: Won-Hyeong Lee
+Author-email: wohy1220@gmail.com
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: astropy
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: pathlib
+Requires-Dist: photutils
+Requires-Dist: reproject
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

spec7dt-0.9.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spec7dt-0.9.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='Spec7DT',
+    version='0.9.0',
+    description='Spectral image handling package for 7-Dimensional Telescope users by Won-Hyeong Lee',
+    author='Won-Hyeong Lee',
+    author_email='wohy1220@gmail.com',
+    url='https://github.com/Yicircle/Spec7DT',
+    install_requires=[
+        'numpy',
+        'astropy',
+        'matplotlib',
+        'seaborn',
+        'pathlib',
+        'photutils',
+        'reproject',
+    ],
+    packages=find_packages(where='src'),
+    package_dir={'': 'src'},
+    keywords=[''],
+    python_requires='>=3.10',
+    package_data={},
+    zip_safe=False,
+    classifiers=[
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12'
+    ],
+)

spec7dt-0.9.0/src/Spec7DT.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.2
+Name: Spec7DT
+Version: 0.9.0
+Summary: Spectral image handling package for 7-Dimensional Telescope users by Won-Hyeong Lee
+Home-page: https://github.com/Yicircle/Spec7DT
+Author: Won-Hyeong Lee
+Author-email: wohy1220@gmail.com
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: astropy
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: pathlib
+Requires-Dist: photutils
+Requires-Dist: reproject
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

spec7dt-0.9.0/src/Spec7DT.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+README.md
+setup.py
+src/Spec7DT.egg-info/PKG-INFO
+src/Spec7DT.egg-info/SOURCES.txt
+src/Spec7DT.egg-info/dependency_links.txt
+src/Spec7DT.egg-info/not-zip-safe
+src/Spec7DT.egg-info/requires.txt
+src/Spec7DT.egg-info/top_level.txt
+src/division/__init__.py
+src/division/binning.py
+src/division/cutout.py
+src/manipulation/__init__.py
+src/manipulation/mask.py
+src/manipulation/reddening.py
+src/manipulation/sky_interpolate.py
+src/reduction/PSF.py
+src/reduction/__init__.py
+src/reduction/background.py
+src/utils/__init__.py
+src/utils/file_generator.py
+src/utils/file_handler.py
+src/utils/pipeline.py
+src/utils/unit.py
+src/utils/utility.py

spec7dt-0.9.0/src/Spec7DT.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spec7dt-0.9.0/src/Spec7DT.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

spec7dt-0.9.0/src/Spec7DT.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy
+astropy
+matplotlib
+seaborn
+pathlib
+photutils
+reproject

spec7dt-0.9.0/src/Spec7DT.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+division
+manipulation
+reduction
+utils

spec7dt-0.9.0/src/division/binning.py

@@ -0,0 +1,20 @@
+class Bin:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def do_binning(cls, bin_size, image_data, error_data, galaxy_name, observatory, band, image_set):
+        # if bin_size is None:
+        #     bin_size = image_data.shape[0]
+        binned_img = cls.binning(image_data, bin_size, bin_size)
+        binned_err = cls.binning_err(error_data, bin_size, bin_size)
+        image_set.update_data(binned_img, galaxy_name, observatory, band)
+        image_set.update_error(binned_err, galaxy_name, observatory, band)
+        
+    def binning(image, bin_x, bin_y):
+        return image.reshape(bin_x, image.shape[0] // bin_x, bin_y, image.shape[1] // bin_y).sum(3).sum(1)
+
+    def binning_err(image, bin_x, bin_y):
+        image = image ** 2
+        image = image.reshape(bin_x, image.shape[0] // bin_x, bin_y, image.shape[1] // bin_y).sum(3).sum(1)
+        return image ** (0.5)

spec7dt-0.9.0/src/division/cutout.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+class CutRegion:
+    
+    @classmethod
+    def cutout_region(cls, box_size, image_data, error_data, galaxy_name, observatory, band, image_set):
+        cut_img, cut_error = cls.get_cutout(image_data, error_data, box_size, 'ellipse')
+        image_set.update_data(cut_img, galaxy_name, observatory, band)
+        image_set.update_error(cut_error, galaxy_name, observatory, band)
+
+    def get_cutout(img, error, size, _shape: str='box'):
+        """
+        Mask out everything except a central region of shape 'box', 'circle', or 'ellipse'.
+
+        Parameters
+        ----------
+        img : 2D ndarray
+            Input image.
+        size : float or tuple of floats
+            - If _shape in {'box','circle'}: scalar = side‐length (box) or diameter (circle).
+            - If _shape=='ellipse': either
+                * scalar = major and minor axes
+                * tuple (width, height) in pixels for major/minor axes.
+        _shape : {'box','circle','ellipse'}
+            Shape of the kept region.
+
+        Returns
+        -------
+        cutout : 2D ndarray
+            Same shape as `img`, with pixels **outside** the requested region set to zero.
+        """
+        ny, nx = img.shape
+        cx, cy = nx // 2, ny // 2  # center coordinates
+
+        if _shape == 'box':
+            hs = int(size // 2)
+            cut = np.zeros_like(img)
+            cut[cy-hs:cy+hs, cx-hs:cx+hs] = img[cy-hs:cy+hs, cx-hs:cx+hs]
+            return cut
+
+        elif _shape == 'circle':
+            r = size / 2
+            y, x = np.ogrid[:ny, :nx]
+            mask = (x - cx)**2 + (y - cy)**2 <= r**2
+            return img * mask.astype(img.dtype)
+
+        elif _shape == 'ellipse':
+            # Determine semiaxes in pixels
+            if isinstance(size, (list, tuple, np.ndarray)):
+                w, h = size
+            else:
+                w = h = size
+            a = w / 2  # semimajor axis
+            b = h / 2  # semiminor axis
+
+            # Create an ellipse mask
+            y, x = np.ogrid[:ny, :nx]
+            # Standard ellipse equation (centered at cx,cy)
+            mask = ((x - cx)**2 / a**2 + (y - cy)**2 / b**2) <= 1.0
+            
+            return img * mask.astype(img.dtype), error * mask.astype(error.dtype)
+
+        else:
+            raise ValueError(f"Unknown shape '{_shape}'. Choose 'box', 'circle', or 'ellipse'.")

spec7dt-0.9.0/src/manipulation/mask.py

@@ -0,0 +1,87 @@
+import numpy as np
+from astroquery.ipac.ned import Ned
+from astropy.wcs import WCS
+from photutils.segmentation import detect_sources
+from photutils.background import Background2D, MedianBackground
+from photutils.detection import DAOStarFinder
+from astropy.stats import sigma_clipped_stats
+from photutils.psf import PSFPhotometry, MoffatPSF
+
+class Masking:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def adapt_mask(cls, image_data, header, error_data, galaxy_name, observatory, band, image_set):
+        mask_image, masked_image, _ = cls.make_mask(cls, image_data, header, galaxy_name)
+        masked_err = np.where(mask_image, 999.0, error_data)
+        
+        image_set.update_data(masked_image, galaxy_name, observatory, band)
+        image_set.update_error(masked_err, galaxy_name, observatory, band)
+        
+
+    def make_mask(self, image, header, galaxy):
+        ra, dec = Ned.query_object(galaxy)['RA', 'DEC'][0]
+
+        wcs = WCS(header)
+        x, y = wcs.all_world2pix(ra, dec, 0)
+
+        bkg_estimator = MedianBackground()
+        try:    
+            bkg = Background2D(image, (500, 500), filter_size=(13, 13), bkg_estimator=bkg_estimator)
+        except ValueError:
+            print('ValueError occured. Try Smaller Background size.')
+            bkg = Background2D(image, (200, 200), filter_size=(13, 13), bkg_estimator=bkg_estimator)
+        threshold = 1.5*bkg.background_rms
+
+        segment_map = detect_sources(image, threshold, npixels=5)
+        if segment_map == None:
+            return image, image, image
+
+        sky_map = np.nonzero(segment_map.data)
+        sky_image = image.copy()
+        sky_image[sky_map] = np.nan
+
+        label_main = segment_map.data[int(y), int(x)]
+        if label_main != 0:
+            segment_map.remove_labels([label_main])
+
+        mask = np.nonzero(segment_map.data)
+        masked_image = image.copy()
+        masked_image[mask] = np.nan
+            
+        mask_image = np.zeros_like(image)
+        mask_image[mask] = image[mask]
+        
+        mean, median, std = sigma_clipped_stats(image, sigma=3.0)
+        daofind = DAOStarFinder(fwhm=6.0, threshold=100.*std)
+        sources = daofind(masked_image - mean)  # Table with 'xcentroid', 'ycentroid', etc.
+
+        # 2. Compute center and a small exclusion radius (in pixels)
+        excl_radius = 200.0  # e.g. 5 pixels
+
+        # 3. Measure distance of each source to center
+        dx = sources['xcentroid'] - x
+        dy = sources['ycentroid'] - y
+        dist = np.hypot(dx, dy)
+
+        # 4. Filter out the central source(s)
+        good = dist > excl_radius
+        filtered_sources = sources[good]
+
+        psf_model = MoffatPSF(alpha=5.0)
+        psf_model.alpha.fixed = False
+        psf_model.flux.fixed = False
+        fit_shape = (31, 31) 
+        psfphot = PSFPhotometry(psf_model, fit_shape,
+                                aperture_radius=12.0)
+        phot = psfphot(masked_image - mean, init_params=filtered_sources["xcentroid", "ycentroid", "flux"])
+        if phot is None:
+            print('No PSF photometry found.')
+            return masked_image, masked_image, masked_image
+        
+        resid = psfphot.make_residual_image(masked_image - mean)
+        mask_image = np.where(masked_image - mean - resid > 0, 0, 1)
+        masked_image = resid.copy()
+        
+        return mask_image, masked_image, sky_image

spec7dt-0.9.0/src/manipulation/reddening.py

@@ -0,0 +1,223 @@
+import numpy as np
+from astropy.coordinates import SkyCoord
+from astroquery.ipac.ned import Ned
+from dustmaps.planck import PlanckQuery
+from pathlib import Path
+
+class Reddening:
+    def __init__(self):
+        from dustmaps.config import config
+        config.reset()
+        
+        import dustmaps.planck
+        dustmaps.planck.fetch()
+        
+    
+    def dered(self, image_data, error_data, galaxy_name, observatory, band, image_set):
+        self.obj, self.obs, self.filt = galaxy_name, observatory, band
+        self.filter_file = f'{self.obs}.{self.filt}.dat'
+        self.ra, self.dec = Ned.query_object(self.obj)['RA', 'DEC'][0]
+        coords = SkyCoord(self.ra, self.dec, unit='deg', frame='icrs')
+        planck = PlanckQuery()
+        self.ebv = planck(coords)
+        wave, resp = self.get_resp_curve()
+        # Check if filter is valid for CCM98 model
+        if (max(wave) > 3.3 * 1e4) | (min(wave) < 9.1 * 1e2):
+            print('Filter is not valid for CCM98 model')
+            return 0
+        
+        A_mean = self.median_reddening(wave, resp)
+        deredden_img = image_data * 10 ** (0.4 * A_mean)
+        deredden_err = error_data * 10 ** (0.4 * A_mean)
+        
+        image_set.update_data(deredden_img, galaxy_name, observatory, band)
+        image_set.update_error(deredden_err, galaxy_name, observatory, band)
+        
+                
+    def get_resp_curve(self):
+        base_dir = Path(__file__).resolve().parents[2]
+        filter_dir = base_dir / "src" / "reference" / "filter_curves"
+        dat_path = filter_dir / f"{self.filter_file}"
+        
+        f_g = np.genfromtxt(dat_path, skip_header = 3 , delimiter = ' ' , dtype = float)
+        wave = f_g[:, 0]
+        resp = f_g[:, 1]
+        
+        mask = (resp != 0)
+        
+        return wave[mask], resp[mask]
+    
+    def reddening_ccm(self, wave, ebv=None, a_v=None, r_v=3.1, model='ccm89'):
+        """
+        Not used in FIREFLY
+        Determines a CCM reddening curve.
+
+        Parameters
+        ----------
+        wave: ~numpy.ndarray
+            wavelength in Angstroms
+        flux: ~numpy.ndarray
+        ebv: float
+            E(B-V) differential extinction; specify either this or a_v.
+        a_v: float
+            A(V) extinction; specify either this or ebv.
+        r_v: float, optional
+            defaults to standard Milky Way average of 3.1
+        model: {'ccm89', 'gcc09'}, optional
+            * 'ccm89' is the default Cardelli, Clayton, & Mathis (1989) [1]_, but
+            does include the O'Donnell (1994) parameters to match IDL astrolib.
+            * 'gcc09' is Gordon, Cartledge, & Clayton (2009) [2]_. This paper has
+            incorrect parameters for the 2175A bump; not yet corrected here.
+
+        Returns
+        -------
+        reddening_curve: ~numpy.ndarray
+            Multiply to deredden flux, divide to redden.
+
+        Notes
+        -----
+        Cardelli, Clayton, & Mathis (1989) [1]_ parameterization is used for all
+        models. The default parameter values are from CCM except in the optical
+        range, where the updated parameters of O'Donnell (1994) [3]_ are used
+        (matching the Goddard IDL astrolib routine CCM_UNRED).
+
+        The function is works between 910 A and 3.3 microns, although note the
+        default ccm89 model is scientifically valid only at >1250 A.
+
+        Model gcc09 uses the updated UV coefficients of Gordon, Cartledge, & Clayton
+        (2009) [2]_, and is valid from 910 A to 3030 A. This function will use CCM89
+        at longer wavelengths if GCC09 is selected, but note that the two do not
+        connect perfectly smoothly. There is a small discontinuity at 3030 A. Note
+        that GCC09 equations 14 and 15 apply to all x>5.9 (the GCC09 paper
+        mistakenly states they do not apply at x>8; K. Gordon, priv. comm.).
+
+        References
+        ----------
+        [1] Cardelli, J. A., Clayton, G. C., & Mathis, J. S. 1989, ApJ, 345, 245
+        [2] Gordon, K. D., Cartledge, S., & Clayton, G. C. 2009, ApJ, 705, 1320
+        [3] O'Donnell, J. E. 1994, ApJ, 422, 158O
+
+        """
+
+        import warnings
+
+        model = model.lower()
+        if model not in ['ccm89','gcc09']:
+            raise ValueError('model must be ccm89 or gcc09')
+        if (a_v is None) and (ebv is None):
+            raise ValueError('Must specify either a_v or ebv')
+        if (a_v is not None) and (ebv is not None):
+            raise ValueError('Cannot specify both a_v and ebv')
+        if a_v is not None:
+            ebv = a_v / r_v
+
+        if model == 'gcc09':
+            raise ValueError('TEMPORARY: gcc09 currently does 2175A bump '+
+                'incorrectly')
+
+        x = 1e4 / wave      # inverse microns
+        if any(x < 0.3) or any(x > 11):
+            raise ValueError('ccm_dered valid only for wavelengths from 910 A to '+
+                '3.3 microns')
+        if any(x > 8) and (model == 'ccm89'):
+            warnings.warn('CCM89 should not be used below 1250 A.')
+        #    if any(x < 3.3) and any(x > 3.3) and (model == 'gcc09'):
+        #        warnings.warn('GCC09 has a discontinuity at 3030 A.')
+
+        a = np.zeros(x.size)
+        b = np.zeros(x.size)
+
+        # NIR
+        valid = (0.3 <= x) & (x < 1.1)
+        a[valid] = 0.574 * x[valid]**1.61
+        b[valid] = -0.527 * x[valid]**1.61
+
+        # optical, using O'Donnell (1994) values
+        valid = (1.1 <= x) & (x < 3.3)
+        y = x[valid] - 1.82
+        coef_a = np.array([-0.505, 1.647, -0.827, -1.718, 1.137, 0.701, -0.609,
+            0.104, 1.])
+        coef_b = np.array([3.347, -10.805, 5.491, 11.102, -7.985, -3.989, 2.908,
+            1.952, 0.])
+        a[valid] = np.polyval(coef_a,y)
+        b[valid] = np.polyval(coef_b,y)
+
+        # UV
+        valid = (3.3 <= x) & (x < 8)
+        y = x[valid]
+        f_a = np.zeros(y.size)
+        f_b = np.zeros(y.size)
+        select = (y >= 5.9)
+        yselect = y[select] - 5.9
+
+        f_a[select] = -0.04473 * yselect**2 - 0.009779 * yselect**3
+        f_b[select] = 0.2130 * yselect**2 + 0.1207 * yselect**3
+        a[valid] = 1.752 - 0.316*y - (0.104 / ((y-4.67)**2 + 0.341)) + f_a
+        b[valid] = -3.090 + 1.825*y + (1.206 / ((y-4.62)**2 + 0.263)) + f_b
+
+        # far-UV CCM89 extrapolation
+        valid = (8 <= x) & (x < 11)
+        y = x[valid] - 8.
+        coef_a = np.array([-0.070, 0.137, -0.628, -1.073])
+        coef_b = np.array([0.374, -0.420, 4.257, 13.670])
+        a[valid] = np.polyval(coef_a,y)
+        b[valid] = np.polyval(coef_b,y)
+
+        # Overwrite UV with GCC09 model if applicable. Not an extrapolation.
+        if model == 'gcc09':
+            valid = (3.3 <= x) & (x < 11)
+            y = x[valid]
+            f_a = np.zeros(y.size)
+            f_b = np.zeros(y.size)
+            select = (5.9 <= y)
+            yselect = y[select] - 5.9
+            f_a[select] = -0.110 * yselect**2 - 0.0099 * yselect**3
+            f_b[select] = 0.537 * yselect**2 + 0.0530 * yselect**3
+            a[valid] = 1.896 - 0.372*y - (0.0108 / ((y-4.57)**2 + 0.0422)) + f_a
+            b[valid] = -3.503 + 2.057*y + (0.718 / ((y-4.59)**2 + 0.0530*3.1)) + f_b
+
+        if isinstance(ebv, np.ndarray):
+            if (len(ebv.shape) > 1):
+                a = a[np.newaxis, np.newaxis, :]; b = b[np.newaxis, np.newaxis, :]
+                ebv = ebv[:, :, np.newaxis]
+        
+        a_v = ebv * r_v
+        a_lambda = a_v * (a + b/r_v)
+        reddening_curve = 10**(0.4 * a_lambda)
+
+        return reddening_curve
+
+    def median_reddening(self, wavelength, response):
+            """
+            Compute the mean wavelength given arrays of wavelength (wavelength) and transmission (response).
+
+            Parameters
+            ----------
+            wavelength : array_like
+                Wavelengths (e.g., in Angstroms).
+            response : array_like
+                Filter transmission values corresponding to wavelength.
+
+            Returns
+            -------
+            lambda_mean : float
+                The mean wavelength.
+            """
+            # Ensure the inputs are numpy arrays
+            wavelength = np.asarray(wavelength)
+            response = np.asarray(response) / np.max(np.asarray(response))
+            
+            # Get reddening curve
+            red_curve = self.reddening_ccm(wavelength, ebv=self.ebv, a_v=None, r_v=3.1, model='ccm89')
+            A_lambda = 2.5 * np.log10(red_curve)
+
+            # Numerically integrate T(lambda)*lambda over lambda for the numerator
+            numerator = np.trapz(response * A_lambda, x=wavelength)
+            
+            # Numerically integrate response(lambda)/lambda over lambda for the denominator
+            denominator = np.trapz(response, x=wavelength)
+            
+            # Compute the pivot wavelength as the square root of the ratio
+            A_mean = numerator / denominator
+            return A_mean
+        

spec7dt-0.9.0/src/manipulation/sky_interpolate.py

@@ -0,0 +1,6 @@
+from astropy.convolution import convolve, Gaussian2DKernel
+
+def interpolate_sky(image_data, galaxy_name, observatory, band, image_set):
+    gauss_kernal = Gaussian2DKernel(x_stddev=1)
+    interp_img = convolve(image_data, gauss_kernal, normalize_kernel=True, nan_treatment='interpolate')
+    image_set.update_data(interp_img, galaxy_name, observatory, band)

spec7dt-0.9.0/src/reduction/PSF.py

@@ -0,0 +1,123 @@
+import numpy as np
+from scipy.stats import mode
+
+from photutils.detection import DAOStarFinder
+from astropy.stats import sigma_clipped_stats
+from astropy.modeling import models, fitting
+from astropy.convolution import convolve_fft, Gaussian2DKernel
+
+import warnings
+from astropy.utils.exceptions import AstropyWarning
+warnings.simplefilter('ignore', category=AstropyWarning)
+
+class PointSpreadFunction:
+    
+    def __call__(self):
+        pass
+    
+    @classmethod
+    def extract(cls, image_data, header, galaxy_name, observatory, band, image_set):    
+        fwhm_val = cls.measure_psf_fwhm(cls, image_data, header, threshold_sigma=15)
+        
+        image_set.set_psf(galaxy_name, observatory, band, fwhm_val) # in " fwhm * pixel_scale
+    
+    @classmethod
+    def convolution(cls, image_data, header, error_data, galaxy_name, observatory, band, image_set):
+        """
+        Convolve `image` with a Gaussian kernel of width `sigma_extra_pix` (pixels).
+        If sigma_extra_pix==0, return original image.
+        """
+        pixel_scale = np.abs(header.get("CD1_1", 1.1e-4)) * 3600  # in "
+        
+        psf_list = image_set.get_psf(galaxy_name)
+        sig_i = image_set.psf[galaxy_name][observatory][band]
+        sig_t = np.max(psf_list)
+        sigma_extra = np.sqrt(sig_t**2 - sig_i**2) / pixel_scale
+        
+        if sigma_extra <= 0:
+            return image_data.copy()
+        kernel = Gaussian2DKernel(x_stddev=sigma_extra)
+        convolved_img = convolve_fft(
+            image_data, kernel,
+            normalize_kernel=True,
+            nan_treatment='interpolate'
+        )
+        convolved_err = convolve_fft(
+            error_data, kernel,
+            normalize_kernel=True,
+            nan_treatment='interpolate'
+        )
+        image_set.update_data(convolved_img, galaxy_name, observatory, band)
+        image_set.update_error(convolved_err, galaxy_name, observatory, band)
+    
+
+    def measure_fwhm_gaussian(image, x_center, y_center, box_size=21):
+        """
+        Measure FWHM by fitting 2D Gaussian to PSF
+        """
+        # Extract cutout around star
+        y, x = np.ogrid[:box_size, :box_size]
+        x_start = int(x_center - box_size//2)
+        y_start = int(y_center - box_size//2)
+        
+        cutout = image[y_start:y_start+box_size, x_start:x_start+box_size]
+        
+        # Create coordinate grids
+        y_grid, x_grid = np.mgrid[:box_size, :box_size]
+        
+        # Initial parameter guess
+        amplitude = np.max(cutout)
+        x_mean = box_size // 2
+        y_mean = box_size // 2
+        
+        # Fit 2D Gaussian
+        g_init = models.Gaussian2D(amplitude=amplitude, 
+                                x_mean=x_mean, y_mean=y_mean,
+                                x_stddev=box_size * 0.05, y_stddev=box_size * 0.05)
+        fit_g = fitting.TRFLSQFitter()
+        g = fit_g(g_init, x_grid, y_grid, cutout)
+        
+        # Convert stddev to FWHM
+        fwhm_x = 2.355 * g.x_stddev.value
+        fwhm_y = 2.355 * g.y_stddev.value
+        fwhm_avg = (fwhm_x + fwhm_y) / 2
+        
+        return fwhm_avg
+
+    def measure_psf_fwhm(self, image, header, threshold_sigma=15):
+        """
+        Complete pipeline: detect stars and measure FWHM
+        """
+        im_x, im_y = image.shape
+        box_size = int((im_x + im_y) * 0.1 / 2)
+        mean, median, std = sigma_clipped_stats(image, sigma=10.0)
+        
+        # Star detection
+        daofind = DAOStarFinder(fwhm=3.0, threshold=threshold_sigma*std)
+        sources = daofind(image)
+        
+        if sources is None:
+            return -1.0
+        
+        # Measure FWHM for each detected star
+        fwhm_measurements = []
+        
+        for source in sources:
+            x, y = source['xcentroid'], source['ycentroid']
+            
+            margin = 0.1
+            # Skip stars too close to edges
+            if (x > im_x * margin and x < im_x * (1 - margin) and 
+                y > im_y * margin and y < im_y * (1 - margin)):
+                
+                try:
+                    fwhm = self.measure_fwhm_gaussian(image, x, y, box_size=box_size)
+                    if not np.isnan(fwhm) and fwhm > 0:
+                        fwhm_measurements.append(fwhm)
+                except:
+                    continue
+        
+        fwhm, _ = mode(fwhm_measurements, nan_policy='omit')
+        pixel_scale = np.abs(header.get("CD1_1", 1.1e-4)) * 3600  # in "
+        
+        return fwhm * pixel_scale