def testFootprintToBBoxList(self):
"""Test footprintToBBoxList"""
region = afwGeom.Box2I(afwGeom.Point2I(0, 0), afwGeom.Extent2I(12, 10))
foot = afwDetect.Footprint(0, region)
for y, x0, x1 in [
(3, 3, 5),
(3, 7, 7),
(4, 2, 3),
(4, 5, 7),
(5, 2, 3),
(5, 5, 8),
(6, 3, 5),
]:
foot.addSpan(y, x0, x1)
idImage = afwImage.ImageU(region.getDimensions())
idImage.set(0)
foot.insertIntoImage(idImage, 1)
if display:
ds9.mtv(idImage)
idImageFromBBox = idImage.Factory(idImage, True)
idImageFromBBox.set(0)
bboxes = afwDetect.footprintToBBoxList(foot)
for bbox in bboxes:
x0, y0, x1, y1 = bbox.getMinX(), bbox.getMinY(), bbox.getMaxX(
), bbox.getMaxY()
for y in range(y0, y1 + 1):
for x in range(x0, x1 + 1):
idImageFromBBox.set(x, y, 1)
if display:
x0 -= 0.5
y0 -= 0.5
x1 += 0.5
y1 += 0.5
ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)],
ctype=ds9.RED)
idImageFromBBox -= idImage # should be blank
stats = afwMath.makeStatistics(idImageFromBBox, afwMath.MAX)
self.assertEqual(stats.getValue(), 0)
def testFootprintToBBoxList(self):
"""Test footprintToBBoxList"""
region = lsst.geom.Box2I(lsst.geom.Point2I(0, 0),
lsst.geom.Extent2I(12, 10))
foot = afwDetect.Footprint(afwGeom.SpanSet(), region)
spanList = [
afwGeom.Span(*span)
for span in ((3, 3, 5), (3, 7, 7), (4, 2, 3), (4, 5, 7), (5, 2, 3),
(5, 5, 8), (6, 3, 5))
]
foot.spans = afwGeom.SpanSet(spanList)
idImage = afwImage.ImageU(region.getDimensions())
idImage.set(0)
foot.spans.setImage(idImage, 1)
if display:
disp = afwDisplay.Display(frame=1)
disp.mtv(idImage, title=self._testMethodName + " image")
idImageFromBBox = idImage.Factory(idImage, True)
idImageFromBBox.set(0)
bboxes = afwDetect.footprintToBBoxList(foot)
for bbox in bboxes:
x0, y0, x1, y1 = bbox.getMinX(), bbox.getMinY(), \
bbox.getMaxX(), bbox.getMaxY()
for y in range(y0, y1 + 1):
for x in range(x0, x1 + 1):
idImageFromBBox[x, y, afwImage.LOCAL] = 1
if display:
x0 -= 0.5
y0 -= 0.5
x1 += 0.5
y1 += 0.5
disp.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)],
ctype=afwDisplay.RED)
idImageFromBBox -= idImage # should be blank
stats = afwMath.makeStatistics(idImageFromBBox, afwMath.MAX)
self.assertEqual(stats.getValue(), 0)
def defectListFromFootprintList(fpList):
"""Compute a defect list from a footprint list, optionally growing the footprints.
Parameters
----------
fpList : `list` of `lsst.afw.detection.Footprint`
Footprint list to process.
Returns
-------
defectList : `list` of `lsst.afw.meas.algorithms.Defect`
List of defects.
"""
defectList = []
for fp in fpList:
for bbox in afwDetection.footprintToBBoxList(fp):
defect = measAlg.Defect(bbox)
defectList.append(defect)
return defectList
def defectListFromFootprintList(fpList, growFootprints=1):
"""Compute a defect list from a footprint list, optionally growing the footprints
@param[in] fpList footprint list
@param[in] growFootprints amount by which to grow footprints of detected regions
@return meas.algorithms.DefectListT
"""
defectList = measAlg.DefectListT()
for fp in fpList:
if growFootprints > 0:
# if "True", growing requires a convolution
# if "False", its faster
fpGrow = afwDetection.growFootprint(fp, growFootprints, False)
else:
fpGrow = fp
for bbox in afwDetection.footprintToBBoxList(fpGrow):
defect = measAlg.Defect(bbox)
defectList.push_back(defect)
return defectList
def defectListFromFootprintList(fpList, growFootprints=1):
"""Compute a defect list from a footprint list, optionally growing the footprints
@param[in] fpList footprint list
@param[in] growFootprints amount by which to grow footprints of detected regions
@return meas.algorithms.DefectListT
"""
defectList = measAlg.DefectListT()
for fp in fpList:
if growFootprints > 0:
# if "True", growing requires a convolution
# if "False", its faster
fpGrow = afwDetection.growFootprint(fp, growFootprints, False)
else:
fpGrow = fp
for bbox in afwDetection.footprintToBBoxList(fpGrow):
defect = measAlg.Defect(bbox)
defectList.push_back(defect)
return defectList
def defectListFromFootprintList(fpList, growFootprints=1):
"""Compute a defect list from a footprint list, optionally growing the footprints
@param[in] fpList footprint list
@param[in] growFootprints amount by which to grow footprints of detected regions
@return a list of defects (meas.algorithms.Defect)
"""
defectList = []
for fp in fpList:
if growFootprints > 0:
# if "True", growing requires a convolution
# if "False", its faster
tempSpans = fp.spans.dilated(growFootprints,
afwGeom.Stencil.MANHATTAN)
fpGrow = afwDetection.Footprint(tempSpans, fp.getRegion())
else:
fpGrow = fp
for bbox in afwDetection.footprintToBBoxList(fpGrow):
defect = measAlg.Defect(bbox)
defectList.append(defect)
return defectList
def testFootprintToBBoxList(self):
"""Test footprintToBBoxList"""
region = afwGeom.Box2I(afwGeom.Point2I(0,0), afwGeom.Extent2I(12,10))
foot = afwDetect.Footprint(0, region)
for y, x0, x1 in [(3, 3, 5), (3, 7, 7),
(4, 2, 3), (4, 5, 7),
(5, 2, 3), (5, 5, 8),
(6, 3, 5),
]:
foot.addSpan(y, x0, x1)
idImage = afwImage.ImageU(region.getDimensions())
idImage.set(0)
foot.insertIntoImage(idImage, 1)
if display:
ds9.mtv(idImage)
idImageFromBBox = idImage.Factory(idImage, True)
idImageFromBBox.set(0)
bboxes = afwDetect.footprintToBBoxList(foot)
for bbox in bboxes:
x0, y0, x1, y1 = bbox.getMinX(), bbox.getMinY(), bbox.getMaxX(), bbox.getMaxY()
for y in range(y0, y1 + 1):
for x in range(x0, x1 + 1):
idImageFromBBox.set(x, y, 1)
if display:
x0 -= 0.5
y0 -= 0.5
x1 += 0.5
y1 += 0.5
ds9.line([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)], ctype=ds9.RED)
idImageFromBBox -= idImage # should be blank
stats = afwMath.makeStatistics(idImageFromBBox, afwMath.MAX)
self.assertEqual(stats.getValue(), 0)
im = mi.getImage()
arr = im.getArray()
deadidx = numpy.where(arr == 0.)
hotidx = numpy.where(arr > 1.1)
arr[deadidx] = 2.
arr[hotidx] = 3.
im2 = ai.makeImageFromArray(arr)
thresh = afwDetection.Threshold(1.1)
fs = afwDetection.FootprintSet(im2, thresh)
x0 = []
y0 = []
width = []
height = []
for f in fs.getFootprints():
for bbox in afwDetection.footprintToBBoxList(f):
bbox = cameraGeom.rotateBBoxBy90(bbox, 3, im.getBBox().getDimensions())
x0.append(bbox.getMinX())
y0.append(bbox.getMinY())
width.append(bbox.getWidth())
height.append(bbox.getHeight())
head = fits.Header()
cmap = {'A': (0, 0), 'B': (0, 1)}
if ha is not None:
head.update('SERIAL', int('%i%i%i%i%i%i' %
(rx, ry, sx, sy, cmap[ha][0], cmap[ha][1])), 'Serial of the sensor')
head.update('NAME', 'R:%i,%i S:%i,%i,%c'%(rx, ry, sx, sy, ha), 'Name of sensor for this defect map')
else:
head.update('SERIAL', int('%i%i%i%i'%(rx, ry, sx, sy)), 'Serial of the sensor')
head.update('NAME', 'R:%i,%i S:%i,%i'%(rx, ry, sx, sy), 'Name of sensor for this defect map')
def makeBBList(mask, ccd):
# Create a bounding box corresponding to the useful part of the CCD
# (exclude overscan regions)
bb = geom.Box2I(geom.Point2I(32, 0), geom.Point2I(2079, 4611))
# Read mask file provided by Elixir team
im = afwImage.ImageF('%s.fits[' % mask + str(ccd + 1) + ']',
bbox=bb,
origin=afwImage.ImageOrigin.PARENT)
# Pixel values in mask files are 1 for background and 0 for bad pixels
# - Need to inverse this
im *= -1.
im += 1.
im *= 10.
level = 2
s = afwDetect.FootprintSet(im, afwDetect.Threshold(level, polarity=True))
keys = ['x', 'y', 'w', 'h']
defect = {k: [] for k in keys}
defectE = {k: [] for k in keys}
for f in s.getFootprints():
fpl = afwDetect.footprintToBBoxList(f)
for i in fpl:
i.shift(geom.Extent2I(-32, 0))
x0 = i.getBeginX()
y0 = i.getBeginY()
w0 = i.getWidth()
h0 = i.getHeight()
defect['x'].append(x0)
defect['y'].append(y0)
defect['w'].append(w0)
defect['h'].append(h0)
if (x0 % 2 == 0):
x1 = x0
if (w0 % 2 == 0):
w1 = w0
else:
w1 = w0 + 1
else:
x1 = max(x0 - 1, 0)
if (w0 % 2 == 0):
w1 = min(w0 + 2, 2048)
else:
w1 = min(w0 + 1, 2048)
if (y0 % 2 == 0):
y1 = y0
if (h0 % 2 == 0):
h1 = h0
else:
h1 = min(h0 + 1, 4612)
else:
y1 = max(y0 - 1, 0)
if (h0 % 2 == 0):
h1 = min(h0 + 2, 4612)
else:
h1 = min(h0 + 1, 4612)
defectE['x'].append(x1)
defectE['y'].append(y1)
defectE['w'].append(w1)
defectE['h'].append(h1)
return defect, defectE
def findMatchingFootprints(eIm, eHDUList, wcs, ra, dec, rmags, baRatio, objId, option, a_disk, b_disk, a_bulge, b_bulge, diskFluxNorm, bulgeFluxNorm, pa_d, raEdge, decEdge, dxMin, dyMin, matchArcsec, plotno, ePath):
# Get the set of footprints from the FITS image, setting the
# threshold by either count value or STDEV. footprintsP is the list
# of positive footprints for that particular FITS file, con-
# sisting of a set of pixels. getFootprints() returns the
# footprints of detected objects.
# Don't set the detection limit too bright, or sources will
# sometimes be missed.
detSetP = afwDetection.makeFootprintSet(
eIm, afwDetection.createThreshold(2., 'value'))
#eIm, afwDetection.createThreshold(28., 'stdev'))
footprintsP = detSetP.getFootprints()
nf = len(footprintsP)
b1 = 1.999*1 - 0.327
b4 = 1.999*4 - 0.327
detxs = []; detys = []; nCts = []; estSizePix = []
detMinx = []; detMaxx = []; detMiny = []; detMaxy = []
detMaxRad2 = []
n = 0; boxSize = 2
minCtsBrightThresh = 1000
#print 'Considering %i positive footprints.' % len(footprintsP)
for fp in footprintsP:
if n % 10000 == 0: print '%i of %i positive footprints analyzed.' % (n, nf)
# Return "a list of BBoxs whose union contains exactly the pixels in
# foot, neither more or less."
# This looks at each boundary box in the list of boundary boxes (bboxes)
# and gets the minimum and maximum x and y values of the list of coordinates,
# and calculates the x and y lengths of the boundary box (dx, dy).
# Lots of times they're only 1 pixel in length. fAllFPP is a file
# containing the center x,y coordinates of each footprint, as well as dx and dy.
# minx, maxx, miny, and maxy will be the very minimum and maximum values of
# all the footprints for all the boundary boxes in the list. Create a
# rectangular footprint:
bboxes = afwDetection.footprintToBBoxList(fp)
minx = 1e100; maxx = -1e100; miny = 1e100; maxy = -1e100
for bbox in bboxes:
x0, y0 = bbox.getMinX(), bbox.getMinY()
x1, y1 = bbox.getMaxX(), bbox.getMaxY()
dx = x1 - x0; dy = y1 - y0
minx = min([minx, x0, x1]); maxx = max([maxx, x0, x1])
miny = min([miny, y0, y1]); maxy = max([maxy, y0, y1])
oldminx = minx; oldmaxx = maxx
oldminy = miny; oldmaxy = maxy
# The footprint regions are sometimes skewed, so center them
# as best we can by finding the maximum pixel and then weighting
# around that.
# eIm.get(x,y) returns the number of counts (t0) in that pixel.
# DS9 uses 1-based coords, so add 1
highPixx = -1; highPixy = -1; highPixVal = -1.e100
for x in range(minx, maxx+1):
for y in range(miny, maxy+1):
t0 = eIm.get(x, y)
if t0 > highPixVal:
highPixx = x; highPixy = y; highPixVal = t0
# Now we know the max pixel. Work in an aperture around it. Use the
# footprints to set the maximum extent of the aperture.
# Check to make sure the distance of the pixel in question is equal
# to or less that the maximum radius of the aperture.
# ctsWtSumx(or y) is the weighted center coordinate of the object
# in the x (or y) direction.
# detxs is a list of ctsWtSumx for each footprint.
# Only keep the eImages that are above a minimum brightness threshold
# and above a minimum x or y width in terms of pixels.
tCts = 0; ctsWtSumx = 0; ctsWtSumy = 0; nPix = 0
t0 = (maxx - highPixx)**2
t1 = (minx - highPixx)**2
maxx2 = max(t0, t1)
t0 = (maxy - highPixy)**2
t1 = (miny - highPixy)**2
maxy2 = max(t0, t1)
maxRad2 = maxx2 + maxy2
dx = abs(maxx - minx)
dy = abs(maxy - miny)
if dx >= dxMin or dy >= dyMin:
for x in range(minx, maxx+1):
for y in range(miny, maxy+1):
r2 = (x-highPixx)**2 + (y-highPixy)**2
if r2 > maxRad2: continue
t0 = eIm.get(x, y)
tCts += t0
ctsWtSumx += x * t0; ctsWtSumy += y * t0
nPix += 1
if tCts > minCtsBrightThresh:
ctsWtSumx /= float(tCts); ctsWtSumy /= float(tCts)
# Now iterate it again over a smaller region to improve
# your chances of hitting the center.
minx = int(ctsWtSumx - dx/5.); maxx = int(ctsWtSumx + dx/5.)
miny = int(ctsWtSumy - dy/5.); maxy = int(ctsWtSumy + dy/5.)
if maxx > 3999: maxx = 3999
if minx < 1: minx = 0
if maxy > 4071: maxy = 4071
if miny < 1: miny = 0
highPixx = -1; highPixy = -1; highPixVal = -1.e100
for x in range(minx, maxx+1):
for y in range(miny, maxy+1):
t0 = eIm.get(x, y)
if t0 > highPixVal:
highPixx = x; highPixy = y; highPixVal = t0
tCts = 0; ctsWtSumx = 0; ctsWtSumy = 0; nPix = 0
t0 = (maxx - highPixx)**2
t1 = (minx - highPixx)**2
maxx2 = max(t0, t1)
t0 = (maxy - highPixy)**2
t1 = (miny - highPixy)**2
maxy2 = max(t0, t1)
maxRad2 = maxx2 + maxy2
for x in range(minx, maxx+1):
for y in range(miny, maxy+1):
r2 = (x-highPixx)**2 + (y-highPixy)**2
if r2 > maxRad2: continue
t0 = eIm.get(x, y)
tCts += t0
ctsWtSumx += x * t0; ctsWtSumy += y * t0
nPix += 1
ctsWtSumx /= float(tCts); ctsWtSumy /= float(tCts)
minx = oldminx
maxx = oldmaxx
miny = oldminy
maxy = oldmaxy
t0 = (maxx - ctsWtSumx)**2
t1 = (minx - ctsWtSumx)**2
maxx2 = max(t0, t1)
t0 = (maxy - ctsWtSumy)**2
t1 = (miny - ctsWtSumy)**2
maxy2 = max(t0, t1)
maxRad2 = maxx2 + maxy2
detxs.append(ctsWtSumx); detys.append(ctsWtSumy)
nCts.append(tCts); estSizePix.append(nPix)
detMinx.append(int(ctsWtSumx-dx/2.)); detMaxx.append(int(ctsWtSumx+dx/2.))
detMiny.append(int(ctsWtSumy-dy/2.)); detMaxy.append(int(ctsWtSumy+dy/2.))
detMaxRad2.append(maxRad2)
n += 1
# At this point you have data for bright enough, wide enough footprints.
detxs = numpy.array(detxs); detys = numpy.array(detys)
nCts = numpy.array(nCts); estSizePix = numpy.array(estSizePix)
detMinx = numpy.array(detMinx); detMaxx = numpy.array(detMaxx)
detMiny = numpy.array(detMiny); detMaxy = numpy.array(detMaxy)
#brightRAs = numpy.zeros(len(detxs))
#brightDecs = numpy.zeros(len(detxs))
brightRAs = wcs.pixelToSky(detxs, detys).getPosition()[0]
brightDecs = wcs.pixelToSky(detxs, detys).getPosition()[1]
# for each value of your original coordinates of interest,
# create a list (t0) of the square of the distance between each bright
# coordinate and the galaxy coordinates. t1 is the index of the minimum distance
# squared, so t0[t1] is the minimum distance squared. The match to your
# coordinates is brightRAs[t1] and BrightDecs[t1].
#matchDistArcsec = numpy.zeros(len(ra))id
psi = []
psiFit = []
psiCatRaDec = []
psiCatXY = []
psiImageRaDec = []
psiImageXY = []
pa_d = []
aFit = []
bFit = []
baRatioFit = []
idx = []
tidx = []
distArcsec = []
gal_code = ['Lowba_bulge_Only', 'Lowba_disk_Only', 'Lowba_bulge_and_Disk']
#gal_code = ['Bulge_Only', 'Disk_Only', 'Bulge_and_Disk']
for i in range(len(ra)):
# Assuming distance is small, keep it linear
t0 = (brightRAs - ra[i])**2 + (brightDecs - dec[i])**2
t1 = numpy.argmin(t0)
diffArcsec = numpy.sqrt(t0[t1]) * 3600.
if diffArcsec <= matchArcsec:
idx.append(i)
tidx.append(t1)
distArcsec.append(diffArcsec)
ra = ra[idx]
dec = dec[idx]
raEdge = raEdge[idx]
decEdge = decEdge[idx]
raCat = raEdge - ra
decCat = decEdge - dec
psiCatRaDec.append(positionAngle(raCat, decCat))
xyCtrCat = wcs.skyToPixel(ra, dec)
xCtrCat, yCtrCat = xyCtrCat
xyPixPos = wcs.skyToPixel(raEdge, decEdge)
xPixPos, yPixPos = xyPixPos
xCat = xPixPos - xCtrCat
yCat = yPixPos - yCtrCat
psiCatXY.append(positionAngle(xCat, yCat))
distArcsec = numpy.array(distArcsec)
brightRAs = brightRAs[tidx]
brightDecs = brightDecs[tidx]
ra = ra[idx]
dec = dec[idx]
raEdge = raEdge[idx]
decEdge = decEdge[idx]
detMinx = detMinx[tidx]
detMaxx = detMaxx[tidx]
detMiny = detMiny[tidx]
detMaxy = detMaxy[tidx]
xwidth = abs(detMaxx - detMinx)
ywidth = abs(detMaxy - detMiny)
detxs = detxs[tidx]
detys = detys[tidx]
pa_d = pa_d[idx]
Rad2Max = max((xwidth/2.)**2, (ywidth/2.)**2)
nbins = int(max(xwidth/2., ywidth/2.))
rmags = rmags[idx]
baRatio = baRatio[idx]
option = option[idx]
objId = objId[idx]
a_disk = a_disk[idx]
b_disk = b_disk[idx]
a_bulge = a_bulge[idx] #for m in range(nbins[i]):
b_bulge = b_bulge[idx]
diskFluxNorm = diskFluxNorm[idx]
bulgeFluxNorm = bulgeFluxNorm[idx]
# Now you've got the object and its radius. To calculate the flux as a
# function of radius, I(r), break the radius squared into multiple segments
# and bin the number of counts. Then divide the total number of counts
# in each bin by the area, if you want.
print 'len(detxs), len(objId), len(rmags), len(a_disk), len(detMinx), len(detMaxy): '
print len(detxs), len(objId), len(rmags), len(a_disk), len(detMinx), len(detMaxy)
for i in range(len(detxs)):
if i != -1:
print 'Galaxy ID: ', objId[i]
print 'rmags: ', rmags[i]
print 'a_disk: ', a_disk[i]
print 'b_disk: ', b_disk[i]
print 'a_bulge: ', a_bulge[i]
print 'b_bulge: ', b_bulge[i]
print 'diskFluxNorm: ', diskFluxNorm[i]
print 'bulgeFluxNorm: ', bulgeFluxNorm[i]
print 'detMinx: ', detMinx[i]
print 'detMaxx: ', detMaxx[i]
print 'detMiny: ', detMiny[i]
print 'detMaxy: ', detMaxy[i]
print 'pa_d: ', pa_d[i]
print 'detxs: ', detxs[i]
print 'detys: ', detys[i]
print 'ra (cat): ', ra[i]
print 'dec (cat): ', dec[i]
print 'raEdge, decEdge: ', raEdge[i], decEdge[i]
print 'psiCatXY: xPixPos, xCtrCat, yPixPos, yCtrCat'
print xPixPos[i], xCtrCat[i], yPixPos[i], yCtrCat[i]
tCts = numpy.zeros(nbins[i])
I_R = numpy.zeros(nbins[i])
nPix = numpy.zeros(nbins[i])
mew = numpy.zeros(nbins[i])
rErr = numpy.zeros(nbins[i])
Err_Up = numpy.zeros(nbins[i])
Err_Dn = numpy.zeros(nbins[i])
a2Bin = numpy.zeros(nbins[i])
aBin = numpy.zeros(nbins[i])
AveABin = numpy.zeros(nbins[i])
xBdry = []
yBdry = []
ellipticity = b_disk[i]/a_disk[i]
# Create an image plot for each footprint.
C = numpy.zeros(((detMaxy[i]-detMiny[i]+1), (detMaxx[i]-detMinx[i]+1)), numpy.int)
for y in range (detMiny[i], detMaxy[i], 1):
for x in range(detMinx[i], detMaxx[i], 1):
C[y-detMiny[i], x-detMinx[i]] = eIm.get(x,y)
# Find the boundaries of an eimage using the pixel count threshold
# as the discriminator. Break the eimage into anglar bins (say,
# 50,so the distant outliers are less likely to be included)and
# select the minimum value in each bin. The original purpose was
# to get data points for fitting ellipses to galactic disks.
n = 50
deltaAng = 2.*math.pi/float(n)
xBdry = []
yBdry = []
theta = []
radDist2 = []
xVal = []
yVal = []
angleDeg = []
for j in range(n):
radDist2.append([])
xVal.append([])
yVal.append([])
angleDeg.append([])
# This section is devoted to finding psi, the angle of
# the ellipse's rotation CCW with respect to the positive
# x-axis
countMin = 12
count = 0
for x in range(detMinx[i] + 1, detMaxx[i]-1, 1):
xp = float(x - detMinx[i])
for y in range(detMiny[i], detMaxy[i], 1):
yp = float(y - detMiny[i])
if C[yp, xp] < countMin:
if C[yp, xp-1] < countMin or C[yp, xp+1] < countMin:
y0 = float(y) - detys[i]
x0 = float(x) - detxs[i]
Angle = xyPosAngle(x0, y0)
m = int(Angle/deltaAng)
radDist2[m].append(x0**2 + y0**2)
xVal[m].append(xp)
yVal[m].append(yp)
angleDeg[m].append(Angle*180./math.pi)
for j in range(n):
if len(radDist2[j]) >= 1.:
t1 = numpy.argmin(radDist2[j])
xBdry.append(xVal[j][t1])
yBdry.append(yVal[j][t1])
theta.append(angleDeg[j][t1])
z, a, b, psiAve = fitellipse([xBdry, yBdry])
aFit.append(a)
bFit.append(b)
if a >= b and a != None and b !=None:
baRatioFit.append(b/a)
elif b > a and a != None and b !=None:
baRatioFit.append(a/b)
else:
baRatioFit.append(None)
if psiAve != None:
psiFit.append(float(psiAve)*180./math.pi)
else:
psiFit.append(None)
print 'psiFit: ', psiFit[i]
if a and b and psiAve and z != None:
xEllipse, yEllipse = ellipse(aFit[-1], bFit[-1], psiAve, detxs[i]-detMinx[i], detys[i]-detMiny[i])
daMax2 = a*a/float(nbins[i])
else:
print 'a, b, psiAve, or z = None for i = ', i, a, b, psiAve, z
psiImageXY.append(None)
psiImageRaDec.append(None)
print 'psiImageXY, psiImageRaDec: ', psiImageXY[i], psiImageRaDec[i]
continue
xMajor = aFit[-1]*math.cos(psiAve) + detxs[i]-detMinx[i]
yMajor = aFit[-1]*math.sin(psiAve) + detys[i]-detMiny[i]
print 'xMajor, yMajor = ', xMajor, yMajor
x0 = xMajor - detxs[i]
y0 = yMajor - detys[i]
psiImageXY.append(positionAngle(x0, y0))
ra3 = wcs.pixelToSky(xMajor, yMajor).getPosition()[0]
dec3 = wcs.pixelToSky(xMajor, yMajor).getPosition()[1]
print 'ra3, brightRAs[i], dec3, brightDecs[i] = ', ra3, brightRAs[i], brightDecs[i], dec3
xyMajor3 = wcs.skyToPixel(ra3, dec3)
xMajor3, yMajor3 = xyMajor3
print "xMajor3, yMajor3 = ", xMajor3, yMajor3
xyMajor2 = wcs.skyToPixel(raEdge[i], decEdge[i])
xMajor2, yMajor2 = xyMajor2
print 'brightRAs[i], brightDecs[i]:'
print brightRAs[i], brightDecs[i]
ra0 = ra3 - brightRAs[i]
dec0 = dec3 - brightDecs[i]
psiImageRaDec.append(positionAngle(ra0, dec0))
t0 = 0.
for m in range(nbins[i]):
t0 += daMax2
a2Bin[m] = t0
aBin[m] = math.sqrt(t0)
AveABin[0] = 10.**(math.log10(aBin[0])/2.)
for m in range(nbins[i]-1):
Ave = (math.log10(aBin[m+1]) + math.log10(aBin[m]))/2.
AveABin[m+1] = 10.**Ave
xbin = []
ybin = []
for x in range(detMinx[i], detMaxx[i]+1):
for y in range(detMiny[i], detMaxy[i]+1):
xprime = x - detxs[i]
yprime = y - detys[i]
aXY2 = (xprime*math.cos(psiAve) + yprime*math.sin(psiAve
))**2 + (xprime*math.sin(psiAve)
- yprime*math.cos(psiAve)/(b/a))**2
if aXY2 > a*a: continue
nval = min(int(aXY2/daMax2), nbins[i]-1)
tCts[nval] += eIm.get(x,y)
nPix[nval] += 1
if nval <= 4:
xbin.append(x - detMinx[i])
ybin.append(y - detMiny[i])
sumCts = 0
sumPix = 0
for m in range(nbins[i]):
sumCts += tCts[m]
sumPix += nPix[m]
#mew, the mean, is in counts/pixel
mew[m] = tCts[m]/nPix[m]
for m in range(nbins[i]):
# I(R) in units of counts per square arcsec:
if mew[m] == 0:
I_R[m] = numpy.nan
else:
I_R[m] = mew[m]/.04
rErr[m] = math.sqrt(tCts[m])/nPix[m]/.04
I_Reff = max(I_R)/math.e
for m in range(nbins[i]):
if I_R[m] < I_Reff:
R_eff = 10**(math.log10(AveABin[m]) - (math.log10(I_R[m]) - math.log10(I_Reff))/(math.log10(I_R[m]) - math.log10(I_R[m-1]))*(math.log10(AveABin[m]) - math.log10(AveABin[m-1])))
break
print 'xwidth, ywidth (in pixels) = ', abs(detMaxx[i] - detMinx[i]), abs(detMaxy[i] - detMiny[i])
print 'Total Counts = %i, Total Pixels = %i' % (sumCts, sumPix)
print 'log_Radius(") log_Intensity n = 1 and 4 n = 1 n = 4 Pixels Counts Mean Sigma'
#Prepare Sersic n=1 and n = 4 model profiles for comparison
In1 = numpy.zeros(nbins[i])
In4 = numpy.zeros(nbins[i])
InBoth = numpy.zeros(nbins[i])
for m in range(nbins[i]):
In1[m] = I_Reff*math.exp(-b1*((AveABin[m]/R_eff) - 1))
In4[m] = I_Reff*math.exp(-b4*(((AveABin[m]/R_eff)**0.25) - 1))
InBoth[m] = (diskFluxNorm[i]*In1[m] + bulgeFluxNorm[i]*In4[m])/(diskFluxNorm[i] + bulgeFluxNorm[i])
for m in range(nbins[i]):
# Convert pixels to arcsec (0.2 arcsec/pixel, roughly)
AveABin[m] = math.log10(AveABin[m]*.2)
if I_R[m] != None:
Err_Up[m] = math.log10(I_R[m] + rErr[m]) - math.log10(I_R[m])
if I_R[m] > rErr[m]:
Err_Dn[m] = math.log10(I_R[m]) - math.log10(I_R[m] - rErr[m])
else:
Err_Dn[m] = 5
I_R[m] = math.log10(I_R[m])
if In1[m] != 0.:
In1[m] = math.log10(In1[m])
else:
In1[m] = numpy.nan
if In4[m] != 0.:
In4[m] = math.log10(In4[m])
else:
In4[m] = numpy.nan
if InBoth[m] != 0.:
InBoth[m] = math.log10(InBoth[m])
else:
InBoth[m] = numpy.nan
if m > 8 and I_R[m] is 'nan' and I_R[m-1] is 'nan' and I_R[m-2] is 'nan' and I_R[m-3] is 'nan':
nbins[i] = nbins[:(nbins[i]-m+1)]
for m in range(nbins[i]):
print '%11.2f %11.2f %11.2f %11.2f %11.2f %11.2f %11.2f %11.2f %11.2f' % (AveABin[m], I_R[m], InBoth[m], In1[m], In4[m], nPix[m], tCts[m], mew[m], rErr[m])
fig = plt.figure()
fig.suptitle('Galaxy %s, (ra,dec)=(%5.2f, %5.2f), %d pixels \n%d counts; Gal_ID %s R_eff = %5.2f arcsecs, PA = %5.2f deg.\n%s' %(gal_code[option[i]], brightRAs[i], brightDecs[i], sumPix, sumCts, objId[i], R_eff*.2, pa_d[i], ePath), fontsize=9)
ax = fig.add_subplot(121)
im = plt.imshow(C, aspect ='equal', origin='lower', cmap = plt.cm.gray, interpolation = 'nearest')
cir = Circle((detxs[i]-detMinx[i],detys[i]-detMiny[i]), radius = .25, ec='r', fc = 'r')
cir2 = Circle((xMajor, yMajor), radius = .25, ec='g', fc = 'g')
print 'semi-major axis direction at (', xMajor, ', ', yMajor, ')'
ax.add_patch(cir)
ax.add_patch(cir2)
line5, = ax.plot(xBdry, yBdry, 'r.')
line6, = ax.plot(xEllipse, yEllipse, 'm.')
line7, = ax.plot(xbin, ybin, 'y.')
xcolname = 'log [Radius (arcsec)]'
ycolname = 'Intensity (Log_10[Counts/Area])'
ax2 = fig.add_subplot(122)
plt.xlabel(xcolname, fontsize=10)
plt.ylabel(ycolname, fontsize=10)
line1 = ax2.errorbar(AveABin, I_R, yerr=[Err_Dn, Err_Up], fmt = 'bo', ms = 2)
line2, = ax2.plot(AveABin, In1, 'm--')
line3, = ax2.plot(AveABin, In4, 'g-.')
line4, = ax2.plot(AveABin, InBoth, 'r-')
props = font_manager.FontProperties(size=12)
leg = ax2.legend([line1[0], line2, line3, line4], ['eImage', 'n=1', 'n=4', 'n=1+4'], loc='upper right', prop=props)
plt.text(0.1, 0.1, 'r = %5.2f\nb/a = %5.3f' % (rmags[i], baRatio[i]), transform = ax2.transAxes)
plt.savefig('%s/Sers70cM12%sh.png' % (gal_code[option[i]], objId[i]), format = 'png')
plotno += 1
plt.clf()
print 'Length of the following variables:'
print len(detxs), len(detys), len(xPixPos), len(yPixPos), len(psiImageXY), len(psiImageRaDec), len(psiCatXY), len(psiCatRaDec), len(psiFit), len(a_disk), len(b_disk), len(aFit), len(bFit)
print 'objId ra2-raEdge dec2-decEdge detxs detys xPixPos yPixPos a_disk b_disk a b b/a catalog b/a fit'
for i in range(len(detxs)):
if aFit[i] and bFit[i] and a_disk[i] and b_disk[i] and psiFit[i] != None:
print '%8i %7.2e %7.2e %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f' % (objId[i],
ra2[i]-raEdge[i], dec2[i]-decEdge[i], detxs[i],
detys[i], xPixPos[i], yPixPos[i], a_disk[i], b_disk[i], aFit[i], bFit[i],
b_disk[i]/a_disk[i], bFit[i]/aFit[i])
print 'objId pa_d psiCatRD psiImRD psiCatXY psiImXY psiFit b/a cat b/a fit'
for i in range(len(detxs)):
if aFit[i] and bFit[i] and a_disk[i] and b_disk[i] and psiFit[i] != None:
print '%8i %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f' % (objId[i], pa_d[i], psiCatRaDec[i], psiImageRaDec[i], psiCatXY[i], psiImageXY[i], psiFit[i], b_disk[i]/a_disk[i], bFit[i]/aFit[i])
return plotno
im = mi.getImage()
arr = im.getArray()
deadidx = numpy.where(arr == 0.)
hotidx = numpy.where(arr > 1.1)
arr[deadidx] = 2.
arr[hotidx] = 3.
im2 = ai.makeImageFromArray(arr)
thresh = afwDetection.Threshold(1.1)
fs = afwDetection.FootprintSet(im2, thresh)
x0 = []
y0 = []
width = []
height = []
for f in fs.getFootprints():
for bbox in afwDetection.footprintToBBoxList(f):
bbox = cameraGeom.rotateBBoxBy90(bbox, 3, im.getBBox().getDimensions())
x0.append(bbox.getMinX())
y0.append(bbox.getMinY())
width.append(bbox.getWidth())
height.append(bbox.getHeight())
head = pyfits.Header()
cmap = {'A': (0, 0), 'B': (0, 1)}
if ha is not None:
head.update(
'SERIAL',
int('%i%i%i%i%i%i' % (rx, ry, sx, sy, cmap[ha][0], cmap[ha][1])),
'Serial of the sensor')
head.update('NAME', 'R:%i,%i S:%i,%i,%c' % (rx, ry, sx, sy, ha),
'Name of sensor for this defect map')
if len(footprintsN) > 0:
raise RuntimeError, '*** Unexpected negative source.'
else: print ' No negative footprints found, as expected.'
regOut = open(outDir + 'pDet.reg', 'w')
print 'Making positive footprint detections.'
detSetP = afwDetection.makeFootprintSet(useEImForBG, afwDetection.createThreshold(5, "stdev"))
footprintsP = detSetP.getFootprints()
nf = len(footprintsP)
detxs = []; detys = []; nCts = []; estSizePix = []
n = 0; boxSize = 2; circleSize = 20
print 'Considering %i positive footprints.' % len(footprintsP)
fAllFPP = open(outDir + 'fAllFPP.reg', 'w')
for fp in footprintsP:
if n % 10000 == 0: print '%i of %i done.' % (n, nf)
bboxes = afwDetection.footprintToBBoxList(fp)
tCts = 0; ctsWtSumx = 0; ctsWtSumy = 0; nPix = 0
for bbox in bboxes:
x0, y0, x1, y1 = bbox.getX0(), bbox.getY0(), bbox.getX1(), bbox.getY1()
dx = x1 - x0; dy = y1 - y0
fAllFPP.write('box %5.3f %5.3f %5.3f %5.3f #color=yellow\n' % (
min([x0,x1])+0.5*dx, min([y0,y1])+0.5*dy, dx, dy))
for x in range(x0, x1 + 1):
for y in range(y0, y1 + 1):
t0 = eIm.get(x, y)
tCts += t0
ctsWtSumx += 0.5*(x0 + x1) * t0
ctsWtSumy += 0.5*(y0 + y1) * t0
nPix += 1
ctsWtSumx /= float(tCts); ctsWtSumy /= float(tCts)
#regOut.write('box %5.5f %5.5f %i %i 0 # color=darkgoldenrod2\n' % (ctsWtSumx, ctsWtSumy, boxSize, boxSize))
def makeBBList(mask, ccd):
# Create a bounding box corresponding to the useful part of the CCD (exclude overscan regions)
bb = afwGeom.Box2I(afwGeom.Point2I(32, 0), afwGeom.Point2I(2079, 4611))
# Read mask file provided by Elixir team
im = afwImage.ImageF('%s.fits['%mask + str(ccd+1) + ']', bbox=bb, origin=afwImage.ImageOrigin.PARENT)
# Pixel values in mask files are 1 for background and 0 for bad pixels - Need to inverse this
im *= -1.
im += 1.
im *= 10.
level = 2
s = afwDetect.FootprintSet(im, afwDetect.Threshold(level, polarity=True))
keys = ['x', 'y', 'w', 'h']
defect = {k: [] for k in keys}
defectE = {k: [] for k in keys}
for f in s.getFootprints():
fpl = afwDetect.footprintToBBoxList(f)
for i in fpl:
i.shift(afwGeom.Extent2I(-32, 0))
x0 = i.getBeginX()
y0 = i.getBeginY()
w0 = i.getWidth()
h0 = i.getHeight()
defect['x'].append(x0)
defect['y'].append(y0)
defect['w'].append(w0)
defect['h'].append(h0)
if (x0 % 2 == 0):
x1 = x0
if (w0 % 2 == 0):
w1 = w0
else:
w1 = w0 + 1
else:
x1 = max(x0 - 1, 0)
if (w0 % 2 == 0):
w1 = min(w0 + 2, 2048)
else:
w1 = min(w0 + 1, 2048)
if (y0 % 2 == 0):
y1 = y0
if (h0 % 2 == 0):
h1 = h0
else:
h1 = min(h0 + 1, 4612)
else:
y1 = max(y0 - 1, 0)
if (h0 % 2 == 0):
h1 = min(h0 + 2, 4612)
else:
h1 = min(h0 + 1, 4612)
defectE['x'].append(x1)
defectE['y'].append(y1)
defectE['w'].append(w1)
defectE['h'].append(h1)
return defect, defectE
detSetP = afwDetection.makeFootprintSet(
useEImForBG, afwDetection.createThreshold(5, "stdev"))
footprintsP = detSetP.getFootprints()
nf = len(footprintsP)
detxs = []
detys = []
nCts = []
estSizePix = []
n = 0
boxSize = 2
circleSize = 20
print 'Considering %i positive footprints.' % len(footprintsP)
fAllFPP = open(outDir + 'fAllFPP.reg', 'w')
for fp in footprintsP:
if n % 10000 == 0: print '%i of %i done.' % (n, nf)
bboxes = afwDetection.footprintToBBoxList(fp)
tCts = 0
ctsWtSumx = 0
ctsWtSumy = 0
nPix = 0
for bbox in bboxes:
x0, y0, x1, y1 = bbox.getX0(), bbox.getY0(), bbox.getX1(), bbox.getY1()
dx = x1 - x0
dy = y1 - y0
fAllFPP.write(
'box %5.3f %5.3f %5.3f %5.3f #color=yellow\n' %
(min([x0, x1]) + 0.5 * dx, min([y0, y1]) + 0.5 * dy, dx, dy))
for x in range(x0, x1 + 1):
for y in range(y0, y1 + 1):
t0 = eIm.get(x, y)
tCts += t0