def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, max_x = lib_background.compute_background(pixels)
clustering = lib_cluster.Clustering()
clusters = clustering(pixels, background, dispersion)
# console output
if not interactive:
print('{} clusters'.format(len(clusters)))
else:
# graphic output
fig, axis = plt.subplots()
imgplot = axis.imshow(pixels)
axcolor = 'lightgoldenrodyellow'
ax_thresh = plt.axes([0.25, 0.92, 0.65, 0.03], axisbg=axcolor)
threshold = 6.0
slider = widgets.Slider(ax_thresh, 'Threshold', 0.0, 5*threshold, valinit=threshold)
update_slider = UpdateSlider(pixels, background, dispersion, imgplot, fig)
slider.on_changed(update_slider)
update_slider(threshold)
plt.show()
return 0
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, _ = lib_background.compute_background(pixels)
# search for clusters
clustering = RecursiveClustering()
clusters = clustering(pixels, background, dispersion)
max_cluster = clusters[0]
wcs = lib_wcs.get_wcs(header)
pxy = lib_wcs.PixelXY(max_cluster.column, max_cluster.row)
radec = lib_wcs.xy_to_radec(wcs, pxy)
cobjects, _, _ = lib_stars.get_celestial_objects(radec)
# console output
print(
'number of clusters: {:2d}, greatest integral: {:7d}, x: {:4.1f}, y: {:4.1f}'
.format(len(clusters), max_cluster.integral, max_cluster.column,
max_cluster.row))
for cobj in cobjects.keys():
print('celestial object: {}'.format(cobj))
# graphic output
if interactive:
_, axis = plt.subplots()
axis.imshow(lib_cluster.add_crosses(pixels, clusters))
plt.show()
return 0
def main():
# analyse command line arguments
file_name, interactive = lib_args.get_args()
pixels = None
pixels, header = lib_fits.read_first_image(file_name)
signature_fmt_1 = 'RESULT: cd1_1 = {:.10f}'.format(header["CD1_1"])
signature_fmt_2 = 'RESULT: cd1_2 = {:.10f}'.format(header["CD1_2"])
signature_fmt_3 = 'RESULT: cd2_1 = {:.10f}'.format(header["CD2_1"])
signature_fmt_4 = 'RESULT: cd2_2 = {:.10f}'.format(header["CD2_2"])
print(signature_fmt_1)
print(signature_fmt_2)
print(signature_fmt_3)
print(signature_fmt_4)
if interactive:
fig, main_axes = plt.subplots()
main_axes.imshow(pixels)
plt.show()
return 0
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, _ = lib_background.compute_background(pixels)
# search for clusters
time0 = time.time()
clustering = ParallelClustering()
clusters = clustering(pixels, background, dispersion)
time1 = time.time()
max_cluster = clusters[0]
# console output
print(
'number of clusters: {:2d}, greatest integral: {:7d}, x: {:4.1f}, y: {:4.1f}'
.format(len(clusters), max_cluster.integral, max_cluster.column,
max_cluster.row))
print('clustering execution time: {:.3f} seconds'.format(time1 - time0))
# graphic output
if interactive:
_, axis = plt.subplots()
axis.imshow(lib_cluster.add_crosses(pixels, clusters))
plt.show()
return 0
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, max_x = lib_background.compute_background(pixels)
# console output
print('background: {:d}, dispersion: {:d}'.format(int(background),int(dispersion)))
# graphic output
if interactive:
fig, axis = plt.subplots()
imgplot = axis.imshow(pixels)
ax_thresh = plt.axes([0.25, 0.92, 0.65, 0.03])
s_thresh = widgets.Slider(ax_thresh, 'Threshold', 0.0, max_x, valinit=background)
update_slider = UpdateSlider(pixels,imgplot,fig)
s_thresh.on_changed(update_slider)
update_slider(background)
plt.show()
return 0
def main():
# analyse command line arguments
file_name, interactive = lib_args.get_args()
pixels = None
pixels, header = lib_fits.read_first_image(file_name)
background, dispersion, mx, hist_sum = lib_background.compute_background(
pixels, interactive)
test_gaussian = lib_background.modelling_function(
np.arange(-10.0, 10.0, 1.0), 1.0, 1.0, 1.0).sum()
print('RESULT: test_gaussian = {:3f}'.format(test_gaussian))
signature_hist = 'RESULT: histogram = {:5d}'.format(hist_sum)
print(signature_hist)
print('RESULT: background = {:d}'.format(int(background)))
print('RESULT: dispersion = {:d}'.format(int(dispersion)))
# graphic output
if interactive:
# ...
pass
# end
return 0
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, _ = lib_background.compute_background(pixels)
clustering = lib_cluster.Clustering()
clusters = clustering(pixels, background, dispersion)
max_cluster = clusters[0]
# coordinates ra dec
wcs = lib_wcs.get_wcs(header)
for i, c in enumerate(clusters):
show_cluster(wcs, i, c)
# graphic output
if interactive:
import matplotlib.pyplot as plt
import lib_graphics
fig, axis = plt.subplots()
axis.imshow(pixels, interpolation='none')
fig.canvas.mpl_connect('motion_notify_event',
lib_graphics.ShowClusterProperties(fig,clusters,ShowCelestialObjects(wcs)))
plt.show()
return 0
def main():
""" Exercise 4: Clusters """
lib_fits.init()
print(lib_fits.file_name)
header, pixels = lib_fits.read_first_image(lib_fits.file_name)
thres = lib_background.threshold(pixels)
peaks = lib_conv.complete_peaks_search(pixels)
lums = lib_cluster.peak_lum(pixels, peaks)
clusters = []
for i in range(len(peaks)):
clust = lib_cluster.build_cluster(pixels, peaks[i], thres)
if clust == None:
continue
else:
clusters.append(clust)
signature_fmt_1 = 'RESULT: clusters_number={:d}'.format(len(clusters))
signature_fmt_2 = 'RESULT: cluster_max_top={:d}'.format(max(lums))
print(signature_fmt_1)
print(signature_fmt_2)
sort_clus = lib_cluster.sort_clusters(clusters)
bcfe = sort_clus[0]
fig, main_axes = plt.subplots()
main_axes.imshow(pixels)
# Draws clusters arround peaks.
for i in range(len(clusters)):
xleft = clusters[i].coord[0] - clusters[i].ext
xright = clusters[i].coord[0] + clusters[i].ext
ybottom = clusters[i].coord[1] - clusters[i].ext
ytop = clusters[i].coord[1] + clusters[i].ext
squarex = [xleft, xright, xright, xleft, xleft]
squarey = [ybottom, ybottom, ytop, ytop, ybottom]
plt.plot(squarey, squarex, 'r--')
plt.show()
signature_fmt_3 = 'RESULT: cluster_max_integral={:d}'.format(bcfe.lum)
signature_fmt_4 = 'RESULT: cluster_max_column={:d}'.format(bcfe.coord[1])
signature_fmt_5 = 'RESULT: cluster_max_row={:d}'.format(bcfe.coord[0])
signature_fmt_6 = 'RESULT: cluster_max_extension={:d}'.format(bcfe.ext)
print(signature_fmt_3)
print(signature_fmt_4)
print(signature_fmt_5)
print(signature_fmt_6)
return 0
def main():
# analyse command line arguments
file_name, interactive = lib_args.get_args()
data = None
data, header = lib_fits.read_first_image(file_name)
data = data[400:600, 300:500]
done = np.zeros(data.shape)
background, dispersion, mx, hist_sum = lib_background.compute_background(
data, False)
threshold = 2 * background + 6. * dispersion
#threshold=11000
cluster_pix_list = []
for i in range(data.shape[0]):
for j in range(data.shape[1]):
if not done[i][j]:
done[i][j] = 1
if data[i][j] > threshold:
cluster_pixels = lib_pixels_set.PixelsSet()
cluster_pixels.add(i, j, data[i][j])
recursive_search(i, j, data, done, cluster_pixels,
threshold)
if cluster_pixels.get_len() > 1:
cluster_pix_list.append(cluster_pixels)
print([str(cluster) for cluster in cluster_pix_list])
if interactive:
fig, main_axes = plt.subplots()
main_axes.imshow(data)
for cluster in cluster_pix_list:
peak = cluster.get_peak()
plt.scatter([peak[1]], [peak[0]])
fig, main_axes = plt.subplots()
main_axes.imshow(data)
for cluster in cluster_pix_list:
for pixel in cluster.pixels:
plt.plot(pixel[1], pixel[0], 'rs', alpha=0.05)
fig, main_axes = plt.subplots()
main_axes.imshow(data)
matrix = np.zeros(data.shape)
for cluster in cluster_pix_list:
for pixel in cluster.pixels:
matrix[pixel[0], pixel[1]] = 1
plt.contour(matrix)
plt.show()
return 0
def main():
# analyse command line arguments
file_name, interactive = lib_args.get_args()
logging.info('----------------')
logging.info('name of file: {}'.format(file_name))
# read fits file
header, pixels = lib_fits.read_first_image(file_name)
logging.info('cd1_1: {CD1_1:.10f}'.format(**header))
logging.info('cd1_2: {CD1_2:.10f}'.format(**header))
logging.info('cd2_1: {CD2_1:.10f}'.format(**header))
logging.info('cd2_2: {CD2_2:.10f}'.format(**header))
# compute background
background, dispersion, _ = lib_background.compute_background(pixels)
logging.info('background: {:d}'.format(int(background)))
logging.info('dispersion: {:d}'.format(int(dispersion)))
# clustering
clustering = lib_cluster.Clustering()
clusters = clustering(pixels, background, dispersion)
for icl, cl in enumerate(clusters):
logging.info('----------------')
logging.info('cluster {:d}: {}'.format(icl, cl))
# radec coordinates of the greatest cluster
wcs = lib_wcs.get_wcs(header)
pxy = lib_wcs.PixelXY(cl.column, cl.row)
radec = lib_wcs.xy_to_radec(wcs, pxy)
logging.info('right ascension: {:.3f}'.format(radec.ra))
logging.info('declination: {:.3f}'.format(radec.dec))
# celestial objects for the biggest cluster
cobjects, _, _ = get_celestial_objects(wcs, cl)
for icobj, cobj in enumerate(cobjects.keys()):
logging.info('celestial object {}: {}'.format(icobj, cobj))
# graphic output
if interactive:
fig, axis = plt.subplots()
axis.imshow(pixels, interpolation='none')
fig.canvas.mpl_connect(
'motion_notify_event',
lib_graphics.ShowClusterProperties(fig, clusters,
ShowCelestialObjects(wcs)))
plt.show()
logging.info('----------------')
return 0
def main():
""" Exercise 6: Display stars """
lib_fits.init()
print(lib_fits.file_name)
global pixels
global header
header, pixels = lib_fits.read_first_image(lib_fits.file_name)
clusters = lib_cluster.find_clusters(pixels)
for i in range(6):
rad = lib_stars.cluster_radec(clusters, i, header, pixels)
lib_stars.celestial_objects(rad, i)
return 0
def __init__(self):
self.image_file_name = get_fits_file(1)
self.header_image, self.pixels_image = lib_fits.read_first_image(
self.image_file_name)
self.fig, self.main_ax = plt.subplots()
self.y1_max, self.x1_max = self.pixels_image.shape
self.border = 5
self.font_size = 14
self.pixels_image = np.zeros_like(self.pixels_image)
self.imgplot = self.main_ax.imshow(self.pixels_image)
self.update = None
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, _ = lib_background.compute_background(pixels)
clustering = lib_cluster.Clustering()
clusters = clustering(pixels, background, dispersion)
max_cluster = clusters[0]
# coordinates ra dec
wcs = lib_wcs.get_wcs(header)
for i, c in enumerate(clusters):
show_cluster(wcs, i, c)
break
return 0
def main():
fig, ax = plt.subplots()
plt.subplots_adjust(left=0.4)
pixels, header = lib_fits.read_first_image("../data/common.fits")
ax.imshow(pixels)
my_widget_area = plt.axes([0.05, 0.4, 0.25, 0.3],
facecolor='lightgoldenrodyellow')
folder = list(os.walk("../data"))[0]
dirpath, dirnames, filenames = folder
radio = RadioButtons(my_widget_area, tuple(filenames))
def my_action(label):
pixels, header = lib_fits.read_first_image("../data/" + label)
ax.imshow(pixels)
radio.on_clicked(my_action)
plt.show()
def main():
'''
Main function of the program
'''
global reg
# process command-line options
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
logging.debug('cd1_1: %s, cd1_2: %s, cd2_1: %s, cd2_2: %s',
header['CD1_1'], header['CD1_2'], header['CD2_1'],
header['CD2_2'])
logging.debug('height: %s, width: %s', pixels.shape[0], pixels.shape[1])
# compute background
background, dispersion, _ = lib_background.compute_background(pixels)
logging.debug('background: %s, dispersion: %s', int(background),
int(dispersion))
print('---------------------')
# search for clusters in a sub-region of the image
threshold = 6.0
# graphic output
if interactive:
image = pixels
reg = lib_cluster_thr.RegionThr(image,
background + threshold * dispersion)
reg.run_threaded()
max_integral = reg.clusters[0].integral
logging.info(
'number of clusters: %2d, greatest integral: %7d, centroid x: %4.1f, centroid y: %4.1f',
len(reg.clusters), max_integral, reg.clusters[0].centroid[1],
reg.clusters[0].centroid[0])
plt.show()
return 0
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
# console output
print('RESULT: cd1_1 = {CD1_1:.10f}'.format(**header))
print('RESULT: cd1_2 = {CD1_2:.10f}'.format(**header))
print('RESULT: cd2_1 = {CD2_1:.10f}'.format(**header))
print('RESULT: cd2_2 = {CD2_2:.10f}'.format(**header))
# graphic output
if interactive:
import matplotlib.pyplot as plt
_, axis = plt.subplots()
plt.text(0, -10, file_name, fontsize=14, color='white')
axis.imshow(pixels)
plt.show()
return 0
def main():
file_name, interactive = lib_args.get_args()
# importing image
pixels = None
pixels, header = lib_fits.read_first_image(file_name)
my_wcs = lib_wcs.get_wcs(header)
clusters = ex3_clusters.find_clusters(pixels, False)
for j in range(len(clusters)):
peak_pixel = lib_wcs.PixelXY(clusters[j].y, clusters[j].x)
cel_coord = lib_wcs.xy_to_radec(my_wcs, peak_pixel)
acc_radius = 0.001
celestial_objects, out, req = lib_stars.get_celestial_objects(
cel_coord, acc_radius)
signature_fmt_1 = 'RESULT: right_ascension_{:d} = {:.3f}'.format(
j, cel_coord[0])
signature_fmt_2 = 'RESULT: declination_{:d} = {:.3f}'.format(
j, cel_coord[1])
print(signature_fmt_1)
print(signature_fmt_2)
for i, key in enumerate(celestial_objects.keys()):
signature_fmt_3 = 'RESULT: celestial_object_{:d}_{:d} = {}'.format(
j, i, key)
print(signature_fmt_3)
# graphic output
if interactive:
fig, main_axes = plt.subplots()
handler = Handler(fig, main_axes, my_wcs)
main_axes.imshow(pixels)
#fig.canvas.mpl_connect('motion_notify_event', handler.move)
fig.canvas.mpl_connect('button_press_event', handler.on_click)
plt.show()
# end
return 0
def main():
""" Exercise 5: Stars """
lib_fits.init()
print(lib_fits.file_name)
global pixels
global header
header, pixels = lib_fits.read_first_image(lib_fits.file_name)
clusters = lib_cluster.find_clusters(pixels)
clusters_radec = []
for i in range(len(clusters)):
clusters_radec.append(
lib_stars.get_radec(clusters[i].coord[0], clusters[i].coord[1],
header, pixels))
signature_fmt_1 = 'RESULT: right_ascension = {:.3f}'.format(
clusters_radec[0][0])
signature_fmt_2 = 'RESULT: declination = {:.3f}'.format(
clusters_radec[0][1])
print(signature_fmt_1)
print(signature_fmt_2)
celestial_objects = stars.get_celestial_objects(clusters_radec[0])
#print(celestial_objects)
for i in range(len(celestial_objects[0])):
signature_fmt_3 = 'RESULT: celestial_object_{:02d} = {:s}'.format(
i,
list(celestial_objects[0].keys())[i])
signature_fmt_4 = 'RESULT: dist_{:02d} = {:5.1f}'.format(
i,
list(celestial_objects[0].values())[i])
print(signature_fmt_3)
print(signature_fmt_4)
return 0
def main():
""" Exercise 1: Read Image """
#taking file name
lib_fits.init()
print(lib_fits.file_name)
header, pixels = lib_fits.read_first_image(lib_fits.file_name)
# show figure
if lib_fits.interactive:
fig, main_axes = plt.subplots()
main_axes.imshow(pixels)
plt.show()
#signature
signature_fmt_1 = 'RESULT: CRPIX1 = {:.0f}'.format(header.get("CRPIX1"))
signature_fmt_2 = 'RESULT: CRPIX2 = {:.0f}'.format(header.get("CRPIX2"))
print(signature_fmt_1)
print(signature_fmt_2)
return 0
def main():
# analyse command line arguments
file_name, interactive = lib_args.get_args()
# importing image
pixels = None
pixels, header = lib_fits.read_first_image(file_name)
my_wcs = lib_wcs.get_wcs(header)
sorted_clusters = ex3_clusters.find_clusters(pixels, False)
peak_pixel = lib_wcs.PixelXY(sorted_clusters[0].y, sorted_clusters[0].x)
cel_coord = lib_wcs.xy_to_radec(my_wcs, peak_pixel)
acc_radius = 0.001
celestial_objects, out, req = lib_stars.get_celestial_objects(
cel_coord, acc_radius)
signature_fmt_1 = 'RESULT: right_ascension = {:.3f}'.format(cel_coord[0])
signature_fmt_2 = 'RESULT: declination = {:.3f}'.format(cel_coord[1])
print(signature_fmt_1)
print(signature_fmt_2)
i = 0
for key in celestial_objects.keys():
signature_fmt_3 = 'RESULT: celestial_object_{:d} = {}'.format(i, key)
print(signature_fmt_3)
i += 1
# graphic output
if interactive:
# ...
pass
# end
return 0
def main():
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
z = lib_model.gaussian_model(np.arange(-10.0, 10.0, 1.0), 1.0, 1.0, 1.0)
print('RESULT: test_gaussian = {:3f}'.format(np.sum(z)))
y, x = lib_background.build_pixel_histogram(pixels, 200)
print('RESULT: histogram = {:5d}'.format(np.sum(y)))
background, dispersion, mx, y, x = lib_background.compute_background_from_histogram((y, x))
# console output
print('RESULT: background = {:d}'.format(int(background)))
print('RESULT: dispersion = {:d}'.format(int(dispersion)))
# graphic output
if interactive:
import matplotlib.pyplot as plt
_, axis = plt.subplots()
# axis.imshow(pixels)
z = lib_model.gaussian_model(x, 1.0, background/mx, dispersion/mx)
plt.plot(x, y, 'b+:', label='data')
plt.plot(x, z, 'r.:', label='fit')
plt.legend()
plt.title('Flux distribution')
plt.xlabel('Amplitude')
plt.ylabel('Frequence')
plt.show()
return 0
def __call__(self, filepath):
print(filepath)
header, pixels = lib_fits.read_first_image(filepath)
imgplot = self.axis.imshow(pixels)
self.fig.canvas.draw_idle()
def main():
'''
Main function of the program
'''
global reg
global strategy
global in_cluster
global in_scanning
# process command-line options
file_name, interactive = lib_args.get_args()
header, pixels = lib_fits.read_first_image(file_name)
logging.debug('cd1_1: %s, cd1_2: %s, cd2_1: %s, cd2_2: %s',
header['CD1_1'], header['CD1_2'], header['CD2_1'],
header['CD2_2'])
logging.debug('height: %s, width: %s', pixels.shape[0], pixels.shape[1])
# compute background
background, dispersion, _ = lib_background.compute_background(pixels)
logging.debug('background: %s, dispersion: %s', int(background),
int(dispersion))
print('---------------------')
# search for clusters in a sub-region of the image
threshold = 6.0
# graphic output
if interactive:
# cluster central
image = pixels[45:70, 40:65]
reg = lib_cluster.Region(image, background + threshold * dispersion)
strategy = '4centers'
in_cluster = 1.0
in_scanning = 0.1
def select_strategy(value):
global strategy
print(('select strategy=', value))
strategy = value
def select_in_cluster(value):
global in_cluster
in_cluster = value
def select_in_scanning(value):
global in_scanning
in_scanning = value
def start_animate(value):
print(('animate with strategy=', strategy))
reg.animate(in_cluster=in_cluster,
in_scanning=in_scanning,
strategy=strategy)
strategies = ['random', 'all', 'center', '4centers']
axis_strategy = plt.axes([0.2, 0.8, 0.15, 0.15])
axis_strategy.set_title('Scanning strategy')
strategy_widget = RadioButtons(axis_strategy, strategies)
strategy_widget.set_active(strategies.index(strategy))
strategy_widget.on_clicked(select_strategy)
axis_in_cluster = plt.axes([0.2, 0.7, 0.65, 0.03])
in_cluster_widget = Slider(axis_in_cluster,
'wait in clusters',
0.0,
5.0,
valinit=in_cluster)
in_cluster_widget.on_changed(select_in_cluster)
axis_in_scanning = plt.axes([0.2, 0.6, 0.65, 0.03])
in_scanning_widget = Slider(axis_in_scanning,
'wait in scanning',
0.0,
1.0,
valinit=in_scanning)
in_scanning_widget.on_changed(select_in_scanning)
axis_animate = plt.axes([0.2, 0.5, 0.1, 0.03])
in_animate = Button(axis_animate, 'Animate')
in_animate.on_clicked(start_animate)
plt.show()
return 0
def main():
file_name, interactive = lib_args.get_args()
#print(file_name)
header, pixels = lib_fits.read_first_image(file_name)
background, dispersion, _ = lib_background.compute_background(pixels)
# search for clusters
clustering = lib_cluster.Clustering()
# clusters = clustering(pixels, background, dispersion)
pattern = clustering.step_build_pattern()
print('RESULT: pattern_sum = {:5.0f}'.format(np.sum(pattern)))
ext_image = clustering.step_extend_image(pixels)
print('RESULT: extended_image_width = {:2d}'.format(ext_image.shape[1]))
print('RESULT: extended_image_height = {:2d}'.format(ext_image.shape[0]))
print('RESULT: extended_image_sum = {:5.0f}'.format(np.sum(ext_image)))
cp_image = clustering.step_build_convolution_image(ext_image)
print('RESULT: convolution_image_width = {:2d}'.format(cp_image.shape[1]))
print('RESULT: convolution_image_height = {:2d}'.format(cp_image.shape[0]))
print('RESULT: convolution_image_sum = {:5.0f}'.format(np.sum(cp_image)))
ext_cp_image = clustering.step_extend_convolution_image(cp_image)
print('RESULT: extended_convolution_image_width = {:2d}'.format(ext_cp_image.shape[1]))
print('RESULT: extended_convolution_image_height = {:2d}'.format(ext_cp_image.shape[0]))
print('RESULT: extended_convolution_image_sum = {:5.0f}'.format(np.sum(ext_cp_image)))
peaks = clustering.step_detect_peaks(pixels, cp_image, ext_cp_image, background, dispersion)
print('RESULT: peaks_number = {:2d}'.format(len(peaks)))
#for npeak, peak in enumerate(peaks):
# print('peak[{}]: {}'.format(npeak, peak))
clusters = clustering.step_build_clusters(pixels, peaks, background, dispersion)
print('RESULT: clusters_number = {:2d}'.format(len(clusters)))
clusters, max_top = clustering.step_sort_clusters(clusters)
print('RESULT: cluster_max_top = {:5d}'.format(max_top))
max_cluster = clusters[0]
# console output
print('RESULT: cluster_max_integral = {:5d}'.format(max_cluster.integral))
print('RESULT: cluster_max_column = {:5d}'.format(max_cluster.column))
print('RESULT: cluster_max_row = {:5d}'.format(max_cluster.row))
# graphic output
if interactive:
import matplotlib.pyplot as plt
_, axes = plt.subplots(2)
_ = axes[0].imshow(clustering._build_pattern())
_ = axes[1].imshow(lib_cluster.add_crosses(pixels,clusters))
plt.show()
return 0
def main():
# analyse command line arguments
file_name, interactive = lib_args.get_args()
# importing image
pixels = None
pixels, header = lib_fits.read_first_image(file_name)
pattern = lib_cluster.build_pattern(interactive)
background, dispersion, mx, hist_sum = lib_background.compute_background(
pixels, interactive)
threshold = background + 6. * dispersion
extended_image = lib_cluster.extend(pixels, interactive, 0, 4)
convolved_image = lib_cluster.convolve(extended_image, pattern)
extended_convolved_image = lib_cluster.extend(convolved_image, interactive,
0, 1)
max_mask = lib_cluster.has_peak(convolved_image, interactive, threshold)
peak_list = lib_cluster.get_peaks_from_mask(max_mask)
clusters = lib_cluster.get_clusters(peak_list, pixels, threshold)
sorted_clusters = sorted(clusters, key=lambda cluster: -cluster.int_lumi)
print('RESULT: pattern_sum = {:5.0f}'.format(pattern.sum().sum()))
print('RESULT: extended_image_width = {:2d}'.format(
extended_image.shape[0]))
print('RESULT: extended_image_height = {:2d}'.format(
extended_image.shape[1]))
print('RESULT: extended_image_sum = {:5.0f}'.format(
extended_image.sum().sum()))
print('RESULT: convolution_image_width = {:2d}'.format(
convolved_image.shape[0]))
print('RESULT: convolution_image_height = {:2d}'.format(
convolved_image.shape[1]))
print('RESULT: convolution_image_sum = {:5.0f}'.format(
convolved_image.sum().sum()))
print('RESULT: extended_convolution_image_width = {:2d}'.format(
extended_convolved_image.shape[0]))
print('RESULT: extended_convolution_image_height = {:2d}'.format(
extended_convolved_image.shape[1]))
print('RESULT: extended_convolution_image_sum = {:5.0f}'.format(
extended_convolved_image.sum().sum()))
print('RESULT: peaks_number={:2d}'.format(max_mask.sum().sum()))
print('RESULT: clusters_number={:2d}'.format(len(sorted_clusters)))
print('RESULT: cluster_max_top={:5d}'.format(
int(sorted_clusters[0].peak_lumi)))
print('RESULT: cluster_max_integral={:5d}'.format(
int(sorted_clusters[0].int_lumi)))
print('RESULT: cluster_max_column={:5d}'.format(int(sorted_clusters[0].y)))
print('RESULT: cluster_max_row={:5d}'.format(int(sorted_clusters[0].x)))
# graphic output
if interactive:
fig, main_axes = plt.subplots()
main_axes.imshow(convolved_image)
#plt.show()
# end
return 0
def my_action(label):
pixels, header = lib_fits.read_first_image("../data/" + label)
ax.imshow(pixels)
def main():
""" Exercise 3: Peaks """
lib_fits.init()
print(lib_fits.file_name)
header, pixels = lib_fits.read_first_image(lib_fits.file_name)
# Build Gaussian pattern
pattern = lib_conv.pattern(9)
plt.imshow(pattern)
#plt.show()
sum_pat = np.sum(pattern)
pattern = pattern/sum_pat
sum_pat_norm = np.sum(pattern)
max_pat_norm = np.max(pattern)
signature_fmt_1 = 'RESULT: pattern_sum={:.5f}'.format(sum_pat_norm)
signature_fmt_2 = 'RESULT: pattern_max={:.5f}'.format(max_pat_norm)
print(signature_fmt_1)
print(signature_fmt_2)
# Extend the image
extended = lib_conv.extend(pixels, 4)
plt.imshow(extended)
plt.show()
height = len(extended)
width = len(extended[0])
sum = np.sum(extended)
signature_fmt_3 = 'RESULT: extended_image_width={:d}'.format(width)
signature_fmt_4 = 'RESULT: extended_image_height={:d}'.format(height)
signature_fmt_5 = 'RESULT: extended_image_sum={:.0f}'.format(sum)
print(signature_fmt_3)
print(signature_fmt_4)
print(signature_fmt_5)
# Convoluted
conv = lib_conv.scan(extended, 4, pattern)
plt.imshow(conv)
plt.show()
conv_height = len(conv)
conv_width = len(conv[0])
conv_sum = np.sum(conv)
signature_fmt_6 = 'RESULT: convoluted_image_width={:d}'.format(conv_width)
signature_fmt_7 = 'RESULT: convoluted_image_height={:d}'.format(conv_height)
signature_fmt_8 = 'RESULT: convoluted_image_sum={:.0f}'.format(conv_sum)
print(signature_fmt_6)
print(signature_fmt_7)
print(signature_fmt_8)
# Extend the convolution image
conv_ext = lib_conv.extend(conv, 1)
conv_ext_height = len(conv_ext)
conv_ext_width = len(conv_ext[0])
conv_ext_sum = np.sum(conv_ext)
signature_fmt_9 = 'RESULT: extended_convoluted_image_width={:d}'.format(conv_ext_width)
signature_fmt_10 = 'RESULT: extended_convoluted_image_height={:d}'.format(conv_ext_height)
signature_fmt_11 = 'RESULT: extended_convoluted_image_sum={:.0f}'.format(conv_ext_sum)
print(signature_fmt_9)
print(signature_fmt_10)
print(signature_fmt_11)
# Identify the Peaks
threshold = lib_background.threshold(pixels)
print(threshold)
peaks = lib_conv.peaks(conv_ext, 1, threshold)
signature_fmt_12 = 'RESULT: peaks_number={:d}'.format(len(peaks))
print(signature_fmt_12)
# end
return 0
label = ' '.join(tokens)
self.text = plt.text(x, y, label, fontsize=14, color='white')
self.fig.canvas.draw()
# =====
# Unit test
# =====
if __name__ == '__main__':
import sys, lib_fits, lib_background, lib_wcs
filename = '../../data/fits/common.fits'
header, pixels = lib_fits.read_first_image(filename)
background, dispersion, _ = lib_background.compute_background(pixels)
clusters = lib_cluster.convolution_clustering(pixels, background,
dispersion)
wcs = lib_wcs.get_wcs(header)
fig, axis = plt.subplots()
axis.imshow(pixels, interpolation='none')
fig.canvas.mpl_connect(
'motion_notify_event',
ShowClusterProperties(fig, clusters,
lambda cl: ["{}".format(cl.integral)]))
plt.show()
sys.exit(0)
