def compute_regions(min_val, min_del, npix, filename, reg_file, pdf=False):
contfile = fits.open(filename)
mywcs = wcs.WCS(contfile[0].header).celestial
array = contfile[0].data.squeeze()
beam = radio_beam.Beam.from_fits_header(contfile[0].header)
d = Dendrogram.compute(array,
min_value=min_val,
min_delta=min_del,
min_npix=npix,
wcs=mywcs,
verbose=False)
metadata = {}
metadata['data_unit'] = u.Jy / u.beam
pixel_scale = np.abs(
mywcs.pixel_scale_matrix.diagonal().prod())**0.5 * u.deg
metadata['spatial_scale'] = pixel_scale
metadata['beam_major'] = beam.major
metadata['beam_minor'] = beam.minor
#metadata['wavelength'] = contfile[0].header['CRVAL3']*u.GHz
metadata['wcs'] = mywcs
cat = pp_catalog(d, metadata)
with open(reg_file, 'w') as fh:
fh.write("fk5\n")
for row in cat:
fh.write(
"ellipse({x_cen}, {y_cen}, {major_sigma}, "
"{minor_sigma}, {position_angle}) # text={{{_idx}}}\n".format(
**dict(zip(row.colnames, row))))
if pdf == True:
ax = pl.gca()
ax.cla()
pl.imshow(array,
cmap='gray_r',
interpolation='none',
origin='lower',
vmax=0.01,
vmin=-0.001)
pltr = d.plotter()
for struct in d.leaves:
cntr = pltr.plot_contour(ax,
structure=struct,
colors=['r'],
linewidths=[0.9],
zorder=5)
if struct.parent:
while struct.parent:
struct = struct.parent
cntr_g = pltr.plot_contour(ax,
structure=struct,
colors=[(0, 1, 0, 1)],
linewidths=[0.2])
pl.savefig(reg_file + '.pdf')
return d, cat
def to_catalog(self, dendrogram=None):
"""
Creates a new position-position catalog of leaves in a dendrogram.
This task will overwrite the existing catalog if there is one.
Parameters
----------
dendrogram : `~astrodendro.dendrogram.Dendrogram` object, optional
The dendrogram object to extract sources from.
Returns
-------
`~astropy.table.Table`
"""
if not dendrogram:
try:
dendrogram = self.dendrogram
except AttributeError:
dendrogram = self.to_dendrogram()
cat = pp_catalog(dendrogram.leaves, self.metadata)
cat.add_column(Column(length=len(cat), shape=20, dtype=str),
name='_name')
cat.add_column(Column(data=range(len(cat))), name='_index')
cat = cat[sorted(cat.colnames)]
for i, idx in enumerate(cat['_idx']):
cat['_name'][i] = str('{:.0f}{:03d}'.format(
np.round(self.nu.to(u.GHz).value), idx))
try:
cat['major_sigma'] = cat['major_sigma'] * np.sqrt(8 * np.log(2))
cat['minor_sigma'] = cat['minor_sigma'] * np.sqrt(8 * np.log(2))
cat.rename_column('major_sigma', 'major_fwhm')
cat.rename_column('minor_sigma', 'minor_fwhm')
cat.rename_column('flux', '{}_dend_flux'.format(self.freq_id))
except KeyError:
pass
try:
cat.remove_column('rejected')
cat.remove_column(self.freq_id + '_detected')
except KeyError:
pass
cat.add_column(Column(np.zeros(len(cat)), dtype=int), name='rejected')
cat.add_column(Column(np.ones(len(cat)), dtype=int),
name=self.freq_id + '_detected')
self.catalog = Table(cat, masked=True)
return Table(cat, masked=True)
def run_dendro(data,header,noise,delta,value,pp,pm,low_noise):
##Calculate the dendrogram
dend = astrodendro.Dendrogram.compute(data,
min_value=value*low_noise,
min_delta=delta*low_noise,
min_npix=15)
PixelAreaArcsec = 3600. * abs(header['CDELT1']) * 3600. * abs(header['CDELT2'])
##Compile Metadata
Metadata = {}
Metadata['data_unit'] = u.Jy / u.sr
Metadata['spatial_scale'] = PixelAreaArcsec**0.5 * u.arcsec
##Actually build the catalog from the initial dendrogram
Catalogue = astrodendro.pp_catalog(dend, Metadata)
Catalogue.rename_column('_idx', 'index')
##Add noise column to catalog
keys = ['noise', 'is_leaf', 'peak_cont_flux', 'min_cont_flux',
'mean_cont_flux']
columns = {k:[] for k in (keys)}
for ii, row in enumerate(ProgressBar(Catalogue)):
structure = dend[row['index']]
assert structure.idx == row['index'] == ii
dend_inds = structure.indices()
columns['noise'].append(noise[dend_inds].mean())
columns['is_leaf'].append(structure.is_leaf)
peakflux = data[dend_inds].max()
columns['peak_cont_flux'].append(peakflux)
columns['min_cont_flux'].append(data[dend_inds].min())
columns['mean_cont_flux'].append(data[dend_inds].mean())
for k in columns:
if k not in Catalogue.keys():
Catalogue.add_column(Column(name=k, data=columns[k]))
##Do the pruning
#do pruning
cat_mask = (Catalogue['is_leaf'] &
(Catalogue['peak_cont_flux']>pp*Catalogue['noise']) &
(Catalogue['mean_cont_flux']>pm*Catalogue['noise']))
pruned_ppcat = Catalogue[cat_mask]
mask = dend.index_map.copy()
for ii in range(len(Catalogue)):
if ii not in pruned_ppcat['index']:
mask[mask == ii] = -1
pyfits.writeto(path+'temp_mask.fits',mask,header,clobber=True)
print len(pruned_ppcat['index'])
return len(pruned_ppcat['index'])
hdu = fits.open(file)[0]
mask = np.zeros(hdu.data.shape, dtype=bool)
for leaf in leaves:
if leaf.idx == 45:
mask = mask | leaves_brick.get_mask()
else:
mask = mask | leaf.get_mask()
mask_hdu = fits.PrimaryHDU(mask.astype('short'), hdu.header)
metadata = {}
metadata['data_unit'] = u.MJy / u.sr
metadata['spatial_scale'] = (np.abs(head['CDELT2'])) * u.deg
metadata['WCS'] = mywcs
# Force Brick catalogue data into full catalogue
cat = pp_catalog(leaves, metadata)
cat_brick = pp_catalog(dend_brick.leaves, metadata)
cat[cat['_idx']==45] = cat_brick[-5]
cat[cat['x_cen']==1032.6463805131666][0][0] = 15
# Plot HiGAL column density map with leave contours & labels
l = np.zeros(len(cat))
b = np.zeros(len(cat))
for i in range(0,len(cat),1):
l[i] = cat[i][8]
b[i] = cat[i][9]
fig=aplpy.FITSFigure(file)
lab = fig.pixel2world(l,b)
i = 0
for structure in leaves:
df.writeto('dendrograms_min1mJy_diff1mJy.fits', clobber=True)
beam = radio_beam.Beam.from_fits_header(contfile[0].header)
metadata = {}
metadata['data_unit'] = u.Jy/u.beam
pixel_scale = np.abs(mywcs.pixel_scale_matrix.diagonal().prod())**0.5 * u.deg
pixel_scale_as = pixel_scale.to(u.arcsec).value
metadata['spatial_scale'] = pixel_scale
metadata['beam_major'] = beam.major
metadata['beam_minor'] = beam.minor
metadata['wavelength'] = 218.22219*u.GHz
metadata['velocity_scale'] = u.km/u.s
metadata['wcs'] = mywcs
ppbeam = (beam.sr/(pixel_scale**2)).decompose().value
ppcat = astrodendro.pp_catalog(dend, metadata)
with open(paths.rpath("raw_dendrogram_cores.reg"), 'w') as fh:
fh.write("fk5\n")
for row in ppcat:
fh.write("ellipse({x_cen}, {y_cen}, {major_sigma}, "
"{minor_sigma}, {position_angle}) # text={{{_idx}}}\n"
.format(**dict(zip(row.colnames, row))))
# add a 'noise' column to the catalog
keys = ['noise', 'is_leaf', 'peak_cont_flux', 'min_cont_flux',
'mean_cont_flux', 'peak_cont_mass', 'peak_cont_col', 'beam_area']
radii = (0.2,0.4,0.6,0.8,1.0,1.5)*u.arcsec
columns = {k:[] for k in (keys)}
log.info("Doing photometry")
def detect(infile,
region,
band,
min_value=0.000325,
min_delta=0.0005525,
min_npix=7.5,
plot=False,
verbose=True):
outfile = 'region{}_band{}_val{:.5g}_delt{:.5g}_pix{}'.format(
region, band, min_value, min_delta, min_npix)
contfile = fits.open(infile) # load in fits image
da = contfile[0].data.squeeze() # get rid of extra axes
print(da)
mywcs = wcs.WCS(
contfile[0].header
).celestial # set up world coordinate system, ditch extra dimensions
beam = radio_beam.Beam.from_fits_header(contfile[0].header)
d = Dendrogram.compute(da,
min_value=min_value,
min_delta=min_delta,
min_npix=min_npix,
wcs=mywcs,
verbose=verbose)
pixel_scale = np.abs(
mywcs.pixel_scale_matrix.diagonal().prod())**0.5 * u.deg
metadata = {
'data_unit': u.Jy / u.beam,
'spatial_scale': pixel_scale,
'beam_major': beam.major,
'beam_minor': beam.minor,
'wavelength': 9.298234612192E+10 * u.Hz,
'velocity_scale': u.km / u.s,
'wcs': mywcs,
}
cat = pp_catalog(d.leaves, metadata) # set up position-position catalog
cat['_idx'] = range(len(cat))
# Use FWHM for ellipse dimensions instead of sigma
cat['major_sigma'] = cat['major_sigma'] * np.sqrt(8 * np.log(2))
cat['minor_sigma'] = cat['minor_sigma'] * np.sqrt(8 * np.log(2))
cat.rename_column('major_sigma', 'major_fwhm')
cat.rename_column('minor_sigma', 'minor_fwhm')
cat.rename_column('flux', 'dend_flux_band{}'.format(band))
# Rename _idx to include the band number in the hundreds digit
for i in range(len(cat)):
cat['_idx'][i] = int('{}{:02d}'.format(band, cat['_idx'][i]))
# Output the catalog and region files
cat.write('./cat/cat_' + outfile + '.dat', format='ascii')
savereg(cat, './reg/reg_' + outfile + '.reg')
if plot: # create PDF plots of contour regions, if enabled
ax = plt.gca()
ax.cla()
plt.imshow(da,
cmap='gray_r',
interpolation='none',
origin='lower',
vmax=0.01,
vmin=-0.001)
pltr = d.plotter()
if verbose:
print("Plotting contours to PDF...")
pb = ProgressBar(len(d.leaves))
for struct in d.leaves: # iterate over each of the leaf structures
pltr.plot_contour(ax,
structure=struct,
colors=['r'],
linewidths=[0.9],
zorder=5)
if struct.parent:
while struct.parent:
struct = struct.parent
pltr.plot_contour(ax,
structure=struct,
colors=[(0, 1, 0, 1)],
linewidths=[0.5])
if verbose:
pb.update()
cntr = plt.gca().collections
plt.setp([x for x in cntr if x.get_color()[0, 0] == 1], linewidth=0.25)
plt.setp([x for x in cntr if x.get_color()[0, 1] == 1], linewidth=0.25)
plt.savefig('./contour/contour_' + outfile + '.pdf')
plt.axis((1125.4006254228616, 1670.3650637799306, 1291.6829155596627,
1871.8063499397681))
plt.setp([x for x in cntr if x.get_color()[0, 0] == 1],
linewidth=0.75) # Red
plt.setp([x for x in cntr if x.get_color()[0, 1] == 1],
linewidth=0.5) # Green
plt.savefig('./contour/contour_' + outfile + 'zoom.pdf')
# axins.imshow(Z2, extent=extent, interpolation="nearest",
# origin="lower")
# sub region of the original image
x1, x2, y1, y2 = 0, 30, 1e22, 0.5e23
axins.set_xlim(x1, x2)
axins.set_ylim(y1, y2)
axins.hlines(10 * 8e20 / 2.35 * 5., *ax2.get_xlim(), color='b', linestyle=':')
# ax2.set_xticks([])
axins.set_yticks([])
# ax2.set_xtick_labels([])
plt.xticks(visible=False)
plt.yticks(visible=False)
mark_inset(ax2, axins, loc1=2, loc2=4, fc="none", ec="0.5")
cat = pp_catalog(d, metadata)
# leaf and brances parameters
distance = 5500 * u.pc
eff_radius = np.sqrt(cat['area_exact'] / np.pi) * distance / 206265. * u.pc
mass = cat['flux'] * 2.8 * con.m_p.cgs / (1.9891e+33 * u.g) * (((1.5 * distance / 206265.).to(u.cm)) ** 2)
mass_corrected_leaf = []
mass_leaf = []
eff_radius_leaf = []
# calculate leaf parameters
for i, leaf in enumerate(d.leaves):
if leaf.parent is not None:
merging_level = np.sum(leaf.parent.values(subtree=False)) / leaf.parent.get_npix(subtree=False)
else:
merging_level = np.sum(leaf.ancestor.values(subtree=False)) / leaf.ancestor.get_npix(subtree=False)
fluxes_corrected = cat[leaf.idx]['flux'] - merging_level * leaf.get_npix()
df.writeto('dendrograms_min1mJy_diff1mJy.fits', clobber=True)
beam = radio_beam.Beam.from_fits_header(contfile[0].header)
metadata = {}
metadata['data_unit'] = u.Jy/u.beam
pixel_scale = np.abs(mywcs.pixel_scale_matrix.diagonal().prod())**0.5 * u.deg
pixel_scale_as = pixel_scale.to(u.arcsec).value
metadata['spatial_scale'] = pixel_scale
metadata['beam_major'] = beam.major
metadata['beam_minor'] = beam.minor
metadata['wavelength'] = 218.22219*u.GHz
metadata['velocity_scale'] = u.km/u.s
metadata['wcs'] = mywcs
ppbeam = (beam.sr/(pixel_scale**2)).decompose().value
ppcat = astrodendro.pp_catalog(dend, metadata)
# add a 'noise' column to the catalog
keys = ['noise', 'is_leaf', 'peak_cont_flux', 'min_cont_flux',
'mean_cont_flux', 'peak_cont_mass', 'peak_cont_col', 'beam_area']
radii = (0.2,0.4,0.6,0.8,1.0,1.5)*u.arcsec
columns = {k:[] for k in (keys)}
log.info("Doing photometry")
for ii, row in enumerate(ProgressBar(ppcat)):
structure = dend[row['_idx']]
assert structure.idx == row['_idx'] == ii
dend_inds = structure.indices()
columns['noise'].append(noise[dend_inds].mean())
columns['is_leaf'].append(structure.is_leaf)
peakflux = data[dend_inds].max()
import numpy as np
import astrodendro
import FITS_tools
from astropy import units as u
from paths import datapath
from astropy.io import fits
from allpaths import cont6cm as oneonefn
from allpaths import cont2cm as twotwofn
oneoned = (fits.getdata(oneonefn) * u.K).to(u.Jy, equivalencies=u.brightness_temperature(aobeamarea, h2co11freq))
twotwod = fits.getdata(twotwofn)
oneoneh = fits.getheader(oneonefn)
twotwoh = fits.getheader(twotwofn)
dendone = astrodendro.dendrogram.Dendrogram.compute(oneoned, 0.1 * u.Jy, 0.05 * u.Jy, 6)
metadata = {}
# metadata['data_unit'] = u.K
metadata["spatial_scale"] = FITS_tools.header_tools.header_to_platescale(oneoneh) * u.deg
metadata["beam_major"] = aobeam
metadata["beam_minor"] = aobeam
cat = astrodendro.pp_catalog(dendone, metadata)
# Some pixel area stuff ...
pix_width = head['cdelt2']*u.deg
pix_width_pc = (pix_width).to(u.rad).value * distance
pixels_1pc = (1/pix_width_pc).value
pc_sc = (pixels_1pc*pix_width).value
# Load dendrogram
dend = astrodendro.Dendrogram.load_from("./../Dendrogram_files/clouds_only_dendrogram.fits")
leaves = dend.leaves[9:(len(dend.leaves)-3)]
metadata = {}
metadata['data_unit'] = u.MJy / u.sr
metadata['spatial_scale'] = (np.abs(head['CDELT2'])) * u.deg
metadata['WCS'] = wcs
cat = pp_catalog(leaves, metadata)
# Cut out continuum based on radius from leaf area.
i=1
for leaf in leaves:
hdu = fits.open(file)[0]
wcs = WCS(hdu.header)
position = (cat[cat['_idx']==leaf.idx]['x_cen'], cat[cat['_idx']==leaf.idx]['y_cen'])
size = (4*int(np.around(np.sqrt(cat[cat['_idx']==leaf.idx]['area_exact']/np.pi)/pix_width.value)),
4*int(np.around(np.sqrt(cat[cat['_idx']==leaf.idx]['area_exact']/np.pi)/pix_width.value)))
cutout = Cutout2D(hdu.data, position=position, size=size, wcs=wcs)
hdu.data = cutout.data
hdu.header.update(cutout.wcs.to_header())
hdu.writeto('./../Continuum_cutouts/'+str(i)+"_cutout.fits", overwrite=True)
i=i+1
df = fits.open('perseus_dendrograms_min1mJy_diff1mJy.fits')
df[1].header.update(df[0].header)
df[2].header.update(df[0].header)
df.writeto('perseus_dendrograms_min1mJy_diff1mJy.fits', clobber=True)
beam = radio_beam.Beam.from_fits_header(contfile[0].header)
metadata = {}
metadata['data_unit'] = u.Jy/u.beam
metadata['spatial_scale'] = 0.05 * u.arcsec
metadata['beam_major'] = beam.major
metadata['beam_minor'] = beam.minor
metadata['wavelength'] = 218.22219*u.GHz
metadata['velocity_scale'] = u.km/u.s
metadata['wcs'] = mywcs
orig_ppcat = astrodendro.pp_catalog(orig_dend, metadata)
ppcat = astrodendro.pp_catalog(dend, metadata)
# add a 'noise' column to the catalog
keys = ['noise','is_leaf','peak_flux','min_flux','mean_flux']
columns = {k:[] for k in (keys)}
for ii, row in enumerate(ProgressBar(ppcat)):
structure = dend[row['_idx']]
assert structure.idx == row['_idx'] == ii
dend_inds = structure.indices()
columns['noise'].append(noise[dend_inds].mean())
columns['is_leaf'].append(structure.is_leaf)
columns['peak_flux'].append(contfile[0].data[dend_inds].max())
columns['min_flux'].append(contfile[0].data[dend_inds].min())
columns['mean_flux'].append(contfile[0].data[dend_inds].mean())
df = fits.open('perseus_dendrograms_min1mJy_diff1mJy.fits')
df[1].header.update(df[0].header)
df[2].header.update(df[0].header)
df.writeto('perseus_dendrograms_min1mJy_diff1mJy.fits', clobber=True)
beam = radio_beam.Beam.from_fits_header(contfile[0].header)
metadata = {}
metadata['data_unit'] = u.Jy/u.beam
metadata['spatial_scale'] = 0.05 * u.arcsec
metadata['beam_major'] = beam.major
metadata['beam_minor'] = beam.minor
metadata['wavelength'] = 218.22219*u.GHz
metadata['velocity_scale'] = u.km/u.s
metadata['wcs'] = mywcs
orig_ppcat = astrodendro.pp_catalog(orig_dend, metadata)
ppcat = astrodendro.pp_catalog(dend, metadata)
# add a 'noise' column to the catalog
keys = ['noise','is_leaf','peak_flux','min_flux','mean_flux']
columns = {k:[] for k in (keys)}
for ii, row in enumerate(ProgressBar(ppcat)):
structure = dend[row['_idx']]
assert structure.idx == row['_idx'] == ii
dend_inds = structure.indices()
columns['noise'].append(noise[dend_inds].mean())
columns['is_leaf'].append(structure.is_leaf)
columns['peak_flux'].append(contfile[0].data[dend_inds].max())
columns['min_flux'].append(contfile[0].data[dend_inds].min())
columns['mean_flux'].append(contfile[0].data[dend_inds].mean())