plotastrodata 1.8.15__tar.gz → 1.8.17__tar.gz

{plotastrodata-1.8.15/plotastrodata.egg-info → plotastrodata-1.8.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.15
+Version: 1.8.17
 Summary: plotastrodata is a tool for astronomers to create figures from FITS files and perform fundamental data analyses with ease.
 Home-page: https://github.com/yusukeaso-astron/plotastrodata
 Download-URL: https://github.com/yusukeaso-astron/plotastrodata

{plotastrodata-1.8.15 → plotastrodata-1.8.17}/plotastrodata/__init__.py

@@ -1,4 +1,4 @@
 import warnings
 
 warnings.simplefilter('ignore', FutureWarning)
-__version__ = '1.8.15'
+__version__ = '1.8.17'

{plotastrodata-1.8.15 → plotastrodata-1.8.17}/plotastrodata/analysis_utils.py

@@ -2,17 +2,16 @@ import numpy as np
 import warnings
 from dataclasses import dataclass
 from scipy.interpolate import RegularGridInterpolator as RGI
-from scipy.optimize import curve_fit
 from scipy.signal import convolve
 
 from plotastrodata import const_utils as cu
 from plotastrodata.coord_utils import coord2xy, rel2abs, xy2coord
 from plotastrodata.fits_utils import data2fits, FitsData, Jy2K
-from plotastrodata.fitting_utils import EmceeCorner, gaussfit1d
+from plotastrodata.fitting_utils import (EmceeCorner, gaussian2d,
+                                         gaussfit1d, gaussfit2d)
 from plotastrodata.matrix_utils import dot2d, Mfac, Mrot
 from plotastrodata.noise_utils import estimate_rms
-from plotastrodata.other_utils import (gaussian2d, isdeg,
-                                       RGIxy, RGIxyv, to4dim, trim)
+from plotastrodata.other_utils import isdeg, RGIxy, RGIxyv, to4dim, trim
 
 
 def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
@@ -106,7 +105,7 @@ class AstroData():
     beam: np.ndarray | tuple[None] = (None, None, None)
     fitsimage: str | None = None
     Tb: bool = False
-    sigma: str = 'hist'
+    sigma: str | float | None = 'hist'
     center: str = 'common'
     restfreq: float | None = None
     cfactor: float = 1
@@ -333,47 +332,32 @@ class AstroData():
 
     @_need_multipixels
     def gaussfit2d(self, chan: int | None = None) -> dict:
-        """Fit a 2D Gaussian function to self.data.
+        """Fit a 2D Gaussian function to self.data using fitting_utils.gaussfit2d().
 
         Args:
             chan (int): The channel number where the 2D Gaussian is fitted. Defaults to None.
 
         Returns:
-            dict: The best parameter set (popt), the covariance set (pcov), the best 2D Gaussian array (model), the residual from the model (residual), and the coordinates of the best-fit center (center).
+            dict: The best parameter set (popt), the error set (perr), the best 2D Gaussian array (model), the residual from the model (residual), and the coordinates of the best-fit center (center).
         """
-        d = self.data if chan is None else self.data[chan]
-        x = self.x
-        y = self.y
-        ds = np.min([np.abs(self.dx), np.abs(self.dy)])
-        p0 = (np.max(d), np.median(x), np.median(y), 5 * ds, 5 * ds, 0)
-        amax = np.max(np.abs(d))
-        xmin = np.min(x)
-        xmax = np.max(x)
-        ymin = np.min(y)
-        ymax = np.max(y)
-        smax = np.max([xmax - xmin, ymax - ymin])
-        bounds = [[-amax, xmin, ymin, ds, ds, -90],
-                  [amax, xmax, ymax, smax, smax, 90]]
-        x, y = np.meshgrid(x, y)
+        z = self.data if chan is None else self.data[chan]
         Omega = np.pi * self.beam[0] * self.beam[1] / 4 / np.log(2)
         pixelperbeam = Omega / np.abs(self.dx * self.dy)
         s = 'sigma is multiplied by sqrt(pixel-per-beam)' \
             + ' to consider the noise correlation in a beam.' \
             + ' This correction is relatively conservative.'
         warnings.warn(s, UserWarning)
-        popt, pcov = curve_fit(gaussian2d,
-                               (x.ravel(), y.ravel()), d.ravel(),
-                               p0=p0, bounds=bounds,
-                               sigma=self.sigma * np.sqrt(pixelperbeam),
-                               absolute_sigma=True)
-        model = gaussian2d((x, y), *popt)
-        residual = d - model
-        if (center := self.center) is not None:
-            xy = popt[1:3] / 3600
-            newcenter = xy2coord(xy, coordorg=center)
+        res = gaussfit2d(xdata=self.x, ydata=self.y, zdata=z,
+                         sigma=self.sigma * np.sqrt(pixelperbeam),
+                         show=False, nwalkersperdim=4)
+        popt, perr = res['popt'], res['perr']
+        model = gaussian2d(np.meshgrid(self.x, self.y), *popt)
+        residual = z - model
+        if self.center is not None:
+            newcenter = xy2coord(popt[1:3] / 3600, coordorg=self.center)
         else:
             newcenter = None
-        return {'popt': popt, 'pcov': pcov,
+        return {'popt': popt, 'perr': perr,
                 'model': model, 'residual': residual,
                 'center': newcenter}
 
@@ -468,7 +452,8 @@ class AstroData():
             res = [None] * nprof
             for i in range(nprof):
                 res[i] = gaussfit1d(xdata=v, ydata=prof[i],
-                                    sigma=None, show=True)
+                                    sigma=None, show=True,
+                                    nwalkersperdim=8)
             gfitres['best'] = [a['popt'][:3] for a in res]
             gfitres['error'] = [a['perr'][:3] for a in res]
         return v, prof, gfitres

{plotastrodata-1.8.15 → plotastrodata-1.8.17}/plotastrodata/fitting_utils.py

@@ -8,6 +8,7 @@ from dynesty import DynamicNestedSampler as DNS
 from multiprocessing import Pool
 from tqdm import tqdm
 
+from plotastrodata.matrix_utils import Mrot, dot2d
 from plotastrodata.other_utils import close_figure
 
 
@@ -395,6 +396,47 @@ class EmceeCorner():
         return {'evidence': evidence, 'error': error}
 
 
+def gaussian1d(x: np.ndarray | float,
+               amplitude: float, xo: float, fwhm: float,
+               ) -> np.ndarray:
+    """One dimensional Gaussian function.
+
+    Args:
+        x (np.ndarray): Variable of the Gaussian function.
+        amplitude (float): Peak value.
+        xo (float): Offset in the x direction.
+        fwhm (float): Full width at half maximum.
+
+    Returns:
+        g (np.ndarray): 1D numpy array.
+    """
+    g = amplitude * np.exp2(-4 * (((x - xo) / fwhm)**2))
+    return g
+
+
+def gaussian2d(xy: np.ndarray,
+               amplitude: float, xo: float, yo: float,
+               fwhm_major: float, fwhm_minor: float, pa: float
+               ) -> np.ndarray:
+    """Two dimensional Gaussian function.
+
+    Args:
+        xy (np.ndarray): A pair of (x, y).
+        amplitude (float): Peak value.
+        xo (float): Offset in the x direction.
+        yo (float): Offset in the y direction.
+        fwhm_major (float): Full width at half maximum in the major axis (but can be shorter than the minor axis).
+        fwhm_minor (float): Full width at half maximum in the minor axis (but can be longer then the major axis).
+        pa (float): Position angle of the major axis from the +y axis to the +x axis in the unit of degree.
+
+    Returns:
+        g (np.ndarray): Output array in the same shape as xy.
+    """
+    s, t = dot2d(Mrot(-pa), [xy[1] - yo, xy[0] - xo])
+    g = amplitude * np.exp2(-4 * ((s / fwhm_major)**2 + (t / fwhm_minor)**2))
+    return g
+
+
 def gaussfit1d(xdata: np.ndarray, ydata: np.ndarray,
                sigma: float | np.ndarray | None,
                show: bool = False, **kwargs) -> dict:
@@ -403,43 +445,90 @@ def gaussfit1d(xdata: np.ndarray, ydata: np.ndarray,
     Args:
         xdata (np.ndarray): ydata is compared with Gauss(xdata).
         ydata (np.ndarray): ydata is compared with Gauss(xdata).
-        sigma (float | np.ndarray | None): Noise level of ydata. If None is given, sigma is also a free parameter. Defaults to None.
+        sigma (float | np.ndarray | None): Noise level of ydata. If None is given, sigma is estimated by a temporary fitting. Defaults to None.
         show (bool, optional): True means to show the best-fit parameters and uncertainties. Defaults to False.
 
     Returns:
-        dict: _description_
+        dict: The keys are popt, perr, and sigma.
     """
-    if sigma is not None and np.shape(sigma) == ():
-        sigma = [sigma] * len(xdata)
     xmin, xmax = np.min(xdata), np.max(xdata)
     ymin, ymax = np.min(ydata), np.max(ydata)
+    xw = xmax - xmin
+    yw = ymax - ymin
     dx = np.abs(xdata[1] - xdata[0])
-    bounds = [[ymin, ymax], [xmin, xmax], [dx, xmax - xmin]]
-    if sigma is None:
-        bounds.append([np.log(ymax * 1e-6), np.log(ymax)])
-
-    def g(x, p):
-        a, c, w = p
-        return a * np.exp(-4. * np.log(2.) * ((x - c) / w)**2)
-
-    if sigma is None:
-        def logl(p):
-            sigmdl = np.exp(p[3])
-            chi2 = np.sum(((ydata - g(xdata, p[:3])) / sigmdl)**2)
-            return -0.5 * chi2 - p[3]
-    else:
-        def logl(p):
-            chi2 = np.sum(((ydata - g(xdata, p)) / sigma)**2)
-            return -0.5 * chi2
-
-    fitter = EmceeCorner(bounds=bounds, logl=logl)
-    fitter.fit(**kwargs)
+    bounds = [[ymin - yw * 10, ymax + yw * 10], [xmin, xmax], [dx, xw]]
+    sigtmp = sigma or max(np.abs(ymin), np.abs(ymax)) * 0.01
+    for i in range(2 if sigma is None else 1):
+        fitter = EmceeCorner(bounds=bounds, model=gaussian1d,
+                             sigma=sigtmp, xdata=xdata, ydata=ydata)
+        fitter.fit(**kwargs)
+        if i == 0:
+            sigtmp = np.std(ydata - gaussian1d(xdata, *fitter.popt))
     popt = fitter.popt
     plow = fitter.plow
     phigh = fitter.phigh
     perr = (phigh - plow) / 2
-    pars = 'peak, center, FWHM' + (', lnsigma' if sigma is None else '')
     if show:
-        print(f'Gauss ({pars}):', popt)
+        print('Gauss (peak, center, FWHM):', popt)
+        print('Gauss uncertainties:', perr)
+        if sigma is None:
+            print('Estimated sigma: ', sigtmp)
+    return {'popt': popt, 'perr': perr, 'sigma': sigtmp}
+
+
+def gaussfit2d(xdata: np.ndarray, ydata: np.ndarray, zdata: np.ndarray,
+               sigma: float | np.ndarray | None,
+               show: bool = False, **kwargs) -> dict:
+    """Gaussian fitting to a pair of 1D arrays.
+
+    Args:
+        xdata (np.ndarray): zdata is compared with Gauss(xdata, ydata).
+        ydata (np.ndarray): zdata is compared with Gauss(xdata, ydata).
+        zdata (np.ndarray): zdata is compared with Gauss(xdata, ydata).
+        sigma (float | np.ndarray | None): Noise level of ydata. If None is given, sigma is estimated by a temporary fitting. Defaults to None.
+        show (bool, optional): True means to show the best-fit parameters and uncertainties. Defaults to False.
+
+    Returns:
+        dict: The keys are popt, perr, and sigma.
+    """
+    xmin, xmax = np.min(xdata), np.max(xdata)
+    ymin, ymax = np.min(ydata), np.max(ydata)
+    zmin, zmax = np.min(zdata), np.max(zdata)
+    xw = xmax - xmin
+    yw = ymax - ymin
+    zw = zmax - zmin
+    dx = min(np.abs(xdata[1] - xdata[0]), np.abs(ydata[1] - ydata[0]))
+    xw = max(xw, yw)
+    xy = np.meshgrid(xdata, ydata)
+    sigtmp = sigma or max(np.abs(zmin), np.abs(zmax)) * 0.01
+
+    def model(xy, a, cx, cy, wmaj, wmin, pa):
+        if wmaj < wmin:
+            return np.inf
+        else:
+            return gaussian2d(xy, a, cx, cy, wmaj, wmin, pa)
+
+    bounds = [[zmin - zw * 10, zmax + zw * 10],
+              [xmin, xmax], [ymin, ymax],
+              [dx, xw], [dx, xw], [-90, 90]]
+    for i in range(2):
+        fitter = EmceeCorner(bounds=bounds, model=model,
+                             sigma=sigtmp, xdata=xy, ydata=zdata)
+        fitter.fit(**kwargs)
+        a, cx, cy, wmaj, wmin, pa = fitter.popt
+        wmax = max(wmaj, wmin)
+        bounds = [sorted([a / 2, a * 2]),
+                  [cx - wmax, cx + wmax], [cy - wmax, cy + wmax],
+                  [wmaj / 2, wmaj * 2], [wmin / 2, wmin * 2],
+                  [pa - 45, pa + 45]]
+        if i == 0 and sigma is None:
+            sigtmp = np.std(ydata - gaussian2d(xy, *fitter.popt))
+    popt = fitter.popt
+    popt[-1] = (popt[-1] + 90) % 180 - 90
+    perr = (fitter.phigh - fitter.plow) / 2
+    if show:
+        print('Gauss (peak, center, FWHM):', popt)
         print('Gauss uncertainties:', perr)
-    return {'popt': popt, 'perr': perr}
+        if sigma is None:
+            print('Estimated sigma: ', sigtmp)
+    return {'popt': popt, 'perr': perr, 'sigma': sigtmp}

{plotastrodata-1.8.15 → plotastrodata-1.8.17}/plotastrodata/other_utils.py

@@ -2,8 +2,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 from scipy.interpolate import RegularGridInterpolator as RGI
 
-from plotastrodata.matrix_utils import Mrot, dot2d
-
 
 def listing(*args) -> list:
     """Output a list of the input when the input is string or number.
@@ -176,29 +174,6 @@ def RGIxyv(v: np.ndarray, y: np.ndarray, x: np.ndarray, data: np.ndarray,
         return np.squeeze([f3d(tuple(vyxnew)) for f3d in f])
 
 
-def gaussian2d(xy: np.ndarray,
-               amplitude: float, xo: float, yo: float,
-               fwhm_major: float, fwhm_minor: float, pa: float
-               ) -> np.ndarray:
-    """Two dimensional Gaussian function.
-
-    Args:
-        xy (np.ndarray): A pair of (x, y).
-        amplitude (float): Peak value.
-        xo (float): Offset in the x direction.
-        yo (float): Offset in the y direction.
-        fwhm_major (float): Full width at half maximum in the major axis (but can be shorter than the minor axis).
-        fwhm_minor (float): Full width at half maximum in the minor axis (but can be longer then the major axis).
-        pa (float): Position angle of the major axis from the +y axis to the +x axis in the unit of degree.
-
-    Returns:
-        g (np.ndarray): 2D numpy array.
-    """
-    s, t = dot2d(Mrot(-pa), [xy[1] - yo, xy[0] - xo])
-    g = amplitude * np.exp2(-4 * ((s / fwhm_major)**2 + (t / fwhm_minor)**2))
-    return g
-
-
 def close_figure(fig: object, savefig: dict | str | None = None,
                  show: bool = False, tight: bool = True) -> None:
     """Save, show, and close the figure.

{plotastrodata-1.8.15 → plotastrodata-1.8.17}/plotastrodata/plot_utils.py

@@ -99,6 +99,39 @@ def logcbticks(vmin: float = 1e-3, vmax: float = 1e3
     return ticks[cond], ticklabels[cond]
 
 
+def _get_sec(coord: str, mode: str) -> str:
+    i_axis = 0 if mode == 'ra' else 1
+    return coord.split(' ')[i_axis].split('m')[1].strip('s')
+
+
+def _get_min(coord: str, mode: str) -> str:
+    i_axis = 0 if mode == 'ra' else 1
+    s = 'h' if mode == 'ra' else 'd'
+    return coord.split(' ')[i_axis].split(s)[1].split('m')[0]
+
+
+def _get_hmdm(coord: str, mode: str) -> str:
+    i_axis = 0 if mode == 'ra' else 1
+    return coord.split(' ')[i_axis].split('m')[0] + 'm'
+
+
+def _get_gridwidth(mode: str, rmax: float) -> tuple[float, int]:
+    # 10^1.5 / 15 ~ 2 grids for R.A.
+    # 10^0.5 ~ 3 grids for Dec.
+    scale = 1.5 if mode == 'ra' else 0.5
+    log2r = np.log10(2. * rmax)
+    x = log2r - scale
+    order = np.floor(x)
+    frac = x - order
+    if frac <= 0.33:
+        base = 1
+    elif frac <= 0.68:
+        base = 2
+    else:
+        base = 5
+    return base * 10**order, int(order)
+
+
 @dataclass
 class Stretcher():
     """Arguments and methods related to the stretch in PlotAstroData.add_color() and add_rgb().
@@ -1057,86 +1090,71 @@ class PlotAstroData(AstroFrame):
             center = '00h00m00s 00d00m00s'
         if len(csplit := center.split()) == 3:
             center = f'{csplit[1]} {csplit[2]}'
-
-        def get_sec(x, i):
-            return x.split(' ')[i].split('m')[1].strip('s')
-
-        def get_min(x, i):
-            s = 'h' if i == 0 else 'd'
-            return x.split(' ')[i].split(s)[1].split('m')[0]
-
-        def get_hmdm(x, i):
-            return x.split(' ')[i].split('m')[0] + 'm'
-
-        on_min_scale = self.rmax >= 60.0
-        if on_min_scale:
-            ra_s = np.floor(float(get_sec(center, 0)) / 5) * 5
+        if on_min_scale := (self.rmax >= 60.0):
+            # On a 5-second grid.
+            ra_s = np.floor(float(_get_sec(center, 0)) / 5) * 5
             dec_s = 0.0
-            ra = get_hmdm(center, 0) + f'{ra_s:.1f}s'
-            dec = get_hmdm(center, 1) + f'{dec_s:.1f}s'
+            ra = _get_hmdm(center, 'ra') + f'{ra_s:.1f}s'
+            dec = _get_hmdm(center, 'dec') + f'{dec_s:.1f}s'
             center = f'{ra} {dec}'
 
-        dec = np.radians(coord2xy(center)[1])
-        log2r = np.log10(2. * self.rmax)
-        n = np.array([-3, -2, -1, 0, 1, 2, 3])
-
-        def makegrid(second, mode):
-            second = float(second)
-            is_dec = mode == 'dec'
-            scale = 0.5 if is_dec else 1.5
-            factor = 1 if is_dec else 15 * np.cos(dec)
-            no_sec = on_min_scale and is_dec
-            if no_sec:
-                unit = r'$^{\prime}$' if is_dec else r'$^\mathrm{m}$'
-            else:
-                unit = r'$^{\prime\prime}$' if is_dec else r'$^\mathrm{s}$'
-                unit = r'.$\hspace{-0.4}$' + unit
-            dorder = log2r - scale - (order := np.floor(log2r - scale))
-            if 0.00 < dorder <= 0.33:
-                g = 1
-            elif 0.33 < dorder <= 0.68:
-                g = 2
-            elif 0.68 < dorder <= 1.00:
-                g = 5
-            g *= 10**order
-            decimals = max(-int(order), -1)
-            rounded = round(second, decimals)
-            lastdigit = round(rounded // 10**(-decimals-1) % 100 / 10) % 10
-            rounded -= lastdigit * 10**(-decimals) % g
-            ticks = (n*g - second + rounded) * factor
-            ticksminor = np.linspace(ticks[0], ticks[-1], 6*nticksminor + 1)
-            decimals = max(decimals, 0)
-            decimals = f'{decimals:d}'
+        def get_tickvalues(ticks: np.ndarray, mode: str, no_sec: bool
+                           ) -> np.ndarray:
+            xy = [np.zeros_like(ticks), ticks / 3600.]
             if mode == 'ra':
-                xy, i = [ticks / 3600., ticks * 0], 0
-            else:
-                xy, i = [ticks * 0, ticks / 3600.], 1
+                xy.reverse()
             tickvalues = xy2coord(xy, center)
-            _get = get_min if no_sec else get_sec
-            tickvalues = np.array([float(_get(t, i)) for t in tickvalues])
-            tickvalues = np.divmod(tickvalues + 1e-7, 1)
-            tickvalues = (tickvalues[0] % 60, tickvalues[1])
-            ticklabels = [f'{int(i):02d}{unit}' + f'{j:.{decimals}f}'[2:]
-                          for i, j in zip(*tickvalues)]
+            getter = _get_min if no_sec else _get_sec
+            tickvalues = [getter(t, mode) for t in tickvalues]  # str
+            tickvalues = np.array(tickvalues, dtype=float)
+            # 7-digit precision for practical use.
+            tickvalues = np.round(tickvalues, 7)
+            return tickvalues
+
+        units = {'ra': {'h': r'$^\mathrm{h}$',
+                        'm': r'$^\mathrm{m}$',
+                        's': r'.$\hspace{-0.4}^\mathrm{s}$'},
+                 'dec': {'d': r'$^{\circ}$',
+                         'm': r'$^{\prime}$',
+                         's': r'.$\hspace{-0.4}^{\prime\prime}$'}}
+        cos_dec = np.cos(np.radians(coord2xy(center)[1]))
+        intgrid = np.array([-3, -2, -1, 0, 1, 2, 3])
+        i_mid = (len(intgrid) - 1) // 2
+
+        def makegrid(mode: str):
+            second = float(_get_sec(center, mode))
+            no_sec = on_min_scale and (mode == 'dec')
+            # gridwidth is a float like 2 x 10^order (arcsec).
+            gridwidth, order = _get_gridwidth(mode, self.rmax)
+            # ndigits = -1 is the largest case for 10", 20", ...
+            decimals = str(max(-order, 0))
+            rounded = round(second, ndigits=max(-order, -1))
+            # Get a grid point closest to the input second.
+            rounded = round(rounded / gridwidth) * gridwidth
+            factor = 15 * cos_dec if mode == 'ra' else 1
+            ticks = (intgrid * gridwidth - second + rounded) * factor
+            ticksminor = np.linspace(ticks[0], ticks[-1], 6*nticksminor + 1)
+            tickvalues = get_tickvalues(ticks, mode, no_sec)
+            whole, frac = np.divmod(tickvalues, 1)
+            u = units[mode]['m' if no_sec else 's']
+            ticklabels = [f'{int(i):02d}{u}' + f'{j:.{decimals}f}'[2:]
+                          for i, j in zip(whole % 60, frac)]
             return ticks, ticksminor, ticklabels
 
-        ra_s = get_sec(center, 0)
-        dec_s = get_sec(center, 1)
-        xticks, xticksminor, xticklabels = makegrid(ra_s, 'ra')
-        yticks, yticksminor, yticklabels = makegrid(dec_s, 'dec')
-        ra_hm = get_hmdm(xy2coord([xticks[3] / 3600., 0], center), 0)
-        dec_dm = get_hmdm(xy2coord([0, yticks[3] / 3600.], center), 1)
+        xticks, xticksminor, xticklabels = makegrid('ra')
+        yticks, yticksminor, yticklabels = makegrid('dec')
+        ra_hm = _get_hmdm(xy2coord([xticks[i_mid] / 3600., 0], center), 'ra')
+        dec_dm = _get_hmdm(xy2coord([0, yticks[i_mid] / 3600.], center), 'dec')
         if on_min_scale:
             dec_dm = dec_dm.split('d')[0] + 'd'
-        trans = {'h': r'$^\mathrm{h}$', 'm': r'$^\mathrm{m}$'}
-        ra_hm = ra_hm.translate(str.maketrans(trans))
-        trans = {'d': r'$^{\circ}$', 'm': r'$^{\prime}$'}
-        dec_dm = dec_dm.translate(str.maketrans(trans))
-        xticklabels[3] = ra_hm + xticklabels[3]
-        yticklabels[3] = dec_dm + '\n' + yticklabels[3]
-        pa2 = PlotAxes2D(True, None, 'linear', 'linear', self.Xlim, self.Ylim,
-                         xlabel, ylabel, xticks, yticks, xticklabels,
-                         yticklabels, xticksminor, yticksminor, grid)
+        ra_hm = ra_hm.translate(str.maketrans(units['ra']))
+        dec_dm = dec_dm.translate(str.maketrans(units['dec']))
+        xticklabels[i_mid] = ra_hm + xticklabels[i_mid]
+        yticklabels[i_mid] = dec_dm + '\n' + yticklabels[i_mid]
+        pa2 = PlotAxes2D(True, None, 'linear', 'linear',
+                         self.Xlim, self.Ylim, xlabel, ylabel,
+                         xticks, yticks, xticklabels, yticklabels,
+                         xticksminor, yticksminor, grid)
         self._set_axis_shared(pa2=pa2, title=title)
 
     def savefig(self, filename: str | None = None,

{plotastrodata-1.8.15 → plotastrodata-1.8.17/plotastrodata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.15
+Version: 1.8.17
 Summary: plotastrodata is a tool for astronomers to create figures from FITS files and perform fundamental data analyses with ease.
 Home-page: https://github.com/yusukeaso-astron/plotastrodata
 Download-URL: https://github.com/yusukeaso-astron/plotastrodata