def evolve(input, output, lookup): """Evolve it.""" return generate.inline(""" PyArrayObject *input; PyArrayObject *output; PyArrayObject *lookup; char h = 0; unsigned xstride, ystride; unsigned xa, x0, x1, xM; unsigned /*ya,*/ y0, y1, yM; unsigned z; char c, n, r; if (!PyArg_ParseTuple(args, "O!O!O!", &PyArray_Type, &input, &PyArray_Type, &output, &PyArray_Type, &lookup )) return NULL; xstride = input-> strides[0]; ystride = input-> strides[1]; xM = (input-> dimensions[0] - 1) * xstride; yM = (input-> dimensions[1] - 1) * ystride; xa = 0; for (x0 = xstride; x0 < xM; x0 += xstride) { xa = x0 - xstride; x1 = x0 + xstride; n = input-> data[x0 + 1 * ystride]; z = ((input-> data[xa + 0 * ystride] & 1) << 0x3) | ((input-> data[x0 + 0 * ystride] & 1) << 0x4) | ((input-> data[x1 + 0 * ystride] & 1) << 0x5) | ((input-> data[xa + 1 * ystride] & 1) << 0x6) | ((n & 1) << 0x7) | ((input-> data[x1 + 1 * ystride] & 1) << 0x8) ; for (y0 = ystride; y0 < yM; y0 += ystride) { z >>= 3; y1 = y0 + ystride; c = n; n = input-> data[x0 + y1]; z |=((input-> data[xa + y1] & 1) << 0x6) | ((n & 1) << 0x7) | ((input-> data[x1 + y1] & 1) << 0x8) ; r = lookup-> data[z | ((c & 0xFE) << 8)]; output-> data[x0 + y0] = (char)r; } } return PyFloat_FromDouble(1.0); """)(input, output, lookup)
def cc1_evolve(input, output, lookup): """Evolve it.""" output[:,:,0] *= lookup[9] #history X = input.shape[0] Y = input.shape[1] for i, (y,x) in enumerate( itertools.product((-1,0,1), (-1,0,1)) ): if lookup[i]: output[+1:-1,+1:-1,0] += input[x+1:X+x-1,y+1:Y+y-1,0] * lookup[i] if lookup[10]: output[:,:,0] += lookup[10] * input[:,:,1] if lookup[11]: denom = lookup[11] output[:,:,0] *= denom / (input[:,:,1] + denom) output[:,:,1] = input[:,:,1] M = numpy.max(numpy.abs(output[:,:,0])) if M > 10: #M = numpy.sum(numpy.square(numpy.abs(output[:,:,0]))) print 'rescaling %s' % M output[:,:,0] /= M input[:,:,0] /= M else: print '.' return return generate.inline(""" PyArrayObject *input; PyArrayObject *output; PyArrayObject *lookup; char h = 0; unsigned xstride, ystride; unsigned xa, x0, x1, xM; unsigned ya, y0, y1, yM; double daa, d0a, d1a; double da0, d00, d10; double da1, d01, d11; double d00d; double damp; double excite; double z; double rmin, rmax; double rn, rp; double *ind, *oud, *look; if (!PyArg_ParseTuple(args, "O!O!O!", &PyArray_Type, &input, &PyArray_Type, &output, &PyArray_Type, &lookup )) return NULL; xstride = input-> strides[0] >> 3; ystride = input-> strides[1] >> 3; xM = (input-> dimensions[0] - 1) * xstride; yM = (input-> dimensions[1] - 1) * ystride; ind = (double*)(input-> data); oud = (double*)(output-> data); look = (double*)(lookup-> data); daa = look[0]; d0a = look[1]; d1a = look[2]; da0 = look[3]; d00 = look[4]; d10 = look[5]; da1 = look[6]; d01 = look[7]; d11 = look[8]; d00d= look[9]; damp= look[10]; excite= look[11]; rmin = look[12]; rmax = look[13]; rn = look[14]; rp = look[15]; for (x0 = xstride; x0 < xM; x0 += xstride) { xa = x0 - xstride; x1 = x0 + xstride; for (y0 = ystride; y0 < yM; y0 += ystride) { ya = y0 - ystride; y1 = y0 + ystride; z = ind[xa + ya] * daa + ind[x0 + ya] * d0a + ind[x1 + ya] * d1a + ind[xa + y0] * da0 + ind[x0 + y0] * d00 + ind[x1 + y0] * d10 + ind[xa + y1] * da1 + ind[x0 + y1] * d01 + ind[x1 + y1] * d11 + oud[x0 + y0] * d00d; z *= damp; z += excite; if (z < rmin) z = rn; else if (z > rmax) z = rp; oud[x0 + y0] = z; } } return PyFloat_FromDouble(1.0); """)(input, output, lookup)
def dd1_evolve(input, output, lookup): """Evolve it.""" return generate.inline(""" PyArrayObject *input; PyArrayObject *output; PyArrayObject *lookup; char h = 0; unsigned xstride, ystride; unsigned xa, x0, x1, xM; unsigned ya, y0, y1, yM; double daa, d0a, d1a; double da0, d00, d10; double da1, d01, d11; double d00d; double damp; double excite; double z; double rmin, rmax; double rn, rp; double *ind, *oud, *look; if (!PyArg_ParseTuple(args, "O!O!O!", &PyArray_Type, &input, &PyArray_Type, &output, &PyArray_Type, &lookup )) return NULL; xstride = input-> strides[0] >> 3; ystride = input-> strides[1] >> 3; xM = (input-> dimensions[0] - 1) * xstride; yM = (input-> dimensions[1] - 1) * ystride; ind = (double*)(input-> data); oud = (double*)(output-> data); look = (double*)(lookup-> data); daa = look[0]; d0a = look[1]; d1a = look[2]; da0 = look[3]; d00 = look[4]; d10 = look[5]; da1 = look[6]; d01 = look[7]; d11 = look[8]; d00d= look[9]; damp= look[10]; excite= look[11]; rmin = look[12]; rmax = look[13]; rn = look[14]; rp = look[15]; for (x0 = xstride; x0 < xM; x0 += xstride) { xa = x0 - xstride; x1 = x0 + xstride; for (y0 = ystride; y0 < yM; y0 += ystride) { ya = y0 - ystride; y1 = y0 + ystride; z = ind[xa + ya] * daa + ind[x0 + ya] * d0a + ind[x1 + ya] * d1a + ind[xa + y0] * da0 + ind[x0 + y0] * d00 + ind[x1 + y0] * d10 + ind[xa + y1] * da1 + ind[x0 + y1] * d01 + ind[x1 + y1] * d11 + oud[x0 + y0] * d00d; z *= damp; z += excite; if (z < rmin) z = rn; else if (z > rmax) z = rp; oud[x0 + y0] = z; } } return PyFloat_FromDouble(1.0); """)(input, output, lookup)
def rivers_evolve(input, output, lookup): """Evolve it.""" return generate.inline(""" #define ABS(X) ((X) < 0 ? -(X) : +(X)) #define POS(X) ((X) > 0 ? (X) : 0) #define NEG(X) ((X) < 0 ? (X) : 0) #define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) #define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) #define VS 0.001 #define WS 0.2 #define WIN(V0, W0, V1, W1) (POS(MIN((W1), ((V1)+(W1))-((V0)+(W0)) ))) #define WOUT(V0, W0, V1, W1) (WIN((V1), (W1), (V0), (W0))) #define THRESH 0.2 // These define soil/water when we transform #define TRANSERODE 1.0 #define TRANSDEPOSIT 1.0 // These define rate of erosion/deposition per velocity unit #define RATEERODE 0.01 #define RATEDEPOSIT 0.001 PyArrayObject *input; PyArrayObject *output; PyArrayObject *lookup; char h = 0; unsigned xstride, ystride, zstride; unsigned xa, x0, x1, xM; unsigned ya, y0, y1, yM; double *ind, *oud, *look; double v00, va0, v10, v0a, v01; double w00, wa0, w10, w0a, w01; double win, wout; double wvel, Dw, Dv; if (!PyArg_ParseTuple(args, "O!O!O!", &PyArray_Type, &input, &PyArray_Type, &output, &PyArray_Type, &lookup )) return NULL; xstride = input-> strides[0] >> 3; ystride = input-> strides[1] >> 3; zstride = input-> strides[2] >> 3; xM = (input-> dimensions[0] - 1) * xstride; yM = (input-> dimensions[1] - 1) * ystride; //zM = (input-> dimensions[2] - 1) * zstride; ind = (double*)(input-> data); oud = (double*)(output-> data); look = (double*)(lookup-> data); for (x0 = xstride; x0 < xM; x0 += xstride) { xa = x0 - xstride; x1 = x0 + xstride; for (y0 = ystride; y0 < yM; y0 += ystride) { ya = y0 - ystride; y1 = y0 + ystride; // v00 is sediment, w00 is water. v00 = ind[x0 + y0 + 0*zstride]; va0 = ind[xa + y0 + 0*zstride]; v10 = ind[x1 + y0 + 0*zstride]; v0a = ind[x0 + ya + 0*zstride]; v01 = ind[x0 + y1 + 0*zstride]; w00 = ind[x0 + y0 + 1*zstride]; wa0 = ind[xa + y0 + 1*zstride]; w10 = ind[x1 + y0 + 1*zstride]; w0a = ind[x0 + ya + 1*zstride]; w01 = ind[x0 + y1 + 1*zstride]; // Determine water flow in. win = 0; win += WIN(v00, w00, va0, wa0); win += WIN(v00, w00, v10, w10); win += WIN(v00, w00, v0a, w0a); win += WIN(v00, w00, v01, w01); win *= WS; // Determine water flow out. wout = 0; wout += WOUT(v00, w00, va0, wa0); wout += WOUT(v00, w00, v10, w10); wout += WOUT(v00, w00, v0a, w0a); wout += WOUT(v00, w00, v01, w01); wout *= WS; w00 = POS(w00 + win - wout); Dw = Dv = 0; // Determine water velocity. if (w00 > 0) { wvel = win / w00; // Perform erosion. if (wvel > THRESH) { // Erosion Dw = (wvel - THRESH) * RATEERODE; Dv = -Dw * TRANSERODE; } else { // Deposition Dw = -MIN(w00, (THRESH - wvel) * RATEDEPOSIT); Dv = -Dw * TRANSDEPOSIT; } } // Determine sediment shift. Dv += VS * (va0 + v10 + v0a + v01 - 4 * v00); // Write results. oud[x0 + y0 + 0*zstride] = v00 + Dv; oud[x0 + y0 + 1*zstride] = w00 + Dw; } } return PyFloat_FromDouble(1.0); """)(input, output, lookup)