plotastrodata 1.9.6__tar.gz → 1.9.8__tar.gz

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

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

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

{plotastrodata-1.9.6 → plotastrodata-1.9.8}/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,133 @@ 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 "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:
+        """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 _shift_center(self, d: AstroData, i: int, grid: list) -> list:
+        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(corg, cnew) * 3600
+        grid[0] = grid[0] + cx  # Don't use += cx.
+        grid[1] = grid[1] + cy  # Don't use += cy.
+        d.center[i] = cnew
+        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.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)))
+
+    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 +820,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.6 → plotastrodata-1.9.8}/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:
@@ -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.6 → plotastrodata-1.9.8}/plotastrodata/plot_utils.py

@@ -149,7 +149,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

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

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