C++ PyCObject_AsVoidPtr函数代码示例

int LoadCarbonXAE() {
	PyObject *aeModule, *aeAPIObj;
	CarbonXAE_API *aeAPI;
	
	if ((aeModule = PyImport_ImportModule("CarbonX.AE")) == NULL) goto failed;
	if ((aeAPIObj = PyObject_GetAttrString(aeModule, "aeAPI")) == NULL) goto failed;
	if ((aeAPI = (CarbonXAE_API *)PyCObject_AsVoidPtr(aeAPIObj)) == NULL) goto failed;
	
	Ptr_AEDescX_New = aeAPI->Ptr_AEDescX_New;
	Ptr_AEDescX_NewBorrowed = aeAPI->Ptr_AEDescX_NewBorrowed;
	Ptr_AEDescX_Convert = aeAPI->Ptr_AEDescX_Convert;
	
	if (!Ptr_AEDescX_New) goto failed;
	shouldLoad = 0; 
	return 1;
failed:
	PyErr_SetString(PyExc_ImportError, "Couldn't load module: CarbonX.AE");
	return 0;
}

static PyObject* pysplicing_simulate_reads(PyObject *self, PyObject *args) {
  PyObject *gff, *expression;
  int gene, noreads, readLength;
  splicing_vector_t myexpression;
  splicing_gff_t *mygff;
  splicing_vector_int_t isoform, position;
  splicing_strvector_t cigar;
  PyObject *risoform, *rposition, *rcigar;
  
  if (!PyArg_ParseTuple(args, "OiOii", &gff, &gene, &expression, &noreads,
			&readLength)) { return NULL; }

  mygff=PyCObject_AsVoidPtr(gff);
  if (pysplicing_to_vector(expression, &myexpression)) { return NULL; }
  SPLICING_FINALLY(splicing_vector_destroy, &myexpression);
  
  SPLICING_PYCHECK(splicing_strvector_init(&cigar, 0));
  SPLICING_FINALLY(splicing_strvector_destroy, &cigar);
  SPLICING_PYCHECK(splicing_vector_int_init(&position, 0));
  SPLICING_FINALLY(splicing_vector_int_destroy, &position);
  SPLICING_PYCHECK(splicing_vector_int_init(&isoform, 0));
  SPLICING_FINALLY(splicing_vector_int_destroy, &isoform);
  
  SPLICING_PYCHECK(splicing_simulate_reads(mygff, gene, &myexpression, 
					   noreads, readLength,
					   &isoform, &position, &cigar));
  
  risoform = pysplicing_from_vector_int(&isoform);
  splicing_vector_int_destroy(&isoform);
  SPLICING_FINALLY_CLEAN(1);
  rposition = pysplicing_from_vector_int(&position);
  splicing_vector_int_destroy(&position);
  SPLICING_FINALLY_CLEAN(1);
  rcigar = pysplicing_from_strvector(&cigar);
  splicing_strvector_destroy(&cigar);
  SPLICING_FINALLY_CLEAN(1);
  
  splicing_vector_destroy(&myexpression);
  SPLICING_FINALLY_CLEAN(1);
  
  return Py_BuildValue("OOO", risoform, rposition, rcigar);
}

static PyObject *
_xson_reader_simple (PyObject *self, PyObject *args, xson_reader_simple_t fn)
{
    PyObject *reader_obj;
    xson_reader_t *reader;
    xson_error_t err;
    if (!PyArg_ParseTuple (args, "O", &reader_obj)) {
        return NULL;
    }
    reader = PyCObject_AsVoidPtr (reader_obj);
    if (reader == NULL) {
        return NULL;
    }
    if (fn (reader, &err) != XSON_STATUS_OK) {
        PyErr_SetString (PyExc_TypeError, xson_error_message (&err));
        return NULL;
    }
    Py_INCREF (Py_None);
    return Py_None;
}

/**
 * Get the q-value of a given bin
 */
PyObject * get_q(PyObject *, PyObject *args) {
	PyObject *smear_obj;
	int bin;

	if (!PyArg_ParseTuple(args, "Oi", &smear_obj, &bin)) return NULL;

	// Set the array pointers
	void *temp = PyCObject_AsVoidPtr(smear_obj);
	BaseSmearer* s = static_cast<BaseSmearer *>(temp);

	if(s->get_nbins()<=0 || s->get_nbins()<=bin) {
		return NULL;
	}

	double q, q_min, q_max;
	if (s->get_bin_range(bin, &q, &q_min, &q_max)<0) {
		return NULL;
	}
	return Py_BuildValue("d", q);
}

static PyObject*
pydc_find(PyObject* self, PyObject* args)
{
  PyObject* pcobj;
  const char* symbol;
  void* libhandle;
  void* funcptr;

  if ( !PyArg_ParseTuple(args,"Os", &pcobj, &symbol) ) return PyErr_Format(PyExc_RuntimeError, "argument mismatch");
  
  libhandle = PyCObject_AsVoidPtr(pcobj);
  
  if (!libhandle) return PyErr_Format(PyExc_RuntimeError, "libhandle is null");

  funcptr = dlFindSymbol(libhandle, symbol);
  if (!funcptr) 
    return PyErr_Format(PyExc_RuntimeError, "symbol '%s' not found", symbol);

  return PyCObject_FromVoidPtr(funcptr, NULL);
}

static PyObject* TextParser_read(PyObject* self, PyObject* args)
{
    // 引数の解析
    const char* filename;
    PyObject*   handle;
    if(!PyArg_ParseTuple(args, "Os", &handle, &filename))
    {
        return NULL;
    }
    TextParser* tp = static_cast<TextParser*>(PyCObject_AsVoidPtr(handle));

    int         ret = tp->read(filename);
    if(ret != 0)
    {
        std::cerr<<"MetaData read failed!! ("<<filename<<")"<<std::endl;
    }

    //戻り値を設定
    return Py_BuildValue("i", ret);
}

PyObject* detect_and_extract(PyObject* p_descriptor_extractor, PyObject *p_img,
        PyObject *p_thresh, PyObject *p_octaves) {
    cv::Mat img = get_gray_img(p_img);
    std::vector<cv::KeyPoint> keypoints = detect(img, p_thresh, p_octaves);

    cv::Mat descriptors;
    brisk::BriskDescriptorExtractor* descriptor_extractor =
            static_cast<brisk::BriskDescriptorExtractor*>(PyCObject_AsVoidPtr(p_descriptor_extractor));
    descriptor_extractor->compute(img, keypoints, descriptors);

    NDArrayConverter cvt;
    PyObject* ret = PyList_New(2);
    PyObject* ret_keypoints = keypoints_ctopy(keypoints);
    PyList_SetItem(ret, 0, ret_keypoints);
    PyList_SetItem(ret, 1, cvt.toNDArray(descriptors));
    // TODO: decrement reference doesn't work
    // Py_DECREF(ret_keypoints);

    return ret;
}

static PyObject* TextParser_splitList(PyObject* self, PyObject* args)
{
    PyObject*   handle;
    const char* value;
    if(!PyArg_ParseTuple(args, "Os", &handle, &value))
    {
        return NULL;
    }
    TextParser*         tp = static_cast<TextParser*>(PyCObject_AsVoidPtr(handle));
    std::vector<double> list;
    TextParserSortOrder order = TP_SORT_NONE;
    int                 ret     = tp->splitList(value, list, order);
    PyObject*           py_list = PyList_New(list.size());
    int                 i       = 0;
    for(std::vector<double>::iterator it = list.begin(); it != list.end(); ++it)
    {
        PyList_SetItem(py_list, i++, Py_BuildValue("d", *it));
    }
    return Py_BuildValue("iO", ret, py_list);
}

PyObject * pyCitcom_ic_init_tracer_composition(PyObject *self, PyObject *args)
{
    PyObject *obj;
    struct All_variables* E;

    if (!PyArg_ParseTuple(args, "O:init_tracer_composition", &obj))
        return NULL;

    E = (struct All_variables*)(PyCObject_AsVoidPtr(obj));

    if (E->control.tracer==1) {
        initialize_tracers(E);

        if (E->composition.on)
            init_composition(E);
    }

    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject* TextParser_getLabels(PyObject* self, PyObject* args)
{
    PyObject* handle;
    int oswitch=0;
    if(!PyArg_ParseTuple(args, "O|i", &handle, &oswitch))
    {
        return NULL;
    }
    TextParser*              tp = static_cast<TextParser*>(PyCObject_AsVoidPtr(handle));

    std::vector<std::string> labels;
    int                      ret       = tp->getLabels(labels, oswitch);
    PyObject*                py_labels = PyList_New(labels.size());
    int                      i         = 0;
    for(std::vector<std::string>::iterator it = labels.begin(); it != labels.end(); ++it)
    {
        PyList_SetItem(py_labels, i++, Py_BuildValue("s", (*it).c_str()));
    }
    return Py_BuildValue("iO", ret, py_labels);
}

static PyObject* TextParser_expandRange(PyObject* self, PyObject* args)
{
    PyObject*   handle;
    const char* value;
    if(!PyArg_ParseTuple(args, "Os", &handle, &value))
    {
        return NULL;
    }
    TextParser*         tp = static_cast<TextParser*>(PyCObject_AsVoidPtr(handle));

    std::vector<double> expanded;
    int                 ret         = tp->expandRange(value, expanded);
    PyObject*           py_expanded = PyList_New(expanded.size());
    int                 i           = 0;
    for(std::vector<double>::iterator it = expanded.begin(); it != expanded.end(); ++it)
    {
        PyList_SetItem(py_expanded, i++, Py_BuildValue("d", *it));
    }
    return Py_BuildValue("iO", ret, py_expanded);
}

  int pythonTrace(PyObject* mobj, PyFrameObject *mframe, int mwhat, PyObject *marg) {
    // DBG("Python trace\n");
    IvrPython* pIvrPython = 0; //getIvrPythonPointer();
    if (mobj != NULL){
      if (PyCObject_Check(mobj)) {
	  pIvrPython = (IvrPython*)PyCObject_AsVoidPtr(mobj);
	  //	  Py_DECREF(mobj);
      }
    }

    if (pIvrPython) {
      AmEventQueue* evq = pIvrPython->getScriptEventQueue();
      if (evq)
	evq->processEvents();
    } else {
      ERROR("IvrPython pointer not found in Trace!\n");
      return 1;
    }
    return 0; 
  }

static PyObject *
pango_LayoutPath(PyObject *self, PyObject *args) {

	PycairoContext *context;
	cairo_t *ctx;
	void *LayoutObj;
	PangoLayout *layout;

	if (!PyArg_ParseTuple(args, "OO", &context, &LayoutObj)) {
		return NULL;
	}

	ctx = context->ctx;
	layout = PyCObject_AsVoidPtr(LayoutObj);

	pango_cairo_layout_path(ctx, layout);

	Py_INCREF(Py_None);
	return Py_None;
}

static PyObject *
im_GetImageBlob(PyObject *self, PyObject *args) {

	void *magick_pointer;
	MagickWand *magick_wand;
	unsigned char *blob;
	size_t length;
	PyObject *ret;

	if (!PyArg_ParseTuple(args, "O", &magick_pointer)){
		return Py_BuildValue("i", 0);
	}

	magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer);
	blob = MagickGetImagesBlob(magick_wand, &length);
	ret = Py_BuildValue("s#", blob, length);
	MagickRelinquishMemory(blob);

	return ret;
}

static PyObject *
image_save_footer(PyObject *self,PyObject *args)
{
    PyObject *pyimwriter;
    if(!PyArg_ParseTuple(args,"O",&pyimwriter))
    {
	return NULL;
    }

    ImageWriter *i = (ImageWriter *)PyCObject_AsVoidPtr(pyimwriter);

    if(!i || !i->save_footer())
    {
	PyErr_SetString(PyExc_IOError, "Couldn't save image footer");
	return NULL;
    }
    
    Py_INCREF(Py_None);
    return Py_None;
}