static int
check_object(PyObject *ob, int t, char *obname,
char *tname, char *funname)
{
if (!PyArray_Check(ob)) {
PyErr_Format(LapackError,
"Expected an array for parameter %s in lapack_lite.%s",
obname, funname);
return 0;
}
else if (!PyArray_IS_C_CONTIGUOUS((PyArrayObject *)ob)) {
PyErr_Format(LapackError,
"Parameter %s is not contiguous in lapack_lite.%s",
obname, funname);
return 0;
}
else if (!(PyArray_TYPE((PyArrayObject *)ob) == t)) {
PyErr_Format(LapackError,
"Parameter %s is not of type %s in lapack_lite.%s",
obname, tname, funname);
return 0;
}
else if (PyArray_ISBYTESWAPPED((PyArrayObject *)ob)) {
PyErr_Format(LapackError,
"Parameter %s has non-native byte order in lapack_lite.%s",
obname, funname);
return 0;
}
else {
return 1;
}
}
/*NUMPY_API
* Clip
*/
NPY_NO_EXPORT PyObject *
PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *out)
{
PyArray_FastClipFunc *func;
int outgood = 0, ingood = 0;
PyArrayObject *maxa = NULL;
PyArrayObject *mina = NULL;
PyArrayObject *newout = NULL, *newin = NULL;
PyArray_Descr *indescr = NULL, *newdescr = NULL;
char *max_data, *min_data;
PyObject *zero;
/* Treat None the same as NULL */
if (min == Py_None) {
min = NULL;
}
if (max == Py_None) {
max = NULL;
}
if ((max == NULL) && (min == NULL)) {
PyErr_SetString(PyExc_ValueError,
"array_clip: must set either max or min");
return NULL;
}
func = PyArray_DESCR(self)->f->fastclip;
if (func == NULL
|| (min != NULL && !PyArray_CheckAnyScalar(min))
|| (max != NULL && !PyArray_CheckAnyScalar(max))
|| PyArray_ISBYTESWAPPED(self)
|| (out && PyArray_ISBYTESWAPPED(out))) {
return _slow_array_clip(self, min, max, out);
}
/* Use the fast scalar clip function */
/* First we need to figure out the correct type */
if (min != NULL) {
indescr = PyArray_DescrFromObject(min, NULL);
if (indescr == NULL) {
goto fail;
}
}
if (max != NULL) {
newdescr = PyArray_DescrFromObject(max, indescr);
Py_XDECREF(indescr);
indescr = NULL;
if (newdescr == NULL) {
goto fail;
}
}
else {
/* Steal the reference */
newdescr = indescr;
indescr = NULL;
}
/*
* Use the scalar descriptor only if it is of a bigger
* KIND than the input array (and then find the
* type that matches both).
*/
if (PyArray_ScalarKind(newdescr->type_num, NULL) >
PyArray_ScalarKind(PyArray_DESCR(self)->type_num, NULL)) {
indescr = PyArray_PromoteTypes(newdescr, PyArray_DESCR(self));
if (indescr == NULL) {
goto fail;
}
func = indescr->f->fastclip;
if (func == NULL) {
Py_DECREF(indescr);
return _slow_array_clip(self, min, max, out);
}
}
else {
indescr = PyArray_DESCR(self);
Py_INCREF(indescr);
}
Py_DECREF(newdescr);
newdescr = NULL;
if (!PyDataType_ISNOTSWAPPED(indescr)) {
PyArray_Descr *descr2;
descr2 = PyArray_DescrNewByteorder(indescr, '=');
Py_DECREF(indescr);
indescr = NULL;
if (descr2 == NULL) {
goto fail;
}
indescr = descr2;
}
/* Convert max to an array */
if (max != NULL) {
Py_INCREF(indescr);
maxa = (PyArrayObject *)PyArray_FromAny(max, indescr, 0, 0,
NPY_ARRAY_DEFAULT, NULL);
if (maxa == NULL) {
goto fail;
}
}
/*
* If we are unsigned, then make sure min is not < 0
* This is to match the behavior of _slow_array_clip
*
* We allow min and max to go beyond the limits
* for other data-types in which case they
* are interpreted as their modular counterparts.
*/
if (min != NULL) {
if (PyArray_ISUNSIGNED(self)) {
int cmp;
zero = PyInt_FromLong(0);
cmp = PyObject_RichCompareBool(min, zero, Py_LT);
if (cmp == -1) {
Py_DECREF(zero);
goto fail;
}
if (cmp == 1) {
min = zero;
}
else {
Py_DECREF(zero);
Py_INCREF(min);
}
}
else {
Py_INCREF(min);
}
/* Convert min to an array */
Py_INCREF(indescr);
mina = (PyArrayObject *)PyArray_FromAny(min, indescr, 0, 0,
NPY_ARRAY_DEFAULT, NULL);
Py_DECREF(min);
if (mina == NULL) {
goto fail;
}
}
/*
* Check to see if input is single-segment, aligned,
* and in native byteorder
*/
if (PyArray_ISONESEGMENT(self) &&
PyArray_CHKFLAGS(self, NPY_ARRAY_ALIGNED) &&
PyArray_ISNOTSWAPPED(self) &&
(PyArray_DESCR(self) == indescr)) {
ingood = 1;
}
if (!ingood) {
int flags;
if (PyArray_ISFORTRAN(self)) {
flags = NPY_ARRAY_FARRAY;
}
else {
flags = NPY_ARRAY_CARRAY;
}
Py_INCREF(indescr);
newin = (PyArrayObject *)PyArray_FromArray(self, indescr, flags);
if (newin == NULL) {
goto fail;
}
}
else {
newin = self;
Py_INCREF(newin);
}
/*
* At this point, newin is a single-segment, aligned, and correct
* byte-order array of the correct type
*
* if ingood == 0, then it is a copy, otherwise,
* it is the original input.
*/
/*
* If we have already made a copy of the data, then use
* that as the output array
*/
if (out == NULL && !ingood) {
out = newin;
}
/*
* Now, we know newin is a usable array for fastclip,
* we need to make sure the output array is available
* and usable
*/
if (out == NULL) {
Py_INCREF(indescr);
out = (PyArrayObject*)PyArray_NewFromDescr(Py_TYPE(self),
indescr, PyArray_NDIM(self),
PyArray_DIMS(self),
NULL, NULL,
PyArray_ISFORTRAN(self),
(PyObject *)self);
if (out == NULL) {
goto fail;
}
outgood = 1;
}
else Py_INCREF(out);
/* Input is good at this point */
if (out == newin) {
outgood = 1;
}
/* make sure the shape of the output array is the same */
if (!PyArray_SAMESHAPE(newin, out)) {
PyErr_SetString(PyExc_ValueError, "clip: Output array must have the"
"same shape as the input.");
goto fail;
}
if (!outgood && PyArray_EQUIVALENTLY_ITERABLE(
self, out, PyArray_TRIVIALLY_ITERABLE_OP_READ,
PyArray_TRIVIALLY_ITERABLE_OP_NOREAD) &&
PyArray_CHKFLAGS(out, NPY_ARRAY_ALIGNED) &&
PyArray_ISNOTSWAPPED(out) &&
PyArray_EquivTypes(PyArray_DESCR(out), indescr)) {
outgood = 1;
}
/*
* Do we still not have a suitable output array?
* Create one, now. No matter why the array is not suitable a copy has
* to be made. This may be just to avoid memory overlap though.
*/
if (!outgood) {
int oflags;
if (PyArray_ISFORTRAN(self)) {
oflags = NPY_ARRAY_FARRAY;
}
else {
oflags = NPY_ARRAY_CARRAY;
}
oflags |= (NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_FORCECAST |
NPY_ARRAY_ENSURECOPY);
Py_INCREF(indescr);
newout = (PyArrayObject*)PyArray_FromArray(out, indescr, oflags);
if (newout == NULL) {
goto fail;
}
}
else {
newout = out;
Py_INCREF(newout);
}
/* Now we can call the fast-clip function */
min_data = max_data = NULL;
if (mina != NULL) {
min_data = PyArray_DATA(mina);
}
if (maxa != NULL) {
max_data = PyArray_DATA(maxa);
}
func(PyArray_DATA(newin), PyArray_SIZE(newin), min_data, max_data, PyArray_DATA(newout));
/* Clean up temporary variables */
Py_XDECREF(indescr);
Py_XDECREF(newdescr);
Py_XDECREF(mina);
Py_XDECREF(maxa);
Py_DECREF(newin);
/* Copy back into out if out was not already a nice array. */
PyArray_ResolveWritebackIfCopy(newout);
Py_DECREF(newout);
return (PyObject *)out;
fail:
Py_XDECREF(indescr);
Py_XDECREF(newdescr);
Py_XDECREF(maxa);
Py_XDECREF(mina);
Py_XDECREF(newin);
PyArray_DiscardWritebackIfCopy(newout);
Py_XDECREF(newout);
return NULL;
}
static PyObject*
mseed_store_traces (PyObject *m, PyObject *args)
{
char *filename;
MSTrace *mst = NULL;
PyObject *array = NULL;
PyObject *in_traces = NULL;
PyObject *in_trace = NULL;
PyArrayObject *contiguous_array = NULL;
int i;
char *network, *station, *location, *channel;
char mstype;
int msdetype;
int64_t psamples;
int numpytype;
int length;
FILE *outfile;
struct module_state *st = GETSTATE(m);
if (!PyArg_ParseTuple(args, "Os", &in_traces, &filename)) {
PyErr_SetString(st->error, "usage store_traces(traces, filename)" );
return NULL;
}
if (!PySequence_Check( in_traces )) {
PyErr_SetString(st->error, "Traces is not of sequence type." );
return NULL;
}
outfile = fopen(filename, "w" );
if (outfile == NULL) {
PyErr_SetString(st->error, "Error opening file.");
return NULL;
}
for (i=0; i<PySequence_Length(in_traces); i++) {
in_trace = PySequence_GetItem(in_traces, i);
if (!PyTuple_Check(in_trace)) {
PyErr_SetString(st->error, "Trace record must be a tuple of (network, station, location, channel, starttime, endtime, samprate, data)." );
Py_DECREF(in_trace);
return NULL;
}
mst = mst_init (NULL);
if (!PyArg_ParseTuple(in_trace, "ssssLLdO",
&network,
&station,
&location,
&channel,
&(mst->starttime),
&(mst->endtime),
&(mst->samprate),
&array )) {
PyErr_SetString(st->error, "Trace record must be a tuple of (network, station, location, channel, starttime, endtime, samprate, data)." );
mst_free( &mst );
Py_DECREF(in_trace);
return NULL;
}
strncpy( mst->network, network, 10);
strncpy( mst->station, station, 10);
strncpy( mst->location, location, 10);
strncpy( mst->channel, channel, 10);
mst->network[10] = '\0';
mst->station[10] = '\0';
mst->location[10] ='\0';
mst->channel[10] = '\0';
if (!PyArray_Check(array)) {
PyErr_SetString(st->error, "Data must be given as NumPy array." );
mst_free( &mst );
Py_DECREF(in_trace);
return NULL;
}
if (PyArray_ISBYTESWAPPED((PyArrayObject*)array)) {
PyErr_SetString(st->error, "Data must be given in machine byte-order" );
mst_free( &mst );
Py_DECREF(in_trace);
return NULL;
}
numpytype = PyArray_TYPE((PyArrayObject*)array);
switch (numpytype) {
case NPY_INT32:
assert( ms_samplesize('i') == 4 );
mstype = 'i';
msdetype = DE_STEIM1;
break;
case NPY_INT8:
assert( ms_samplesize('a') == 1 );
mstype = 'a';
msdetype = DE_ASCII;
break;
case NPY_FLOAT32:
assert( ms_samplesize('f') == 4 );
mstype = 'f';
msdetype = DE_FLOAT32;
break;
case NPY_FLOAT64:
assert( ms_samplesize('d') == 8 );
mstype = 'd';
msdetype = DE_FLOAT64;
break;
default:
PyErr_SetString(st->error, "Data must be of type float64, float32, int32 or int8.");
mst_free( &mst );
Py_DECREF(in_trace);
return NULL;
}
mst->sampletype = mstype;
contiguous_array = PyArray_GETCONTIGUOUS((PyArrayObject*)array);
length = PyArray_SIZE(contiguous_array);
mst->numsamples = length;
mst->samplecnt = length;
mst->datasamples = calloc(length,ms_samplesize(mstype));
memcpy(mst->datasamples, PyArray_DATA(contiguous_array), length*ms_samplesize(mstype));
Py_DECREF(contiguous_array);
mst_pack (mst, &record_handler, outfile, 4096, msdetype,
1, &psamples, 1, 0, NULL);
mst_free( &mst );
Py_DECREF(in_trace);
}
fclose( outfile );
Py_INCREF(Py_None);
return Py_None;
}