static PyObject *Py_RankFilter(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL, *footprint = NULL;
PyArray_Dims origin;
int mode, rank;
double cval;
if (!PyArg_ParseTuple(args, "O&iO&O&idO&",
NI_ObjectToInputArray, &input, &rank,
NI_ObjectToInputArray, &footprint,
NI_ObjectToOutputArray, &output,
&mode, &cval,
PyArray_IntpConverter, &origin)) {
goto exit;
}
if (!_validate_origin(input, origin)) {
goto exit;
}
NI_RankFilter(input, rank, footprint, output, (NI_ExtendMode)mode, cval,
origin.ptr);
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
Py_XDECREF(input);
Py_XDECREF(footprint);
Py_XDECREF(output);
PyDimMem_FREE(origin.ptr);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
static void
array_dealloc(PyArrayObject *self) {
_array_dealloc_buffer_info(self);
if (self->weakreflist != NULL) {
PyObject_ClearWeakRefs((PyObject *)self);
}
if (self->base) {
/*
* UPDATEIFCOPY means that base points to an
* array that should be updated with the contents
* of this array upon destruction.
* self->base->flags must have been WRITEABLE
* (checked previously) and it was locked here
* thus, unlock it.
*/
if (self->flags & UPDATEIFCOPY) {
((PyArrayObject *)self->base)->flags |= WRITEABLE;
Py_INCREF(self); /* hold on to self in next call */
if (PyArray_CopyAnyInto((PyArrayObject *)self->base, self) < 0) {
PyErr_Print();
PyErr_Clear();
}
/*
* Don't need to DECREF -- because we are deleting
*self already...
*/
}
/*
* In any case base is pointing to something that we need
* to DECREF -- either a view or a buffer object
*/
Py_DECREF(self->base);
}
if ((self->flags & OWNDATA) && self->data) {
/* Free internal references if an Object array */
if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) {
Py_INCREF(self); /*hold on to self */
PyArray_XDECREF(self);
/*
* Don't need to DECREF -- because we are deleting
* self already...
*/
}
PyDataMem_FREE(self->data);
}
PyDimMem_FREE(self->dimensions);
Py_DECREF(self->descr);
Py_TYPE(self)->tp_free((PyObject *)self);
}
static PyObject *Py_BinaryErosion(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL, *strct = NULL;
PyArrayObject *mask = NULL;
PyObject *cobj = NULL;
int border_value, invert, center_is_true;
int changed = 0, return_coordinates;
NI_CoordinateList *coordinate_list = NULL;
PyArray_Dims origin;
if (!PyArg_ParseTuple(args, "O&O&O&O&iO&iii",
NI_ObjectToInputArray, &input,
NI_ObjectToInputArray, &strct,
NI_ObjectToOptionalInputArray, &mask,
NI_ObjectToOutputArray, &output,
&border_value,
PyArray_IntpConverter, &origin,
&invert, ¢er_is_true, &return_coordinates)) {
goto exit;
}
if (!_validate_origin(input, origin)) {
goto exit;
}
if (!NI_BinaryErosion(input, strct, mask, output, border_value,
origin.ptr, invert, center_is_true, &changed,
return_coordinates ? &coordinate_list : NULL)) {
goto exit;
}
if (return_coordinates) {
cobj = NpyCapsule_FromVoidPtr(coordinate_list, _FreeCoordinateList);
}
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
Py_XDECREF(input);
Py_XDECREF(strct);
Py_XDECREF(mask);
Py_XDECREF(output);
PyDimMem_FREE(origin.ptr);
if (PyErr_Occurred()) {
Py_XDECREF(cobj);
return NULL;
} else {
if (return_coordinates) {
return Py_BuildValue("iN", changed, cobj);
} else {
return Py_BuildValue("i", changed);
}
}
}
/*NUMPY_API
* Get intp chunk from sequence
*
* This function takes a Python sequence object and allocates and
* fills in an intp array with the converted values.
*
* Remember to free the pointer seq.ptr when done using
* PyDimMem_FREE(seq.ptr)**
*/
NPY_NO_EXPORT int
PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)
{
Py_ssize_t len;
int nd;
seq->ptr = NULL;
seq->len = 0;
if (obj == Py_None) {
return NPY_SUCCEED;
}
len = PySequence_Size(obj);
if (len == -1) {
/* Check to see if it is an integer number */
if (PyNumber_Check(obj)) {
/*
* After the deprecation the PyNumber_Check could be replaced
* by PyIndex_Check.
* FIXME 1.9 ?
*/
len = 1;
}
}
if (len < 0) {
PyErr_SetString(PyExc_TypeError,
"expected sequence object with len >= 0 or a single integer");
return NPY_FAIL;
}
if (len > NPY_MAXDIMS) {
PyErr_Format(PyExc_ValueError, "sequence too large; "
"cannot be greater than %d", NPY_MAXDIMS);
return NPY_FAIL;
}
if (len > 0) {
seq->ptr = PyDimMem_NEW(len);
if (seq->ptr == NULL) {
PyErr_NoMemory();
return NPY_FAIL;
}
}
seq->len = len;
nd = PyArray_IntpFromIndexSequence(obj, (npy_intp *)seq->ptr, len);
if (nd == -1 || nd != len) {
PyDimMem_FREE(seq->ptr);
seq->ptr = NULL;
return NPY_FAIL;
}
return NPY_SUCCEED;
}
/*NUMPY_API
* Get intp chunk from sequence
*
* This function takes a Python sequence object and allocates and
* fills in an intp array with the converted values.
*
* Remember to free the pointer seq.ptr when done using
* PyDimMem_FREE(seq.ptr)**
*/
NPY_NO_EXPORT int
PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)
{
int len;
int nd;
seq->ptr = NULL;
seq->len = 0;
if (obj == Py_None) {
return PY_SUCCEED;
}
len = PySequence_Size(obj);
if (len == -1) {
/* Check to see if it is a number */
if (PyNumber_Check(obj)) {
len = 1;
}
}
if (len < 0) {
PyErr_SetString(PyExc_TypeError,
"expected sequence object with len >= 0");
return PY_FAIL;
}
if (len > MAX_DIMS) {
PyErr_Format(PyExc_ValueError, "sequence too large; " \
"must be smaller than %d", MAX_DIMS);
return PY_FAIL;
}
if (len > 0) {
seq->ptr = PyDimMem_NEW(len);
if (seq->ptr == NULL) {
PyErr_NoMemory();
return PY_FAIL;
}
}
seq->len = len;
nd = PyArray_IntpFromSequence(obj, (intp *)seq->ptr, len);
if (nd == -1 || nd != len) {
PyDimMem_FREE(seq->ptr);
seq->ptr = NULL;
return PY_FAIL;
}
return PY_SUCCEED;
}
static PyObject *Py_BinaryErosion2(PyObject *obj, PyObject *args)
{
PyArrayObject *array = NULL, *strct = NULL, *mask = NULL;
PyObject *cobj = NULL;
int invert, niter;
PyArray_Dims origin;
if (!PyArg_ParseTuple(args, "O&O&O&iO&iO",
NI_ObjectToInputOutputArray, &array,
NI_ObjectToInputArray, &strct,
NI_ObjectToOptionalInputArray,
&mask, &niter,
PyArray_IntpConverter, &origin,
&invert, &cobj)) {
goto exit;
}
if (!_validate_origin(array, origin)) {
goto exit;
}
if (NpyCapsule_Check(cobj)) {
NI_CoordinateList *cobj_data = NpyCapsule_AsVoidPtr(cobj);
if (!NI_BinaryErosion2(array, strct, mask, niter, origin.ptr, invert,
&cobj_data)) {
goto exit;
}
}
else {
PyErr_SetString(PyExc_RuntimeError, "cannot convert CObject");
}
exit:
Py_XDECREF(array);
Py_XDECREF(strct);
Py_XDECREF(mask);
PyDimMem_FREE(origin.ptr);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
/* unravel_index implementation - see add_newdocs.py */
NPY_NO_EXPORT PyObject *
arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *indices0 = NULL, *ret_tuple = NULL;
PyArrayObject *ret_arr = NULL;
PyArrayObject *indices = NULL;
PyArray_Descr *dtype = NULL;
PyArray_Dims dimensions={0,0};
NPY_ORDER order = NPY_CORDER;
npy_intp unravel_size;
NpyIter *iter = NULL;
int i, ret_ndim;
npy_intp ret_dims[NPY_MAXDIMS], ret_strides[NPY_MAXDIMS];
char *kwlist[] = {"indices", "dims", "order", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|O&:unravel_index",
kwlist,
&indices0,
PyArray_IntpConverter, &dimensions,
PyArray_OrderConverter, &order)) {
goto fail;
}
if (dimensions.len == 0) {
PyErr_SetString(PyExc_ValueError,
"dims must have at least one value");
goto fail;
}
unravel_size = PyArray_MultiplyList(dimensions.ptr, dimensions.len);
if (!PyArray_Check(indices0)) {
indices = (PyArrayObject*)PyArray_FromAny(indices0,
NULL, 0, 0, 0, NULL);
if (indices == NULL) {
goto fail;
}
}
else {
indices = (PyArrayObject *)indices0;
Py_INCREF(indices);
}
dtype = PyArray_DescrFromType(NPY_INTP);
if (dtype == NULL) {
goto fail;
}
iter = NpyIter_New(indices, NPY_ITER_READONLY|
NPY_ITER_ALIGNED|
NPY_ITER_BUFFERED|
NPY_ITER_ZEROSIZE_OK|
NPY_ITER_DONT_NEGATE_STRIDES|
NPY_ITER_MULTI_INDEX,
NPY_KEEPORDER, NPY_SAME_KIND_CASTING,
dtype);
if (iter == NULL) {
goto fail;
}
/*
* Create the return array with a layout compatible with the indices
* and with a dimension added to the end for the multi-index
*/
ret_ndim = PyArray_NDIM(indices) + 1;
if (NpyIter_GetShape(iter, ret_dims) != NPY_SUCCEED) {
goto fail;
}
ret_dims[ret_ndim-1] = dimensions.len;
if (NpyIter_CreateCompatibleStrides(iter,
dimensions.len*sizeof(npy_intp), ret_strides) != NPY_SUCCEED) {
goto fail;
}
ret_strides[ret_ndim-1] = sizeof(npy_intp);
/* Remove the multi-index and inner loop */
if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
if (NpyIter_EnableExternalLoop(iter) != NPY_SUCCEED) {
goto fail;
}
ret_arr = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
ret_ndim, ret_dims, ret_strides, NULL, 0, NULL);
dtype = NULL;
if (ret_arr == NULL) {
goto fail;
}
if (order == NPY_CORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_corder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else if (order == NPY_FORTRANORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_forder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else {
PyErr_SetString(PyExc_ValueError,
"only 'C' or 'F' order is permitted");
goto fail;
}
/* Now make a tuple of views, one per index */
ret_tuple = PyTuple_New(dimensions.len);
if (ret_tuple == NULL) {
goto fail;
}
for (i = 0; i < dimensions.len; ++i) {
PyArrayObject *view;
view = (PyArrayObject *)PyArray_New(&PyArray_Type, ret_ndim-1,
ret_dims, NPY_INTP,
ret_strides,
PyArray_BYTES(ret_arr) + i*sizeof(npy_intp),
0, NPY_ARRAY_WRITEABLE, NULL);
if (view == NULL) {
goto fail;
}
Py_INCREF(ret_arr);
if (PyArray_SetBaseObject(view, (PyObject *)ret_arr) < 0) {
Py_DECREF(view);
goto fail;
}
PyTuple_SET_ITEM(ret_tuple, i, PyArray_Return(view));
}
Py_DECREF(ret_arr);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return ret_tuple;
fail:
Py_XDECREF(ret_tuple);
Py_XDECREF(ret_arr);
Py_XDECREF(dtype);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return NULL;
}
/* ravel_multi_index implementation - see add_newdocs.py */
NPY_NO_EXPORT PyObject *
arr_ravel_multi_index(PyObject *self, PyObject *args, PyObject *kwds)
{
int i, s;
PyObject *mode0=NULL, *coords0=NULL;
PyArrayObject *ret = NULL;
PyArray_Dims dimensions={0,0};
npy_intp ravel_strides[NPY_MAXDIMS];
NPY_ORDER order = NPY_CORDER;
NPY_CLIPMODE modes[NPY_MAXDIMS];
PyArrayObject *op[NPY_MAXARGS];
PyArray_Descr *dtype[NPY_MAXARGS];
npy_uint32 op_flags[NPY_MAXARGS];
NpyIter *iter = NULL;
char *kwlist[] = {"multi_index", "dims", "mode", "order", NULL};
memset(op, 0, sizeof(op));
dtype[0] = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"OO&|OO&:ravel_multi_index", kwlist,
&coords0,
PyArray_IntpConverter, &dimensions,
&mode0,
PyArray_OrderConverter, &order)) {
goto fail;
}
if (dimensions.len+1 > NPY_MAXARGS) {
PyErr_SetString(PyExc_ValueError,
"too many dimensions passed to ravel_multi_index");
goto fail;
}
if (!PyArray_ConvertClipmodeSequence(mode0, modes, dimensions.len)) {
goto fail;
}
switch (order) {
case NPY_CORDER:
s = 1;
for (i = dimensions.len-1; i >= 0; --i) {
ravel_strides[i] = s;
s *= dimensions.ptr[i];
}
break;
case NPY_FORTRANORDER:
s = 1;
for (i = 0; i < dimensions.len; ++i) {
ravel_strides[i] = s;
s *= dimensions.ptr[i];
}
break;
default:
PyErr_SetString(PyExc_ValueError,
"only 'C' or 'F' order is permitted");
goto fail;
}
/* Get the multi_index into op */
if (sequence_to_arrays(coords0, op, dimensions.len, "multi_index") < 0) {
goto fail;
}
for (i = 0; i < dimensions.len; ++i) {
op_flags[i] = NPY_ITER_READONLY|
NPY_ITER_ALIGNED;
}
op_flags[dimensions.len] = NPY_ITER_WRITEONLY|
NPY_ITER_ALIGNED|
NPY_ITER_ALLOCATE;
dtype[0] = PyArray_DescrFromType(NPY_INTP);
for (i = 1; i <= dimensions.len; ++i) {
dtype[i] = dtype[0];
}
iter = NpyIter_MultiNew(dimensions.len+1, op, NPY_ITER_BUFFERED|
NPY_ITER_EXTERNAL_LOOP|
NPY_ITER_ZEROSIZE_OK,
NPY_KEEPORDER,
NPY_SAME_KIND_CASTING,
op_flags, dtype);
if (iter == NULL) {
goto fail;
}
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr;
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
if (ravel_multi_index_loop(dimensions.len, dimensions.ptr,
ravel_strides, *countptr, modes,
dataptr, strides) != NPY_SUCCEED) {
goto fail;
}
} while(iternext(iter));
}
ret = NpyIter_GetOperandArray(iter)[dimensions.len];
Py_INCREF(ret);
Py_DECREF(dtype[0]);
for (i = 0; i < dimensions.len; ++i) {
Py_XDECREF(op[i]);
}
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return PyArray_Return(ret);
fail:
Py_XDECREF(dtype[0]);
for (i = 0; i < dimensions.len; ++i) {
Py_XDECREF(op[i]);
}
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return NULL;
}
static PyObject *Py_GenericFilter(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL, *footprint = NULL;
PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL;
void *func = NULL, *data = NULL;
NI_PythonCallbackData cbdata;
int mode;
PyArray_Dims origin;
double cval;
ccallback_t callback;
static ccallback_signature_t callback_signatures[] = {
{"int (double *, intptr_t, double *, void *)"},
{"int (double *, npy_intp, double *, void *)"},
#if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT
{"int (double *, short, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_INT
{"int (double *, int, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG
{"int (double *, long, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG
{"int (double *, long long, double *, void *)"},
#endif
{NULL}
};
callback.py_function = NULL;
callback.c_function = NULL;
if (!PyArg_ParseTuple(args, "O&OO&O&idO&OO",
NI_ObjectToInputArray, &input,
&fnc,
NI_ObjectToInputArray, &footprint,
NI_ObjectToOutputArray, &output,
&mode, &cval,
PyArray_IntpConverter, &origin,
&extra_arguments, &extra_keywords)) {
goto exit;
}
if (!_validate_origin(input, origin)) {
goto exit;
}
if (!PyTuple_Check(extra_arguments)) {
PyErr_SetString(PyExc_RuntimeError, "extra_arguments must be a tuple");
goto exit;
}
if (!PyDict_Check(extra_keywords)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_keywords must be a dictionary");
goto exit;
}
if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) {
func = PyCapsule_GetPointer(fnc, NULL);
data = PyCapsule_GetContext(fnc);
#if PY_VERSION_HEX < 0x03000000
} else if (PyCObject_Check(fnc)) {
/* 'Legacy' low-level callable on Py2 */
func = PyCObject_AsVoidPtr(fnc);
data = PyCObject_GetDesc(fnc);
#endif
} else {
int ret;
ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS);
if (ret == -1) {
goto exit;
}
if (callback.py_function != NULL) {
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
callback.info_p = (void*)&cbdata;
func = Py_FilterFunc;
data = (void*)&callback;
}
else {
func = callback.c_function;
data = callback.user_data;
}
}
NI_GenericFilter(input, func, data, footprint, output, (NI_ExtendMode)mode,
cval, origin.ptr);
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
if (callback.py_function != NULL || callback.c_function != NULL) {
ccallback_release(&callback);
}
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(footprint);
PyDimMem_FREE(origin.ptr);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}