/*==========================================================================*/
PyObject *calculate(PyObject *self, PyObject *args)
{
long i, j;
KD kd;
int nReps=0, bPeriodic=0, bEwald=0;
float fSoft;
int nPos;
PyObject *kdobj, *acc, *pot, *pos;
PARTICLE *testParticles;
PyArg_ParseTuple(args, "OOOOdi", &kdobj, &pos, &acc, &pot, &fSoft, &nPos);
kd = PyCObject_AsVoidPtr(kdobj);
if (kd == NULL) return NULL;
testParticles = (PARTICLE *)malloc(nPos*sizeof(PARTICLE));
assert(testParticles != NULL);
for (i=0; i< nPos; i++) {
for (j=0; j < 3; j++) {
testParticles[i].r[j] =
(float)*((double *)PyArray_GETPTR2(pos, i, j));
testParticles[i].a[j] = 0;
}
testParticles[i].fMass = 0;
testParticles[i].fPot = 0;
testParticles[i].fSoft = fSoft;
testParticles[i].iOrder = i;
}
Py_BEGIN_ALLOW_THREADS
kdGravWalk(kd, nReps, bPeriodic && bEwald, testParticles, nPos);
Py_END_ALLOW_THREADS
for (i=0; i < nPos; i++) {
PyArray_SETITEM(pot, PyArray_GETPTR1(pot,i), PyFloat_FromDouble(testParticles[i].fPot));
for (j=0; j < 3; j++) {
PyArray_SETITEM(acc, PyArray_GETPTR2(acc, i, j),
PyFloat_FromDouble(testParticles[i].a[j]));
}
}
Py_DECREF(kd);
/*
Py_DECREF(pos);
Py_DECREF(pot);
Py_DECREF(acc);
*/
Py_INCREF(Py_None);
return Py_None;
}
/*
Resample a 3d image submitted to an affine transformation.
Tvox is the voxel transformation from the image to the destination grid.
*/
void cubic_spline_resample3d(PyArrayObject* im_resampled, const PyArrayObject* im,
const double* Tvox, int cast_integer,
int mode_x, int mode_y, int mode_z)
{
double i1;
PyObject* py_i1;
PyArrayObject* im_spline_coeff;
PyArrayIterObject* imIter = (PyArrayIterObject*)PyArray_IterNew((PyObject*)im_resampled);
unsigned int x, y, z;
unsigned dimX = PyArray_DIM(im, 0);
unsigned dimY = PyArray_DIM(im, 1);
unsigned dimZ = PyArray_DIM(im, 2);
npy_intp dims[3] = {dimX, dimY, dimZ};
double Tx, Ty, Tz;
/* Compute the spline coefficient image */
im_spline_coeff = (PyArrayObject*)PyArray_SimpleNew(3, dims, NPY_DOUBLE);
cubic_spline_transform(im_spline_coeff, im);
/* Force iterator coordinates to be updated */
UPDATE_ITERATOR_COORDS(imIter);
/* Resampling loop */
while(imIter->index < imIter->size) {
x = imIter->coordinates[0];
y = imIter->coordinates[1];
z = imIter->coordinates[2];
_apply_affine_transform(&Tx, &Ty, &Tz, Tvox, x, y, z);
i1 = cubic_spline_sample3d(Tx, Ty, Tz, im_spline_coeff, mode_x, mode_y, mode_z);
if (cast_integer)
i1 = ROUND(i1);
/* Copy interpolated value into numpy array */
py_i1 = PyFloat_FromDouble(i1);
PyArray_SETITEM(im_resampled, PyArray_ITER_DATA(imIter), py_i1);
Py_DECREF(py_i1);
/* Increment iterator */
PyArray_ITER_NEXT(imIter);
}
/* Free memory */
Py_DECREF(imIter);
Py_DECREF(im_spline_coeff);
return;
}
int Object_npyArrayAddItem(void *prv, JSOBJ obj, JSOBJ value)
{
PyObject* type;
PyArray_Descr* dtype;
npy_intp i;
char *new_data, *item;
NpyArrContext* npyarr = (NpyArrContext*) obj;
PRINTMARK();
if (!npyarr)
{
return 0;
}
i = npyarr->i;
npyarr->shape.ptr[npyarr->dec->curdim-1]++;
if (PyArray_Check((PyObject*)value))
{
// multidimensional array, keep decoding values.
return 1;
}
if (!npyarr->ret)
{
// Array not initialised yet.
// We do it here so we can 'sniff' the data type if none was provided
if (!npyarr->dec->dtype)
{
type = PyObject_Type(value);
if(!PyArray_DescrConverter(type, &dtype))
{
Py_DECREF(type);
goto fail;
}
Py_INCREF(dtype);
Py_DECREF(type);
}
else
{
dtype = PyArray_DescrNew(npyarr->dec->dtype);
}
// If it's an object or string then fill a Python list and subsequently
// convert. Otherwise we would need to somehow mess about with
// reference counts when renewing memory.
npyarr->elsize = dtype->elsize;
if (PyDataType_REFCHK(dtype) || npyarr->elsize == 0)
{
Py_XDECREF(dtype);
if (npyarr->dec->curdim > 1)
{
PyErr_SetString(PyExc_ValueError, "Cannot decode multidimensional arrays with variable length elements to numpy");
goto fail;
}
npyarr->elcount = 0;
npyarr->ret = PyList_New(0);
if (!npyarr->ret)
{
goto fail;
}
((JSONObjectDecoder*)npyarr->dec)->newArray = Object_npyNewArrayList;
((JSONObjectDecoder*)npyarr->dec)->arrayAddItem = Object_npyArrayListAddItem;
((JSONObjectDecoder*)npyarr->dec)->endArray = Object_npyEndArrayList;
return Object_npyArrayListAddItem(prv, obj, value);
}
npyarr->ret = PyArray_NewFromDescr(&PyArray_Type, dtype, 1,
&npyarr->elcount, NULL,NULL, 0, NULL);
if (!npyarr->ret)
{
goto fail;
}
}
if (i >= npyarr->elcount) {
// Grow PyArray_DATA(ret):
// this is similar for the strategy for PyListObject, but we use
// 50% overallocation => 0, 4, 8, 14, 23, 36, 56, 86 ...
if (npyarr->elsize == 0)
{
PyErr_SetString(PyExc_ValueError, "Cannot decode multidimensional arrays with variable length elements to numpy");
goto fail;
}
npyarr->elcount = (i >> 1) + (i < 4 ? 4 : 2) + i;
if (npyarr->elcount <= NPY_MAX_INTP/npyarr->elsize) {
new_data = PyDataMem_RENEW(PyArray_DATA(npyarr->ret), npyarr->elcount * npyarr->elsize);
}
else {
PyErr_NoMemory();
goto fail;
}
((PyArrayObject*) npyarr->ret)->data = (void*) new_data;
// PyArray_BYTES(npyarr->ret) = new_data;
}
PyArray_DIMS(npyarr->ret)[0] = i + 1;
if ((item = PyArray_GETPTR1(npyarr->ret, i)) == NULL
|| PyArray_SETITEM(npyarr->ret, item, value) == -1) {
goto fail;
}
Py_DECREF( (PyObject *) value);
npyarr->i++;
return 1;
fail:
Npy_releaseContext(npyarr);
return 0;
}
