void *
PyCapsule_Import(const char *name, int no_block)
{
PyObject *object = NULL;
void *return_value = NULL;
char *trace;
size_t name_length = (strlen(name) + 1) * sizeof(char);
char *name_dup = (char *)PyMem_MALLOC(name_length);
if (!name_dup) {
return NULL;
}
memcpy(name_dup, name, name_length);
trace = name_dup;
while (trace) {
char *dot = strchr(trace, '.');
if (dot) {
*dot++ = '\0';
}
if (object == NULL) {
if (no_block) {
object = PyImport_ImportModuleNoBlock(trace);
} else {
object = PyImport_ImportModule(trace);
if (!object) {
PyErr_Format(PyExc_ImportError, "PyCapsule_Import could not import module \"%s\"", trace);
}
}
} else {
PyObject *object2 = PyObject_GetAttrString(object, trace);
Py_DECREF(object);
object = object2;
}
if (!object) {
goto EXIT;
}
trace = dot;
}
/* compare attribute name to module.name by hand */
if (PyCapsule_IsValid(object, name)) {
PyCapsule *capsule = (PyCapsule *)object;
return_value = capsule->pointer;
} else {
PyErr_Format(PyExc_AttributeError,
"PyCapsule_Import \"%s\" is not valid",
name);
}
EXIT:
Py_XDECREF(object);
if (name_dup) {
PyMem_FREE(name_dup);
}
return return_value;
}
static PyObject *Py_BinaryErosion2(PyObject *obj, PyObject *args)
{
PyArrayObject *array = NULL, *strct = NULL, *mask = NULL;
PyObject *cobj = NULL;
int invert, niter;
maybelong *origins = NULL;
if (!PyArg_ParseTuple(args, "O&O&O&iO&iO", NI_ObjectToIoArray, &array,
NI_ObjectToInputArray, &strct, NI_ObjectToOptionalInputArray,
&mask, &niter, NI_ObjectToLongSequence, &origins, &invert,
&cobj))
goto exit;
if (PyCapsule_IsValid(cobj, "")) {
NI_CoordinateList *cobj_data = PyCapsule_GetPointer(cobj, "");
if (!NI_BinaryErosion2(array, strct, mask, niter, origins, invert,
&cobj_data))
goto exit;
} else {
PyErr_SetString(PyExc_RuntimeError, "cannot convert CObject");
goto exit;
}
exit:
Py_XDECREF(array);
Py_XDECREF(strct);
Py_XDECREF(mask);
if (origins) free(origins);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
static PyObject *Py_GeometricTransform(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL;
PyArrayObject *coordinates = NULL, *matrix = NULL, *shift = NULL;
PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL;
int mode, order;
double cval;
void *func = NULL, *data = NULL;
NI_PythonCallbackData cbdata;
if (!PyArg_ParseTuple(args, "O&OO&O&O&O&iidOO", NI_ObjectToInputArray,
&input, &fnc, NI_ObjectToOptionalInputArray,
&coordinates, NI_ObjectToOptionalInputArray,
&matrix, NI_ObjectToOptionalInputArray, &shift,
NI_ObjectToOutputArray, &output, &order, &mode,
&cval, &extra_arguments, &extra_keywords))
goto exit;
if (fnc != Py_None) {
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_IsValid(fnc, "")) {
func = PyCapsule_GetPointer(fnc, "");
data = NULL;//PyCObject_GetDesc(fnc);
} else if (PyCallable_Check(fnc)) {
func = Py_Map;
cbdata.function = fnc;
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
data = (void*)&cbdata;
} else {
PyErr_SetString(PyExc_RuntimeError,
"function parameter is not callable");
goto exit;
}
}
if (!NI_GeometricTransform(input, func, data, matrix, shift, coordinates,
output, order, (NI_ExtendMode)mode, cval))
goto exit;
exit:
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(coordinates);
Py_XDECREF(matrix);
Py_XDECREF(shift);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
int
CCNObject_ReqType(enum _pyccn_capsules type, PyObject *capsule)
{
int r;
const char *t = type2name(type);
r = PyCapsule_IsValid(capsule, t);
if (!r)
PyErr_Format(PyExc_TypeError, "Argument needs to be of %s type", t);
return r;
}
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 = Py_FilterFunc, *data = NULL;
NI_PythonCallbackData cbdata;
int mode;
maybelong *origin = NULL;
double cval;
if (!PyArg_ParseTuple(args, "O&OO&O&idO&OO", NI_ObjectToInputArray,
&input, &fnc, NI_ObjectToInputArray, &footprint,
NI_ObjectToOutputArray, &output, &mode, &cval,
NI_ObjectToLongSequence, &origin,
&extra_arguments, &extra_keywords))
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_IsValid(fnc, "")) {
func = PyCapsule_GetPointer(fnc, "");
data = NULL; //PyCObject_GetDesc(fnc);
} else if (PyCallable_Check(fnc)) {
cbdata.function = fnc;
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
data = (void*)&cbdata;
} else {
PyErr_SetString(PyExc_RuntimeError,
"function parameter is not callable");
goto exit;
}
if (!NI_GenericFilter(input, func, data, footprint, output,
(NI_ExtendMode)mode, cval, origin))
goto exit;
exit:
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(footprint);
if (origin)
free(origin);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%s does not export expected C function %s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %s.%s has wrong signature (expected %s, got %s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %s.%s has wrong signature (expected %s, got %s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
EXPORT bool
py_coded_image_take_source( PyObject *source, CodedImageSourceHolder *holder ) {
Py_CLEAR( holder->source.obj );
Py_CLEAR( holder->csource );
holder->source.funcs = NULL;
if( source == NULL || source == Py_None )
return true;
Py_INCREF( source );
holder->source.obj = source;
holder->csource = PyObject_GetAttrString( source, CODED_IMAGE_SOURCE_FUNCS );
if( !PyCapsule_IsValid( holder->csource, CODED_IMAGE_SOURCE_FUNCS ) ) {
Py_CLEAR( holder->source.obj );
PyErr_SetString( PyExc_Exception, "The source didn't have an acceptable " CODED_IMAGE_SOURCE_FUNCS " attribute." );
return false;
}
holder->source.funcs = (coded_image_source_funcs*)
PyCapsule_GetPointer( holder->csource, CODED_IMAGE_SOURCE_FUNCS );
return true;
}
static PyObject* w_store_get(PyObject *dummy, PyObject *args) {
PyObject *capsule;
uint64_t irecord;
store_t *store;
gf_dtype *adata;
trace_t trace;
PyArrayObject *array = NULL;
npy_intp array_dims[1] = {0};
int32_t itmin;
int32_t nsamples;
int i;
store_error_t err;
(void)dummy; /* silence warning */
if (!PyArg_ParseTuple(args, "OKii", &capsule, &irecord, &itmin, &nsamples)) {
PyErr_SetString(StoreExtError, "usage store_get(cstore, irecord, itmin, nsamples)");
return NULL;
}
#ifdef HAVE_CAPSULE
if (!PyCapsule_IsValid(capsule, NULL)) {
#else
if (!PyCObject_Check(capsule)) {
#endif
PyErr_SetString(StoreExtError, "invalid cstore argument");
return NULL;
}
if (!inlimits(itmin)) {
PyErr_SetString(StoreExtError, "invalid itmin argument");
return NULL;
}
if (!(inposlimits(nsamples) || -1 == nsamples)) {
PyErr_SetString(StoreExtError, "invalid nsamples argument");
return NULL;
}
#ifdef HAVE_CAPSULE
store = (store_t*)PyCapsule_GetPointer(capsule, NULL);
#else
store = (store_t*)PyCObject_AsVoidPtr(capsule);
#endif
err = store_get(store, irecord, &trace);
if (SUCCESS != err) {
PyErr_SetString(StoreExtError, store_error_names[err]);
return NULL;
}
if (-1 != nsamples) {
trace_trim(&trace, itmin, nsamples);
}
array_dims[0] = trace.nsamples;
array = (PyArrayObject*)PyArray_EMPTY(1, array_dims, NPY_FLOAT32, 0);
adata = (gf_dtype*)PyArray_DATA(array);
for (i=0; i<trace.nsamples; i++) {
adata[i] = fe32toh(trace.data[i]);
}
return Py_BuildValue("Nififf", array, trace.itmin, store->deltat,
trace.is_zero, trace.begin_value, trace.end_value);
}
static PyObject* w_store_sum(PyObject *dummy, PyObject *args) {
PyObject *capsule, *irecords_arr, *delays_arr, *weights_arr;
store_t *store;
gf_dtype *adata;
trace_t result;
PyArrayObject *array = NULL;
npy_intp array_dims[1] = {0};
PyArrayObject *c_irecords_arr, *c_delays_arr, *c_weights_arr;
uint64_t *irecords;
float32_t *delays, *weights;
npy_intp n, n1, n2;
int32_t itmin;
int32_t nsamples;
store_error_t err;
(void)dummy; /* silence warning */
if (!PyArg_ParseTuple(args, "OOOOii", &capsule, &irecords_arr, &delays_arr,
&weights_arr, &itmin, &nsamples)) {
PyErr_SetString(StoreExtError,
"usage: store_sum(cstore, irecords, delays, weights, itmin, nsamples)");
return NULL;
}
#ifdef HAVE_CAPSULE
if (!PyCapsule_IsValid(capsule, NULL)) {
#else
if (!PyCObject_Check(capsule)) {
#endif
PyErr_SetString(StoreExtError, "invalid cstore argument");
return NULL;
}
if (!PyArray_Check(irecords_arr) ||
NPY_UINT64 != PyArray_TYPE((PyArrayObject*)irecords_arr)) {
PyErr_SetString(StoreExtError,
"store_sum: 'irecords' must be a NumPy array of type uint64");
return NULL;
}
if (!PyArray_Check(delays_arr) ||
NPY_FLOAT32 != PyArray_TYPE((PyArrayObject*)delays_arr)) {
PyErr_SetString(StoreExtError,
"store_sum: 'delays' must be a NumPy array of type float32");
return NULL;
}
if (!PyArray_Check(weights_arr) ||
NPY_FLOAT32 != PyArray_TYPE((PyArrayObject*)weights_arr)) {
PyErr_SetString(StoreExtError,
"store_sum: 'weights' must be a NumPy array of type float32");
return NULL;
}
if (!inlimits(itmin)) {
PyErr_SetString(StoreExtError, "invalid itmin argument");
return NULL;
}
if (!(inposlimits(nsamples) || -1 == nsamples)) {
PyErr_SetString(StoreExtError, "invalid nsamples argument");
return NULL;
}
#ifdef HAVE_CAPSULE
store = (store_t*)PyCapsule_GetPointer(capsule, NULL);
#else
store = (store_t*)PyCObject_AsVoidPtr(capsule);
#endif
c_irecords_arr = PyArray_GETCONTIGUOUS((PyArrayObject*)irecords_arr);
c_delays_arr = PyArray_GETCONTIGUOUS((PyArrayObject*)delays_arr);
c_weights_arr = PyArray_GETCONTIGUOUS((PyArrayObject*)weights_arr);
n = PyArray_SIZE(c_irecords_arr);
n1 = PyArray_SIZE(c_delays_arr);
n2 = PyArray_SIZE(c_weights_arr);
if (n != n1 || n != n2) {
PyErr_SetString(StoreExtError,
"store_sum: 'irecords', 'delays', and 'weights' must have same length");
return NULL;
}
irecords = PyArray_DATA(c_irecords_arr);
delays = PyArray_DATA(c_delays_arr);
weights = PyArray_DATA(c_weights_arr);
err = store_sum(store, irecords, delays, weights, n, itmin, nsamples, &result);
if (SUCCESS != err) {
PyErr_SetString(StoreExtError, store_error_names[err]);
return NULL;
}
Py_DECREF(c_irecords_arr);
Py_DECREF(c_delays_arr);
Py_DECREF(c_weights_arr);
array_dims[0] = result.nsamples;
array = (PyArrayObject*)PyArray_EMPTY(1, array_dims, NPY_FLOAT32, 0);
adata = (gf_dtype*)PyArray_DATA(array);
memcpy(adata, result.data, result.nsamples*sizeof(gf_dtype));
free(result.data);
return Py_BuildValue("Nififf", array, result.itmin, store->deltat,
result.is_zero, result.begin_value, result.end_value);
}
static PyMethodDef StoreExtMethods[] = {
{"store_init", w_store_init, METH_VARARGS,
"Initialize store struct." },
{"store_get", w_store_get, METH_VARARGS,
"Get a GF trace." },
{"store_sum", w_store_sum, METH_VARARGS,
"Get weight-and-delay-sum of GF traces." },
{NULL, NULL, 0, NULL} /* Sentinel */
};
PyMODINIT_FUNC
initstore_ext(void)
{
PyObject *m;
m = Py_InitModule("store_ext", StoreExtMethods);
if (m == NULL) return;
import_array();
StoreExtError = PyErr_NewException("store_ext.error", NULL, NULL);
Py_INCREF(StoreExtError); /* required, because other code could remove `error`
from the module, what would create a dangling
pointer. */
PyModule_AddObject(m, "StoreExtError", StoreExtError);
}
int
CCNObject_IsValid(enum _pyccn_capsules type, PyObject *capsule)
{
return PyCapsule_IsValid(capsule, type2name(type));
}
EXPORT bool
py_framefunc_take_source( PyObject *source, FrameFunctionHolder *holder ) {
Py_CLEAR( holder->source );
Py_CLEAR( holder->csource );
memset( holder, 0, sizeof(FrameFunctionHolder) );
if( source == NULL || source == Py_None )
return true;
box2i const_box2i;
if( py_parse_box2i( source, &const_box2i ) ) {
holder->constant[0] = const_box2i.min.x;
holder->constant[1] = const_box2i.min.y;
holder->constant[2] = const_box2i.max.x;
holder->constant[3] = const_box2i.max.y;
return true;
}
else {
PyErr_Clear();
}
box2f const_box2f;
if( py_parse_box2f( source, &const_box2f ) ) {
holder->constant[0] = const_box2f.min.x;
holder->constant[1] = const_box2f.min.y;
holder->constant[2] = const_box2f.max.x;
holder->constant[3] = const_box2f.max.y;
return true;
}
else {
PyErr_Clear();
}
if( PyTuple_Check( source ) ) {
Py_ssize_t length = PyTuple_GET_SIZE( source );
if( !length ) {
PyErr_SetString( PyExc_ValueError, "An empty tuple was passed." );
return false;
}
else if( length > 4 ) {
PyErr_Format( PyExc_ValueError, "One of the tuples passed has more than four entries (%" PRIdPTR ").", (intptr_t) length );
return false;
}
for( Py_ssize_t i = 0; i < length; i++ ) {
PyObject *f = PyNumber_Float( PyTuple_GET_ITEM( source, i ) );
if( !f )
return false;
holder->constant[i] = PyFloat_AS_DOUBLE( f );
Py_CLEAR( f );
if( PyErr_Occurred() )
return false;
}
return true;
}
else {
// Try to interpret it as a number
PyObject *asFloat = PyNumber_Float( source );
if( asFloat ) {
holder->constant[0] = PyFloat_AS_DOUBLE( asFloat );
Py_CLEAR( asFloat );
return true;
}
else {
// Clear any errors
PyErr_Clear();
}
}
Py_INCREF( source );
holder->source = source;
holder->csource = PyObject_GetAttrString( source, FRAME_FUNCTION_FUNCS );
if( !PyCapsule_IsValid( holder->csource, FRAME_FUNCTION_FUNCS ) ) {
Py_CLEAR( holder->source );
PyErr_SetString( PyExc_Exception, "The source didn't have an acceptable " FRAME_FUNCTION_FUNCS " attribute." );
return false;
}
holder->funcs = (FrameFunctionFuncs*) PyCapsule_GetPointer(
holder->csource, FRAME_FUNCTION_FUNCS );
return true;
}
