int NI_GenericFilter(PyArrayObject* input,
int (*function)(double*, npy_intp, double*, void*), void *data,
PyArrayObject* footprint, PyArrayObject* output,
NI_ExtendMode mode, double cvalue, npy_intp *origins)
{
Bool *pf = NULL;
npy_intp fsize, jj, filter_size = 0, border_flag_value;
npy_intp *offsets = NULL, *oo, size;
NI_FilterIterator fi;
NI_Iterator ii, io;
char *pi, *po;
double *buffer = NULL;
int ll;
/* get the the footprint: */
fsize = 1;
for(ll = 0; ll < footprint->nd; ll++)
fsize *= footprint->dimensions[ll];
pf = (Bool*)PyArray_DATA(footprint);
for(jj = 0; jj < fsize; jj++) {
if (pf[jj])
++filter_size;
}
/* initialize filter offsets: */
if (!NI_InitFilterOffsets(input, pf, footprint->dimensions, origins,
mode, &offsets, &border_flag_value, NULL))
goto exit;
/* initialize filter iterator: */
if (!NI_InitFilterIterator(input->nd, footprint->dimensions,
filter_size, input->dimensions, origins, &fi))
goto exit;
/* initialize input element iterator: */
if (!NI_InitPointIterator(input, &ii))
goto exit;
/* initialize output element iterator: */
if (!NI_InitPointIterator(output, &io))
goto exit;
/* get data pointers an array size: */
pi = (void *)PyArray_DATA(input);
po = (void *)PyArray_DATA(output);
size = 1;
for(ll = 0; ll < input->nd; ll++)
size *= input->dimensions[ll];
/* buffer for filter calculation: */
buffer = (double*)malloc(filter_size * sizeof(double));
if (!buffer) {
PyErr_NoMemory();
goto exit;
}
/* iterate over the elements: */
oo = offsets;
for(jj = 0; jj < size; jj++) {
double tmp = 0.0;
switch (NI_NormalizeType(input->descr->type_num)) {
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Bool,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, UInt8,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, UInt16,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, UInt32,
tmp, border_flag_value, function, data, buffer);
#if HAS_UINT64
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, UInt64,
tmp, border_flag_value, function, data, buffer);
#endif
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Int8,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Int16,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Int32,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Int64,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Float32,
tmp, border_flag_value, function, data, buffer);
CASE_FILTER_POINT(pi, oo, filter_size, cvalue, Float64,
tmp, border_flag_value, function, data, buffer);
default:
PyErr_SetString(PyExc_RuntimeError, "array type not supported");
goto exit;
}
switch (NI_NormalizeType(output->descr->type_num)) {
CASE_FILTER_OUT(po, tmp, Bool);
CASE_FILTER_OUT(po, tmp, UInt8);
CASE_FILTER_OUT(po, tmp, UInt16);
CASE_FILTER_OUT(po, tmp, UInt32);
#if HAS_UINT64
CASE_FILTER_OUT(po, tmp, UInt64);
#endif
CASE_FILTER_OUT(po, tmp, Int8);
CASE_FILTER_OUT(po, tmp, Int16);
CASE_FILTER_OUT(po, tmp, Int32);
CASE_FILTER_OUT(po, tmp, Int64);
CASE_FILTER_OUT(po, tmp, Float32);
CASE_FILTER_OUT(po, tmp, Float64);
default:
PyErr_SetString(PyExc_RuntimeError, "array type not supported");
goto exit;
}
NI_FILTER_NEXT2(fi, ii, io, oo, pi, po);
}
exit:
if (offsets) free(offsets);
if (buffer) free(buffer);
return PyErr_Occurred() ? 0 : 1;
}
int NI_MinOrMaxFilter(PyArrayObject* input, PyArrayObject* footprint,
PyArrayObject* structure, PyArrayObject* output,
NI_ExtendMode mode, double cvalue, npy_intp *origins,
int minimum)
{
Bool *pf = NULL;
npy_intp fsize, jj, kk, filter_size = 0, border_flag_value;
npy_intp *offsets = NULL, *oo, size;
NI_FilterIterator fi;
NI_Iterator ii, io;
char *pi, *po;
int ll, err = 0;
double *ss = NULL;
Float64 *ps;
NPY_BEGIN_THREADS_DEF;
/* get the the footprint: */
fsize = 1;
for(ll = 0; ll < footprint->nd; ll++)
fsize *= footprint->dimensions[ll];
pf = (Bool*)PyArray_DATA(footprint);
for(jj = 0; jj < fsize; jj++) {
if (pf[jj]) {
++filter_size;
}
}
/* get the structure: */
if (structure) {
ss = (double*)malloc(filter_size * sizeof(double));
if (!ss) {
PyErr_NoMemory();
goto exit;
}
/* copy the weights to contiguous memory: */
ps = (Float64*)PyArray_DATA(structure);
jj = 0;
for(kk = 0; kk < fsize; kk++)
if (pf[kk])
ss[jj++] = minimum ? -ps[kk] : ps[kk];
}
/* initialize filter offsets: */
if (!NI_InitFilterOffsets(input, pf, footprint->dimensions, origins,
mode, &offsets, &border_flag_value, NULL))
goto exit;
/* initialize filter iterator: */
if (!NI_InitFilterIterator(input->nd, footprint->dimensions,
filter_size, input->dimensions, origins, &fi))
goto exit;
/* initialize input element iterator: */
if (!NI_InitPointIterator(input, &ii))
goto exit;
/* initialize output element iterator: */
if (!NI_InitPointIterator(output, &io))
goto exit;
NPY_BEGIN_THREADS;
/* get data pointers an array size: */
pi = (void *)PyArray_DATA(input);
po = (void *)PyArray_DATA(output);
size = 1;
for(ll = 0; ll < input->nd; ll++)
size *= input->dimensions[ll];
/* iterator over the elements: */
oo = offsets;
for(jj = 0; jj < size; jj++) {
double tmp = 0.0;
switch (NI_NormalizeType(input->descr->type_num)) {
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Bool,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, UInt8,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, UInt16,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, UInt32,
minimum, tmp, border_flag_value, ss);
#if HAS_UINT64
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, UInt64,
minimum, tmp, border_flag_value, ss);
#endif
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Int8,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Int16,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Int32,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Int64,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Float32,
minimum, tmp, border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(pi, oo, filter_size, cvalue, Float64,
minimum, tmp, border_flag_value, ss);
default:
err = 1;
goto exit;
}
switch (NI_NormalizeType(output->descr->type_num)) {
CASE_FILTER_OUT(po, tmp, Bool);
CASE_FILTER_OUT(po, tmp, UInt8);
CASE_FILTER_OUT(po, tmp, UInt16);
CASE_FILTER_OUT(po, tmp, UInt32);
#if HAS_UINT64
CASE_FILTER_OUT(po, tmp, UInt64);
#endif
CASE_FILTER_OUT(po, tmp, Int8);
CASE_FILTER_OUT(po, tmp, Int16);
CASE_FILTER_OUT(po, tmp, Int32);
CASE_FILTER_OUT(po, tmp, Int64);
CASE_FILTER_OUT(po, tmp, Float32);
CASE_FILTER_OUT(po, tmp, Float64);
default:
err = 1;
goto exit;
}
NI_FILTER_NEXT2(fi, ii, io, oo, pi, po);
}
exit:
NPY_END_THREADS;
if (err == 1) {
PyErr_SetString(PyExc_RuntimeError, "array type not supported");
}
if (offsets) free(offsets);
if (ss) free(ss);
return PyErr_Occurred() ? 0 : 1;
}
int NI_Correlate(PyArrayObject* input, PyArrayObject* weights,
PyArrayObject* output, NI_ExtendMode mode,
double cvalue, npy_intp *origins)
{
Bool *pf = NULL;
npy_intp fsize, jj, kk, filter_size = 0, border_flag_value;
npy_intp *offsets = NULL, *oo, size;
NI_FilterIterator fi;
NI_Iterator ii, io;
char *pi, *po;
Float64 *pw;
Float64 *ww = NULL;
int ll, err = 0;
NPY_BEGIN_THREADS_DEF;
/* get the the footprint: */
fsize = 1;
for(ll = 0; ll < weights->nd; ll++)
fsize *= weights->dimensions[ll];
pw = (Float64*)PyArray_DATA(weights);
pf = (Bool*)malloc(fsize * sizeof(Bool));
if (!pf) {
PyErr_NoMemory();
goto exit;
}
for(jj = 0; jj < fsize; jj++) {
if (fabs(pw[jj]) > DBL_EPSILON) {
pf[jj] = 1;
++filter_size;
} else {
pf[jj] = 0;
}
}
/* copy the weights to contiguous memory: */
ww = (Float64*)malloc(filter_size * sizeof(Float64));
if (!ww) {
PyErr_NoMemory();
goto exit;
}
jj = 0;
for(kk = 0; kk < fsize; kk++) {
if (pf[kk]) {
ww[jj++] = pw[kk];
}
}
/* initialize filter offsets: */
if (!NI_InitFilterOffsets(input, pf, weights->dimensions, origins,
mode, &offsets, &border_flag_value, NULL))
goto exit;
/* initialize filter iterator: */
if (!NI_InitFilterIterator(input->nd, weights->dimensions, filter_size,
input->dimensions, origins, &fi))
goto exit;
/* initialize input element iterator: */
if (!NI_InitPointIterator(input, &ii))
goto exit;
/* initialize output element iterator: */
if (!NI_InitPointIterator(output, &io))
goto exit;
NPY_BEGIN_THREADS;
/* get data pointers an array size: */
pi = (void *)PyArray_DATA(input);
po = (void *)PyArray_DATA(output);
size = 1;
for(ll = 0; ll < input->nd; ll++)
size *= input->dimensions[ll];
/* iterator over the elements: */
oo = offsets;
for(jj = 0; jj < size; jj++) {
double tmp = 0.0;
switch (NI_NormalizeType(input->descr->type_num)) {
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Bool,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, UInt8,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, UInt16,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, UInt32,
tmp, border_flag_value);
#if HAS_UINT64
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, UInt64,
tmp, border_flag_value);
#endif
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Int8,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Int16,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Int32,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Int64,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Float32,
tmp, border_flag_value);
CASE_CORRELATE_POINT(pi, ww, oo, filter_size, cvalue, Float64,
tmp, border_flag_value);
default:
err = 1;
goto exit;
}
switch (NI_NormalizeType(output->descr->type_num)) {
CASE_FILTER_OUT(po, tmp, Bool);
CASE_FILTER_OUT(po, tmp, UInt8);
CASE_FILTER_OUT(po, tmp, UInt16);
CASE_FILTER_OUT(po, tmp, UInt32);
#if HAS_UINT64
CASE_FILTER_OUT(po, tmp, UInt64);
#endif
CASE_FILTER_OUT(po, tmp, Int8);
CASE_FILTER_OUT(po, tmp, Int16);
CASE_FILTER_OUT(po, tmp, Int32);
CASE_FILTER_OUT(po, tmp, Int64);
CASE_FILTER_OUT(po, tmp, Float32);
CASE_FILTER_OUT(po, tmp, Float64);
default:
err = 1;
goto exit;
}
NI_FILTER_NEXT2(fi, ii, io, oo, pi, po);
}
exit:
NPY_END_THREADS;
if (err == 1) {
PyErr_SetString(PyExc_RuntimeError, "array type not supported");
}
if (offsets) free(offsets);
if (ww) free(ww);
if (pf) free(pf);
return PyErr_Occurred() ? 0 : 1;
}
int NI_GenericFilter(PyArrayObject* input,
int (*function)(double*, npy_intp, double*, void*), void *data,
PyArrayObject* footprint, PyArrayObject* output,
NI_ExtendMode mode, double cvalue, npy_intp *origins)
{
npy_bool *pf = NULL;
npy_intp fsize, jj, filter_size = 0, border_flag_value;
npy_intp *offsets = NULL, *oo, size;
NI_FilterIterator fi;
NI_Iterator ii, io;
char *pi, *po;
double *buffer = NULL;
/* get the the footprint: */
fsize = PyArray_SIZE(footprint);
pf = (npy_bool*)PyArray_DATA(footprint);
for(jj = 0; jj < fsize; jj++) {
if (pf[jj])
++filter_size;
}
/* initialize filter offsets: */
if (!NI_InitFilterOffsets(input, pf, PyArray_DIMS(footprint), origins,
mode, &offsets, &border_flag_value, NULL)) {
goto exit;
}
/* initialize filter iterator: */
if (!NI_InitFilterIterator(PyArray_NDIM(input), PyArray_DIMS(footprint),
filter_size, PyArray_DIMS(input), origins,
&fi)) {
goto exit;
}
/* initialize input element iterator: */
if (!NI_InitPointIterator(input, &ii))
goto exit;
/* initialize output element iterator: */
if (!NI_InitPointIterator(output, &io))
goto exit;
/* get data pointers an array size: */
pi = (void *)PyArray_DATA(input);
po = (void *)PyArray_DATA(output);
size = PyArray_SIZE(input);
/* buffer for filter calculation: */
buffer = malloc(filter_size * sizeof(double));
if (!buffer) {
PyErr_NoMemory();
goto exit;
}
/* iterate over the elements: */
oo = offsets;
for(jj = 0; jj < size; jj++) {
double tmp = 0.0;
switch (PyArray_TYPE(input)) {
CASE_FILTER_POINT(NPY_BOOL, npy_bool,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_UBYTE, npy_ubyte,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_USHORT, npy_ushort,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_UINT, npy_uint,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_ULONG, npy_ulong,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_ULONGLONG, npy_ulonglong,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_BYTE, npy_byte,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_SHORT, npy_short,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_INT, npy_int,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_LONG, npy_long,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_LONGLONG, npy_longlong,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_FLOAT, npy_float,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
CASE_FILTER_POINT(NPY_DOUBLE, npy_double,
pi, oo, filter_size, cvalue, tmp,
border_flag_value, function, data, buffer);
default:
PyErr_SetString(PyExc_RuntimeError,
"array type not supported");
goto exit;
}
switch (PyArray_TYPE(output)) {
CASE_FILTER_OUT(NPY_BOOL, npy_bool, po, tmp);
CASE_FILTER_OUT(NPY_UBYTE, npy_ubyte, po, tmp);
CASE_FILTER_OUT(NPY_USHORT, npy_ushort, po, tmp);
CASE_FILTER_OUT(NPY_UINT, npy_uint, po, tmp);
CASE_FILTER_OUT(NPY_ULONG, npy_ulong, po, tmp);
CASE_FILTER_OUT(NPY_ULONGLONG, npy_ulonglong, po, tmp);
CASE_FILTER_OUT(NPY_BYTE, npy_byte, po, tmp);
CASE_FILTER_OUT(NPY_SHORT, npy_short, po, tmp);
CASE_FILTER_OUT(NPY_INT, npy_int, po, tmp);
CASE_FILTER_OUT(NPY_LONG, npy_long, po, tmp);
CASE_FILTER_OUT(NPY_LONGLONG, npy_longlong, po, tmp);
CASE_FILTER_OUT(NPY_FLOAT, npy_float, po, tmp);
CASE_FILTER_OUT(NPY_DOUBLE, npy_double, po, tmp);
default:
PyErr_SetString(PyExc_RuntimeError,
"array type not supported");
goto exit;
}
NI_FILTER_NEXT2(fi, ii, io, oo, pi, po);
}
exit:
free(offsets);
free(buffer);
return PyErr_Occurred() ? 0 : 1;
}
int NI_MinOrMaxFilter(PyArrayObject* input, PyArrayObject* footprint,
PyArrayObject* structure, PyArrayObject* output,
NI_ExtendMode mode, double cvalue, npy_intp *origins,
int minimum)
{
npy_bool *pf = NULL;
npy_intp fsize, jj, kk, filter_size = 0, border_flag_value;
npy_intp *offsets = NULL, *oo, size;
NI_FilterIterator fi;
NI_Iterator ii, io;
char *pi, *po;
int err = 0;
double *ss = NULL;
npy_double *ps;
NPY_BEGIN_THREADS_DEF;
/* get the the footprint: */
fsize = PyArray_SIZE(footprint);
pf = (npy_bool*)PyArray_DATA(footprint);
for(jj = 0; jj < fsize; jj++) {
if (pf[jj]) {
++filter_size;
}
}
/* get the structure: */
if (structure) {
ss = malloc(filter_size * sizeof(double));
if (!ss) {
PyErr_NoMemory();
goto exit;
}
/* copy the weights to contiguous memory: */
ps = (npy_double*)PyArray_DATA(structure);
jj = 0;
for(kk = 0; kk < fsize; kk++)
if (pf[kk])
ss[jj++] = minimum ? -ps[kk] : ps[kk];
}
/* initialize filter offsets: */
if (!NI_InitFilterOffsets(input, pf, PyArray_DIMS(footprint), origins,
mode, &offsets, &border_flag_value, NULL)) {
goto exit;
}
/* initialize filter iterator: */
if (!NI_InitFilterIterator(PyArray_NDIM(input), PyArray_DIMS(footprint),
filter_size, PyArray_DIMS(input), origins,
&fi)) {
goto exit;
}
/* initialize input element iterator: */
if (!NI_InitPointIterator(input, &ii))
goto exit;
/* initialize output element iterator: */
if (!NI_InitPointIterator(output, &io))
goto exit;
NPY_BEGIN_THREADS;
/* get data pointers an array size: */
pi = (void *)PyArray_DATA(input);
po = (void *)PyArray_DATA(output);
size = PyArray_SIZE(input);
/* iterator over the elements: */
oo = offsets;
for(jj = 0; jj < size; jj++) {
double tmp = 0.0;
switch (PyArray_TYPE(input)) {
CASE_MIN_OR_MAX_POINT(NPY_BOOL, npy_bool,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_UBYTE, npy_ubyte,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_USHORT, npy_ushort,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_UINT, npy_uint,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_ULONG, npy_ulong,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_ULONGLONG, npy_ulonglong,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_BYTE, npy_byte,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_SHORT, npy_short,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_INT, npy_int,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_LONG, npy_long,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_LONGLONG, npy_longlong,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_FLOAT, npy_float,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
CASE_MIN_OR_MAX_POINT(NPY_DOUBLE, npy_double,
pi, oo, filter_size, cvalue, minimum, tmp,
border_flag_value, ss);
default:
err = 1;
goto exit;
}
switch (PyArray_TYPE(output)) {
CASE_FILTER_OUT(NPY_BOOL, npy_bool, po, tmp);
CASE_FILTER_OUT(NPY_UBYTE, npy_ubyte, po, tmp);
CASE_FILTER_OUT(NPY_USHORT, npy_ushort, po, tmp);
CASE_FILTER_OUT(NPY_UINT, npy_uint, po, tmp);
CASE_FILTER_OUT(NPY_ULONG, npy_ulong, po, tmp);
CASE_FILTER_OUT(NPY_ULONGLONG, npy_ulonglong, po, tmp);
CASE_FILTER_OUT(NPY_BYTE, npy_byte, po, tmp);
CASE_FILTER_OUT(NPY_SHORT, npy_short, po, tmp);
CASE_FILTER_OUT(NPY_INT, npy_int, po, tmp);
CASE_FILTER_OUT(NPY_LONG, npy_long, po, tmp);
CASE_FILTER_OUT(NPY_LONGLONG, npy_longlong, po, tmp);
CASE_FILTER_OUT(NPY_FLOAT, npy_float, po, tmp);
CASE_FILTER_OUT(NPY_DOUBLE, npy_double, po, tmp);
default:
err = 1;
goto exit;
}
NI_FILTER_NEXT2(fi, ii, io, oo, pi, po);
}
exit:
NPY_END_THREADS;
if (err == 1) {
PyErr_SetString(PyExc_RuntimeError, "array type not supported");
}
free(offsets);
free(ss);
return PyErr_Occurred() ? 0 : 1;
}
int NI_Correlate(PyArrayObject* input, PyArrayObject* weights,
PyArrayObject* output, NI_ExtendMode mode,
double cvalue, npy_intp *origins)
{
npy_bool *pf = NULL;
npy_intp fsize, jj, kk, filter_size = 0, border_flag_value;
npy_intp *offsets = NULL, *oo, size;
NI_FilterIterator fi;
NI_Iterator ii, io;
char *pi, *po;
npy_double *pw;
npy_double *ww = NULL;
int err = 0;
NPY_BEGIN_THREADS_DEF;
/* get the the footprint: */
fsize = PyArray_SIZE(weights);
pw = (npy_double*)PyArray_DATA(weights);
pf = malloc(fsize * sizeof(npy_bool));
if (!pf) {
PyErr_NoMemory();
goto exit;
}
for(jj = 0; jj < fsize; jj++) {
if (fabs(pw[jj]) > DBL_EPSILON) {
pf[jj] = 1;
++filter_size;
} else {
pf[jj] = 0;
}
}
/* copy the weights to contiguous memory: */
ww = malloc(filter_size * sizeof(npy_double));
if (!ww) {
PyErr_NoMemory();
goto exit;
}
jj = 0;
for(kk = 0; kk < fsize; kk++) {
if (pf[kk]) {
ww[jj++] = pw[kk];
}
}
/* initialize filter offsets: */
if (!NI_InitFilterOffsets(input, pf, PyArray_DIMS(weights), origins,
mode, &offsets, &border_flag_value, NULL)) {
goto exit;
}
/* initialize filter iterator: */
if (!NI_InitFilterIterator(PyArray_NDIM(input), PyArray_DIMS(weights),
filter_size, PyArray_DIMS(input), origins,
&fi)) {
goto exit;
}
/* initialize input element iterator: */
if (!NI_InitPointIterator(input, &ii))
goto exit;
/* initialize output element iterator: */
if (!NI_InitPointIterator(output, &io))
goto exit;
NPY_BEGIN_THREADS;
/* get data pointers an array size: */
pi = (void *)PyArray_DATA(input);
po = (void *)PyArray_DATA(output);
size = PyArray_SIZE(input);
/* iterator over the elements: */
oo = offsets;
for(jj = 0; jj < size; jj++) {
double tmp = 0.0;
switch (PyArray_TYPE(input)) {
CASE_CORRELATE_POINT(NPY_BOOL, npy_bool,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_UBYTE, npy_ubyte,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_USHORT, npy_ushort,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_UINT, npy_uint,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_ULONG, npy_ulong,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_ULONGLONG, npy_ulonglong,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_BYTE, npy_byte,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_SHORT, npy_short,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_INT, npy_int,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_LONG, npy_long,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_LONGLONG, npy_longlong,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_FLOAT, npy_float,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
CASE_CORRELATE_POINT(NPY_DOUBLE, npy_double,
pi, ww, oo, filter_size, cvalue, tmp,
border_flag_value);
default:
err = 1;
goto exit;
}
switch (PyArray_TYPE(output)) {
CASE_FILTER_OUT(NPY_BOOL, npy_bool, po, tmp);
CASE_FILTER_OUT(NPY_UBYTE, npy_ubyte, po, tmp);
CASE_FILTER_OUT(NPY_USHORT, npy_ushort, po, tmp);
CASE_FILTER_OUT(NPY_UINT, npy_uint, po, tmp);
CASE_FILTER_OUT(NPY_ULONG, npy_ulong, po, tmp);
CASE_FILTER_OUT(NPY_ULONGLONG, npy_ulonglong, po, tmp);
CASE_FILTER_OUT(NPY_BYTE, npy_byte, po, tmp);
CASE_FILTER_OUT(NPY_SHORT, npy_short, po, tmp);
CASE_FILTER_OUT(NPY_INT, npy_int, po, tmp);
CASE_FILTER_OUT(NPY_LONG, npy_long, po, tmp);
CASE_FILTER_OUT(NPY_LONGLONG, npy_longlong, po, tmp);
CASE_FILTER_OUT(NPY_FLOAT, npy_float, po, tmp);
CASE_FILTER_OUT(NPY_DOUBLE, npy_double, po, tmp);
default:
err = 1;
goto exit;
}
NI_FILTER_NEXT2(fi, ii, io, oo, pi, po);
}
exit:
NPY_END_THREADS;
if (err == 1) {
PyErr_SetString(PyExc_RuntimeError, "array type not supported");
}
free(offsets);
free(ww);
free(pf);
return PyErr_Occurred() ? 0 : 1;
}
