def test_close(): mask = SkyMask.empty(nxpix=5, nypix=5) mask.data[1:-1, 1:-1] = 1 mask.data[2, 2] = 0 structure = Box2DKernel(3).array mask = mask.close(structure) assert mask.data.sum() == 9
def convolve(image, smooth=3, kernel='gauss'): if smooth is None and kernel in ['box', 'gauss']: return image if smooth is not None and not np.isscalar(smooth): raise ValueError("smooth= should be an integer - for more complex " "kernels, pass an array containing the kernel " "to the kernel= option") # The Astropy convolution doesn't treat +/-Inf values correctly yet, so we # convert to NaN here. image_fixed = np.array(image, dtype=float, copy=True) image_fixed[np.isinf(image)] = np.nan if kernel == 'gauss': if make_kernel is None: kernel = Gaussian2DKernel(smooth, x_size=smooth * 5, y_size=smooth * 5) else: kernel = make_kernel((smooth * 5, smooth * 5), smooth, 'gaussian') elif kernel == 'box': if make_kernel is None: kernel = Box2DKernel(smooth, x_size=smooth * 5, y_size=smooth * 5) else: kernel = make_kernel((smooth * 5, smooth * 5), smooth, 'boxcar') else: kernel = kernel return astropy_convolve(image, kernel, boundary='extend')
def test_convolve_nd(): energy_axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 4), unit="TeV", name="energy_true") geom = WcsGeom.create(binsz=0.02 * u.deg, width=4.0 * u.deg, axes=[energy_axis]) m = Map.from_geom(geom) m.fill_by_coord([[0.2, 0.4], [-0.1, 0.6], [0.5, 3.6]]) # TODO : build EnergyDependentTablePSF programmatically rather than using CTA 1DC IRF filename = ( "$GAMMAPY_DATA/cta-1dc/caldb/data/cta//1dc/bcf/South_z20_50h/irf_file.fits" ) psf = EnergyDependentMultiGaussPSF.read(filename, hdu="POINT SPREAD FUNCTION") table_psf = psf.to_energy_dependent_table_psf(theta=0.5 * u.deg) psf_kernel = PSFKernel.from_table_psf(table_psf, geom, max_radius=1 * u.deg) assert psf_kernel.psf_kernel_map.data.shape == (3, 101, 101) mc = m.convolve(psf_kernel) assert_allclose(mc.data.sum(axis=(1, 2)), [0, 1, 1], atol=1e-5) kernel_2d = Box2DKernel(3, mode="center") kernel_2d.normalize("peak") mc = m.convolve(kernel_2d.array) assert_allclose(mc.data[0, :, :].sum(), 0, atol=1e-5) assert_allclose(mc.data[1, :, :].sum(), 9, atol=1e-5)
def test_convolve_nd(): energy_axis = MapAxis.from_edges( np.logspace(-1.0, 1.0, 4), unit="TeV", name="energy_true" ) geom = WcsGeom.create(binsz=0.02 * u.deg, width=4.0 * u.deg, axes=[energy_axis]) m = Map.from_geom(geom) m.fill_by_coord([[0.2, 0.4], [-0.1, 0.6], [0.5, 3.6]]) psf = PSFMap.from_gauss(energy_axis, sigma=[0.1, 0.2, 0.3] * u.deg) psf_kernel = psf.get_psf_kernel(geom=geom, max_radius=1 * u.deg) assert psf_kernel.psf_kernel_map.data.shape == (3, 101, 101) mc = m.convolve(psf_kernel) assert_allclose(mc.data.sum(axis=(1, 2)), [0, 1, 1], atol=1e-5) kernel_2d = Box2DKernel(3, mode="center") kernel_2d.normalize("peak") mc = m.convolve(kernel_2d.array) assert_allclose(mc.data[0, :, :].sum(), 0, atol=1e-5) assert_allclose(mc.data[1, :, :].sum(), 9, atol=1e-5) kernel_2d = Gaussian2DKernel(15, mode="center") kernel_2d.normalize("peak") mc_full = m.convolve(kernel_2d.array, mode="full") mc_same = m.convolve(kernel_2d.array, mode="same") coords = [[0.2, 0.1, 0.4, 0.44, -1.3], [-0.1, -0.13, 0.6, 0.57, 0.91], [0.5, 0.5, 3.6, 3.6, 0.5]] values_full = mc_full.get_by_coord(coords) values_same = mc_same.get_by_coord(coords) assert mc_same.data.shape == (3, 200, 200) assert mc_full.data.shape == (3, 320, 320) assert_allclose(values_full, values_same, rtol=1e-5)
def convolve(image, smooth=3, kernel='gauss'): """ Convolve 2D image. Hacked from aplpy """ if smooth is None and isinstance(kernel, str) and kernel in ['box', 'gauss']: return image if smooth is not None and not np.isscalar(smooth): raise ValueError("smooth= should be an integer - for more complex " "kernels, pass an array containing the kernel " "to the kernel= option") # The Astropy convolution doesn't treat +/-Inf values correctly yet, so we # convert to NaN here. image_fixed = np.array(image, dtype=float, copy=True) image_fixed[np.isinf(image)] = np.nan if isinstance(kernel, str): if kernel == 'gauss': kernel = Gaussian2DKernel( smooth, x_size=smooth * 5, y_size=smooth * 5) elif kernel == 'box': kernel = Box2DKernel(smooth, x_size=smooth * 5, y_size=smooth * 5) else: raise ValueError("Unknown kernel: {0}".format(kernel)) return astropy_convolve(image, kernel, boundary='extend')
def laplacian(data, x, y, bw=5, w='default'): import numpy as np from astropy.convolution import convolve, Box2DKernel # https://docs.astropy.org/en/latest/api/astropy.convolution.Box2DKernel.html if (w == 'default'): w = data.shape[0] / data.shape[1] data_smth = convolve(data, Box2DKernel(bw)) # crop the edges bo = int(bw / 2 + 1) data_smth = data_smth[bo:-bo, bo:-bo] x = x[bo:-bo] y = y[bo:-bo] # Laplacian diff2 = np.gradient(np.gradient(data_smth, axis=0), axis=0) + \ w*w*np.gradient(np.gradient(data_smth, axis=1), axis=1) # NaN wrapping for edges instead of cropping # for ii in range(data.shape[0]): # for jj in range(data.shape[1]): # if (ii <= bo+1 or ii >= data.shape[0]-bo-1 or \ # jj <= bo+1 or jj >= data.shape[1]-bo-1): # diff2[ii][jj] = np.nan return diff2, x, y
def sub_bkg(self, verbose=True): # Here I subtract local sky background # Evaluate local sky backgroud within `halo_i` # Actually this should be estimated in larger cutuouts. # So make another cutout (larger)! from astropy.convolution import convolve, Box2DKernel from .image import extract_obj, seg_remove_cen_obj from sep import Background img_blur = convolve(abs(self.image), Box2DKernel(2)) img_objects, img_segmap = extract_obj(abs(img_blur), b=5, f=4, sigma=4.5, minarea=2, pixel_scale=self.pixel_scale, deblend_nthresh=32, deblend_cont=0.0001, sky_subtract=False, show_fig=False, verbose=False) bk = Background(self.image, img_segmap != 0) glbbck = bk.globalback self.globalback = glbbck if verbose: print('# Global background: ', glbbck) self.image -= glbbck
def surface(self, box_size=None): """Retrieve surface covered by unmasked pixels Parameters ---------- box_size : scalar or tuple, optional The edge of the map is cropped by the box_size if not None. Default is None. Returns ------- :class:`astropy.units.Quantity` Surface covered by unmasked pixels Notes ------- Default value for box_size in detect_sources is 5""" nvalid = np.prod(self.data.shape) if self.mask is not None: mask = self.mask if box_size is not None: box_kernel = Box2DKernel(box_size) mask = shrink_mask(mask, box_kernel) nvalid = np.sum(~mask) conversion = (u.pix.to(u.arcsec, equivalencies=self._pixel_scale)) ** 2 return nvalid * conversion * u.arcsec ** 2
def calculate_gradient(self,P,G,Z,smooth=False): """Calculate the gradient of any property. Deals with grid points that have no mass (that should'nt contribute to the gradient). :param P: A param.Param instance. .. warning:: This returns the gradient of the input field ... kind of ... sometimes """ method = 'astropy' if method == 'self_defined': # SELF-DEFINED METHOD # This should set any boundary grid points using first order gradients, and then set any interior grid points using the numpy gradient method Z[isnan(Z)] = 0. mask = (G.m<P.M_tol).reshape(P.G.ny,P.G.nx) good_values = (G.m>P.M_tol).reshape(P.G.ny,P.G.nx) Z = Z.reshape(P.G.ny,P.G.nx) dZdy_nice,dZdx_nice = gradient(Z,G.dy,G.dx) has_right = hstack([good_values[:,1:], zeros([P.G.ny,1],dtype=bool)])*good_values has_left = hstack([zeros([P.G.ny,1],dtype=bool), good_values[:,:-1]])*good_values has_down = vstack([good_values[1:], zeros([1,P.G.nx],dtype=bool)])*good_values has_up = vstack([zeros([1,P.G.nx],dtype=bool), good_values[:-1]])*good_values right_grad = hstack([(Z[:,1:] - Z[:,:-1])/G.dx, zeros([P.G.ny,1])]) up_grad = vstack([(Z[1:] - Z[:-1])/G.dy, zeros([1,P.G.nx])]) dZdx = zeros([P.G.ny,P.G.nx]) dZdx[has_right] = right_grad[has_right] dZdx[has_left] = right_grad[roll(has_left,-1,axis=1)] dZdx[has_right*has_left] = dZdx_nice[has_right*has_left] dZdy = zeros([P.G.ny,P.G.nx]) dZdy[has_up] = up_grad[has_up] dZdy[has_down] = up_grad[roll(has_down,-1,axis=0)] dZdy[has_up*has_down] = dZdy_nice[has_up*has_down] elif method == 'interp': # INTERPOLATION METHOD F = interp2d(G.X[good_values],G.Y[good_values],Z[good_values]) Z[mask] = F(G.X[mask],G.Y[mask]) Z = Z.reshape(P.G.ny,P.G.nx) dZdy,dZdx = gradient(Z,G.dy,G.dx) elif method == 'astropy': # see here: https://astropy.readthedocs.io/en/v0.3/convolution/index.html#using-convolve Z = ma.masked_where(G.m<P.M_tol,Z).reshape(P.G.ny,P.G.nx) # if smooth: # kernel = Box2DKernel(3) # smallest possible square kernel # Z = convolve(Z,kernel) dZdy,dZdx = gradient(Z,G.dy,G.dx) if smooth: # kernel = Gaussian2DKernel(1) # smallest possible gaussian - maybe something even smaller? kernel = Box2DKernel(3) # smallest possible square kernel dZdy = convolve(dZdy,kernel) dZdx = convolve(dZdx,kernel) grad = array([dZdx.flatten(), dZdy.flatten(), zeros_like(G.m)]).T return grad
def interped(self): if not hasattr(self, '_interped'): kernel = Box2DKernel(5) # Gaussian2DKernel(stddev=2.5) # crmask, _ = detect_cosmics(indat=np.ascontiguousarray( self.bkg_sub_img.filled(-9999)), inmask=self.bkg_sub_img.mask, sigclip=6., cleantype='medmask') self.bkg_sub_img.mask = np.ma.mask_or(self.bkg_sub_img.mask, crmask) self.bkg_sub_img.mask = np.ma.mask_or(self.bkg_sub_img.mask, np.isnan(self.bkg_sub_img)) print(('Masked pixels: ', np.sum(self.bkg_sub_img.mask))) img = self.bkg_sub_img.filled(np.nan) img_interp = interpolate_replace_nans(img, kernel, convolve=conv) while np.any(np.isnan(img_interp)): img_interp = interpolate_replace_nans(img_interp, kernel, convolve=conv) # clipped = sigma_clip(self.bkg_sub_img, # iters=5, sigma_upper=40).filled(np.nan) # img_interp = interpolate_replace_nans(img_interp, kernel) self._interped = img_interp return self._interped
def cv2d(data, x, y, bw=5, c1=0.001, c2=0.001, w='default'): import numpy as np from astropy.convolution import convolve, Box2DKernel # https://docs.astropy.org/en/latest/api/astropy.convolution.Box2DKernel.html if (w == 'default'): w = data.shape[0] / data.shape[1] data_smth = convolve(data, Box2DKernel(bw)) # crop the edges bo = int(bw / 2 + 1) data_smth = data_smth[bo:-bo, bo:-bo] x = x[bo:-bo] y = y[bo:-bo] dE = np.gradient(data_smth, axis=0) dT = np.gradient(data_smth, axis=1) * w d2E = np.gradient(np.gradient(data_smth, axis=0), axis=0) d2T = np.gradient(np.gradient(data_smth, axis=1), axis=1) * w * w dEdT = np.gradient(np.gradient(data_smth, axis=1), axis=0) * w # 2D curvature - https://doi.org/10.1063/1.3585113 cv2d = ((1 + c1*dE**2)*c2*d2T - 2*c1*c2*dE*dT*dEdT + (1 + c2*dT**2)*c1*d2E)/ \ (1 + c1*dE**2 + c2*dT**2)**1.5 # NaN wrapping for edges instead of cropping # for ii in range(data.shape[0]): # for jj in range(data.shape[1]): # if (ii <= bo+1 or ii >= data.shape[0]-bo-1 or \ # jj <= bo+1 or jj >= data.shape[1]-bo-1): # diff2[ii][jj] = np.nan return cv2d, x, y
def identify_objects(image_data, nsigma, min_area, deb_n_thresh, deb_cont, param_dict): ''' This function performs source identification and generates a segmentation map, which is then used for masking the sources. :param image_data: provide the image data, which is a mxn numpy nd array. e.g., fits.getdata('image_file_name') :param nsigma: source detection significance. :param min_area: minimum area to be considered as a source :param deb_n_thresh: number of threshold values for deblending routine. e.g., 32, 64 etc. :param deb_cont: deblend minimum contrast ratio (see source extraction or SEP python page). :param param_dict: a dictionary containing the 'sep_filter_kwarg' = filter keyword argument, which can be a 'tophat', 'gauss', or 'boxcar' 'sep_filter_size' = the 'size' of the filter. In case of gaussian, it is the FWHM of the gaussian. For tophat, it is the radius of the tophat filter. For boxcar, it is the side length of the 2D Box. :return: objects: a numpy array of the objects, ordered as per their segmentation values in the segmap. segmap: a segmentation map, where each source is marked with unique source identification number. ''' # Note, this whole routine uses a Python-based source identification module named SEP (Barbary et al., 2016) # Unpack the filter keyword and its size from the parameter dictionary. filter_kwarg = param_dict['sep_filter_kwarg'] filter_size = float(param_dict['sep_filter_size']) # Look at the SEP webpage, this is suggested for working of SEP. byte_swaped_data = image_data.byteswap().newbyteorder() # SEP estimates a global background. global_bkg = sep.Background(byte_swaped_data) # background subtracted data = original data - estimated global background. bkg_subtracted = byte_swaped_data - global_bkg # In the following block, we check for the user's choice of filter and its size. # We define a kernel based on their choice. if filter_kwarg.lower() not in ['tophat', 'gauss', 'boxcar']: warnings.warn( 'The filter %s is not supported as of yet, defaulting to tophat of radius 5' ) source_kernel = Tophat2DKernel(5) elif filter_kwarg.lower() == 'tophat': source_kernel = Tophat2DKernel(filter_size) elif filter_kwarg.lower() == 'gauss': _gauss_sigma = gaussian_fwhm_to_sigma(filter_size) source_kernel = Gaussian2DKernel(_gauss_sigma) elif filter_kwarg.lower() == 'boxcar': source_kernel = Box2DKernel(filter_size) # Object detection and Segmentation map generataion. objects, segmap = sep.extract(bkg_subtracted, nsigma, err=global_bkg.globalrms, minarea=min_area, deblend_nthresh=deb_n_thresh, deblend_cont=deb_cont, segmentation_map=True, filter_kernel=source_kernel.array) return objects, segmap
def nb_cogphot(nbima, nbvar, xc, yc, maxrad=15, growthlim=1.025, plots=False): from photutils import CircularAperture, CircularAnnulus from photutils import aperture_photometry from astropy.stats import sigma_clipped_stats as scl from astropy.convolution import convolve, Box2DKernel rad = np.arange(1, maxrad + 1) phot = np.zeros_like(rad, dtype=float) photerr = np.zeros_like(rad, dtype=float) growth = np.zeros_like(rad, dtype=float) skyaper = CircularAnnulus((xc - 1, yc - 1), r_in=maxrad, r_out=np.max([1.5 * maxrad, 20])) skymask = skyaper.to_mask(method='center') skydata = skymask.multiply(nbima)[skymask.data > 0] bkg_avg, bkg_med, _ = scl(skydata) for ii, r in enumerate(rad): aper = CircularAperture((xc - 1, yc - 1), r=r) phot[ii] = (aperture_photometry( nbima, aper))['aperture_sum'][0] - bkg_med * aper.area photerr[ii] = np.sqrt((aperture_photometry(nbvar, aper))['aperture_sum'][0]) if ii < 3: growth[ii] = 100 else: growth[ii] = phot[ii] / phot[ii - 1] rlim = np.argmin(growth > growthlim) - 1 fluxarr = phot[rlim] errarr = photerr[rlim] radarr = rad[rlim] if plots: fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(5, 5)) ax.imshow(convolve(nbima, Box2DKernel(5)), vmin=-2, vmax=30, origin='lower') #ax.imshow(tmpnbima, vmin=-2, vmax=30, origin='lower') circ = plt.Circle((xc - 1, yc - 1), rad[rlim], color='r', fill=False, lw=3) ax.add_artist(circ) ax.set_xlim(xc - 50, xc + 50) ax.set_ylim(yc - 50, yc + 50) plt.show() plt.plot(rad, phot) plt.show() return fluxarr, errarr, radarr
def smooth_iter(a, boxsize, n, lo, hi): a = chop_once(a, lo, hi) box_2D_kernel = Box2DKernel(boxsize) for i in range(n): a = convolve(a, box_2D_kernel) a = chop_once(a, lo, hi) return a
def mask_out_contam(self, sigma=4.5, deblend_cont=0.0001, blowup=True, show_fig=True, verbose=True): """ Mask out contamination in the cutout of star. Contamination may be stars, galaxies or artifacts. This function uses ``sep`` to identify and mask contamination. ** DO THIS AFTER CENTERIZING! ** Parameters: sigma (float): The sigma in ``SExtractor``. Default is 4.5. deblend_cont (float): Deblending parameter. Default is 0.0005. blowup (bool): Whether blow up the segmentation mask by convolving a 1.5 pixel Gaussian kernel. show_fig (bool): Whether show the figure. verbose (bool): Whether print out results. Returns: None """ from astropy.convolution import convolve, Box2DKernel from .utils import extract_obj, seg_remove_cen_obj img_blur = convolve(abs(self.image), Box2DKernel(2)) img_objects, img_segmap = extract_obj(abs(img_blur), b=10, f=3, sigma=sigma, minarea=1, pixel_scale=self.pixel_scale, deblend_nthresh=72, deblend_cont=deblend_cont, flux_aper=None, sky_subtract=True, show_fig=show_fig, verbose=verbose) # remove central object from segmap cen_obj = img_objects[img_segmap[img_segmap.shape[1] // 2, img_segmap.shape[0] // 2] - 1] img_segmap = seg_remove_cen_obj(img_segmap) detect_mask = (img_segmap != 0).astype(float) if blowup is True: from astropy.convolution import convolve, Gaussian2DKernel cv = convolve(1e3 * detect_mask / np.nansum(detect_mask), Gaussian2DKernel(1.5)) detect_mask = (cv > 0.5).astype(float) self.mask = detect_mask #imgcp = copy.copy(self.image) #imgcp[detect_mask.astype(bool)] = cval #self.image = imgcp # Shift mask will be very horrible!!! Hence we still don't use self.mask. # Instead we directly mask out on the image. return
def smooth_map(map, mask, smooth_kernal, smooth_scale, nan_flag): map[mask==0] = nan_flag if smooth_kernal=='box': kernel = Box2DKernel(smooth_scale) if smooth_kernal=='tophat': kernel = Tophat2DKernel(smooth_scale/2) return convolution.convolve_fft(map, kernel, normalize_kernel=True, ignore_edge_zeros=True, interpolate_nan=True)
def smooth_tidal_feature(feat,box_size): ''' Smoothing the input image using a Boxcar filter. :param feat: input image to be smoothed :param box_size: size of the boxcar filter :return: smoothed image ''' from astropy.convolution import Box2DKernel, convolve #import modules kernel = Box2DKernel(box_size) # initiate the kernel convolved_feature = convolve(feat,kernel) #convolve the image with the kernel return convolved_feature # return the smoothed feature.
def smooth_corr(corr, statistics, nbins=9, width=3): nstats = len(statistics) kernel = Box2DKernel(width=width) corr_convolved = np.zeros_like(corr) for i in range(nstats): for j in range(nstats): corr_sub = corr[i * nbins:(i + 1) * nbins, j * nbins:(j + 1) * nbins] corr_sub_convolved = convolve(corr_sub, kernel, boundary='extend') corr_convolved[i * nbins:(i + 1) * nbins, j * nbins:(j + 1) * nbins] = corr_sub_convolved return corr_convolved
def kappag_map_bin(N2d, mask, fraction, z_l1, z_l2, z_s, cosmo, smooth_kernal, smooth_scale): """ Calculate kappa_g map for a lens redshift bin from z_l1 to z_l2 and a source redshift of z_s. """ c_light = 3.0e5 if smooth_kernal == 'box': kernel = Box2DKernel(smooth_scale) if smooth_kernal == 'tophat': kernel = Tophat2DKernel(smooth_scale / 2) # make 2D galaxy over-density maps ######## if fraction == None: fraction = mask.copy() N2d = N2d * mask area_fraction = np.sum(fraction[mask == 1]) / len(fraction[mask == 1]) dN2d = N2d * 0.0 ave = np.mean(N2d[mask == 1]) / area_fraction dN2d[mask == 1] = (N2d[mask == 1] - (ave * fraction[mask == 1])) / (ave * fraction[mask == 1]) # print(ave) # make 2D kappa_g maps ######## zl1_cd = cd.comoving_distance(z_l1, **cosmo) # Mpc zl2_cd = cd.comoving_distance(z_l2, **cosmo) # Mpc zs_cd = cd.comoving_distance(z_s, **cosmo) # Mpc delta_cd = zl2_cd - zl1_cd const = ((100. * cosmo['h'])**2 * cosmo['omega_M_0']) * (3 / 2.) * (1 / c_light**2) integ = lens_weight(np.array([z_l1, z_l2]), z_s, cosmo)[0] temp_dN = dN2d * 1.0 temp_dN[mask == 0] = 'nan' kg = const * delta_cd * integ * convolution.convolve_fft( temp_dN, kernel, normalize_kernel=True, ignore_edge_zeros=True, interpolate_nan=True) kg[mask == 0] = 0 return kg
def boxcar2D_smooth(data, scale=90, mask=False): dims = _get_dims(data) box2d_kernel = Box2DKernel(scale).array sc_convolve = lambda data: convolve(data, box2d_kernel, mode='same') if mask: data_masked = data.where(data[mask_vars[dims]]) else: data_masked = data.fillna(0.) return xr.apply_ufunc(sc_convolve, data_masked, vectorize=True, dask='parallelized', input_core_dims=[dims], output_core_dims=[dims], output_dtypes=[data.dtype])
def mask_contam(self, method='hscmask', blowup=True, show_fig=True, verbose=True): if method == 'hscmask': from unagi import mask from .image import mask_remove_cen_obj detect_mask = mask.Mask( self.hscmask, data_release='s18a').extract('DETECTED').astype(float) detect_mask = mask_remove_cen_obj(detect_mask) if blowup is True: from astropy.convolution import convolve, Gaussian2DKernel cv = convolve(detect_mask, Gaussian2DKernel(1.5)) detect_mask = (cv > 0.1).astype(float) self.mask = detect_mask return else: # method = 'sep' from astropy.convolution import convolve, Box2DKernel from .image import extract_obj, seg_remove_cen_obj img_blur = convolve(abs(self.image), Box2DKernel(2)) img_objects, img_segmap = extract_obj(abs(img_blur), b=5, f=4, sigma=4.5, minarea=2, pixel_scale=0.168, deblend_nthresh=32, deblend_cont=0.0001, sky_subtract=False, show_fig=show_fig, verbose=verbose) # remove central object from segmap img_segmap = seg_remove_cen_obj(img_segmap) detect_mask = (img_segmap != 0).astype(float) if blowup is True: from astropy.convolution import convolve, Gaussian2DKernel cv = convolve(detect_mask, Gaussian2DKernel(1.5)) detect_mask = (cv > 0.1).astype(float) self.mask = detect_mask return
def smooth(data, box_width=15): """Create a smoothed version of the 2D input data Parameters ---------- data : numpy.ndarray 2D array of data to be smoothed box_width : int Width of the smoothing box, in pixels Returns ------- smoothed : numpy.ndarray A smoothed version of ``data`` """ smoothing_kernel = Box2DKernel(box_width) smoothed = convolve(data, smoothing_kernel, boundary='fill', fill_value=np.nanmedian(data), nan_treatment='interpolate') return smoothed
def image(url,position,size): image_file = download_file(url, cache=True, show_progress='True') hdu_lists = fits.open(image_file, memmap='True') hdu_lists.info() image_data = hdu_lists[0].data print( "Above is the list of Header Data Unit of FITS file. \nWe will be working on PRIMARY Block. \nThe shape of the array is as below:") print((type(image_data))) print(image_data.shape) hdu_lists.close() print("Viewing Image..\nStatistics of the Image: ") plt.imshow(image_data, cmap='gray') plt.colorbar() plt.savefig('Original_Image.png') plt.show() print('Min:', np.min(image_data)) print('Max:', np.max(image_data)) print('Mean:', np.mean(image_data)) print('Stdev:', np.std(image_data)) crop = Cutout2D(image_data, position, size) plt.imshow(crop.data, origin='upper', cmap='gray') plt.savefig('Cropped_Image.png') plt.show() gauss_kernel = Gaussian2DKernel(0.5) smoothed_data_gauss = convolve(crop.data, gauss_kernel) plt.imshow(smoothed_data_gauss, cmap='gray') plt.savefig('Gaussian Smoothing Filter') plt.show() tophat_kernel = Tophat2DKernel(2) smoothed_data_tophat = convolve(crop.data, tophat_kernel) plt.imshow(smoothed_data_tophat, cmap='gray') plt.savefig('Tophat Smoothing Filter') plt.show() box_kernel = Box2DKernel(5) smoothed_data_box = convolve(crop.data, box_kernel) plt.imshow(smoothed_data_box, cmap='gray') plt.savefig('Box_kernel Smoothing Filter') plt.show()
def kappag_map_bin_nofz2(N2d, mask, z_l1, z_l2, nofz_s, cosmo, smooth_kernal, smooth_scale): """ Calculate kappa_g map for a lens redshift bin with nofz_l and a source redshift with nofz_s. nofz_s are arrays that are normalized to 1 and with 200 bins from 0 to 1.8. """ c_light = 3.0e5 if smooth_kernal == 'box': kernel = Box2DKernel(smooth_scale) if smooth_kernal == 'tophat': kernel = Tophat2DKernel(smooth_scale / 2) # make 2D galaxy over-density maps ######## dN2d = N2d * 0.0 ave = np.mean(N2d[mask == 1]) dN2d[mask == 1] = (N2d[mask == 1] - ave) / ave # make 2D kappa_g maps ######## const = ((100. * cosmo['h'])**2 * cosmo['omega_M_0']) * (3 / 2.) * (1 / c_light**2) integ = lens_weight_nofz2(z_l1, z_l2, nofz_s, cosmo) temp_dN = dN2d * 1.0 temp_dN[mask == 0] = 'nan' kg = const * integ * convolution.convolve_fft(temp_dN, kernel, normalize_kernel=True, ignore_edge_zeros=True, interpolate_nan=True) kg[mask == 0] = 0 return kg
def mask_out_contam(self, blowup=True, show_fig=True, verbose=True): from astropy.convolution import convolve, Box2DKernel from .utils import extract_obj, seg_remove_cen_obj img_blur = convolve(abs(self.image), Box2DKernel(2)) img_objects, img_segmap = extract_obj(abs(img_blur), b=5, f=4, sigma=4.5, minarea=2, pixel_scale=self.pixel_scale, deblend_nthresh=32, deblend_cont=0.0005, sky_subtract=False, show_fig=show_fig, verbose=verbose) # remove central object from segmap img_segmap = seg_remove_cen_obj(img_segmap) detect_mask = (img_segmap != 0).astype(float) if blowup is True: from astropy.convolution import convolve, Gaussian2DKernel cv = convolve(detect_mask, Gaussian2DKernel(1.5)) detect_mask = (cv > 0.1).astype(float) self.mask = detect_mask return
def interped(self): if not hasattr(self, "_interped"): kernel = Box2DKernel(5) # Gaussian2DKernel(stddev=2.5) # crmask, _ = detect_cosmics( indat=np.ascontiguousarray(self.bkg_sub_img.filled(-9999)), inmask=self.bkg_sub_img.mask, sigclip=6.0, cleantype="medmask", ) self.bkg_sub_img.mask = np.ma.mask_or(self.bkg_sub_img.mask, crmask) self.bkg_sub_img.mask = np.ma.mask_or(self.bkg_sub_img.mask, np.isnan(self.bkg_sub_img)) img = self.bkg_sub_img.filled(np.nan) img_interp = interpolate_replace_nans(img, kernel, convolve=conv) while np.any(np.isnan(img_interp)): img_interp = interpolate_replace_nans(img_interp, kernel, convolve=conv) self._interped = img_interp return self._interped
def sub_bkg(self, sigma=4.5, deblend_cont=0.0001, verbose=True): """ Subtract the locally-measured background of ``Star`` object. The sky is measured by masking out objects using ``sep``. Be cautious and be aware what you do when using this function. Parameters: sigma (float): The sigma in ``SExtractor``. deblend_cont (float): Deblending parameter. verbose (bool): Whether print out background value. Returns: None """ # Actually this should be estimated in larger cutuouts. # So make another cutout (larger)! from astropy.convolution import convolve, Box2DKernel from .image import extract_obj, seg_remove_cen_obj from sep import Background img_blur = convolve(abs(self.image), Box2DKernel(2)) img_objects, img_segmap = extract_obj(abs(img_blur), b=10, f=4, sigma=sigma, minarea=2, pixel_scale=self.pixel_scale, deblend_nthresh=32, deblend_cont=deblend_cont, sky_subtract=False, show_fig=False, verbose=False) bk = Background(self.image, img_segmap != 0) glbbck = bk.globalback self.globalback = glbbck if verbose: print('# Global background: ', glbbck) self.image -= glbbck
def makeplot(filename, data, head, verbose=True, thumbnail=False, lims=None, dpi=1000): """ Produce the plots. Will open an interactive matplotlib plot for inspection. After closing the image will be saved to a PNG. Args: filename: Name of the file (str). data: Astropy array of containing selected channel image. head: Astropy fits header. verbose: Verbosity (bool). thumbnail: EXPERIMENTAL -- Convolve the image with a 2D box and produce image (bool). lims: The vmin and vmax of the image. Returns: None """ # Make thumbnail image - work in progress if thumbnail: if verbose: print('Making thumbnail') kernel = Box2DKernel(head['NAXIS1'] / 1000) astropy_conv = convolve_fft(data, kernel, allow_huge=True) image = np.power(astropy_conv, 2) if lims is None: rms = np.nanstd(image) proj = WCS(head).dropaxis(2).dropaxis(2) fig = plt.figure() fig.set_size_inches(8, 8) ax = fig.add_subplot(111, projection=proj) if lims is None: im = ax.imshow(image, origin='lower', cmap='cubehelix_r', vmax=10 * rms) if lims is not None: im = ax.imshow(image, origin='lower', cmap='cubehelix_r', vmin=lims[0], vmax=lims[1]) lon = ax.coords[0] lon.set_ticklabel(size=8) lon.set_axislabel(r'$RA$') lon.display_minor_ticks(True) lat = ax.coords[1] lat.set_ticklabel(size=8) lat.display_minor_ticks(True) lat.set_axislabel(r'$DEC$') c = plt.colorbar(im) c.set_label('$S^2$') c.ax.tick_params(length=3) plt.title('Thumbnail') plt.show() outfile = re.sub('.fits', '.thumbnail.png', filename) fig.savefig(outfile, dpi=dpi) if verbose: print('Saved to', outfile) # Make main image if verbose: print('Making plot') image = np.power(data, 2) if lims is None: rms = np.nanstd(image) proj = WCS(head).dropaxis(2).dropaxis(2) print() fig = plt.figure() fig.set_size_inches(8, 8) ax = fig.add_subplot(111, projection=proj) if lims is None: im = ax.imshow(image, origin='lower', cmap='cubehelix_r', vmax=10 * rms) if lims is not None: im = ax.imshow(image, origin='lower', cmap='cubehelix_r', vmin=lims[0], vmax=lims[1]) lon = ax.coords[0] lon.set_ticklabel(size=8) lon.set_axislabel(head['CTYPE1']) lon.display_minor_ticks(True) lat = ax.coords[1] lat.set_ticklabel(size=8) lat.display_minor_ticks(True) lat.set_axislabel(head['CTYPE2']) c = plt.colorbar(im) c.set_label('$S^2$') c.ax.tick_params(length=3) plt.title('Full image') plt.show() outfile = re.sub('.fits', '.medimage.png', filename) fig.savefig(outfile, dpi=dpi) if verbose: print('Saved to', outfile)
# peak minimum S/N, minimum width in channels, maximum difference from SAA velocity, maximum difference from SAA FWHM, maximum separation in units FWHM tol = [3.0, 1.0, 3.0, 2.0, 0.5] # Spectral resolution #specres = 0.07 RG = False nRG = 1. TS = False verb = True fittype = 'gaussian' njobs = 1 cube = SpectralCube.read('n2h+10_37.fits').with_spectral_unit(u.km / u.s) # smooth and downsample for first-round fitting # (smoothing is maybe optional..) dscube = cube.spatial_smooth(Box2DKernel(2))[:, ::2, ::2] dscube.write('n2h+10_37_ds.fits', overwrite=True) # run the full scouse suite on the downsampled data if os.path.exists(datadirectory + filename + '/stage_1/s1.scousepy'): s = scouse(outputdir=datadirectory, filename=filename, fittype=fittype, datadirectory=datadirectory) s.load_stage_1(datadirectory + filename + '/stage_1/s1.scousepy') s.load_cube(fitsfile=filename + ".fits") else: s = scouse.stage_1(filename, datadirectory, wsaa, ppv_vol=ppv_vol,
def smoothTaData(self, ALEXIgeodict): ALEXILatRes = ALEXIgeodict['ALEXI_LatRes'] ALEXILonRes = ALEXIgeodict['ALEXI_LonRes'] sceneID = self.sceneID scene = self.scene outFN = os.path.join(self.resultsBase, scene, '%s_Ta.tif' % sceneID[:-5]) inProj4 = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' # =======================convert fine TA to coarse resolution========= outfile = os.path.join(self.resultsBase, scene, 'Ta_DisALEXI.tif') coarseFile = os.path.join(self.resultsBase, scene, 'TaCoarse.tif') coarse2fineFile = os.path.join(self.resultsBase, scene, 'TaCoarse2Fine.tif') if not os.path.exists(outFN): print 'get->Ta' # get mask from Landsat LAI ls = GeoTIFF(outfile) sceneDir = os.path.join(self.satscene_path, 'CF_MASK') maskFN = os.path.join(sceneDir, '%s_Mask.tif' % sceneID) g = gdal.Open(maskFN, GA_ReadOnly) cfmask = g.ReadAsArray() g = None # =============find Average Ta====================================== COMMENTED FOR TESTING in_ds = gdal.Open(outfile) coarseds = gdal.Translate(coarseFile, in_ds, options=gdal.TranslateOptions( resampleAlg='average', xRes=400, yRes=400)) fineds = gdal.Warp(outFN, coarseds, options=gdal.WarpOptions(resampleAlg='average', height=ls.nrow, width=ls.ncol)) coarseds = None # ========smooth Ta data======================================== ta = fineds.ReadAsArray() fineRes = ls.Lat[1, 0] - ls.Lat[0, 0] coarseRes = ALEXILatRes course2fineRatio = coarseRes**2 / fineRes**2 rid2 = int(np.sqrt(course2fineRatio)) # gauss_kernal = Gaussian2DKernel(rid2) box_kernal = Box2DKernel(rid2) ta = convolve_fft(ta, box_kernal, allow_huge=True) fineds.GetRasterBand(1).WriteArray(ta) fineds = None ulx = ls.ulx uly = ls.uly delx = ls.delx dely = -ls.dely fineRes = ls.Lat[1, 0] - ls.Lat[0, 0] coarseRes = ALEXILatRes inUL = [ulx, uly] inRes = [delx, dely] # Ta = interp_ta(ta,coarseRes,fineRes)-273.16 # Ta = ta - 273.16 # FOR TESTING!! Ta = ta outFormat = gdal.GDT_Float32 writeArray2Tiff(Ta, inRes, inUL, ls.proj4, outFN, outFormat) os.remove(coarseFile)