plotastrodata 1.0.1__py3-none-any.whl

plotastrodata/fft_utils.py

@@ -0,0 +1,304 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+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:
+    """Shift the phase of 1D FFT by xoff.
+
+    Args:
+        F (np.ndarray): 1D FFT.
+        u (np.ndarray): 1D array. The first frequency coordinate.
+        xoff (float): From old to new center. Defaults to 0.
+
+    Returns:
+        np.ndarray: phase-shifted FFT.
+    """
+    return F * np.exp(1j * 2 * np.pi * u * xoff)
+
+
+def shiftphase2(F: np.ndarray, u: np.ndarray, v: np.ndarray,
+                xoff: float = 0, yoff: float = 0) -> np.ndarray:
+    """Shift the phase of 2D FFT by (xoff, yoff).
+
+    Args:
+        F (np.ndarray): 2D FFT.
+        u (np.ndarray): 1D or 2D array. The first frequency coordinate.
+        v (np.ndarray): 1D or 2D array. The second frequency coordinate. Defaults to None.
+        xoff (float): From old to new center. Defaults to 0.
+        yoff (float): From old to new center. Defaults to 0.
+
+    Returns:
+        np.ndarray: phase-shifted FFT.
+    """
+    (U, V) = np.meshgrid(u, v) if np.ndim(u) == 1 else (u, v)
+    return F * np.exp(1j * 2 * np.pi * (U * xoff + V * yoff))
+
+
+def fftcentering(f: np.ndarray, x: np.ndarray | None = None,
+                 xcenter: float = 0
+                 ) -> tuple[np.ndarray, np.ndarray]:
+    """FFT with the phase referring to a specific point.
+
+    Args:
+        f (np.ndarray): 1D array for FFT.
+        x (np.ndarray, optional): 1D array. The spatial coordinate. Defaults to None.
+        xcenter (float, optional): x of phase reference. Defaults to 0.
+
+    Returns:
+        tuple: (F, u). F is FFT of f. u is a 1D array of the frequency coordinate.
+    """
+    nx = np.shape(f)[0]
+    if x is None:
+        x = np.arange(nx)
+    X = x[0, :] if np.ndim(x) == 2 else x
+    dx = X[1] - X[0]
+    u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
+    F = np.fft.fftshift(np.fft.fft(f))
+    F = shiftphase(F, u=u, xoff=xcenter - X[-1] - dx)
+    return F, u
+
+
+def fftcentering2(f: np.ndarray,
+                  x: np.ndarray | None = None, y: np.ndarray | None = None,
+                  xcenter: float = 0, ycenter: float = 0
+                  ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """FFT with the phase referring to a specific point.
+
+    Args:
+        f (np.ndarray): 2D array for FFT.
+        x (np.ndarray, optional): 1D or 2D array. The first spatial coordinate. Defaults to None.
+        y (np.ndarray, optional): 1D or 2D array. The second spatial coordinate. Defaults to None.
+        xcenter (float, optional): x of phase reference. Defaults to 0.
+        ycenter (float, optional): y of phase reference. Defaults to 0.
+
+    Returns:
+        tuple: (F, u, v). F is FFT of f. u and v are 1D arrays of the frequency coordinates.
+    """
+    ny, nx = np.shape(f)
+    if x is None:
+        x = np.arange(nx)
+    if y is None:
+        y = np.arange(ny)
+    X = x[0, :] if np.ndim(x) == 2 else x
+    Y = y[:, 0] if np.ndim(y) == 2 else y
+    dx, dy = X[1] - X[0], Y[1] - Y[0]
+    u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
+    v = np.fft.fftshift(np.fft.fftfreq(ny, d=dy))
+    F = np.fft.fftshift(np.fft.fft2(f))
+    F = shiftphase2(F, u, v, xcenter - X[-1] - dx, ycenter - Y[-1] - dy)
+    return F, u, v
+
+
+def ifftcentering(F: np.ndarray, u: np.ndarray | None = None,
+                  xcenter: float = 0, x0: float = None, outreal: bool = True
+                  ) -> tuple[np.ndarray, np.ndarray]:
+    """inverse FFT with the phase referring to a specific point.
+
+    Args:
+        F (np.ndarray): 1D array. A result of FFT.
+        u (np.ndarray, optional): 1D array. The frequency coordinate. Defaults to None.
+        xcenter (float, optional): x of phase reference (used in fftcentering). Defaults to 0.
+        x0 (float, optional): spatial coordinate of x[0]. Defaults to None.
+        outreal (bool, optional): whether output only the real part. Defaults to True.
+
+    Returns:
+        tuple: (f, x). f is iFFT of F. x is a 1D array of the spatial coordinate.
+    """
+    nx = np.shape(F)[0]
+    if u is None:
+        u = np.fft.fftshift(np.fft.fftfreq(nx, d=1))
+    x = (np.arange(nx) - (nx-1)/2.) / (u[1]-u[0]) / nx + xcenter
+    if x0 is not None:
+        x = x - x[0] + x0
+    dx = x[1] - x[0]
+    F = shiftphase(F, u=u, xoff=x[-1] + dx - xcenter)
+    f = np.fft.ifft(np.fft.ifftshift(F))
+    if outreal:
+        f = np.real(f)
+    return f, x
+
+
+def ifftcentering2(F: np.ndarray,
+                   u: np.ndarray | None = None, v: np.ndarray | None = None,
+                   xcenter: float = 0, ycenter: float = 0,
+                   x0: float | None = None, y0: float | None = None,
+                   outreal: bool = True
+                   ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """inverse FFT with the phase referring to a specific point.
+
+    Args:
+        F (np.ndarray): 2D array. A result of FFT.
+        u (np.ndarray, optional): 1D or 2D array. The first frequency coordinate. Defaults to None.
+        v (np.ndarray, optional): 1D or 2D array. The second frequency cooridnate. Defaults to None.
+        xcenter (float, optional): x of phase reference (used in fftcentering2). Defaults to 0.
+        ycenter (float, optional): y of phase reference (used in fftcentering2). Defaults to 0.
+        x0 (float, optional): spatial coordinate of x[0]. Defaults to None.
+        y0 (float, optional): spatial coordinate of y[0]. Defaults to None.
+        outreal (bool, optional): whether output only the real part. Defaults to True.
+
+    Returns:
+        tuple: (f, x, y). f is iFFT of F. x and y are 1D arrays of the spatial coordinates.
+    """
+    ny, nx = np.shape(F)
+    if u is None:
+        u = np.fft.fftshift(np.fft.fftfreq(nx, d=1))
+    if v is None:
+        v = np.fft.fftshift(np.fft.fftfreq(ny, d=1))
+    x = (np.arange(nx) - (nx-1)/2.) / (u[1]-u[0]) / nx + xcenter
+    y = (np.arange(ny) - (ny-1)/2.) / (v[1]-v[0]) / ny + ycenter
+    if x0 is not None:
+        x = x - x[0] + x0
+    if y0 is not None:
+        y = y - y[0] + y0
+    dx, dy = x[1] - x[0], y[1] - y[0]
+    F = shiftphase(F, u, v, x[-1] + dx - xcenter, y[-1] + dy - ycenter)
+    f = np.fft.ifft2(np.fft.ifftshift(F))
+    if outreal:
+        f = np.real(f)
+    return f, x, y
+
+
+def zeropadding(f: np.ndarray, x: np.ndarray, y: np.ndarray,
+                xlim: list, ylim: list
+                ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Pad an outer region with zero.
+
+    Args:
+        f (np.ndarray): Input 2D array.
+        x (np.ndarray): 1D array.
+        y (np.ndarray): 1D array.
+        xlim (list): range of x after the zero padding.
+        ylim (list): range of y after the zero padding.
+
+    Returns:
+        tuple: (fnew, xnew, ynew). fnew is an 2D array and xnew and ynew are 1D arrays after the zero padding.
+    """
+    nx, ny = len(x), len(y)
+    dx, dy = x[1] - x[0], y[1] - y[0]
+    if dx < 0:
+        xlim = [xlim[1], xlim[0]]
+    if dy < 0:
+        ylim = [ylim[1], ylim[0]]
+    nx0 = max(int((x[0] - xlim[0]) / dx), 0)
+    nx1 = max(int((xlim[1] - x[-1]) / dx), 0)
+    nxnew = nx0 + nx + nx1
+    xnew = np.linspace(x[0] - nx0*dx, x[-1] + nx1*dx, nxnew)
+    ny0 = max(int((y[0] - ylim[0]) / dy), 0)
+    ny1 = max(int((ylim[1] - y[-1]) / dy), 0)
+    nynew = ny0 + ny + ny1
+    ynew = np.linspace(y[0] - ny0*dy, y[-1] + ny1*dy, nynew)
+    fnew = np.zeros((nynew, nxnew))
+    fnew[ny0:ny0 + ny, nx0:nx0 + nx] = f
+    return fnew, xnew, ynew
+
+
+def fftfits(fitsimage: str, center: str | None = None, lam: float = 1,
+            xlim: list | None = None, ylim: list | None = None,
+            plot: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """FFT a fits image with the phase referring to a specific point.
+
+    Args:
+        fitsimage (str): Input fits name in the unit of Jy/pixel.
+        center (str, optional): Text coordinate. Defaults to None.
+        lam (float, optional): Return u * lam and v * lam. Defaults to 1.
+        xlim (list, optional): Range of x for zero padding in arcsec.
+        ylim (list, optional): Range of y for zero padding in arcsec.
+        plot (bool, optional): Check F through images.
+
+    Returns:
+        tuple: (F, u, v). F is FFT of f in the unit of Jy. u and v are 1D arrays in the unit of lambda or meter if lam it not unity.
+    """
+    f, (x, y, v), _, _, _ = fits2data(fitsimage, center=center)
+    if xlim is not None and ylim is not None:
+        f, x, y = zeropadding(f, x, y, xlim, ylim)
+    arcsec = np.radians(1) / 3600.
+    F, u, v = fftcentering2(f, x * arcsec, y * arcsec)
+    u, v = u * lam, v * lam
+    if plot:
+        set_rcparams()
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(2, 2, 1)
+        m = ax.pcolormesh(u, v, np.real(F), shading='nearest', cmap='jet')
+        fig.colorbar(m, ax=ax, label='Real', format='%.1e')
+        ax.set_ylabel(r'v ($\lambda$)')
+        ax = fig.add_subplot(2, 2, 2)
+        m = ax.pcolormesh(u, v, np.imag(F), shading='nearest', cmap='jet')
+        fig.colorbar(m, ax=ax, label='Imaginary', format='%.1e')
+        ax = fig.add_subplot(2, 2, 3)
+        m = ax.pcolormesh(u, v, np.abs(F), shading='nearest', cmap='jet')
+        fig.colorbar(m, ax=ax, label='Amplitude', format='%.1e')
+        ax.set_xlabel(r'u ($\lambda$)')
+        ax.set_ylabel(r'v ($\lambda$)')
+        ax = fig.add_subplot(2, 2, 4)
+        m = ax.pcolormesh(u, v, np.angle(F) * np.degrees(1),
+                          shading='nearest', cmap='jet')
+        fig.colorbar(m, ax=ax, label='Phase (deg)', format='%.0f')
+        ax.set_xlabel(r'u ($\lambda$)')
+        fig.tight_layout()
+        plt.show()
+        plt.close()
+    return F, u, v
+
+
+def findindex(u: np.ndarray | None = None, v: np.ndarray | None = None,
+              uobs: np.ndarray | None = None, vobs: np.ndarray | None = None
+              ) -> np.ndarray:
+    """Find indicies of the observed visibility points.
+
+    Args:
+        u (np.ndarray, optional): 1D array. The first frequency coordinate. Defaults to None.
+        v (np.ndarray, optional): 1D array. The second frequency cooridnate. Defaults to None.
+        uobs (np.ndarray, optional): 1D array. Observed u. Defaults to None.
+        vobs (np.ndarray, optional): 1D array. Observed v. Defaults to None.
+
+    Returns:
+        np.ndarray: Indicies or an array of indicies.
+    """
+    if u is not None:
+        Nu, du = len(u), u[1] - u[0]
+    if v is not None:
+        Nv, dv = len(v), v[1] - v[0]
+    idx_u, idx_v = None, None
+    if uobs is not None:
+        idx_u = np.round(uobs / du + Nu // 2).astype(np.int64)
+    if vobs is not None:
+        idx_v = np.round(vobs / dv + Nv // 2).astype(np.int64)
+    if idx_u is not None and idx_v is not None:
+        return np.array([idx_u, idx_v])
+    if idx_u is not None:
+        return idx_u
+
+
+def fftfitssample(fitsimage: str, center: str | None = None,
+                  index_u: np.ndarray | None = None,
+                  index_v: np.ndarray | None = None,
+                  xlim: list | None = None, ylim: list | None = None,
+                  getindex: bool = False,
+                  u_sample: np.ndarray | None = None,
+                  v_sample: np.ndarray | None = None) -> np.ndarray:
+    """Find indicies or the visibilities on them from an image fits file.
+
+    Args:
+        fitsimage (str): Input fits name in the unit of Jy/pixel.
+        center (str, optional): Text coordinate. Defaults to None.
+        index_u (np.ndarray, optional): Indicies. Output from the getindex mode. Defaults to None.
+        index_v (np.ndarray, optional): Indicies. Output from the getindex mode. Defaults to None.
+        xlim (list, optional): Range of x for zero padding in arcsec.
+        ylim (list, optional): Range of y for zero padding in arcsec.
+        getindex (bool, optional): True outputs [index_u, index_v]. Defaults to False.
+        u_sample (np.ndarray, optional): 1D array. Observed u. Defaults to None.
+        v_sample (np.ndarray, optional): 1D array. Observed u. Defaults to None.
+
+    Returns:
+        np.ndarray: Array of indicies or sampled FFT.
+    """
+    F, u, v = fftfits(fitsimage=fitsimage, center=center, xlim=xlim, ylim=ylim)
+    if index_u is None or index_v is None:
+        index_u, index_v = findindex(u, v, u_sample, v_sample)
+    if getindex:
+        return np.array([index_u, index_v])
+    else:
+        return F[index_v, index_u]

plotastrodata/fits_utils.py

@@ -0,0 +1,325 @@
+import numpy as np
+from astropy.io import fits
+from astropy import constants, units, wcs
+
+from plotastrodata.other_utils import coord2xy, xy2coord, estimate_rms, trim
+
+
+def Jy2K(header=None, bmaj: float | None = None, bmin: float | None = None,
+         restfreq: float | None = None) -> float:
+    """Calculate a conversion factor in the unit of K/Jy.
+
+    Args:
+        header (optional): astropy.io.fits.open('a.fits')[0].header. Defaults to None.
+        bmaj (float, optional): beam major axis in degree. Defaults to None.
+        bmin (float, optional): beam minor axis in degree. Defaults to None.
+        freq (float, optional): rest frequency in Hz. Defaults to None.
+
+    Returns:
+        float: the conversion factor in the unit of K/Jy.
+    """
+    freq = None
+    if header is not None:
+        if 'BMAJ' in header and 'BMIN' in header:
+            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
+            if header['CUNIT1'] == 'arcsec':
+                bmaj, bmin = bmaj / 3600, bmin / 3600
+        if 'RESTFREQ' in header:
+            freq = header['RESTFREQ']
+        if 'RESTFRQ' in header:
+            freq = header['RESTFRQ']
+    if restfreq is not None:
+        freq = restfreq
+    if freq is None:
+        print('Please input restfreq.')
+        return 1
+    omega = bmaj * bmin * units.arcsec**2 * np.pi / 4. / np.log(2.)
+    equiv = units.brightness_temperature(freq * units.Hz, beam_area=omega)
+    T = (1 * units.Jy / units.beam).to(units.K, equivalencies=equiv)
+    return T.value
+
+
+class FitsData:
+    """For practical treatment of data in a FITS file.
+
+    Args:
+        fitsimage (str): Input FITS file name.
+    """
+    def __init__(self, fitsimage: str):
+        self.fitsimage = fitsimage
+
+    def gen_hdu(self) -> None:
+        """Generate self.hdu. fits.open()[0].
+        """
+        hdu = fits.open(self.fitsimage)
+        self.hdu = hdu[0]
+        if 'BEAMS' in hdu:
+            print('Beam table found in HDU list. Use median beam.')
+            b = hdu['BEAMS'].data
+            area = b['BMAJ'] * b['BMIN']  # arcsec^2?
+            imed = np.nanargmin(np.abs(area - np.nanmedian(area)))
+            self.hdubeam = b['BMAJ'][imed], b['BMIN'][imed], b['BPA'][imed]
+
+    def gen_header(self) -> None:
+        """Generate self.header. fits.open()[0].header.
+        """
+        if not hasattr(self, 'hdu'):
+            self.gen_hdu()
+        self.header = self.hdu.header
+
+    def get_header(self, key: str | None = None) -> dict | float:
+        """Output the entire header or a value when a key is given.
+
+        Args:
+            key (str, optional): Key name of the FITS header. Defaults to None.
+
+        Returns:
+            dict or float: The entire header or a value.
+        """
+        if not hasattr(self, 'header'):
+            self.gen_header()
+        if key is None:
+            return self.header
+        if key in self.header:
+            return self.header[key]
+        print(f'{key} is not in the header.')
+        return None
+
+    def gen_beam(self, dist: float = 1.) -> None:
+        """Generate sef.bmaj, self.bmin, self.bpa from header['BMAJ'], etc.
+
+        Args:
+            dist (float, optional): bmaj and bmin are multiplied by dist. Defaults to 1..
+        """
+        if hasattr(self, 'hdubeam'):
+            bmaj, bmin, bpa = self.hdubeam
+            bmaj = bmaj * dist
+            bmin = bmin * dist
+        else:
+            bmaj = self.get_header('BMAJ')
+            bmin = self.get_header('BMIN')
+            bpa = self.get_header('BPA')
+            if bmaj is not None:
+                bmaj = bmaj * 3600 * dist
+            if bmin is not None:
+                bmin = bmin * 3600 * dist
+        self.bmaj, self.bmin, self.bpa = bmaj, bmin, bpa
+
+    def get_beam(self, dist: float = 1.) -> np.ndarray:
+        """Output the beam array of [bmaj, bmin, bpa].
+
+        Args:
+            dist (float, optional): bmaj and bmin are multiplied by dist. Defaults to 1..
+
+        Returns:
+            np.ndarray: [bmaj, bmin, bpa].
+        """
+        if not hasattr(self, 'bmaj'):
+            self.gen_beam(dist)
+        return np.array([self.bmaj, self.bmin, self.bpa])
+
+    def get_center(self) -> str:
+        """Output the central coordinates as text.
+
+        Returns:
+            str: The central coordinates.
+        """
+        ra_deg = self.get_header('CRVAL1')
+        dec_deg = self.get_header('CRVAL2')
+        return xy2coord([ra_deg, dec_deg])
+
+    def gen_data(self, Tb: bool = False, log: bool = False,
+                 drop: bool = True, restfreq: float = None) -> None:
+        """Generate data, which may be brightness temperature.
+
+        Args:
+            Tb (bool, optional): True means the data are brightness temperatures. Defaults to False.
+            log (bool, optional): True means the data are after taking the logarithm to the base 10. Defaults to False.
+            drop (bool, optional): True means the data are after using np.squeeze. Defaults to True.
+            restfreq (float, optional): Rest frequency for calculating the brightness temperature. Defaults to None.
+        """
+        self.data = None
+        if not hasattr(self, 'hdu'):
+            self.gen_hdu()
+        h, d = self.hdu.header, self.hdu.data
+        if drop:
+            d = np.squeeze(d)
+        if Tb:
+            d *= Jy2K(header=h, restfreq=restfreq)
+        if log:
+            d = np.log10(d.clip(np.min(d[d > 0]), None))
+        self.data = d
+
+    def get_data(self, **kwargs) -> np.ndarray:
+        """Output data. This method can take the arguments of gen_data().
+
+        Returns:
+            np.ndarray: data in the format of np.ndarray.
+        """
+        if not hasattr(self, 'data'):
+            self.gen_data(**kwargs)
+        return self.data
+
+    def gen_grid(self, center: str | None = None, dist: float = 1.,
+                 restfreq: float | None = None, vsys: float = 0.,
+                 pv: bool = False) -> None:
+        """Generate grids relative to the center and vsys.
+
+        Args:
+            center (str, optional): Center for the spatial grids. Defaults to None.
+            dist (float, optional): The spatial grids are multiplied by dist. Defaults to 1..
+            restfreq (float, optional): Rest frequency for converting the frequencies to velocities. Defaults to None.
+            vsys (float, optional): The velocity is relative to vsys. Defaults to 0..
+            pv (bool, optional): Mode for position-velocity diagram. Defaults to False.
+        """
+        h = self.get_header()
+        # spatial center
+        if center is not None:
+            c0 = xy2coord([h['CRVAL1'], h['CRVAL2']])
+            cx, cy = coord2xy(coords=center, coordorg=c0)
+        else:
+            cx, cy = 0, 0
+        # 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: np.ndarray) -> None:
+            s = (s - cx) * dist
+            if h['CUNIT1'].strip() in ['deg', 'DEG', 'degree', 'DEGREE']:
+                s *= 3600.
+            self.x, self.dx = s, s[1] - s[0]
+
+        def gen_y(s: np.ndarray) -> None:
+            s = (s - cy) * dist
+            if h['CUNIT2'].strip() in ['deg', 'DEG', 'degree', 'DEGREE']:
+                s *= 3600.
+            self.y, self.dy = s, s[1] - s[0]
+
+        def gen_v(s: np.ndarray) -> None:
+            if restfreq is None:
+                freq = np.mean(s)
+                print('restfreq is assumed to be the center.')
+            else:
+                freq = restfreq
+            if freq == 0:
+                print('v is frequency because restfreq=0.')
+            else:
+                s = (1 - s / freq) * constants.c.to('km*s**(-1)').value - 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))
+
+    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().
+
+        Returns:
+            tuple: (x, y, v).
+        """
+        if not hasattr(self, 'x') or not hasattr(self, 'y'):
+            self.gen_grid(**kwargs)
+        return self.x, self.y, self.v
+
+    def trim(self, rmax: float = 1e10, xoff: float = 0., yoff: float = 0.,
+             vmin: float = -1e10, vmax: float = 1e10,
+             pv: bool = False) -> None:
+        """Trim the data and grids. The data range will be from xoff - rmax, yoff - rmax, vmin to xoff + rmax, yoff + rmax, vmax.
+
+        Args:
+            rmax (float, optional): Defaults to 1e10.
+            xoff (float, optional): Defaults to 0..
+            yoff (float, optional): Defaults to 0..
+            vmin (float, optional): Defaults to -1e10.
+            vmax (float, optional): Defaults to 1e10.
+            pv (bool, optional): Mode for position-velocity diagram. Defaults to False.
+        """
+        data = self.data if hasattr(self, 'data') else None
+        x = self.x if hasattr(self, 'x') else None
+        y = self.y if hasattr(self, 'y') else None
+        v = self.v if hasattr(self, 'v') else None
+        self.data, grid = trim(data=data, x=x, y=y, v=v,
+                               xlim=[xoff - rmax, xoff + rmax],
+                               ylim=[yoff - rmax, yoff + rmax],
+                               vlim=[vmin, vmax], pv=pv)
+        self.x, self.y, self.v = grid
+
+
+def fits2data(fitsimage: str, Tb: bool = False, log: bool = False,
+              dist: float = 1., sigma: str | None = None,
+              restfreq: float | None = None, center: str | None = None,
+              vsys: float = 0., pv: bool = False, **kwargs
+              ) -> tuple[np.ndarray, tuple[np.ndarray, np.ndarray, np.ndarray],
+                         tuple[float, float, float], float, float]:
+    """Extract data from a fits file. kwargs are arguments of FitsData.trim().
+
+    Args:
+        fitsimage (str): Input fits name.
+        Tb (bool, optional): True means ouput data are brightness temperature. Defaults to False.
+        log (bool, optional): True means output data are logarhismic. Defaults to False.
+        dist (float, optional): Change x and y in arcsec to au. Defaults to 1..
+        sigma (str, optional): Noise level or method for measuring it. Defaults to None.
+        restfreq (float, optional): Used for velocity and brightness temperature. Defaults to None.
+        center (str, optional): Text coordinates. Defaults to None.
+        vsys (float, optional): In the unit of km/s. Defaults to 0.
+        pv (bool, optional): True means PV fits file. Defaults to False.
+
+    Returns:
+        tuple: (data, (x, y, v), (bmaj, bmin, bpa), bunit, rms)
+    """
+    fd = FitsData(fitsimage)
+    fd.gen_data(Tb=Tb, log=log, drop=True, restfreq=restfreq)
+    rms = estimate_rms(fd.data, sigma)
+    fd.gen_grid(center=center, dist=dist, restfreq=restfreq, vsys=vsys, pv=pv)
+    fd.trim(pv=pv, **kwargs)
+    beam = fd.get_beam(dist=dist)
+    bunit = fd.get_header('BUNIT')
+    return fd.data, (fd.x, fd.y, fd.v), beam, bunit, rms
+
+
+def data2fits(d: np.ndarray | None = None, h: dict = {},
+              templatefits: str | None = None,
+              fitsimage: str = 'test') -> None:
+    """Make a fits file from a N-D array.
+
+    Args:
+        d (np.ndarray, optional): N-D array. Defaults to None.
+        h (dict, optional): Fits header. Defaults to {}.
+        templatefits (str, optional): Fits file to copy header. Defaults to None.
+        fitsimage (str, optional): Output name. Defaults to 'test'.
+    """
+    ctype0 = ["RA---SIN", "DEC--SIN", "VELOCITY"]
+    naxis = np.ndim(d)
+    w = wcs.WCS(naxis=naxis)
+    _h = {} if templatefits is None else FitsData(templatefits).get_header()
+    _h.update(h)
+    if _h == {}:
+        w.wcs.crpix = [0] * naxis
+        w.wcs.crval = [0] * naxis
+        w.wcs.cdelt = [1] * naxis
+        w.wcs.ctype = ctype0[:naxis]
+    header = w.to_header()
+    hdu = fits.PrimaryHDU(d, header=header)
+    for k in _h:
+        if not ('COMMENT' in k or 'HISTORY' in k):
+            hdu.header[k] = _h[k]
+    hdu = fits.HDUList([hdu])
+    hdu.writeto(fitsimage.replace('.fits', '') + '.fits', overwrite=True)