// create a new NDF extension
static PyObject*
pyndf_xnew(NDF *self, PyObject *args)
{
int ndim = 0;
const char *xname, *type;
PyObject *dim;
if(!PyArg_ParseTuple(args, "ss|iO:pyndf_xnew", &xname, &type, &ndim, &dim))
return NULL;
int status = SAI__OK;
HDSLoc *loc = NULL;
// perform checks if we're not making an extension header
if(ndim != 0) {
// check for HDS types
if (!checkHDStype(type))
return NULL;
// need dims if it's not an ext
if(ndim < 1 || dim == NULL)
return NULL;
PyArrayObject *npydim = (PyArrayObject*) PyArray_FROM_OTF(dim,NPY_INT,NPY_IN_ARRAY|NPY_FORCECAST);
if (PyArray_SIZE(npydim) != ndim)
return NULL;
errBegin(&status);
ndfXnew(self->_ndfid,xname,type,ndim,(int*)PyArray_DATA(npydim),&loc,&status);
Py_DECREF(npydim);
} else {
// making an ext/struct
errBegin(&status);
ndfXnew(self->_ndfid,xname,type,0,0,&loc,&status);
}
if (raiseNDFException(&status)) return NULL;
PyObject* pobj = NpyCapsule_FromVoidPtr(loc, PyDelLoc);
return Py_BuildValue("O",pobj);
}
/*NUMPY_API
Register Casting Function
Replaces any function currently stored.
*/
NPY_NO_EXPORT int
PyArray_RegisterCastFunc(PyArray_Descr *descr, int totype,
PyArray_VectorUnaryFunc *castfunc)
{
PyObject *cobj, *key;
int ret;
if (totype < NPY_NTYPES_ABI_COMPATIBLE) {
descr->f->cast[totype] = castfunc;
return 0;
}
if (totype >= NPY_NTYPES && !PyTypeNum_ISUSERDEF(totype)) {
PyErr_SetString(PyExc_TypeError, "invalid type number.");
return -1;
}
if (descr->f->castdict == NULL) {
descr->f->castdict = PyDict_New();
if (descr->f->castdict == NULL) {
return -1;
}
}
key = PyInt_FromLong(totype);
if (PyErr_Occurred()) {
return -1;
}
cobj = NpyCapsule_FromVoidPtr((void *)castfunc, NULL);
if (cobj == NULL) {
Py_DECREF(key);
return -1;
}
ret = PyDict_SetItem(descr->f->castdict, key, cobj);
Py_DECREF(key);
Py_DECREF(cobj);
return ret;
}
static PyObject *
HDS_create_object( HDSLoc * locator )
{
PyObject * pobj;
HDSObject * self = (HDSObject*)HDS_new( &HDSType, NULL, NULL );
pobj = NpyCapsule_FromVoidPtr( locator, PyDelLoc );
HDS_init( self, Py_BuildValue("O", pobj ), NULL);
return (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);
}
}
}
static PyObject*
pyndf_xloc(NDF *self, PyObject *args)
{
const char *xname, *mode;
if(!PyArg_ParseTuple(args, "ss:pyndf_xloc", &xname, &mode))
return NULL;
HDSLoc* loc = NULL;
int status = SAI__OK;
errBegin(&status);
ndfXloc(self->_ndfid, xname, mode, &loc, &status);
if (raiseNDFException(&status)) return NULL;
// PyCObject to pass pointer along to other wrappers
PyObject *pobj = NpyCapsule_FromVoidPtr(loc, PyDelLoc);
return Py_BuildValue("O", pobj);
};
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;
npy_intp *origins = NULL;
if (!PyArg_ParseTuple(args, "O&O&O&O&iO&iii",
NI_ObjectToInputArray, &input,
NI_ObjectToInputArray, &strct,
NI_ObjectToOptionalInputArray, &mask,
NI_ObjectToOutputArray, &output,
&border_value,
NI_ObjectToLongSequence, &origins,
&invert, ¢er_is_true, &return_coordinates))
goto exit;
if (!NI_BinaryErosion(input, strct, mask, output, border_value,
origins, invert, center_is_true, &changed,
return_coordinates ? &coordinate_list : NULL))
goto exit;
if (return_coordinates) {
cobj = NpyCapsule_FromVoidPtr(coordinate_list, _FreeCoordinateList);
}
exit:
Py_XDECREF(input);
Py_XDECREF(strct);
Py_XDECREF(mask);
Py_XDECREF(output);
if (origins)
free(origins);
if (PyErr_Occurred()) {
Py_XDECREF(cobj);
return NULL;
} else {
if (return_coordinates) {
return Py_BuildValue("iN", changed, cobj);
} else {
return Py_BuildValue("i", changed);
}
}
}
PyMODINIT_FUNC init5numpy4core5umath(void)
#endif
{
PyObject *m, *d, *s, *s2, *c_api;
int UFUNC_FLOATING_POINT_SUPPORT = 1;
#ifdef NO_UFUNC_FLOATING_POINT_SUPPORT
UFUNC_FLOATING_POINT_SUPPORT = 0;
#endif
/* Create the module and add the functions */
#if defined(NPY_PY3K)
m = PyModule_Create(&moduledef);
#else
m = Py_InitModule("numpy.core.umath", methods);
#endif
if (!m) {
return RETVAL;
}
/* Import the array */
if (_import_array() < 0) {
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_ImportError,
"umath failed: Could not import array core.");
}
return RETVAL;
}
/* Initialize the types */
if (PyType_Ready(&PyUFunc_Type) < 0)
return RETVAL;
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
c_api = NpyCapsule_FromVoidPtr((void *)PyUFunc_API, NULL);
if (PyErr_Occurred()) {
goto err;
}
PyDict_SetItemString(d, "_UFUNC_API", c_api);
Py_DECREF(c_api);
if (PyErr_Occurred()) {
goto err;
}
s = PyString_FromString("0.4.0");
PyDict_SetItemString(d, "__version__", s);
Py_DECREF(s);
/* Load the ufunc operators into the array module's namespace */
InitOperators(d);
PyDict_SetItemString(d, "pi", s = PyFloat_FromDouble(NPY_PI));
Py_DECREF(s);
PyDict_SetItemString(d, "e", s = PyFloat_FromDouble(NPY_E));
Py_DECREF(s);
PyDict_SetItemString(d, "euler_gamma", s = PyFloat_FromDouble(NPY_EULER));
Py_DECREF(s);
#define ADDCONST(str) PyModule_AddIntConstant(m, #str, UFUNC_##str)
#define ADDSCONST(str) PyModule_AddStringConstant(m, "UFUNC_" #str, UFUNC_##str)
ADDCONST(ERR_IGNORE);
ADDCONST(ERR_WARN);
ADDCONST(ERR_CALL);
ADDCONST(ERR_RAISE);
ADDCONST(ERR_PRINT);
ADDCONST(ERR_LOG);
ADDCONST(ERR_DEFAULT);
ADDCONST(SHIFT_DIVIDEBYZERO);
ADDCONST(SHIFT_OVERFLOW);
ADDCONST(SHIFT_UNDERFLOW);
ADDCONST(SHIFT_INVALID);
ADDCONST(FPE_DIVIDEBYZERO);
ADDCONST(FPE_OVERFLOW);
ADDCONST(FPE_UNDERFLOW);
ADDCONST(FPE_INVALID);
ADDCONST(FLOATING_POINT_SUPPORT);
ADDSCONST(PYVALS_NAME);
#undef ADDCONST
#undef ADDSCONST
PyModule_AddIntConstant(m, "UFUNC_BUFSIZE_DEFAULT", (long)NPY_BUFSIZE);
PyModule_AddObject(m, "PINF", PyFloat_FromDouble(NPY_INFINITY));
PyModule_AddObject(m, "NINF", PyFloat_FromDouble(-NPY_INFINITY));
PyModule_AddObject(m, "PZERO", PyFloat_FromDouble(NPY_PZERO));
PyModule_AddObject(m, "NZERO", PyFloat_FromDouble(NPY_NZERO));
PyModule_AddObject(m, "NAN", PyFloat_FromDouble(NPY_NAN));
#if defined(NPY_PY3K)
s = PyDict_GetItemString(d, "true_divide");
PyDict_SetItemString(d, "divide", s);
#endif
s = PyDict_GetItemString(d, "conjugate");
s2 = PyDict_GetItemString(d, "remainder");
/* Setup the array object's numerical structures with appropriate
ufuncs in d*/
PyArray_SetNumericOps(d);
PyDict_SetItemString(d, "conj", s);
PyDict_SetItemString(d, "mod", s2);
initscalarmath(m);
if (!intern_strings()) {
goto err;
}
return RETVAL;
err:
/* Check for errors */
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_RuntimeError,
"cannot load umath module.");
}
return RETVAL;
}
