hdul[0].data[ind0:ind1, :, :] = data[dataslice, slices[1],
                                                     slices[2]]
                log.info("Flushing")
                hdul.flush()
                log.info("Done with iteration for {0}".format(fn))

    if debug_mode:
        log.setLevel(lvl)


if __name__ == "__main__":
    for spw in (0, 1, 2, 3):

        mxind = get_max_ind('OrionSourceI.B3.spw{0}.lines*fits'.format(spw, ))
        if mxind < min_nchans:
            log.critical("Skipping {0} b/c only {1} chans".format(spw, mxind))
            continue
        nchans_total[spw] = mxind
        log.info("nchans_total[{0}] = {1}".format(spw, mxind))

        if os.path.exists(
                'OrionSourceI.B3.spw{0}.lines0-60.clarkclean1000.image.pbcor.fits'
                .format(spw)):

            make_spw_cube(
                spw='spw{0}',
                spwnum=spw,
                fntemplate='full_OrionSourceI_B3',
                overwrite_existing=False,
                bmaj_limits=None,
                fnsuffix="",
Esempio n. 2
0
def fits2bitmap(filename,
                exten=0,
                out_fn=None,
                scale='linear',
                power=1.0,
                noise_level=None,
                min_cut=None,
                max_cut=None,
                min_percent=None,
                max_percent=None,
                percent=None,
                cmap='Greys_r'):
    """
    Create a bitmap file from a FITS image, applying a
    scaling/stretching transform between minimum and maximum cut levels
    and a matplotlib colormap.

    Parameters
    ----------
    filename : str
        The filename of the FITS file.

    exten : int
        FITS extension number of the image to convert.  The default is 0.

    out_fn : str
        The filename of the output bitmap image.  The type of bitmap
        is determined by the filename extension (e.g. '.jpg', '.png').
        The default is a PNG file with the same name as the FITS file.

    scale : {{'linear', 'sqrt', 'power', log', 'asinh'}}
        The scaling/stretch function to apply to the image.  The default
        is 'linear'.

    power : float, optional
        The power index for the image scaling.  The default is 1.0.

    noise_level : float, optional
        The noise level of the image.  Pixel values less than
        ``noise_level`` will approximately be linearly scaled, while
        pixel values greater than ``noise_level`` will approximately be
        logarithmically scaled.  If ``noise_level`` is not input, an
        estimate of the 2-sigma level above the background will be used.

    min_cut : float, optional
        The pixel value of the minimum cut level.  Data values less than
        ``min_cut`` will set to ``min_cut`` before scaling the image.
        The default is the image minimum.  ``min_cut`` overrides
        ``min_percent``.

    max_cut : float, optional
        The pixel value of the maximum cut level.  Data values greater
        than ``min_cut`` will set to ``min_cut`` before scaling the
        image.  The default is the image maximum.  ``max_cut`` overrides
        ``max_percent``.

    min_percent : float, optional
        The percentile value used to determine the pixel value of
        minimum cut level.  The default is 0.0.  ``min_percent``
        overrides ``percent``.

    max_percent : float, optional
        The percentile value used to determine the pixel value of
        maximum cut level.  The default is 100.0.  ``max_percent``
        overrides ``percent``.

    percent : float, optional
        The percentage of the image values used to determine the pixel
        values of the minimum and maximum cut levels.  The lower cut
        level will set at the ``(100 - percent) / 2`` percentile, while
        the upper cut level will be set at the ``(100 + percent) / 2``
        percentile.  The default is 100.0.  ``percent`` is ignored if
        either ``min_percent`` or ``max_percent`` is input.

    cmap : str
        The matplotlib color map name.  The default is 'Greys_r'.
    """

    hdulist = fits.open(filename)
    image = hdulist[exten].data
    hdulist.close()
    if out_fn is None:
        out_fn = filename.replace('.fits', '.png')
    if cmap not in cm.datad.keys():
        log.critical('{0} is not a valid matplotlib colormap '
                     'name'.format(cmap))
        raise SystemExit()

    image_scaled = imageutils.scale_image(image,
                                          scale=scale,
                                          power=power,
                                          noise_level=noise_level,
                                          min_cut=min_cut,
                                          max_cut=max_cut,
                                          min_percent=min_percent,
                                          max_percent=max_percent,
                                          percent=percent)

    mimg.imsave(out_fn, image_scaled, cmap=cmap)
    log.info('Saved file to {0}'.format(out_fn))
    return
Esempio n. 3
0
def fits2bitmap(filename, ext=0, out_fn=None, stretch='linear',
                power=1.0, asinh_a=0.1, min_cut=None, max_cut=None,
                min_percent=None, max_percent=None, percent=None,
                cmap='Greys_r'):
    """
    Create a bitmap file from a FITS image, applying a stretching
    transform between minimum and maximum cut levels and a matplotlib
    colormap.

    Parameters
    ----------
    filename : str
        The filename of the FITS file.
    ext : int
        FITS extension name or number of the image to convert.  The
        default is 0.
    out_fn : str
        The filename of the output bitmap image.  The type of bitmap
        is determined by the filename extension (e.g. '.jpg', '.png').
        The default is a PNG file with the same name as the FITS file.
    stretch : {{'linear', 'sqrt', 'power', log', 'asinh'}}
        The stretching function to apply to the image.  The default is
        'linear'.
    power : float, optional
        The power index for ``stretch='power'``.  The default is 1.0.
    asinh_a : float, optional
        For ``stretch='asinh'``, the value where the asinh curve
        transitions from linear to logarithmic behavior, expressed as a
        fraction of the normalized image.  Must be in the range between
        0 and 1.  The default is 0.1.
    min_cut : float, optional
        The pixel value of the minimum cut level.  Data values less than
        ``min_cut`` will set to ``min_cut`` before stretching the image.
        The default is the image minimum.  ``min_cut`` overrides
        ``min_percent``.
    max_cut : float, optional
        The pixel value of the maximum cut level.  Data values greater
        than ``min_cut`` will set to ``min_cut`` before stretching the
        image.  The default is the image maximum.  ``max_cut`` overrides
        ``max_percent``.
    min_percent : float, optional
        The percentile value used to determine the pixel value of
        minimum cut level.  The default is 0.0.  ``min_percent``
        overrides ``percent``.
    max_percent : float, optional
        The percentile value used to determine the pixel value of
        maximum cut level.  The default is 100.0.  ``max_percent``
        overrides ``percent``.
    percent : float, optional
        The percentage of the image values used to determine the pixel
        values of the minimum and maximum cut levels.  The lower cut
        level will set at the ``(100 - percent) / 2`` percentile, while
        the upper cut level will be set at the ``(100 + percent) / 2``
        percentile.  The default is 100.0.  ``percent`` is ignored if
        either ``min_percent`` or ``max_percent`` is input.
    cmap : str
        The matplotlib color map name.  The default is 'Greys_r'.
    """

    import matplotlib
    import matplotlib.cm as cm
    import matplotlib.image as mimg

    # __main__ gives ext as a string
    try:
        ext = int(ext)
    except ValueError:
        pass

    try:
        image = getdata(filename, ext)
    except Exception as e:
        log.critical(e)
        return 1

    if image.ndim != 2:
        log.critical('data in FITS extension {} is not a 2D array'
                     .format(ext))

    if out_fn is None:
        out_fn = os.path.splitext(filename)[0]
        if out_fn.endswith('.fits'):
            out_fn = os.path.splitext(out_fn)[0]
        out_fn += '.png'

    # need to explicitly define the output format due to a bug in
    # matplotlib (<= 2.1), otherwise the format will always be PNG
    out_format = os.path.splitext(out_fn)[1][1:]

    # workaround for matplotlib 2.0.0 bug where png images are inverted
    # (mpl-#7656)
    if (out_format.lower() == 'png' and
            LooseVersion(matplotlib.__version__) == LooseVersion('2.0.0')):
        image = image[::-1]

    try:
        cm.get_cmap(cmap)
    except ValueError:
        log.critical('{} is not a valid matplotlib colormap name.'
                     .format(cmap))
        return 1

    norm = simple_norm(image, stretch=stretch, power=power, asinh_a=asinh_a,
                       min_cut=min_cut, max_cut=max_cut,
                       min_percent=min_percent, max_percent=max_percent,
                       percent=percent)

    mimg.imsave(out_fn, norm(image), cmap=cmap, origin='lower',
                format=out_format)
    log.info(f'Saved file to {out_fn}.')
Esempio n. 4
0
def fits2bitmap(
    filename,
    exten=0,
    out_fn=None,
    scale="linear",
    power=1.0,
    noise_level=None,
    min_cut=None,
    max_cut=None,
    min_percent=None,
    max_percent=None,
    percent=None,
    cmap="Greys_r",
):
    """
    Create a bitmap file from a FITS image, applying a
    scaling/stretching transform between minimum and maximum cut levels
    and a matplotlib colormap.

    Parameters
    ----------
    filename : str
        The filename of the FITS file.

    exten : int
        FITS extension number of the image to convert.  The default is 0.

    out_fn : str
        The filename of the output bitmap image.  The type of bitmap
        is determined by the filename extension (e.g. '.jpg', '.png').
        The default is a PNG file with the same name as the FITS file.

    scale : {{'linear', 'sqrt', 'power', log', 'asinh'}}
        The scaling/stretch function to apply to the image.  The default
        is 'linear'.

    power : float, optional
        The power index for the image scaling.  The default is 1.0.

    noise_level : float, optional
        The noise level of the image.  Pixel values less than
        ``noise_level`` will approximately be linearly scaled, while
        pixel values greater than ``noise_level`` will approximately be
        logarithmically scaled.  If ``noise_level`` is not input, an
        estimate of the 2-sigma level above the background will be used.

    min_cut : float, optional
        The pixel value of the minimum cut level.  Data values less than
        ``min_cut`` will set to ``min_cut`` before scaling the image.
        The default is the image minimum.  ``min_cut`` overrides
        ``min_percent``.

    max_cut : float, optional
        The pixel value of the maximum cut level.  Data values greater
        than ``min_cut`` will set to ``min_cut`` before scaling the
        image.  The default is the image maximum.  ``max_cut`` overrides
        ``max_percent``.

    min_percent : float, optional
        The percentile value used to determine the pixel value of
        minimum cut level.  The default is 0.0.  ``min_percent``
        overrides ``percent``.

    max_percent : float, optional
        The percentile value used to determine the pixel value of
        maximum cut level.  The default is 100.0.  ``max_percent``
        overrides ``percent``.

    percent : float, optional
        The percentage of the image values used to determine the pixel
        values of the minimum and maximum cut levels.  The lower cut
        level will set at the ``(100 - percent) / 2`` percentile, while
        the upper cut level will be set at the ``(100 + percent) / 2``
        percentile.  The default is 100.0.  ``percent`` is ignored if
        either ``min_percent`` or ``max_percent`` is input.

    cmap : str
        The matplotlib color map name.  The default is 'Greys_r'.
    """

    hdulist = fits.open(filename)
    image = hdulist[exten].data
    hdulist.close()
    if out_fn is None:
        out_fn = filename.replace(".fits", ".png")
    if cmap not in cm.datad.keys():
        log.critical("{0} is not a valid matplotlib colormap " "name".format(cmap))
        raise SystemExit()

    image_scaled = imageutils.scale_image(
        image,
        scale=scale,
        power=power,
        noise_level=noise_level,
        min_cut=min_cut,
        max_cut=max_cut,
        min_percent=min_percent,
        max_percent=max_percent,
        percent=percent,
    )

    mimg.imsave(out_fn, image_scaled, cmap=cmap)
    log.info("Saved file to {0}".format(out_fn))
    return
def chem_plot(
    linere,
    yslice=slice(367, 467),
    xslice=slice(114, 214),
    vrange=[51, 60] * u.km / u.s,
    sourcename='e2',
    filelist=glob.glob(paths.dpath('12m/cutouts/*e2e8*fits')),
    # 5,8 -> 12.8,8
    # 6,8 -> 12.0,8.6
    # 5,9 -> 15.0,8.0
    # 6,9 -> 15,9.6
    #plotgrid=(6,9), figsize=(15.0, 9.6),
    plotgrid=(6, 8),
    figsize=(12.0, 8.6),
    suffix="",
    vmax_m0=5.0,
    vmax_max=150,
    maxbeam=0.5 * u.arcsec,
    contourlevels=None,
    filetype='pdf',
):
    nplots = np.product(plotgrid)

    text_fontsize = 4.5 if filetype == 'png' else 9

    for ii in range(1, 7):
        if not all(
                pl.figure(ii, figsize=figsize).get_size_inches() == figsize):
            pl.close(ii)

    fig1 = pl.figure(1, figsize=figsize)
    fig1.clf()
    gs1 = gridspec.GridSpec(*plotgrid)
    gs1.update(wspace=0.0, hspace=0.0)

    fig2 = pl.figure(2, figsize=figsize)
    fig2.clf()
    gs2 = gridspec.GridSpec(*plotgrid)
    gs2.update(wspace=0.0, hspace=0.0)

    fig3 = pl.figure(3, figsize=figsize)
    fig3.clf()
    gs3 = gridspec.GridSpec(*plotgrid)
    gs3.update(wspace=0.0, hspace=0.0)

    fig4 = pl.figure(4, figsize=figsize)
    fig4.clf()
    gs4 = gridspec.GridSpec(*plotgrid)
    gs4.update(wspace=0.0, hspace=0.0)

    fig5 = pl.figure(5, figsize=figsize)
    fig5.clf()
    gs5 = gridspec.GridSpec(*plotgrid)
    gs5.update(wspace=0.0, hspace=0.0)

    fig6 = pl.figure(6, figsize=figsize)
    fig6.clf()
    gs6 = gridspec.GridSpec(*plotgrid)
    gs6.update(wspace=0.0, hspace=0.0)

    figcounter = 0

    for ii, fn in enumerate(ProgressBar(filelist)):

        linename = linere.search(fn).groups()[0]
        if linename not in labeldict:
            print()
            print("Skipping {0} because it's not in the label dict".format(
                linename))
            continue
        label = labeldict[linename]

        # cache the results for use in other work, later use, ...
        m0fitsfn = paths.dpath(
            "chemslices/chemical_m0_slabs_{0}_{1}{2}.fits".format(
                sourcename, linename, suffix))
        m1fitsfn = paths.dpath(
            "chemslices/chemical_m1_slabs_{0}_{1}{2}.fits".format(
                sourcename, linename, suffix))
        m2fitsfn = paths.dpath(
            "chemslices/chemical_m2_slabs_{0}_{1}{2}.fits".format(
                sourcename, linename, suffix))
        maxfitsfn = paths.dpath(
            "chemslices/chemical_max_slabs_{0}_{1}{2}.fits".format(
                sourcename, linename, suffix))
        maxsubfitsfn = paths.dpath(
            "chemslices/chemical_max_sub_slabs_{0}_{1}{2}.fits".format(
                sourcename, linename, suffix))
        madstdfitsfn = paths.dpath(
            "chemslices/chemical_madstd_slabs_{0}_{1}{2}.fits".format(
                sourcename, linename, suffix))
        if not (os.path.exists(m0fitsfn) and os.path.exists(m2fitsfn) and
                os.path.exists(maxfitsfn) and os.path.exists(madstdfitsfn)):
            print()
            print("Extracting max/m0/m1/m2 for {0}".format(fn))
            cube = SpectralCube.read(fn)[:, yslice, xslice]
            goodbeams = np.array([bm.major < maxbeam for bm in cube.beams],
                                 dtype='bool')
            if np.count_nonzero(goodbeams) < 5:
                print()
                print("Skipping {0} because it has too few good beams.".format(
                    fn))
                continue

            cube = cube.with_mask(goodbeams[:, None, None])
            cube = cube.minimal_subcube()

            if cube.shape[0] == 0:
                print()
                print("Skipping {0} because it was masked out".format(fn))
                continue

            bm = cube.beams[0]
            restfreq = cube.wcs.wcs.restfrq
            cube = cube.to(u.K, bm.jtok_equiv(restfreq * u.Hz))

            slab = cube.spectral_slab(*vrange)
            cube.beam_threshold = 1
            #contguess = cube.spectral_slab(0*u.km/u.s, 40*u.km/u.s).percentile(50, axis=0)
            #contguess = cube.spectral_slab(70*u.km/u.s, 100*u.km/u.s).percentile(50, axis=0)
            mask = (cube.spectral_axis < 40 * u.km / u.s) | (cube.spectral_axis
                                                             > 75 * u.km / u.s)
            try:
                contguess = cube.with_mask(mask[:, None,
                                                None]).percentile(30, axis=0)
            except ValueError as ex:
                print()
                print("skipping {0}".format(fn))
                print(ex)
                continue
            slabsub = (slab - contguess)
            slab.beam_threshold = 0.25
            slabsub.beam_threshold = 0.25
            m0 = slabsub.moment0()
            m1 = slabsub.moment1()
            m2 = slabsub.moment2()
            max_sub = slabsub.max(axis=0)
            max = slab.max(axis=0)
            madstd = cube.with_mask(mask[:, None, None]).apply_function(
                mad_std,
                axis=0,
                projection=True,
                progressbar=True,
                unit=cube.unit,
            )

            m0.write(m0fitsfn, overwrite=True)
            m1.write(m1fitsfn, overwrite=True)
            m2.write(m2fitsfn, overwrite=True)
            max.write(maxfitsfn, overwrite=True)
            max_sub.write(maxsubfitsfn, overwrite=True)
            madstd.write(madstdfitsfn, overwrite=True)
            maxfh = max.hdu
        else:
            m0fh = fits.open(m0fitsfn)
            m1fh = fits.open(m1fitsfn)
            m2fh = fits.open(m2fitsfn)
            maxfh = fits.open(maxfitsfn)[0]
            maxsubfh = fits.open(maxsubfitsfn)
            madstdfh = fits.open(madstdfitsfn)

            m0 = Projection(
                value=m0fh[0].data,
                header=m0fh[0].header,
                wcs=wcs.WCS(m0fh[0].header),
                unit=u.Unit(m0fh[0].header['BUNIT']),
            )
            m1 = Projection(
                value=m1fh[0].data,
                header=m1fh[0].header,
                wcs=wcs.WCS(m1fh[0].header),
                unit=u.Unit(m1fh[0].header['BUNIT']),
            )
            m2 = Projection(
                value=m2fh[0].data,
                header=m2fh[0].header,
                wcs=wcs.WCS(m2fh[0].header),
                unit=u.Unit(m2fh[0].header['BUNIT']),
            )
            max = Projection(
                value=maxfh.data,
                header=maxfh.header,
                wcs=wcs.WCS(maxfh.header),
                unit=u.Unit(maxfh.header['BUNIT']),
            )
            max_sub = Projection(
                value=maxsubfh[0].data,
                header=maxsubfh[0].header,
                wcs=wcs.WCS(maxsubfh[0].header),
                unit=u.Unit(maxsubfh[0].header['BUNIT']),
            )
            madstd = Projection(
                value=madstdfh[0].data,
                header=madstdfh[0].header,
                wcs=wcs.WCS(madstdfh[0].header),
                unit=u.Unit(madstdfh[0].header['BUNIT']),
            )

            bm = radio_beam.Beam.from_fits_header(m0fh[0].header)
            restfreq = m0fh[0].header['RESTFRQ']

        jtok = bm.jtok(restfreq * u.Hz)

        if figcounter >= nplots:
            print("Skipping {0}".format(fn))
            break

        ax1 = fig1.add_subplot(gs1[figcounter])

        im1 = ax1.imshow(m0.value,
                         vmin=-1.25 * jtok.value,
                         vmax=vmax_m0 * jtok.value,
                         cmap=pl.cm.bone_r,
                         interpolation='nearest',
                         origin='lower')
        ax1.text(3, 0.87 * m0.shape[0], label, fontsize=text_fontsize)
        ax1.set_xticklabels([])
        ax1.set_yticklabels([])
        ax1.set_xticks([])
        ax1.set_yticks([])
        ax1.set_aspect('equal')

        ax2 = fig2.add_subplot(gs2[figcounter])

        im2 = ax2.imshow(m1.value,
                         vmin=vrange[0].value,
                         vmax=vrange[1].value,
                         cmap='seismic',
                         interpolation='nearest',
                         origin='lower')
        ax2.text(3,
                 0.87 * m0.shape[0],
                 label,
                 fontsize=text_fontsize,
                 color='g')
        ax2.set_xticklabels([])
        ax2.set_yticklabels([])
        ax2.set_xticks([])
        ax2.set_yticks([])
        ax2.set_aspect('equal')

        ax3 = fig3.add_subplot(gs3[figcounter])

        im3 = ax3.imshow(max_sub.value,
                         vmin=-10,
                         vmax=vmax_max,
                         cmap=pl.cm.bone_r,
                         interpolation='nearest',
                         origin='lower')
        # add a contour to show the regions that are "saturated" above T_max
        if contourlevels is None:
            contourlevels = [vmax_max, 300, 400, 500]
        qcs = ax3.contour(max_sub.value,
                          levels=contourlevels,
                          colors=['r', 'g', 'b', 'y'])
        #print("levels: {0} = {1}".format(qcs.levels, contourlevels))
        ax3.text(3,
                 0.87 * m0.shape[0],
                 label,
                 fontsize=text_fontsize,
                 color='r')
        ax3.set_xticklabels([])
        ax3.set_yticklabels([])
        ax3.set_xticks([])
        ax3.set_yticks([])
        ax3.set_aspect('equal')

        ax5 = fig5.add_subplot(gs5[figcounter])

        im5 = ax5.imshow(max.value,
                         vmin=-10,
                         vmax=vmax_max,
                         cmap=pl.cm.bone_r,
                         interpolation='nearest',
                         origin='lower')
        # add a contour to show the regions that are "saturated" above T_max
        qcs = ax5.contour(max.value,
                          levels=contourlevels,
                          colors=['r', 'g', 'b', 'y'])
        if False:  # debug
            print("levels: {0} = {1}".format(qcs.levels, contourlevels))
        ax5.text(3,
                 0.87 * m0.shape[0],
                 label,
                 fontsize=text_fontsize,
                 color='r')
        ax5.set_xticklabels([])
        ax5.set_yticklabels([])
        ax5.set_xticks([])
        ax5.set_yticks([])
        ax5.set_aspect('equal')

        ax4 = fig4.add_subplot(gs4[figcounter])

        im4 = ax4.imshow(madstd.value,
                         cmap=pl.cm.bone_r,
                         interpolation='nearest',
                         origin='lower')
        ax4.text(3,
                 0.87 * m0.shape[0],
                 label,
                 fontsize=text_fontsize,
                 color='r')
        ax4.set_xticklabels([])
        ax4.set_yticklabels([])
        ax4.set_xticks([])
        ax4.set_yticks([])
        ax4.set_aspect('equal')

        ax6 = fig6.add_subplot(gs6[figcounter])

        im6 = ax6.imshow((m2**0.5).to(u.km / u.s).value * SIGMA2FWHM,
                         vmin=0,
                         vmax=15,
                         cmap='viridis',
                         interpolation='nearest',
                         origin='lower')
        ax6.text(3,
                 0.87 * m0.shape[0],
                 label,
                 fontsize=text_fontsize,
                 color='k')
        ax6.set_xticklabels([])
        ax6.set_yticklabels([])
        ax6.set_xticks([])
        ax6.set_yticks([])
        ax6.set_aspect('equal')

        figcounter += 1

    # add a continuum image to the 'max' plots
    # ax5 = fig5.add_subplot(gs5[figcounter])
    if figcounter != nplots - 1:
        log.critical("Figcounter={0} but nplots={1}".format(
            figcounter, nplots))
    ax5 = fig5.add_subplot(gs5[nplots - 1])
    ax5.cla()

    cont = get_cont(maxfh.header)

    im5 = ax5.imshow(cont.value,
                     vmin=-10,
                     vmax=vmax_max,
                     cmap=pl.cm.bone_r,
                     interpolation='nearest',
                     origin='lower')
    # add a contour to show the regions that are "saturated" above T_max
    ax5.contour(cont.value, levels=contourlevels, colors=['r', 'g', 'b', 'y'])
    ax5.text(3,
             0.87 * m0.shape[0],
             'Continuum',
             fontsize=text_fontsize,
             color='r')
    ax5.set_xticklabels([])
    ax5.set_yticklabels([])
    ax5.set_aspect('equal')

    cbs = {}
    for ii, fig, im, gs in (
        (1, fig1, im1, gs1),
        (2, fig2, im2, gs2),
        (3, fig3, im3, gs3),
        (4, fig4, im4, gs4),
        (5, fig5, im5, gs5),
        (6, fig6, im6, gs6),
    ):
        bottom, top, left, right = gs.get_grid_positions(fig)
        cbar_ax = fig.add_axes([
            np.max(right) + 0.01,
            np.min(bottom), 0.05,
            np.max(top) - np.min(bottom)
        ])
        cbs[ii] = pl.colorbar(mappable=im, cax=cbar_ax)
        cbs[ii].ax.tick_params(labelsize=12)

    cbs[1].set_label("Flux Density (K km s$^{-1}$)", fontsize=12)
    cbs[2].set_label("Velocity (km s$^{-1}$)", fontsize=12)
    cbs[3].set_label("Peak Brightness (K)", fontsize=12)
    cbs[5].set_label("Peak Brightness (K)", fontsize=12)
    cbs[4].set_label("MAD StdDev (K)", fontsize=12)
    cbs[6].set_label("Velocity Dispersion (km s$^{-1}$)", fontsize=12)

    pl.draw()
    pl.show()

    fig1.savefig(paths.fpath("chemical_m0_slabs_{0}{1}.{2}".format(
        sourcename, suffix, filetype)),
                 bbox_inches='tight',
                 dpi=300)

    fig2.savefig(paths.fpath("chemical_m1_slabs_{0}{1}.{2}".format(
        sourcename, suffix, filetype)),
                 bbox_inches='tight',
                 dpi=300)

    fig3.savefig(paths.fpath("chemical_max_contsub_slabs_{0}{1}.{2}".format(
        sourcename, suffix, filetype)),
                 bbox_inches='tight',
                 dpi=300)

    fig4.savefig(paths.fpath("chemical_madstd_slabs_{0}{1}.{2}".format(
        sourcename, suffix, filetype)),
                 bbox_inches='tight',
                 dpi=300)

    fig5.savefig(paths.fpath("chemical_max_slabs_{0}{1}.{2}".format(
        sourcename, suffix, filetype)),
                 bbox_inches='tight',
                 dpi=300)

    fig6.savefig(paths.fpath("chemical_m2_slabs_{0}{1}.{2}".format(
        sourcename, suffix, filetype)),
                 bbox_inches='tight',
                 dpi=300)
                                                     slices[1], slices[2]]
                hdul.flush()

    if debug_mode:
        log.setLevel(lvl)


if __name__ == "__main__":
    for robust in (0, 2):
        for spw in (0, 1, 2, 3):

            mxind = get_max_ind(
                'piece_of_full_SgrB2_TETC7m_r{1}_cube.spw{0}.channels*fits'.
                format(spw, robust))
            if mxind < min_nchans:
                log.critical("Skipping {0}:{1} b/c only {2} chans".format(
                    robust, spw, mxind))
                continue
            nchans_total[spw] = mxind
            log.info("nchans_total[{0},{1}] = {2}".format(spw, robust, mxind))

            if os.path.exists(
                    'piece_of_full_SgrB2_TETC7m_r{1}_cube.spw{0}.channels0to75.image.pbcor.fits'
                    .format(spw, robust)):

                make_spw_cube(
                    spw='spw{0}',
                    spwnum=spw,
                    fntemplate='full_SgrB2_TETC7m_r{0}'.format(robust),
                    overwrite_existing=False,
                    bmaj_limits=None,
                    fnsuffix="",
Esempio n. 7
0
def fits2bitmap(filename, ext=0, out_fn=None, stretch='linear',
                power=1.0, asinh_a=0.1, min_cut=None, max_cut=None,
                min_percent=None, max_percent=None, percent=None,
                cmap='Greys_r'):
    """
    Create a bitmap file from a FITS image, applying a stretching
    transform between minimum and maximum cut levels and a matplotlib
    colormap.

    Parameters
    ----------
    filename : str
        The filename of the FITS file.
    ext : int
        FITS extension name or number of the image to convert.  The
        default is 0.
    out_fn : str
        The filename of the output bitmap image.  The type of bitmap
        is determined by the filename extension (e.g. '.jpg', '.png').
        The default is a PNG file with the same name as the FITS file.
    stretch : {{'linear', 'sqrt', 'power', log', 'asinh'}}
        The stretching function to apply to the image.  The default is
        'linear'.
    power : float, optional
        The power index for ``stretch='power'``.  The default is 1.0.
    asinh_a : float, optional
        For ``stretch='asinh'``, the value where the asinh curve
        transitions from linear to logarithmic behavior, expressed as a
        fraction of the normalized image.  Must be in the range between
        0 and 1.  The default is 0.1.
    min_cut : float, optional
        The pixel value of the minimum cut level.  Data values less than
        ``min_cut`` will set to ``min_cut`` before stretching the image.
        The default is the image minimum.  ``min_cut`` overrides
        ``min_percent``.
    max_cut : float, optional
        The pixel value of the maximum cut level.  Data values greater
        than ``min_cut`` will set to ``min_cut`` before stretching the
        image.  The default is the image maximum.  ``max_cut`` overrides
        ``max_percent``.
    min_percent : float, optional
        The percentile value used to determine the pixel value of
        minimum cut level.  The default is 0.0.  ``min_percent``
        overrides ``percent``.
    max_percent : float, optional
        The percentile value used to determine the pixel value of
        maximum cut level.  The default is 100.0.  ``max_percent``
        overrides ``percent``.
    percent : float, optional
        The percentage of the image values used to determine the pixel
        values of the minimum and maximum cut levels.  The lower cut
        level will set at the ``(100 - percent) / 2`` percentile, while
        the upper cut level will be set at the ``(100 + percent) / 2``
        percentile.  The default is 100.0.  ``percent`` is ignored if
        either ``min_percent`` or ``max_percent`` is input.
    cmap : str
        The matplotlib color map name.  The default is 'Greys_r'.
    """

    import matplotlib
    import matplotlib.cm as cm
    import matplotlib.image as mimg

    # __main__ gives ext as a string
    try:
        ext = int(ext)
    except ValueError:
        pass

    try:
        image = getdata(filename, ext)
    except Exception as e:
        log.critical(e)
        return 1

    if image.ndim != 2:
        log.critical('data in FITS extension {0} is not a 2D array'
                     .format(ext))

    if out_fn is None:
        out_fn = os.path.splitext(filename)[0]
        if out_fn.endswith('.fits'):
            out_fn = os.path.splitext(out_fn)[0]
        out_fn += '.png'

    # need to explicitly define the output format due to a bug in
    # matplotlib (<= 2.1), otherwise the format will always be PNG
    out_format = os.path.splitext(out_fn)[1][1:]

    # workaround for matplotlib 2.0.0 bug where png images are inverted
    # (mpl-#7656)
    if (out_format.lower() == 'png' and
            LooseVersion(matplotlib.__version__) == LooseVersion('2.0.0')):
        image = image[::-1]

    if cmap not in cm.datad:
        log.critical('{0} is not a valid matplotlib colormap name.'
                     .format(cmap))
        return 1

    norm = simple_norm(image, stretch=stretch, power=power, asinh_a=asinh_a,
                       min_cut=min_cut, max_cut=max_cut,
                       min_percent=min_percent, max_percent=max_percent,
                       percent=percent)

    mimg.imsave(out_fn, norm(image), cmap=cmap, origin='lower',
                format=out_format)
    log.info('Saved file to {0}.'.format(out_fn))
Esempio n. 8
0
def fits2bitmap(filename, exten=0, out_fn=None, scale='linear',
                power=1.0, asinh_a=0.1, min_cut=None, max_cut=None,
                min_percent=None, max_percent=None, percent=None,
                cmap='Greys_r'):
    """
    Create a bitmap file from a FITS image, applying a
    scaling/stretching transform between minimum and maximum cut levels
    and a matplotlib colormap.

    Parameters
    ----------
    filename : str
        The filename of the FITS file.

    exten : int
        FITS extension number of the image to convert.  The default is 0.

    out_fn : str
        The filename of the output bitmap image.  The type of bitmap
        is determined by the filename extension (e.g. '.jpg', '.png').
        The default is a PNG file with the same name as the FITS file.

    scale : {{'linear', 'sqrt', 'power', log', 'asinh'}}
        The scaling/stretch function to apply to the image.  The default
        is 'linear'.

    power : float, optional
        The power index for ``scale='power'`` image scaling.  The
        default is 1.0.

    asinh_a : float, optional
        For ``scale='asinh'`` image scaling, the value where the asinh
        curve transitions from linear to logarithmic behavior, expressed
        as a fraction of the normalized image.  Must be in the range
        between 0 and 1.

    min_cut : float, optional
        The pixel value of the minimum cut level.  Data values less than
        ``min_cut`` will set to ``min_cut`` before scaling the image.
        The default is the image minimum.  ``min_cut`` overrides
        ``min_percent``.

    max_cut : float, optional
        The pixel value of the maximum cut level.  Data values greater
        than ``min_cut`` will set to ``min_cut`` before scaling the
        image.  The default is the image maximum.  ``max_cut`` overrides
        ``max_percent``.

    min_percent : float, optional
        The percentile value used to determine the pixel value of
        minimum cut level.  The default is 0.0.  ``min_percent``
        overrides ``percent``.

    max_percent : float, optional
        The percentile value used to determine the pixel value of
        maximum cut level.  The default is 100.0.  ``max_percent``
        overrides ``percent``.

    percent : float, optional
        The percentage of the image values used to determine the pixel
        values of the minimum and maximum cut levels.  The lower cut
        level will set at the ``(100 - percent) / 2`` percentile, while
        the upper cut level will be set at the ``(100 + percent) / 2``
        percentile.  The default is 100.0.  ``percent`` is ignored if
        either ``min_percent`` or ``max_percent`` is input.

    cmap : str
        The matplotlib color map name.  The default is 'Greys_r'.
    """

    hdulist = fits.open(filename)
    image = hdulist[exten].data
    hdulist.close()
    if out_fn is None:
        out_fn = filename.replace('.fits', '.png')
    if cmap not in cm.datad.keys():
        log.critical('{0} is not a valid matplotlib colormap '
                     'name'.format(cmap))
        raise SystemExit()

    image_scaled = scale_image(image, scale=scale, power=power,
                               asinh_a=asinh_a, min_cut=min_cut,
                               max_cut=max_cut, min_percent=min_percent,
                               max_percent=max_percent, percent=percent)

    mimg.imsave(out_fn, image_scaled, cmap=cmap)
    log.info('Saved file to {0}'.format(out_fn))
    return