plotastrodata 1.9.7__tar.gz → 1.9.9__tar.gz

{plotastrodata-1.9.7/plotastrodata.egg-info → plotastrodata-1.9.9}/PKG-INFO

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

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

{plotastrodata-1.9.7 → plotastrodata-1.9.9}/plotastrodata/analysis_utils.py

@@ -688,12 +688,12 @@ class AstroFrame():
 
     def _get_restfreq(self, header: dict):
         """Extract rest frequency from FITS header."""
-        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:
@@ -718,20 +718,16 @@ class AstroFrame():
         d.bunit[i] = fd.get_header("BUNIT")
         return grid
 
-    def _no_newcenter(self, center: str | None):
-        return (self.pv
-                or self.center is None
-                or center is None
-                or center == self.center)
-
     def _shift_center(self, d: AstroData, i: int, grid: list) -> list:
-        if self._no_newcenter(d.center[i]):
+        corg = d.center[i]
+        cnew = self.center
+        if self.pv or cnew is None or corg is None or corg == cnew:
             return grid
 
-        cx, cy = coord2xy(d.center[i], self.center) * 3600
+        cx, cy = coord2xy(corg, cnew) * 3600
         grid[0] = grid[0] + cx  # Don't use += cx.
         grid[1] = grid[1] + cy  # Don't use += cy.
-        d.center[i] = self.center
+        d.center[i] = cnew
         return grid
 
     def _ascending_v(self, d: AstroData, i: int, v: np.ndarray | None):
@@ -756,9 +752,11 @@ class AstroFrame():
         self._ascending_v(d, i, v=grid[2])
         grid = [grid[0], d.v] if self.pv else [grid[0], grid[1]]
         if self.swapxy:
-            grid = [grid[1], grid[0]]
+            grid.reverse()
             d.data[i] = np.moveaxis(d.data[i], 1, 0)
         self._xyskip(d, i, x=grid[0], y=grid[1])
+        if self.pv:
+            d.v = d.y
         for axis in ['x', 'y', 'v']:
             setattr(d, f"d{axis}", _get_gridsep(getattr(d, axis)))
 

{plotastrodata-1.9.7 → plotastrodata-1.9.9}/plotastrodata/fits_utils.py

@@ -177,6 +177,137 @@ class FitsData:
             self.gen_data(**kwargs)
         return self.data
 
+    def _read_cd(self):
+        h = self.header
+        cdij = ['CD1_1', 'CD1_2', 'CD2_1', 'CD2_2']
+        if not np.all([k in list(h.keys()) for k in cdij]):
+            self.wcsrot = False
+            self.Mcd = None
+            return
+
+        self.wcsrot = True
+        cd11, cd12, cd21, cd22 = [h[k] for k in cdij]
+        self.Mcd = [[cd11, cd12], [cd21, cd22]]
+        if cd21 == 0:
+            rho_a = 0
+        else:
+            rho_a = np.arctan2(np.abs(cd21), np.sign(cd21) * cd11)
+        if cd12 == 0:
+            rho_b = 0
+        else:
+            rho_b = np.arctan2(np.abs(cd12), -np.sign(cd12) * cd22)
+        if (drho := np.abs(np.degrees(rho_a - rho_b))) > 1.0:
+            print('Angles from (CD21, CD11) and (CD12, CD22)'
+                  + f' are different by {drho:.2} degrees.')
+        crota2 = (rho_a + rho_b) / 2.
+        sin_rho = np.sin(crota2)
+        cos_rho = np.cos(crota2)
+        cdelt1 = cd11 * cos_rho + cd21 * sin_rho
+        cdelt2 = -cd12 * sin_rho + cd22 * cos_rho
+        crota2 = np.degrees(crota2)
+        h['CDELT1'] = cdelt1
+        h['CDELT2'] = cdelt2
+        for k in cdij:
+            del h[k]
+        print(f'WCS rotation was found (CROTA2 = {crota2:f} deg).')
+
+    def _rotate_cd(self):
+        h = self.header
+        data = self.get_data()
+        ic = len(self.x) // 2
+        jc = len(self.y) // 2
+        h['CRPIX1'] = ic + 1
+        h['CRPIX2'] = jc + 1
+        xc = self.x[ic] / self.dx
+        yc = self.y[jc] / self.dy
+        xc, yc = dot2d(self.Mcd, [xc, yc])
+        newcenter = xy2coord([xc, yc], coordorg=self.get_center())
+        xc, yc = coord2xy(coords=newcenter)
+        h['CRVAL1'] = xc
+        h['CRVAL2'] = yc
+        self.x = self.x - self.x[ic]
+        self.y = self.y - self.y[jc]
+        x = self.x / (3600 if isdeg(h['CUNIT1']) else 1)
+        y = self.y / (3600 if isdeg(h['CUNIT2']) else 1)
+        X, Y = np.meshgrid(x, y)
+        Mcdinv = np.linalg.inv(self.Mcd)
+        xnew, ynew = dot2d(Mcdinv, [X, Y])
+        datanew = RGIxy(self.y / self.dy, self.x / self.dx,
+                        data, (ynew, xnew))
+        self.data = datanew
+        print('Data values were interpolated for WCS rotation.')
+
+    def _get_genx_geny(self, center: str, dist: float):
+        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}"
+            cxy = coord2xy(center, coordorg)
+        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:
+                    s, ds = None, None
+                else:
+                    s = (s_in - cxy[i]) * dist
+                    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)
+            return gen_s
+
+        return wrapper(0), wrapper(1)
+
+    def _get_genv(self, restfreq: float | None, vsys: float, pv: bool):
+        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:
+                self.v, self.dv = None, None
+                return
+
+            if restfreq is None:
+                freq = np.mean(v_in)
+                print("restfreq is assumed to be the center.")
+            else:
+                freq = restfreq
+            v = v_in + h[f"CRVAL{vaxis}"]
+            key = f'CUNIT{vaxis}'
+            cunitv = h[key].strip()
+            match cunitv:
+                case "Hz" | "HZ":
+                    if freq == 0:
+                        print("v is read as is, because restfreq=0.")
+                    else:
+                        v = (1 - v / freq) * cu.c_kms - vsys
+                case "m/s" | "M/S":
+                    print(f'{key}={cunitv} found.')
+                    v = v * 1e-3 - vsys
+                case 'km/s' | "KM/S":
+                    print(f'{key}={cunitv} found.')
+                    v = v - vsys
+                case _:
+                    print(f'Unknown CUNIT3 {cunitv} found.'
+                          + ' v is read as is.')
+            dv = None if len(v) == 0 else v[1] - v[0]
+            self.v, self.dv = v, dv
+
+        return gen_v
+
+    def _get_array(self, i: int) -> np.ndarray:
+        h = self.header
+        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}"]
+        return s
+
     def gen_grid(self, center: str | None = None, dist: float = 1.,
                  restfreq: float | None = None, vsys: float = 0.,
                  pv: bool = False) -> None:
@@ -191,146 +322,20 @@ class FitsData:
         """
         h = self.get_header()
         # WCS rotation (Calabretta & Greisen 2002, Astronomy & Astrophysics, 395, 1077)
-        self.wcsrot = False
-        cdij = ['CD1_1', 'CD1_2', 'CD2_1', 'CD2_2']
-        if np.all([s in list(h.keys()) for s in cdij]):
-            self.wcsrot = True
-            cd11, cd12, cd21, cd22 = [h[s] for s in cdij]
-            if cd21 == 0:
-                rho_a = 0
-            else:
-                rho_a = np.arctan2(np.abs(cd21), np.sign(cd21) * cd11)
-            if cd12 == 0:
-                rho_b = 0
-            else:
-                rho_b = np.arctan2(np.abs(cd12), -np.sign(cd12) * cd22)
-            if (drho := np.abs(np.degrees(rho_a - rho_b))) > 1.0:
-                print('Angles from (CD21, CD11) and (CD12, CD22)'
-                      + f' are different by {drho:.2} degrees.')
-            crota2 = (rho_a + rho_b) / 2.
-            sin_rho = np.sin(crota2)
-            cos_rho = np.cos(crota2)
-            cdelt1 = cd11 * cos_rho + cd21 * sin_rho
-            cdelt2 = -cd12 * sin_rho + cd22 * cos_rho
-            crota2 = np.degrees(crota2)
-            h['CDELT1'] = cdelt1
-            h['CDELT2'] = cdelt2
-            del h['CD1_1']
-            del h['CD1_2']
-            del h['CD2_1']
-            del h['CD2_2']
-            print(f'WCS rotation was found (CROTA2 = {crota2:f} deg).')
-        # spatial center
-        if center is None or self.wcsrot:
-            cx, cy = 0, 0
+        self._read_cd()
+        gen_x, gen_y = self._get_genx_geny(center, dist)
+        restfreq = restfreq or h.get('RESTFRQ') or h.get('RESTFREQ')
+        gen_v = self._get_genv(restfreq, vsys, pv)
+        if pv:
+            gen_x(self._get_array(1))
+            gen_v(self._get_array(2))
+            self.y, self.dy = None, None
         else:
-            c0 = xy2coord([h['CRVAL1'], h['CRVAL2']])
-            if 'RADESYS' in h:
-                radesys = h['RADESYS']
-                c0 = f'{radesys}  {c0}'
-            cx, cy = coord2xy(center, c0)
-        # rest frequency
-        if restfreq is None:
-            if 'RESTFRQ' in h:
-                restfreq = h['RESTFRQ']
-            if 'RESTFREQ' in h:
-                restfreq = h['RESTFREQ']
-        self.x, self.y, self.v = None, None, None
-        self.dx, self.dy, self.dv = None, None, None
-
-        def get_list(i: int, crval=False) -> np.ndarray:
-            s = np.arange(h[f'NAXIS{i:d}'])
-            s = (s - h[f'CRPIX{i:d}'] + 1) * h[f'CDELT{i:d}']
-            if crval:
-                s = s + h[f'CRVAL{i:d}']
-            return s
-
-        def gen_x(s_in: np.ndarray) -> None:
-            s = (s_in - cx) * dist
-            if isdeg(h['CUNIT1']):
-                s *= 3600.
-            self.x, self.dx = s, s[1] - s[0]
-
-        def gen_y(s_in: np.ndarray) -> None:
-            s = (s_in - cy) * dist
-            if isdeg(h['CUNIT2']):
-                s *= 3600.
-            self.y, self.dy = s, s[1] - s[0]
-
-        def gen_v(s_in: np.ndarray) -> None:
-            if restfreq is None:
-                freq = np.mean(s_in)
-                print('restfreq is assumed to be the center.')
-            else:
-                freq = restfreq
-
-            vaxis = '2' if pv else '3'
-            key = f'CUNIT{vaxis}'
-            cunitv = h[key]
-            match cunitv.strip():
-                case 'Hz':
-                    if freq == 0:
-                        print('v is frequency because restfreq=0.')
-                        s = s_in * 1
-                    else:
-                        s = (1 - s_in / freq) * cu.c_kms - vsys
-                case 'HZ':
-                    if freq == 0:
-                        print('v is frequency because restfreq=0.')
-                        s = s_in * 1
-                    else:
-                        s = (1 - s_in / freq) * cu.c_kms - vsys
-                case 'm/s':
-                    print(f'{key}=\'m/s\' found.')
-                    s = s_in * 1e-3 - vsys
-                case 'M/S':
-                    print(f'{key}=\'M/S\' found.')
-                    s = s_in * 1e-3 - vsys
-                case 'km/s':
-                    print(f'{key}=\'km/s\' found.')
-                    s = s_in - vsys
-                case 'KM/S':
-                    print(f'{key}=\'KM/S\' found.')
-                    s = s_in - vsys
-                case _:
-                    print(f'Unknown CUNIT3 {cunitv} found.'
-                          + ' v is read as is.')
-                    s = s_in - vsys
-
-            self.v, self.dv = s, s[1] - s[0]
-
-        if h['NAXIS'] > 0 and h['NAXIS1'] > 1:
-            gen_x(get_list(1))
-        if h['NAXIS'] > 1 and h['NAXIS2'] > 1:
-            gen_v(get_list(2, True)) if pv else gen_y(get_list(2))
-        if h['NAXIS'] > 2 and h['NAXIS3'] > 1:
-            gen_v(get_list(3, True))
-
+            gen_x(self._get_array(1))
+            gen_y(self._get_array(2))
+            gen_v(self._get_array(3))
         if self.wcsrot:
-            data = self.get_data()
-            self.header['CRPIX1'] = ic = len(self.x) // 2
-            self.header['CRPIX2'] = jc = len(self.y) // 2
-            xc = self.x[ic] / self.dx
-            yc = self.y[jc] / self.dy
-            Mcd = [[cd11, cd12], [cd21, cd22]]
-            xc, yc = dot2d(Mcd, [xc, yc])
-            newcenter = xy2coord(xy=[xc, yc],
-                                 coordorg=self.get_center())
-            xc, yc = coord2xy(coords=newcenter,
-                              coordorg='00h00m00s 00d00m00s')
-            self.header['CRVAL1'] = xc
-            self.header['CRVAL2'] = yc
-            self.x = self.x - self.x[ic]
-            self.y = self.y - self.y[jc]
-            x = self.x / (3600 if isdeg(h['CUNIT1']) else 1)
-            y = self.y / (3600 if isdeg(h['CUNIT2']) else 1)
-            X, Y = np.meshgrid(x, y)
-            cdinv = np.linalg.inv([[cd11, cd12], [cd21, cd22]])
-            xnew, ynew = dot2d(cdinv, [X, Y])
-            datanew = RGIxy(self.y / self.dy, self.x / self.dx,
-                            data, (ynew, xnew))
-            self.data = datanew
-            print('Data values were interpolated for WCS rotation.')
+            self._rotate_cd()
 
     def get_grid(self, **kwargs) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """Output the grids, [x, y, v]. This method can take the arguments of gen_grid().
@@ -338,7 +343,7 @@ class FitsData:
         Returns:
             tuple: (x, y, v).
         """
-        if not hasattr(self, 'x') or not hasattr(self, 'y'):
+        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.7 → plotastrodata-1.9.9}/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)
@@ -149,7 +150,7 @@ def _get_gridwidth(mode: str, rmax: float, cos_dec: float
 def _get_v(p, v: np.ndarray | None = None,
            restfreq: float | None = None,
            vskip: int = 1) -> np.ndarray:
-    if p.fitsimage is not None:
+    if p.fitsimage is not None and v is None:
         p.read(d := AstroData(fitsimage=p.fitsimage,
                               restfreq=restfreq, sigma=None))
         v = d.v
@@ -1199,6 +1200,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 +1258,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,63 +1287,29 @@ 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)
+    set_rcparams(20, "w")
+    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].hlines([0], v.min(), v.max(), linestyle="dashed", color="k")
         ax[i].set_ylabel(ylabel[i])
         pa2.set_xyaxes(ax[i])
         if text is not None:
             ax[i].text(**text[i])
         if title is not None:
-            if type(title[i]) is str:
-                title[i] = {'label': title[i]}
+            if isinstance(title[i], str):
+                title[i] = {"label": title[i]}
             ax[i].set_title(**title[i])
         if i <= nprof - ncols - 1:
             plt.setp(ax[i].get_xticklabels(), visible=False)
@@ -1369,8 +1383,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 +1536,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.7 → plotastrodata-1.9.9/plotastrodata.egg-info}/PKG-INFO

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