plotastrodata 1.9.8__tar.gz → 1.9.10__tar.gz

{plotastrodata-1.9.8/plotastrodata.egg-info → plotastrodata-1.9.10}/PKG-INFO

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

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

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/analysis_utils.py

@@ -117,7 +117,7 @@ class AstroData():
     def __post_init__(self):
         n = 0
         if self.fitsimage is not None:
-            if type(self.fitsimage) is not list:
+            if not isinstance(self.fitsimage, list):
                 n = 1
             elif any(a is not None for a in self.fitsimage):
                 n = len(self.fitsimage)
@@ -126,7 +126,7 @@ class AstroData():
             if n > 0:
                 self.data = None
         if self.data is not None:
-            if type(self.data) is not list:
+            if not isinstance(self.data, list):
                 n = 1
             elif any(a is not None for a in self.data):
                 n = len(self.data)
@@ -590,9 +590,9 @@ def _get_gridsep(axis: np.ndarray | None):
     return axis[1] - axis[0] if axis is not None and len(axis) > 1 else None
 
 
-ASTRODATA_ARGS = ["fitsimage", "data", "Tb", "sigma", "center", "restfreq",
-                  "cfactor", "bunit", "fitsimage_org", "sigma_org",
-                  "beam_org", "fitsheader", "pv", "pvpa"]
+ASTRODATA_ARGS = ['fitsimage', 'data', 'Tb', 'sigma', 'center', 'restfreq',
+                  'cfactor', 'bunit', 'fitsimage_org', 'sigma_org',
+                  'beam_org', 'fitsheader', 'pv', 'pvpa']
 
 
 @dataclass
@@ -675,12 +675,12 @@ class AstroFrame():
          Returns:
             np.ndarray: absolute coordinates.
          """
-        onexy = np.shape(poslist) == (2,) and type(poslist[0]) is not str
+        onexy = np.shape(poslist) == (2,) and not isinstance(poslist[0], str)
         if np.shape(poslist) == () or onexy:
             poslist = [poslist]
         x, y = [None] * len(poslist), [None] * len(poslist)
         for i, p in enumerate(poslist):
-            if type(p) is str:
+            if isinstance(p, str):
                 x[i], y[i] = coord2xy(p, self.center) * 3600.
             else:
                 x[i], y[i] = rel2abs(*p, self.Xlim, self.Ylim)
@@ -688,12 +688,12 @@ class AstroFrame():
 
     def _get_restfreq(self, header: dict):
         """Extract rest frequency from FITS header."""
-        if "RESTFRQ" in header:
-            return header["RESTFRQ"]
-        if "RESTFREQ" in header:
-            return header["RESTFREQ"]
-        if "NAXIS3" in header and header["NAXIS3"] == 1 and not self.pv:
-            return header["CRVAL3"]
+        if 'RESTFRQ' in header:
+            return header['RESTFRQ']
+        if 'RESTFREQ' in header:
+            return header['RESTFREQ']
+        if 'NAXIS3' in header and header['NAXIS3'] == 1 and not self.pv:
+            return header['CRVAL3']
         return None
 
     def _read_fitsimage(self, d: AstroData, i: int, grid: list) -> list:
@@ -715,7 +715,7 @@ class AstroFrame():
         if fd.wcsrot:
             d.center[i] = fd.get_center()
         d.beam[i] = fd.get_beam(dist=self.dist)
-        d.bunit[i] = fd.get_header("BUNIT")
+        d.bunit[i] = fd.get_header('BUNIT')
         return grid
 
     def _shift_center(self, d: AstroData, i: int, grid: list) -> list:
@@ -758,7 +758,7 @@ class AstroFrame():
         if self.pv:
             d.v = d.y
         for axis in ['x', 'y', 'v']:
-            setattr(d, f"d{axis}", _get_gridsep(getattr(d, axis)))
+            setattr(d, f'd{axis}', _get_gridsep(getattr(d, axis)))
 
     def _convert_to_Tb(self, d: AstroData, i: int):
         """Convert Jy/beam data to brightness temperature if requested."""
@@ -766,12 +766,12 @@ class AstroFrame():
             return
 
         dx = d.dy if self.swapxy else d.dx
-        header = {"CDELT1": dx / 3600,
-                  "CUNIT1": "DEG",
-                  "RESTFREQ": d.restfreq[i]}
+        header = {'CDELT1': dx / 3600,
+                  'CUNIT1': 'deg',
+                  'RESTFREQ': d.restfreq[i]}
         if None not in d.beam[i]:
-            header["BMAJ"] = d.beam[i][0] / 3600 / self.dist
-            header["BMIN"] = d.beam[i][1] / 3600 / self.dist
+            header['BMAJ'] = d.beam[i][0] / 3600 / self.dist
+            header['BMIN'] = d.beam[i][1] / 3600 / self.dist
         factor = Jy2K(header=header)
         d.data[i] = d.data[i] * factor
         if d.sigma[i] is not None:
@@ -785,7 +785,7 @@ class AstroFrame():
         bmaj, bmin, bpa = d.beam_org[i] = d.beam[i]
         if d.pvpa[i] is None:
             d.pvpa[i] = bpa
-            print("pvpa is not specified. pvpa=bpa is assumed.")
+            print('pvpa is not specified. pvpa=bpa is assumed.')
         angle = np.radians(bpa - d.pvpa[i])
         beam_incut = 1 / np.hypot(np.cos(angle) / bmaj, np.sin(angle) / bmin)
         d.beam[i] = np.array([np.abs(d.dv), beam_incut, 0])
@@ -827,5 +827,5 @@ class AstroFrame():
         d.beam = _as_list(d.beam, d.n, isbeam=True)
         for i in range(d.n):
             self._read_one(d, i)
-        for name in ASTRODATA_ARGS + ["beam"]:
+        for name in ASTRODATA_ARGS + ['beam']:
             setattr(d, name, _scalar_if_single(getattr(d, name), d.n))

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/coord_utils.py

@@ -18,7 +18,7 @@ def _updateframe(frame: str) -> str:
         a = FK5(equinox='J2000')
     elif 'B1950' in frame or 'FK4' in frame:
         a = FK4(equinox='B1950')
-    elif type(frame) is str:
+    elif isinstance(frame, str):
         print(f'Unknown frame ({frame}) was found. Use ICRS instead.')
         a = 'icrs'
     else:
@@ -26,7 +26,7 @@ def _updateframe(frame: str) -> str:
     return a
 
 
-def _getframe(coord: str) -> tuple:
+def _getframe(coord: str | list) -> tuple:
     """Internal function to pick up the frame name from the coordinates. When coord is a list, frame and framename are picked up from the first element.
 
     Args:
@@ -43,7 +43,7 @@ def _getframe(coord: str) -> tuple:
         framename = c[0] if hasframe else None
         return hmsdms, frame, framename
 
-    if type(coord) is str:
+    if isinstance(coord, str):
         return getframe_single(coord)
     else:
         outlist = [getframe_single(c) for c in coord]
@@ -108,7 +108,7 @@ def xy2coord(xy: list, coordorg: str = '00h00m00s 00d00m00s',
         coords = coords.transform_to(frame=frame)
     coords = coords.to_string('hmsdms')
     if framename is not None:
-        if type(coords) is str:
+        if isinstance(coords, str):
             coords = f'{framename} {coords}'
         else:
             coords = np.array([f'{framename} {s}' for s in coords])

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/fits_utils.py

@@ -241,23 +241,23 @@ class FitsData:
         h = self.header
         cxy = (0, 0)
         if center is not None and not self.wcsrot:
-            coordorg = xy2coord([h["CRVAL1"], h["CRVAL2"]])
-            if (radesys := h.get("RADESYS")) is not None:
-                coordorg = f"{radesys}  {coordorg}"
+            coordorg = xy2coord([h['CRVAL1'], h['CRVAL2']])
+            if (radesys := h.get('RADESYS')) is not None:
+                coordorg = f'{radesys}  {coordorg}'
             cxy = coord2xy(center, coordorg)
-        slabel = ["x", "y"]
+        slabel = ['x', 'y']
 
         def wrapper(i: int):
             def gen_s(s_in: np.ndarray | None) -> None:
-                if h.get(f"NAXIS{i+1}") is None or s_in is None:
+                if h.get(f'NAXIS{i+1}') is None or s_in is None:
                     s, ds = None, None
                 else:
                     s = (s_in - cxy[i]) * dist
-                    if isdeg(h[f"CUNIT{i+1}"]):
+                    if isdeg(h[f'CUNIT{i+1}']):
                         s *= 3600.
                     ds = None if len(s) == 0 else s[1] - s[0]
-                setattr(self, f"{slabel[i]}", s)
-                setattr(self, f"d{slabel[i]}", ds)
+                setattr(self, f'{slabel[i]}', s)
+                setattr(self, f'd{slabel[i]}', ds)
             return gen_s
 
         return wrapper(0), wrapper(1)
@@ -266,29 +266,29 @@ class FitsData:
         h = self.header
 
         def gen_v(v_in: np.ndarray) -> None:
-            vaxis = "2" if pv else "3"
-            if h.get(f"NAXIS{vaxis}") is None or v_in is None:
+            vaxis = '2' if pv else '3'
+            if h.get(f'NAXIS{vaxis}') is None or v_in is None:
                 self.v, self.dv = None, None
                 return
 
             if restfreq is None:
                 freq = np.mean(v_in)
-                print("restfreq is assumed to be the center.")
+                print('restfreq is assumed to be the center.')
             else:
                 freq = restfreq
-            v = v_in + h[f"CRVAL{vaxis}"]
+            v = v_in + h[f'CRVAL{vaxis}']
             key = f'CUNIT{vaxis}'
             cunitv = h[key].strip()
             match cunitv:
-                case "Hz" | "HZ":
+                case 'Hz' | 'HZ':
                     if freq == 0:
-                        print("v is read as is, because restfreq=0.")
+                        print('v is read as is, because restfreq=0.')
                     else:
                         v = (1 - v / freq) * cu.c_kms - vsys
-                case "m/s" | "M/S":
+                case 'm/s' | 'M/S':
                     print(f'{key}={cunitv} found.')
                     v = v * 1e-3 - vsys
-                case 'km/s' | "KM/S":
+                case 'km/s' | 'KM/S':
                     print(f'{key}={cunitv} found.')
                     v = v - vsys
                 case _:
@@ -301,11 +301,11 @@ class FitsData:
 
     def _get_array(self, i: int) -> np.ndarray:
         h = self.header
-        n = h.get(f"NAXIS{i:d}")
+        n = h.get(f'NAXIS{i:d}')
         if n is None:
             return None
 
-        s = (np.arange(n) - h[f"CRPIX{i:d}"] + 1) * h[f"CDELT{i:d}"]
+        s = (np.arange(n) - h[f'CRPIX{i:d}'] + 1) * h[f'CDELT{i:d}']
         return s
 
     def gen_grid(self, center: str | None = None, dist: float = 1.,
@@ -343,7 +343,7 @@ class FitsData:
         Returns:
             tuple: (x, y, v).
         """
-        if not np.all([hasattr(self, s) for s in ["x", "y", "v"]]):
+        if not np.all([hasattr(self, s) for s in ['x', 'y', 'v']]):
             self.gen_grid(**kwargs)
         return self.x, self.y, self.v
 

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/fitting_utils.py

@@ -290,9 +290,9 @@ class EmceeCorner():
             log (list, optional): Whether to search in the logarithmic space. The percentile is counted in the linear space regardless of this option. Defaults to False.
             pcut (float, optional): Posterior is reset to be zero if it is below this cut off.
         """
-        if type(ngrid) is int:
+        if isinstance(ngrid, int):
             ngrid = [ngrid] * self.dim
-        if type(log) is bool:
+        if isinstance(log, bool):
             log = [log] * self.dim
         pargrid = []
         inzip = [self.bounds[:, 0], self.bounds[:, 1], ngrid, log]

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/noise_utils.py

@@ -1,4 +1,5 @@
 import matplotlib.pyplot as plt
+import numbers
 import numpy as np
 import warnings
 from scipy.special import erf
@@ -12,7 +13,7 @@ def normalize(range: tuple = (-3.5, 3.5), bins: int = 100):
     def decorator(f):
         h = np.linspace(*range, bins + 1)
         h = (h[1:] + h[:-1]) / 2
-        dh = (range[1] - range[0]) / 100
+        dh = h[1] - h[0]
 
         def wrapper(x, *args):
             area = np.sum(f(h, *args)) * dh
@@ -73,7 +74,7 @@ def select_noise(data: np.ndarray, sigma: str) -> np.ndarray:
     Returns:
         np.ndarray: 1D array that includes only the selected pixels.
     """
-    n = data * 1
+    n = np.array(data) * 1
     if 'edge' in sigma:
         if np.ndim(n) <= 2:
             print('\'edge\' is ignored because ndim <= 2.')
@@ -194,8 +195,7 @@ def estimate_rms(data: np.ndarray,
     Returns:
         float: The estimated standard deviation of noise.
     """
-    nums = [float, int, np.float64, np.int64, np.float32, np.int32]
-    if sigma is None or type(sigma) in nums:
+    if sigma is None or isinstance(sigma, numbers.Number):
         return sigma
 
     if np.ndim(np.squeeze(data)) == 0:

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/other_utils.py

@@ -1,4 +1,5 @@
 import matplotlib.pyplot as plt
+import numbers
 import numpy as np
 import warnings
 from scipy.interpolate import RegularGridInterpolator as RGI
@@ -10,10 +11,9 @@ def listing(*args) -> list:
     Returns:
         list: With a single non-list input, the output is a list like ['a'], rather than [['a']].
     """
-    strnum = [str, float, int, np.float64, np.int64, np.float32, np.int32]
     b = [None] * len(args)
     for i, a in enumerate(args):
-        b[i] = [a] if type(a) in strnum else a
+        b[i] = [a] if isinstance(a, (str, numbers.Number)) else a
     if len(args) == 1:
         b = b[0]
     return b
@@ -28,7 +28,7 @@ def isdeg(s: str) -> bool:
     Returns:
         bool: Whether the given string means degree.
     """
-    if type(s) is str:
+    if isinstance(s, str):
         return s.strip() in ['deg', 'DEG', 'degree', 'DEGREE']
     else:
         return False
@@ -86,7 +86,7 @@ def trim(data: np.ndarray | None = None, x: np.ndarray | None = None,
     d = np.squeeze(data)
 
     if d.ndim == 0:
-        print("data has only one pixel.")
+        print('data has only one pixel.')
         return data, [xout, yout, vout]
 
     if d.ndim == 2:

{plotastrodata-1.9.8 → plotastrodata-1.9.10}/plotastrodata/plot_utils.py

@@ -8,6 +8,7 @@ from typing import TypeVar
 from plotastrodata.analysis_utils import AstroData, AstroFrame
 from plotastrodata.coord_utils import (coord2xy, xy2coord,
                                        get_hmdm, get_min, get_sec)
+from plotastrodata.fitting_utils import gaussian1d
 from plotastrodata.noise_utils import estimate_rms
 from plotastrodata.other_utils import (close_figure, listing,
                                        reform_grid, reform_data)
@@ -176,9 +177,13 @@ def _get_ch2nij(nrows: int = 1, ncols: int = 1) -> object:
     return ch2nij
 
 
-def _get_vskipfill(nv: float, v_org: np.ndarray, vskip: int) -> object:
+def _get_vskipfill(nv: float, v_org: np.ndarray, vskip: int,
+                   channelnumber: 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)
+        c = reform_data(c=c, v_in=v_in, nv=nv, v_org=v_org, vskip=vskip)
+        if isinstance(channelnumber, int):
+            c = [c[channelnumber]]
+        return c
     return vskipfill
 
 
@@ -202,7 +207,7 @@ class Stretcher():
     sigma: float = 0
 
     def __post_init__(self):
-        self.n = 1 if type(self.stretch) is str else len(self.stretch)
+        self.n = 1 if isinstance(self.stretch, str) else len(self.stretch)
         stretch = self.stretch
         stsc = self.stretchscale
         vmin = self.vmin
@@ -371,8 +376,8 @@ class PlotAxes2D():
         if self.loglog is not None:
             self.xscale = self.yscale = 'log'
             self.samexy = True
-            for axis in ["x", "y"]:
-                attr = f"{axis}lim"
+            for axis in ['x', 'y']:
+                attr = f'{axis}lim'
                 lim = getattr(self, attr)
                 if lim is not None:
                     lim[0] = lim[1] / self.loglog
@@ -382,14 +387,14 @@ class PlotAxes2D():
 
     def _init_ticks(self, axis):
         ax = self.ax
-        ticks_attr = f"{axis}ticks"
-        ticklabels_attr = f"{axis}ticklabels"
-        scale = getattr(self, f"{axis}scale")
-        lim = getattr(self, f"{axis}lim")
+        ticks_attr = f'{axis}ticks'
+        ticklabels_attr = f'{axis}ticklabels'
+        scale = getattr(self, f'{axis}scale')
+        lim = getattr(self, f'{axis}lim')
         ticks = getattr(self, ticks_attr)
         if ticks is None:
-            ticks = getattr(ax, f"get_{axis}ticks")()
-            if scale == "log":
+            ticks = getattr(ax, f'get_{axis}ticks')()
+            if scale == 'log':
                 ticks, ticklabels = logticks(ticks, lim)
                 setattr(self, ticklabels_attr, ticklabels)
             setattr(self, ticks_attr, ticks)
@@ -402,21 +407,21 @@ class PlotAxes2D():
 
     def _set_ticks(self, axis):
         ax = self.ax
-        attr = f"{axis}ticks"
+        attr = f'{axis}ticks'
         ticks = getattr(self, attr)
-        getattr(ax, f"set_{attr}")(ticks)
-        ticksminor = getattr(self, f"{attr}minor")
+        getattr(ax, f'set_{attr}')(ticks)
+        ticksminor = getattr(self, f'{attr}minor')
         if ticksminor is not None:
             if isinstance(ticksminor, int):
                 ticksminor = self._make_ticks(ticks, ticksminor)
-            getattr(ax, f"set_{attr}")(ticksminor, minor=True)
+            getattr(ax, f'set_{attr}')(ticksminor, minor=True)
 
     def _apply_if_not_none(self, axis, attr):
         ax = self.ax
-        method = getattr(ax, f"set_{axis}{attr}")
-        value = getattr(self, f"{axis}{attr}")
+        method = getattr(ax, f'set_{axis}{attr}')
+        value = getattr(self, f'{axis}{attr}')
         if value is not None:
-            if attr == "lim":
+            if attr == 'lim':
                 method(*value)
             else:
                 method(value)
@@ -428,10 +433,10 @@ class PlotAxes2D():
             ax.set_xticks(ax.get_yticks())
             ax.set_yticks(ax.get_xticks())
             ax.set_aspect(1)
-        for axis in ["x", "y"]:
+        for axis in ['x', 'y']:
             self._init_ticks(axis)
             self._set_ticks(axis)
-            for attr in ["ticklabels", "label", "lim"]:
+            for attr in ['ticklabels', 'label', 'lim']:
                 self._apply_if_not_none(axis, attr)
         if self.grid is not None:
             ax.grid(**({} if self.grid is True else self.grid))
@@ -513,9 +518,10 @@ class PlotAstroData(AstroFrame):
         super().__init__(**kwargs)
         internalfig = fig is None
         internalax = ax is None
+        animation = isinstance(channelnumber, int)
         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:
+        if self.pv or len(v) == 1 or animation:
             nrows = ncols = npages = nchan = 1
         else:
             npages = int(np.ceil(nv / nrows / ncols))
@@ -531,7 +537,7 @@ class PlotAstroData(AstroFrame):
                               ymin=self.ymin, ymax=self.ymax,
                               figsize=figsize,
                               ncols=ncols, nrows=nrows, nchan=nchan)
-        need_vlabel = nchan > 1 or type(channelnumber) is int
+        need_vlabel = nchan > 1 or animation
         for ch in range(nchan):
             n, i, j = ch2nij(ch)
             if internalfig and n not in plt.get_fignums():
@@ -556,8 +562,9 @@ class PlotAstroData(AstroFrame):
         self.allchan = np.arange(nv)
         self.bottomleft = nij2ch(np.arange(npages), nrows - 1, 0)
         self.channelnumber = channelnumber
+        self.animation = animation
         self.v = v
-        self.vskipfill = _get_vskipfill(nv=nv, v_org=v, vskip=vskip)
+        self.vskipfill = _get_vskipfill(nv, v, vskip, channelnumber)
 
     def _map_init(self, kw: dict) -> tuple:
         """
@@ -586,6 +593,12 @@ class PlotAstroData(AstroFrame):
         return (d.data, d.x, d.y, d.v, d.sigma, d.bunit,
                 self._kw, singlepix)
 
+    def _validchan(self, include_chan: list) -> list:
+        chans = self.allchan if include_chan is None else include_chan
+        if self.animation:
+            chans = [0] if self.channelnumber in include_chan else [1]
+        return chans
+
     def add_region(self, patch: str = 'ellipse',
                    poslist: list[str | list[float, float]] = [],
                    majlist: list[float] = [], minlist: list[float] = [],
@@ -605,8 +618,6 @@ class PlotAstroData(AstroFrame):
         _kw = {'facecolor': 'none', 'edgecolor': 'gray',
                'linewidth': 1.5, 'zorder': 10}
         _kw.update(kwargs)
-        if include_chan is None:
-            include_chan = self.allchan
         if patch not in ['rectangle', 'ellipse']:
             print('Only patch=\'rectangle\' or \'ellipse\' supported. ')
             return
@@ -614,9 +625,7 @@ class PlotAstroData(AstroFrame):
         z = listing(*self.pos2xy(poslist), minlist, majlist, palist)
         for x, y, width, height, angle in zip(*z):
             for ch, axnow in enumerate(self.ax):
-                if type(self.channelnumber) is int:
-                    ch = self.channelnumber
-                if ch not in include_chan:
+                if ch not in self._validchan(include_chan):
                     continue
                 if self.fig is None:
                     plt.figure(ch // self.rowcol)
@@ -642,12 +651,11 @@ class PlotAstroData(AstroFrame):
         if not show_beam:
             return
 
-        animation = self.channelnumber is not None
-        include_chan = self.allchan if animation else self.bottomleft
+        include_chan = self.allchan if self.animation else self.bottomleft
         patch = 'rectangle' if self.pv else 'ellipse'
         blist = [beam] if np.ndim(beam) == 1 else beam
         n = len(blist)
-        bclist = beamcolor if type(beamcolor) is list else [beamcolor] * n
+        bclist = beamcolor if isinstance(beamcolor, list) else [beamcolor] * n
         islist = beampos == [None] * 3 or np.ndim(beampos) == 2
         bplist = beampos if islist else [beampos] * n
         for (bmaj, bmin, bpa), bc, bp in zip(blist, bclist, bplist):
@@ -678,12 +686,8 @@ class PlotAstroData(AstroFrame):
         _kw = {'marker': '+', 'ms': 10, 'mfc': 'gray',
                'mec': 'gray', 'mew': 2, 'alpha': 1, 'zorder': 10}
         _kw.update(kwargs)
-        if include_chan is None:
-            include_chan = self.allchan
         for ch, axnow in enumerate(self.ax):
-            if type(self.channelnumber) is int:
-                ch = self.channelnumber
-            if ch not in include_chan:
+            if ch not in self._validchan(include_chan):
                 continue
             for x, y in zip(*self.pos2xy(poslist)):
                 axnow.plot(x, y, **_kw)
@@ -706,12 +710,8 @@ class PlotAstroData(AstroFrame):
             if long in kwargs:
                 kwargs[short] = kwargs.pop(long)
         _kw.update(kwargs)
-        if include_chan is None:
-            include_chan = self.allchan
         for ch, axnow in enumerate(self.ax):
-            if type(self.channelnumber) is int:
-                ch = self.channelnumber
-            if ch not in include_chan:
+            if ch not in self._validchan(include_chan):
                 continue
             z = listing(*self.pos2xy(poslist), slist)
             for x, y, s in zip(*z):
@@ -732,12 +732,8 @@ class PlotAstroData(AstroFrame):
         _kw = {'color': 'gray', 'linewidth': 1.5,
                'linestyle': '-', 'zorder': 10}
         _kw.update(kwargs)
-        if include_chan is None:
-            include_chan = self.allchan
         for ch, axnow in enumerate(self.ax):
-            if type(self.channelnumber) is int:
-                ch = self.channelnumber
-            if ch not in include_chan:
+            if ch not in self._validchan(include_chan):
                 continue
             alist = np.radians(anglelist)
             z = listing(*self.pos2xy(poslist), alist, rlist)
@@ -760,12 +756,8 @@ class PlotAstroData(AstroFrame):
         _kw = {'color': 'gray', 'width': 0.012,
                'headwidth': 5, 'headlength': 5, 'zorder': 10}
         _kw.update(kwargs)
-        if include_chan is None:
-            include_chan = self.allchan
         for ch, axnow in enumerate(self.ax):
-            if type(self.channelnumber) is int:
-                ch = self.channelnumber
-            if ch not in include_chan:
+            if ch not in self._validchan(include_chan):
                 continue
             alist = np.radians(anglelist)
             z = listing(*self.pos2xy(poslist), alist, rlist)
@@ -877,8 +869,6 @@ class PlotAstroData(AstroFrame):
         _kw['vmin'] = cmin
         _kw['vmax'] = cmax
         c = self.vskipfill(c, v)
-        if type(self.channelnumber) is int:
-            c = [c[self.channelnumber]]
         p = [None] * len(self.ax)
         for ch, (axnow, cnow) in enumerate(zip(self.ax, c)):
             pnow = axnow.pcolormesh(x, y, cnow, **_kw)
@@ -904,8 +894,6 @@ class PlotAstroData(AstroFrame):
             return
 
         c = self.vskipfill(c, v)
-        if type(self.channelnumber) is int:
-            c = [c[self.channelnumber]]
         for axnow, cnow in zip(self.ax, c):
             axnow.contour(x, y, cnow, np.sort(levels) * sigma, **_kw)
 
@@ -962,9 +950,6 @@ class PlotAstroData(AstroFrame):
         V = ampfactor * amp * np.cos(np.radians(ang + rotation))
         U = self.vskipfill(U, v)
         V = self.vskipfill(V, v)
-        if type(self.channelnumber) is int:
-            U = [U[self.channelnumber]]
-            V = [V[self.channelnumber]]
         _kw['scale'] = 1. / np.abs(x[1] - x[0])
         for axnow, unow, vnow in zip(self.ax, U, V):
             axnow.quiver(x, y, unow, vnow, **_kw)
@@ -1026,13 +1011,13 @@ class PlotAstroData(AstroFrame):
         if title is not None:
             if len(self.ax) > 1:
                 t = {'y': 0.9}
-                t_in = {'t': title} if type(title) is str else title
+                t_in = {'t': title} if isinstance(title, str) else title
                 t.update(t_in)
                 for i in range(self.npages):
                     fig = plt.figure(i)
                     fig.suptitle(**t)
             else:
-                t = {'label': title} if type(title) is str else title
+                t = {'label': title} if isinstance(title, str) else title
                 axnow.set_title(**t)
 
     def set_axis(self, title: dict | str | None = None, **kwargs) -> None:
@@ -1172,7 +1157,7 @@ class PlotAstroData(AstroFrame):
         for axnow in self.ax:
             axnow.set_xlim(*self.Xlim)
             axnow.set_ylim(*self.Ylim)
-        if type(filename) is str:
+        if isinstance(filename, str):
             ext = filename.split('.')[-1]
             for i in range(self.npages):
                 ver = '' if self.npages == 1 else f'_{i:d}'
@@ -1199,6 +1184,55 @@ class PlotAstroData(AstroFrame):
         return fig, self.ax[0]
 
 
+def _get_ylabel_profile(_kw: dict, Tb: bool, flux: bool, bunit: str
+                        ) -> str:
+    if 'ylabel' in _kw:
+        return _kw['ylabel']
+    if Tb:
+        return r'$T_b$ (K)'
+    if flux:
+        return 'Flux (Jy)'
+    return bunit
+
+
+def _prep_plotprofile(width: int, coords: list | str,
+                      xlist: list, ylist: list, ellipse: list,
+                      ninterp: int, flux: bool, gaussfit: bool,
+                      _kw: dict) -> tuple:
+    if isinstance(coords, str):
+        coords = [coords]
+    Tb = _kw.get('Tb', False)
+    f = kwargs2instance(AstroFrame, _kw)
+    d = kwargs2instance(AstroData, _kw)
+    f.read(d)
+    d.binning([width, 1, 1])
+    v, prof, gfitres = d.profile(coords=coords, xlist=xlist, ylist=ylist,
+                                 ellipse=ellipse, ninterp=ninterp,
+                                 flux=flux, gaussfit=gaussfit)
+    ylabel = _get_ylabel_profile(_kw, Tb, flux, d.bunit)
+    if isinstance(ylabel, str):
+        ylabel = [ylabel] * len(prof)
+    _kw.setdefault('xlim', [v.min(), v.max()])
+    pa2 = kwargs2instance(PlotAxes2D, _kw)
+    return v, prof, gfitres, pa2, ylabel
+
+
+def _set_figax_plotprofile(fig, ax, nrows: int, ncols: int,
+                           nprof: int) -> tuple:
+    if ncols == 1:
+        nrows = nprof
+    if fig is None:
+        fig = plt.figure(figsize=(6 * ncols, 3 * nrows))
+    if nprof > 1 and ax is not None:
+        print('External ax is supported only when len(coords)=1.')
+        ax = None
+    ax = np.empty(nprof, dtype=object) if ax is None else [ax]
+    for i in range(nprof):
+        sharex = None if i < nrows - 1 else ax[i - 1]
+        ax[i] = fig.add_subplot(nrows, ncols, i + 1, sharex=sharex)
+    return fig, ax
+
+
 def plotprofile(coords: list[str] | str = [],
                 xlist: list[float] = [], ylist: list[float] = [],
                 ellipse: list[float, float, float] | None = None,
@@ -1208,11 +1242,9 @@ def plotprofile(coords: list[str] | str = [],
                 title: list[str] | None = None,
                 text: list[str] | None = None,
                 nrows: int = 0, ncols: int = 1,
-                fig: object | None = None,
-                ax: object | None = None,
+                fig: object | None = None, ax: object | None = None,
                 getfigax: bool = False,
-                savefig: dict | str | None = None,
-                show: bool = False,
+                savefig: dict | str | None = None, show: bool = False,
                 **kwargs) -> tuple[object, object]:
     """Use Axes.plot of matplotlib to plot line profiles at given coordinates. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs must include the arguments of AstroFrame to specify the ranges and so on for plotting. kwargs can include the arguments of PlotAxes2D to adjust x and y axes.
 
@@ -1239,54 +1271,20 @@ def plotprofile(coords: list[str] | str = [],
     Returns:
         tuple: (fig, ax), where ax is a list, if getfigax=True. Otherwise, no return.
     """
-    _kw = {'drawstyle': 'steps-mid', 'color': 'k'}
+    _kw = {'drawstyle': 'steps-mid', 'color': 'k',
+           'xlabel': r'Velocity (km s$^{-1}$)', 'samexy': False}
     _kw.update(kwargs)
     _kwgauss = {'drawstyle': 'default', 'color': 'g'}
     _kwgauss.update(gauss_kwargs)
-    if type(coords) is str:
-        coords = [coords]
-    f = kwargs2instance(AstroFrame, _kw)
-    d = kwargs2instance(AstroData, _kw)
-    f.read(d)
-    d.binning([width, 1, 1])
-    v, prof, gfitres = d.profile(coords=coords, xlist=xlist, ylist=ylist,
-                                 ellipse=ellipse, ninterp=ninterp,
-                                 flux=flux, gaussfit=gaussfit)
+    v, prof, gfitres, pa2, ylabel \
+        = _prep_plotprofile(width, coords, xlist, ylist, ellipse,
+                            ninterp, flux, gaussfit, _kw)
     nprof = len(prof)
-    if 'ylabel' in _kw:
-        ylabel = _kw['ylabel']
-    elif d.Tb:
-        ylabel = r'$T_b$ (K)'
-    elif flux:
-        ylabel = 'Flux (Jy)'
-    else:
-        ylabel = d.bunit
-    if type(ylabel) is str:
-        ylabel = [ylabel] * nprof
-
-    def gauss(x, p, c, w):
-        return p * np.exp(-4. * np.log(2.) * ((x - c) / w)**2)
-
     set_rcparams(20, 'w')
-    if ncols == 1:
-        nrows = nprof
-    if fig is None:
-        fig = plt.figure(figsize=(6 * ncols, 3 * nrows))
-    if nprof > 1 and ax is not None:
-        print('External ax is supported only when len(coords)=1.')
-        ax = None
-    ax = np.empty(nprof, dtype='object') if ax is None else [ax]
-    if 'xlabel' not in _kw:
-        _kw['xlabel'] = 'Velocity (km s$^{-1}$)'
-    if 'xlim' not in _kw:
-        _kw['xlim'] = [v.min(), v.max()]
-    _kw['samexy'] = False
-    pa2 = kwargs2instance(PlotAxes2D, _kw)
+    fig, ax = _set_figax_plotprofile(fig, ax, nrows, ncols, nprof)
     for i in range(nprof):
-        sharex = None if i < nrows - 1 else ax[i - 1]
-        ax[i] = fig.add_subplot(nrows, ncols, i + 1, sharex=sharex)
         if gaussfit:
-            ax[i].plot(v, gauss(v, *gfitres['best'][i]), **_kwgauss)
+            ax[i].plot(v, gaussian1d(v, *gfitres['best'][i]), **_kwgauss)
         ax[i].plot(v, prof[i], **_kw)
         ax[i].hlines([0], v.min(), v.max(), linestyle='dashed', color='k')
         ax[i].set_ylabel(ylabel[i])
@@ -1294,7 +1292,7 @@ def plotprofile(coords: list[str] | str = [],
         if text is not None:
             ax[i].text(**text[i])
         if title is not None:
-            if type(title[i]) is str:
+            if isinstance(title[i], str):
                 title[i] = {'label': title[i]}
             ax[i].set_title(**title[i])
         if i <= nprof - ncols - 1:
@@ -1369,8 +1367,69 @@ def plotslice(length: float, dx: float | None = None, pa: float = 0,
     close_figure(fig, savefig, show)
 
 
+def _plot_on_wall(d: AstroData, x: np.ndarray, y: np.ndarray, v: np.ndarray,
+                  measure: object, datalist: list,
+                  sign: int, axis: int, **kwargs):
+    dx, dy, dv = x[1] - x[0], y[1] - y[0], v[1] - v[0]
+    s, ds = [x, y, v], [dx, dy, dv]
+    if kwargs == {}:
+        return
+
+    match axis:
+        case 2:
+            shape = np.shape(d.data[:, :, 0])
+        case 1:
+            shape = np.shape(d.data[:, 0, :])
+        case 0:
+            shape = np.shape(d.data[0, :, :])
+    if np.shape(kwargs['data']) != shape:
+        print('The shape of the 2D data is inconsistent'
+              + ' with the shape of the 3D data.')
+        return
+
+    _kw = {'levels': [3, 6, 12, 24, 48, 96, 192, 384],
+           'sigma': 'hist', 'cmap': 'Jet', 'alpha': 0.3}
+    _kw.update(kwargs)
+    volume = _kw['data']
+    levels = _kw['levels']
+    cmap = _kw['cmap']
+    alpha = _kw['alpha']
+    sigma = estimate_rms(data=volume, sigma=_kw['sigma'])
+    volume[np.isnan(volume)] = 0
+    a = int(sign == -1)
+    b = int(sign == 1)
+    volume = np.moveaxis([volume * a, volume * b], 0, axis)
+    if d.dx < 0:
+        volume = volume[:, :, ::-1]
+    if d.dy < 0:
+        volume = volume[:, ::-1, :]
+    if d.dv < 0:
+        volume = volume[::-1, :, :]
+    for lev in levels:
+        if lev * sigma > np.max(volume):
+            continue
+        vertices, simplices, _, _ = measure.marching_cubes(volume, lev * sigma)
+        Xg, Yg, Zg = [t[0] + i * dt for t, i, dt
+                      in zip(s, vertices.T[::-1], ds)]
+        match axis:
+            case 2:
+                Xg = Xg * 0 + (x[-1] if sign == 1 else x[0])
+            case 1:
+                Yg = Yg * 0 + (y[-1] if sign == 1 else y[0])
+            case 0:
+                Zg = Zg * 0 + (v[-1] if sign == 1 else v[0])
+        i, j, k = simplices.T
+        mesh2d = dict(type='mesh3d', x=Xg, y=Yg, z=Zg,
+                      i=i, j=j, k=k,
+                      intensity=Zg * 0 + lev,
+                      colorscale=cmap, reversescale=False,
+                      cmin=np.min(levels), cmax=np.max(levels),
+                      opacity=alpha, name='', showscale=False)
+        datalist.append(mesh2d)
+
+
 def plot3d(levels: list[float] = [3, 6, 12],
-           cmap: str = 'Jet', alpha: float = 0.08,
+           cmap: str = 'jet', alpha: float = 0.08,
            xlabel: str = 'R.A. (arcsec)',
            ylabel: str = 'Dec. (arcsec)',
            vlabel: str = 'Velocity (km/s)',
@@ -1461,67 +1520,11 @@ def plot3d(levels: list[float] = [3, 6, 12],
                      name='', line=dict(color='rgb(0,0,0)', width=1))
         data.append(lines)
 
-    def plot_on_wall(sign: int, axis: int, **kwargs):
-        if kwargs == {}:
-            return
-
-        match axis:
-            case 2:
-                shape = np.shape(d.data[:, :, 0])
-            case 1:
-                shape = np.shape(d.data[:, 0, :])
-            case 0:
-                shape = np.shape(d.data[0, :, :])
-        if np.shape(kwargs['data']) != shape:
-            print('The shape of the 2D data is inconsistent'
-                  + ' with the shape of the 3D data.')
-            return
-
-        _kw = {'levels': [3, 6, 12, 24, 48, 96, 192, 384],
-               'sigma': 'hist', 'cmap': 'Jet', 'alpha': 0.3}
-        _kw.update(kwargs)
-        volume = _kw['data']
-        levels = _kw['levels']
-        cmap = _kw['cmap']
-        alpha = _kw['alpha']
-        sigma = estimate_rms(data=volume, sigma=_kw['sigma'])
-        volume[np.isnan(volume)] = 0
-        a = int(sign == -1)
-        b = int(sign == 1)
-        volume = np.moveaxis([volume * a, volume * b], 0, axis)
-        if d.dx < 0:
-            volume = volume[:, :, ::-1]
-        if d.dy < 0:
-            volume = volume[:, ::-1, :]
-        if d.dv < 0:
-            volume = volume[::-1, :, :]
-        for lev in levels:
-            if lev * sigma > np.max(volume):
-                continue
-            vertices, simplices, _, _ = measure.marching_cubes(volume, lev * sigma)
-            Xg, Yg, Zg = [t[0] + i * dt for t, i, dt
-                          in zip(s, vertices.T[::-1], ds)]
-            match axis:
-                case 2:
-                    Xg = Xg * 0 + (x[-1] if sign == 1 else x[0])
-                case 1:
-                    Yg = Yg * 0 + (y[-1] if sign == 1 else y[0])
-                case 0:
-                    Zg = Zg * 0 + (v[-1] if sign == 1 else v[0])
-            i, j, k = simplices.T
-            mesh2d = dict(type='mesh3d', x=Xg, y=Yg, z=Zg,
-                          i=i, j=j, k=k,
-                          intensity=Zg * 0 + lev,
-                          colorscale=cmap, reversescale=False,
-                          cmin=np.min(levels), cmax=np.max(levels),
-                          opacity=alpha, name='', showscale=False)
-            data.append(mesh2d)
-
     klist = [xplus, xminus, yplus, yminus, vplus, vminus]
     slist = [1, -1, 1, -1, 1, -1]
     alist = [2, 2, 1, 1, 0, 0]
     for kw, sign, axis in zip(klist, slist, alist):
-        plot_on_wall(sign=sign, axis=axis, **kw)
+        _plot_on_wall(d, x, y, v, measure, data, sign, axis, **kw)
 
     if return_data_layout:
         return {'data': data, 'layout': layout}

{plotastrodata-1.9.8 → plotastrodata-1.9.10/plotastrodata.egg-info}/PKG-INFO

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