def iterate(board): """ Funkcja pobiera planszę game of life i zwraca jej następną iterację. Zasady Game of life są takie: 1. Komórka może być albo żywa albo martwa. 2. Jeśli komórka jest martwa i ma trzech sąsiadóœ to ożywa. 3. Jeśli komórka jest żywa i ma mniej niż dwóch sąsiadów to umiera, jeśli ma więcej niż trzech sąsiadóœ również umiera. W przeciwnym wypadku (dwóch lub trzech sąsiadów) to żyje dalej. :param np.ndarray board: Dwuwymiarowa tablica zmiennych logicznych która obrazuje aktualny stan game of life. Jeśli w danym polu jest True (lub 1) oznacza to że dana komórka jest obsadzona """ from numpy import logical_and as land, logical_or as lor, logical_not as lnot # print(board) board = board.astype(np.bool) neigh = calculate_neighbours(board) # print(neigh) ozywa = land(board == False, neigh == 3) umiera = lnot(land( board == True, lor( neigh < 2, neigh > 3) )) # print(ozywa) # print(umiera) board2 = land(lor(board, ozywa), umiera) return(board2)
def recurtime(array0, array1, border=None, exclude_zero=False, relative_time=False): """Return a list of time bef and time aft array0 if border is None, put nan for missing values (first and last time) if border is "exclude" keep only time with a tbef and a taft if exclude_zero is True, do not count synchronous times if relative_time,return the shift, otherwise the absolute time """ if not array0.size or not array1.size: print("One empty array in recurtime") if border is None: return [np.ones(array0.size) * np.inf] * 2 else: return [np.array([])] * 2 # initalise output exact_match = np.zeros(array0.shape, dtype=bool) afts = np.zeros(array0.shape) + np.nan tbefs = np.zeros(array0.shape) + np.nan tafts = np.zeros(array0.shape) + np.nan # search array0 in array1 ind = array1.searchsorted(array0) # first deal with the middle: tbefs[ind > 0] = array1[ind[ind > 0] - 1] tafts[ind < len(array1)] = array1[ind[ind < len(array1)]] # find exact match: exact_match = tafts == array0 if exclude_zero: # pb if the last match is exact lastmatch = ind >= len(array1) - 1 to_push = land(exact_match, lnot(lastmatch)) to_nan = land(exact_match, lastmatch) tafts[to_push] = array1[ind[to_push] + 1] tafts[to_nan] = np.nan else: tbefs[exact_match] = array0[exact_match] tafts[exact_match] = array0[exact_match] if relative_time: tbefs = array0 - tbefs tafts = tafts - array0 if border == 'exclude': to_ret = land(lnot(np.isnan(tbefs)), lnot(np.isnan(tbafts))) else: to_ret = ones(tbefs.shape, dtype=bool) return tbefs[to_ret], tafts[to_ret]
def _groub_by(p, tol, r): g, gm, gp = [], [], p - p[0] while True: if gp[-1] < 0: break ndx = where(land(0. <= gp, gp < tol))[0] if 0 < len(ndx): g.append(ndx) gm.append(p[ndx].mean()) gp -= tol return g, array([gm, [r] * len(gm)])
def _groub_by(p, tol, r): g, gm, gp= [], [], p- p[0] while True: if gp[-1]< 0: break ndx= where(land(0.<= gp, gp< tol))[0] if 0< len(ndx): g.append(ndx) gm.append(p[ndx].mean()) gp-= tol return g, array([gm, [r]* len(gm)])
def cube2world(u, v): # [u,v] = meshgrid(0:3/(3*dim-1):3, 0:4/(4*dim-1):4); # u and v are in the [0,1] interval, so put them back to [0,3] # and [0,4] u = u * 3 v = v * 4 x = np.zeros(u.shape) y = np.zeros(u.shape) z = np.zeros(u.shape) valid = np.zeros(u.shape, dtype='bool') # up indUp = land(land(u >= 1, u < 2), v < 1) x[indUp] = (u[indUp] - 1.5) * 2 y[indUp] = 1 z[indUp] = (v[indUp] - 0.5) * -2 # left indLeft = land(land(u < 1, v >= 1), v < 2) x[indLeft] = -1 y[indLeft] = (v[indLeft] - 1.5) * -2 z[indLeft] = (u[indLeft] - 0.5) * -2 # forward indForward = land(land(land(u >= 1, u < 2), v >= 1), v < 2) x[indForward] = (u[indForward] - 1.5) * 2 y[indForward] = (v[indForward] - 1.5) * -2 z[indForward] = -1 # right indRight = land(land(u >= 2, v >= 1), v < 2) x[indRight] = 1 y[indRight] = (v[indRight] - 1.5) * -2 z[indRight] = (u[indRight] - 2.5) * 2 # down indDown = land(land(land(u >= 1, u < 2), v >= 2), v < 3) x[indDown] = (u[indDown] - 1.5) * 2 y[indDown] = -1 z[indDown] = (v[indDown] - 2.5) * 2 # backward indBackward = land(land(u >= 1, u < 2), v >= 3) x[indBackward] = (u[indBackward] - 1.5) * 2 y[indBackward] = (v[indBackward] - 3.5) * 2 z[indBackward] = 1 # normalize # np.hypot(x, y, z) #sqrt(x.^2 + y.^2 + z.^2); norm = np.sqrt(x**2 + y**2 + z**2) x = x / norm y = y / norm z = z / norm # return valid indices valid_ind = lor( lor(lor(indUp, indLeft), lor(indForward, indRight)), lor(indDown, indBackward)) valid[valid_ind] = 1 return x, y, z, valid
def world2cube(x, y, z): # world -> cube u = np.zeros(x.shape) v = np.zeros(x.shape) # forward indForward = np.nonzero( land(land(z <= 0, z <= -np.abs(x)), z <= -np.abs(y))) u[indForward] = 1.5 - 0.5 * x[indForward] / z[indForward] v[indForward] = 1.5 + 0.5 * y[indForward] / z[indForward] # backward indBackward = np.nonzero( land(land(z >= 0, z >= np.abs(x)), z >= np.abs(y))) u[indBackward] = 1.5 + 0.5 * x[indBackward] / z[indBackward] v[indBackward] = 3.5 + 0.5 * y[indBackward] / z[indBackward] # down indDown = np.nonzero( land(land(y <= 0, y <= -np.abs(x)), y <= -np.abs(z))) u[indDown] = 1.5 - 0.5 * x[indDown] / y[indDown] v[indDown] = 2.5 - 0.5 * z[indDown] / y[indDown] # up indUp = np.nonzero(land(land(y >= 0, y >= np.abs(x)), y >= np.abs(z))) u[indUp] = 1.5 + 0.5 * x[indUp] / y[indUp] v[indUp] = 0.5 - 0.5 * z[indUp] / y[indUp] # left indLeft = np.nonzero( land(land(x <= 0, x <= -np.abs(y)), x <= -np.abs(z))) u[indLeft] = 0.5 + 0.5 * z[indLeft] / x[indLeft] v[indLeft] = 1.5 + 0.5 * y[indLeft] / x[indLeft] # right indRight = np.nonzero(land(land(x >= 0, x >= np.abs(y)), x >= np.abs(z))) u[indRight] = 2.5 + 0.5 * z[indRight] / x[indRight] v[indRight] = 1.5 - 0.5 * y[indRight] / x[indRight] # bring back in the [0,1] intervals u = u / 3 v = v / 4 return u, v
def _p_poly_dists(xs,ys,xv,yv): """ http://www.mathworks.com/matlabcentral/fileexchange/19398-distance-from-a-point-to-polygon/content/p_poly_dist.m function: p_poly_dist Description: distance from many points to polygon whose vertices are specified by the vectors xv and yv Input: xs - points' x coordinates ys - points' y coordinates xv - vector of polygon vertices x coordinates yv - vector of polygon vertices x coordinates Output: d - distance from point to polygon (defined as a minimal distance from point to any of polygon's ribs, positive if the point is outside the polygon and negative otherwise) x_poly: x coordinate of the point in the polygon closest to x,y y_poly: y coordinate of the point in the polygon closest to x,y Routines: p_poly_dist.m Revision history: 03/31/2008 - return the point of the polygon closest to x,y - added the test for the case where a polygon rib is either horizontal or vertical. From Eric Schmitz. - Changes by Alejandro Weinstein 7/9/2006 - case when all projections are outside of polygon ribs 23/5/2004 - created by Michael Yoshpe function [d,x_poly,y_poly] = p_poly_dist(x, y, xv, yv) """ xs = array(xs) ys = array(ys) xv = array(xv) yv = array(yv) Nv = len(xv)-1 if ((xv[0] != xv[Nv]) or (yv[0] != yv[Nv])): xv = append(xv,xv[0]) yv = append(yv,yv[0]) # Nv = Nv + 1 # linear parameters of segments that connect the vertices # Ax + By + C = 0 A = -diff(yv) B = diff(xv) C = yv[1:]*xv[:-1] - xv[1:]*yv[:-1] # find the projection of each point (x,y) on each rib AB = 1./(A**2 + B**2) vv = outer(xs,A)+outer(ys,B)+C xps = (xs - (A*AB*vv).T).T yps = (ys - (B*AB*vv).T).T # Test for the case where a polygon rib is # either horizontal or vertical. From Eric Schmitz i = where(diff(xv)==0) xps[:,i]=xv[i] i = where(diff(yv)==0) yps[:,i]=yv[i] # find all cases where projected point is inside the segment idx_x = lor(land(xv[:-1]<xps,xps<xv[1:]),land(xv[1:]<xps,xps<xv[:-1])) idx_y = lor(land(yv[:-1]<yps,yps<yv[1:]),land(yv[1:]<yps,yps<yv[:-1])) idx = land(idx_x,idx_y) idxsum = idx.sum(axis=1) ds = zeros(len(xs)) x_polys = zeros(len(xs)) y_polys = zeros(len(xs)) offribs = where(idxsum==0)[0] #all projections outside of polygon ribs if len(offribs) > 0: dvs = hypot(subouter(xv[:-1],xs[offribs]), subouter(yv[:-1],ys[offribs])) I = argmin(dvs,axis=0) ds[offribs] = dvs[I,range(len(I))] x_polys[offribs] = xv[I] y_polys[offribs] = yv[I] onrib = where(idxsum!=0)[0] idx2 = idx[onrib] if len(onrib) > 0: dps = ma.masked_array(empty(idx2.shape), mask=lnot(idx2)) dps[idx2] = hypot(xps[idx]-xs[where(idx)[0]], yps[idx]-ys[where(idx)[0]]) # minds = dps.min(axis=0) # idxs = where(dps == minds) I = argmin(dps,axis=1) ds[onrib] = dps[range(len(I)),I] x_polys[onrib] = xps[onrib,I] y_polys[onrib] = yps[onrib,I] # if(inpolygon(x, y, xv, yv)) # d = -d # end return ds,x_polys,y_polys
def _p_poly_dist(x,y,xv,yv): """ function: p_poly_dist Description: distance from point to polygon whose vertices are specified by the vectors xv and yv Input: x - point's x coordinate y - point's y coordinate xv - vector of polygon vertices x coordinates yv - vector of polygon vertices x coordinates Output: d - distance from point to polygon (defined as a minimal distance from point to any of polygon's ribs, positive if the point is outside the polygon and negative otherwise) x_poly: x coordinate of the point in the polygon closest to x,y y_poly: y coordinate of the point in the polygon closest to x,y Routines: p_poly_dist.m Revision history: 03/31/2008 - return the point of the polygon closest to x,y - added the test for the case where a polygon rib is either horizontal or vertical. From Eric Schmitz. - Changes by Alejandro Weinstein 7/9/2006 - case when all projections are outside of polygon ribs 23/5/2004 - created by Michael Yoshpe function [d,x_poly,y_poly] = p_poly_dist(x, y, xv, yv) """ Nv = len(xv)-1 if ((xv[0] != xv[Nv]) or (yv[0] != yv[Nv])): xv = append(xv,xv[0]) yv = append(yv,yv[0]) # Nv = Nv + 1 # linear parameters of segments that connect the vertices # Ax + By + C = 0 A = -diff(yv) B = diff(xv) C = yv[1:]*xv[:-1] - xv[1:]*yv[:-1] # find the projection of point (x,y) on each rib AB = 1./(A**2 + B**2) vv = (A*x+B*y+C) xp = x - (A*AB)*vv yp = y - (B*AB)*vv # Test for the case where a polygon rib is # either horizontal or vertical. From Eric Schmitz i = where(diff(xv)==0) xp[i]=xv[i] i = where(diff(yv)==0) yp[i]=yv[i] # find all cases where projected point is inside the segment idx_x = lor(land(xv[:-1]<xp,xp<xv[1:]),land(xv[1:]<xp,xp<xv[:-1])) idx_y = lor(land(yv[:-1]<yp,yp<yv[1:]),land(yv[1:]<yp,yp<yv[:-1])) idx = land(idx_x,idx_y) if idx.sum()==0:#no True, all projections are outside of polygon ribs # distance from point (x,y) to the vertices dv = hypot(xv[:-1]-x,yv[:-1]-y) I = argmin(dv) d = dv[I] x_poly = xv[I] y_poly = yv[I] else: # distance from point (x,y) to the projection on ribs dp = hypot(xp[idx]-x,yp[idx]-y) # d = min(dp) # idxs = where(dp == d) I = argmin(dp) d = dp[I] x_poly = xp[idx][I] y_poly = yp[idx][I] # if(inpolygon(x, y, xv, yv)) # d = -d # end return d,x_poly,y_poly
# The masks apply to ranges you don't want, they're MASKED! # the result is an array with the values you do want # # Include points not exceeding the input threshold mx_include = ma.masked_array(tt1, mask=(tt1 > threshold)) # Exclude points that exceed the input threshold mx_exclude = ma.masked_array(tt1, mask=(tt1 < threshold)) exclude_counts.append(mx_exclude.count()) else: mx_include = tt1 mx_exclude = ma.masked_array([]) exclude_counts.append(0) r1counts.append( ma.masked_array(tt1, land(tt1 >= s1Left, tt1 <= s1Right)).count()) r2counts.append( ma.masked_array( tt1, lor(land(tt1 <= s1Left, tt1 >= s2Left), land(tt1 >= s1Right, tt1 <= s2Right))).count()) r3counts.append( ma.masked_array( tt1, lor(land(tt1 <= s2Left, tt1 >= s3Left), land(tt1 >= s2Right, tt1 <= s3Right))).count()) if threshold is not None: print '\tExtreme counts greater than %f = %d' % ( threshold, mx_exclude.count())
def contains_points(self, points): """Like contains_point but takes a list or array of points.""" xs, ys = array(points).T return land( land(self._min.x <= xs, xs < self._max.x), land(self._min.y < ys, ys <= self._max.y) )