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)
