plotastrodata 1.5.0__tar.gz → 1.6.0__tar.gz

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.5.0
+Version: 1.6.0
 Summary: plotastrodata is a tool for astronomers to create figures from FITS files and perform fundamental data analyses with ease.
 Home-page: https://github.com/yusukeaso-astron/plotastrodata
 Download-URL: https://github.com/yusukeaso-astron/plotastrodata

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/__init__.py

@@ -1,4 +1,4 @@
 import warnings
 
 warnings.simplefilter('ignore', UserWarning)
-__version__ = '1.5.0'
+__version__ = '1.6.0'

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/analysis_utils.py

@@ -15,7 +15,8 @@ from plotastrodata.fitting_utils import EmceeCorner
 
 
 def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
-                 quadrants: str = '13') -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+                 quadrants: str = '13'
+                 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Take mean between 1st and 3rd (or 2nd and 4th) quadrants.
 
     Args:
@@ -67,6 +68,16 @@ def filled2d(data: np.ndarray, x: np.ndarray, y: np.ndarray, n: int = 1,
     return d, xnew, ynew
 
 
+def need_multipixel(method):
+    def wrapper(self, *args, **kwargs):
+        singlepixel = self.dx is None or self.dy is None
+        if singlepixel:
+            print('No pixel size.')
+            return
+        return method(self, *args, **kwargs)
+    return wrapper
+
+
 @dataclass
 class AstroData():
     """Data to be processed and parameters for processing the data.
@@ -132,23 +143,30 @@ class AstroData():
         Args:
             width (list, optional): Number of channels, y-pixels, and x-pixels for binning. Defaults to [1, 1, 1].
         """
-        width = [1] * (4 - len(width)) + width
+        w = [1] * (4 - len(width)) + list(width)
         d = to4dim(self.data)
-        size = list(np.shape(d))
-        newsize = size // np.array(width, dtype=int)
+        size = np.array(np.shape(d))
+        w = np.array(w, dtype=int)
+        if np.any(w > size):
+            w = np.minimum(w, size)
+            ws = ', '.join([f'{s:d}' for s in w[1:]])
+            print(f'width was changed to [{ws}].')
+        newsize = size // w
         grid = [None, self.v, self.y, self.x]
         for n in range(4):
-            if width[n] == 1:
+            if w[n] == 1 or grid[n] is None:
                 continue
             size[n] = newsize[n]
             olddata = np.moveaxis(d, n, 0)
             newdata = np.moveaxis(np.zeros(size), n, 0)
             t = np.zeros(newsize[n])
-            for i in range(width[n]):
-                t += grid[n][i:i + newsize[n]*width[n]:width[n]]
-                newdata += olddata[i:i + newsize[n]*width[n]:width[n]]
-            grid[n] = t / width[n]
-            d = np.moveaxis(newdata, 0, n) / width[n]
+            for i in range(w[n]):
+                i_stop = i + newsize[n] * w[n]
+                i_step = w[n]
+                t += grid[n][i:i_stop:i_step]
+                newdata += olddata[i:i_stop:i_step]
+            grid[n] = t / w[n]
+            d = np.moveaxis(newdata, 0, n) / w[n]
         self.data = np.squeeze(d)
         _, self.v, self.y, self.x = grid
 
@@ -188,6 +206,7 @@ class AstroData():
         else:
             print('No change because includexy=False and includev=False.')
 
+    @need_multipixel
     def circularbeam(self):
         """Make the beam circular by convolving with 1D Gaussian
         """
@@ -201,7 +220,8 @@ class AstroData():
         ny = len(self.y) if len(self.y) % 2 == 1 else len(self.y) - 1
         y = np.linspace(-(ny-1) / 2, (ny-1) / 2, ny) * np.abs(self.dy)
         g1 = np.exp(-4*np.log(2) * y**2 / (bmaj**2 - bmin**2))
-        g1 /= np.sqrt(np.pi/4/np.log(2) * bmin * np.sqrt(1 - bmin**2/bmaj**2))
+        e = np.sqrt(1 - bmin**2 / bmaj**2)
+        g1 /= np.sqrt(np.pi / 4 / np.log(2) * bmin * e)
         g = np.zeros((ny, nx))
         g[:, (nx - 1) // 2] = g1
         d = self.data.copy()
@@ -239,7 +259,9 @@ class AstroData():
             bmin_new = 1 / np.sqrt(alpha + Det)
             self.beam = np.array([bmaj_new, bmin_new, bpa_new])
 
-    def fit2d(self, model: object, bounds: np.ndarray, progressbar: bool = False,
+    @need_multipixel
+    def fit2d(self, model: object, bounds: np.ndarray,
+              progressbar: bool = False,
               kwargs_fit: dict = {}, kwargs_plotcorner: dict = {},
               chan: int | None = None):
         """Fit a given 2D model function to self.data.
@@ -257,7 +279,7 @@ class AstroData():
         """
         d = self.data if chan is None else self.data[chan]
         x, y = np.meshgrid(self.x, self.y)
-        if None not in self.beam and None not in [self.dx, self.dy]:
+        if None not in self.beam:
             Omega = np.pi * self.beam[0] * self.beam[1] / 4 / np.log(2)
             pixelperbeam = Omega / np.abs(self.dx * self.dy)
         else:
@@ -273,8 +295,9 @@ class AstroData():
         mcmc.fit(**kwargs_fit0)
         kwargs_plotcorner0 = {'show': False, 'savefig': None}
         kwargs_plotcorner0.update(kwargs_plotcorner)
-        if kwargs_plotcorner0['show'] or kwargs_plotcorner0['savefig'] is not None:
-            mcmc.plotcorner(**kwargs_plotcorner0)
+        kw_pl = kwargs_plotcorner0
+        if kw_pl['show'] or kw_pl['savefig'] is not None:
+            mcmc.plotcorner(**kw_pl)
         popt = mcmc.popt
         plow = mcmc.plow
         pmid = mcmc.pmid
@@ -284,6 +307,7 @@ class AstroData():
         return {'popt': popt, 'plow': plow, 'pmid': pmid, 'phigh': phigh,
                 'model': modelopt, 'residual': residual}
 
+    @need_multipixel
     def gaussfit2d(self, chan: int | None = None):
         """Fit a 2D Gaussian function to self.data.
 
@@ -311,7 +335,8 @@ class AstroData():
                                p0=p0, bounds=bounds)
         model = gaussian2d((x, y), *popt)
         residual = d - model
-        return {'popt': popt, 'pcov': pcov, 'model': model, 'residual': residual}
+        return {'popt': popt, 'pcov': pcov,
+                'model': model, 'residual': residual}
 
     def histogram(self, **kwargs) -> tuple:
         """Output histogram of self.data using numpy.histogram. This method can take the arguments of numpy.histogram.
@@ -415,10 +440,10 @@ class AstroData():
             best, error = [None] * nprof, [None] * nprof
             for i in range(nprof):
                 popt, pcov = curve_fit(gauss, v, prof[i], bounds=bounds)
-                e = np.sqrt(np.diag(pcov))
+                perr = np.sqrt(np.diag(pcov))
                 print('Gauss (peak, center, FWHM):', popt)
-                print('Gauss uncertainties:', e)
-                best[i], error[i] = popt, e
+                print('Gauss uncertainties:', perr)
+                best[i], error[i] = popt, perr
             gfitres = {'best': best, 'error': error}
         return v, prof, gfitres
 
@@ -445,8 +470,12 @@ class AstroData():
         Returns:
             np.ndarray: [x, data]. If self.data is 3D, the output data are in the shape of (len(v), len(x)).
         """
-        if dx is None:
+        if dx is None and self.dx is not None:
             dx = np.abs(self.dx)
+        if dx is None:
+            print('dx was not found. Please input dx.')
+            return
+
         n = int(np.ceil(length / 2 / dx))
         r = np.linspace(-n, n, 2 * n + 1) * dx
         pa_rad = np.radians(pa)
@@ -466,6 +495,7 @@ class AstroData():
              'sigma': self.sigma, 'center': self.center, 'pv': self.pv}
         return d
 
+    @need_multipixel
     def writetofits(self, fitsimage: str = 'out.fits', header: dict = {}):
         """Write out the AstroData to a FITS file.
 

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/fft_utils.py

@@ -5,7 +5,8 @@ from plotastrodata.fits_utils import fits2data
 from plotastrodata.plot_utils import set_rcparams
 
 
-def shiftphase(F: np.ndarray, u: np.ndarray, xoff: float = 0) -> np.ndarray:
+def shiftphase(F: np.ndarray, u: np.ndarray,
+               xoff: float = 0) -> np.ndarray:
     """Shift the phase of 1D FFT by xoff.
 
     Args:
@@ -93,7 +94,9 @@ def fftcentering2(f: np.ndarray,
 
 
 def ifftcentering(F: np.ndarray, u: np.ndarray | None = None,
-                  xcenter: float = 0, x0: float = None, outreal: bool = True
+                  xcenter: float = 0,
+                  x0: float = None,
+                  outreal: bool = True
                   ) -> tuple[np.ndarray, np.ndarray]:
     """inverse FFT with the phase referring to a specific point.
 

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/fits_utils.py

@@ -28,7 +28,8 @@ def Jy2K(header=None, bmaj: float | None = None, bmin: float | None = None,
             bmaj, bmin = header['BMAJ'] * 3600, header['BMIN'] * 3600
         else:
             print('Use CDELT1^2 for Tb conversion.')
-            bmaj = bmin = header['CDELT1'] * np.sqrt(4*np.log(2)/np.pi) * 3600
+            todiameter = np.sqrt(4 * np.log(2) / np.pi) * 3600
+            bmaj = bmin = header['CDELT1'] * todiameter
             if header['CUNIT1'] == 'arcsec':
                 bmaj, bmin = bmaj / 3600, bmin / 3600
         if 'RESTFREQ' in header:
@@ -244,21 +245,21 @@ class FitsData:
                 s = s + h[f'CRVAL{i:d}']
             return s
 
-        def gen_x(s: np.ndarray) -> None:
-            s = (s - cx) * dist
+        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: np.ndarray) -> None:
-            s = (s - cy) * dist
+        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: np.ndarray) -> None:
+        def gen_v(s_in: np.ndarray) -> None:
             if restfreq is None:
-                freq = np.mean(s)
+                freq = np.mean(s_in)
                 print('restfreq is assumed to be the center.')
             else:
                 freq = restfreq
@@ -271,28 +272,28 @@ class FitsData:
                     if freq == 0:
                         print('v is frequency because restfreq=0.')
                     else:
-                        s = (1 - s / freq) * cu.c_kms - vsys
+                        s = (1 - s_in / freq) * cu.c_kms - vsys
                 case 'HZ':
                     if freq == 0:
                         print('v is frequency because restfreq=0.')
                     else:
-                        s = (1 - s / freq) * cu.c_kms - vsys
+                        s = (1 - s_in / freq) * cu.c_kms - vsys
                 case 'm/s':
                     print(f'{key}=\'m/s\' found.')
-                    s = s * 1e-3 - vsys
+                    s = s_in * 1e-3 - vsys
                 case 'M/S':
                     print(f'{key}=\'M/S\' found.')
-                    s = s * 1e-3 - vsys
+                    s = s_in * 1e-3 - vsys
                 case 'km/s':
                     print(f'{key}=\'km/s\' found.')
-                    s = s - vsys
+                    s = s_in - vsys
                 case 'KM/S':
                     print(f'{key}=\'KM/S\' found.')
-                    s = s - vsys
+                    s = s_in - vsys
                 case _:
                     print(f'Unknown CUNIT3 {cunitv} found.'
                           + ' v is read as is.')
-                    s = s - vsys
+                    s = s_in - vsys
 
             self.v, self.dv = s, s[1] - s[0]
 

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/fitting_utils.py

@@ -36,7 +36,8 @@ class EmceeCorner():
 
     def __init__(self, bounds: np.ndarray, logl: object | None = None,
                  model: object | None = None,
-                 xdata: np.ndarray | None = None, ydata: np.ndarray | None = None,
+                 xdata: np.ndarray | None = None,
+                 ydata: np.ndarray | None = None,
                  sigma: np.ndarray = 1, progressbar: bool = True,
                  percent: list = [16, 84]):
         """Make bounds, logl, and logp for ptemcee.
@@ -88,7 +89,8 @@ class EmceeCorner():
         """
         global bar
         if nwalkersperdim < 2:
-            print(f'nwalkersperdim < 2 is not allowed. Use 2 instead of {nwalkersperdim:d}.')
+            print('nwalkersperdim < 2 is not allowed.'
+                  + f' Use 2 instead of {nwalkersperdim:d}.')
         nwalkers = max(nwalkersperdim, 2) * self.dim  # must be even and >= 2 * dim
         if ntemps > 1 and not pt:
             print('ntemps>1 is supported only with pt=True. Set pt=True.')
@@ -170,7 +172,8 @@ class EmceeCorner():
             print('')
 
     def plotcorner(self, show: bool = False,
-                   savefig: str | None = None, labels: list[str] | None = None,
+                   savefig: str | None = None,
+                   labels: list[str] | None = None,
                    cornerrange: list[float] | None = None) -> None:
         """Make the corner plot from self.samples.
 
@@ -184,8 +187,11 @@ class EmceeCorner():
             labels = [f'Par {i:d}' for i in range(self.dim)]
         if cornerrange is None:
             cornerrange = self.bounds
-        corner.corner(np.reshape(self.samples, (-1, self.dim)), truths=self.popt,
-                      quantiles=[self.percent[0] / 100, 0.5, self.percent[1] / 100],
+        corner.corner(np.reshape(self.samples, (-1, self.dim)),
+                      truths=self.popt,
+                      quantiles=[self.percent[0] / 100,
+                                 0.5,
+                                 self.percent[1] / 100],
                       show_titles=True, labels=labels, range=cornerrange)
         if savefig is not None:
             plt.savefig(savefig)
@@ -292,8 +298,10 @@ class EmceeCorner():
         self.evidence = evidence
 
     def plotongrid(self, show: bool = False, savefig: str | None = None,
-                   labels: list[str] = None, cornerrange: list[float] = None,
-                   cmap: str = 'binary', levels: list[float] = [0.011109, 0.135335, 0.606531]) -> None:
+                   labels: list[str] = None,
+                   cornerrange: list[float] = None, cmap: str = 'binary',
+                   levels: list[float] = [0.011109, 0.135335, 0.606531]
+                   ) -> None:
         """Make the corner plot from the posterior calculated on a grid.
 
         Args:
@@ -380,7 +388,10 @@ class EmceeCorner():
         """Calculate the Bayesian evidence for a model using dynamic nested sampling through dynesty.
         """
         def prior_transform(u):
-            return self.bounds[:, 0] + (self.bounds[:, 1] - self.bounds[:, 0]) * u
+            b0 = self.bounds[:, 0]
+            b1 = self.bounds[:, 1]
+            return b0 + (b1 - b0) * u
+
         dsampler = DNS(loglikelihood=self.logl,
                        prior_transform=prior_transform,
                        ndim=self.dim, **kwargs)

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/los_utils.py

@@ -74,7 +74,8 @@ def sys2obs(xsys: np.ndarray, ysys: np.ndarray, zsys: np.ndarray,
 
 def polarvel2losvel(v_r: np.ndarray, v_theta: np.ndarray, v_phi: np.ndarray,
                     theta: np.ndarray, phi: np.ndarray,
-                    incl: float = 0, phi0: float = 0, theta0: float = 90) -> np.ndarray:
+                    incl: float = 0, phi0: float = 0, theta0: float = 90
+                    ) -> np.ndarray:
     """Convert the polar velocities in the system's coordinates to the line-of-sight velocity in the observer's coordinates. In the system coordinates, the observer is at the direction of (0, -sin i, cos i). The observer's +z (i.e., line-of-sight) is from the observer to the system. The system's x coordinate and the observer's x coordinate have opposite signs.
 
     Args:

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/other_utils.py

@@ -36,7 +36,8 @@ def isdeg(s: str) -> bool:
         return False
 
 
-def estimate_rms(data: np.ndarray, sigma: float | str | None = 'hist') -> float:
+def estimate_rms(data: np.ndarray, sigma: float | str | None = 'hist'
+                 ) -> float:
     """Estimate a noise level of a N-D array.
        When a float number or None is given, this function just outputs it.
        Following methos are acceptable.
@@ -123,7 +124,8 @@ def trim(data: np.ndarray | None = None, x: np.ndarray | None = None,
          xlim: list[float, float] | None = None,
          ylim: list[float, float] | None = None,
          vlim: list[float, float] | None = None,
-         pv: bool = False) -> tuple[np.ndarray, list[np.ndarray, np.ndarray, np.ndarray]]:
+         pv: bool = False
+         ) -> tuple[np.ndarray, list[np.ndarray, np.ndarray, np.ndarray]]:
     """Trim 2D or 3D data by given coordinates and their limits.
 
     Args:
@@ -270,7 +272,8 @@ def RGIxyv(v: np.ndarray, y: np.ndarray, x: np.ndarray, data: np.ndarray,
 
 def gaussian2d(xy: np.ndarray,
                amplitude: float, xo: float, yo: float,
-               fwhm_major: float, fwhm_minor: float, pa: float) -> np.ndarray:
+               fwhm_major: float, fwhm_minor: float, pa: float
+               ) -> np.ndarray:
     """Two dimensional Gaussian function.
 
     Args:

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata/plot_utils.py

@@ -167,8 +167,8 @@ class PlotAxes2D():
 
 
 def set_minmax(data: np.ndarray, stretch: str, stretchscale: float,
-               stretchpower: float,
-               rms: float, kw: dict) -> np.ndarray:
+               stretchpower: float, rms: float, kw: dict
+               ) -> np.ndarray:
     """Set vmin and vmax for color pcolormesh and RGB maps.
 
     Args:
@@ -203,8 +203,8 @@ def set_minmax(data: np.ndarray, stretch: str, stretchscale: float,
         elif st == 'power':
             cmin = kw['min'][i] if 'vmin' in kw else r
             c = c.clip(cmin, None)
-            c = ((c / cmin)**(1 - stretchpower) - 1) \
-                / (1 - stretchpower) / np.log(10)
+            p = 1 - stretchpower
+            c = ((c / cmin)**p - 1) / p / np.log(10)
         data[i] = c
     n = len(data)
     for m in ['vmin', 'vmax']:
@@ -215,13 +215,12 @@ def set_minmax(data: np.ndarray, stretch: str, stretchscale: float,
                 elif st == 'asinh':
                     kw[m][i] = np.arcsinh(kw[m][i] / stsc)
                 elif st == 'power':
-                    kw[m][i] = ((kw[m][i]/c.min())**(1 - stretchpower) - 1) \
-                               / (1 - stretchpower) / np.log(10)
+                    p = 1 - stretchpower
+                    kw[m][i] = ((kw[m][i]/c.min())**p - 1) / p / np.log(10)
         else:
             kw[m] = [None] * n
             for i, (c, st, _, r) in enumerate(zip(*z)):
                 if m == 'vmin':
-
                     kw[m][i] = np.log10(r) if st == 'log' else np.nanmin(c)
                 else:
                     kw[m][i] = np.nanmax(c)
@@ -344,12 +343,16 @@ class PlotAstroData(AstroFrame):
         fig (optional): External plt.figure(). Defaults to None.
         ax (optional): External fig.add_subplot(). Defaults to None.
     """
-    def __init__(self, v: np.ndarray = np.array([0]), vskip: int = 1,
+    def __init__(self,
+                 v: np.ndarray = np.array([0]), vskip: int = 1,
                  veldigit: int = 2, restfreq: float | None = None,
-                 channelnumber: int | None = None, nrows: int = 4, ncols: int = 6,
-                 fontsize: int | None = None, nancolor: str = 'w', dpi: int = 256,
+                 channelnumber: int | None = None,
+                 nrows: int = 4, ncols: int = 6,
+                 fontsize: int | None = None,
+                 nancolor: str = 'w', dpi: int = 256,
                  figsize: tuple[float, float] | None = None,
-                 fig: object | None = None, ax: object | None = None, **kwargs) -> None:
+                 fig: object | None = None, ax: object | None = None,
+                 **kwargs) -> None:
         super().__init__(**kwargs)
         internalfig = fig is None
         internalax = ax is None
@@ -455,6 +458,37 @@ class PlotAstroData(AstroFrame):
             return np.concatenate((d, dnan), axis=0)
         self.vskipfill = vskipfill
 
+    def _map_init(self, kw: dict) -> tuple:
+        """
+        Common process for add_color, add_contour, add_segment, and add_rgb.
+        xskip and yskip (int) mean spatial pixel skips, which defaults to 1.
+
+        Args:
+            kw (dict): kwargs input for each method.
+
+        Returns:
+            tuple: Data and parameters used in each method.
+        """
+        beam_kwargs = kwargs2beamargs(kw)
+        self._kw.update(kw)
+        if 'xskip' in self._kw:
+            xskip = self._kw['xskip']
+            del self._kw['xskip']
+        else:
+            xskip = 1
+        if 'yskip' in self._kw:
+            yskip = self._kw['yskip']
+            del self._kw['yskip']
+        else:
+            yskip = 1
+        d = kwargs2AstroData(self._kw)
+        self.read(d, xskip, yskip)
+        self.beam = d.beam
+        self.sigma = d.sigma
+        singlepix = d.dx is None or d.dy is None
+        return (d.data, d.x, d.y, d.v, d.beam, d.sigma, d.bunit,
+                self._kw, beam_kwargs, singlepix)
+
     def add_region(self, patch: str = 'ellipse',
                    poslist: list[str | list[float, float]] = [],
                    majlist: list[float] = [], minlist: list[float] = [],
@@ -666,18 +700,20 @@ class PlotAstroData(AstroFrame):
             axnow.plot([x[0] - length/2., x[0] + length/2.], [y[0], y[0]],
                        '-', linewidth=linewidth, color=color)
 
-    def add_color(self, xskip: int = 1, yskip: int = 1,
+    def add_color(self,
                   stretch: str = 'linear',
                   stretchscale: float | None = None,
                   stretchpower: float = 0,
-                  show_cbar: bool = True, cblabel: str | None = None,
-                  cbformat: float = '%.1e', cbticks: list[float] | None = None,
-                  cbticklabels: list[str] | None = None, cblocation: str = 'right',
+                  show_cbar: bool = True,
+                  cblabel: str | None = None,
+                  cbformat: float = '%.1e',
+                  cbticks: list[float] | None = None,
+                  cbticklabels: list[str] | None = None,
+                  cblocation: str = 'right',
                   **kwargs) -> None:
-        """Use Axes.pcolormesh of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail.
+        """Use Axes.pcolormesh of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
-            xskip, yskip (int, optional): Spatial pixel skip. Defaults to 1.
             stretch (str, optional): 'log' means the mapped data are logarithmic. 'asinh' means the mapped data are arc sin hyperbolic. 'power' means the mapped data are power-law (see also stretchpower). Defaults to 'linear'.
             stretchscale (float, optional): color scale is asinh(data / stretchscale). Defaults to None.
             stretchpower (float, optional): color scale is ((data / vmin)**(1 - stretchpower) - 1) / (1 - stretchpower) / ln(10). 0 means the linear scale. 1 means the logarithmic scale. Defaults to 0.
@@ -688,16 +724,14 @@ class PlotAstroData(AstroFrame):
             cbticklabels (list, optional): Ticklabels of colorbar. Defaults to None.
             cblocation (str, optional): 'left', 'top', 'left', 'right'. Only for 2D images. Defaults to 'right'.
         """
-        _kw = {'cmap': 'cubehelix', 'alpha': 1,
-               'edgecolors': 'none', 'zorder': 1}
-        beam_kwargs = kwargs2beamargs(kwargs)
-        _kw.update(kwargs)
-        d = kwargs2AstroData(_kw)
-        self.read(d, xskip, yskip)
-        c, x, y, v, beam, sigma = d.data, d.x, d.y, d.v, d.beam, d.sigma
-        bunit = d.bunit
-        self.beam = beam
-        self.sigma = sigma
+        self._kw = {'cmap': 'cubehelix', 'alpha': 1,
+                    'edgecolors': 'none', 'zorder': 1}
+        c, x, y, v, beam, sigma, bunit, _kw, beam_kwargs, singlepix \
+            = self._map_init(kwargs)
+        if singlepix:
+            print('No pixel size. Skip add_color.')
+            return
+
         if stretchscale is None:
             stretchscale = sigma
         cmin_org = _kw['vmin'] if 'vmin' in _kw else sigma
@@ -732,8 +766,9 @@ class PlotAstroData(AstroFrame):
                 elif stretch == 'asinh':
                     cbticks = np.arcsinh(np.array(cbticks) / stretchscale)
                 elif stretch == 'power':
-                    cbticks = (np.array(cbticks) / cmin_org)**(1 - stretchpower)
-                    cbticks = (cbticks - 1) / (1 - stretchpower) / np.log(10)
+                    cbticks = np.array(cbticks)
+                    p = 1 - stretchpower
+                    cbticks = ((cbticks / cmin_org)**p - 1) / p / np.log(10)
                 cb.set_ticks(cbticks)
             if cbticklabels is not None:
                 cb.set_ticklabels(cbticklabels)
@@ -746,28 +781,26 @@ class PlotAstroData(AstroFrame):
                 elif stretch == 'asinh':
                     ticklin = np.sinh(t) * stretchscale
                 elif stretch == 'power':
-                    ticklin = 1 + (1 - stretchpower) * np.log(10) * t
-                    ticklin = cmin_org * ticklin**(1 / (1 - stretchpower))
+                    p = 1 - stretchpower
+                    ticklin = cmin_org * (1 + p * np.log(10) * t)**(1 / p)
                 cb.set_ticklabels([f'{d:{cbformat[1:]}}' for d in ticklin])
         self.add_beam(beam=beam, **beam_kwargs)
 
-    def add_contour(self, xskip: int = 1, yskip: int = 1,
+    def add_contour(self,
                     levels: list[float] = [-12, -6, -3, 3, 6, 12, 24, 48, 96, 192, 384],
                     **kwargs) -> None:
-        """Use Axes.contour of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail.
+        """Use Axes.contour of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
-            xskip, yskip (int, optional): Spatial pixel skip. Defaults to 1.
             levels (list, optional): Contour levels in the unit of sigma. Defaults to [-12,-6,-3,3,6,12,24,48,96,192,384].
         """
-        _kw = {'colors': 'gray', 'linewidths': 1.0, 'zorder': 2}
-        beam_kwargs = kwargs2beamargs(kwargs)
-        _kw.update(kwargs)
-        d = kwargs2AstroData(_kw)
-        self.read(d, xskip, yskip)
-        c, x, y, v, beam, sigma = d.data, d.x, d.y, d.v, d.beam, d.sigma
-        self.beam = beam
-        self.sigma = sigma
+        self._kw = {'colors': 'gray', 'linewidths': 1.0, 'zorder': 2}
+        c, x, y, v, beam, sigma, _, _kw, beam_kwargs, singlepix \
+            = self._map_init(kwargs)
+        if singlepix:
+            print('No pixel size. Skip add_contour.')
+            return
+
         c = self.vskipfill(c, v)
         if type(self.channelnumber) is int:
             c = [c[self.channelnumber]]
@@ -775,9 +808,9 @@ class PlotAstroData(AstroFrame):
             axnow.contour(x, y, cnow, np.sort(levels) * sigma, **_kw)
         self.add_beam(beam=beam, **beam_kwargs)
 
-    def add_segment(self, ampfits: str = None, angfits: str = None,
+    def add_segment(self,
+                    ampfits: str = None, angfits: str = None,
                     Ufits: str = None, Qfits: str = None,
-                    xskip: int = 1, yskip: int = 1,
                     amp: list[np.ndarray] | None = None,
                     ang: list[np.ndarray] | None = None,
                     stU: list[np.ndarray] | None = None,
@@ -786,14 +819,13 @@ class PlotAstroData(AstroFrame):
                     rotation: float = 0.,
                     cutoff: float = 3.,
                     **kwargs) -> None:
-        """Use Axes.quiver of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. fitsimage = [ampfits, angfits, Ufits, Qfits]. data = [amp, ang, stU, stQ]. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail.
+        """Use Axes.quiver of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. fitsimage = [ampfits, angfits, Ufits, Qfits]. data = [amp, ang, stU, stQ]. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
             ampfits (str, optional): In put fits name. Length of segment. Defaults to None.
             angfits (str, optional): In put fits name. North to east. Defaults to None.
             Ufits (str, optional): In put fits name. Stokes U. Defaults to None.
             Qfits (str, optional): In put fits name. Stokes Q. Defaults to None.
-            xskip, yskip (int, optional): Spatial pixel skip. Defaults to 1.
             amp (list, optional): Length of segment. Defaults to None.
             ang (list, optional): North to east. Defaults to None.
             stU (list, optional): Stokes U. Defaults to None.
@@ -803,16 +835,17 @@ class PlotAstroData(AstroFrame):
             rotation (float, optional): Segment angle is ang + rotation. Defaults to 0..
             cutoff (float, optional): Used when amp and ang are calculated from Stokes U and Q. In the unit of sigma. Defaults to 3..
         """
-        _kw = {'angles': 'xy', 'scale_units': 'xy', 'color': 'gray',
-               'pivot': 'mid', 'headwidth': 0, 'headlength': 0,
-               'headaxislength': 0, 'width': 0.007, 'zorder': 3}
-        beam_kwargs = kwargs2beamargs(kwargs)
-        _kw.update(kwargs)
-        _kw['data'] = [amp, ang, stU, stQ]
-        _kw['fitsimage'] = [ampfits, angfits, Ufits, Qfits]
-        d = kwargs2AstroData(_kw)
-        self.read(d, xskip, yskip)
-        c, x, y, v, beam, sigma = d.data, d.x, d.y, d.v, d.beam, d.sigma
+        self._kw = {'angles': 'xy', 'scale_units': 'xy', 'color': 'gray',
+                    'pivot': 'mid', 'headwidth': 0, 'headlength': 0,
+                    'headaxislength': 0, 'width': 0.007, 'zorder': 3,
+                    'fitsimage': [ampfits, angfits, Ufits, Qfits],
+                    'data': [amp, ang, stU, stQ]}
+        c, x, y, v, beam, sigma, _, _kw, beam_kwargs, singlepix \
+            = self._map_init(kwargs)
+        if singlepix:
+            print('No pixel size. Skip add_segment.')
+            return
+
         amp, ang, stU, stQ = c
         sigmaU, sigmaQ = sigma[2:]
         beam = [beam[i] for i in range(4) if beam[i][0] is not None][0]
@@ -834,34 +867,32 @@ class PlotAstroData(AstroFrame):
         if type(self.channelnumber) is int:
             U = [U[self.channelnumber]]
             V = [V[self.channelnumber]]
-        _kw['scale'] = 1 if len(x) == 1 else 1. / np.abs(x[1] - x[0])
+        _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)
         self.add_beam(beam=beam, **beam_kwargs)
 
-    def add_rgb(self, xskip: int = 1, yskip: int = 1,
+    def add_rgb(self,
                 stretch: list[str, str, str] = ['linear'] * 3,
                 stretchscale: list[float | None, float | None, float | None] = [None] * 3,
                 stretchpower: float = 0,
                 **kwargs) -> None:
-        """Use PIL.Image and imshow of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. A three-element array ([red, green, blue]) is supposed for all arguments, except for xskip, yskip and show_beam, including vmax and vmin. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail.
+        """Use PIL.Image and imshow of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. A three-element array ([red, green, blue]) is supposed for all arguments, except for xskip, yskip and show_beam, including vmax and vmin. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
-            xskip, yskip (int, optional): Spatial pixel skip. Defaults to 1.
             stretch (str, optional): 'log' means the mapped data are logarithmic. 'asinh' means the mapped data are arc sin hyperbolic. 'power' means the mapped data are power-law (see also stretchpower). Defaults to 'linear'.
             stretchscale (float, optional): color scale is asinh(data / stretchscale). Defaults to None.
             stretchpower (float, optional): color scale is ((data / vmin)**(1 - stretchpower) - 1) / (1 - stretchpower) / ln(10). 0 means the linear scale. 1 means the logarithmic scale. Defaults to 0.
         """
         from PIL import Image
 
-        _kw = {}
-        beam_kwargs = kwargs2beamargs(kwargs)
-        _kw.update(kwargs)
-        d = kwargs2AstroData(_kw)
-        self.read(d, xskip, yskip)
-        c, x, y, v, beam, sigma = d.data, d.x, d.y, d.v, d.beam, d.sigma
-        self.beam = beam
-        self.sigma = sigma
+        self._kw = {}
+        c, x, y, v, beam, sigma, _, _kw, beam_kwargs, singlepix \
+            = self._map_init(kwargs)
+        if singlepix:
+            print('No pixel size. Skip add_rgb.')
+            return
+
         for i in range(len(stretchscale)):
             if stretchscale[i] is None:
                 stretchscale[i] = sigma[i]
@@ -951,7 +982,8 @@ class PlotAstroData(AstroFrame):
                        xlabel: str = 'R.A. (ICRS)',
                        ylabel: str = 'Dec. (ICRS)',
                        nticksminor: int = 2,
-                       grid: dict | None = None, title: dict | None = None) -> None:
+                       grid: dict | None = None, title: dict | None = None
+                       ) -> None:
         """Use Axes.set_* of matplotlib. kwargs can include the arguments of PlotAxes2D to adjust x and y axis.
 
         Args:
@@ -1095,7 +1127,8 @@ def plotprofile(coords: list[str] | str = [],
                 ninterp: int = 1,
                 flux: bool = False, width: int = 1,
                 gaussfit: bool = False, gauss_kwargs: dict = {},
-                title: list[str] | None = None, text: list[str] | None = None,
+                title: list[str] | None = None,
+                text: list[str] | None = None,
                 dist: float = 1., vsys: float = 0.,
                 nrows: int = 0, ncols: int = 1, fig=None, ax=None,
                 getfigax: bool = False,
@@ -1365,7 +1398,8 @@ def plot3d(levels: list[float] = [3, 6, 12],
             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.')
+            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],
@@ -1418,4 +1452,5 @@ def plot3d(levels: list[float] = [3, 6, 12],
         return {'data': data, 'layout': layout}
     else:
         fig = go.Figure(data=data, layout=layout)
-        fig.write_html(file=outname.replace('.html', '') + '.html', auto_play=show)
+        fig.write_html(file=outname.replace('.html', '') + '.html',
+                       auto_play=show)

{plotastrodata-1.5.0 → plotastrodata-1.6.0}/plotastrodata.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.5.0
+Version: 1.6.0
 Summary: plotastrodata is a tool for astronomers to create figures from FITS files and perform fundamental data analyses with ease.
 Home-page: https://github.com/yusukeaso-astron/plotastrodata
 Download-URL: https://github.com/yusukeaso-astron/plotastrodata