plotastrodata 1.9.5__tar.gz → 1.9.7__tar.gz

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

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

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

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

@@ -575,6 +575,26 @@ class AstroData():
                   fitsimage=fitsimage)
 
 
+def _as_list(value, n: int, isbeam: bool = False):
+    if isbeam:
+        return [value] * n if np.ndim(value) == 1 else value
+    else:
+        return value if isinstance(value, list) else [value] * n
+
+
+def _scalar_if_single(value, n: int):
+    return value[0] if n == 1 else value
+
+
+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"]
+
+
 @dataclass
 class AstroFrame():
     """Parameter set to limit and reshape the data in the AstroData format.
@@ -666,6 +686,135 @@ class AstroFrame():
                 x[i], y[i] = rel2abs(*p, self.Xlim, self.Ylim)
         return np.array([x, y])
 
+    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"]
+        return None
+
+    def _read_fitsimage(self, d: AstroData, i: int, grid: list) -> list:
+        """Read FITS-derived values into d and return the FITS grid."""
+        if d.fitsimage[i] is None:
+            return grid
+
+        fd = FitsData(d.fitsimage[i])
+        if d.fitsheader[i] is None:
+            d.fitsheader[i] = fd.get_header()
+        if d.center[i] is None and not self.pv:
+            d.center[i] = fd.get_center()
+        if d.restfreq[i] is None:
+            d.restfreq[i] = self._get_restfreq(d.fitsheader[i])
+        d.data[i] = fd.get_data()
+        grid = fd.get_grid(center=d.center[i], dist=self.dist,
+                           restfreq=d.restfreq[i], vsys=self.vsys,
+                           pv=self.pv)
+        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")
+        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]):
+            return grid
+
+        cx, cy = coord2xy(d.center[i], self.center) * 3600
+        grid[0] = grid[0] + cx  # Don't use += cx.
+        grid[1] = grid[1] + cy  # Don't use += cy.
+        d.center[i] = self.center
+        return grid
+
+    def _ascending_v(self, d: AstroData, i: int, v: np.ndarray | None):
+        if v is not None and len(v) > 1 and v[1] < v[0]:
+            d.data[i], v = d.data[i][::-1], v[::-1]
+            print('Velocity has been inverted.')
+        d.v = v
+
+    def _xyskip(self, d: AstroData, i: int,
+                x: np.ndarray | None, y: np.ndarray | None):
+        d.x = x[::self.xskip]
+        d.y = y[::self.yskip]
+        data = np.moveaxis(d.data[i], [-2, -1], [0, 1])
+        data = data[::self.yskip, ::self.xskip]
+        d.data[i] = np.moveaxis(data, [0, 1], [-2, -1])
+
+    def _trim_skip(self, d: AstroData, i: int, grid: list):
+        d.data[i], grid = trim(data=d.data[i],
+                               x=grid[0], y=grid[1], v=grid[2],
+                               xlim=self.xlim, ylim=self.ylim,
+                               vlim=self.vlim, pv=self.pv)
+        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]]
+            d.data[i] = np.moveaxis(d.data[i], 1, 0)
+        self._xyskip(d, i, x=grid[0], y=grid[1])
+        for axis in ['x', 'y', 'v']:
+            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."""
+        if not d.Tb[i]:
+            return
+
+        dx = d.dy if self.swapxy else d.dx
+        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
+        factor = Jy2K(header=header)
+        d.data[i] = d.data[i] * factor
+        if d.sigma[i] is not None:
+            d.sigma[i] = d.sigma[i] * factor
+
+    def _set_pv_beam(self, d: AstroData, i: int):
+        """Set effective PV beam."""
+        if not self.pv or d.pv[i] or None in d.beam[i]:
+            return
+
+        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.")
+        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])
+
+    def _read_one(self, d: AstroData, i: int):
+        if d.center[i] == 'common':
+            d.center[i] = self.center
+        d.sigma_org[i] = d.sigma[i]
+        grid = self._read_fitsimage(d, i, grid=[d.x, d.y, d.v])
+        if d.data[i] is not None:
+            d.sigma[i] = estimate_rms(d.data[i], d.sigma[i])
+            grid = self._shift_center(d, i, grid)
+            self._trim_skip(d, i, grid)
+            if self.quadrants is not None:
+                d.data[i], d.x, d.y \
+                    = quadrantmean(d.data[i], d.x, d.y, self.quadrants)
+            d.data[i] = d.data[i] * d.cfactor[i]
+            if d.sigma[i] is not None:
+                d.sigma[i] = d.sigma[i] * d.cfactor[i]
+            self._convert_to_Tb(d, i)
+            self._set_pv_beam(d, i)
+            d.pv[i] = self.pv
+        d.Tb[i] = False
+        d.cfactor[i] = 1
+        d.fitsimage_org[i] = d.fitsimage[i]
+        d.fitsimage[i] = None
+
     def read(self, d: AstroData, xskip: int = 1, yskip: int = 1):
         """Get data, grid, sigma, beam, and bunit from AstroData, which is a part of the input of add_color, add_contour, add_segment, and add_rgb.
 
@@ -673,145 +822,12 @@ class AstroFrame():
             d (AstroData): Dataclass for the add_* input.
             xskip, yskip (int): Spatial pixel skip. Defaults to 1.
         """
-        if type(d.fitsimage) is not list:
-            d.fitsimage = [d.fitsimage] * d.n
-        if type(d.data) is not list:
-            d.data = [d.data] * d.n
-        if np.ndim(d.beam) == 1:
-            d.beam = [d.beam] * d.n
-        if type(d.Tb) is not list:
-            d.Tb = [d.Tb] * d.n
-        if type(d.sigma) is not list:
-            d.sigma = [d.sigma] * d.n
-        if type(d.center) is not list:
-            d.center = [d.center] * d.n
-        if type(d.restfreq) is not list:
-            d.restfreq = [d.restfreq] * d.n
-        if type(d.cfactor) is not list:
-            d.cfactor = [d.cfactor] * d.n
-        if type(d.bunit) is not list:
-            d.bunit = [d.bunit] * d.n
-        if type(d.fitsimage_org) is not list:
-            d.fitsimage_org = [d.fitsimage_org] * d.n
-        if type(d.sigma_org) is not list:
-            d.sigma_org = [d.sigma_org] * d.n
-        if type(d.beam_org) is not list:
-            d.beam_org = [d.beam_org] * d.n
-        if type(d.fitsheader) is not list:
-            d.fitsheader = [d.fitsheader] * d.n
-        if type(d.pv) is not list:
-            d.pv = [d.pv] * d.n
-        if type(d.pvpa) is not list:
-            d.pvpa = [d.pvpa] * d.n
-        grid0 = [d.x, d.y, d.v]
+        self.xskip = xskip
+        self.yskip = yskip
+        for name in ASTRODATA_ARGS:
+            setattr(d, name, _as_list(getattr(d, name), d.n))
+        d.beam = _as_list(d.beam, d.n, isbeam=True)
         for i in range(d.n):
-            if d.center[i] == 'common':
-                d.center[i] = self.center
-            grid = grid0.copy()
-            if d.fitsimage[i] is not None:
-                fd = FitsData(d.fitsimage[i])
-                if d.fitsheader[i] is None:
-                    d.fitsheader[i] = fd.get_header()
-                if d.center[i] is None and not self.pv:
-                    d.center[i] = fd.get_center()
-                if d.restfreq[i] is None:
-                    h = d.fitsheader[i]
-                    if 'NAXIS3' in h and h['NAXIS3'] == 1 and not self.pv:
-                        d.restfreq[i] = h['CRVAL3']
-                    elif 'RESTFRQ' in h:
-                        d.restfreq[i] = h['RESTFRQ']
-                    elif 'RESTFREQ' in h:
-                        d.restfreq[i] = h['RESTFREQ']
-                d.data[i] = fd.get_data()
-                grid = fd.get_grid(center=d.center[i], dist=self.dist,
-                                   restfreq=d.restfreq[i], vsys=self.vsys,
-                                   pv=self.pv)
-                if fd.wcsrot:
-                    d.center[i] = fd.get_center()  # for WCS rotation
-                d.beam[i] = fd.get_beam(dist=self.dist)
-                d.bunit[i] = fd.get_header('BUNIT')
-            if d.data[i] is not None:
-                d.sigma_org[i] = d.sigma[i]
-                d.sigma[i] = estimate_rms(d.data[i], d.sigma[i])
-                diffcent = (not self.pv
-                            and self.center is not None
-                            and d.center[i] is not None
-                            and d.center[i] != self.center)
-                if diffcent:
-                    cx, cy = coord2xy(d.center[i], self.center) * 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.data[i], grid = trim(data=d.data[i],
-                                       x=grid[0], y=grid[1], v=grid[2],
-                                       xlim=self.xlim, ylim=self.ylim,
-                                       vlim=self.vlim, pv=self.pv)
-                v = grid[2]
-                has_v = v is not None and len(v) > 1
-                if has_v and v[1] < v[0]:
-                    d.data[i], v = d.data[i][::-1], v[::-1]
-                    print('Velocity has been inverted.')
-                d.v = v
-                d.dv = v[1] - v[0] if has_v else None
-                grid = grid[:3:2] if self.pv else grid[:2]
-                if self.swapxy:
-                    grid = [grid[1], grid[0]]
-                    d.data[i] = np.moveaxis(d.data[i], 1, 0)
-                grid[0] = grid[0][::xskip]
-                grid[1] = grid[1][::yskip]
-                a = d.data[i]
-                a = np.moveaxis(a, [-2, -1], [0, 1])
-                a = a[::yskip, ::xskip]
-                a = np.moveaxis(a, [0, 1], [-2, -1])
-                d.data[i] = a
-                x, y = d.x, d.y = grid
-                has_x = x is not None and len(x) > 1
-                d.dx = x[1] - x[0] if has_x else None
-                has_y = y is not None and len(y) > 1
-                d.dy = y[1] - y[0] if has_y else None
-                if self.quadrants is not None:
-                    d.data[i], d.x, d.y \
-                        = quadrantmean(d.data[i], d.x, d.y, self.quadrants)
-                d.data[i] = d.data[i] * d.cfactor[i]
-                if d.sigma[i] is not None:
-                    d.sigma[i] = d.sigma[i] * d.cfactor[i]
-                if d.Tb[i]:
-                    dx = d.dy if self.swapxy else d.dx
-                    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
-                    d.data[i] = d.data[i] * Jy2K(header=header)
-                    d.sigma[i] = d.sigma[i] * Jy2K(header=header)
-                if self.pv and not d.pv[i] and None not in d.beam[i]:
-                    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.')
-                    p = np.radians(bpa - d.pvpa[i])
-                    b = 1 / np.hypot(np.cos(p) / bmaj, np.sin(p) / bmin)
-                    d.beam[i] = np.array([np.abs(d.dv), b, 0])
-                d.pv[i] = self.pv
-            d.Tb[i] = False
-            d.cfactor[i] = 1
-            if d.fitsimage[i] is not None:
-                d.fitsimage_org[i] = d.fitsimage[i]
-            d.fitsimage[i] = None
-        if d.n == 1:
-            d.data = d.data[0]
-            d.beam = d.beam[0]
-            d.fitsimage = d.fitsimage[0]
-            d.Tb = d.Tb[0]
-            d.sigma = d.sigma[0]
-            d.center = d.center[0]
-            d.restfreq = d.restfreq[0]
-            d.cfactor = d.cfactor[0]
-            d.bunit = d.bunit[0]
-            d.fitsimage_org = d.fitsimage_org[0]
-            d.sigma_org = d.sigma_org[0]
-            d.beam_org = d.beam_org[0]
-            d.fitsheader = d.fitsheader[0]
-            d.pv = d.pv[0]
-            d.pvpa = d.pvpa[0]
+            self._read_one(d, i)
+        for name in ASTRODATA_ARGS + ["beam"]:
+            setattr(d, name, _scalar_if_single(getattr(d, name), d.n))

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

@@ -29,7 +29,7 @@ def Jy2K(header=None, bmaj: float | None = None, bmin: float | None = None,
         else:
             print('Use CDELT1^2 for Tb conversion.')
             todiameter = np.sqrt(4 * np.log(2) / np.pi) * 3600
-            bmaj = bmin = header['CDELT1'] * todiameter
+            bmaj = bmin = np.abs(header['CDELT1']) * todiameter
             if header['CUNIT1'] == 'arcsec':
                 bmaj, bmin = bmaj / 3600, bmin / 3600
         if 'RESTFREQ' in header:

{plotastrodata-1.9.5 → plotastrodata-1.9.7}/plotastrodata/plot_utils.py

@@ -366,65 +366,77 @@ class PlotAxes2D():
     grid: dict | None = None
     aspect: dict | float | None = None
 
-    def set_xyaxes(self, ax):
+    def _set_scale(self):
+        ax = self.ax
         if self.loglog is not None:
-            self.xscale = 'log'
-            self.yscale = 'log'
+            self.xscale = self.yscale = 'log'
             self.samexy = True
-            if self.xlim is not None:
-                self.xlim[0] = self.xlim[1] / self.loglog
-            if self.ylim is not None:
-                self.ylim[0] = self.ylim[1] / self.loglog
+            for axis in ["x", "y"]:
+                attr = f"{axis}lim"
+                lim = getattr(self, attr)
+                if lim is not None:
+                    lim[0] = lim[1] / self.loglog
+                setattr(self, attr, lim)
         ax.set_xscale(self.xscale)
         ax.set_yscale(self.yscale)
+
+    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 = getattr(self, ticks_attr)
+        if ticks is None:
+            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)
+
+    def _make_ticks(self, ticks, ticksminor):
+        dt = ticks[1] - ticks[0]
+        t = np.r_[ticks[0] - dt, ticks, ticks[-1] + dt]
+        num = ticksminor * (len(t) - 1) + 1
+        return np.linspace(t[0], t[-1], num)
+
+    def _set_ticks(self, axis):
+        ax = self.ax
+        attr = f"{axis}ticks"
+        ticks = getattr(self, attr)
+        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)
+
+    def _apply_if_not_none(self, axis, attr):
+        ax = self.ax
+        method = getattr(ax, f"set_{axis}{attr}")
+        value = getattr(self, f"{axis}{attr}")
+        if value is not None:
+            if attr == "lim":
+                method(*value)
+            else:
+                method(value)
+
+    def set_xyaxes(self, ax):
+        self.ax = ax
+        self._set_scale()
         if self.samexy:
             ax.set_xticks(ax.get_yticks())
             ax.set_yticks(ax.get_xticks())
             ax.set_aspect(1)
-        if self.xticks is None:
-            self.xticks = ax.get_xticks()
-            if self.xscale == 'log':
-                self.xticks, self.xticklabels \
-                    = logticks(self.xticks, self.xlim)
-        if self.yticks is None:
-            self.yticks = ax.get_yticks()
-            if self.yscale == 'log':
-                self.yticks, self.yticklabels \
-                    = logticks(self.yticks, self.ylim)
-        ax.set_xticks(self.xticks)
-        ax.set_yticks(self.yticks)
-        if self.xticksminor is not None:
-            if type(self.xticksminor) is int:
-                t = ax.get_xticks()
-                dt = t[1] - t[0]
-                t = np.r_[t[0] - dt, t, t[-1] + dt]
-                num = self.xticksminor * (len(t) - 1) + 1
-                self.xticksminor = np.linspace(t[0], t[-1], num)
-            ax.set_xticks(self.xticksminor, minor=True)
-        if self.yticksminor is not None:
-            if type(self.yticksminor) is int:
-                t = ax.get_yticks()
-                dt = t[1] - t[0]
-                t = np.r_[t[0] - dt, t, t[-1] + dt]
-                num = self.yticksminor * (len(t) - 1) + 1
-                self.yticksminor = np.linspace(t[0], t[-1], num)
-            ax.set_yticks(self.yticksminor, minor=True)
-        if self.xticklabels is not None:
-            ax.set_xticklabels(self.xticklabels)
-        if self.yticklabels is not None:
-            ax.set_yticklabels(self.yticklabels)
-        if self.xlabel is not None:
-            ax.set_xlabel(self.xlabel)
-        if self.ylabel is not None:
-            ax.set_ylabel(self.ylabel)
-        if self.xlim is not None:
-            ax.set_xlim(*self.xlim)
-        if self.ylim is not None:
-            ax.set_ylim(*self.ylim)
+        for axis in ["x", "y"]:
+            self._init_ticks(axis)
+            self._set_ticks(axis)
+            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))
         if self.aspect is not None:
-            if type(self.aspect) is dict:
+            if isinstance(self.aspect, dict):
                 ax.set_aspect(**self.aspect)
             else:
                 ax.set_aspect(self.aspect)

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

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