def deltaC(size,center=None,magnitude=False): """ returns an array where every value is the distance from the center point. :param center: center point, if not specified, assume size/2 :param magnitude: return a single magnitude value instead of [dx,dy] """ size=(int(size[0]),int(size[1])) if center is None: center=size[0]/2.0,size[1]/2.0 if magnitude: if False: # old way, non-vector img=np.ndarray((size[0],size[1])) for x in range(size[0]): for y in range(size[1]): img[x,y]=math.sqrt((x-center[0])**2+(y-center[1])**2) else: img=np.sqrt((np.arange(size[0])-center[0])**2+(np.arange(size[1])[:,None]-center[1])**2) else: img=np.ndarray((size[0],size[1],2)) for x in range(size[0]): for y in range(size[1]): img[x,y]=(x-center[0]),(y-center[1]) return img
def cartesian2logpolar(img, center=None, final_radius=None, initial_radius = None, phase_width = 3000): """ See also: https://en.wikipedia.org/wiki/Log-polar_coordinates """ if center is None: center=(img.shape[0]/2,img.shape[1]/2) if final_radius is None: final_radius=max(img.shape[0],img.shape[1])/2 if initial_radius is None: initial_radius = 0 phase_width=img.shape[0]/2 theta , R = np.meshgrid(np.linspace(0, 2*np.pi, phase_width), np.arange(initial_radius, final_radius)) Xcart = np.exp(R) * np.cos(theta) + center[0] Ycart = np.exp(R) * np.sin(theta) + center[1] Xcart = Xcart.astype(int) Ycart = Ycart.astype(int) if img.ndim ==3: polar_img = img[Ycart,Xcart,:] polar_img = np.reshape(polar_img,(final_radius-initial_radius,phase_width,img.shape[-1])) else: polar_img = img[Ycart,Xcart] polar_img = np.reshape(polar_img,(final_radius-initial_radius,phase_width)) return polar_img
def cartesian2polar(img, center=None, final_radius=None, initial_radius = None, phase_width = 3000): """ Comes from: https://stackoverflow.com/questions/9924135/fast-cartesian-to-polar-to-cartesian-in-python """ img=numpyArray(img) if center is None: center=(img.shape[0]/2,img.shape[1]/2) if final_radius is None: final_radius=max(img.shape[0],img.shape[1])/2 if initial_radius is None: initial_radius = 0 phase_width=img.shape[0]/2 theta , R = np.meshgrid(np.linspace(0, 2*np.pi, phase_width), np.arange(initial_radius, final_radius)) Xcart = R * np.cos(theta) + center[0] Ycart = R * np.sin(theta) + center[1] Xcart = Xcart.astype(int) Ycart = Ycart.astype(int) if img.ndim ==3: polar_img = img[Ycart,Xcart,:] polar_img = np.reshape(polar_img,(final_radius-initial_radius,phase_width,img.shape[-1])) else: polar_img = img[Ycart,Xcart] polar_img = np.reshape(polar_img,(final_radius-initial_radius,phase_width)) return polar_img
def solve_implicit(ks, a, b, c, d, b_edge=None, d_edge=None): land_mask = (ks >= 0)[:, :, bh.newaxis] edge_mask = land_mask & (bh.arange(a.shape[2])[bh.newaxis, bh.newaxis, :] == ks[:, :, bh.newaxis]) water_mask = land_mask & (bh.arange(a.shape[2])[bh.newaxis, bh.newaxis, :] >= ks[:, :, bh.newaxis]) a_tri = water_mask * a * bh.logical_not(edge_mask) b_tri = where(water_mask, b, 1.) if b_edge is not None: b_tri = where(edge_mask, b_edge, b_tri) c_tri = water_mask * c d_tri = water_mask * d if d_edge is not None: d_tri = where(edge_mask, d_edge, d_tri) return solve_tridiag(a_tri, b_tri, c_tri, d_tri), water_mask
def has_ext(): try: a = bh.arange(4).astype(bh.float64).reshape(2, 2) bh.blas.gemm(a, a) return True except Exception as e: print("\n\033[31m[ext] Cannot test BLAS extension methods.\033[0m") print(e) return False
def has_ext(): try: a = bh.arange(4).astype(bh.float64).reshape(2, 2) bh.blas.gemm(a, a) return True except Exception as e: print("\n\033[31m[ext] Cannot test BLAS extension methods.\033[0m") print(e) return False
def has_ext(): try: a = bh.arange(4).astype(bh.float64).reshape(2, 2) bh.linalg.solve_tridiagonal(a, a, a, a) return True except Exception as e: print("\n\033[31m[ext] Cannot test TDMA extension methods.\033[0m") print(e) return False
def main(): B = util.Benchmark() N, = B.size x = numpy.arange(N**2, dtype=numpy.float32) x.shape = (N, N) x.bohrium = B.bohrium y = numpy.arange(N**2, dtype=numpy.float32) y.shape = (N, N) x.bohrium = B.bohrium B.start() numpy.add.reduce(x[:,numpy.newaxis]*numpy.transpose(y),-1) B.stop() B.pprint()
def weighted_line(r0, c0, r1, c1, w, rmin=0, rmax=np.inf): # The algorithm below works fine if c1 >= c0 and c1-c0 >= abs(r1-r0). # If either of these cases are violated, do some switches. if abs(c1-c0) < abs(r1-r0): # Switch x and y, and switch again when returning. xx, yy, val = weighted_line(c0, r0, c1, r1, w, rmin=rmin, rmax=rmax) return (yy, xx, val) # At this point we know that the distance in columns (x) is greater # than that in rows (y). Possibly one more switch if c0 > c1. if c0 > c1: return weighted_line(r1, c1, r0, c0, w, rmin=rmin, rmax=rmax) # The following is now always < 1 in abs num=r1-r0 denom=c1-c0 slope = np.divide(num,denom,out=np.zeros_like(denom), where=denom!=0) # Adjust weight by the slope w *= np.sqrt(1+np.abs(slope)) / 2 # We write y as a function of x, because the slope is always <= 1 # (in absolute value) x = np.arange(c0, c1+1, dtype=float) y = x * slope + (c1*r0-c0*r1) / (c1-c0) # Now instead of 2 values for y, we have 2*np.ceil(w/2). # All values are 1 except the upmost and bottommost. thickness = np.ceil(w/2) yy = (np.floor(y).reshape(-1,1) + np.arange(-thickness-1,thickness+2).reshape(1,-1)) xx = np.repeat(x, yy.shape[1]) vals = trapez(yy, y.reshape(-1,1), w).flatten() yy = yy.flatten() # Exclude useless parts and those outside of the interval # to avoid parts outside of the picture mask = np.logical_and.reduce((yy >= rmin, yy < rmax, vals > 0)) return (yy[mask].astype(int), xx[mask].astype(int), vals[mask])
def logpolar2cartesian(polar_data): """ From: https://stackoverflow.com/questions/2164570/reprojecting-polar-to-cartesian-grid """ from scipy.ndimage.interpolation import map_coordinates theta_step=1 range_step=500 x=np.arange(-100000, 100000, 1000) y=x order=3 # "x" and "y" are numpy arrays with the desired cartesian coordinates # we make a meshgrid with them X, Y = np.meshgrid(x, y) # Now that we have the X and Y coordinates of each point in the output plane # we can calculate their corresponding theta and range Tc = np.degrees(np.arctan2(Y, X)).ravel() Rc = np.ln(np.sqrt(X**2 + Y**2)).ravel() # Negative angles are corrected Tc[Tc < 0] = 360 + Tc[Tc < 0] # Using the known theta and range steps, the coordinates are mapped to # those of the data grid Tc = Tc / theta_step Rc = Rc / range_step # An array of polar coordinates is created stacking the previous arrays #coords = np.vstack((Ac, Sc)) coords = np.vstack((Tc, Rc)) # To avoid holes in the 360º - 0º boundary, the last column of the data # copied in the begining polar_data = np.vstack((polar_data, polar_data[-1,:])) # The data is mapped to the new coordinates # Values outside range are substituted with nans cart_data = map_coordinates(polar_data, coords, order=order, mode='constant', cval=np.nan) # The data is reshaped and returned return cart_data.reshape(len(Y), len(X)).T
def waveImage(size=(256,256),repeats=2,angle=0,wave='sine',radial=False): """ create an image based on a sine, saw, or triangle wave function """ ret=np.zeros(size) if radial: raise NotImplementedError() # TODO: Implement radial wave images else: twopi=2*pi thetas=np.arange(size[0])*float(repeats)/size[0]*twopi if wave=='sine': ret[:,:]=0.5+0.5*np.sin(thetas) elif wave=='saw': n=np.round(thetas/twopi) thetas-=n*twopi ret[:,:]=np.where(thetas<0,thetas+twopi,thetas)/twopi elif wave=='triangle': ret[:,:]=1.0-2.0*np.abs(np.floor((thetas*(1.0/twopi))+0.5)-(thetas*(1.0/twopi))) return ret
def naive_line(r0, c0, r1, c1): # The algorithm below works fine if c1 >= c0 and c1-c0 >= abs(r1-r0). # If either of these cases are violated, do some switches. if abs(c1-c0) < abs(r1-r0): # Switch x and y, and switch again when returning. xx, yy, val = naive_line(c0, r0, c1, r1) return (yy, xx, val) # At this point we know that the distance in columns (x) is greater # than that in rows (y). Possibly one more switch if c0 > c1. if c0 > c1: return naive_line(r1, c1, r0, c0) # We write y as a function of x, because the slope is always <= 1 # (in absolute value) x = np.arange(c0, c1+1, dtype=float) y = x * (r1-r0) / (c1-c0) + (c1*r0-c0*r1) / (c1-c0) valbot = np.floor(y)-y+1 valtop = y-np.floor(y) return (np.concatenate((np.floor(y), np.floor(y)+1)).astype(int), np.concatenate((x,x)).astype(int),np.concatenate((valbot, valtop)))
def perlinNoiseX(size=(256,256),seed=None): """ Generate a black and white image consisting of perlinNoise (clouds) """ def lerp(a,b,x): "linear interpolation" return a + x * (b-a) def fade(t): "6t^5 - 15t^4 + 10t^3" return 6 * t**5 - 15 * t**4 + 10 * t**3 def gradient(h,x,y): "converts h to the right gradient vector and return the dot product with (x,y)" vectors = np.array([[0,1],[0,-1],[1,0],[-1,0]]) g = vectors[h%4] return g[:,:,0] * x + g[:,:,1] * y # permutation table if seed is not None: np.random.seed(seed) p = np.arange(256,dtype=int) np.random.shuffle(p) p = np.stack([p,p]).flatten() # coordinates of the top-left xi = size[0].astype(int) yi = size[1].astype(int) # internal coordinates xf = size[0] - xi yf = size[1] - yi # fade factors u = fade(xf) v = fade(yf) # noise components n00 = gradient(p[p[xi]+yi],xf,yf) n01 = gradient(p[p[xi]+yi+1],xf,yf-1) n11 = gradient(p[p[xi+1]+yi+1],xf-1,yf-1) n10 = gradient(p[p[xi+1]+yi],xf-1,yf) # combine noises x1 = lerp(n00,n10,u) x2 = lerp(n01,n11,u) return lerp(x1,x2,v)
def curves(image, controlPoints, clampBlack=0, clampWhite=1, degree=None, extrapolate=True): """ Perform a curves adjustment on an image :param image: evaluate the curve at these points can be pil image or numpy array :param controlPoints: set of [x,y] points that define the mapping :param clampBlack: clamp the black pixels to this value :param clampBlack: clamp the white pixels to this value :param degree: polynomial degree (if omitted, make it the same as the number of control points) :param extrapolate: go beyond the defined area of the curve to get values (oterwise returns NaN for outside values) :return: the adjusted image """ import scipy.interpolate img = numpyArray(image) count = len(controlPoints) if degree is None: degree = count - 1 else: degree = np.clip(degree, 1, count - 1) knots = np.clip(np.arange(count + degree + 1) - degree, 0, count - degree) spline = scipy.interpolate.BSpline(knots, controlPoints, degree) if len(img.shape) < 3: # for some reason it keeps the original point, which we need to strip off resultPoints = spline(img[:, :], extrapolate=extrapolate)[:, :, 0] else: # for some reason it keeps the original point, which we need to strip off resultPoints = spline(img[:, :, :], extrapolate=extrapolate)[:, :, :, 0] resultPoints = clampImage(resultPoints, clampBlack, clampWhite) return pilImage(resultPoints)
# -*- coding: utf-8 -*- import bohrium as np from math import pi import matplotlib.pyplot as plt import matplotlib.colors as colors fig = plt.figure() plt.xticks([]) plt.yticks([]) k = 5 # number of plane waves stripes = 37 # number of stripes per wave N = 512 # image size in pixels ite = 30 # iterations phases = np.arange(0, 2 * pi, 2 * pi / ite) image = np.empty((N, N)) d = np.arange(-N / 2, N / 2, dtype=np.float64) xv, yv = np.meshgrid(d, d) theta = np.arctan2(yv, xv) r = np.log(np.sqrt(xv * xv + yv * yv)) r[np.isinf(r) == True] = 0 tcos = theta * np.cos(np.arange(0, pi, pi / k))[:, np.newaxis, np.newaxis] rsin = r * np.sin(np.arange(0, pi, pi / k))[:, np.newaxis, np.newaxis] inner = (tcos - rsin) * stripes cinner = np.cos(inner) sinner = np.sin(inner)
G_dir.add_edges_from(G_undir.edges()) A = nx.to_numpy_matrix(G_dir.to_undirected(), dtype=np.bool) A = np.asarray(A, dtype=np.bool) #fig = plt.figure(figsize=(5, 5)) #plt.title("Adjacency Matrix") #plt.imshow(A,cmap="Greys",interpolation="none") #%matplotlib inline #sns.heatmap(A, cmap="Greys") #plt.show() #storex = np.zeros((N,steps)) #storex_noava = np.zeros((N,steps)) temp = np.arange(0, int(2 * G_undir.number_of_edges())) R = [(temp[2 * i], temp[2 * i + 1]) for i in range(G_undir.number_of_edges())] recency = {} for edge, rec in zip(G_dir.edges(), R): recency[edge] = {'recency': rec} nx.set_edge_attributes(G_dir, recency) #print() #print(G_dir.edges(data=True)) print(G_dir.edges(data=True)) degree = np.array(np.sum(A, 0), dtype=np.int32) G_undir.clear() del (R)