def growEllipses(inputImage, distances, center, start, end, pa, ba, mask):
fluxData = np.empty((30, 5))
i = 0
for isoA in range(start, end):
#draw ellipse for all pixels:
currentPixels = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, isoA, ba)
Npix = inputImage[currentPixels].shape[0]
currentFlux = np.sum(inputImage[currentPixels])
#draw ellipse with masks:
inputImageM = np.ma.masked_array(inputImage, mask=mask)
currentPixelsM = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, isoA, ba)
NpixM = inputImageM[currentPixelsM].compressed().shape[0]
currentFluxM = np.sum(inputImageM.filled(0)[currentPixelsM])
#write out
fluxData[i, 0] = isoA
fluxData[i, 1] = currentFlux
fluxData[i, 2] = Npix
fluxData[i, 3] = currentFluxM
fluxData[i, 4] = NpixM
#print isoA, currentFlux, Npix, currentFlux/Npix
i = i + 1
#print 'ret'
return fluxData
def buildGrowthCurve(name, center, distances, pa, ba, inputImage, mask, isoA_max):
band = Settings.getConstants().band
#masked input array
inputImageM = np.ma.masked_array(inputImage, mask=mask)
ellipseMask = np.zeros((inputImage.shape), dtype=np.uint8)
ellipseMaskM = ellipseMask.copy()
fluxData = Photometry.initFluxData(inputImage, center, distances)
#currentPixels = center
#currentFlux = inputImage[center]
Npix = 1 #init
growthSlope = 200 #init
md = np.max(distances)
#print md, 'MD'
for isoA in range(1, min(int(isoA_max), int(md))):
#draw ellipse for all pixels:
currentPixels = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, isoA, ba)
#Npix = inputImage[currentPixels].shape[0]
#currentFlux = np.sum(inputImage[currentPixels])
ellipseMask[currentPixels] = 1
Npix = inputImage[currentPixels].shape[0]
#draw ellipse for masked pixels only:
currentPixelsM = ellipse.draw_ellipse(inputImageM.shape, center[0], center[1], pa, isoA, ba)
ellipseMaskM[currentPixelsM] = 1
maskedPixels = inputImageM[np.where((ellipseMaskM == 1) & (mask == 0))]
#print np.sum(maskedPixels), np.sum(inputImage[np.where(ellipseMask == 1)])
fluxData[isoA, 0] = isoA
fluxData[isoA, 1] = np.sum(inputImage[np.where(ellipseMask == 1)])# cumulative flux
fluxData[isoA, 2] = inputImage[np.where(ellipseMask == 1)].shape[0]
fluxData[isoA, 3] = np.sum(maskedPixels)# - maskedPixels.shape[0]*sky# cumulative flux, without masked pixels
fluxData[isoA, 4] = maskedPixels.shape[0]
#print Npix, NpixM, fluxData[isoA, 2], fluxData[isoA, 4]
isoA = isoA +1
#gc_sky = np.mean(fluxData[isoA-width:isoA-1, 2])
#flux = np.sum(inputImage[np.where(ellipseMask == 1)]) - sky*inputImage[np.where(ellipseMask == 1)].shape[0]
fluxData = fluxData[0:isoA-1,:]
#fluxData[:, 3] = fluxData[:, 3] - fluxData[isoA-1, 4]*sky
#print fluxData[isoA-1, 4], 'no pix'
#fluxData[:, 3] = np.cumsum(fluxData[:, 3])
#fluxData[:, 1] = np.cumsum(fluxData[:, 1])
#the last isoA value was incremented, so it should be subtracted
#fluxData[:, 1] = fluxData[:, 1] - sky*fluxData[:, 5]#cumulative flux, _sky_subtracted
#fluxData[:, 3] = fluxData[:, 3] - sky*fluxData[:, 4]
#fluxData[:, 2] = fluxData[:, 2] - sky #sky-subtracted flux per pixel
#print inputImage[np.where(ellipseMask == 1)].shape[0], '***************************************'
# --------------------------------------- writing an ellipse of counted points, testing only
plotGrowthCurve.plotGrowthCurve(fluxData, Settings.getConstants().band, name)
#hdu = pyfits.PrimaryHDU(ellipseMask)
#hdu.writeto('vimos_masks/Mask'+name+"_"+Settings.getConstants().band+'.fits', clobber=True)
np.savetxt('vimos_growth_curves/el/'+Settings.getConstants().band+'/gc_profile_el_new_'+name+'.csv', fluxData)
def getEllipticalSky(image, i):
center = Photometry.getCenter(i)
print i
CALIFA_ID = str(i+1)
pa = db.dbUtils.getFromDB('pa', Settings.getConstants().dbDir+'CALIFA.sqlite', 'nadine', ' where califa_id = '+ CALIFA_ID)[0]
ba = db.dbUtils.getFromDB('ba', Settings.getConstants().dbDir+'CALIFA.sqlite', 'bestBA', ' where califa_id = '+ CALIFA_ID)[0]
isoA_max = Settings.getSkyFitValues(str(CALIFA_ID)).isoA
start = int(isoA_max - 150)
end = int(isoA_max)
print start, end
fluxData = np.empty((150, 2))
ellipseMask = np.empty((image.shape))
for ind, isoA in enumerate(range(start, end)):
currentPixels = ellipse.draw_ellipse(image.shape, center[0], center[1], pa, isoA, ba)
ellipseMask[currentPixels] = 1
fluxData[ind, 0] = np.sum(image[np.where(ellipseMask == 1)])# cumulative flux
fluxData[ind, 1] = image[np.where(ellipseMask == 1)].shape[0]
Npix = fluxData[-1,1]
sky = np.mean(fluxData[-1, 0]/Npix)
return sky
def fitSky(center, distances, pa, ba, img, mask, name):
#limit = findClosestEdge(distances, center)
band = Settings.getConstants().band
#start = Photometry.getStart(CALIFA_ID) - 500
start = 10
radius = 30
step = 5
fluxSlopeM = -10 #init
fluxSlope = -10
while fluxSlopeM < 0:
fluxData = Photometry.growEllipses(img, distances, center, start, start+radius, pa, ba, mask)
#fitting unmasked
xi = fluxData[:, 0] #isoA
A = np.array([xi, np.ones(len(fluxData))])
y = np.divide(fluxData[:, 1], fluxData[:, 2]) #flux ppx
#print np.mean(y), start
w = np.linalg.lstsq(A.T,y)[0] # obtaining the parameters
fluxSlope = w[0]
line = w[0]*xi+w[1] # regression line
#print fluxSlope, 'slope'
#fitting masked
#print 'fitting masked'
xi = fluxData[:, 0] #isoA
A = np.array([xi, np.ones(len(fluxData))])
yM = np.divide(fluxData[:, 3],fluxData[:, 4]) #flux ppx
w = np.linalg.lstsq(A.T,yM)[0] # obtaining the parameters
fluxSlopeM = w[0]
#print np.mean(yM), np.mean(y), start, fluxSlope, np.sum(fluxData[:, 2]), np.sum(fluxData[:, 4])
line = w[0]*xi+w[1] # regression line
print fluxSlopeM, 'slope', start+radius
start = start + step
img_c = img.copy()
currentPixels = ellipse.draw_ellipse(img.shape, center[0], center[1], pa, start-step, ba)
img_c[currentPixels] = 10
img_c, cdf = imtools.histeq(img_c)
scipy.misc.imsave('vimos/img/snapshots/'+band+"/"+name+'.png', img_c)
return np.mean(y), fluxSlope, np.mean(yM), fluxSlopeM, fluxData[-1, 0]
def ellipseContours(y0, x0, pa, isoA, axisRatio): #ellipseY, ellipseX = ellipse.draw_ellipse(y0, x0, pa, isoA, axisRatio, nPoints) ellipseY, ellipseX = ellipse.draw_ellipse(y0, x0, pa, 60, 0.5) return (ellipseY, ellipseX)
def buildGrowthCurve(center, distances, pa, ba, CALIFA_ID):
band = Settings.getConstants().band
sky = Settings.getSkyFitValues(str(CALIFA_ID)).sky
isoA_max = Settings.getSkyFitValues(str(CALIFA_ID)).isoA
inputImage = Photometry.getInputFile(int(CALIFA_ID) - 1, band)
#masked input array
mask = Photometry.getMask(int(CALIFA_ID)-1)
mask = getCroppedMask(mask, int(CALIFA_ID)-1)
inputImageM = np.ma.masked_array(inputImage, mask=mask)
ellipseMask = np.zeros((inputImage.shape), dtype=np.uint8)
ellipseMaskM = ellipseMask.copy()
fluxData = Photometry.initFluxData(inputImage, center, distances)
#currentPixels = center
#currentFlux = inputImage[center]
Npix = 1 #init
growthSlope = 200 #init
for isoA in range(1, int(isoA_max)+1):
#draw ellipse for all pixels:
currentPixels = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, isoA, ba)
#Npix = inputImage[currentPixels].shape[0]
#currentFlux = np.sum(inputImage[currentPixels])
ellipseMask[currentPixels] = 1
Npix = inputImage[currentPixels].shape[0]
#draw ellipse for masked pixels only:
currentPixelsM = ellipse.draw_ellipse(inputImageM.shape, center[0], center[1], pa, isoA, ba)
ellipseMaskM[currentPixelsM] = 1
maskedPixels = inputImageM[np.where((ellipseMaskM == 1) & (mask == 0))]
#NpixM = inputImageM[currentPixelsM].compressed().shape[0]
#currentFluxM = np.sum(inputImageM.filled(0)[currentPixelsM])
#print Npix - NpixM, currentFlux-currentFluxM
#growthSlope = utils.getSlope(oldFlux, currentFlux, isoA-1, isoA)
#print 'isoA', isoA
fluxData[isoA, 0] = isoA
fluxData[isoA, 1] = np.sum(inputImage[np.where(ellipseMask == 1)])# cumulative flux
fluxData[isoA, 2] = inputImage[np.where(ellipseMask == 1)].shape[0]
fluxData[isoA, 3] = np.sum(maskedPixels)# cumulative flux, without masked pixels
fluxData[isoA, 4] = maskedPixels.shape[0]
#print Npix, NpixM, fluxData[isoA, 2], fluxData[isoA, 4]
isoA = isoA +1
#gc_sky = np.mean(fluxData[isoA-width:isoA-1, 2])
#flux = np.sum(inputImage[np.where(ellipseMask == 1)]) - sky*inputImage[np.where(ellipseMask == 1)].shape[0]
fluxData = fluxData[0:isoA-1,:] #the last isoA value was incremented, so it should be subtracted
#fluxData[:, 1] = fluxData[:, 1] - sky*fluxData[:, 5]#cumulative flux, _sky_subtracted
#fluxData[:, 3] = fluxData[:, 3] - sky*fluxData[:, 4]
#fluxData[:, 2] = fluxData[:, 2] - sky #sky-subtracted flux per pixel
#print inputImage[np.where(ellipseMask == 1)].shape[0], '***************************************'
# --------------------------------------- writing an ellipse of counted points, testing only
#hdu = pyfits.PrimaryHDU(ellipseMask)
#hdu.writeto('masks/ellipseMask'+CALIFA_ID+'.fits', clobber=True)
# --------------------- writing output jpg file with both outermost annuli
outputImage = inputImage
elPix = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, isoA-1, ba)
outputImage[elPix] = 0
outputImage, cdf = imtools.histeq(outputImage)
scipy.misc.imsave('img/2/snapshots/'+band+"/"+CALIFA_ID+'.jpg', outputImage)
np.savetxt('growth_curves/2/'+Settings.getConstants().band+'/gc_profile'+CALIFA_ID+'.csv', fluxData)
def calculateGrowthCurve(listFile, dataDir, i):
CALIFA_ID = str(i+1)
inputImage = Photometry.getInputFile(listFile, dataDir, i)
dbDir = '../db/'
imgDir = 'img/'+setBand()+'/'
center = Photometry.getCenter(listFile, i, dataDir)
distances = Photometry.createDistanceArray(listFile, i, dataDir)
#hdu = pyfits.PrimaryHDU(distances)
#hdu.writeto('distances.fits')
sky = inputImage[np.where(distances > int(round(Photometry.iso25D)))]
skyMean = np.mean(sky)
skySD = np.std(sky)
#i+1 in the next line reflects the fact that CALIFA id's start with 1
pa = db.dbUtils.getFromDB('PA', dbDir+'CALIFA.sqlite', 'nadine', ' where califa_id = '+ CALIFA_ID)[0][0] #parsing tuples
ba = db.dbUtils.getFromDB('ba', dbDir+'CALIFA.sqlite', 'nadine', ' where califa_id = '+ CALIFA_ID)[0][0]#parsing tuples
#ba = 1
#r_mag = db.dbUtils.getFromDB('r_mag', dbDir+'CALIFA.sqlite', 'nadine', ' where califa_id = '+ CALIFA_ID)[0][0]#parsing tuples
#r_e = db.dbUtils.getFromDB('re', dbDir+'CALIFA.sqlite', 'nadine', ' where califa_id = '+ CALIFA_ID)[0][0]#parsing tuples
#lucy_re = db.dbUtils.getFromDB('re', dbDir+'CALIFA.sqlite', 'lucie', ' where id = '+ CALIFA_ID)[0][0]#parsing tuples
#l_SkyMean = db.dbUtils.getFromDB('sky', dbDir+'CALIFA.sqlite', 'lucie', ' where id = '+ CALIFA_ID)[0][0] - 1000#parsing tuples
# print 'ba', ba
#fluxData = Photometry.buildGrowthCurve(inputImage, center, distances, skyMean, pa, ba)
#isoA = fluxData.shape[0]
# --------------------------------------- starting GC photometry in circular annuli
print 'CIRCULAR APERTURE'
#circFlux, circFluxData = Photometry.circularFlux(inputImage, center, distances, skyMean)
circFlux, circFluxData, gc_sky = Photometry.buildGrowthCurve(inputImage, center, distances, skyMean, pa, 1, str(i+1))
circRadius = circFluxData.shape[0]
#print circRadius, 'circle radius'
#otherFlux = circFluxData[-1, 1]
#print 'fluxes: mask:', circFlux, 'sum', otherFlux
try:
circHLR = circFluxData[np.where(np.floor(circFlux/circFluxData[:,1]) == 1)][0][0] - 1 #Floor() -1 -- last element where the ratio is 2
except IndexError as e:
circHLR = str(e)
circMag = Photometry.calculateFlux(circFlux, listFile, i)
# --------------------------------------- starting ellipse GC photometry
print 'ELLIPTICAL APERTURE'
totalFlux, fluxData, gc_sky = Photometry.buildGrowthCurve(inputImage, center, distances, skyMean, pa, ba, CALIFA_ID, e=True)
otherFlux = fluxData[fluxData.shape[0]-1, 6]
elMajAxis = fluxData.shape[0]
#print totalFlux - otherFlux, 'flux diff'
#print 't', totalFlux, 'o', otherFlux
diff = [CALIFA_ID, totalFlux - otherFlux]
utils.writeOut(diff, 'fluxdiff.txt')
elMag = Photometry.calculateFlux(totalFlux, listFile, i)
try:
elHLR = fluxData[np.where(np.floor(totalFlux/fluxData[:, 1]) == 1)][0][0] - 1 #Floor() -1 -- last element where the ratio is 2
print elHLR
except IndexError as e:
print 'err'
elHLR = e
plotGrowthCurve.plotGrowthCurve(fluxData, CALIFA_ID)
# --------------------- writing output jpg file with both outermost annuli
outputImage = inputImage
circpix = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, circRadius, 1)
elPix = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, elMajAxis, ba)
outputImage[circpix] = 0
outputImage[elPix] = 0
outputImage, cdf = imtools.histeq(outputImage)
#scipy.misc.imsave('img/output/'+CALIFA_ID+'.jpg', outputImage)
scipy.misc.imsave(imgDir+'snapshots/'+CALIFA_ID+'_gc.jpg', outputImage)
#hdu = pyfits.PrimaryHDU(outputImage)
#outputName = 'CALIFA'+CALIFA_ID+'.fits'
#hdu.writeto(outputName)
# ------------------------------------- formatting output row
output = [CALIFA_ID, elMag, elHLR, circMag, circHLR, np.mean(sky), gc_sky]
print output
#print skyMean, oldSky, 'sky'
return output
def buildGrowthCurve(inputImage, center, distances, skyMean, pa, ba, CALIFA_ID, e=False):
ellipseMask = np.zeros((inputImage.shape))
sky = inputImage[np.where(distances > int(round(Photometry.iso25D)))]
fluxData = np.empty((np.max(distances), 7))
fluxData[0,0] = 0
fluxData[0,1] = inputImage[center]
fluxData[0,2] = inputImage[center]
fluxData[0,3] = 200
fluxData[0,4] = inputImage[center]
fluxData[0,5] = 1
fluxData[0,6] = 1
currentPixels = center
currentFlux = inputImage[center] - skyMean
isoA = 1 #initialising
Npix = 1
totalNpix = 1
oldFlux = inputImage[center[0], center[1]]
growthSlope = 200
outputImage = inputImage
skySD = np.std(sky)
limitCriterion = 0.0001*skySD
width = 20
output = inputImage.copy()
while Photometry.checkLimitCriterion(fluxData, isoA-1, limitCriterion, width) != 1:
previousNpix = Npix
oldFlux = currentFlux
currentPixels = ellipse.draw_ellipse(inputImage.shape, center[0], center[1], pa, isoA, ba)
ellipse.getPixelEllipseLength(isoA, ba)
ellipseMask[currentPixels] = 1
Npix = inputImage[currentPixels].shape[0]
totalNpix = inputImage[np.where(ellipseMask == 1)].shape[0]
currentFlux = np.sum(inputImage[currentPixels])
output[currentPixels] = 1
growthSlope = utils.getSlope(oldFlux, currentFlux, isoA-1, isoA)
#print 'isoA', isoA, 'Npix', Npix
fluxData[isoA, 0] = isoA
fluxData[isoA, 1] = np.sum(inputImage[np.where(ellipseMask == 1)])# cumulative flux
fluxData[isoA, 2] = currentFlux/Npix
fluxData[isoA, 3] = growthSlope/Npix
fluxData[isoA, 4] = currentFlux #current flux
fluxData[isoA, 5] = Npix
fluxData[isoA, 6] = totalNpix
isoA = isoA +1
gc_sky = np.mean(fluxData[isoA-width:isoA-1, 2])
flux = np.sum(inputImage[np.where(ellipseMask == 1)]) - gc_sky*inputImage[np.where(ellipseMask == 1)].shape[0]
fluxData = fluxData[0:isoA-1,:] #the last isoA value was incremented, so it should be subtracted
fluxData[:, 1] = fluxData[:, 1] - gc_sky*fluxData[:, 6]#cumulative flux, _sky_subtracted
#print fluxData[-1, 1], gc_sky, 'SKY', fluxData[-1, 6], gc_sky*totalNpix
fluxData[:, 4] = fluxData[:, 4] #current flux
fluxData[:, 6] = fluxData[:, 4] - gc_sky*fluxData[:, 5] #current flux, sky subtracted
#print inputImage[np.where(ellipseMask == 1)].shape[0], 'shape', Npix, 'npix', np.mean(fluxData[isoA-width:isoA-1, 2]), 'sky'
fluxData[:, 2] = fluxData[:, 2] - gc_sky #sky-subtracted flux per pixel
#print inputImage[np.where(ellipseMask == 1)].shape[0], '***************************************'
# --------------------------------------- writing an ellipse of counted points, testing only
#if e:
# hdu = pyfits.PrimaryHDU(output)
# hdu.writeto('ellipseMask'+CALIFA_ID+'.fits')
np.savetxt('growth_curves/'+setBand()+'/gc_profile'+CALIFA_ID+'.csv', fluxData)
return (flux, fluxData, gc_sky)
