C++ PyArray_FROM_OTF函数代码示例

// create a new NDF (simple) structure
static PyObject*
pyndf_new(NDF *self, PyObject *args)
{
	// use ultracam defaults
	const char *ftype = "_REAL";
	int ndim;
	PyObject* lb;
	PyObject* ub;
	if(!PyArg_ParseTuple(args, "siOO:pyndf_new", &ftype, &ndim, &lb, &ub))
		return NULL;
	if(ndim < 0 || ndim > 7)
		return NULL;
	// TODO: check for ftype here
	int status = SAI__OK;
	PyArrayObject* lower = (PyArrayObject*) PyArray_FROM_OTF(lb, NPY_UINT, NPY_IN_ARRAY | NPY_FORCECAST);
	PyArrayObject* upper = (PyArrayObject*) PyArray_FROM_OTF(ub, NPY_UINT, NPY_IN_ARRAY | NPY_FORCECAST);
	if (!lower || !upper)
		return NULL;
	if(PyArray_SIZE(lower) != ndim || PyArray_SIZE(upper) != ndim)
		return NULL;
        errBegin(&status);
	ndfNew(ftype,ndim,(int*)PyArray_DATA(lower),(int*)PyArray_DATA(upper),&self->_place,&self->_ndfid,&status); // placeholder annulled by this routine
	Py_DECREF(lower);
	Py_DECREF(upper);
	if (raiseNDFException(&status))
		return NULL;
	Py_RETURN_NONE;
}

static PyObject * averageDirectionIndexed(PyObject *dummy, PyObject *args)
{
  PyObject *arg1=NULL, *arg2=NULL;
  PyObject *arr1=NULL, *arr2=NULL;
  int *ind;
  float *vec, tol;
  if (!PyArg_ParseTuple(args, "OOf", &arg1, &arg2, &tol)) return NULL;
  arr1 = PyArray_FROM_OTF(arg1, NPY_FLOAT, NPY_INOUT_ARRAY);
  if (arr1 == NULL) return NULL;
  arr2 = PyArray_FROM_OTF(arg2, NPY_INT, NPY_INOUT_ARRAY);
  if (arr2 == NULL) goto fail;

  npy_intp * dims;
  int nvec,ndim;
  dims = PyArray_DIMS(arg1);
  ndim = dims[1];
  dims = PyArray_DIMS(arg2);
  nvec = dims[0];

  vec = (float *)PyArray_DATA(arr1);
  ind = (int *)PyArray_DATA(arr2);
  average_direction_indexed(vec,ndim,ind,nvec,tol);

  /* Clean up and return */
  Py_DECREF(arr1);
  Py_DECREF(arr2);
  Py_INCREF(Py_None);
  return Py_None;
 fail:
  Py_XDECREF(arr1);
  Py_XDECREF(arr2);
  return NULL;
}

//http://www.tutorialspoint.com/python/python_further_extensions.htm
//https://docs.python.org/2/extending/extending.html
//http://dan.iel.fm/posts/python-c-extensions/
static PyObject* pyspectro_HelloWorld(PyObject* self, PyObject* args) {
	printf("compiled on %s %s\n", __DATE__, __TIME__);
	printf("Then Ben said something");
	PyObject *doublearr_obj, *intarr_obj;
	if(PyArg_ParseTuple(args, "OO", &doublearr_obj, &intarr_obj) == 0) {
		printf("error!\n");
		return NULL;
	}
	PyObject* doublearr = PyArray_FROM_OTF(doublearr_obj, NPY_DOUBLE, NPY_OUT_ARRAY);
	PyObject* intarr = PyArray_FROM_OTF(intarr_obj, NPY_UINT8, NPY_OUT_ARRAY);
	if(!doublearr || !intarr) {
		Py_XDECREF(doublearr);
		Py_XDECREF(intarr);
		return NULL;
	}
	int dN = (int)PyArray_DIM(doublearr, 0);
	int iN = (int)PyArray_DIM(intarr, 0);
	double* c_doublearr = (double*)PyArray_DATA(doublearr);
	unsigned char* c_intarr = (unsigned char*)PyArray_DATA(intarr);
	if(c_intarr[0] == 1) {
		PyErr_SetString(PyExc_IOError, "hello");
		return NULL;
	}
	for(int i = 0; i < dN; i++)
		c_doublearr[i] = dN - i;
	for(int i = 0; i < iN; i++)
		c_intarr[i] = dN - i;
	Py_DECREF(doublearr);
	Py_DECREF(intarr);
	Py_RETURN_NONE;
}

static PyObject* dtw_extension(PyObject *dummy, PyObject *args) {
    PyObject *arg1 = NULL;
    PyObject *arr1 = NULL;
    PyObject *arg2 = NULL;
    PyObject *arr2 = NULL;

    if (!PyArg_ParseTuple(args, "OO", &arg1, &arg2)) {
      return NULL;
    }

    arr1 = PyArray_FROM_OTF(arg1, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY);
    if (arr1 == NULL) {
      return NULL;
    }
    arr2 = PyArray_FROM_OTF(arg2, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY);
    if (arr2 == NULL) {
      return NULL;
    }

    // Number of dimensions
    int nd1 = PyArray_NDIM((PyArrayObject*)arr1);
    int arr_type1 = PyArray_TYPE((PyArrayObject*)arr1);
    npy_intp *dims1 = PyArray_DIMS((PyArrayObject*)arr1);
    int nd2 = PyArray_NDIM((PyArrayObject*)arr2);
    int arr_type2 = PyArray_TYPE((PyArrayObject*)arr2);
    npy_intp *dims2 = PyArray_DIMS((PyArrayObject*)arr2);
    int r = 0;
    npy_double **input1 = NULL;
    r = PyArray_AsCArray((PyObject**)&arr1, (void**)&input1, dims1, nd1, PyArray_DescrFromType(arr_type1));
    if (r < 0) {
      PyErr_SetString(PyExc_RuntimeError, "Could not convert input to C array");
      return NULL;
    }
    npy_double **input2 = NULL;
    r = PyArray_AsCArray((PyObject**)&arr2, (void**)&input2, dims2, nd2, PyArray_DescrFromType(arr_type2));
    if (r < 0) {
      PyErr_SetString(PyExc_RuntimeError, "Could not convert input to C array");
      return NULL;
    }

    // DTW
    matrix_t mat_a = { input1, dims1[0], dims1[1] };
    matrix_t mat_b = { input2, dims2[0], dims2[1] };
    double dist = dtw_distance(&mat_a, &mat_b);
    PyObject *value = PyFloat_FromDouble(dist);
    if (value == NULL) {
      PyErr_SetString(PyExc_RuntimeError, "Could not convert double to object");
      return NULL;
    }
    Py_DECREF(arr1);
    Py_DECREF(arr2);

    PyArray_Free(arr1, (void*)input1);
    PyArray_Free(arr2, (void*)input2);

    return value;
}

static PyObject* evaluate_baseline_uvw_ha_dec(PyObject* self, PyObject* args)
{
    /* Read input arguments */
    PyObject *x_ecef_o=NULL, *y_ecef_o=NULL, *z_ecef_o=NULL;
    double ha, dec;
    if (!PyArg_ParseTuple(args, "O!O!O!dd", &PyArray_Type, &x_ecef_o,
        &PyArray_Type, &y_ecef_o, &PyArray_Type, &z_ecef_o, &ha, &dec))
        return NULL;

    /*  Convert Python objects to array of specified built-in data-type.*/
    int typenum = NPY_DOUBLE;
    int requirements = NPY_ARRAY_IN_ARRAY;
    PyObject *x_ecef_=NULL, *y_ecef_=NULL, *z_ecef_=NULL;
    x_ecef_ = PyArray_FROM_OTF(x_ecef_o, typenum, requirements);
    if (!x_ecef_) goto fail;
    y_ecef_ = PyArray_FROM_OTF(y_ecef_o, typenum, requirements);
    if (!y_ecef_) goto fail;
    z_ecef_ = PyArray_FROM_OTF(z_ecef_o, typenum, requirements);
    if (!z_ecef_) goto fail;

    /* Extract dimensions and pointers. */
    /* TODO(BM) Require input arrays be 1D, and check dimension consistency.
     * int nd = PyArray_NDIM(x_ecef_); */
    npy_intp* dims = PyArray_DIMS((PyArrayObject*)x_ecef_);
    double* x_ecef = (double*)PyArray_DATA((PyArrayObject*)x_ecef_);
    double* y_ecef = (double*)PyArray_DATA((PyArrayObject*)y_ecef_);
    double* z_ecef = (double*)PyArray_DATA((PyArrayObject*)z_ecef_);

    /* Create New arrays for baseline coordinates. */
    int n   = dims[0];
    npy_intp nb  = (n * (n - 1)) / 2;
    PyObject* uu_ = PyArray_SimpleNew(1, &nb, NPY_DOUBLE);
    PyObject* vv_ = PyArray_SimpleNew(1, &nb, NPY_DOUBLE);
    PyObject* ww_ = PyArray_SimpleNew(1, &nb, NPY_DOUBLE);
    double* uu  = (double*)PyArray_DATA((PyArrayObject*)uu_);
    double* vv  = (double*)PyArray_DATA((PyArrayObject*)vv_);
    double* ww  = (double*)PyArray_DATA((PyArrayObject*)ww_);

    /* Call function to evaluate baseline uvw */
    uvwsim_evaluate_baseline_uvw_ha_dec(uu, vv, ww, n, x_ecef, y_ecef, z_ecef,
                                        ha, dec);

    /* Decrement references to local array objects. */
    Py_DECREF(x_ecef_);
    Py_DECREF(y_ecef_);
    Py_DECREF(z_ecef_);

    /* Return baseline coordinates. */
    return Py_BuildValue("NNN", uu_, vv_, ww_);

fail:
    Py_XDECREF(x_ecef_);
    Py_XDECREF(y_ecef_);
    Py_XDECREF(z_ecef_);
    return NULL;
}

static PyObject* evaluate_station_uvw(PyObject* self, PyObject* args)
{
    /* Read input arguments */
    PyObject *x_ecef_o=NULL, *y_ecef_o=NULL, *z_ecef_o=NULL;
    double ra0, dec0, mjd;
    if (!PyArg_ParseTuple(args, "O!O!O!ddd", &PyArray_Type, &x_ecef_o,
        &PyArray_Type, &y_ecef_o, &PyArray_Type, &z_ecef_o,
        &ra0, &dec0, &mjd)) return NULL;

    /*  Convert Python objects to array of specified built-in data-type.*/
    int typenum = NPY_DOUBLE;
    int requirements = NPY_ARRAY_IN_ARRAY;
    PyObject *x_ecef_=NULL, *y_ecef_=NULL, *z_ecef_=NULL;
    x_ecef_ = PyArray_FROM_OTF(x_ecef_o, typenum, requirements);
    if (!x_ecef_) goto fail;
    y_ecef_ = PyArray_FROM_OTF(y_ecef_o, typenum, requirements);
    if (!y_ecef_) goto fail;
    z_ecef_ = PyArray_FROM_OTF(z_ecef_o, typenum, requirements);
    if (!z_ecef_) goto fail;

    /* Extract dimensions and pointers. */
    /* TODO Require input arrays be 1D, and check dimension consistency.
     * int nd = PyArray_NDIM(x_ecef_); */
    npy_intp* dims = PyArray_DIMS((PyArrayObject*)x_ecef_);
    double* x_ecef = (double*)PyArray_DATA((PyArrayObject*)x_ecef_);
    double* y_ecef = (double*)PyArray_DATA((PyArrayObject*)y_ecef_);
    double* z_ecef = (double*)PyArray_DATA((PyArrayObject*)z_ecef_);

    /* Create New arrays for station coordinates. */
    npy_intp n = dims[0];
    PyObject* u_ = PyArray_SimpleNew(1, &n, NPY_DOUBLE);
    PyObject* v_ = PyArray_SimpleNew(1, &n, NPY_DOUBLE);
    PyObject* w_ = PyArray_SimpleNew(1, &n, NPY_DOUBLE);
    double* u  = (double*)PyArray_DATA((PyArrayObject*)u_);
    double* v  = (double*)PyArray_DATA((PyArrayObject*)v_);
    double* w  = (double*)PyArray_DATA((PyArrayObject*)w_);

    /* Call function to evaluate station uvw */
    uvwsim_evaluate_station_uvw(u, v, w, n, x_ecef, y_ecef, z_ecef, ra0, dec0,
        mjd);

    /* Decrement references to local array objects. */
    Py_DECREF(x_ecef_);
    Py_DECREF(y_ecef_);
    Py_DECREF(z_ecef_);

    /* Return station uvw coordinates. */
    return Py_BuildValue("NNN", u_, v_, w_);

fail:
    Py_XDECREF(x_ecef_);
    Py_XDECREF(y_ecef_);
    Py_XDECREF(z_ecef_);
    return NULL;
}

PyObject *punwrap2D_Unwrap2D(PyObject *self, PyObject *args) {
  PyObject *op1, *op2;
  PyArrayObject *phsArray, *mskArray, *retArray;
  float *wr_phs, *uw_phs;
  BYTE *bmask;
  int typenum_phs, typenum_msk, ndim;
  npy_intp *dims;
  PyArray_Descr *dtype_phs;

  if(!PyArg_ParseTuple(args, "OO", &op1, &op2)) {
    PyErr_SetString(PyExc_Exception,"Unwrap2D: Couldn't parse the arguments");
    return NULL;
  }
  if(op1==NULL || op2==NULL) {
    PyErr_SetString(PyExc_Exception,"Unwrap2D: Arguments not read correctly");
    return NULL;
  }
  
  typenum_phs = PyArray_TYPE(op1);
  typenum_msk = PyArray_TYPE(op2);
  ndim = PyArray_NDIM(op1);
  dims = PyArray_DIMS(op2);
  /* This stuff is technically enforced in punwrap/__init__.py */
  if(typenum_phs != PyArray_FLOAT) {
    PyErr_SetString(PyExc_Exception, "Unwrap2D: I can only handle single-precision floating point numbers");
    return NULL;
  }
  if(typenum_msk != PyArray_UBYTE) {
    PyErr_SetString(PyExc_Exception, "Unwrap2D: The mask should be type uint8");
    return NULL;
  }
  if(ndim != 2) {
    PyErr_SetString(PyExc_Exception, "Unwrap2D: I can only unwrap 2D arrays");
    return NULL;
  }

  dtype_phs = PyArray_DescrFromType(typenum_phs);
  /* increasing references here */
  phsArray = (PyArrayObject *)PyArray_FROM_OTF(op1, typenum_phs, NPY_IN_ARRAY);
  mskArray = (PyArrayObject *)PyArray_FROM_OTF(op2, typenum_msk, NPY_IN_ARRAY);
  /* create a new, empty ndarray with floats */
  retArray = (PyArrayObject *)PyArray_SimpleNewFromDescr(ndim, dims, dtype_phs);
  wr_phs = (float *)PyArray_DATA(phsArray);
  uw_phs = (float *)PyArray_DATA(retArray);
  bmask = (BYTE *)PyArray_DATA(mskArray);

  phase_unwrap_2D(wr_phs, uw_phs, bmask, (int) dims[0], (int) dims[1]);

  Py_DECREF(phsArray);
  Py_DECREF(mskArray);
  return PyArray_Return(retArray);
    
}

static PyObject *hc_cut(PyObject *self, PyObject *args, PyObject *keywds)
{
  /* Inputs */
  PyObject *ia = NULL; PyObject *ia_a = NULL;
  PyObject *ib = NULL; PyObject *ib_a = NULL;
  PyObject *height = NULL; PyObject *height_a = NULL;
  double t;
  
  npy_intp n;
   
  long *ia_c;
  long *ib_c;
  double *height_c;

  PyObject *cmap = NULL;
  npy_intp cmap_dims[1];
  long *cmap_c;
  

  static char *kwlist[] = {"ia", "ib", "height", "t", NULL};
  if (!PyArg_ParseTupleAndKeywords(args, keywds, "OOOd", kwlist,
				   &ia, &ib, &height, &t))
    return NULL;

  ia_a = PyArray_FROM_OTF(ia, NPY_LONG, NPY_IN_ARRAY);
  if (ia_a == NULL) return NULL;
  
  ib_a = PyArray_FROM_OTF(ib, NPY_LONG, NPY_IN_ARRAY);
  if (ib_a == NULL) return NULL;
  
  height_a = PyArray_FROM_OTF(height, NPY_DOUBLE, NPY_IN_ARRAY);
  if (height_a == NULL) return NULL;
  
  n = PyArray_DIM(height_a, 0);
  
  ia_c = (long *) PyArray_DATA(ia_a);
  ib_c = (long *) PyArray_DATA(ib_a);
  height_c = (double *) PyArray_DATA(height_a);
 
  cmap_dims[0] = n;
  cmap = PyArray_SimpleNew(1, cmap_dims, NPY_LONG);
  cmap_c = (long *) PyArray_DATA(cmap);

  cutree((long) n, ia_c, ib_c, height_c, t, cmap_c);
  
  Py_DECREF(ia_a);
  Py_DECREF(ib_a);
  Py_DECREF(height_a);

  return Py_BuildValue("N", cmap);
}

static PyObject *chi2_chi2(PyObject *self, PyObject *args)
{
    double m, b;
    PyObject *x_obj, *y_obj, *yerr_obj;

    /* Parse the input tuple */
    if (!PyArg_ParseTuple(args, "ddOOO", &m, &b, &x_obj, &y_obj,
                                         &yerr_obj))
        return NULL;

    /* Interpret the input objects as numpy arrays. */
    PyObject *x_array = PyArray_FROM_OTF(x_obj, NPY_DOUBLE, NPY_IN_ARRAY);
    PyObject *y_array = PyArray_FROM_OTF(y_obj, NPY_DOUBLE, NPY_IN_ARRAY);
    PyObject *yerr_array = PyArray_FROM_OTF(yerr_obj, NPY_DOUBLE,
                                            NPY_IN_ARRAY);

    /* If that didn't work, throw an exception. */
    if (x_array == NULL || y_array == NULL || yerr_array == NULL) {
        Py_XDECREF(x_array);
        Py_XDECREF(y_array);
        Py_XDECREF(yerr_array);
        return NULL;
    }

    /* How many data points are there? */
    int N = (int)PyArray_DIM(x_array, 0);

    /* Get pointers to the data as C-types. */
    double *x    = (double*)PyArray_DATA(x_array);
    double *y    = (double*)PyArray_DATA(y_array);
    double *yerr = (double*)PyArray_DATA(yerr_array);

    /* Call the external C function to compute the chi-squared. */
    double value = chi2(m, b, x, y, yerr, N);

    /* Clean up. */
    Py_DECREF(x_array);
    Py_DECREF(y_array);
    Py_DECREF(yerr_array);

    if (value < 0.0) {
        PyErr_SetString(PyExc_RuntimeError,
                    "Chi-squared returned an impossible value.");
        return NULL;
    }

    /* Build the output tuple */
    PyObject *ret = Py_BuildValue("d", value);
    return ret;
}

static PyObject * tofile_iint32(PyObject *dummy, PyObject *args)
{
  PyObject *arg1=NULL, *arg2=NULL, *arg3=NULL;
  PyObject *arr1=NULL, *arr2=NULL;
  FILE *fp;
  char *fmt; /* single element format */

  if (!PyArg_ParseTuple(args, "OOOs", &arg1, &arg2, &arg3, &fmt)) return NULL;
  arr1 = PyArray_FROM_OTF(arg1, NPY_INT, NPY_IN_ARRAY);
  if (arr1 == NULL) return NULL;
  arr2 = PyArray_FROM_OTF(arg2, NPY_INT, NPY_IN_ARRAY);
  if (arr2 == NULL) goto fail;
  fp = PyFile_AsFile(arg3);
  if (!fp) goto fail;

  int *val;
  val = (int *)PyArray_DATA(arr2);
  npy_intp * dims;
  dims = PyArray_DIMS(arg2);
  int nr,nc;
  nr = dims[0];
  nc = dims[1];

  int *ind;
  ind = (int *)PyArray_DATA(arr1);
  dims = PyArray_DIMS(arg1);
  if (dims[0] != nr) goto fail;

  int i,j;
  for (i=0; i<nr; i++) {
    fprintf(fp,"%i ",*(ind++));
    for (j=0; j<nc; j++) {
      fprintf(fp,fmt,*(val++));
    }
    fprintf(fp,"\n");
  }

  /* Clean up and return */
  Py_DECREF(arr1);
  Py_DECREF(arr2);
  Py_INCREF(Py_None);
  return Py_None;

 fail:
  Py_XDECREF(arr1);
  Py_XDECREF(arr2);
  return NULL;
}

static PyObject* Py_convert_shape(
	PyObject*	self,
	PyObject*	args)
{
	PyObject*	landmarks_obj;
	int		format;

	if (!PyArg_ParseTuple(args, "Oi:convert_shape", &landmarks_obj, &format))
		return NULL;

	PyArrayObject* landmarks_array = (PyArrayObject*)
			PyArray_FROM_OTF(landmarks_obj, NPY_FLOAT, NPY_ARRAY_IN_ARRAY);
	if (landmarks_array == NULL)
	{
		PyErr_SetString(PyExc_TypeError, landmark_error);
		return NULL;
	}

	if (PyArray_NDIM(landmarks_array) != 2)
	{
		PyErr_SetString(PyExc_TypeError, landmark_dim_error);
		return NULL;
	}

	PyObject* retArray = PyArray_Copy(landmarks_array);
	Py_DECREF(landmarks_array);
	float* landmarks = (float*)PyArray_DATA((PyArrayObject*)retArray);
	stasm_convert_shape(landmarks, format);

	return retArray;
}

static PyObject* pyspectro_readavsspectrum(PyObject* self, PyObject* args) {
	PyObject *spectrum_obj;
	unsigned int timeout;
	long hDevice;
	if(PyArg_ParseTuple(args, "Oil", &spectrum_obj, &timeout, &hDevice) == 0)
		return NULL;
	PyObject* spectrum = PyArray_FROM_OTF(spectrum_obj, NPY_DOUBLE, NPY_OUT_ARRAY);
	if(!spectrum) {
		Py_XDECREF(spectrum);
		return NULL;
	}
	//int N = (int)PyArray_DIM(spectrum, 0);
	double* c_spectrum = (double*)PyArray_DATA(spectrum);

	int err;
	unsigned int timestamp = 0;
	if((err = fReadAVSSpectrum(hDevice, c_spectrum, &timestamp, timeout)) != 0) {
		Py_DECREF(spectrum);
		char line[512];
		snprintf(line, sizeof(line), "ReadAVSSpectrum(): %d\n", err);
		PyErr_SetString(PyExc_IOError, line);
		return NULL;
	}
	Py_DECREF(spectrum);
	return Py_BuildValue("i", timestamp);
}

static PyObject *wrap_logicle_scale(PyObject *self, PyObject *args) {
    double t, w, m, a;
    PyObject *x;

    // parse the input args tuple
    if (!PyArg_ParseTuple(args, "ddddO", &t, &w, &m, &a, &x)) {
        return NULL;
    }

    // read the numpy array
    PyObject *x_array = PyArray_FROM_OTF(x, NPY_DOUBLE, NPY_IN_ARRAY);

    // throw exception if the array doesn't exist
    if (x_array == NULL) {
        Py_XDECREF(x_array);
        return NULL;
    }

    // get length of input array
    int n = (int)PyArray_DIM(x_array, 0);

    // get pointers to the data as C-type
    double *xc    = (double*)PyArray_DATA(x_array);

    // now we can call our function!
    logicle_scale(t, w, m, a, xc, n);

    return x_array;
}

/*
 * Returns image data from a PyObject representing a numpy array.
 *
 * In:		array_obj	-	Numpy array with image data
 * Out:		width		-	Image width
 * Out:		height		-	Image height
 *
 * Returns:	char* pointing to the array data;
 * 			NULL if array is invalid
 */
const char* PyArray_to_image(
	PyObject*	array_obj,
	int* 		width,
	int*		height)
{
	PyArrayObject* img_array = (PyArrayObject*)
		PyArray_FROM_OTF(array_obj, NPY_UINT8, NPY_ARRAY_IN_ARRAY);

	if (img_array == NULL)
	{
		PyErr_SetString(PyExc_TypeError, imarray_error);
		return NULL;
	}

	if (PyArray_NDIM(img_array) != 2)
	{
		PyErr_SetString(PyExc_TypeError, imarray_dim_error);
		return NULL;
	}

	*height = (int)PyArray_DIM(img_array, 0);
	*width = (int)PyArray_DIM(img_array, 1);
	const char* img_data = PyArray_BYTES(img_array);

	Py_DECREF(img_array);

	return img_data;
}

// this copies a block of memory from a numpy array to a memory address
static PyObject*
pymappedndf_numpytondf(NDFMapped *self, PyObject *args)
{
	PyObject *npy, *ptrobj;
	PyArrayObject *npyarray;
	npy_intp el;
	size_t bytes;

	if(!PyArg_ParseTuple(args, "O:pyndfmapped_numpytondf",&npy))
		return NULL;
	void *ptr = self->_pntr;
	el = self->nelem;
	if (el <= 0 || ptr == NULL) {
          PyErr_SetString( PyExc_ValueError,
                           "ndf.mapped object does not have mapped pointer or element count");
          return NULL;
        }

        int npytype = ndftype2numpy( self->type, &bytes );
        if (npytype == 0) return NULL;
        npyarray = (PyArrayObject*) PyArray_FROM_OTF(npy, npytype, NPY_IN_ARRAY | NPY_FORCECAST);
        if (!npyarray) return NULL;

        /* Verify the number of elements */
        if ( PyArray_Size(npyarray) != el ) {
          PyErr_Format( PyExc_ValueError,
                        "Number of elements in numpy array (%zu) differs from number of elements mapped (%zu)",
                        (size_t)PyArray_Size(npyarray), (size_t)el );
          Py_DECREF(npyarray);
          return NULL;
        }
        memcpy(ptr,PyArray_DATA(npyarray),el*bytes);
	Py_DECREF(npyarray);
	Py_RETURN_NONE;
}