def main():
get_photometry(sys.argv[1], sys.argv[2])
with open('NGC4621_i.cat', 'r') as catalog:
tmp = filter(lambda line: phot_utils.no_head(line), catalog)
tmp2 = map(lambda line: Sources.SCAMSource(line), tmp)
ra = map(lambda line: line.ra, tmp2)
dec = map(lambda line: line.dec, tmp2)
i_sources = Quadtree.ScamEquatorialQuadtree(min(ra), min(dec),
max(ra), max(dec))
with open('NGC4621_i.cat', 'r') as catalog:
tmp = filter(lambda line: phot_utils.no_head(line), catalog)
map(lambda line: i_sources.insert(Sources.SCAMSource(line)), tmp)
makeRegionFile.makeRegionFile('NGC4621_i.cat', 'NGC4621_i.reg', 10, 'blue')
with open('NGC4621_g.cat', 'r') as catalog:
tmp = filter(lambda line: phot_utils.no_head(line), catalog)
tmp2 = map(lambda line: Sources.SCAMSource(line), tmp)
ra = map(lambda line: line.ra, tmp2)
dec = map(lambda line: line.dec, tmp2)
g_sources = Quadtree.ScamEquatorialQuadtree(min(ra), min(dec),
max(ra), max(dec))
with open('NGC4621_g.cat', 'r') as catalog:
tmp = filter(lambda line: phot_utils.no_head(line), catalog)
map(lambda line: g_sources.insert(Sources.SCAMSource(line)), tmp)
makeRegionFile.makeRegionFile('NGC4621_g.cat', 'NGC4621_g.reg', 10, 'blue')
# Aaron gave me the coordinates
m59_ucd3_i = i_sources.match(190.54601, 11.64478)
m59_ucd3_g = g_sources.match(190.54601, 11.64478)
print '\n'
print "M58-UCD3's Location in catalog: ", m59_ucd3_i.name
print "I Mag and G Mag: ", m59_ucd3_i.mag_auto, m59_ucd3_g.mag_auto
print 'M59-UCD3 g-i: ', m59_ucd3_g.mag_auto - m59_ucd3_i.mag_auto
print 'M59-UCD3 FWHM: ', m59_ucd3_g.fwhm*0.2
print "Coordinates from i-band catalog - "
print phot_utils.convertRA(m59_ucd3_i.ra), phot_utils.convertDEC(m59_ucd3_i.dec)
print "Coordinates from g-band catalog - "
print phot_utils.convertRA(m59_ucd3_g.ra), phot_utils.convertDEC(m59_ucd3_g.dec)
print '\n'
print '\n'
m59cO_i = i_sources.match(190.48056, 11.66771)
m59cO_g = g_sources.match(190.48056, 11.66771)
print "M59cO's Location in catalog: ", m59cO_i.name
print "I Mag and G Mag: ", m59cO_i.mag_auto, m59cO_g.mag_auto
print 'M59cO g-i: ', m59cO_g.mag_auto - m59cO_i.mag_auto
print "Coordinates from i-band catalog - "
print phot_utils.convertRA(m59cO_i.ra), phot_utils.convertDEC(m59cO_i.dec)
print "Coordinates from g-band catalog - "
print phot_utils.convertRA(m59cO_g.ra), phot_utils.convertDEC(m59cO_g.dec)
print '\n'
def correct_mags(galaxy, catalog, band):
print "band: ", band
zp = calcZeropoint.calcZP(galaxy, catalog, band)
if verbose:
print "Zeropoint for " + band + "-band", zp
with open(catalog, 'r') as f:
tmp = filter(lambda line: phot_utils.no_head(line), f)
sources = map(lambda line: Sources.SCAMSource(line), tmp)
for source in sources:
source.mag_aper = round(source.mag_aper + zp, 3)
source.mag_auto = round(source.mag_auto + zp, 3)
source.mag_best = round(source.mag_best + zp, 3)
new_catalog = 'zpcorrected_' + catalog
with open(new_catalog, 'w') as output:
output.write(''.join(
map(
lambda source: '%5s' % source.name + '%15s' % source.flux_iso +
'%15s' % source.fluxerr_iso + '%15s' % source.flux_aper +
'%15s' % source.fluxerr_aper + '%15s' % source.ximg + '%15s' %
source.yimg + '%15s' % source.ra + '%15s' % source.dec + '%15s'
% source.mag_auto + '%15s' % source.mag_auto_err + '%15s' %
source.mag_best + '%15s' % source.mag_best_err + '%15s' %
source.mag_aper + '%15s' % source.mag_aper_err + '%15s' %
source.a_world + '%15s' % source.a_world_err + '%15s' % source.
b_world + '%15s' % source.b_world_err + '%15s' % source.
theta_err + '%15s' % source.theta + '%15s' % source.isoarea +
'%15s' % source.mu + '%15s' % source.flux_radius + '%15s' %
source.flags + '%15s' % source.fwhm + '%15s' % source.elogation
+ '%15s' % source.vignet + '\n', sources)))
return new_catalog
def calcZP(galaxy, scam, band):
"""
To calculate the zeropoint of the Subaru image match the Subaru catalog
and the table returned from Vizier.
"""
sdss = getSDSS(galaxy)
column = str(band + 'mag')
print "Column: ", column
# Get only the brightest sources of both SDSS and Subaru.
mag = map(lambda source: source[column], sdss)
max_mag = np.mean(mag) + 0.25*np.mean(np.std(mag))
sdss = filter(lambda s: phot_utils.mag_cut(s[column], 18, max_mag), sdss)
with open(scam, 'r') as f:
catalog = [S.SCAMSource(line) for line in f if phot_utils.no_head(line)]
mag = map(lambda s: s.mag_best, catalog)
max_mag = np.mean(mag) + 0.25*np.mean(np.std(mag))
sources = filter(lambda s: phot_utils.mag_cut(s.mag_best, 18, max_mag), catalog)
ra = [source.ra for source in catalog]
dec = [source.dec for source in catalog]
scam_sources = Q.ScamEquatorialQuadtree(min(ra), min(dec),
max(ra), max(dec))
map(lambda sources: scam_sources.insert(sources), sources)
matches = associate(sdss, scam_sources)
m_scam_sources = map(lambda source: source.mag_aper, matches)
m_sdss_sources = map(lambda source: source.match2[column], matches)
# Clip outliers of (m_sdss - m_scam)
difference = []
for m_sdss, m_scam in zip(m_sdss_sources, m_scam_sources):
difference.append(m_sdss - m_scam)
std = np.std(difference)
# Make a region file to check the matching
makeRegionFile.fromList(matches, band + "_scam_match_source.reg", 0.1, "red")
makeRegionFile.fromList(matches, band + "_sdss_match_source.reg", 0.1, "green")
clipped = []
for entry in matches:
if entry.match2[column] - entry.mag_aper < std*3:
clipped.append(entry)
difference = []
for entry in clipped:
difference.append(entry.match2[column] - entry.mag_aper)
m_scam = map(lambda source: source.mag_aper, clipped)
# Look at offsets
plt.plot(difference, m_scam, linestyle='none', marker='o')
plt.xlabel(r'$m_{SDSS}$ - $m_{SCAM}$', fontsize=20)
plt.ylabel(r'$m_{SCAM}$', fontsize=20, labelpad=30)
path = os.getcwd()
phot_utils.save(path, band + '_zp.png')
# Take median of offset
return np.median(difference)
def main():
equinox = 2000
passband = 'I'
sample = 1
s_flag = 1
pa = 119
catalog = open(sys.argv[1], 'r')
# Get rid of any header and real lines into source objects
tmp = filter(lambda line: pu.noHead(line), catalog)
src = map(lambda line: S.CFHTSource(line), tmp)
catalog.close()
# DSIM requires that RA and DEC be in sexagesimal
ra = map(lambda obj: pu.convertRA(obj.ra), src)
dec = map(lambda obj: pu.convertDEC(obj.dec), src)
# Determine priority for each source
mag_min = min(map(lambda s: s.mag, src))
priority = map(lambda s: detPriority(mag_min, s.mag1), src)
# Put it all together and write to ouput file
output = open(sys.argv[2], 'w')
for i in range(len(src)):
output.write('%10s' % src[i].name + '%15s' % ra[i] + '%15s' % dec[i] +
'%6.d' % equinox + '%10.2f' % src[i].mag1 + '%2s' % passband +
'%5.0d' % priority[i] + '%5.0d' % sample + '%5s' % s_flag +
'%10.d' % pa + '\n')
output.close()
def fromFile(filename, outname, pixsize, color):
with open(filename, "r") as catalog:
sources = [Sources.SCAMSource(line) for line in catalog if phot_utils.no_head(line)]
with open(outname, "w") as out:
for source in sources:
out.write("physical;circle(" + str(source.ximg) + "," +
str(source.yimg) + "," + str(pixsize) + ") #color=" + str(color) + "\n")
def keymatchChains(imagePath):
# KeyMatchFull, KeyMatchGPU
imageSource = Sources.ImageSource(imagePath, "pgm")
sift = FeatureExtraction.Sift(imageSource, False, "SiftHess")
keyMatch = FeatureMatch.KeyMatch(sift, True, "KeyMatchFull", forceRun=True)
print Chain.Render(keyMatch,"UnitTest-keymatchChains-KeyMatchFull-log.txt")
def non_flux_terms_dt_tilde_e(tilde_e, tilde_s, tilde_p, lapse, shift,
spatial_metric, inv_spatial_metric, source_n,
source_i, d_lapse, d_shift, d_spatial_metric,
extrinsic_curvature):
return Sources.source_tilde_e(tilde_e, tilde_s, tilde_p, source_n,
source_i, lapse, d_lapse, d_shift,
d_spatial_metric, inv_spatial_metric,
extrinsic_curvature)
def source_tilde_s(tilde_d, tilde_tau, tilde_s, lapse, shift,
sqrt_det_spatial_metric, pressure, spatial_velocity,
d_lapse, d_shift, d_spatial_metric, inv_spatial_metric,
extrinsic_curvature, spatial_metric):
return Sources.source_tilde_s(tilde_d, tilde_tau, tilde_s,
spatial_velocity, pressure, lapse, d_lapse,
d_shift, d_spatial_metric,
inv_spatial_metric, sqrt_det_spatial_metric,
extrinsic_curvature)
def makeRegionFile(filename, outname, pixsize, color):
catalog = open(filename, "r")
tmp = filter(lambda line: pu.no_head(line), catalog)
sources = map(lambda line: S.SCAMSource(line), tmp)
out = open(outname, "w")
for source in sources:
out.write("physical;circle(" + str(source.ximg) + "," +
str(source.yimg) + "," + str(pixsize) + ") #color=" +
str(color) + "\n")
def siftChains(imagePath):
#SiftWin32, SiftHess, SiftGPU, VLFeat
imageSource = Sources.ImageSource(imagePath, "pgm")
sift = FeatureExtraction.Sift(imageSource, False, "SiftWin32", forceRun=True)
# SiftWin32 only on windows
if (Common.Utility.OSName=="Windows"):
print Chain.Render(sift,"UnitTest-siftChains-SiftWin32-log.txt")
sift.SetProperty("Sift Method", "VLFeat")
print Chain.Render(sift,"UnitTest-siftChains-VLFeat-log.txt")
# daisy only on windows (note: this should not be the last test, as the descriptors are for ROIs)
if (Common.Utility.OSName=="Windows"):
imageSource = Sources.ImageSource(imagePath, "jpg")
daisy = FeatureExtraction.Daisy(imageSource, False, roi="0,0,50,50", forceRun=True)
print Chain.Render(daisy,"UnitTest-siftChains-daisy-log.txt")
sift.SetProperty("Sift Method", "SiftHess")
print Chain.Render(sift,"UnitTest-siftChains-SiftHess-log.txt")
def source_tilde_s(tilde_d, tilde_tau, tilde_s, tilde_b, tilde_phi, lapse,
shift, sqrt_det_spatial_metric, spatial_metric,
inv_spatial_metric, d_lapse, d_shift, d_spatial_metric,
pressure, spatial_velocity, lorentz_factor, magnetic_field,
rest_mass_density, specific_enthalpy, extrinsic_curvature,
constraint_damping_parameter):
return Sources.source_tilde_s(
tilde_d, tilde_tau, tilde_s, tilde_b, tilde_phi, spatial_velocity,
magnetic_field, rest_mass_density, specific_enthalpy, lorentz_factor,
pressure, lapse, d_lapse, d_shift, spatial_metric, d_spatial_metric,
inv_spatial_metric, sqrt_det_spatial_metric, extrinsic_curvature,
constraint_damping_parameter)
def sfmChainBuild(chainFilePath, imagePath):
# build chain
imageSource = Sources.ImageSource(imagePath, "jpg")
sift = FeatureExtraction.Sift(imageSource, False, "SiftHess")
keyMatch = FeatureMatch.KeyMatch(sift, False, "KeyMatchFull")
bundler = BundleAdjustment.Bundler([keyMatch, imageSource])
radialUndistort = Cluster.RadialUndistort([bundler, imageSource])
prepCmvsPmvs = Cluster.PrepCmvsPmvs(radialUndistort,
os.path.join(imagePath, "pmvs"))
cmvs = Cluster.CMVS(prepCmvsPmvs)
pmvs = Cluster.PMVS(cmvs)
# persist chain
Chain.StageRegistry.Save(chainFilePath)
def make_trees(catalog):
with open(catalog, 'r') as f:
tmp = filter(lambda line: phot_utils.no_head(line), f)
tmp2 = map(lambda line: Sources.SCAMSource(line), tmp)
ra = map(lambda line: line.ra, tmp2)
dec = map(lambda line: line.dec, tmp2)
sources = Quadtree.ScamEquatorialQuadtree(min(ra), min(dec), max(ra),
max(dec))
map(lambda line: sources.insert(line), tmp2)
#if verbose:
# makeRegionFile.makeRegionFile('NGC4621_i.cat', 'NGC4621_i.reg', 10, 'blue')
return sources
def resync():
if not c.UseRemoteServer or len(c.DataUrl) == 0:
raise Exception("Cannot resync when using local data.")
print("Syncing with server: {0}".format(c.DataUrl.split("://")[1].split("/")[0]))
sources = Sources.getRemoteSources(c.DataUrl)
active = { }
# Get current call list from server
ok, response = WebClient.openUrl(c.DataUrl, { "request": 2 })
if ok:
data = json.loads(response)
status = data["status"]
if status["success"]:
if isinstance(data["data"], dict):
# Format: data => source: { cid => [ category, location, meta ] }
for srcID, calls in data["data"].items():
isrc = int(srcID)
if not isrc in sources: continue
src = sources[isrc]
active[src.id] = [ ]
for cID, call in calls.items():
# Create a call object to represent this item
callObj = Calls.CallData(json.loads(call[2]))
callObj.category = call[0]
callObj.location = call[1]
callObj.key = cID
callObj.source = src
active[src.id].append(callObj)
print("\t{0}: {1}".format(src.tag, callObj.getShortDisplayString()))
else:
print("\t... No calls active.")
else:
print("\t...", status["message"])
else:
print("\t... failed: " + str(response))
return sources, active
def calc_seeing(catalog, **kwargs):
"""
Calculate the seeing of an image by taking a SE catalog
cutting out the extended and dim sources and averaging
the FWHM. Only for Subaru Suprime-Cam right now
"""
pixel_scale = 0.20
with open(catalog, 'r') as f:
tmp = filter(lambda line: no_head(line), f)
cat = map(lambda line: sources.SCAMSource(line), tmp)
shape = map(lambda s: s.a_world, cat)
peak = det_size_cut(shape, 1000)
ptsources = filter(lambda s: s.a_world <= peak, cat)
mag = map(lambda s: s.mag_best, ptsources)
max_mag = calc_average(mag) - 3.0 * calc_average(variance(mag))
ptsources = filter(lambda s: mag_cut(s.mag_best, 0, max_mag), ptsources)
#if kwargs['makereg']:
fwhm = map(lambda line: line.fwhm, ptsources)
return sum(fwhm) / len(fwhm) * pixel_scale
def main():
#get_photometry(sys.argv[1], sys.argv[2])
catalogs = (glob.glob('NGC4621*.cat'))
for catalog in catalogs:
if verbose:
print "Working on catalog: ", catalog
corrected_catalog = correct_mags(sys.argv[1], catalog, catalog[-5])
sys.exit()
with open('NGC4621_g.cat', 'r') as catalog:
tmp = filter(lambda line: phot_utils.no_head(line), catalog)
g_sources = map(lambda source: Sources.SCAMSource(source), tmp)
r_sources = make_trees('NGC4621_r.cat')
i_sources = make_trees('NGC4621_i.cat')
matches = associate(g_sources, r_sources, i_sources)
with open('matched_gri.cat', 'w') as out:
out.write()
def bundlerChain(imagePath):
# PMVS path
pmvsPath = os.path.join(imagePath,"pmvs")
# build chain
imageSource = Sources.ImageSource(imagePath, "jpg")
sift = FeatureExtraction.Sift(imageSource, False, "SiftHess")
keyMatch = FeatureMatch.KeyMatch(sift, False, "KeyMatchFull")
bundler = BundleAdjustment.Bundler([keyMatch, imageSource], forceRun=True)
radialUndistort = Cluster.RadialUndistort([bundler, imageSource], forceRun=True)
prepCmvsPmvs = Cluster.PrepCmvsPmvs(radialUndistort, pmvsPath, forceRun=True)
# cmvs not build on 32bit Linux yet
if (Common.Utility.PlatformName != "Linux32bit"):
cmvs = Cluster.CMVS(prepCmvsPmvs, forceRun=True)
pmvs = Cluster.PMVS(cmvs, forceRun=True)
else:
pmvs = Cluster.PMVS(prepCmvsPmvs, forceRun=True)
# render chain
print Chain.Render(pmvs,"UnitTest-bundlerChain-log.txt")
# For color selection
# Have the slope, y-intercept, and endpoints from M87 data
# This is for <u-z> vs <g-z> space.
b = -0.086
m = 0.50
x0 = 1.5
x1 = 3.0
var = 0.3 # This controls how strict the color cut is
catalog = open("n4459_cfht_ugiz_auto.cat", "r")
catalog.next() # This is to skip the header
# This reads in the catalog and initalizes each line as a
# CFHT source
sources = map(lambda line: S.CFHTSource(line), catalog)
## Make the color cut
candidates = filter(
lambda s: pu.makeColorCut(s.mag1, s.mag4, s.mag2, s.mag4, x0, x1, m, b, var
), sources)
# Finds the value of a_world that seems to "contain" the point-like sources
shape = map(lambda s: s.a_world, candidates)
'''
Zach and I use the x-value that seems to contain the gaussian
distribution as the cut off. Not sure how well detSizeCut is
going to work for different data sets so at the moment it's good to
take a look for youself.
'''
pu.LookAtShapes(shape, 1000)
self._properties["Prefix Name"] = prefixName
def GetOutputImagePath(self, inputImagePath):
# construct the output image path, including the prefix name
return os.path.join(self._properties["Output Image Path"],
self._properties["Prefix Name"] +
os.path.splitext(os.path.basename(inputImagePath))[0] +
"."+self._properties["Image Extension"])
def ProcessImage(self, inputImagePath, outputImagePath):
# copy the input to output
shutil.copy(inputImagePath, outputImagePath)
#################################################################################
# input/output image path
imagePath = os.path.abspath("../Datasets/ET")
imagePathOut = os.path.join(imagePath, "test")
Common.Utility.MakeDir(imagePathOut)
imageSource = Sources.ImageSource(imagePath, "jpg")
imageCopy = CopyImages(imageSource, "test-", imagePathOut, "jpg")
print Chain.Render(imageCopy)
mass = parsed_args.mass
channel = parsed_args.channel
DM_model = parsed_args.model
add_point_source = parsed_args.add
experiment = parsed_args.exp
verbose = parsed_args.verbose
ebl_model = parsed_args.ebl
ra_shift = parsed_args.shiftra
dec_shift = parsed_args.shiftdec
maptree = parsed_args.maptree
print("running for mass {} GeV".format(mass))
print(" channel {}".format(channel))
print(" {} EBL Model".format(ebl_model))
sources = Sources(DM_model)
sources.set_mass(float(mass))
sources.set_channel(int(float(channel)))
sources.set_EBL_model(ebl_model_name=ebl_model)
sources.shift_templates(ra_shift, dec_shift)
sources.setup(data=experiment)
if add_point_source == 0:
model = Model(sources.source_M87, sources.source_M49)
else:
model = Model(sources.source_M87, sources.source_M49,
sources.point_M87)
model.link(model.M87.spectrum.main.DMAnnihilationFlux.sigmav,
model.M49.spectrum.main.DMAnnihilationFlux.sigmav,
Identity())
import random as r
import Quadtree
import Sources as S
import phot_utils
sources = Quadtree.ScamPixelQuadtree(0, 0, 15000, 15000)
with open(
"/Users/alexawork/Documents/GlobularClusters/Photometry/NGC4649/NGC4649_g.cat"
) as f:
tmp = filter(lambda line: phot_utils.no_head(line), f)
map(lambda line: sources.insert(S.SCAMSource(line)), tmp)
sources.match(10, 15)
sources.debug()
def imageConvertChain(imagePath):
imageSource = Sources.ImageSource(imagePath, "jpg")
imageConvert = Sources.ImageConvert(imageSource, imagePath, "pgm")
print Chain.Render(imageConvert,"UnitTest-imageConvertChain-log.txt")
else:
print("\t... failed: " + str(response))
return sources, active
# Startup
print("Loading config...")
c = ClientConfig.load()
ClientConfig.save(c) # This writes default values of new settings
# Get initial data
if c.UseRemoteServer:
sources, active_calls = resync()
last_sync = datetime.now()
else:
sources = Sources.getLocalSources(c.SourceLocation)
active_calls = { }
# Can't do anything without sources
if len(sources) == 0:
print("No sources found.")
sys.exit()
# List source info and initialize call lists
for src in sources.values():
print("Source #{0}: {1} => {2} [Can check?: {3}]".format(src.id, src.tag, src.parser, Sources.canCheck(src)))
if not src.id in active_calls:
active_calls[src.id] = [ ]
# Run
while True:
parser.add_argument("--maptree", dest="maptree", default="../../data/maptree.root")
parser.add_argument("--response", dest="response", default="../../data/response.root")
parsed_args = parser.parse_args()
experiment = parsed_args.exp
verbose = parsed_args.verbose
maptree = parsed_args.maptree
ebin = parsed_args.ebin
index = parsed_args.index
lo_range = [0.562, 1.778, 5.623, 17.783, 56.234]
hi_range = [1.778, 5.623, 17.783, 56.234, 177.828]
#lo_range = [1.]
#hi_range = [20.]
sources = Sources()
sources.setup(data=experiment, isQuasiDiff=True, index=index, enLo=lo_range[ebin], enHi=hi_range[ebin])
model_M87 = Model(sources.source_M87)
model_M49 = Model(sources.source_M49)
model_linked = Model(sources.source_M87, sources.source_M49)
model_notlinked = Model(sources.source_M87, sources.source_M49)
model_linked.link(model_linked.M49.spectrum.main.RangedPowerlaw.K,
model_linked.M87.spectrum.main.RangedPowerlaw.K,
Identity())
models = [model_M87, model_M49, model_linked, model_notlinked]
if verbose:
model_linked.display()
from utils import ImageCapturer
cap = ImageCapturer.ImageCapturer()
if not cap:
print "Error opening capture device"
else:
print "successfully imported video capture"
while True:
rval, frame = cap.get_image()
fd.processImage(frame)
if (True):
img_path = os.path.abspath(
'/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014'
)
[y, block, names, filenames] = Sources.read_images_2(img_path,
useBatch=2,
maxNum=1500)
w = None
#import csv
#w = csv.writer(open("../../data/" + 'batch2_46_gamma_dog.csv', 'w'))
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Oliver_2/Oliver-2-41.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Dejan_1/Dejan-1-1.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Rebekka_2/Rebekka-2-3.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Rebekka_2/Rebekka-2-31.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Rebekka_2/Rebekka-2-5.png"
fd.processImage(cv2.imread(d), 0, w)
# cv2.imshow("Gallo ", img);
# import matplotlib.pyplot as plt
# plt.ion()
import glob
import math
import matplotlib.pyplot as plt
import numpy as np
import Sources as S
import phot_utils as pu
noisef = (glob.glob('/Users/alexawork/Documents/GlobularClusters/Photometry/NGC4649/BestApertureFiles/g_ap_*noise*txt'))
signlf = (glob.glob('/Users/alexawork/Documents/GlobularClusters/Photometry/NGC4649/BestApertureFiles/g_ap_*signal*txt'))
noise = []
for thing in noisef:
f = open(thing)
ntmp = map(lambda line: S.SCAMSource(line), f)
f.close()
nflux = map(lambda f: math.fabs(f.mag_best), ntmp)
nflux = filter(lambda value: value != 99.0, nflux)
noise.append(pu.calc_MAD(nflux))
signal = []
for thing in signlf:
f = open(thing)
stmp = map(lambda line: S.SCAMSource(line), f)
f.close()
sflux = map(lambda f: math.fabs(f.mag_best), stmp)
sflux = filter(lambda value: value != 99.0, sflux)
signal.append(pu.calc_MAD(sflux))
def findBestAperture(path, image, satur, seeing):
if os.path.isdir('BestApertureFiles') == False:
os.mkdir('BestApertureFiles')
sname = "sign"
nname = "noise"
filter_file = "default.conv"
assoc_file = "measurefluxat.txt"
output = open(assoc_file, "w")
for i in xrange(0, 100000):
output.write('%.3f' % r.uniform(1, 11000) +
'%10.3f' % r.uniform(1, 9000) + '\n')
sp.createSexParam(sname, False)
sp.createSexParam(nname, True)
sparam_file = sname + ".param"
nparam_file = nname + ".param"
signal = []
noise = []
aperture = np.linspace(0.5, 12, num=10)
for ap in aperture:
sc.createSexConfig(sname, filter_file, sparam_file, satur, seeing,
"nill", ap, False)
call(['sex', '-c', sname + '.config', image])
sc.createSexConfig(nname, filter_file, nparam_file, satur, seeing,
assoc_file, ap, True)
call(['sex', '-c', nname + '.config', image])
scat = open(sname + ".cat")
stmp = filter(lambda line: pu.no_head(line), scat)
ncat = open(nname + ".cat")
ntmp = filter(lambda line: pu.no_head(line), ncat)
# Background measuresments can't overlap with source detections
ssources = q.ScamPixelQuadtree(0, 0, 12000, 10000)
map(lambda line: ssources.insert(S.SCAMSource(line)), stmp)
nsources = map(lambda line: S.SCAMSource(line), ntmp)
start = time.time()
bkgddetections = disassociate(nsources, ssources, ap)
end = time.time()
print("ELAPSED TIME: " + str(end - start))
srcdetections = map(lambda line: S.SCAMSource(line), stmp)
flux = map(lambda f: f.flux_aper, bkgddetections)
noise.append(pu.calc_MAD(flux))
flux = map(lambda f: f.flux_aper, srcdetections)
signal.append(pu.calc_MAD(flux))
with open(image[-6] + "_ap_" + str(round(ap, 2)) + "noise.txt",
"w") as output:
for source in bkgddetections:
output.write(source.line)
call([
'mv', image[-6] + "_ap_" + str(round(ap, 2)) + "noise.txt",
'BestApertureFiles'
])
with open(image[-6] + "_ap_" + str(round(ap, 2)) + "signal.txt",
"w") as output:
for source in srcdetections:
output.write(source.line)
call([
'mv', image[-6] + "_ap_" + str(round(ap, 2)) + "signal.txt",
'BestApertureFiles'
])
'''
The files generated here aren't important and need to be
removed for the next steps to work properly.
'''
try:
os.remove('measurefluxat.txt')
except OSError:
pass
noise_files = (glob.glob('noise*'))
try:
for f in noise_files:
os.remove(f)
except OSError:
pass
sign_files = (glob.glob('sign*'))
try:
for f in sign_files:
os.remove(f)
except OSError:
pass
snr = []
for i in range(len(noise)):
snr.append(signal[i] / noise[i])
plt.plot(aperture, snr, linestyle='none', marker='o')
plt.xlabel('Aperture (pix)')
plt.ylabel('SNR')
pu.save(path, image[-6] + '_snr')
maxsnr = snr.index(max(snr))
return aperture[maxsnr]
def calcZP(galaxy, scam, band):
"""
To calculate the zeropoint of the Subaru image match the Subaru catalog
and the table returned from Vizier.
"""
sdss = getSDSS(galaxy)
column = str(band + 'mag')
with open(scam, 'r') as catalog:
tmp = filter(lambda line: phot_utils.no_head(line), catalog)
# Do magnitude cute on data here
tmp2 = map(lambda line: S.SCAMSource(line), tmp)
mag = map(lambda s: s.mag_best, tmp2)
max_mag = phot_utils.calc_average(mag) + 0.25 * phot_utils.calc_average(
phot_utils.variance(mag))
sources = filter(lambda s: phot_utils.mag_cut(s.mag_best, 0, max_mag),
tmp2)
ra = map(lambda line: line.ra, tmp2)
dec = map(lambda line: line.dec, tmp2)
scam_sources = Q.ScamEquatorialQuadtree(min(ra), min(dec), max(ra),
max(dec))
map(lambda sources: scam_sources.insert(sources), sources)
matches = associate(sdss, scam_sources)
m_scam = map(lambda source: source.mag_aper, matches)
m_sdss = map(lambda source: source.match2[column], matches)
# Clip outliers of (m_sdss - m_scam)
difference = []
for i, entry in enumerate(m_scam):
difference.append(m_sdss[i] - m_scam[i])
std = np.std(difference)
# Make a region file to check the matching
with open("scam_match_source.reg", "w") as out:
for source in matches:
out.write("j2000; circle " + str(phot_utils.convertRA(source.ra)) +
"," + str(phot_utils.convertDEC(source.dec)) +
" .1' #color=red \n")
with open("sdss_match_source.reg", "w") as out:
for source in matches:
out.write("j2000; circle " +
str(phot_utils.convertRA(source.match2['RAJ2000'])) +
"," +
str(phot_utils.convertDEC(source.match2['DEJ2000'])) +
" .15' #color=green \n")
clipped = []
for entry in matches:
if entry.match2[column] - entry.mag_aper < std * 3:
clipped.append(entry)
difference = []
for entry in clipped:
difference.append(entry.match2[column] - entry.mag_aper)
m_scam = map(lambda source: source.mag_aper, clipped)
# Look at offsets
plt.plot(difference, m_scam, linestyle='none', marker='o')
plt.xlabel(r'$m_{SDSS}$ - $m_{SCAM}$', fontsize=20)
plt.ylabel(r'$m_{SCAM}$', fontsize=20, labelpad=30)
plt.show()
# Take median of offset
return phot_utils.calc_median(difference)
def associate(list1, tree2):
dist = 5
with open("test.reg", "w") as out:
for entry in list1:
match2 = tree2.match(entry.ximg, entry.yimg)
if match2 != None and _norm.norm(entry.ximg, entry.yimg,
match2.ximg, match2.yimg) <= dist:
out.write("physical;circle(" + str(entry.ximg) + "," +
str(entry.yimg) + " 10) #color=red \n")
with open('NGC4621_i.cat', 'r') as f:
i_catalog = [
Sources.SCAMSource(line) for line in f if phot_utils.no_head(line)
]
with open('NGC4621_g.cat', 'r') as f:
g_catalog = [
Sources.SCAMSource(line) for line in f if phot_utils.no_head(line)
]
ximg = [source.ximg for source in i_catalog]
yimg = [source.yimg for source in i_catalog]
sources = Quadtree.ScamPixelQuadtree(min(ximg), min(yimg), max(ximg),
max(yimg))
#ra = [source.ra for source in i_catalog]
#dec = [source.dec for source in i_catalog]
#sources = Quadtree.ScamEquatorialQuadtree(min(ra), min(dec), max(ra), max(dec))
# Copyright (c) 2012, Adam J. Rossi. All rights reserved. See README for licensing details.
import sys, os
sys.path.append(os.path.abspath("."))
import Chain # Chain must be imported first, requirement of registry
import Sources, FeatureExtraction, FeatureMatch, BundleAdjustment, Cluster, Common
# path to images / PMVS
imagePath = os.path.abspath("../Datasets/ET")
pmvsPath = os.path.join(imagePath, "pmvs")
# build chain
imageSourceJpg = Sources.ImageSource(imagePath, "jpg")
imageSource = Sources.ImageConvert(imageSourceJpg, imagePath, "pgm")
asift = FeatureExtraction.ASIFT(imageSource)
keyMatch = FeatureMatch.ASIFTMatch(asift)
bundler = BundleAdjustment.Bundler([keyMatch, imageSource])
radialUndistort = Cluster.RadialUndistort([bundler, imageSourceJpg])
prepCmvsPmvs = Cluster.PrepCmvsPmvs(radialUndistort, pmvsPath)
cmvs = Cluster.CMVS(prepCmvsPmvs)
pmvs = Cluster.PMVS(cmvs)
# render chain
print Chain.Render(pmvs, "asift.txt")
fd = FaceDetectorAll(show = show)
if (webcam): #Using the webcam
from utils import ImageCapturer
cap = ImageCapturer.ImageCapturer()
if not cap:
print "Error opening capture device"
else:
print "successfully imported video capture"
while True:
rval, frame = cap.get_image()
fd.processImage(frame)
if (True):
img_path = os.path.abspath('/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014')
[y, block, names, filenames] = Sources.read_images_2(img_path, useBatch=2, maxNum=1500)
w = None
#import csv
#w = csv.writer(open("../../data/" + 'batch2_46_gamma_dog.csv', 'w'))
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Oliver_2/Oliver-2-41.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Dejan_1/Dejan-1-1.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Rebekka_2/Rebekka-2-3.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Rebekka_2/Rebekka-2-31.png"
d = "/Users/oli/Proj_Large_Data/PiVision/pivision/images/session_30_july_2014/Rebekka_2/Rebekka-2-5.png"
fd.processImage(cv2.imread(d), 0, w)
# cv2.imshow("Gallo ", img);
# import matplotlib.pyplot as plt
# plt.ion()
# fig = plt.figure("Hello Convolutional World", figsize=(18, 12))