def display_map(map, scale="logZscale"):
img = fits.open(map)[0]
image_data = img.data[:, :]
image_data = img.data[:, :] / np.mean(image_data)
for i, line in enumerate(image_data):
for j, col in enumerate(line):
image_data[i][j] = max([col, 0.00001])
print len(image_data)
#image_data= image_data/((1-0.72)**2-1.03**2)
fig, ax = plt.subplots(1, figsize=(10, 10))
ax.set_aspect('equal')
if scale == "linZscale":
norm = ImageNormalize(image_data,
interval=ZScaleInterval(contrast=0.01),
stretch=SqrtStretch())
im = ax.imshow(image_data, cmap='gray', norm=norm)
plt.colorbar(im, ax=ax)
if scale == "logZscale":
new_image_data = 2.5 * np.log(image_data)
norm = ImageNormalize(new_image_data,
interval=ZScaleInterval(contrast=0.000001),
stretch=SqrtStretch())
im = ax.imshow(new_image_data - np.min(new_image_data),
aspect='auto',
cmap='gray')
#plt.colorbar(im,ax=ax)
circ = Circle((1000, 3000), 20, ec="red", fc=None, fill=False)
circ2 = Circle((1000, 3000), 250, ec="green", fc=None, fill=False)
#ax.add_patch(circ)
#ax.add_patch(circ2)
#plt.axis('off')
locs2 = ax.get_xticks()
print locs2
# locs2[1] = frequency_spline[0]
temp_lab = ax.get_xticklabels()
lab2 = np.round(np.multiply(0.00244140625, locs2[1:-1]), 1)
print lab2
labels = []
ax.set(xlabel=r'$\theta_E$', ylabel=r'$\theta_E$')
ax.set_xticks(locs2[1:-1], minor=False)
ax.set_yticks(locs2[1:-1], minor=False)
ax.set_xticklabels(lab2, minor=False)
ax.set_yticklabels(lab2, minor=False)
plt.show()
fig.savefig('mapA-B.png')
def norm_set(self, text):
stretch_dict = {
'No Stretch': None,
'Sqrt Stretch': SqrtStretch(),
'Linear Stretch': LinearStretch(),
'Squared Stretch': SquaredStretch(),
'Power Stretch': PowerStretch(self.a),
'Log Stretch': LogStretch(self.a)
}
self.stretch_val = stretch_dict[text]
if text == 'Log Stretch':
self.var_max = 10000
self.var_int = 10
self.cube = self.stretch_val(self.cube_base)
#self.norm = ImageNormalize(interval=self.interval, stretch=self.stretch_val, clip=True)
elif text == 'Sqrt Stretch':
self.cube = np.sqrt(self.cube)
elif text == 'No Stretch':
self.norm = None
self.cube = self.cube_base
else:
self.var_max = 10
self.var_int = 1
self.cube = self.stretch_val(self.cube_base, clip=False)
#self.norm = ImageNormalize(interval=self.interval, stretch=self.stretch_val, clip=True)
main.create_image(self.cube)
def try_dao(fitsfile, outfile='out.png'):
hdulist = fits.open(fitsfile)
hdu = hdulist[0]
if len(hdu.data.shape) == 3:
data = hdu.data[0]
else:
data = hdu.data
mean, median, std = sigma_clipped_stats(data[800:900, 800:900],
sigma=3.0,
iters=5)
print(mean, median, std)
#data = hdu.data
sources = daofind(data - median, fwhm=3.0, threshold=5. * std)
print 'Found %i sources' % len(sources)
positions = (sources['xcentroid'], sources['ycentroid'])
apertures = CircularAperture(positions, r=4.)
norm = ImageNormalize(stretch=SqrtStretch(), vmin=2000, vmax=3000)
plt.imshow(data, cmap='Greys', origin='lower', norm=norm)
plt.title('%i Sources from a single all-sky frame' % len(sources))
apertures.plot(color='blue', lw=1.5, alpha=0.5)
plt.savefig(filename=outfile)
def crop_roi(self,
fits_file,
source_x,
source_y,
roi_box=10,
use_pil=False):
body_path, ext = os.path.splitext(fits_file)
fo = FitsOps(fits_file)
source_roi = fo.hdu[0].data[int(source_y - roi_box):int(source_y +
roi_box),
int(source_x - roi_box):int(source_x +
roi_box)]
norm = ImageNormalize(stretch=SqrtStretch())
plt.axis('off')
plt.imshow(source_roi, cmap='Greys', origin='lower', norm=norm)
plt.savefig('{}_roi.png'.format(body_path),
bbox_inches='tight',
pad_inches=0,
transparent=True)
plt.close()
return source_roi
def stretchImage(self, image=None):
"""
stretchImage take the actual image and calculated norm based on the min, max
derived from interval which is calculated with AsymmetricPercentileInterval.
:param image: image
:return: norm for plot
"""
if image is None:
return None
values = self.stretchValues[self.ui.stretch.currentText()]
interval = AsymmetricPercentileInterval(*values)
vmin, vmax = interval.get_limits(image)
# cutout the noise
delta = vmax - vmin
vmin = min(vmin + delta * 0.01, vmax)
norm = ImageNormalize(image,
vmin=vmin,
vmax=vmax,
stretch=SqrtStretch(),
)
return norm, vmin, vmax
def plot_frames(self, save=False):
""" Loop through all the images in a directory and plot them.
* NEEDS WORK -- NOT DONE *
"""
image_directory = self.file_list
self.norm = ImageNormalize(vmin=-300, vmax=22000, stretch=SqrtStretch())
fig = plt.figure() # Get a figure up there
for ip in image_directory:
plt.plot(i)
plt.show()
plt.xlim(1500, 1550)
plt.ylim(970, 1020)
ax = fig.add_subplot(111) # yeah
ax.set_title("yep")
im = ax.imshow(self.reduced_images[0], cmap='gray', norm=self.norm, origin='lower')
fig.show()
im.axes.figure.canvas.draw()
for files in image_directory:
dat = fits.getdata(files, ext=0)
ax.set_title(str(files))
im.set_data(dat)
if save:
plt.savefig("C:/Users/Austin/Desktop/Nanohmics/fits_images/uh.png", bbox_inches='tight')
im.axes.figure.canvas.draw()
def photplots(data, bkg_image, bkg_rms, data_sub, fitsfile, outfig):
from astropy.visualization import LogStretch, SqrtStretch
from astropy.visualization.mpl_normalize import ImageNormalize
norm = ImageNormalize(stretch=SqrtStretch())
# for plotting
mask = (data <= 0)
data[mask] = 0
data_sub[mask] = 0
kw = {'norm': norm, 'cmap': 'Greys', 'origin': 'lower'}
# kw = {'cmap': 'Greys_r', 'origin': 'lower'}
bkw = {'cmap': 'Greys_r', 'origin': 'lower'}
fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(10, 10))
[ax.grid() for ax in axs.ravel()]
im = axs[0][0].imshow(data, **kw)
axs[0][0].set_title(fitsfile)
im = axs[1][0].imshow(bkg_image, **bkw)
axs[1][0].set_title('bg')
im = axs[1][1].imshow(bkg_rms, **bkw)
axs[1][1].set_title('bg rms')
# plot background-subtracted image
ax = axs[0][1]
im = ax.imshow(data_sub, **kw)
ax.set_title('bg-sub data')
plt.tight_layout()
plt.savefig(outfig)
return axs
def showNorm(imaOrCcd, **kwargs):
from astropy.visualization import imshow_norm, SqrtStretch
from astropy.visualization.mpl_normalize import PercentileInterval
from astropy.nddata import CCDData
plt.clf()
fig = plt.gcf()
if isinstance(imaOrCcd, CCDData):
arr = imaOrCcd.data
wcs = imaOrCcd.wcs
if wcs is None:
ax = plt.subplot()
else:
ax = plt.subplot(projection=wcs)
ax.coords.grid(True, color='white', ls='solid')
else:
arr = imaOrCcd
ax = plt.subplot()
if 'interval' not in kwargs:
kwargs['interval'] = PercentileInterval(99.7)
if 'stretch' not in kwargs:
kwargs['stretch'] = SqrtStretch()
if 'origin' not in kwargs:
kwargs['origin'] = 'lower'
im, _ = imshow_norm(arr, ax=ax, **kwargs)
cb = fig.colorbar(im)
cb.ax.tick_params(labelsize=11)
def display_trajectory_bis(arrow_coord, map):
arrow = [
arrow_coord[0], arrow_coord[1],
int(arrow_coord[2] - arrow_coord[0]), arrow_coord[3] - arrow_coord[1]
]
print arrow
image_file = get_pkg_data_filename(map)
image_data = fits.getdata(image_file, ext=0)
# image_data = np.swapaxes(image_data,0,1)
real_arrow = [
arrow_coord[0], arrow_coord[1], arrow_coord[2], arrow_coord[3]
]
new_image_data = -2.5 * np.log(abs(image_data))
norm = ImageNormalize(new_image_data - np.min(new_image_data),
interval=ZScaleInterval(contrast=0.25),
stretch=SqrtStretch())
im = plt.imshow(new_image_data - np.min(new_image_data),
aspect='auto',
cmap='gray')
plt.colorbar(im)
plt.arrow(arrow[0],
arrow[1],
arrow[2],
arrow[3],
head_width=50,
head_length=50,
fc='g',
ec='g')
plt.show()
def get_norm(self, stretch_text, scale_text):
image = self.ax.get_images()[0]
scale = None
if scale_text == "MinMax":
scale = MinMaxInterval()
else:
scale = ZScaleInterval()
if stretch_text == "Linear":
stretch = LinearStretch()
elif stretch_text == "Log":
stretch = LogStretch()
else:
stretch = SqrtStretch()
minV, maxV = scale.get_limits(
self.cubeObj.data_cube[self.cubeObj.currSlice])
norm = ImageNormalize(vmin=minV, vmax=maxV, stretch=stretch)
return norm
def plot_image(fitsname,
imagename,
rms=np.nan,
vmin=-3,
vmax=25,
ra_zoom=None,
dec_zoom=None,
d_zoom=None,
AR=16 / 9.):
'''
make an image called imagename from cutout from fits file fitsname at coords ra_zoom, dec_zoom and dimensions d_zoom x d_zoom/AR
'''
hdu = extract_subim(fitsname, ra_zoom, dec_zoom, d_zoom, d_zoom / AR)
dat = hdu[0].data
figsize = (10, 10. / AR)
f1 = plt.figure(figsize=figsize)
norm = ImageNormalize(vmin=vmin * rms,
vmax=vmax * rms,
stretch=SqrtStretch())
plt.imshow(dat, origin='lower', cmap=plt.cm.cubehelix, norm=norm)
plt.subplots_adjust(left=0.0, bottom=0.0, top=1.0, right=1.0)
plt.savefig(imagename)
return
def saveim_png(data,
savedir,
fname,
colmap='coolwarm',
orig=None,
datextent=None,
interp='None',
xtag='X',
ytag='Y',
title=None):
# Show and save image
plt.figure()
norm = ImageNormalize(stretch=SqrtStretch())
plt.imshow(data,
cmap=colmap,
origin=orig,
norm=norm,
interpolation=interp,
extent=datextent)
plt.colorbar()
plt.xlabel(xtag, fontsize=20), plt.ylabel(ytag, fontsize=20)
if not title == None:
plt.title(title, fontsize=24)
plt.tight_layout()
# Create savedir
if not os.path.exists(savedir):
os.makedirs(savedir)
plt.savefig(savedir + '/' + fname + ".png")
plt.show()
plt.close()
def takePicture():
img = cv2.imread('output/20201024013736_ZWO_ASI294MC_Pro.tiff')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
mean, median, std = sigma_clipped_stats(gray, sigma=3.0)
print(f'mean:{mean} median:{median} std:{std}')
daofind = DAOStarFinder(fwhm=5.0, threshold=5. * std)
print(gray.shape, median.shape)
sources = daofind(gray - median)
for col in sources.colnames:
sources[col].info.format = '%.8g' # for consistent table output
print(sources)
import numpy as np
import matplotlib.pyplot as plt
from astropy.visualization import SqrtStretch
from astropy.visualization.mpl_normalize import ImageNormalize
from photutils import CircularAperture
positions = np.transpose((sources['xcentroid'], sources['ycentroid']))
apertures = CircularAperture(positions, r=4.)
norm = ImageNormalize(stretch=SqrtStretch())
plt.imshow(gray,
cmap='Greys',
origin='lower',
norm=norm,
interpolation='nearest')
apertures.plot(color='blue', lw=1.5, alpha=0.5)
plt.savefig('kk.png')
cv2.namedWindow('Falcon')
cv2.imshow('Falcon', gray)
cv2.waitKey(0)
return
def convert_to_valid_color(
image_color: np.ndarray,
clip: bool = False,
lower_clip: float = 0.0,
upper_clip: float = 1.0,
normalize: bool = False,
scaling: Optional[str] = None,
simple_norm: bool = False,
) -> np.ndarray:
"""
Convert the channel to a valid 0-1 range for RGB images
"""
if simple_norm:
interval = MinMaxInterval()
norm = ImageNormalize()
return norm(interval(image_color))
if clip:
image_color = np.clip(image_color, lower_clip, upper_clip)
if normalize:
interval = ManualInterval(lower_clip, upper_clip)
else:
interval = MinMaxInterval()
if scaling == "sqrt":
stretch = SqrtStretch()
image_color = stretch(interval(image_color))
else:
norm = ImageNormalize()
image_color = norm(interval(image_color))
return image_color
def plot_peaks(box, x_peaks, y_peaks, radius=None, title=None, vmin=None, vmax=None):
"""
This function plots the data with peaks marked ...
:param box:
:param x_peaks:
:param y_peaks:
:return:
"""
# Determine the maximum value in the box and the minium value for plotting
if vmin is None: vmin = max(np.nanmin(box), 0.)
if vmax is None: vmax = 0.5 * (np.nanmax(box) + vmin)
# Set the normalization
norm = ImageNormalize(stretch=SqrtStretch())
# Make the plot
plt.figure(figsize=(8,2.5))
plt.imshow(box, origin='lower', norm=norm, interpolation='nearest', vmin=vmin, vmax=vmax, cmap="viridis")
if radius is None: plt.plot(x_peaks, y_peaks, ls='none', color='white', marker='+', ms=40, lw=10, mew=4)
else:
positions = (x_peaks, y_peaks)
apertures = CircularAperture(positions, r=radius)
apertures.plot(color='green', lw=1.5, alpha=0.5)
plt.xlim(0, box.shape[1]-1)
plt.ylim(0, box.shape[0]-1)
if title is not None: plt.title(title)
plt.show()
def plot_star(box, peak, model, title=None, vmin=None, vmax=None):
"""
This function ...
:param box:
:param peak:
:param model:
:param title:
:return:
"""
# Normalization
norm = ImageNormalize(stretch=SqrtStretch())
# Determine the maximum value in the box and the minimum value for plotting
if vmin is None: vmin = max(np.nanmin(box), 0.)
if vmax is None: vmax = 0.5 * (np.nanmax(box) + vmin)
# Evaluate the model and subtract it from the cutout
evaluated = box.evaluate_model(model)
subtracted = box - evaluated
# Create a figure
plt.figure(figsize=(10,3))
# Plot the box
plt.subplot(1,4,1)
plt.imshow(box, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.plot(peak.x, peak.y, ls='none', color='white', marker='+', ms=40, lw=10, mew=4)
plt.xlim(0, box.xsize-1)
plt.ylim(0, box.ysize-1)
plt.title("Cutout")
# Plot the model
plt.subplot(1,4,2)
plt.imshow(evaluated, origin='lower', interpolation="nearest", norm=norm, vmin=0.0, vmax=vmax, cmap="viridis")
plt.xlim(0, box.xsize-1)
plt.ylim(0, box.ysize-1)
plt.title("Model")
# Plot the subtracted box on the same scale as the original box and model
plt.subplot(1,4,3)
plt.imshow(subtracted, origin='lower', interpolation="nearest", norm=norm, vmin=0.0, vmax=vmax, cmap="viridis")
plt.xlim(0, box.xsize-1)
plt.ylim(0, box.ysize-1)
plt.title("Residual")
# Plot the subtracted box on a narrower color scale
plt.subplot(1,4,4)
sp = plt.imshow(subtracted, origin='lower', interpolation="nearest", cmap="viridis")
plt.xlim(0, box.xsize-1)
plt.ylim(0, box.ysize-1)
plt.title("Residual")
plt.colorbar(sp, format="%.2f")
# Set the main title
if title is not None: plt.suptitle(title, size=16)
# Show the plot
plt.show()
def contour_plot(ax, contour_file, contour_type, image_beam):
"""Plots contours over the main image, can be either from the same image or from a different one, fits file."""
cblock = import_contours(contour_file)
cdata = cblock[0]
cheader = cblock[1]
cwcs = WCS(cheader)
contour_type = str(contour_type)
ax.set_autoscale_on(False)
norm = ImageNormalize(cdata,
interval=MinMaxInterval(),
stretch=SqrtStretch())
if contour_type == "automatic":
spacing = contour_bias
n = 6 #number of contours
ub = np.max(cdata)
lb = np.min(cdata)
def level_func(lb, ub, n, spacing=1.1):
span = (ub - lb)
dx = 1.0 / (n - 1)
return [lb + (i * dx)**spacing * span for i in range(n)]
levels = level_func(lb, ub, n, spacing=float(spacing))
levels = np.array(levels)[np.array(levels) > 0.]
print('Generated Levels for contour are: ', levels, 'MJy/sr')
CS = ax.contour(cdata,
levels=levels,
colors='black',
transform=ax.get_transform(cwcs.celestial),
alpha=1.0,
linewidths=1)
if contour_type == "sigma":
contour_levels = list(map(float, args.contour_levels))
sigma_levels = np.array(contour_levels)
rms = (0.0004 * u.Jy / u.beam).to(
u.MJy / u.sr, equivalencies=u.beam_angular_area(image_beam))
levels = rms * sigma_levels
print('Sigma Levels for contour are: ', sigma_levels, 'sigma')
CS = ax.contour(cdata,
levels=levels,
norm=norm,
transform=ax.get_transform(cwcs.celestial),
colors='white',
alpha=0.5)
#plt.title(label='Contours at %s sigma' % contour_levels)
if contour_type == "manual":
levels = list(map(float, args.contour_levels))
print('Contour Levels are: ', levels, 'MJy/sr')
CS = ax.contour(cdata,
levels=levels,
norm=norm,
transform=ax.get_transform(cwcs.celestial),
colors='white',
alpha=0.5,
linewidths=1.0)
def __init__(self):
pass
self.image_norms = {
'log': LogStretch(),
'linear': LinearStretch(),
'sqrt': SqrtStretch(),
}
self.map = None
def plot_box(box, title=None, path=None, format=None, scale="log", interval="pts", cmap="viridis"):
"""
This function ...
:param box:
:param title:
:param path:
:param format:
:param scale:
:param interval:
:param cmap:
:return:
"""
# Other new colormaps: plasma, magma, inferno
# Normalization
if scale == "log": norm = ImageNormalize(stretch=LogStretch())
elif scale == "sqrt": norm = ImageNormalize(stretch=SqrtStretch())
#elif scale == "skimage": norm = exposure.equalize_hist
else: raise ValueError("Invalid option for 'scale'")
if interval == "zscale":
vmin, vmax = ZScaleInterval().get_limits(box)
elif interval == "pts":
# Determine the maximum value in the box and the mimimum value for plotting
vmin = max(np.nanmin(box), 0.)
vmax = 0.5 * (np.nanmax(box) + vmin)
elif interval == "minmax":
vmin, vmax = MinMaxInterval().get_limits(box)
elif isinstance(interval, tuple):
vmin = interval[0]
vmax = interval[1]
else: raise ValueError("Invalid option for 'interval'")
# Make the plot
plt.figure(figsize=(7,7))
plt.imshow(box, origin="lower", interpolation="nearest", vmin=vmin, vmax=vmax, norm=norm, cmap=cmap)
plt.xlim(0, box.shape[1]-1)
plt.ylim(0, box.shape[0]-1)
if title is not None: plt.title(title)
if path is None: plt.show()
else: plt.savefig(path, format=format)
plt.close()
# Return vmin and vmax
return vmin, vmax
def plotSatelliteTrail(imageArray, trailPoint1, trailPoint2, trailWidth):
"""Make three figures to illustrate the original and rotated image,
summed flux profile of the satellite trail, and flux along the trail.
Parameters
----------
imageArray : np.array
2D array containing image data.
trailPoint1 : `list` with 2 values
[x1, y1] coordinates of first point on trail, in pixels
trailPoint2 : `list` with 2 values
[x2, y2] coordinates of second point on trail, in pixels
trailWidth : `int`
Width of trail, in pixels
"""
rotatedInfo = makeTrailHorizontal(imageArray, trailPoint1, trailPoint2,
trailWidth)
rotatedArray = rotatedInfo[0]
trailRotX = rotatedInfo[1]
trailRotY = rotatedInfo[2]
sliced = rotatedInfo[3]
trailLength = getTrailLength(trailPoint1, trailPoint2)
norm = ImageNormalize(imageArray,
interval=ZScaleInterval(),
stretch=SqrtStretch())
fig1 = plt.figure(figsize=(8, 4))
fig1.add_subplot(121)
plt.imshow(imageArray, cmap='gray', norm=norm, origin='lower')
plt.plot([trailPoint1[0], trailPoint2[0]],
[trailPoint1[1], trailPoint2[1]],
ls=':',
color='C0',
lw=2)
plt.title('Original image with satellite trail')
fig1.add_subplot(122)
plt.imshow(rotatedArray, cmap='gray', norm=norm, origin='lower')
plt.axhline(y=trailRotY - trailWidth, ls=':', color='C1', lw=2)
plt.axhline(y=trailRotY + trailWidth, ls=':', color='C1', lw=2)
plt.axhline(y=trailRotY, ls=':', color='C0', lw=2)
plt.plot(trailRotX, trailRotY, marker='o', color='C4')
plt.plot(trailRotX + trailLength, trailRotY, marker='o', color='C4')
plt.title('Rotated image with horizontal satellite trail')
fig2 = plt.figure(figsize=(8, 4))
ax2 = fig2.subplots()
ax2.plot(sliced.sum(axis=1), marker='o')
plt.xlabel('Pixel index')
plt.ylabel('Flux (nJy)')
plt.title('Summed flux profile')
fig3 = plt.figure(figsize=(8, 4))
ax3 = fig3.subplots()
ax3.plot(sliced.sum(axis=0))
plt.xlabel('Rotated X pixel position')
plt.ylabel('Flux (nJy)')
plt.title('Flux along the trail')
def background_reduction(List):
Raw_Image_Data = []
Reduced_Image_Data = []
Bkg = []
Bkg_Sigma = []
Median = []
Std = []
Norm = ImageNormalize(stretch=SqrtStretch())
for i in range(len(List)):
Image_File = get_pkg_data_filename(f'RAW_DATA/{List[i]}')
crmask, Raw_Image_Data_1 = astroscrappy.detect_cosmics(
fits.getdata(Image_File, ext=0))
Raw_Image_Data.append(Raw_Image_Data_1)
Mask = (Raw_Image_Data_1 == 0)
Sigma_Clip = SigmaClip(sigma=3.0)
Bkg_Estimator = MedianBackground()
Bkg_ta = Background2D(Raw_Image_Data_1, (25, 25),
filter_size=(3, 3),
sigma_clip=Sigma_Clip,
bkg_estimator=Bkg_Estimator,
mask=Mask)
Bkg.append(Bkg_ta)
Bkg_Sigma_ta = mad_std(Raw_Image_Data_1)
Bkg_Sigma.append(Bkg_Sigma_ta)
Mean, Median_ta, Std_ta = sigma_clipped_stats(Raw_Image_Data_1,
sigma=3.0)
Median.append(Median_ta)
Std.append(Std_ta)
Reduced_Image_Data_to_append = Raw_Image_Data_1 - Bkg_ta.background
Reduced_Image_Data.append(Reduced_Image_Data_to_append)
#plt.figure()
#plt.imshow(Raw_Image_Data_1, cmap = 'gray', origin = 'lower', interpolation = 'bicubic', norm = Norm, vmin = 100, vmax = 1000)
#plt.colorbar()
#plt.figure()
#plt.imshow(Bkg_ta.background, origin='lower', cmap='gray', interpolation = 'bicubic')
#plt.colorbar()
#plt.figure()
#plt.imshow(Reduced_Image_Data_to_append, norm = Norm, origin = 'lower', cmap = 'gray', interpolation = 'bicubic', vmin = 1, vmax = 1000)
#plt.colorbar()
#plt.show()
return Raw_Image_Data, Reduced_Image_Data, Bkg, Bkg_Sigma, Median, Std
def find_sources(file_, fwhm):
"""
Uses DAOStarFinder to extract source positions from fits file
:param file_ (str): name of target .fits file
:param fwhm (float): The full width half maximum of the gaussian kernel in pixels
For more config see
https://photutils.readthedocs.io/en/stable/api/photutils.detection.DAOStarFinder.html
"""
# Read in fits file as numpy array
data = read_fits(file_, return_array=True)
# Calculate background level
mean, median, std = stats.sigma_clipped_stats(data)
print(('mean', 'median', 'std'))
print((mean, median, std))
# Set up DAO Finder and run on bg subtracted image, printing results
# sharplo=.2, sharphi=1., roundlo=-.3, roundhi=.3,
daofind = DAOStarFinder(exclude_border=True, fwhm=fwhm, threshold=std)
sources = daofind.find_stars(data - median) # daofind(data-median) #
print('Sources:')
print(sources)
# Save positions of detected sources to csv file
positions = (sources['xcentroid'], sources['ycentroid'])
print_positions = zip(*[
sources[x] for x in [
'id', 'xcentroid', 'ycentroid', 'sharpness', 'roundness1',
'roundness2', 'npix', 'sky', 'peak', 'flux', 'mag'
]
])
header = 'id,xcentroid,ycentroid,sharpness,roundness1,roundness2,npix,sky,peak,flux,mag'
np.savetxt(file_[:-5] + '_positions.csv',
print_positions,
fmt='%.5e',
header=header)
# Show image with detected sources circled in blue
apertures = CircularAperture(positions, r=4.)
norm = ImageNormalize(stretch=SqrtStretch())
plt.imshow(data, cmap='Greys', origin='lower', norm=norm)
apertures.plot(color='blue', lw=1.5, alpha=0.5)
plt.draw()
# Scatter plot sharpness vs magnitude
plt.figure(2)
sharp, round_, mags = (sources['sharpness'], sources['roundness1'],
sources['mag'])
plt.scatter(mags, sharp)
plt.title('Sharpness vs Magnitude')
plt.xlabel('Mag')
plt.ylabel('Sharp')
# Scatter plot roundness vs magnitude
plt.figure(3)
plt.scatter(mags, round_)
plt.title('Roundness vs Magnitude')
plt.xlabel('Mag')
plt.ylabel('Roundness1')
plt.show()
def find_sources(data,
threshold=30,
fwhm=3.0,
show_sources=True,
save_sources=False,
plot_name='sources.png'):
"""Use photutils' DAOFind to locate sources in the input image.
Parameters
----------
data : numpy.ndarray
2D image
threshold : float
Number of sigma above the background used to determine the
presence of a source
show_sources : bool
If True, create an image with overlain marks showing sources
save_sources : bool
If True, save the image of the source locations at ```plot_name```
plot_name : str
Name of file to save the image with marked sources
Returns
-------
sources : astropy.table.Table
Table of source positions
"""
mean, median, std = sigma_clipped_stats(data, sigma=3.0)
daofind = DAOStarFinder(fwhm=fwhm, threshold=threshold * std)
sources = daofind(data - median)
if sources is not None:
print('{} sources found.'.format(len(sources)))
if show_sources or save_sources:
positions = np.transpose(
(sources['xcentroid'], sources['ycentroid']))
apertures = CircularAperture(positions, r=4.)
norm = ImageNormalize(stretch=SqrtStretch())
plt.imshow(data, cmap='Greys', origin='lower', norm=norm)
apertures.plot(color='blue', lw=1.5, alpha=0.5)
if show_sources:
plt.show()
if save_sources:
plt.savefig(plot_name)
print('Plot saved to {}'.format(plot_name))
plt.close()
else:
print('No sources found.')
return sources
def display_trajectory(crop_coord, arrow_coord, axes, map, scale="logZscale"):
image_file = get_pkg_data_filename(map)
image_data = fits.getdata(image_file, ext=0)
# image_data = np.swapaxes(image_data,0,1)
image_data = image_data[np.min([crop_coord[0], crop_coord[1]]
):np.max([crop_coord[0], crop_coord[1]]),
np.min([crop_coord[2], crop_coord[3]]):np.
max([crop_coord[2], crop_coord[3]])]
real_arrow = [
arrow_coord[0] - crop_coord[0], arrow_coord[1] - crop_coord[2],
arrow_coord[2] - crop_coord[0] - (arrow_coord[0] - crop_coord[0]),
-crop_coord[2] + arrow_coord[3] - (arrow_coord[1] - crop_coord[2])
]
#print real_arrow
ax = axes[1]
if scale == "linZscale":
norm = ImageNormalize(image_data,
interval=ZScaleInterval(contrast=0.1),
stretch=SqrtStretch())
im = ax.imshow(image_data, cmap='gray', norm=norm)
plt.colorbar(im, ax=ax)
if scale == "logZscale":
new_image_data = -2.5 * np.log10(abs(image_data))
norm = ImageNormalize(new_image_data - np.min(new_image_data),
interval=ZScaleInterval(contrast=0.25),
stretch=SqrtStretch())
im = ax.imshow(new_image_data - np.min(new_image_data),
aspect='auto',
cmap='gray')
plt.colorbar(im, ax=ax)
ax.arrow(real_arrow[1],
real_arrow[0],
real_arrow[3],
real_arrow[2],
head_width=50,
head_length=50,
fc='g',
ec='g')
def starbright(fnstar, fnflat, istar, axs, fg):
# %% load data
data = meanstack(fnstar, 100)[0]
# %% flat field
flatnorm = readflat(fnflat, fnstar)
data = (data / flatnorm).round().astype(data.dtype)
# %% background
mean, median, std = sigma_clipped_stats(data, sigma=3.0)
rfact = data.shape[0] // 40
cfact = data.shape[1] // 40
bg = Background(data, (rfact, cfact), interp_order=1, sigclip_sigma=3)
# http://docs.astropy.org/en/stable/units/#module-astropy.units
# dataphot = (data - bg.background)*u.ph/(1e-4*u.m**2 * u.s * u.sr)
# data = (data-0.97*data.min()/bg.background.min()*bg.background) * u.ph/(u.cm**2 * u.s * u.sr)
data = data * u.ph / (u.cm**2 * u.s * u.sr)
# %% source extraction
sources = daofind(data, fwhm=3.0, threshold=5 * std)
# %% star identification and quantification
XY = column_stack((sources["xcentroid"], sources["ycentroid"]))
apertures = CircularAperture(XY, r=4.0)
norm = ImageNormalize(stretch=SqrtStretch())
flux = apertures.do_photometry(data, effective_gain=camgain)[0]
# %% plots
fg.suptitle("{}".format(fnflat.parent), fontsize="x-large")
hi = axs[-3].imshow(flatnorm, interpolation="none", origin="lower")
fg.colorbar(hi, ax=axs[-3])
axs[-3].set_title("flatfield {}".format(fnflat.name))
hi = axs[-2].imshow(bg.background, interpolation="none", origin="lower")
fg.colorbar(hi, ax=axs[-2])
axs[-2].set_title("background {}".format(fnstar.name))
hi = axs[-1].imshow(data.value,
cmap="Greys",
origin="lower",
norm=norm,
interpolation="none")
fg.colorbar(hi, ax=axs[-1])
for i, xy in enumerate(XY):
axs[-1].text(xy[0],
xy[1],
str(i),
ha="center",
va="center",
fontsize=16,
color="w")
apertures.plot(ax=axs[-1], color="blue", lw=1.5, alpha=0.5)
axs[-1].set_title("star {}".format(fnstar.name))
return flux[istar]
def plot_removal(cutout, mask, background, removed, title=None, vmin=None, vmax=None):
"""
This function ...
:param cutout:
:param mask:
:param background:
:param removed:
:param title:
:return:
"""
# Get raw data of mask as a numpy array
if hasattr(mask, "data"): maskdata = mask.data
else: maskdata = mask
norm = ImageNormalize(stretch=SqrtStretch())
# Determine the maximum value in the box and the minimum value for plotting
if vmin is None: vmin = max(np.nanmin(cutout), 0.)
if vmax is None: vmax = 0.5 * (np.nanmax(cutout) + vmin)
# Plot the data with the best-fit model
plt.figure(figsize=(20,3))
plt.subplot(1,4,1)
plt.imshow(cutout, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(-0.5, cutout.xsize-0.5)
plt.ylim(-0.5, cutout.ysize-0.5)
plt.title("Cutout")
plt.subplot(1,4,2)
plt.imshow(np.ma.masked_array(cutout, mask=maskdata), origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(-0.5, cutout.xsize-0.5)
plt.ylim(-0.5, cutout.ysize-0.5)
plt.title("Background mask")
plt.subplot(1,4,3)
plt.imshow(background, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(-0.5, background.xsize-0.5)
plt.ylim(-0.5, background.ysize-0.5)
plt.title("Estimated background")
plt.subplot(1,4,4)
plt.imshow(removed, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(-0.5, background.xsize-0.5)
plt.ylim(-0.5, background.ysize-0.5)
plt.title("Cutout with star removed")
# Set the main title
if title is not None: plt.suptitle(title, size=16)
# Show the plot
plt.show()
def __init__(self,
hdu,
plot=True,
num_std=20,
max_stars=300,
query_radius=5.):
'''
:param hdu:
:param plot:
:param num_std:
:param max_stars:
:param query_radius:
'''
self.data = hdu.data.copy()
self.header = hdu.header.copy()
# Extract star positions and magnitudes from image
mean, med, std = sigma_clipped_stats(self.data)
daofind = DAOStarFinder(fwhm=3, threshold=num_std * std)
sources = daofind(self.data - med)
self.pixel_positions = (sources['xcentroid'], sources['ycentroid'])
self.inst_magnitudes = sources['mag']
if (plot):
apertures = CircularAperture(self.pixel_positions, r=4)
norm = ImageNormalize(stretch=SqrtStretch())
plt.imshow(self.data, cmap='Greys', origin='lower', norm=norm)
apertures.plot(color='blue', lw=1.5, alpha=0.5)
self.wcs_orig = wcs.WCS(self.header)
(self.ra_orig,
self.dec_orig) = self.wcs_orig.all_pix2world(self.pixel_positions[0],
self.pixel_positions[1],
0)
arr_ref = query_vizier(query_radius,
self.header['CRVAL1'],
self.header['CRVAL2'],
max_stars=max_stars)
self.ra_ref = arr_ref[:, 0]
self.dec_ref = arr_ref[:, 1]
self.mag_ref = arr_ref[:, 2]
(self.xpix_ref,
self.ypix_ref) = self.wcs_orig.all_world2pix(self.ra_ref,
self.dec_ref, 0)
(self.xpix_orig, self.ypix_orig) = self.pixel_positions
if (plot):
ref_aper = CircularAperture((self.xpix_ref, self.ypix_ref), r=4)
ref_aper.plot(color='red', lw=1.5, alpha=0.5)
plt.show()
def find_sources_via_segmentation(data,
sigma=3,
fwhm=2.0,
min_pix=5,
make_plot=False):
"""
"""
yd, xd = data.shape
# Let's define the background using boxes of ~50x50 pixels
nboxx = int(xd / 150)
nboxy = int(yd / 150)
bkg_estimator = MedianBackground()
bkg = Background2D(data, (nboxy, nboxx),
filter_size=(3, 3),
bkg_estimator=bkg_estimator)
data -= bkg.background # subtract the background
threshold = sigma * bkg.background_rms
#threshold = detect_threshold(data, nsigma=sigma)
gaussian_sigma = fwhm * gaussian_fwhm_to_sigma
kernel = Gaussian2DKernel(gaussian_sigma, x_size=3, y_size=3)
kernel.normalize(mode='integral')
segm = detect_sources(data,
threshold,
npixels=min_pix,
filter_kernel=kernel)
segm_deblend = deblend_sources(data,
segm,
npixels=min_pix,
filter_kernel=kernel,
nlevels=32,
contrast=0.001)
if make_plot:
norm = ImageNormalize(stretch=SqrtStretch())
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12.5))
ax1.imshow(data, origin='lower', cmap='Greys_r', norm=norm)
ax1.set_title('Data')
cmap = segm.make_cmap(seed=123)
ax2.imshow(segm, origin='lower', cmap=cmap, interpolation='nearest')
ax2.set_title('Segmentation Image')
ax3.imshow(segm_deblend,
origin='lower',
cmap=cmap,
interpolation='nearest')
ax3.set_title('Deblended Segmentation Image')
plt.show()
#plt.save('testing.jpg')
return data, segm_deblend, bkg
def convert_fits2png(fitsfile, png, scale="logZscale"):
image_file = get_pkg_data_filename(fitsfile)
image_data = fits.getdata(image_file, ext=0)
#print real_arrow
if scale == "linZscale":
norm = ImageNormalize(image_data,
interval=ZScaleInterval(contrast=0.1),
stretch=SqrtStretch())
im = plt.imshow(image_data, cmap='gray', norm=norm)
if scale == "logZscale":
new_image_data = -2.5 * np.log(abs(image_data))
norm = ImageNormalize(new_image_data - np.min(new_image_data),
interval=ZScaleInterval(contrast=0.25),
stretch=SqrtStretch())
im = plt.imshow(new_image_data - np.min(new_image_data),
aspect='auto',
cmap='gray')
plt.show()
im.savefig(png)
def plot_background_subtraction(background, background_clipped, est_background, star, est_background_star):
"""
This function ...
:param background:
:param background_clipped:
:param est_background:
:param star:
:param est_background_star:
:param peaks:
:return:
"""
norm = ImageNormalize(stretch=SqrtStretch())
# Determine the maximum value in the box and the minimum value for plotting
vmax = np.nanmax(background)
vmin = np.nanmin(background) if vmax <= 0 else 0.0
# Plot the data with the best-fit model
plt.figure(figsize=(20,3))
plt.subplot(1,5,1)
plt.imshow(background, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(0, background.shape[1]-1)
plt.ylim(0, background.shape[0]-1)
plt.title("Background")
plt.subplot(1,5,2)
plt.imshow(background_clipped, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(0, background_clipped.shape[1]-1)
plt.ylim(0, background_clipped.shape[0]-1)
plt.title("Sigma-clipped background")
plt.subplot(1,5,3)
plt.imshow(est_background, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(0, est_background.shape[1]-1)
plt.ylim(0, est_background.shape[0]-1)
plt.title("Estimated background")
plt.subplot(1,5,4)
plt.imshow(star, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(0, star.shape[1]-1)
plt.ylim(0, star.shape[0]-1)
plt.title("Star")
plt.subplot(1,5,5)
plt.imshow(star.data - est_background_star, origin='lower', interpolation="nearest", norm=norm, vmin=vmin, vmax=vmax, cmap="viridis")
plt.xlim(0, star.shape[1]-1)
plt.ylim(0, star.shape[0]-1)
plt.title("Star without background")
plt.show()
