from Error import raiseError
try:
import pyfits as pf
except:
try:
import astropy.io.fits as pf
except:
raiseError('No pyfits module found.', None)
def getRegions(configOpts, logger):
#####################################################################
########################## FUV processing ##########################
fuvImage = configOpts['fuvImage']
logger.write('FUV Image: %s' % fuvImage, newLine=True)
if not os.path.exists(fuvImage):
raiseError('FUV image does not exist.', logger)
if (configOpts['fuvMaskFile'].lower() == 'default') or (configOpts['fuvMaskFile'] is None):
configOpts['fuvMaskFile'] = configOpts['root'] + '_Mask.fits'
doCLFindFUV = True
if os.path.exists(configOpts['fuvMaskFile']):
if configOpts['overwrite'] is True:
doCLFindFUV = True
else:
doCLFindFUV = getYN('\nFound {0}. Rerun CLFind? [y/N] '.format(configOpts['fuvMaskFile']),
returnOpt=False)
if doCLFindFUV is False:
logger.write('FUV mask not created. Using previously generated mask %s.' % configOpts['fuvMaskFile'])
else:
if configOpts['fuvInteractive'] is False:
logger.write('FUV parameters loaded')
else:
logger.write('FUV: Running in interactive mode ... ', newLine=True)
data = pf.getdata(fuvImage)
logger.write('Image statistics', newLine=True, log=True)
logger.write('Max: %9.3e' % np.nanmax(data), log=True)
logger.write('Min: %9.3e' % np.nanmin(data), log=True)
logger.write('Mean: %9.3e' % np.mean(data), log=True)
logger.write('Median: %9.3e' % np.median(data), log=True)
configOpts['fuvBackground'] = calcBackground(fuvImage, logger, verbose=configOpts['verbose'])
logger.write('Background: %.5e' % configOpts['fuvBackground'],
newLine=True)
configOpts['fuvSigma'] = getFloat('Sigma [3]: ', 3)
configOpts['fuvhLevel'] = getFloat('Highest level [-1 for automatic]: ', -1)
configOpts['fuvnLevels'] = getFloat('Number of levels [-1 for automatic]: ', -1)
configOpts['fuvMinPixels'] = getFloat('Minimum number of pixels [20]: ', 20)
calcParameters('fuv', configOpts, logger)
printCLFindOptions('fuv', configOpts, logger)
resultCheck = checkCLFindOptions('fuv', configOpts)
if resultCheck is False:
raiseError('Some of the parameters are incorrect. Please, review the configuration file.',
logger)
clfind2d(fuvImage, configOpts['fuvMaskFile'], configOpts['fuvLevels'],
log=True, nPixMin=configOpts['fuvMinPixels'],
verbose=configOpts['verbose'])
logger.write('CLFind log can be found in %s.log' %
configOpts['fuvMaskFile'], newLine=True, doPrint=False)
#####################################################################
########################## FUV rejection ###########################
if configOpts['checkFUV']:
if (configOpts['fuvMaskFileRej'] is None) or (configOpts['fuvMaskFileRej'].lower() == 'default'):
configOpts['fuvMaskFileRej'] = os.path.splitext(configOpts['fuvImage'])[0] + '_RejMsk.fits'
doRejection = True
if os.path.exists(configOpts['fuvMaskFileRej']) and doCLFindFUV is False:
if configOpts['overwrite'] is False:
doRejection = getYN('\nFound %s. Redo FUV rejection? [y/N] ' %
configOpts['fuvMaskFileRej'], returnOpt=False)
if doRejection is True:
logger.write('FUV rejection', newLine=True)
checkFUV(configOpts, logger)
logger.write('New mask saved as %s' % configOpts['fuvMaskFileRej'],
newLine=True)
else:
logger.write('Not doing FUV rejection. Using image %s' %
configOpts['fuvMaskFileRej'])
#####################################################################
###################### FUV regions catalogue #######################
logger.write('Creating FUV catalogs ... ', newLine=True)
rejMask = configOpts['fuvMaskFileRej']
votRegsFile = os.path.splitext(rejMask)[0] + '.vot'
ds9RegsFile = os.path.splitext(rejMask)[0] + '.reg'
peaksFile = os.path.splitext(rejMask)[0] + '_Peaks.dat'
if False not in map(os.path.exists, [votRegsFile, ds9RegsFile, peaksFile]) and \
configOpts['overwrite'] is False:
logger.write('FUV catalogues already exist.', newLine=True)
if os.path.exists(votRegsFile):
logger.write('VOTable catalogue: %s' % votRegsFile)
logger.write('DS9 catalogue: %s' % ds9RegsFile)
logger.write('Peaks file: %s' % peaksFile)
else:
createCatalog(fuvImage, rejMask, votRegsFile, ds9RegsFile, logger,
peaksFile=peaksFile, ellipse=False, plot=configOpts['plotDS9'])
return
#####################################################################
########################## HI processing ###########################
# if configOpts['hiInteractive'] == False:
# areCLParamsOK = checkCLFindOptions('hi')
# if areCLParamsOK == False:
# fancyPrint('Some HI parameters in config file are wrong\n',
# newLine=True, log=True)
# sys.exit()
# fancyPrint('HI parameters loaded', newLine=True, log=True)
# else:
# fancyPrint('HI: Running in interactive mode ... ', newLine=True, log=True)
# data = pf.getdata(configOpts['hiImage'])
# fancyPrint('Image statistics', newLine=True, log=True)
# fancyPrint('Max: %9.3e' % np.nanmax(data), log=True)
# fancyPrint('Min: %9.3e' % np.nanmin(data), log=True)
# fancyPrint('Mean: %9.3e' % np.mean(data), log=True)
# fancyPrint('Median: %9.3e' % np.median(data), log=True)
# configOpts['hiBackground'] = \
# calcBackground(configOpts['hiImage'], fancyPrint)
# fancyPrint('Background: %.5e' % configOpts['hiBackground'],
# newLine=True, log=False)
# fancyPrint('')
# configOpts['hiSigma'] = getFloat('Sigma [3]: ', 3)
# configOpts['hihLevel'] = getFloat('Highest level [-1 for automatic]: ', -1)
# configOpts['hinLevels'] = getFloat('Number of levels [-1 for automatic]: ', -1)
# configOpts['hiMinPixels'] = getFloat('Minimum number of pixels [20]: ', 20)
# fancyPrint('')
# hiLevels = calcParameters('hi')
# if (configOpts['hiMaskFile'].lower() == 'default') or (configOpts['hiMaskFile'] == None):
# configOpts['hiMaskFile'] = os.path.splitext(configOpts['hiImage'])[0] + '_Msk.fits'
# doIDL = True
# if os.path.exists(configOpts['hiMaskFile']):
# doIDL = getYN('\nFound {0}. Rerun CLFind? [y/N] '.format(configOpts['hiMaskFile']),
# returnOpt=False)
# if doIDL:
# status, maskFile, idlLogFile = clfind2dIDL(configOpts['hiImage'], hiLevels,
# log=configOpts['log'], nPixMin=configOpts['hiMinPixels'],
# verbose=configOpts['verbose'])
# if not status:
# fancyPrint('Problem found running IDL', newLine=True, log=True)
# fancyPrint('Kill IDL, check {0} and try again\n'.format(idlLogFile), log=True)
# sys.exit()
# sh.move(maskFile, configOpts['hiMaskFile'])
# logData = open(idlLogFile, 'r').read().splitlines()
# sh.move(idlLogFile, 'clfind2dHI.log')
# else:
# logData = open('clfind2dHI.log', 'r').read().splitlines()
# for line in logData:
# fancyPrint(line, log=True, noPrint=True)
# if 'clumps found (' in line:
# m = re.match(r'(\d+)(.+)(\(+)(\d+)', line.replace(' ',''))
# nClumpsHI = int(m.groups(0)[0])
# nClumpsRejHI = nClumps = int(m.groups(0)[-1])
# fancyPrint('HI mask file: {0}'.format(configOpts['hiMaskFile']), newLine=True, log=True)
# fancyPrint('Number of clumps: {0}'.format(nClumpsHI), log=True)
# fancyPrint('Number of clumps rejected: {0}'.format(nClumpsRejHI), log=True)
# # #####################################################################
# # ########################## HI rejection ###########################
# #
# # if configOpts['checkHI']:
# # if (configOpts['fuvMaskFileRej'] == None) or (configOpts['fuvMaskFileRej'].lower() == 'default'):
# # configOpts['fuvMaskFileRej'] = os.path.splitext(configOpts['fuvImage'])[0] + '_RejMsk.fits'
# #
# # doRejection = True
# # if os.path.exists(configOpts['fuvMaskFileRej']) and doIDL == False:
# # doRejection = getYN('\nFound {0}. Redo FUV rejection? [y/N] '.format(configOpts['fuvMaskFileRej']),
# # returnOpt=False)
# #
# # if doRejection == True:
# # try:
# # checkFUV(configOpts, fancyPrint)
# # except Exception as detail:
# # raise detail
# # else:
# # fancyPrint('Not doing FUV rejection. Using image {0}'.format(configOpts['fuvMaskFileRej']),
# # log=True, noPrint=True, newLine=True)
# #
# #
# # #####################################################################
# fancyPrint('')
return configOpts
def checkFUV(options, logger):
fuvImage = options['fuvImage']
fuvMask = options['fuvMaskFile']
logger.write('Checking FUV regions ... ', newLine=True, doLog=False)
logger.write('Gathering regions ... ', doLog=False)
hduMask = pf.open(fuvMask)
hduImage = pf.open(fuvImage)
# nRegs = np.max(hduMask[0].data)
regions = Regions.RegionSet(hduMask[0].data, image=hduImage[0].data)
logger.write('Getting adjacent regions ... ', doLog=False)
adjacentRegions = regions.getAdjacentRegs()
logger.write('Processing adjacent regions ... ', doLog=False)
while adjacentRegions != []:
pair = adjacentRegions[0]
fluxA = regions.Regions[pair[0]].getFlux()
fluxB = regions.Regions[pair[1]].getFlux()
peakA = regions.Regions[pair[0]].peak
peakB = regions.Regions[pair[1]].peak
if options['fluxContrast'] is not False:
contrast = float(np.max([fluxA, fluxB]) / np.min([fluxA, fluxB]))
minRegion = pair[np.argmin([fluxA, fluxB])]
maxRegion = pair[np.argmax([fluxA, fluxB])]
if options['fluxContrast'] is True or contrast > options['fluxContrast']:
if options['joinRegions']:
regions.joinRegions(maxRegion, minRegion)
logger.write('Adjacent regions %d and %d joined. Flux contrast=%.1f' %
(maxRegion, minRegion, contrast), doPrint=False)
else:
regions.deleteReg(minRegion)
logger.write('Adjacent regions %d deleted. Flux contrast=%.1f' %
(minRegion, contrast), doPrint=False)
adjacentRegions = regions.getAdjacentRegs()
continue
if options['peakContrast'] is not False:
contrast = float(np.max([peakA, peakB]) / np.min([peakA, peakB]))
minRegion = pair[np.argmin([peakA, peakB])]
maxRegion = pair[np.argmax([peakA, peakB])]
if options['peakContrast'] is True or contrast > options['peakContrast']:
if options['joinRegions']:
regions.joinRegions(maxRegion, minRegion)
logger.write('Adjacent regions %d and %d joined. Peak contrast=%.1f' %
(maxRegion, minRegion, contrast), doPrint=False)
else:
regions.deleteReg(minRegion)
logger.write('Adjacent regions %d deleted. Peak contrast=%.1f' %
(minRegion, contrast), doPrint=False)
adjacentRegions = regions.getAdjacentRegs()
continue
del adjacentRegions[0]
logger.write('Getting close regions ... ', newLine=True, doLog=False)
if options['scale'] is not None:
scalePc = options['scale']
else:
try:
try:
scaleDeg = np.abs(hduImage[0].header['CD1_1'])
except:
scaleDeg = np.abs(hduImage[0].header['CDELT1'])
except:
raiseError('Pixel scale cannot be calculated. Use the scale parameter.')
try:
scalePc = 2.0 * options['distance'] * 1e6 * np.tan(0.5 * scaleDeg * np.pi / 180.)
except:
raiseError('Distance to the galaxy not defined.')
minNumPixels = options['minDistance'] / scalePc
closeRegions = regions.getCloseRegs(minNumPixels, adjacent=False)
logger.write('Processing close regions ... ', newLine=True, doLog=False)
while closeRegions != []:
pair = closeRegions[0]
fluxA = regions.Regions[pair[0]].getFlux()
fluxB = regions.Regions[pair[1]].getFlux()
peakA = regions.Regions[pair[0]].peak
peakB = regions.Regions[pair[1]].peak
if options['alwaysRemoveClose']:
minRegion = pair[np.argmin([fluxA, fluxB])]
regions.deleteReg(minRegion)
closeRegions = regions.getCloseRegs(minNumPixels, adjacent=False)
logger.write('Close region %d removed' % minRegion, doPrint=False)
continue
if options['fluxContrast'] is not False:
contrast = float(np.max([fluxA, fluxB]) / np.min([fluxA, fluxB]))
minRegion = pair[np.argmin([fluxA, fluxB])]
maxRegion = pair[np.argmax([fluxA, fluxB])]
if (options['fluxContrast'] is True) or (contrast > options['fluxContrast']):
regions.deleteReg(minRegion)
closeRegions = regions.getCloseRegs(minNumPixels, adjacent=False)
logger.write('Close region %s removed. Flux contrast=%.1f' %
(minRegion, contrast), doPrint=False)
continue
if options['peakContrast'] is not False:
contrast = float(np.max([peakA, peakB]) / np.min([peakA, peakB]))
minRegion = pair[np.argmin([peakA, peakB])]
maxRegion = pair[np.argmax([peakA, peakB])]
if (options['peakContrast'] is True) or (contrast > options['peakContrast']):
regions.deleteReg(minRegion)
closeRegions = regions.getCloseRegs(minNumPixels, adjacent=False)
logger.write('Close region %d removed. Peak contrast=%.1f' %
(minRegion, contrast), doPrint=False)
continue
del closeRegions[0]
logger.write('Saving new mask ... ', newLine=True, doLog=False)
hdu = pf.PrimaryHDU(regions.DataMask)
hdu.header = hduMask[0].header
hduList = pf.HDUList([hdu])
if os.path.exists(options['fuvMaskFileRej']): os.remove(options['fuvMaskFileRej'])
hduList.writeto(options['fuvMaskFileRej'], output_verify='ignore')
return
def createCatalog(image, mask, voTableCat, ds9RegsFile, logger,
peaksFile=None, ellipse=False, ellMode='linear', plot=False):
if voModule is False:
logger.write(cm.Fore.RED + 'No VO module found. A FITS table will be generated instead.' +
cm.Style.RESET_ALL, newLine=True)
# Reads the header, data and loads the astrometric solution
hduImage = pf.open(image)
hduMask = pf.open(mask)
try:
wcsMask = pw.WCS(hduMask[0].header)
except:
wcsMask = None
logger.write(cm.Fore.YELLOW + 'No WCS information. The VOTable file will not include those fields.' +
cm.Style.RESET_ALL)
logger.write('Gathering mask data ... ', newLine=True)
regions = RegionSet(hduMask[0].data, image=hduImage[0].data)
logger.write('Preparing data ... ')
centroids = np.array([regions.Regions[idReg].getCentroid()[0] for idReg in regions.idRegions])
radii = [regions.Regions[idReg].getCentroid()[1] for idReg in regions.idRegions]
sizes = [regions.Regions[idReg].where[0].size for idReg in regions.idRegions]
peaks = [regions.Regions[idReg].peak for idReg in regions.idRegions]
peaksPix = np.array([regions.Regions[idReg].peakWhere for idReg in regions.idRegions]) + 1
fluxes = [regions.Regions[idReg].getFlux() for idReg in regions.idRegions]
if wcsMask is not None:
skyCoordsCentroids = wcsMask.wcs_pix2sky(np.fliplr(centroids), 0)
skyCoordsPeak = wcsMask.wcs_pix2sky(np.fliplr(peaksPix), 0)
try:
scale = np.abs(hduImage[0].header['CD1_1']) * 3600.
except:
try:
scale = np.abs(hduImage[0].header['CDELT1']) * 3600.
except:
wcsMask = None
logger.write(cm.Fore.YELLOW + 'No WCS information. The VOTable file will ' +
'not include those fields.' + cm.Style.RESET_ALL)
radiiSky = radii * scale
# Calculates an ellipse fit for the pixels in the region
if ellipse:
logger.write('Fitting ellipse parameters ... ')
def getEllParams(data, id):
try:
return list(fitellipse(data, ellMode)) + [0]
except RuntimeError:
return [regions.Regions[id].getCentroid()[0][0], regions.Regions[id].getCentroid()[0][1],
regions.Regions[idReg].getCentroid()[1], regions.Regions[idReg].getCentroid()[1],
0.0, 1]
ellipseFit = np.array([getEllParams(regions.Regions[idReg].pixels, idReg) for idReg in regions.idRegions])
ellipseCentroidWCS = np.array(wcsMask.wcs_pix2sky(ellipseFit[:, [1, 0]], 0))
ellipseAxisWCS = np.array(ellipseFit[:, [2, 3]] * scale)
ellipseAngle = np.array(-ellipseFit[:, 4] * 180. / np.pi + 90.)
if voModule is True:
# Creates a VOTable with the data
logger.write('Creating VOTable ... ')
if os.path.exists(voTableCat):
os.remove(voTableCat)
# from vo.tree import VOTableFile, Resource, Table, Field
votable = VOTableFile()
resource = Resource()
votable.resources.append(resource)
table = Table(votable)
resource.tables.append(table)
# Define fields
fieldsVO = [Field(votable, name='ID', datatype='int'),
Field(votable, name='X_CENTROID', datatype='float', unit='pix'),
Field(votable, name='Y_CENTROID', datatype='float', unit='pix'),
Field(votable, name='RADIUS_PIX', datatype='float', unit='pix'),
Field(votable, name='SIZE', datatype='float', unit='pix')]
if wcsMask is not None:
fieldsVO += [Field(votable, name='RA_CENTROID', datatype='double', unit='deg'),
Field(votable, name='DEC_CENTROID', datatype='double', unit='deg'),
Field(votable, name='RADIUS_SKY', datatype='float', unit='arcsec')]
fieldsVO += [Field(votable, name='PEAK', datatype='float', unit='CPS'),
Field(votable, name='X_PEAK', datatype='float', unit='pix'),
Field(votable, name='Y_PEAK', datatype='float', unit='pix')]
if wcsMask is not None:
fieldsVO += [Field(votable, name='RA_PEAK', datatype='double', unit='deg'),
Field(votable, name='DEC_PEAK', datatype='double', unit='deg')]
fieldsVO += [Field(votable, name='FLUX', datatype='float', unit='CPS')]
if ellipse is True:
fieldsVO += [Field(votable, name='X_ELLIPSE', datatype='float', unit='pix'),
Field(votable, name='Y_ELLIPSE', datatype='float', unit='pix'),
Field(votable, name='SEMIAX1_PIX', datatype='float', unit='pix'),
Field(votable, name='SEMIAX2_PIX', datatype='float', unit='pix'),
Field(votable, name='ELL_ANGLE', datatype='float', unit='deg'),
Field(votable, name='ELL_ERROR', datatype='double')]
if wcsMask is not None:
fieldsVO += [Field(votable, name='RA_ELLIPSE', datatype='double', unit='deg'),
Field(votable, name='DEC_ELLIPSE', datatype='double', unit='deg'),
Field(votable, name='SEMIAX1_SKY', datatype='float', unit='arcsec'),
Field(votable, name='SEMIAX2_SKY', datatype='float', unit='arcsec')]
table.fields.extend(fieldsVO)
table.create_arrays(len(regions.idRegions))
for nReg in range(len(regions.idRegions)):
row = [regions.idRegions[nReg],
centroids[nReg, 1]+1, centroids[nReg, 0]+1, radii[nReg], sizes[nReg]]
if wcsMask is not None:
row += [skyCoordsCentroids[nReg, 0], skyCoordsCentroids[nReg, 1], radiiSky[nReg]]
row += [peaks[nReg], peaksPix[nReg, 1]+1, peaksPix[nReg, 0]+1]
if wcsMask is not None:
row += [skyCoordsPeak[nReg, 0], skyCoordsPeak[nReg, 1]]
row.append(fluxes[nReg])
if ellipse is True:
row += [ellipseFit[nReg, 1]+1, ellipseFit[nReg, 0]+1, ellipseFit[nReg, 2], ellipseFit[nReg, 3],
ellipseAngle[nReg], ellipseFit[nReg, 4]]
if wcsMask is not None:
row += [ellipseCentroidWCS[nReg, 0], ellipseCentroidWCS[nReg, 1], ellipseAxisWCS[nReg, 0],
ellipseAxisWCS[nReg, 1]]
table.array[nReg] = tuple(row)
votable.to_xml(voTableCat)
logger.write('VOTable catalogue: %s' % voTableCat)
else:
# If the vo module is not available, uses PyFits to create a Fits table
logger.write('Creating FITS table ... ', newLine=True)
fields = [pf.Column(name='ID', format='J', array=regions.idRegions),
pf.Column(name='X_CENTROID', format='E', unit='pix', array=centroids[:, 1]+1),
pf.Column(name='Y_CENTROID', format='E', unit='pix', array=centroids[:, 0]+1),
pf.Column(name='RADIUS_PIX', format='E', unit='pix', array=radii),
pf.Column(name='SIZE', format='E', unit='pix', array=sizes)]
if wcsMask is not None:
fields += [pf.Column(name='RA_CENTROID', format='D', unit='deg',
array=skyCoordsCentroids[:, 0]),
pf.Column(name='DEC_CENTROID', format='D', unit='deg',
array=skyCoordsCentroids[:, 1]),
pf.Column(name='RADIUS_SKY', format='D', unit='arcsec',
array=radiiSky)]
fields += [pf.Column(name='PEAK', format='E', unit='CPS', array=peaks),
pf.Column(name='X_PEAK', format='E', unit='pix', array=peaksPix[:, 1]+1),
pf.Column(name='Y_PEAK', format='E', unit='pix', array=peaksPix[:, 0]+1)]
if wcsMask is not None:
fields += [pf.Column(name='RA_PEAK', format='D', unit='deg',
array=skyCoordsPeak[:, 0]),
pf.Column(name='DEC_PEAK', format='D', unit='deg',
array=skyCoordsPeak[:, 1])]
fields += [pf.Column(name='FLUX', format='E', unit='CPS', array=fluxes)]
if ellipse is True:
fields += [pf.Column(name='X_ELLIPSE', format='E', unit='pix',
array=ellipseFit[:, 1]+1),
pf.Column(name='Y_ELLIPSE', format='E', unit='pix',
array=ellipseFit[:, 0]+1),
pf.Column(name='SEMIAX1_PIX', format='E', unit='pix',
array=ellipseFit[:, 2]),
pf.Column(name='SEMIAX2_PIX', format='E', unit='pix',
array=ellipseFit[:, 3]),
pf.Column(name='ELL_ANGLE', format='E', unit='deg',
array=ellipseAngle),
pf.Column(name='ELL_ERROR', format='L', array=ellipseFit[:, 4])]
if wcsMask is not None:
fields += [pf.Column(name='RA_ELLIPSE', format='D', unit='deg',
array=ellipseCentroidWCS[:, 0]),
pf.Column(name='DEC_ELLIPSE', format='D', unit='deg',
array=ellipseCentroidWCS[:, 1]),
pf.Column(name='SEMIAX1_SKY', format='E', unit='arcsec',
array=ellipseAxisWCS[:, 0]),
pf.Column(name='SEMIAX2_SKY', format='E', unit='arcsec',
array=ellipseAxisWCS[:, 1])]
tbhdu = pf.new_table(fields)
hdu = pf.PrimaryHDU()
thdulist = pf.HDUList([hdu, tbhdu])
fitsTableCat = os.path.splitext(voTableCat)[0] + '_Cat.fits'
if os.path.exists(fitsTableCat): os.remove(fitsTableCat)
thdulist.writeto(fitsTableCat)
logger.write('FITS catalogue: %s' % fitsTableCat)
# Creates the DS9 regions file using the centroid and radius information for each region.
logger.write('Creating DS9 regions files ... ', newLine=True)
# For testing purposes we write a file in X, Y.
ds9XYFile = os.path.splitext(ds9RegsFile)[0] + '_XY.reg'
unitRegCentroid = open(ds9XYFile, 'w')
print >>unitRegCentroid, 'global color = green'
ii = 0
for yy, xx in centroids:
regID = regions.idRegions[ii]
rad = radii[ii]
if rad > 0.0:
print >>unitRegCentroid, 'image; circle ' + str(xx+1) + ' ' + str(yy+1) + ' ' + \
str(rad) + '# text = {%d}' % regID
# print >>unitRegCentroid, 'image; x point ' + str(xx+1) + ' ' + str(yy+1) + ' # color=green'
ii += 1
unitRegCentroid.close()
# Write RA, Dec instead:
if wcsMask is not None:
ds9WCSFile = os.path.splitext(ds9RegsFile)[0] + '_WCS.reg'
unitRegCentroid = open(ds9WCSFile, 'w')
print >>unitRegCentroid, 'global color = blue'
print >>unitRegCentroid, 'fk5'
ii = 0
for ra, dec in skyCoordsCentroids:
regID = regions.idRegions[ii]
rad = radii[ii]
if rad > 0.0:
print >> unitRegCentroid, 'circle(' + str(ra) + ',' + str(dec) + ',' + str(rad) + '")' + \
' # text = {%d}' % regID
ii += 1
unitRegCentroid.close()
if ellipse:
ds9EllFile = os.path.splitext(ds9RegsFile)[0] + '_Ell.reg'
unitRegEllipse = open(ds9EllFile, 'w')
print >>unitRegEllipse, 'global color = red'
for ii in range(regions.nRegs):
regID = regions.idRegions[ii]
print >>unitRegEllipse, 'image; ellipse ' + str(ellipseFit[ii, 1]+1) + ' ' + \
str(ellipseFit[ii, 0]+1) + ' ' + str(ellipseFit[ii, 2]) + ' ' + str(ellipseFit[ii, 3]) + \
' ' + str(ellipseAngle[ii]) + '# text = {%d}' % regID
# print >>unitRegEllipse, 'image; x point ' + str(xx+1) + ' ' + str(yy+1) + ' # color=green'
ii += 1
unitRegEllipse.close()
# Writes a file with the peak positions
if peaksFile is not None:
if wcsMask is None:
raiseError('No WCS information. Cannot continue.')
def dec2dms(dd):
sign = -1. if dd < 0 else 1. # Remember to deal with negative DEC
mnt, sec = divmod(abs(dd) * 3600, 60)
deg, mnt = divmod(mnt, 60)
return deg * sign, mnt, sec
logger.write('Saving peak positions ... ', newLine=True)
peaksUnit = open(peaksFile, 'w')
print >>peaksUnit, '# PDRID, XPIXEL, YPIXEL, RA, DEC'
nn = 0
for yy, xx in peaksPix:
ra = skyCoordsPeak[nn, 0]
dec = skyCoordsPeak[nn, 1]
raHH, raMM, raSS = dec2dms(ra/15.)
decDD, decMM, decSS = dec2dms(dec)
row = '%d, %.2f, %.2f, %02d %02d %05.2f, %+02d %02d %05.2f' % \
(nn, xx, yy, raHH, raMM, raSS, decDD, decMM, decSS)
print >>peaksUnit, row
nn += 1
peaksUnit.close()
if plot:
logger.write('Plotting regions ... ', newLine=True)
try:
from plotDS9 import plotDS9
import ds9
except:
raiseWarning('No pyDS9 module find. Skipping plot.')
return
d = ds9.ds9()
d.set('frame delete all')
plotDS9(image, frame=1)
d.set('scale mode minmax')
d.set('regions load ' + os.path.realpath(ds9XYFile))
plotDS9(mask, frame=2)
d.set('scale log')
d.set('scale mode minmax')
d.set('regions load ' + os.path.realpath(ds9XYFile))
if ellipse:
plotDS9(image, frame=3)
d.set('scale mode minmax')
d.set('regions load ' + os.path.realpath(ds9EllFile))
plotDS9(mask, frame=4)
d.set('scale log')
d.set('scale mode minmax')
d.set('regions load ' + os.path.realpath(ds9EllFile))
return
#!/usr/bin/env python
# encoding: utf-8
"""
plotDS9.py
Created by José Ramón Sánchez-Gallego on 2011-02-17.
Copyright (c) 2011. All rights reserved.
"""
from Error import raiseError
try:
import ds9
except:
raiseError('No ds9 module found.')
import os
def plotDS9(image, frame=1, zscale=True, fit=True, ext=None, adjust=True,
minLimZero=False, keepScale=False, scale=False, delete=False):
ddd = ds9.ds9()
if delete: ddd.set('frame delete all')
ddd.set('frame ' + str(frame))
if keepScale is True:
zMin, zMax = map(float, ddd.get('scale limits').split())
if adjust is True:
from Error import raiseError
try:
import pywcs as pw
except:
try:
import astropy.wcs as pw
except:
raiseError('No pywcs module found.', None)
