def sim_matrix_find_segments(arr, length1=10, length2=10): length1 = max(length1, 1) length2 = max(length2, 2) length1 = min(length1, (len(arr) / 2) - 1) length2 = min(length2, (len(arr) / 2) - 1) k1 = range(1, length1) + range(length1, 0, -1) k2 = range(1, length2) + range(length2 - 1, 0, -1) k1 = array(k1, Float32) / sqrt(sum(k1)) #print k1 for i in range(0, len(k2) / 2): #for i in range(0, len(k2), 2): k2[i] = -k2[i] #print k1, type(k1) #print k2, type(k2) k2 = array(k2) #print "f**k signal.sepfir2d" #print arr res1 = signal.sepfir2d(arr, k1, k1) #print res1 res2 = signal.sepfir2d(res1, k2, k2) #print shape(res2) return abs(res2)
def filter(self): # img_average = numpy.average(self.training_set[0].image_data) image = self.training_set[0].image_data derfilt = numpy.array([1.0,-2,1.0],numpy.float32) ck = signal.cspline2d(image,8.0) deriv = signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt) print_image(deriv, 'bsplines.png') for std in [1,2,4,8,16,32,64,128]: filtered_img = ndimage.median_filter(image, std) print_image(filtered_img, 'median_{}.png'.format(std))
def test_sepfir2d_invalid_image(): filt = np.array([1.0, 2.0, 4.0, 2.0, 1.0]) image = np.random.rand(8, 8) # Image must be 2 dimensional with pytest.raises(ValueError, match="object too deep"): signal.sepfir2d(image.reshape(4, 4, 4), filt, filt) with pytest.raises(ValueError, match="object of too small depth"): signal.sepfir2d(image[0], filt, filt)
def sobel3x3_separable(image): sobel_c = array([-1.,0.,1.]) sobel_r = array([1.,2.,1.]) imgx = signal.sepfir2d(image, sobel_c, sobel_r) imgy = signal.sepfir2d(image, sobel_r, sobel_c) mag = sqrt(imgx**2 + imgy**2) + 1e-16 return (mag, imgx, imgy)
def show_angle(angle,power): ARROW_STEP = 40 kernel = np.ones((ARROW_STEP,ARROW_STEP)) rowFilter = gaussian(ARROW_STEP,ARROW_STEP/5) colFilter = rowFilter gb180 = cmt.get_cmap('gb180') #X = np.arange(0,angle.shape(-1),ARROW_STEP) #Y = np.arange(0,angle.shape(-2),ARROW_STEP) x = np.matrix(np.arange(ARROW_STEP/2,angle.shape[-1],ARROW_STEP)) y = np.transpose(np.matrix(np.arange(ARROW_STEP/2,angle.shape[-2],ARROW_STEP))) X = np.array((0*y+1)*x) Y = np.array(y*(0*x+1)) #u = convolve2d(sin(angle),kernel,mode='same') #v = convolve2d(cos(angle),kernel,mode='same') #p = convolve2d(power,kernel,mode='same') u = sepfir2d(np.sin(angle),rowFilter,colFilter) v = sepfir2d(np.cos(angle),rowFilter,colFilter) p = sepfir2d(power,rowFilter,colFilter) U = u[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP]*p[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP] V = v[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP]*p[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP] #U = sin(angle[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP])*(power[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP]) #V = cos(angle[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP])*(power[ARROW_STEP/2::ARROW_STEP,ARROW_STEP/2::ARROW_STEP]) #X = X[(power[::ARROW_STEP,::ARROW_STEP]>.016)] #Y = Y[(power[::ARROW_STEP,::ARROW_STEP]>.016)] #U = U[(power[::ARROW_STEP,::ARROW_STEP]>.016)] #V = V[(power[::ARROW_STEP,::ARROW_STEP]>.016)] ua = ARROW_STEP/1.5*np.nansum(np.sin(angle)*power)/np.nansum(power) va = -ARROW_STEP/1.5*np.nansum(np.cos(angle)*power)/np.nansum(power) xc, yc = angle.shape[-1]/2, angle.shape[-2]/2 pylab.imshow(angle,cmap=gb180) #pylab.imshow(angle,cmap='hsv') pylab.quiver(X,Y,U,V,pivot='middle',color='w',headwidth=1,headlength=0) pylab.arrow(xc,yc,ua,va,color='w',linewidth=2) pylab.arrow(xc,yc,-ua,-va,color='w',linewidth=2) ax=pylab.gca() ax.set_axis_off() pylab.show() A = np.arctan2(-ua,va) return A
def dog_sep_convolution(self, img, k, cell_type, originating_function="filter", force_homebrew=False, mode="full"): ''' Wrapper for separated convolution for DoG kernels in FoCal, enables use of NumPy based sepfir2d. img => the image to convolve k => 1D kernels to use cell_type => ganglion cell type, useful for sampling resolution numbers originating_function => if "filter": use special sampling resolution, else: use every pixel force_hombrew => if True: use my code, else: NumPy's mode => "full" all image convolution, else only valid ''' if originating_function == "filter": row_keep, col_keep = self.get_subsample_keepers(cell_type) else: row_keep, col_keep = 1, 1 if not force_homebrew: # has a problem with images smaller than kernel right_img = sepfir2d(img.copy(), k[0], k[1]) left_img = sepfir2d(img.copy(), k[2], k[3]) else: right_img = self.sep_convolution(img, k[0], k[1], col_keep=col_keep, row_keep=row_keep, mode=mode) left_img = self.sep_convolution(img, k[2], k[3], col_keep=col_keep, row_keep=row_keep, mode=mode) conv_img = left_img + right_img if not force_homebrew and originating_function == "filter": conv_img = self.subsample(conv_img, cell_type) return conv_img
def impyramid_next_level(_img, filter='burt_adelson'): """ IMPYRAMID_NEXT_LEVEL: computes the next level in a Gaussian pyramidal decomposition. :param _img: numpy.ndarray A grey-level image (_img.ndim == 2) :param filter: string Which filter to use in removing high frequencies: - burt_adelson: [-0.125, 0.250, 0.375, 0.250, -0.125] - custom1: [0.125, 0.275, 0.375, 0.125] (Gaussian, sigma=0.866) :return: numpy.ndarray The new level in the pyramid, an image half the size of the original. """ assert (_img.ndim == 2) # classical low-pass filter, with the kernel from Burt & Adelson (1983): if filter == 'burt_adelson': a = 0.375 krn = [1 / 4 - a / 2, 1 / 4, a, 1 / 4, 1 / 4 - a / 2] res = (_img - sepfir2d(_img, krn, krn))[::2, ::2] elif filter == 'custom1': res = gaussian_filter(_img, sigma=0.866)[::2, ::2] return res
def impyramid_next_level(_img, filter='burt_adelson'): """ IMPYRAMID_NEXT_LEVEL: computes the next level in a Gaussian pyramidal decomposition. :param _img: numpy.ndarray A grey-level image (_img.ndim == 2) :param filter: string Which filter to use in removing high frequencies: - burt_adelson: [-0.125, 0.250, 0.375, 0.250, -0.125] - custom1: [0.125, 0.275, 0.375, 0.125] (Gaussian, sigma=0.866) :return: numpy.ndarray The new level in the pyramid, an image half the size of the original. """ assert (_img.ndim == 2) # classical low-pass filter, with the kernel from Burt & Adelson (1983): if filter == 'burt_adelson': a = 0.375 krn = [1/4 - a/2, 1/4, a, 1/4, 1/4 - a/2] res = (_img - sepfir2d(_img, krn, krn))[::2, ::2] elif filter == 'custom1': res = gaussian_filter(_img, sigma=0.866)[::2, ::2] return res
def test_sepfir2d_invalid_filter(): filt = np.array([1.0, 2.0, 4.0, 2.0, 1.0]) image = np.random.rand(7, 9) # No error for odd lengths signal.sepfir2d(image, filt, filt[2:]) # Row or column filter must be odd with pytest.raises(ValueError, match="odd length"): signal.sepfir2d(image, filt, filt[1:]) with pytest.raises(ValueError, match="odd length"): signal.sepfir2d(image, filt[1:], filt) # Filters must be 1-dimensional with pytest.raises(ValueError, match="object too deep"): signal.sepfir2d(image, filt.reshape(1, -1), filt) with pytest.raises(ValueError, match="object too deep"): signal.sepfir2d(image, filt, filt.reshape(1, -1))
def themis_plot_phasespace_contour(vlsvReader, cellID, plane_x=np.array([1., 0, 0]), plane_y=np.array([0, 0, 1.]), smooth=False, xlabel="Vx", ylabel="Vy"): ''' Plots a contour view of phasespace, as seen by a themis detector, at the given cellID :param vlsvReader: Some VlsvReader class with a file open :type vlsvReader: :class:`vlsvfile.VlsvReader` :param cellid: The cell id where the distribution is supposet to be sampled NOTE: The cell id must have a velocity distribution! :param plane_x and plane_y: x and y direction of the resulting plot plane ''' matrix = simulation_to_observation_frame(plane_x, plane_y) angles, energies, vmin, vmax, values = themis_observation_from_file( vlsvReader=vlsvReader, cellid=cellID, matrix=matrix) if vmin == 0: vmin = 1e-15 if vmax <= vmin: vmax = vmin * 10. # Regrid into cartesian space, 256x256: grid_r, grid_theta = np.meshgrid(energies, angles) grid_x = -grid_r * np.sin( grid_theta) # turn radial grid points into (x, y) grid_y = -grid_r * np.cos( grid_theta ) # (the - comes from detector-look-direction vs particle-movement-direction) hires_x = np.linspace(-2200, 2200, 256) hires_y = np.linspace(-2200, 2200, 256) xi, yi = np.meshgrid(hires_x, hires_y) vi = griddata((grid_x.flatten(), grid_y.flatten()), values.flatten(), (xi, yi)) if smooth: # Convolve the grid data with a gaussian kernel blurkernel = np.exp( -.17 * np.power([6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6], 2)) vi = sepfir2d(vi, blurkernel, blurkernel) / 4.2983098411528502 fig, ax = pl.subplots(figsize=(12, 10)) ax.set_aspect('equal') ax.set_title("Phasespace at cell " + str(cellID)) ax.set_xlabel(xlabel + " (km/s)") ax.set_ylabel(ylabel + " (km/s)") cax = ax.contour(xi, yi, vi.T, levels=np.logspace(np.log10(vmin), np.log10(vmax), 20), norm=matplotlib.colors.LogNorm(vmin=vmin, vmax=vmax)) ax.grid(True) fig.colorbar(cax) pl.show()
def themis_plot_phasespace_helistyle(vlsvReader, cellID, plane_x=np.array([1.,0,0]), plane_y=np.array([0,0,1.]), smooth=True, xlabel="Vx", ylabel="Vy", vmin_min=1e-16): ''' Plots a view of phasespace, as seen by a themis detector, at the given cellID, in the style that heli likes. :param vlsvReader: Some VlsvReader class with a file open :type vlsvReader: :class:`vlsvfile.VlsvReader` :param cellid: The cell id where the distribution is supposet to be sampled NOTE: The cell id must have a velocity distribution! :param smooth: Smooth re-gridded phasespace before plotting :param plane_x and plane_y: x and y direction of the resulting plot plane ''' matrix = simulation_to_observation_frame(plane_x,plane_y) angles, energies, vmin, vmax, values = themis_observation_from_file( vlsvReader=vlsvReader, cellid=cellID, matrix=matrix, countrates=False, noise=False) if vmin == 0: vmin = vmin_min if vmax < vmin: vmax = vmin*10 # Regrid into cartesian space, 256x256: grid_r, grid_theta = np.meshgrid(energies,angles) grid_x = -grid_r * np.sin(grid_theta) # turn radial grid points into (x, y) grid_y = -grid_r * np.cos(grid_theta) hires_x = np.linspace(-2200,2200,256); hires_y = np.linspace(-2200,2200,256); xi,yi = np.meshgrid(hires_x,hires_y); vi = griddata( (grid_x.flatten(),grid_y.flatten()), values.flatten(), (xi,yi), method='linear') if smooth: # Convolve the grid data with a gaussian kernel blurkernel = np.exp(-.17*np.power([6,5,4,3,2,1,0,1,2,3,4,5,6],2)) vi = sepfir2d(vi, blurkernel, blurkernel) / 4.2983098411528502 fig,ax=pl.subplots(figsize=(12,10)) ax.set_aspect('equal') ax.set_title("Phasespace at cell " + str(cellID)) ax.set_xlabel(xlabel+" (km/s)") ax.set_ylabel(ylabel+" (km/s)") vi *= 10.**-3 # Go from s^3 m^-6 to s^3 km^-3 cm^-3 vmin *= 10.**-3 vmax *= 5*10.**-3 cax = ax.pcolormesh(xi,yi,vi.T, norm=matplotlib.colors.LogNorm(vmin=vmin,vmax=vmax), vmin=vmin, vmax=vmax, cmap=pl.get_cmap("Blues"), shading='flat') cax2 = ax.contourf(xi,yi,vi.T, levels=np.logspace(np.log10(vmin),np.log10(vmax),20), norm=matplotlib.colors.LogNorm(vmin=vmin,vmax=vmax), vmin=vmin, vmax=vmax, cmap=pl.get_cmap("Blues")) #cax3 = ax.contour(xi,yi,vi.T, levels=np.logspace(np.log10(vmin),np.log10(vmax),20), norm=matplotlib.colors.LogNorm(vmin=vmin,vmax=vmax), cmap=pl.get_cmap("binary")) ax.grid(True) # Draw a circle at themis max extents angles = np.linspace(0,2*np.pi,180) x = 2188*np.cos(angles) y = 2188*np.sin(angles) ax.plot(x,y) cb = fig.colorbar(cax) cb.set_label("Phasespace density (s^3 km^-3 cm^3)") #pl.show() return ax
def lowpass(image): points = 100 std_dev = 10.0 w = signal.gaussian(points, std_dev) lowpass_image = signal.sepfir2d(image, w, w) avg_image = numpy.mean(image) lowpass_avg_image = numpy.mean(lowpass_image) lowpass_im = lowpass_image * avg_image / lowpass_avg_image return lowpass_im
def filterImage(image, filter_size): """ Filter the image with a rectangular filter filter_size, (int,int) : size of the filter to apply """ hrow = [1. / filter_size[1]] * filter_size[1] hcol = [1. / filter_size[0]] * filter_size[0] image = image - signal.sepfir2d(image, hrow, hcol) return image
def filterImage(image, filter_size): """ Filter the image with a rectangular filter filter_size, (int,int) : size of the filter to apply """ hrow = [1./filter_size[1]]*filter_size[1] hcol = [1./filter_size[0]]*filter_size[0] image = image - signal.sepfir2d(image, hrow, hcol) return image
def blur(phi, window=.2): """ Gaussian blur of basis functions """ C, N, P = phi.shape w = np.int(window * min(C,P)) g = signal.gaussian(w, 1) philp = np.empty_like(phi) for i in range(N): philp[:,i] = signal.sepfir2d(phi[:,i], g, g) return philp
def heatMap (xy): # First calculate the 2D histogram hist2d, xedges, yedges = np.histogram2d(xy[:,1], xy[:,0], bins=(100, 100)) # Then blur the histogram filtx = signal.gaussian(15, 15/6.0) filtx = filtx/sum(filtx) filty = filtx hist2d = signal.sepfir2d(hist2d, filtx, filty) # Calculate the range / extent extent = array([amin(xy[:,0]), amax(xy[:,0]), amin(xy[:,1]), amax(xy[:,1])]) return (hist2d, extent)
def __init__(self, image=[[0.0]]): from scipy import signal, misc import numpy as np self.img = np.array(image) dim = len(image.shape) derfilt = np.array([1.0, -2, 1.0], dtype=np.float32) if dim == 3: for sl1 in range(image.shape[2]): ck = signal.cspline2d(self.img[:, :, sl1].copy(), 8.0) self.img[:, :, sl1] = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) if dim == 4: for sl1 in range(image.shape[2]): for sl2 in range(image.shape[3]): ck = signal.cspline2d(self.img[:, :, sl1, sl2].copy(), 8.0) self.img[:, :, sl1, sl2] = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) if dim == 5: for sl1 in range(image.shape[2]): for sl2 in range(image.shape[3]): for sl3 in range(image.shape[4]): ck = signal.cspline2d( self.img[:, :, sl1, sl2, sl3].copy(), 8.0) self.img[:, :, sl1, sl2, sl3] = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt))
def dog_sep_convolution(img, k, cell_type, originating_function="filter", only_positives=False, sampling_resolution="basab", force_homebrew = False): if force_homebrew: use_numpy = False else: use_numpy = True #if k[0].size < numpy.sqrt(img.shape[0]*img.shape[1])/2 else False #print("filtering for cell type idx %s (numpy? %s)"%(cell_type, use_numpy)) if originating_function == "filter": row_keep, col_keep = get_subsample_keepers(img, cell_type, k, sampling_resolution=sampling_resolution) else: row_keep, col_keep = 1, 1 if use_numpy == True: right_img = sepfir2d(img.copy(), k[0], k[1]) left_img = sepfir2d(img.copy(), k[2], k[3]) else: right_img = sep_convolution(img, k[0], k[1], col_keep=col_keep, row_keep=row_keep) left_img = sep_convolution(img, k[2], k[3], col_keep=col_keep, row_keep=row_keep) c = left_img + right_img #print("after addition") if only_positives: c = c*(c>0) #print("after only_positives") if use_numpy == True and originating_function == "filter": c = subsample(c, cell_type, k, sampling_resolution=sampling_resolution) return c
def dog_sep_convolution(self, img, k, cell_type, originating_function="filter", force_homebrew = False, mode="full"): ''' Wrapper for separated convolution for DoG kernels in FoCal, enables use of NumPy based sepfir2d. img => the image to convolve k => 1D kernels to use cell_type => ganglion cell type, useful for sampling resolution numbers originating_function => if "filter": use special sampling resolution, else: use every pixel force_hombrew => if True: use my code, else: NumPy's mode => "full" all image convolution, else only valid ''' if originating_function == "filter": row_keep, col_keep = self.get_subsample_keepers(cell_type) else: row_keep, col_keep = 1, 1 if not force_homebrew: # has a problem with images smaller than kernel right_img = sepfir2d(img.copy(), k[0], k[1]) left_img = sepfir2d(img.copy(), k[2], k[3]) else: right_img = self.sep_convolution(img, k[0], k[1], col_keep=col_keep, row_keep=row_keep, mode=mode) left_img = self.sep_convolution(img, k[2], k[3], col_keep=col_keep, row_keep=row_keep, mode=mode ) conv_img = left_img + right_img if not force_homebrew and originating_function == "filter": conv_img = self.subsample(conv_img, cell_type) return conv_img
def detect_edges(self, img): logging.debug('Detecting horizontal and vertical edges in screen') mat = np_from_img(img) gradient_kernel = (0, 1, 0, -1, 0) smoothing_kernel = np.ones((7), dtype='float32') vertical_edges = sepfir2d(mat, gradient_kernel, smoothing_kernel) / 7 vertical_edges_positive = vertical_edges * (vertical_edges > 0) vertical_edges_negative = vertical_edges * (vertical_edges < 0) vertical_edges = (np.roll(vertical_edges_positive, -1, axis=1) - np.roll(vertical_edges_negative, 1, axis=1)) / 2 horizontal_edges = sepfir2d(mat, smoothing_kernel, gradient_kernel) / 7 horizontal_edges_positive = horizontal_edges * (horizontal_edges > 0) horizontal_edges_negative = horizontal_edges * (horizontal_edges < 0) horizontal_edges = (np.roll(horizontal_edges_positive, -1, axis=0) - np.roll(horizontal_edges_negative, 1, axis=0)) / 2 if self.config.dump_x_gradients: img_from_np(vertical_edges).save(self.config.dump_x_gradients) if self.config.dump_y_gradients: img_from_np(horizontal_edges).save(self.config.dump_y_gradients) return horizontal_edges, vertical_edges
def interpolate(img_stack, slices, method='bcspline'): """interpolate a single frame. method can be none, bilinear, lanczos3, or bcspline""" #TODO: make this more efficient!! if method == 'none': return img_stack #create the filter based on the type of interpolation: if method == 'bcspline': #reconstruction/interpolation filter #3rd order bspline function filt = signal.bspline([-1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5], 3) elif method == 'bilinear': filt = [0.5, 1.0, 0.5] elif method == 'lanczos3': #x = linspace(-2.5,2.5,11) #evenly spaced from -2.5 to 2.5 by 0.5 increments #filt = sinc(x/3)*sinc(x) filt = [ 2.44565217e-02, 0, -1.35869565e-01, 0, 6.11413043e-01, 1, 6.11413043e-01, 0, -1.35869565e-01, 0, 2.44565217e-02 ] #allocate the output array: #img_stack.shape is (w/2, h/2, 4) #we're going to expand to (w,h,4): s = list(img_stack.shape) s[:2] = np.multiply(s[:2], 2) #element-wise multiply (w,h,4) #interpolated result: interp_stack = zeros(s) #interpolation coefficients for intermediate steps c_jk = zeros(s[:2]) #(w,h) #loop over last dimension (i0,i90,...) for j in xrange(s[-1]): #zero the coefficients c_jk[...] = 0.0 #get coefficients if method in ['bilinear', 'lanczos3']: #coefficients are just the image slices c_jk[slices[j]] = img_stack[..., j] elif method == 'bcspline': #coefficients are bicubic spline coefficients for slice c_jk[slices[j]] = signal.cspline2d(img_stack[..., j]) #convolve (filters are seperable, so we can use sepfir2d) interp_stack[..., j] = signal.sepfir2d(c_jk, filt, filt) #return interpolated image: return interp_stack
def themis_plot_phasespace_contour(vlsvReader, cellID, plane_x=np.array([1.,0,0]), plane_y=np.array([0,0,1.]), smooth=False, xlabel="Vx", ylabel="Vy"): ''' Plots a contour view of phasespace, as seen by a themis detector, at the given cellID :param vlsvReader: Some VlsvReader class with a file open :type vlsvReader: :class:`vlsvfile.VlsvReader` :param cellid: The cell id where the distribution is supposet to be sampled NOTE: The cell id must have a velocity distribution! :param plane_x and plane_y: x and y direction of the resulting plot plane ''' matrix = simulation_to_observation_frame(plane_x,plane_y) angles, energies, vmin, vmax, values = themis_observation_from_file( vlsvReader=vlsvReader, cellid=cellID, matrix=matrix) if vmin == 0: vmin = 1e-15 if vmax <= vmin: vmax = vmin * 10. # Regrid into cartesian space, 256x256: grid_r, grid_theta = np.meshgrid(energies,angles) grid_x = -grid_r * np.sin(grid_theta) # turn radial grid points into (x, y) grid_y = -grid_r * np.cos(grid_theta) # (the - comes from detector-look-direction vs particle-movement-direction) hires_x = np.linspace(-2200,2200,256); hires_y = np.linspace(-2200,2200,256); xi,yi = np.meshgrid(hires_x,hires_y); vi = griddata( (grid_x.flatten(),grid_y.flatten()), values.flatten(), (xi,yi)) if smooth: # Convolve the grid data with a gaussian kernel blurkernel = np.exp(-.17*np.power([6,5,4,3,2,1,0,1,2,3,4,5,6],2)) vi = sepfir2d(vi, blurkernel, blurkernel) / 4.2983098411528502 fig,ax=pl.subplots(figsize=(12,10)) ax.set_aspect('equal') ax.set_title("Phasespace at cell " + str(cellID)) ax.set_xlabel(xlabel+" (km/s)") ax.set_ylabel(ylabel+" (km/s)") cax = ax.contour(xi,yi,vi.T, levels=np.logspace(np.log10(vmin),np.log10(vmax),20), norm=matplotlib.colors.LogNorm(vmin=vmin,vmax=vmax)) ax.grid(True) fig.colorbar(cax) pl.show()
def separable_convolution2d(self, im, row, col, **kwargs): print im.shape print row.shape print col.shape return sepfir2d(array(im), row, col)
def transform(self): Iν = self.I.copy() Iν[self.i, self.j] = self.Iν return DImage(signal.sepfir2d(Iν, self.G, self.G))
import numpy as np from scipy import signal, misc import matplotlib.pyplot as plt #need to pip install matplotlib first image = misc.ascent() w = signal.gaussian(50, 10.0) image_new = signal.sepfir2d(image, w, w) plt.figure() plt.imshow(image_new) #顯示濾波後的圖形 plt.gray() plt.title('Filtered image') plt.show()
import numpy as np from scipy import signal, misc import matplotlib.pyplot as plt image = misc.face(gray=True).astype(np.float32) derfilt = np.array([1.0, -2, 1.0], dtype=np.float32) ck = signal.cspline2d(image, 8.0) deriv = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) # Alternatively we could have done:: # laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32) # deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm') plt.figure() plt.imshow(image) plt.gray() plt.title('Original image') plt.show() plt.figure() plt.imshow(deriv) plt.gray() plt.title('Output of spline edge filter') plt.show()
# Date: N/A # Notes: # 1) from examples # Ref: http://docs.scipy.org/doc/scipy/reference/tutorial/signal.html import numpy as np from scipy import signal, misc import matplotlib.pyplot as plt # import the image -- pre-defined image = misc.lena().astype(np.float32) # filter the image derfilt = np.array([1.0, -2, 1.0], dtype=np.float32) ck = signal.cspline2d(image, 8.0) deriv = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32) deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm') # plot the original plt.figure() plt.imshow(image) plt.gray() plt.title('Original image') plt.show() # plot the edge filter plt.figure() plt.imshow(deriv)
data=np.asarray(img) return data def g(v, std): x = v[0] y = v[1] return np.exp(-((x ** 2) + (y ** 2)) / (2 * std ** 2))# * (1.0 / (2 * np.pi * std ** 2)) #x is the axis of 121 data, from -3~3, k is the calculated value of the gaussian function at integer coordinates x = np.linspace(-3, 3, 121) xy = np.meshgrid(x, x) k = g(xy, 5.0) k = k[::20, ::20] #load the image img = loadtiffs('C:/Users/90759/Desktop/Teaching_python-master/Teaching_python-master/week_2/data/640.tif) #use convolve and fftconcolve to do the convolution to filter the image img_con = signal.convolve(img, k, mode = "valid") img_fft = signal.fftconvolve(img, k, mode = "valid") #use sepfir2d to filter the image w = signal.gaussian(7, std = 5.0) img_sep = signal.sepfir2d(img, w, w) #show the result plt.gray() plt.subplot(221, title = "orginal") plt.imshow(img) plt.subplot(222, title = "fftconvolve") plt.imshow(img_fft) plt.subplot(223, title = "sepfir2d") plt.imshow(img_sep) plt.subplot(224, title = "convolve") plt.imshow(img_con)
def horizontal_fir2d_filter(arr, width=10, factor=10 / 12.0): fir2d = signal.sepfir2d(arr, [1] * width, [1]) return greater(arr, fir2d / width * factor) * arr
#!/usr/bin/python NOTES = ''' Author: Joe Warga Date: 2014-11-07 ''' import numpy as np from scipy import signal, misc import matplotlib.pyplot as plt image = misc.lena() w = signal.gaussian(50, 5.0) image_new = signal.sepfir2d(image, w, w) plt.figure() plt.imshow(image_new) plt.gray() plt.title('Filtered image') plt.show()
Spyder Editor Este é um arquivo de script temporário. """ from pylab import imread, imshow, figure, subplot from scipy.signal import sepfir2d, gaussian from numpy import uint8, float32, array def norm8(img): mn = img.min() mx = img.max() I = (img - mn) / (mx - mn) * 255 return I.astype(uint8) filtro = gaussian(30, 20.0).astype(float32) # possível solução lena = array(imread('dat/lena.dat')) face = lena[180:390, 250:350] # rosto figure(figsize=(10, 8), dpi=80) subplot(2, 2, 1) imshow(face) emba = sepfir2d(lena[200:390, 250:350], filtro, filtro) # embaçamento embb = norm8(emba) subplot(2, 2, 2) imshow(embb) #copia.setflags(write=1) lena[200:390, 250:350] = embb subplot(2, 1, 2) imshow(lena)
def edgeDetect2(imageArray): derfilt = numpy.array([1.0, -2, 1.0], numpy.float32) ck = signal.cspline2d(imageArray, 8.0) deriv = signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d( ck, [1], derfilt) return deriv
def separable_convolution2d(self, im, row, col, **kwargs): return sepfir2d(im, row, col)
the precision used when computing the infinite sum needed to apply mirror- symmetric boundary conditions. ''' import matplotlib.pyplot as plt import matplotlib.image as mpimg import numpy as np from scipy import signal, misc img = mpimg.imread('Screenshot.png') print img imgplot = plt.imshow(img) #plt.show() image = misc.lena().astype("float32") imgplot = plt.imshow(image) plt.show() derfilt = np.array([1.0, -2, 1.0], "float32") ck = signal.cspline2d(image, 8.0) deriv = signal.sepfir2d(ck, derfilt, [1]) + \ signal.sepfir2d(ck, [1], derfilt) ''' Alternative: laplacian = array([[0,1,0],[1,-4,1],[0,1,0]],float32) deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm') ''' plt.gray() imgplot = plt.imshow(deriv) plt.show()
plt.show() # ----------------------------------------------------------------------------- # SIGNAL PROCESSING import numpy as np from scipy import signal, misc import matplotlib.pyplot as plt help(signal) image = misc.face(gray = True).astype(np.float32) derfilt = np.array([1.0, -2, 1.0], dtype = np.float32) ck = signal.cspline2d(image, 8.0) deriv = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) plt.figure() plt.imshow(image) plt.gray() plt.title('Original image') plt.show() plt.figure() plt.imshow(deriv) plt.gray() plt.title('Output of spline edge filter') plt.show() image = misc.face(gray = True) w = np.zeros((50, 50)) w[0][0] = 1.0
def gradient(image): p = np.array([0.0377, 0.2492, 0.4264, 0.2492, 0.0377]).astype(np.float32) d = np.array([0.1096, 0.2767, 0, -0.2767, -0.1096]).astype(np.float32) grad_x = -signal.sepfir2d(image, d, p) grad_y = signal.sepfir2d(image, p, d) return grad_x, grad_y
def border_fir2d_filter(arr, filter_x=[1] * 3, filter_y=[1] * 10): return greater( fast_horizontal_filter(signal.sepfir2d(arr, filter_x, filter_y)), 0) * arr
def plot_log_agn_postcard(MBH, eddrate, # from Baskin & Laor (2017) rad_efficiency = 0.1, Z = 5, # metallicity # Radiative Fountain system assumptions dust_to_gas_ratio = 1/20., kappa = 1e3 * u.cm**2/u.g, rho_g = 300 * u.Msun / u.pc**3, show_BH = True, show_corona = True, show_disk = True, show_BLR = True, show_NLR = True, show_jet = True, show_TOR = True, show_SOI = True, show_viewing = True, colored_disk = True, show_flows = True, ): L_AGN_edd = compute_eddington_luminosity(MBH) L_AGN = eddrate * L_AGN_edd L_AGN_46 = (L_AGN / (1e46 * u.erg/u.s)).to(1) L_AGN_edd = compute_eddington_luminosity(MBH) r_grav = compute_grav_radius(MBH).to(u.pc) M_dot = (L_AGN / c.c**2 / rad_efficiency).to(u.Msun / u.yr) R_in = compute_sublimation_radius(MBH, M_dot) # from Kormendy & Ho+13, compute sigma from BH mass sigma = 200 * u.km / u.s * 10**((log10((MBH / (1e9 * u.Msun)).to(1)) + 0.510) / 4.377) r_infl = compute_sphere_of_influence(MBH, sigma).to(u.pc) R = numpy.logspace(log10(r_grav/R_in), 3, 1000) * R_in R = numpy.logspace(log10(r_grav/R_in), max(3, log10(r_infl/R_in)), 1000) * R_in title = "$M_\mathrm{BH}=%s$ $\lambda=%.3f$ $L_\mathrm{AGN}=%.1f$ $\dot{M}=%.1f M_\odot/yr$" % (log_bhm(MBH), eddrate, log_lum(L_AGN), M_dot.to(u.Msun / u.yr).value) #plt.title(title) colors = plt.rcParams['axes.prop_cycle'].by_key()['color'] textsize = 10 xlo, xhi = 8e-8 * u.pc, 50*100 * u.pc ylo, yhi = xlo / 100, 200*100 * u.pc # Sphere of influence: theta = numpy.linspace(0, pi/2, 400) y, x = pol2cart(r_infl, theta) if show_SOI: plt.plot(x, y, ls='--', lw=0.5, color=colors[8], label='Sphere of influence') #plt.text(x.max().value*1.1, r_infl.value / 1000, 'Sphere of influence', # va='bottom', ha='left', rotation=90) plt.text(x.max().value * 1.2, ylo.value * 2, 'Sphere of influence', va='bottom', ha='left', rotation=90) #plt.fill_between(x.value, y.value, y.value*0 + yhi.value, # color=colors[8], alpha=0.1) #plt.fill_between([x.max().value, xhi.value], [ylo.value]*2, [yhi.value]*2, # color=colors[8], alpha=0.1) #plt.fill_between(x.value, y.value, y.value*0 + ylo.value, # color=colors[8], alpha=0.06) # Accretion disk: R_disk = R z_disk = compute_alphadisk_height(MBH, M_dot, R_disk, alpha=1).to(u.pc) T_disk = compute_alphadisk_temperature(MBH, M_dot, R_disk, alpha=1).to(u.K) if show_disk: mask = R < r_infl if colored_disk: for color, R_part, z_disk_part in find_color_chunks(color_data_T, T_disk[mask], color_data_rgb, R_disk[mask], z_disk[mask]): plt.fill_between(R_part, z_disk_part, z_disk_part * 0 + ylo, color=color) else: plt.fill_between(R_disk[mask], z_disk[mask], z_disk[mask] * 0 + ylo, color='k', label="Accretion disk (SS)") # 'Accretion disk\n$\log \dot{M}=%.1f$' % rround(log10(M_dot.value)), plt.text(7 * r_grav.value, ylo.value * 2, 'Accretion disk\n$\log L_\mathrm{bol}=%.1f$' % log_lum(L_AGN), va='bottom', ha='left', color='k', size=textsize, bbox=dict(color='white')) #idx = numpy.where(R>20*r_grav)[0][0] #plt.text(R_disk[idx].value, z_disk[idx].value, 'Accretion disk', # va='top', ha='left', color='k', size=textsize) if show_flows: outflow = compute_outflow_rate(L_AGN, Mstar = 1e11 * u.Msun, SFR = 0*u.Msun/u.yr) inflow = M_dot # at accretion disk at least, or when considering steady-state # y = z_disk[mask][-1].value/10 plt.text(r_infl.value*2, 1e-3, '$\\uparrow$ Outflow\n$%s M_\odot/\mathrm{yr} \cdot M_{\star,11}^{-0.4}$\n$\leftarrow$ BH Inflow\n$%s M_\odot/\mathrm{yr}$' % (rround(outflow.to(u.Msun/u.yr).value), rround(inflow.to(u.Msun/u.yr).value)), va='top', ha='left', color='k', size=textsize) # Jet: R_fullrange = numpy.logspace(log10(r_grav.value), log10(R.value.max()*5), 400) * u.pc R_fullrange = numpy.logspace(log10(r_grav.value), log10(max(yhi, 1e8*r_grav).value), 400) * u.pc R_j = compute_jet_edge(MBH, R_fullrange) if show_jet: jetcolor = colors[4] plt.plot(R_j, R_fullrange, '--', color=jetcolor, label='Jet') plt.fill_betweenx(R_fullrange, R_j, color=jetcolor, label='Jet', alpha=0.05) plt.text(R_j.value[-1] / 5, R_fullrange.value[-1] / 2, 'Jet', color=jetcolor, va='top', ha='right', size=textsize) # BH: theta = numpy.linspace(0, pi/2, 4000) y, x = pol2cart(r_grav, theta[::-1]) if show_BH: plt.fill_between(x, 1e-10 + 0*y.value, y, color='k', label='Black hole') #plt.plot(x, y / 10, '-', color='k', label='Black hole 1') plt.text(r_grav.value * 0.8, r_grav.value / 3, 'Black Hole\n\n$\log M=%.1f$' % (log_bhm(MBH)) if MBH > 10**7.5 * u.Msun else 'BH\n\n$\log M=%.1f$' % (log_bhm(MBH)), va='top', ha='right', color='white', fontweight='bold', size=textsize) # Corona: y, x = pol2cart(6*r_grav, theta) if show_corona: plt.plot(x, y, ls=':', color=colors[1], label='X-ray Corona') plt.text(xlo.value*1.2, 6*r_grav.value, 'Corona', va='bottom', ha='left', color=colors[1]) # BLR: z1, z2, zmax = compute_blr_shape(MBH, M_dot, L_AGN, R, Z, variant='static') z1, z2, zmax_dyn = compute_blr_shape(MBH, M_dot, L_AGN, R, Z, variant='dynamic', dyn_factor=2) CF = get_blr_covering_factor(z1, z2, R) Rpeak, Hpeak = get_peak(z2, z1, R) z1, z2, zmax_dyn_nodust = compute_blr_shape(MBH, M_dot, L_AGN, R, Z, variant='dustfree', dyn_factor=2) idx, = numpy.where(numpy.logical_or(zmax_dyn_nodust > z_disk, zmax_dyn > z_disk)) if idx.any(): lo, hi = idx.min() - 1, idx.max() + 1 zmax_dyn_disk = numpy.where(zmax_dyn > z_disk, zmax_dyn, z_disk) zmax_dyn_nodust_disk = numpy.where(zmax_dyn_nodust > z_disk, zmax_dyn_nodust, z_disk) else: lo, hi = 0, -1 zmax_dyn_disk = zmax_dyn zmax_dyn_nodust_disk = zmax_dyn_nodust if show_BLR: color = colors[0] l, = plt.plot(R[lo:hi], zmax_dyn_nodust_disk[lo:hi], '--', label="Broad Line Region (BLCH, CF=%.0f%%)" % (CF*100), color=color, ) plt.plot(R[lo:hi], zmax_dyn_disk[lo:hi], '-', color=color, label='Dusty BLR') plt.fill_between(R[lo:hi], z_disk[lo:hi], zmax_dyn_disk[lo:hi], color=color) #plt.plot(Rpeak, Hpeak, 'o', color=color) plt.text(Rpeak.value, Hpeak.value, 'BLCH BLR\nCF=%.2f' % (CF), va='bottom', ha='center', color=color) #plt.fill_between(R.flatten(), 0, zmax_dyn, color=color, hatch='//') #plt.vlines(R_in.to(u.pc).value, 0, Hpeak.to(u.pc).value, linestyles=[':'], colors=[color]) # Radiative fountain r_d = compute_dust_sublimation_radius(L_AGN) r_0 = compute_heating_radius(L_AGN, rho_g = 300 * u.Msun / u.pc**3) r_max = compute_rmax(MBH, L_AGN, theta, r_0, r_d, dust_to_gas_ratio = dust_to_gas_ratio, kappa = kappa).to(u.pc) theta_crit = compute_critical_angle(MBH, L_AGN, r_0, r_d, dust_to_gas_ratio, kappa = kappa) CF = cos(theta_crit) color = colors[3] r_max[r_max > 1000 * u.pc] = numpy.nan z_min = numpy.interp(r_d.value, R.value, z_disk.value) theta_min = arctan2(z_min, r_d.value) y, x = pol2cart(r_max, theta) if show_TOR: #plt.plot(x, y, ls='-.', color=color, label="Radiative Fountain TOR") ## structure: rng = numpy.random.RandomState(1) Nrad = 100 # 100 pixels in radial direction rho = 10**rng.normal(size=(Nrad, Nrad)) rho[rho > 1000] = 1000 from scipy.signal import sepfir2d, convolve2d # we need 5 degree smoothing in theta according to Wada+ sims # but this could be partly due to resolution issues, # so I take twice that here correlation_degrees = 5 / 2 # same scale in radial direction as in vertical direction sigma_rad_pixels = len(rho) * sin(correlation_degrees * pi / 180) H_r = numpy.exp(-0.5 * numpy.linspace(-5, 5, int(sigma_rad_pixels)*10)**2) H_r /= H_r.sum() H_c = H_r kernel = H_r.reshape((-1, 1)) * H_c.reshape((1, -1)) kernel /= kernel.sum() rad = numpy.linspace(0, r_infl.to(u.pc).value, Nrad) X, Y = numpy.meshgrid(rad, rad) R, THETA = cart2pol(X, Y) low_density = 0 # use high values close to disk rho[THETA <= theta_min] = 10 # now erase disallowed regions: # empty jet X_jet = compute_jet_edge(MBH, Y * u.pc).to(u.pc).value rho[X < X_jet] = low_density RMAX = numpy.interp(pi/2 - THETA, xp=theta, fp=r_max.value) RMAX[~numpy.isfinite(RMAX)] = numpy.inf # only fill below r_max rho[R <= RMAX] = low_density # only fill within SOI rho[R > r_infl.to(u.pc).value] = low_density # do convolution convolved = sepfir2d(rho, H_r, H_c) #convolved = convolve2d(rho, kernel, mode='same', fillvalue=low_density) convolved[R <= RMAX] = low_density convolved[R > r_infl.to(u.pc).value] = low_density convolved[X < X_jet] = low_density #convolved[THETA <= theta_min] = 3 #plt.contourf(rad, rad, convolved/convolved[convolved>low_density].std(), # levels=numpy.linspace(-3, 3, 10), cmap='Reds', zorder=-10) #convolved[convolved > 3] = 3 #convolved[convolved < -3] = numpy.nan C = plt.contourf(rad, rad, convolved, levels=10, cmap='Reds', zorder=-10) C.collections[0].set_facecolor('white') ## end structure mask = theta > 89.7/180*pi if show_TOR and mask.any() and numpy.isfinite(x[mask][0].value): plt.text(x[mask][0].value, y[mask][0].value, 'RF TOR \nCF=%.2f ' % CF, va='bottom', ha='right', color=color) # NLR R_NLR_hi = get_nlr_size().to(u.pc) # these are chosen arbitrarily: the inner edge of the NLR and the maximum angle # in practice they are observationally and host galaxy limited, respectively R_NLR_lo = r_infl R_NLR = numpy.array([R_NLR_lo.value, R_NLR_hi.value]) * u.pc thetai = numpy.linspace(pi/400, pi/4, 10) for i, (thetalo, thetahi) in enumerate(zip(thetai[:-1], thetai[1:])): if not show_NLR: break ylo1, ylo2 = R_NLR.value xlo1, xlo2 = compute_jet_edge(MBH, R_NLR).value (yhi1, yhi2), (xhi1, xhi2) = pol2cart(R_NLR.value, thetahi) #(ylo1, ylo2), (xlo1, xlo2) = pol2cart(R_NLR_lo.value, numpy.array([thetalo, thetahi])) #(yhi1, yhi2), (xhi1, xhi2) = pol2cart(R_NLR_hi.value, numpy.array([thetalo, thetahi])) label = 'NLR' if i == 0 else None alpha = (1. - (i*1./len(thetai))**0.8)*0.5 plt.fill([xlo1, xhi1, xhi2, xlo2], [ylo1, yhi1, yhi2, ylo2], color=colors[2], alpha=alpha, lw=0, label=label) plt.text(xlo2, ylo2*0.9, 'NLR', color='white', va='top', ha='left', size=textsize) # sight-lines theta = numpy.array([1, 5, 15, 30, 60, 85]) theta[theta == 0] = 5 theta[theta == 90] = 85 for thetai in theta: if not show_viewing: break Rline = numpy.array([5 * r_grav.to(u.pc).value, 4]) #Rline = numpy.linspace(5 * r_grav.to(u.pc).value, 10, 1000) y, x = pol2cart(Rline, thetai / 180 * pi) #x = R_fullrange.value #y = x * sin(thetai / 180 * pi) #mask = y > 1 #y, x = y[mask], x[mask] plt.plot(x, y, ':', color='k', alpha=0.1) plt.text(x[-1], y[-1], '$%d^\circ$' % (thetai)) plt.xlabel("R [pc]") plt.ylabel("z [pc]") plt.xticks() #plt.legend(loc="lower right", prop=dict(size=12)) #plt.ylim(r_grav.value / 100, 200*100) #plt.xlim(r_grav.value / 2, 50*100) plt.ylim(8e-8 / 100, 200*100) plt.xlim(8e-8, 50*100) plt.xscale('log') plt.yscale('log')
def compute_similarity_from_jhist(jh, fwhm=None, cost_fun='nmi'): """ Computes an information-theoretic similarity from a joint histogram. Parameters ---------- jh: 2D array joint histogram of the two random variables being compared fwhm: float or pair of float kernel width for smoothing the joint histogram cost_fun: string, optional (default 'nmi') smilarity model to use; possible values are: 'mi': Mutual Information 'nmi': Normalized Mutual Information 'ecc': Entropic Cross-Correlation Returns ------- o: float the computed similariy measure """ # sanitize input if fwhm is None: fwhm = [7., 7.] if len(np.shape(jh)) != 2: raise ValueError("jh must be 2D array, got %s" % jh) if len(np.shape(fwhm)) == 0: fwhm = [fwhm] * 2 fwhm = fwhm[:2] # create separable filter for smoothing the joint-histogram lim = np.ceil(fwhm * 2) krn1 = centered_smoothing_kernel(fwhm[0], np.linspace(-1 * lim[0], lim[0], num=2 * lim[0])) krn1 = krn1 / np.sum(krn1) krn2 = centered_smoothing_kernel(fwhm[1], np.linspace(-1 * lim[1], lim[1], num=2 * lim[1])) krn2 = krn2 / np.sum(krn2) # smooth the histogram with kern1 x kern2 jh = sepfir2d(jh, krn1, krn2) # compute marginal histograms jh = jh + EPS sh = np.sum(jh) jh = jh / sh s1 = np.sum(jh, axis=0).reshape((-1, jh.shape[0])) s2 = np.sum(jh, axis=1).reshape((jh.shape[1], -1)) # compute cost function proper if cost_fun == 'mi': # Mutual Information: jh = jh * np.log2(jh / np.dot(s2, s1)) mi = np.sum(jh) o = -mi elif cost_fun == 'ecc': # Entropy Correlation Coefficient of: # Maes, Collignon, Vandermeulen, Marchal & Suetens (1997). # "Multimodality image registration by maximisation of mutual # information". IEEE Transactions on Medical Imaging 16(2):187-198 jh = jh * np.log2(jh / np.dot(s2, s1)) mi = np.sum(jh.ravel(order='F')) ecc = -2 * mi / (np.sum(s1 * np.log2(s1)) + np.sum(s2 * np.log2(s2))) o = -ecc elif cost_fun == 'nmi': # Normalised Mutual Information of: # Studholme, jhill & jhawkes (1998). # "A normalized entropy measure of 3-D medical image alignment". # in Proc. Medical Imaging 1998, vol. 3338, San Diego, CA, pp. 132-143. nmi = (np.sum(s1 * np.log2(s1)) + np.sum(s2 * np.log2(s2))) / np.sum( np.sum(jh * np.log2(jh))) o = -nmi else: raise NotImplementedError( "Unsupported cost_fun (cost function): %s" % cost_fun) return o
def compute_similarity_from_jhist(jh, fwhm=None, cost_fun='nmi'): """ Computes an information-theoretic similarity from a joint histogram. Parameters ---------- jh: 2D array joint histogram of the two random variables being compared fwhm: float or pair of float kernel width for smoothing the joint histogram cost_fun: string, optional (default 'nmi') smilarity model to use; possible values are: 'mi': Mutual Information 'nmi': Normalized Mutual Information 'ecc': Entropic Cross-Correlation Returns ------- o: float the computed similariy measure """ # sanitize input if fwhm is None: fwhm = [7., 7.] if len(np.shape(jh)) != 2: raise ValueError("jh must be 2D array, got %s" % jh) if len(np.shape(fwhm)) == 0: fwhm = [fwhm] * 2 fwhm = fwhm[:2] # create separable filter for smoothing the joint-histogram lim = np.ceil(fwhm * 2).astype(np.int) krn1 = centered_smoothing_kernel( fwhm[0], np.linspace(-1 * lim[0], lim[0], num=2 * lim[0])) krn1 = krn1 / np.sum(krn1) krn2 = centered_smoothing_kernel( fwhm[1], np.linspace(-1 * lim[1], lim[1], num=2 * lim[1])) krn2 = krn2 / np.sum(krn2) # smooth the histogram with kern1 x kern2 jh = sepfir2d(jh, krn1, krn2) # compute marginal histograms jh = jh + EPS sh = np.sum(jh) jh = jh / sh s1 = np.sum(jh, axis=0).reshape((-1, jh.shape[0])) s2 = np.sum(jh, axis=1).reshape((jh.shape[1], -1)) # compute cost function proper if cost_fun == 'mi': # Mutual Information: jh = jh * np.log2(jh / np.dot(s2, s1)) mi = np.sum(jh) o = -mi elif cost_fun == 'ecc': # Entropy Correlation Coefficient of: # Maes, Collignon, Vandermeulen, Marchal & Suetens (1997). # "Multimodality image registration by maximisation of mutual # information". IEEE Transactions on Medical Imaging 16(2):187-198 jh = jh * np.log2(jh / np.dot(s2, s1)) mi = np.sum(jh.ravel(order='F')) ecc = -2 * mi / (np.sum(s1 * np.log2(s1)) + np.sum(s2 * np.log2(s2))) o = -ecc elif cost_fun == 'nmi': # Normalised Mutual Information of: # Studholme, jhill & jhawkes (1998). # "A normalized entropy measure of 3-D medical image alignment". # in Proc. Medical Imaging 1998, vol. 3338, San Diego, CA, pp. 132-143. nmi = (np.sum(s1 * np.log2(s1)) + np.sum(s2 * np.log2(s2))) / np.sum( np.sum(jh * np.log2(jh))) o = -nmi else: raise NotImplementedError("Unsupported cost_fun (cost function): %s" % cost_fun) return o
def edgeDetect2(imageArray): derfilt = numpy.array([1.0,-2,1.0],numpy.float32) ck = signal.cspline2d(imageArray,8.0) deriv = signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt) return deriv
def 高斯模糊(): image = misc.ascent() # 二维图像数组,ascent 图像 w = signal.gaussian(50, 10.0) global image_new image_new = signal.sepfir2d(image, w, w)
To smoothen the input raw satellite image or image with general formats using various smoothing filters such as average filter, Weighted average filter, Gaussian smoothing, etc. ============================ created: 17/08/2015 *auhor: [email protected]* ''' from scipy import misc, signal import numpy as np x = misc.lena() x1 = misc.lena().astype(np.float32) w = signal.gaussian(50, 5.0) laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32) derfilt = np.array([1.0, -2, 1.0], dtype=np.float32) ck = signal.cspline2d(x1, 8.0) deriv = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) im1 = signal.convolve2d(x1,laplacian,mode='same',boundary='symm') im2 = signal.sepfir2d(x, w, w) plt.figure() plt.subplot(221) plt.imshow(x) plt.title('original image') plt.subplot(222) plt.imshow(im1) plt.title('laplacian filter image') plt.subplot(223) plt.imshow(im2) plt.title('gaussian blurred iamge') plt.subplot(224) plt.imshow(deriv) plt.gray()
from numpy import * from scipy import signal, misc import matplotlib.pyplot as plt image = misc.lena().astype(float32) derfilt = array([1.0,-2,1.0],float32) ck = signal.cspline2d(image,8.0) deriv = signal.sepfir2d(ck, derfilt, [1]) + \ signal.sepfir2d(ck, [1], derfilt) # Alternatively we could have done:: # laplacian = array([[0,1,0],[1,-4,1],[0,1,0]],float32) # deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm') plt.figure() plt.imshow(image) plt.gray() plt.title('Original image') plt.show() plt.figure() plt.imshow(deriv) plt.gray() plt.title('Output of spline edge filter') plt.show()
pos_error_xx = np.sum(pos_error_x * pos_error_x, axis=1) / cfg.N pos_error_yy = np.sum(pos_error_y * pos_error_y, axis=1) / cfg.N pos_error_xy = np.sum(pos_error_x * pos_error_y, axis=1) / cfg.N """ Ploting the heatmap, blur heatmaps - boxcar window filter """ w = signal.get_window("boxcar", 7) w /= np.sum(w) # xx heatmap_data = pos_error_xx Z = heatmap_data.reshape( [(boundaries[1][1] - boundaries[1][0] - 1) / cfg.res + 1, (boundaries[0][1] - boundaries[0][0] - 1) / cfg.res + 1] ) Z = signal.sepfir2d(Z, w, w) pos_error_xx = Z.reshape((grid.shape[0])) # yy heatmap_data = pos_error_yy Z = heatmap_data.reshape( [(boundaries[1][1] - boundaries[1][0] - 1) / cfg.res + 1, (boundaries[0][1] - boundaries[0][0] - 1) / cfg.res + 1] ) Z = signal.sepfir2d(Z, w, w) pos_error_yy = Z.reshape((grid.shape[0])) # plot xy heatmap_data = pos_error_xy Z = heatmap_data.reshape(