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;
}
PyObject* Context_Python_Step( PyObject* self, PyObject* args ) {
PyObject* pyContext;
Context* context;
double dt;
/* Obtain arguements */
if( !PyArg_ParseTuple( args, "Od:", &pyContext, &dt ) ) {
return NULL;
}
context = (Context*)( PyCObject_AsVoidPtr( pyContext ) );
/* Run function */
context->currentTime += dt;
AbstractContext_Step( context, dt );
context->timeStep++;
/* Return */
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *
pf_init(PyObject *self, PyObject *args)
{
PyObject *pyobj, *pyarray, *py_posparams;
double period_tolerance;
struct s_param *params;
struct pfHandle *pfh;
double pos_params[N_PARAMS];
if(!PyArg_ParseTuple(
args,"OdOO",&pyobj,&period_tolerance,&py_posparams, &pyarray))
{
return NULL;
}
if(!PyCObject_Check(pyobj))
{
PyErr_SetString(PyExc_ValueError,"Not a valid handle");
return NULL;
}
pfh = (struct pfHandle *)PyCObject_AsVoidPtr(pyobj);
if(!parse_posparams(py_posparams, pos_params))
{
return NULL;
}
int len=0;
params = parse_params(pyarray,&len);
if(!params)
{
return NULL;
}
/*finally all args are assembled */
pfh->pfo->vtbl->init(pfh->pfo,period_tolerance,pos_params,params,len);
free(params);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
im_WriteImage(PyObject *self, PyObject *args) {
void *magick_pointer;
MagickWand *magick_wand;
char *filepath = NULL;
MagickBooleanType status;
if (!PyArg_ParseTuple(args, "Os", &magick_pointer, &filepath)){
return Py_BuildValue("i", 0);
}
magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer);
status = MagickWriteImages(magick_wand, filepath, MagickTrue);
if (status == MagickFalse){
return Py_BuildValue("i", 0);
}
return Py_BuildValue("i", 1);
}
static PyObject* pysplicing_gff_noiso(PyObject *self, PyObject *args) {
PyObject *gff;
splicing_gff_t *mygff;
splicing_vector_int_t noiso;
PyObject *rnoiso;
if (!PyArg_ParseTuple(args, "O", &gff)) { return NULL; }
mygff=PyCObject_AsVoidPtr(gff);
SPLICING_PYCHECK(splicing_vector_int_init(&noiso, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &noiso);
SPLICING_PYCHECK(splicing_gff_noiso(mygff, &noiso));
rnoiso = pysplicing_from_vector_int(&noiso);
splicing_vector_int_destroy(&noiso);
SPLICING_FINALLY_CLEAN(1);
return Py_BuildValue("O", rnoiso);
}
static PyObject *
im_NextImage(PyObject *self, PyObject *args) {
void *magick_pointer;
MagickWand *magick_wand;
MagickBooleanType status;
if (!PyArg_ParseTuple(args, "O", &magick_pointer)){
Py_INCREF(Py_None);
return Py_None;
}
magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer);
status = MagickNextImage(magick_wand);
if (status == MagickFalse){
return Py_BuildValue("i", 0);
}
return Py_BuildValue("i", 1);
}
static PyObject *
im_SetImageFormat(PyObject *self, PyObject *args) {
void *magick_pointer;
MagickWand *magick_wand;
char *format = NULL;
MagickBooleanType status;
if (!PyArg_ParseTuple(args, "Os", &magick_pointer, &format)){
return Py_BuildValue("i", 0);
}
magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer);
status = MagickSetImageFormat(magick_wand, format);
if (status == MagickFalse){
return Py_BuildValue("i", 0);
}
return Py_BuildValue("i", 1);
}
PyObject* Dictionary_Python_LoadFromFile( PyObject* self, PyObject* args ) {
PyObject* pyDictionary;
Dictionary* dictionary;
XML_IO_Handler* ioHandler;
char* filename;
/* Obtain arguements */
if( !PyArg_ParseTuple( args, "Os:", &pyDictionary, &filename ) ) {
return NULL;
}
dictionary = (Dictionary*)( PyCObject_AsVoidPtr( pyDictionary ) );
/* Run function */
ioHandler = XML_IO_Handler_New();
IO_Handler_ReadAllFromFile( ioHandler, filename, dictionary );
Stg_Class_Delete( ioHandler );
/* Return */
Py_INCREF( Py_None );
return Py_None;
}
PyObject* Dictionary_Python_AddStringToList( PyObject* self, PyObject* args ) {
PyObject* pyDictionary;
Dictionary* dictionary;
char* name;
char* value;
Dictionary_Entry_Value* list;
/* Obtain arguements */
if( !PyArg_ParseTuple( args, "Oss:", &pyDictionary, &name, &value ) ) {
return NULL;
}
dictionary = (Dictionary*)( PyCObject_AsVoidPtr( pyDictionary ) );
/* Run function */
list = Dictionary_Get( dictionary, name );
Dictionary_Entry_Value_AddElement( list, Dictionary_Entry_Value_FromString( value ) );
/* Return */
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *
calcmd_CalCmdGetConciseDateTimeRange(PyObject *self, PyObject *args)
{
CalCmdCommand *cmd;
PyObject *cmdObj;
char buf[128];
if (!PyArg_ParseTuple(args, "O", &cmdObj)) {
return NULL;
}
if (cmdObj == Py_None) {
PyErr_SetString(PyExc_ValueError, "calcmd object is None");
return NULL;
}
cmd = PyCObject_AsVoidPtr(cmdObj);
CalCmdPrintConciseDateTimeRange(cmd, buf, sizeof(buf));
return Py_BuildValue("s", buf);
}
static PyObject *
calcmd_CalCmdGetType(PyObject *self, PyObject *args)
{
CalCmdCommand *cmd;
PyObject *cmdObj;
int type;
if (!PyArg_ParseTuple(args, "O", &cmdObj)) {
return NULL;
}
if (cmdObj == Py_None) {
PyErr_SetString(PyExc_ValueError, "calcmd object is None");
return NULL;
}
cmd = PyCObject_AsVoidPtr(cmdObj);
type = CalCmdGetType(cmd);
return Py_BuildValue("i", type);
}
static PyObject *py_parse_options(PyObject *dummy, PyObject *args) {
IO_INFO *io;
PyObject *pyio;
char *opts;
// retrieve args
if(!PyArg_ParseTuple(args, "Os", &pyio, &opts)) {
return NULL;
}
io=(IO_INFO *)PyCObject_AsVoidPtr(pyio);
TRY {
io_parse_options(io,opts);
} EXCEPT(E_ANY) {
return PyErr_Format(map_exceptions_for_python(__EXCEPT__), "%s", except_str);
};
Py_INCREF(Py_None);
return Py_None;
};
static PyObject *
_xson_reader_float (PyObject *self, PyObject *args)
{
PyObject *reader_obj;
xson_reader_t *reader;
xson_error_t err;
double value;
if (!PyArg_ParseTuple (args, "O", &reader_obj)) {
return NULL;
}
reader = PyCObject_AsVoidPtr (reader_obj);
if (reader == NULL) {
return NULL;
}
if (xson_reader_float (reader, &value, &err) != XSON_STATUS_OK) {
PyErr_SetString (PyExc_TypeError, xson_error_message (&err));
return NULL;
}
return PyFloat_FromDouble(value);
}
PyObject*
size(PyObject *self, PyObject *args)
{
/**
* Convert input
*/
PyObject *m = NULL;
if (!PyArg_ParseTuple(args, "O", &m))
return NULL;
/**
* Call the function
*/
clann_matrix_type *a = (clann_matrix_type *) PyCObject_AsVoidPtr(m);
/**
* Convert output
*/
return Py_BuildValue("II", a->rows, a->cols);
}
static PyObject * bluefish_curdoc_replace(PyObject *self, PyObject *args) {
int ok;
PyObject *PyBfwin;
Tbfwin *bfwin;
long start,end;
const char *string;
ok = PyArg_ParseTuple(args, "lls", &start, &end, &string);
if (ok) {
PyBfwin = GetObjectFromBluefishModule("bfwin");
if (!PyBfwin) {
DEBUG_MSG("bluefish_curdoc_replace, noPyBfwin !!\n");
return NULL;
}
bfwin = PyCObject_AsVoidPtr(PyBfwin);
DEBUG_MSG("bluefish_curdoc_replace, bfwin=%p\n",bfwin);
if (bfwin->current_document) {
doc_replace_text(bfwin->current_document,string,start,end);
}
}
return Py_BuildValue("");
}
static PyObject *
image_clear(PyObject *self, PyObject *args)
{
PyObject *pyim;
if(!PyArg_ParseTuple(args,"O",&pyim))
{
return NULL;
}
IImage *i = (IImage *)PyCObject_AsVoidPtr(pyim);
if(NULL == i)
{
return NULL;
}
i->clear();
Py_INCREF(Py_None);
return Py_None;
}
