plotastrodata 1.8.17__tar.gz → 1.9.0__tar.gz

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

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

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

{plotastrodata-1.8.17 → plotastrodata-1.9.0}/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.17 → plotastrodata-1.9.0}/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.17 → plotastrodata-1.9.0}/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.17 → plotastrodata-1.9.0}/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,28 +100,42 @@ 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_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.
 
-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]
-
+    Returns:
+        tuple[float, float]: figsize for matplotlib.pyplot.Figure.
+    """
+    if figsize is not None:
+        return figsize
 
-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'
+    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
-    log2r = np.log10(2. * rmax)
-    x = log2r - scale
+    # 10^1.45 / 15 ~ 2 grids for R.A.
+    # 10^0.45 ~ 3 grids for Dec.
+    scale = 1.45 if mode == 'ra' else 0.45
+    x = np.log10(2. * rmax) - scale
     order = np.floor(x)
     frac = x - order
     if frac <= 0.33:
@@ -132,6 +147,42 @@ def _get_gridwidth(mode: str, rmax: float) -> tuple[float, int]:
     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().
@@ -171,43 +222,51 @@ class Stretcher():
             getsigma = (islog + ispower) * novmin
             self.vmin = np.where(getsigma, sigma, vmin)
 
-    def do(self, x: list | np.ndarray) -> np.ndarray:
+    def do(self, x: list | np.ndarray, i: int = 0) -> np.ndarray:
         """Get the stretched values.
 
         Args:
             x (list | np.ndarray): Input array in the linear scale.
+            i (int): Which element is used in the case where the stretch parameters are lists.
 
         Returns:
             np.ndarray: Output stretched array.
         """
+        st = self.stretch[i] if self.n > 1 else self.stretch
+        stsc = self.stretchscale[i] if self.n > 1 else self.stretchscale
+        stpw = self.stretchpower[i] if self.n > 1 else self.stretchpower
         t = np.array(x)
-        match self.stretch:
+        match st:
             case 'log':
                 t = np.log10(t)  # To be consistent with logcbticks().
             case 'asinh':
-                t = np.arcsinh(t / self.stretchscale)
+                t = np.arcsinh(t / stsc)
             case 'power':
-                p = 1e-6 if self.stretchpower == 0 else self.stretchpower
+                p = 1e-6 if stpw == 0 else stpw
                 t = t**p / p
         return t
 
-    def undo(self, x: list | np.ndarray) -> np.ndarray:
+    def undo(self, x: list | np.ndarray, i: int = 0) -> np.ndarray:
         """Get the linear values from the stretched values.
 
         Args:
             x (list | np.ndarray): Input stretched array.
+            i (int): Which element is used in the case where the stretch parameters are lists.
 
         Returns:
             np.ndarray: Output array in the linear scale.
         """
+        st = self.stretch[i] if self.n > 1 else self.stretch
+        stsc = self.stretchscale[i] if self.n > 1 else self.stretchscale
+        stpw = self.stretchpower[i] if self.n > 1 else self.stretchpower
         t = np.array(x)
-        match self.stretch:
+        match st:
             case 'log':
                 t = 10**t  # To be consistent with logcbticks().
             case 'asinh':
-                t = np.sinh(t) * self.stretchscale
+                t = np.sinh(t) * stsc
             case 'power':
-                p = 1e-6 if self.stretchpower == 0 else self.stretchpower
+                p = 1e-6 if stpw == 0 else stpw
                 t = (t * p)**(1 / p)
         return t
 
@@ -226,7 +285,7 @@ class Stretcher():
         vmaxout = [self.vmax] if single else self.vmax
         dataout = [data] if single else data
         for i, (c, v0, v1) in enumerate(zip(dataout, vminout, vmaxout)):
-            dataout[i] = cout = self.do(c.clip(v0, v1))
+            dataout[i] = cout = self.do(c.clip(v0, v1), i)
             vminout[i] = np.nanmin(cout)
             vmaxout[i] = np.nanmax(cout)
         if single:
@@ -377,7 +436,7 @@ def kwargs2instance(cls: type[T], kw: dict) -> T:
 
     Args:
         cls (class): Class to make the instance.
-        kw (dict): Parameters to make Stretcher.
+        kw (dict): Parameters to make the instance.
 
     Returns:
         instance: an instance of cls made from the parameters in kwargs.
@@ -416,7 +475,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.
@@ -431,7 +490,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,
@@ -443,74 +502,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
@@ -519,55 +546,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:
         """
@@ -816,7 +795,9 @@ class PlotAstroData(AstroFrame):
     def _set_colorbar(self, mappable, ch: int, show_cbar: bool,
                       cblabel: str, cbformat: str,
                       cbticks: list | None, cbticklabels: list | None,
-                      cblocation: str, st: Stretcher):
+                      cblocation: str,
+                      cblabelfontsize: int, cbtickfontsize: int,
+                      st: Stretcher):
         if not show_cbar:
             return
 
@@ -832,8 +813,8 @@ class PlotAstroData(AstroFrame):
             cax = plt.axes([0.88, 0.105, 0.015, 0.77])
             cb = fig.colorbar(mappable[ch], cax=cax, label=cblabel,
                               format=cbformat)
-        cb.ax.tick_params(labelsize=14)
-        font = mpl.font_manager.FontProperties(size=16)
+        cb.ax.tick_params(labelsize=cbtickfontsize)
+        font = mpl.font_manager.FontProperties(size=cblabelfontsize)
         cb.ax.yaxis.label.set_font_properties(font)
         if cbticks is None and st.stretch == 'log':
             cbticks, cbticklabels = logcbticks(10**st.vmin, 10**st.vmax)
@@ -854,6 +835,8 @@ class PlotAstroData(AstroFrame):
                   cbticks: list[float] | None = None,
                   cbticklabels: list[str] | None = None,
                   cblocation: str = 'right',
+                  cblabelfontsize: int = 16,
+                  cbtickfontsize: int = 14,
                   **kwargs) -> None:
         """Use Axes.pcolormesh of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include the arguments for Stretcher (stretch, stretchscale, and stretchpower) to specify the stretch parameters. kwargs may include arguments of Beam; a dict of beam_kwargs specifies the beam patch in more detail. kwargs may include xskiip and yskip.
 
@@ -864,6 +847,8 @@ class PlotAstroData(AstroFrame):
             cbticks (list, optional): Ticks of colorbar. Defaults to None.
             cbticklabels (list, optional): Ticklabels of colorbar. Defaults to None.
             cblocation (str, optional): 'left', 'top', 'left', 'right'. Only for 2D images. Defaults to 'right'.
+            cblabelfontsize (int, optional): Fontsize for the colorbar label. This is independent of set_rcparams().
+            cbtickfontsize (int, optional): Fontsize for the colorbar ticks. This is independent of set_rcparams().
         """
         self._kw = {'cmap': 'cubehelix', 'alpha': 1,
                     'edgecolors': 'none', 'zorder': 1,
@@ -890,7 +875,8 @@ class PlotAstroData(AstroFrame):
                 p[ch] = pnow
         for ch in self.bottomleft:
             self._set_colorbar(p, ch, show_cbar, cblabel, cbformat,
-                               cbticks, cbticklabels, cblocation, st)
+                               cbticks, cbticklabels, cblocation,
+                               cblabelfontsize, cbtickfontsize, st)
 
     def add_contour(self,
                     levels: list[float] = [-12, -6, -3, 3, 6, 12, 24, 48, 96, 192, 384],
@@ -1092,10 +1078,10 @@ class PlotAstroData(AstroFrame):
             center = f'{csplit[1]} {csplit[2]}'
         if on_min_scale := (self.rmax >= 60.0):
             # On a 5-second grid.
-            ra_s = np.floor(float(_get_sec(center, 0)) / 5) * 5
+            ra_s = np.floor(float(get_sec(center, 0)) / 5) * 5
             dec_s = 0.0
-            ra = _get_hmdm(center, 'ra') + f'{ra_s:.1f}s'
-            dec = _get_hmdm(center, 'dec') + 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}'
 
         def get_tickvalues(ticks: np.ndarray, mode: str, no_sec: bool
@@ -1104,7 +1090,7 @@ class PlotAstroData(AstroFrame):
             if mode == 'ra':
                 xy.reverse()
             tickvalues = xy2coord(xy, center)
-            getter = _get_min if no_sec else _get_sec
+            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.
@@ -1117,12 +1103,14 @@ class PlotAstroData(AstroFrame):
                  'dec': {'d': r'$^{\circ}$',
                          'm': r'$^{\prime}$',
                          's': r'.$\hspace{-0.4}^{\prime\prime}$'}}
-        cos_dec = np.cos(np.radians(coord2xy(center)[1]))
+        dec_center = coord2xy(center)[1]
+        sign_dec = np.sign(dec_center)
+        cos_dec = np.cos(np.radians(dec_center))
         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))
+            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)
@@ -1131,7 +1119,7 @@ class PlotAstroData(AstroFrame):
             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
+            factor = 15 * cos_dec if mode == 'ra' else sign_dec
             ticks = (intgrid * gridwidth - second + rounded) * factor
             ticksminor = np.linspace(ticks[0], ticks[-1], 6*nticksminor + 1)
             tickvalues = get_tickvalues(ticks, mode, no_sec)
@@ -1143,8 +1131,8 @@ class PlotAstroData(AstroFrame):
 
         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')
+        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'
         ra_hm = ra_hm.translate(str.maketrans(units['ra']))

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

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