plotastrodata 1.8.16__tar.gz → 1.8.18__tar.gz

{plotastrodata-1.8.16/plotastrodata.egg-info → plotastrodata-1.8.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.16
+Version: 1.8.18
 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.16 → plotastrodata-1.8.18}/plotastrodata/__init__.py

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

{plotastrodata-1.8.16 → plotastrodata-1.8.18}/plotastrodata/analysis_utils.py

@@ -7,11 +7,12 @@ 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, gaussian2d,
-                                         gaussfit1d, gaussfit2d)
+from plotastrodata.fitting_utils import (EmceeCorner, gaussfit1d,
+                                         gaussfit2d, gaussian2d)
 from plotastrodata.matrix_utils import dot2d, Mfac, Mrot
 from plotastrodata.noise_utils import estimate_rms
-from plotastrodata.other_utils import isdeg, RGIxy, RGIxyv, to4dim, trim
+from plotastrodata.other_utils import (isdeg, nearest_index,
+                                       RGIxy, RGIxyv, to4dim, trim)
 
 
 def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
@@ -197,10 +198,10 @@ class AstroData():
             includev (bool, optional): Centering in the v direction at each position. Defaults to False.
         """
         if includexy:
-            xnew = self.x - self.x[np.argmin(np.abs(self.x))]
-            ynew = self.y - self.y[np.argmin(np.abs(self.y))]
+            xnew = self.x - self.x[nearest_index(self.x)]
+            ynew = self.y - self.y[nearest_index(self.y)]
         if includev:
-            vnew = self.v - self.v[np.argmin(np.abs(self.v))]
+            vnew = self.v - self.v[nearest_index(self.v)]
         if includexy and includev:
             self.data = RGIxyv(self.v, self.y, self.x, self.data,
                                np.meshgrid(vnew, ynew, xnew, indexing='ij'),
@@ -518,10 +519,10 @@ class AstroData():
         """
         fhd = self.fitsheader
         h = {}
-        ci = np.argmin(np.abs(self.x))
+        ci = nearest_index(self.x)
         cx = 0
         if not self.pv:
-            cj = np.argmin(np.abs(self.y))
+            cj = nearest_index(self.y)
             if self.center is None:
                 cx, cy = self.x[ci], self.x[cj]
             else:
@@ -538,7 +539,7 @@ class AstroData():
         h['CDELT1'] = float(self.dx / (3600 if indeg('1') else 1))
         if self.dv is not None:
             vaxis = '2' if self.pv else '3'
-            ck = np.argmin(np.abs(self.v))
+            ck = nearest_index(self.v)
             cv = self.v[ck]
             dv = self.dv
             if self.restfreq is None or self.restfreq == 0:

{plotastrodata-1.8.16 → plotastrodata-1.8.18}/plotastrodata/coord_utils.py

@@ -149,3 +149,46 @@ def abs2rel(xabs: float, yabs: float,
     xrel = (xabs - x[0]) / (x[-1] - x[0])
     yrel = (yabs - y[0]) / (y[-1] - y[0])
     return np.array([xrel, yrel])
+
+
+def get_sec(coord: str, mode: str) -> str:
+    """Pick up the second number from a hmsdms string.
+
+    Args:
+        coord (str): hmsdms string.
+        mode (str): 'ra' or 'dec'
+
+    Returns:
+        str: The second number as a string without the unit.
+    """
+    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:
+    """Pick up the minute number from a hmsdms string.
+
+    Args:
+        coord (str): hmsdms string.
+        mode (str): 'ra' or 'dec'
+
+    Returns:
+        str: The minute number as a string without the unit.
+    """
+    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:
+    """Pick up the coordinate string before the second part from a hsmdms string.
+
+    Args:
+        coord (str): hmsdms string.
+        mode (str): 'ra' or 'dec'
+
+    Returns:
+        str: The hm or dm string with the units.
+    """
+    i_axis = 0 if mode == 'ra' else 1
+    return coord.split(' ')[i_axis].split('m')[0] + 'm'

{plotastrodata-1.8.16 → plotastrodata-1.8.18}/plotastrodata/other_utils.py

@@ -1,5 +1,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
+import warnings
 from scipy.interpolate import RegularGridInterpolator as RGI
 
 
@@ -33,6 +34,20 @@ def isdeg(s: str) -> bool:
         return False
 
 
+def nearest_index(arr: np.ndarray, x: float = 0) -> int:
+    """Get the index of the (sorted) arrary that gives a value nearest to x. This is equivalent to np.argmin(np.abs(arr - x)) but optimized for the sorted array.
+
+    Args:
+        arr (np.ndarray): Sorted array.
+        x (float, optional): Value to approach. Defaults to 0.
+
+    Returns:
+        int: The index that gives a value nearest to x.
+    """
+    idx = np.searchsorted(arr, x).clip(1, len(arr) - 1)
+    return idx - 1 if x - arr[idx - 1] <= arr[idx] - x else idx
+
+
 def trim(data: np.ndarray | None = None, x: np.ndarray | None = None,
          y: np.ndarray | None = None, v: np.ndarray | None = None,
          xlim: list[float] | None = None,
@@ -57,8 +72,8 @@ def trim(data: np.ndarray | None = None, x: np.ndarray | None = None,
     def get_bounds(arr, lim):
         if arr is None or lim is None or None in lim:
             return arr, 0, None
-        lo = np.argmin(np.abs(arr - max(np.min(arr), lim[0])))
-        hi = np.argmin(np.abs(arr - min(np.max(arr), lim[1])))
+        lo = nearest_index(arr, max(np.min(arr), lim[0]))
+        hi = nearest_index(arr, min(np.max(arr), lim[1]))
         lo, hi = sorted((lo, hi))
         return arr[lo:hi + 1], lo, hi + 1
 
@@ -106,6 +121,101 @@ def to4dim(data: np.ndarray) -> np.ndarray:
     return d
 
 
+def reform_grid(v: np.ndarray | None = None,
+                k0: int | None = None, k1: int | None = None,
+                vmin: float | None = None, vmax: float | None = None
+                ) -> np.ndarray:
+    """Extend or cut the given 1D array based on the given range.
+
+    Args:
+        v (np.ndarray | None, optional): Input 1D array. Defaults to None.
+        k0 (int | None, optional): How many channels are added before v[0]; the minus sign means extension. k0 has the priority over vmin. Defaults to None.
+        k1 (int | None, optional): How many channels are added after v[-1]; the plus sign means extension. k1 has the priority over vmax. Defaults to None.
+        vmin (float | None, optional): New minimum velocity. Defaults to None.
+        vmax (float | None, optional): New maximum velocity. Defaults to None.
+
+    Returns:
+        np.ndarray: Extended or cut 1D array.
+    """
+    if v is None or len(v) <= 1:
+        return v
+
+    dv = v[1] - v[0]
+    if k0 is None and vmin is not None:
+        k0 = int(round((vmin - v[0]) / dv))
+    if k0 is not None and k0 != 0:
+        if k0 < 0:
+            vpre = v[0] + dv * np.arange(k0, 0)
+            v = np.concatenate((vpre, v))
+        else:
+            v = v[k0:]
+    if k1 is None and vmax is not None:
+        k1 = int(round((vmax - v[-1]) / dv))
+    if k1 is not None and k1 != 0:
+        if k1 > 0:
+            vpost = v[-1] + dv * np.arange(1, k1 + 1)
+            v = np.concatenate((v, vpost))
+        else:
+            v = v[:len(v) + k1]
+    return v
+
+
+def reform_data(c: np.ndarray, v_in: np.ndarray | None,
+                nv: int, v_org: np.ndarray | None = None,
+                vskip: int = 1) -> np.ndarray:
+    """Skip and fill channels with nan.
+
+    Args:
+        c (np.ndarray): The input 2D or 3D arrays.
+        v_in (np.ndarray): The input velocity 1D array.
+        nv (int): The number of channels with a label.
+        v (np.ndarray, optional): The velocity 1D array, including the channels with and without a label. Defaults to None.
+        vskip (int, optional): How many channels are skipped. Defaults to 1.
+
+    Returns:
+        np.ndarray: 3D arrays skipped and filled with nan.
+    """
+    if v_org is None:
+        return c
+
+    ndim = np.ndim(c)
+    if ndim not in [2, 3]:
+        print('c must be 2D or 3D.')
+        return
+
+    if ndim == 2:
+        d = np.full((nv, *np.shape(c)), c)
+    elif v_in is not None:
+        dv_org = v_org[1] - v_org[0]
+        dv_in = (v_in[1] - v_in[0]) * vskip
+        k0 = nearest_index(v_org, v_in[0])
+        k1 = nearest_index(v_org, v_in[-1])
+        if np.abs(dv_in - dv_org) / dv_org < 0.01:
+            d = c
+        else:
+            s = 'Velocity resolution mismatch (>1%).' \
+                + ' The cube needs to be regridded' \
+                + ' outside plotastrodata.'
+            warnings.warn(s, UserWarning)
+            n_valid = k1 - k0
+            d = [None] * n_valid
+            for k in range(n_valid):
+                k_tmp = nearest_index(v_in, v_org[k])
+                diffvel = np.abs(v_in[k_tmp] - v_org[k])
+                nearby = diffvel < dv_org * 0.5
+                d[k] = c[k_tmp] if nearby else c[0] * np.nan
+            d = np.array(d)
+        if k0 > 0:
+            prenan = np.full((k0, *np.shape(d)[1:]), np.nan)
+            d = np.concatenate((prenan, d))
+        d = d[::vskip]
+    shape = np.shape(d)
+    shape = (len(v_org) - shape[0], shape[1], shape[2])
+    postnan = np.full(shape, np.nan)
+    d = np.concatenate((d, postnan))
+    return d
+
+
 def RGIxy(y: np.ndarray, x: np.ndarray, data: np.ndarray,
           yxnew: tuple[np.ndarray, np.ndarray] | None = None,
           **kwargs) -> object | np.ndarray:

{plotastrodata-1.8.16 → plotastrodata-1.8.18}/plotastrodata/plot_utils.py

@@ -1,15 +1,16 @@
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 import numpy as np
-import warnings
 from dataclasses import dataclass
 from matplotlib.patches import Ellipse, Rectangle
 from typing import TypeVar
 
 from plotastrodata.analysis_utils import AstroData, AstroFrame
-from plotastrodata.coord_utils import coord2xy, xy2coord
+from plotastrodata.coord_utils import (coord2xy, xy2coord,
+                                       get_hmdm, get_min, get_sec)
 from plotastrodata.noise_utils import estimate_rms
-from plotastrodata.other_utils import close_figure, listing
+from plotastrodata.other_utils import (close_figure, listing,
+                                       reform_grid, reform_data)
 
 
 plt.ioff()  # force to turn off interactive mode
@@ -99,6 +100,89 @@ def logcbticks(vmin: float = 1e-3, vmax: float = 1e3
     return ticks[cond], ticklabels[cond]
 
 
+def get_figsize(xmin: float, xmax: float, ymin: float, ymax: float,
+                figsize: tuple | None = None,
+                ncols: int = 1, nrows: int = 1, nchan: int = 1
+                ) -> tuple[float, float]:
+    """Get a nice figsize (tuple) with the given x and y ranges.
+
+    Args:
+        xmin (float): The figsize is based on the aspect ratio of (ymax - ymin) / (xmax - xmin).
+        xmax (float): The figsize is based on the aspect ratio of (ymax - ymin) / (xmax - xmin).
+        ymin (float): The figsize is based on the aspect ratio of (ymax - ymin) / (xmax - xmin).
+        ymax (float): The figsize is based on the aspect ratio of (ymax - ymin) / (xmax - xmin).
+        figsize (tuple | None, optional): If this is not None, this will be the output as is. Defaults to None.
+        ncols (int, optional): The number of columns for the channel map. Defaults to 1.
+        nrows (int, optional): The number of rows for the channel map. Defaults to 1.
+        nchan (int, optional): The number of total channels for the channel map. Defaults to 1.
+
+    Returns:
+        tuple[float, float]: figsize for matplotlib.pyplot.Figure.
+    """
+    if figsize is not None:
+        return figsize
+
+    sqrt_a = (ymax - ymin) / (xmax - xmin)
+    sqrt_a = np.sqrt(np.abs(sqrt_a))
+    if nchan == 1:
+        figsize = (7 / sqrt_a, 5 * sqrt_a)
+    else:
+        figsize = (ncols * 2 / sqrt_a, max(nrows*2, 3) * sqrt_a)
+    return figsize
+
+
+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
+    x = np.log10(2. * rmax) - 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)
+
+
+def _get_v(p, v: np.ndarray | None = None,
+           restfreq: float | None = None,
+           vskip: int = 1) -> np.ndarray:
+    if p.fitsimage is not None:
+        p.read(d := AstroData(fitsimage=p.fitsimage,
+                              restfreq=restfreq, sigma=None))
+        v = d.v
+    if v is None:
+        v = np.array([0])
+    if len(v) > 1:
+        v = reform_grid(v=v, vmin=p.vmin, vmax=p.vmax)
+        v = v[::vskip]
+    return v
+
+
+def _get_nij2ch(nrows: int = 1, ncols: int = 1) -> object:
+    def nij2ch(n: int, i: int, j: int) -> int:
+        return n*nrows*ncols + i*ncols + j
+    return nij2ch
+
+
+def _get_ch2nij(nrows: int = 1, ncols: int = 1) -> object:
+    def ch2nij(ch: int) -> tuple[int, int, int]:
+        n = ch // (nrows*ncols)
+        i = (ch - n*nrows*ncols) // ncols
+        j = ch % ncols
+        return n, i, j
+    return ch2nij
+
+
+def _get_vskipfill(nv: float, v_org: np.ndarray, vskip: int) -> object:
+    def vskipfill(c: np.ndarray, v_in: np.ndarray) -> np.ndarray:
+        return reform_data(c=c, v_in=v_in, nv=nv, v_org=v_org, vskip=vskip)
+    return vskipfill
+
+
 @dataclass
 class Stretcher():
     """Arguments and methods related to the stretch in PlotAstroData.add_color() and add_rgb().
@@ -383,7 +467,7 @@ class PlotAstroData(AstroFrame):
     kwargs is the arguments of AstroFrame to define plotting ranges.
 
     Args:
-        v (np.ndarray, optional): Used to set up channels if fitsimage not given. Defaults to [0].
+        v (np.ndarray, optional): Used to set up channels if fitsimage not given. Defaults to None.
         vskip (int, optional): How many channels are skipped. Defaults to 1.
         veldigit (int, optional): How many digits after the decimal point. Defaults to 2.
         restfreq (float, optional): Used for velocity and brightness T. Defaults to None.
@@ -398,7 +482,7 @@ class PlotAstroData(AstroFrame):
         ax (optional): External fig.add_subplot(). Defaults to None.
     """
     def __init__(self,
-                 v: np.ndarray = np.array([0]), vskip: int = 1,
+                 v: np.ndarray | None = None, vskip: int = 1,
                  veldigit: int = 2, restfreq: float | None = None,
                  channelnumber: int | None = None,
                  nrows: int = 4, ncols: int = 6,
@@ -410,74 +494,42 @@ class PlotAstroData(AstroFrame):
         super().__init__(**kwargs)
         internalfig = fig is None
         internalax = ax is None
-        if type(channelnumber) is int:
-            nrows = ncols = 1
-        if self.fitsimage is not None:
-            self.read(d := AstroData(fitsimage=self.fitsimage,
-                                     restfreq=restfreq, sigma=None))
-            v = d.v
-        if len(v) > 1:
-            dv = v[1] - v[0]
-            k0 = int(round((self.vmin - v[0]) / dv))
-            if k0 < 0:
-                vpre = v[0] - (1 + np.arange(-k0)[::-1]) * dv
-                v = np.append(vpre, v)
-            else:
-                v = v[k0:]
-            k1 = len(v) + int(round((self.vmax - v[-1]) / dv))
-            if k1 > len(v):
-                vpost = v[-1] + (1 + np.arange(k1 - len(v))) * dv
-                v = np.append(v, vpost)
-            else:
-                v = v[:k1]
-        if self.pv or v is None or len(v) == 1:
-            nv = nrows = ncols = npages = nchan = 1
+        v = _get_v(p=self, v=v, restfreq=restfreq, vskip=vskip)
+        nv = len(v)  # number of channels with a label
+        if self.pv or len(v) == 1 or channelnumber is not None:
+            nrows = ncols = npages = nchan = 1
         else:
-            nv = len(v := v[::vskip])
             npages = int(np.ceil(nv / nrows / ncols))
             nchan = npages * nrows * ncols
-            v = np.r_[v, v[-1] + (np.arange(nchan - nv) + 1) * dv]
-            if type(channelnumber) is int:
-                nchan = npages = 1
-
-        def nij2ch(n: int, i: int, j: int):
-            return n*nrows*ncols + i*ncols + j
-
-        def ch2nij(ch: int) -> tuple:
-            n = ch // (nrows*ncols)
-            i = (ch - n*nrows*ncols) // ncols
-            j = ch % ncols
-            return n, i, j
-
+            v = reform_grid(v, k1=nchan - nv)
+        nij2ch = _get_nij2ch(nrows=nrows, ncols=ncols)
+        ch2nij = _get_ch2nij(nrows=nrows, ncols=ncols)
         if fontsize is None:
             fontsize = 18 if nchan == 1 else 12
         set_rcparams(fontsize=fontsize, nancolor=nancolor, dpi=dpi)
-        ax = np.empty(nchan, dtype='object') if internalax else [ax]
-        if figsize is None:
-            sqrt_a = (self.ymax - self.ymin) / (self.xmax - self.xmin)
-            sqrt_a = np.sqrt(np.abs(sqrt_a))
-            if nchan == 1:
-                figsize = (7 / sqrt_a, 5 * sqrt_a)
-            else:
-                figsize = (ncols * 2 / sqrt_a, max(nrows*2, 3) * sqrt_a)
+        ax = np.empty(nchan, dtype=object) if internalax else [ax]
+        figsize = get_figsize(xmin=self.xmin, xmax=self.xmax,
+                              ymin=self.ymin, ymax=self.ymax,
+                              figsize=figsize,
+                              ncols=ncols, nrows=nrows, nchan=nchan)
+        need_vlabel = nchan > 1 or type(channelnumber) is int
         for ch in range(nchan):
             n, i, j = ch2nij(ch)
             if internalfig and n not in plt.get_fignums():
                 fig = plt.figure(n, figsize=figsize)
-            sharex = ax[nij2ch(n, i - 1, j)] if i > 0 else None
-            sharey = ax[nij2ch(n, i, j - 1)] if j > 0 else None
+                if need_vlabel:
+                    fig.subplots_adjust(hspace=0, wspace=0,
+                                        right=0.87, top=0.87)
             if internalax:
+                sharex = ax[nij2ch(n, i - 1, j)] if i > 0 else None
+                sharey = ax[nij2ch(n, i, j - 1)] if j > 0 else None
                 ax[ch] = fig.add_subplot(nrows, ncols, i*ncols + j + 1,
                                          sharex=sharex, sharey=sharey)
-            if nchan > 1 or type(channelnumber) is int:
-                fig.subplots_adjust(hspace=0, wspace=0, right=0.87, top=0.87)
-                if ch < nv:
-                    chnum = channelnumber
-                    vellabel = v[ch if chnum is None else chnum]
-                    vd = f'{veldigit:d}'
-                    ax[ch].text(0.9 * self.rmax, 0.7 * self.rmax,
-                                rf'${vellabel:.{vd}f}$', color='black',
-                                backgroundcolor='white', zorder=20)
+            if need_vlabel and ch < nv:
+                vlabel = v[channelnumber or ch]
+                ax[ch].text(0.9 * self.rmax, 0.7 * self.rmax,
+                            rf'${vlabel:.{veldigit}f}$', color='black',
+                            backgroundcolor='white', zorder=20)
         self.fig = None if internalfig else fig
         self.ax = ax
         self.rowcol = nrows * ncols
@@ -486,55 +538,7 @@ class PlotAstroData(AstroFrame):
         self.bottomleft = nij2ch(np.arange(npages), nrows - 1, 0)
         self.channelnumber = channelnumber
         self.v = v
-
-        def vskipfill(c: np.ndarray,
-                      v_in: np.ndarray | None = None
-                      ) -> np.ndarray:
-            """Skip and fill channels with nan.
-
-            Args:
-                c (np.ndarray): 2D or 3D arrays.
-                v_in (np.ndarray): 1D array.
-
-            Returns:
-                np.ndarray: 3D arrays skipped and filled with nan.
-            """
-            if np.ndim(c) == 2:
-                d = np.full((nv, *np.shape(c)), c)
-            elif np.ndim(c) == 3:
-                if v_in is not None:
-                    dv_org = self.v[1] - self.v[0]
-                    dv_in = (v_in[1] - v_in[0]) * vskip
-                    k0 = np.argmin(np.abs(self.v - v_in[0]))
-                    k1 = np.argmin(np.abs(self.v - v_in[-1]))
-                    if np.abs(dv_in - dv_org) / dv_org < 0.01:
-                        d = c
-                    else:
-                        s = 'Velocity resolution mismatch (>1%).' \
-                            + ' The cube needs to be regridded' \
-                            + ' outside plotastrodata.'
-                        warnings.warn(s, UserWarning)
-                        n_valid = k1 - k0
-                        d = [None] * n_valid
-                        for k in range(n_valid):
-                            k_tmp = np.argmin(np.abs(v_in - self.v[k]))
-                            diffvel = np.abs(v_in[k_tmp] - self.v[k])
-                            nearby = diffvel < dv_org * 0.5
-                            d[k] = c[k_tmp] if nearby else c[0] * np.nan
-                        d = np.array(d)
-                    if k0 > 0:
-                        prenan = np.full((k0, *np.shape(d)[1:]), np.nan)
-                        d = np.append(prenan, d, axis=0)
-                d = d[::vskip]
-            else:
-                print('c must be 2D or 3D.')
-                return
-            n = nchan if channelnumber is None else nv
-            shape = (n - len(d), len(d[0]), len(d[0, 0]))
-            postnan = np.full(shape, d[0] * np.nan)
-            d = np.append(d, postnan, axis=0)
-            return d
-        self.vskipfill = vskipfill
+        self.vskipfill = _get_vskipfill(nv=nv, v_org=v, vskip=vskip)
 
     def _map_init(self, kw: dict) -> tuple:
         """
@@ -1057,86 +1061,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:
+        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.16 → plotastrodata-1.8.18/plotastrodata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.16
+Version: 1.8.18
 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