Context Navigation

source: issm/trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp@ 14221

Last change on this file since 14221 was 14221, checked in by Mathieu Morlighem, 12 years ago
CHG: index and segments are now integers
File size: 17.7 KB

Rev	Line
[12011]	1	/*\file FetchData.cpp:
	2	* \brief: general I/O interface to fetch data in python
	3	*/
	4
	5	#ifdef HAVE_CONFIG_H
	6	#include <config.h>
	7	#else
	8	#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
	9	#endif
	10
	11	#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
	12	#define NO_IMPORT
	13
[13749]	14	#include "./pythonio.h"
	15	#include "../../c/include/include.h"
	16	#include "../../c/shared/shared.h"
[12011]	17
[12073]	18	/Primitive data types/
[12365]	19	/FUNCTION FetchData(double pscalar,PyObject* py_float){{{*/
[12011]	20	void FetchData(double* pscalar,PyObject* py_float){
	21
[14093]	22	double dscalar;
[12011]	23
	24	/return internal value: /
[14097]	25	if (PyFloat_Check(py_float))
[14093]	26	dscalar=PyFloat_AsDouble(py_float);
[14097]	27	else if (PyInt_Check(py_float))
[14093]	28	dscalar=(double)PyInt_AsLong(py_float);
[14097]	29	else if (PyLong_Check(py_float))
[14093]	30	dscalar=PyLong_AsDouble(py_float);
[14097]	31	else if (PyBool_Check(py_float))
[14093]	32	dscalar=(double)PyLong_AsLong(py_float);
[14097]	33	else if (PyTuple_Check(py_float) && (int)PyTuple_Size(py_float)==1)
	34	FetchData(&dscalar,PyTuple_GetItem(py_float,(Py_ssize_t)0));
	35	else if (PyList_Check(py_float) && (int)PyList_Size(py_float)==1)
	36	FetchData(&dscalar,PyList_GetItem(py_float,(Py_ssize_t)0));
[14093]	37	else
	38	_error_("unrecognized float type in input!");
[12011]	39
	40	/output: /
[14093]	41	*pscalar=dscalar;
[12011]	42	}
	43	/}}}/
[14093]	44	/FUNCTION FetchData(int pscalar,PyObject* py_long){{{*/
	45	void FetchData(int* pscalar, PyObject* py_long){
[12011]	46
[14093]	47	int iscalar;
[12011]	48
	49	/return internal value: /
[14097]	50	if (PyInt_Check(py_long))
[14093]	51	iscalar=(int)PyInt_AsLong(py_long);
[14097]	52	else if (PyLong_Check(py_long))
[14093]	53	iscalar=(int)PyLong_AsLong(py_long);
[14097]	54	else if (PyFloat_Check(py_long))
[14093]	55	iscalar=(int)PyFloat_AsDouble(py_long);
[14097]	56	else if (PyBool_Check(py_long))
[14093]	57	iscalar=(int)PyLong_AsLong(py_long);
[14097]	58	else if (PyTuple_Check(py_long) && (int)PyTuple_Size(py_long)==1)
	59	FetchData(&iscalar,PyTuple_GetItem(py_long,(Py_ssize_t)0));
	60	else if (PyList_Check(py_long) && (int)PyList_Size(py_long)==1)
	61	FetchData(&iscalar,PyList_GetItem(py_long,(Py_ssize_t)0));
[14093]	62	else
	63	_error_("unrecognized long type in input!");
[12011]	64
	65	/output: /
[14093]	66	*pscalar=iscalar;
[12011]	67	}
	68	/}}}/
[14093]	69	/FUNCTION FetchData(bool pscalar,PyObject* py_boolean){{{*/
	70	void FetchData(bool* pscalar,PyObject* py_boolean){
[12011]	71
[14093]	72	bool bscalar;
[13622]	73
[14097]	74	/return internal value: /
	75	if (PyBool_Check(py_boolean))
	76	bscalar=(bool)PyLong_AsLong(py_boolean);
	77	else if (PyInt_Check(py_boolean))
	78	bscalar=(bool)PyInt_AsLong(py_boolean);
	79	else if (PyLong_Check(py_boolean))
	80	bscalar=(bool)PyLong_AsLong(py_boolean);
	81	else if (PyTuple_Check(py_boolean) && (int)PyTuple_Size(py_boolean)==1)
	82	FetchData(&bscalar,PyTuple_GetItem(py_boolean,(Py_ssize_t)0));
	83	else if (PyList_Check(py_boolean) && (int)PyList_Size(py_boolean)==1)
	84	FetchData(&bscalar,PyList_GetItem(py_boolean,(Py_ssize_t)0));
	85	else
	86	_error_("unrecognized boolean type in input!");
[12011]	87
[14097]	88	/output: /
[14093]	89	*pscalar=bscalar;
[12011]	90	}
	91	/}}}/
[12365]	92	/FUNCTION FetchData(double* pmatrix,int* pM, int* pN, PyObject* py_matrix){{{*/
[12112]	93	void FetchData(double** pmatrix,int* pM,int pN,PyObject py_matrix){
[12073]	94
[12112]	95	/output: /
[13372]	96	double* dmatrix=NULL;
[12112]	97	double* matrix=NULL;
	98	int M,N;
[13373]	99	int ndim;
[12112]	100	npy_intp* dims=NULL;
	101
[13990]	102	/intermediary:/
	103	long* lmatrix=NULL;
	104	bool* bmatrix=NULL;
	105	int i;
	106
[14093]	107	if (PyArray_Check((PyArrayObject*)py_matrix)) {
	108	/retrieve dimensions: /
	109	ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
[14098]	110	if (ndim==2) {
	111	dims=PyArray_DIMS((PyArrayObject*)py_matrix);
	112	M=dims[0]; N=dims[1];
	113	}
	114	else if (ndim==1) {
	115	dims=PyArray_DIMS((PyArrayObject*)py_matrix);
	116	M=dims[0]; N=1;
	117	}
	118	else
	119	_error_("expecting an MxN matrix or M vector in input!");
[13622]	120
[14093]	121	if (M && N) {
	122	if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
	123	/retrieve internal value: /
	124	dmatrix=(double)PyArray_DATA((PyArrayObject)py_matrix);
[12112]	125
[14093]	126	/copy matrix: /
	127	matrix=xNew<double>(M*N);
	128	memcpy(matrix,dmatrix,(MN)sizeof(double));
	129	}
[13990]	130
[14093]	131	else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_INT64) {
	132	/retrieve internal value: /
	133	lmatrix=(long)PyArray_DATA((PyArrayObject)py_matrix);
[13990]	134
[14093]	135	/transform into double matrix: /
	136	matrix=xNew<double>(M*N);
	137	for(i=0;i<M*N;i++)matrix[i]=(double)lmatrix[i];
	138	}
[13990]	139
[14093]	140	else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_BOOL) {
	141	/retrieve internal value: /
	142	bmatrix=(bool)PyArray_DATA((PyArrayObject)py_matrix);
[13990]	143
[14093]	144	/transform into double matrix: /
	145	matrix=xNew<double>(M*N);
	146	for(i=0;i<M*N;i++)matrix[i]=(double)bmatrix[i];
	147	}
	148
	149	else
[14098]	150	_error_("unrecognized float pyarray type in input!");
[13990]	151	}
	152	else
[14093]	153	matrix=NULL;
[13484]	154	}
[14093]	155
[14097]	156	else {
[14093]	157	M=1;
	158	N=1;
	159	matrix=xNew<double>(M*N);
	160	FetchData(&(matrix[0]),py_matrix);
	161	}
	162
[12112]	163	/output: /
	164	if(pM)*pM=M;
	165	if(pN)*pN=N;
	166	if(pmatrix)*pmatrix=matrix;
	167	}
	168	/}}}/
[12776]	169	/FUNCTION FetchData(int* pmatrix,int* pM, int* pN, PyObject* py_matrix){{{*/
	170	void FetchData(int** pmatrix,int* pM,int pN,PyObject py_matrix){
	171
	172	/output: /
	173	int* matrix=NULL;
	174	int M,N;
[13990]	175	int ndim;
	176	npy_intp* dims=NULL;
[12776]	177
	178	/intermediary:/
[13990]	179	double* dmatrix=NULL;
	180	long* lmatrix=NULL;
	181	bool* bmatrix=NULL;
[12776]	182	int i;
	183
[14093]	184	if (PyArray_Check((PyArrayObject*)py_matrix)) {
	185	/retrieve dimensions: /
	186	ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
[14098]	187	if (ndim==2) {
	188	dims=PyArray_DIMS((PyArrayObject*)py_matrix);
	189	M=dims[0]; N=dims[1];
	190	}
	191	else if (ndim==1) {
	192	dims=PyArray_DIMS((PyArrayObject*)py_matrix);
	193	M=dims[0]; N=1;
	194	}
	195	else
	196	_error_("expecting an MxN matrix or M vector in input!");
[13622]	197
[14093]	198	if (M && N) {
	199	if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
	200	/retrieve internal value: /
	201	dmatrix=(double)PyArray_DATA((PyArrayObject)py_matrix);
[12776]	202
[14093]	203	/transform into integer matrix: /
	204	matrix=xNew<int>(M*N);
	205	for(i=0;i<M*N;i++)matrix[i]=(int)dmatrix[i];
	206	}
[13990]	207
[14093]	208	else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_INT64) {
	209	/retrieve internal value: /
	210	lmatrix=(long)PyArray_DATA((PyArrayObject)py_matrix);
[13990]	211
[14093]	212	/transform into integer matrix: /
	213	matrix=xNew<int>(M*N);
	214	for(i=0;i<M*N;i++)matrix[i]=(int)lmatrix[i];
	215	}
[13990]	216
[14093]	217	else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_BOOL) {
	218	/retrieve internal value: /
	219	bmatrix=(bool)PyArray_DATA((PyArrayObject)py_matrix);
[13990]	220
[14093]	221	/transform into integer matrix: /
	222	matrix=xNew<int>(M*N);
	223	for(i=0;i<M*N;i++)matrix[i]=(int)bmatrix[i];
	224	}
	225
	226	else
[14098]	227	_error_("unrecognized long pyarray type in input!");
[13990]	228	}
	229	else
[14093]	230	matrix=NULL;
[13484]	231	}
[14093]	232
[14097]	233	else {
[14093]	234	M=1;
	235	N=1;
	236	matrix=xNew<int>(M*N);
	237	FetchData(&(matrix[0]),py_matrix);
	238	}
	239
[12776]	240	/output: /
	241	if(pM)*pM=M;
	242	if(pN)*pN=N;
	243	if(pmatrix)*pmatrix=matrix;
	244	}
	245	/}}}/
[12365]	246	/FUNCTION FetchData(double* pvector,int* pM, PyObject* py_vector){{{*/
[12120]	247	void FetchData(double** pvector,int* pM,PyObject* py_vector){
[12112]	248
[12120]	249	/output: /
[13372]	250	double* dvector=NULL;
[12120]	251	double* vector=NULL;
	252	int M;
[13373]	253	int ndim;
[12120]	254	npy_intp* dims=NULL;
	255
[13990]	256	/intermediary:/
	257	long* lvector=NULL;
	258	bool* bvector=NULL;
	259	int i;
	260
	261	/retrieve dimensions: /
[12120]	262	ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
[13056]	263	if(ndim!=1)_error_("expecting an Mx1 vector in input!");
[12120]	264	dims=PyArray_DIMS((PyArrayObject*)py_vector);
	265	M=dims[0];
[13622]	266
[13484]	267	if (M) {
[13990]	268	if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
	269	/retrieve internal value: /
	270	dvector=(double)PyArray_DATA((PyArrayObject)py_vector);
[12120]	271
[13990]	272	/copy vector: /
	273	vector=xNew<double>(M);
	274	memcpy(vector,dvector,(M)*sizeof(double));
	275	}
	276
	277	else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
	278	/retrieve internal value: /
	279	lvector=(long)PyArray_DATA((PyArrayObject)py_vector);
	280
	281	/transform into double vector: /
	282	vector=xNew<double>(M);
	283	for(i=0;i<M;i++)vector[i]=(double)lvector[i];
	284	}
	285
	286	else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
	287	/retrieve internal value: /
	288	bvector=(bool)PyArray_DATA((PyArrayObject)py_vector);
	289
	290	/transform into double vector: /
	291	vector=xNew<double>(M);
	292	for(i=0;i<M;i++)vector[i]=(double)bvector[i];
	293	}
	294
	295	else
	296	_error_("unrecognized vector type in input!");
[13484]	297	}
	298	else
	299	vector=NULL;
[13372]	300
[12120]	301	/output: /
	302	if(pM)*pM=M;
	303	if(pvector)*pvector=vector;
	304	}
	305	/}}}/
[14221]	306	/FUNCTION FetchData(int* pvector,int* pM, PyObject* py_vector){{{*/
	307	void FetchData(int** pvector,int* pM,PyObject* py_vector){
[13310]	308
[14221]	309	/output: /
	310	int* vector=NULL;
	311	int M;
	312	int ndim;
	313	npy_intp* dims=NULL;
	314
	315	/intermediary:/
	316	long* lvector=NULL;
	317	bool* bvector=NULL;
	318	double* dvector=NULL;
	319	int i;
	320
	321	/retrieve dimensions: /
	322	ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
	323	if(ndim!=1)_error_("expecting an Mx1 vector in input!");
	324	dims=PyArray_DIMS((PyArrayObject*)py_vector);
	325	M=dims[0];
	326
	327	if (M) {
	328	if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
	329	/retrieve internal value: /
	330	dvector=(double)PyArray_DATA((PyArrayObject)py_vector);
	331
	332	/transform into int vector: /
	333	vector=xNew<int>(M);
	334	for(i=0;i<M;i++)vector[i]=(int)lvector[i];
	335	}
	336
	337	else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
	338	/retrieve internal value: /
	339	lvector=(long)PyArray_DATA((PyArrayObject)py_vector);
	340
	341	/transform into int vector: /
	342	vector=xNew<int>(M);
	343	for(i=0;i<M;i++)vector[i]=(int)lvector[i];
	344	}
	345
	346	else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
	347	/retrieve internal value: /
	348	bvector=(bool)PyArray_DATA((PyArrayObject)py_vector);
	349
	350	/transform into int vector: /
	351	vector=xNew<int>(M);
	352	for(i=0;i<M;i++)vector[i]=(int)bvector[i];
	353	}
	354
	355	else
	356	_error_("unrecognized vector type in input!");
	357	}
	358	else
	359	vector=NULL;
	360
	361	/output: /
	362	if(pM)*pM=M;
	363	if(pvector)*pvector=vector;
	364	}
	365	/}}}/
	366
[13310]	367	/ISSM objects/
	368	/FUNCTION FetchData(BamgGeom* pbamggeom,PyObject* py_dict){{{*/
	369	void FetchData(BamgGeom** pbamggeom,PyObject* py_dict){
	370
	371	/Initialize output/
	372	BamgGeom* bamggeom=new BamgGeom();
	373
	374	/Fetch all fields/
	375	FetchData(&bamggeom->Vertices,&bamggeom->VerticesSize[0],&bamggeom->VerticesSize[1],PyDict_GetItemString(py_dict,"Vertices"));
	376	FetchData(&bamggeom->Edges, &bamggeom->EdgesSize[0], &bamggeom->EdgesSize[1], PyDict_GetItemString(py_dict,"Edges"));
	377	FetchData(&bamggeom->Corners, &bamggeom->CornersSize[0], &bamggeom->CornersSize[1], PyDict_GetItemString(py_dict,"Corners"));
	378	FetchData(&bamggeom->RequiredVertices,&bamggeom->RequiredVerticesSize[0],&bamggeom->RequiredVerticesSize[1],PyDict_GetItemString(py_dict,"RequiredVertices"));
	379	FetchData(&bamggeom->RequiredEdges, &bamggeom->RequiredEdgesSize[0], &bamggeom->RequiredEdgesSize[1], PyDict_GetItemString(py_dict,"RequiredEdges"));
	380	FetchData(&bamggeom->CrackedEdges,&bamggeom->CrackedEdgesSize[0],&bamggeom->CrackedEdgesSize[1],PyDict_GetItemString(py_dict,"CrackedEdges"));
	381	FetchData(&bamggeom->SubDomains,&bamggeom->SubDomainsSize[0],&bamggeom->SubDomainsSize[1],PyDict_GetItemString(py_dict,"SubDomains"));
	382
	383	/Assign output pointers:/
	384	*pbamggeom=bamggeom;
[13287]	385	}
	386	/}}}/
[13310]	387	/FUNCTION FetchData(BamgMesh* pbamgmesh,PyObject* py_dict){{{*/
	388	void FetchData(BamgMesh** pbamgmesh,PyObject* py_dict){
	389
	390	/Initialize output/
	391	BamgMesh* bamgmesh=new BamgMesh();
	392
	393	/Fetch all fields/
	394	FetchData(&bamgmesh->Vertices,&bamgmesh->VerticesSize[0],&bamgmesh->VerticesSize[1],PyDict_GetItemString(py_dict,"Vertices"));
	395	FetchData(&bamgmesh->Edges, &bamgmesh->EdgesSize[0], &bamgmesh->EdgesSize[1], PyDict_GetItemString(py_dict,"Edges"));
	396	FetchData(&bamgmesh->Triangles, &bamgmesh->TrianglesSize[0], &bamgmesh->TrianglesSize[1], PyDict_GetItemString(py_dict,"Triangles"));
	397	FetchData(&bamgmesh->CrackedEdges,&bamgmesh->CrackedEdgesSize[0],&bamgmesh->CrackedEdgesSize[1],PyDict_GetItemString(py_dict,"CrackedEdges"));
	398	FetchData(&bamgmesh->VerticesOnGeomEdge,&bamgmesh->VerticesOnGeomEdgeSize[0],&bamgmesh->VerticesOnGeomEdgeSize[1],PyDict_GetItemString(py_dict,"VerticesOnGeomEdge"));
	399	FetchData(&bamgmesh->VerticesOnGeomVertex,&bamgmesh->VerticesOnGeomVertexSize[0],&bamgmesh->VerticesOnGeomVertexSize[1],PyDict_GetItemString(py_dict,"VerticesOnGeomVertex"));
	400	FetchData(&bamgmesh->EdgesOnGeomEdge, &bamgmesh->EdgesOnGeomEdgeSize[0], &bamgmesh->EdgesOnGeomEdgeSize[1], PyDict_GetItemString(py_dict,"EdgesOnGeomEdge"));
	401	FetchData(&bamgmesh->IssmSegments,&bamgmesh->IssmSegmentsSize[0],&bamgmesh->IssmSegmentsSize[1],PyDict_GetItemString(py_dict,"IssmSegments"));
	402
	403	/Assign output pointers:/
	404	*pbamgmesh=bamgmesh;
[13287]	405	}
	406	/}}}/
[13310]	407	/FUNCTION FetchData(BamgOpts* pbamgopts,PyObject* py_dict){{{*/
	408	void FetchData(BamgOpts** pbamgopts,PyObject* py_dict){
	409
	410	/Initialize output/
	411	BamgOpts* bamgopts=new BamgOpts();
	412
	413	/Fetch all fields/
	414	FetchData(&bamgopts->anisomax,PyDict_GetItemString(py_dict,"anisomax"));
	415	FetchData(&bamgopts->cutoff,PyDict_GetItemString(py_dict,"cutoff"));
	416	FetchData(&bamgopts->coeff,PyDict_GetItemString(py_dict,"coeff"));
	417	FetchData(&bamgopts->errg,PyDict_GetItemString(py_dict,"errg"));
	418	FetchData(&bamgopts->gradation,PyDict_GetItemString(py_dict,"gradation"));
	419	FetchData(&bamgopts->Hessiantype,PyDict_GetItemString(py_dict,"Hessiantype"));
	420	FetchData(&bamgopts->MaxCornerAngle,PyDict_GetItemString(py_dict,"MaxCornerAngle"));
	421	FetchData(&bamgopts->maxnbv,PyDict_GetItemString(py_dict,"maxnbv"));
	422	FetchData(&bamgopts->maxsubdiv,PyDict_GetItemString(py_dict,"maxsubdiv"));
	423	FetchData(&bamgopts->Metrictype,PyDict_GetItemString(py_dict,"Metrictype"));
	424	FetchData(&bamgopts->nbjacobi,PyDict_GetItemString(py_dict,"nbjacobi"));
	425	FetchData(&bamgopts->nbsmooth,PyDict_GetItemString(py_dict,"nbsmooth"));
	426	FetchData(&bamgopts->omega,PyDict_GetItemString(py_dict,"omega"));
	427	FetchData(&bamgopts->power,PyDict_GetItemString(py_dict,"power"));
	428	FetchData(&bamgopts->verbose,PyDict_GetItemString(py_dict,"verbose"));
	429
	430	FetchData(&bamgopts->Crack,PyDict_GetItemString(py_dict,"Crack"));
	431	FetchData(&bamgopts->geometricalmetric,PyDict_GetItemString(py_dict,"geometricalmetric"));
	432	FetchData(&bamgopts->KeepVertices,PyDict_GetItemString(py_dict,"KeepVertices"));
	433	FetchData(&bamgopts->splitcorners,PyDict_GetItemString(py_dict,"splitcorners"));
	434
	435	FetchData(&bamgopts->hmin,PyDict_GetItemString(py_dict,"hmin"));
	436	FetchData(&bamgopts->hmax,PyDict_GetItemString(py_dict,"hmax"));
	437	FetchData(&bamgopts->hminVertices,&bamgopts->hminVerticesSize[0],&bamgopts->hminVerticesSize[1],PyDict_GetItemString(py_dict,"hminVertices"));
	438	FetchData(&bamgopts->hmaxVertices,&bamgopts->hmaxVerticesSize[0],&bamgopts->hmaxVerticesSize[1],PyDict_GetItemString(py_dict,"hmaxVertices"));
	439	FetchData(&bamgopts->hVertices,&bamgopts->hVerticesSize[0],&bamgopts->hVerticesSize[1],PyDict_GetItemString(py_dict,"hVertices"));
	440	FetchData(&bamgopts->metric,&bamgopts->metricSize[0],&bamgopts->metricSize[1],PyDict_GetItemString(py_dict,"metric"));
	441	FetchData(&bamgopts->field,&bamgopts->fieldSize[0],&bamgopts->fieldSize[1],PyDict_GetItemString(py_dict,"field"));
	442	FetchData(&bamgopts->err,&bamgopts->errSize[0],&bamgopts->errSize[1],PyDict_GetItemString(py_dict,"err"));
	443
	444	/Additional checks/
	445	bamgopts->Check();
	446
	447	/Assign output pointers:/
	448	*pbamgopts=bamgopts;
[13287]	449	}
	450	/}}}/
[13374]	451	/FUNCTION FetchData(Options* poptions,int istart, int nrhs,PyObject* py_tuple){{{*/
[13373]	452	void FetchData(Options** poptions,int istart, int nrhs,PyObject* py_tuple){
[12120]	453
[13373]	454	char *name = NULL;
	455	Option *option = NULL;
	456
[12776]	457	/Initialize output/
	458	Options* options=new Options();
	459
[13373]	460	/Fetch all options/
	461	for (int i=istart; i<nrhs; i=i+2){
	462	if (!PyString_Check(PyTuple_GetItem(py_tuple,(Py_ssize_t)i))) _error_("Argument " << i+1 << " must be name of option");
[12776]	463
[13373]	464	FetchData(&name,PyTuple_GetItem(py_tuple,(Py_ssize_t)i));
	465	if(i+1 == nrhs) _error_("Argument " << i+2 << " must exist and be value of option \"" << name << "\".");
	466
[13374]	467	_pprintLine_("FetchData for Options not implemented yet, ignoring option \"" << name << "\"!");
[13373]	468
	469	// option=(Option*)OptionParse(name,&PyTuple_GetItem(py_tuple,(Py_ssize_t)(i+1)));
	470	// options->AddOption(option);
	471	// option=NULL;
	472	}
	473
[12776]	474	/Assign output pointers:/
	475	*poptions=options;
	476	}
	477	/}}}/
[13368]	478	/FUNCTION FetchData(DataSet* pcontours,PyObject* py_list){{{*/
	479	void FetchData(DataSet** pcontours,PyObject* py_list){
[12776]	480
[13368]	481	int numcontours,test1,test2;
	482	char *contourname = NULL;
	483	DataSet *contours = NULL;
	484	Contour<double> *contouri = NULL;
	485	PyObject *py_dicti = NULL;
	486	PyObject *py_item = NULL;
	487
	488	if (PyString_Check(py_list)){
	489	FetchData(&contourname,py_list);
	490	contours=DomainOutlineRead<double>(contourname);
	491	}
	492	else if(PyList_Check(py_list)){
	493
	494	contours=new DataSet(0);
	495	numcontours=(int)PyList_Size(py_list);
	496
	497	for(int i=0;i<numcontours;i++){
	498
	499	contouri=xNew<Contour<double> >(1);
	500	py_dicti=PyList_GetItem(py_list,(Py_ssize_t)i);
	501
	502	py_item = PyDict_GetItemString(py_dicti,"nods");
	503	if(!py_item) _error_("input structure does not have a 'nods' field");
	504	FetchData(&contouri->nods,py_item);
	505
	506	py_item = PyDict_GetItemString(py_dicti,"x");
	507	if(!py_item) _error_("input structure does not have a 'x' field");
	508	FetchData(&contouri->x,&test1,&test2,py_item);
	509	if(test1!=contouri->nods \|\| test2!=1) _error_("field x should be of size ["<<contouri->nods<<" 1]");
	510
	511	py_item = PyDict_GetItemString(py_dicti,"y");
	512	if(!py_item) _error_("input structure does not have a 'y' field");
	513	FetchData(&contouri->y,&test1,&test2,py_item);
	514	if(test1!=contouri->nods \|\| test2!=1) _error_("field y should be of size ["<<contouri->nods<<" 1]");
	515
	516	contours->AddObject(contouri);
	517	}
	518	}
	519	else{
	520	_error_("Contour is neither a string nor a structure and cannot be loaded");
	521	}
	522
	523	/clean-up and assign output pointer/
[13372]	524	xDelete<char>(contourname);
[13368]	525	*pcontours=contours;
[13353]	526	}
	527	/}}}/
	528
[12073]	529	/Python version dependent: /
	530	#if _PYTHON_MAJOR_ >= 3
[12365]	531	/FUNCTION FetchData(char* pstring,PyObject* py_unicode){{{*/
[12073]	532	void FetchData(char** pstring,PyObject* py_unicode){
	533
	534	PyObject* py_bytes;
	535	char* string=NULL;
	536
	537	/convert to bytes format: /
	538	PyUnicode_FSConverter(py_unicode,&py_bytes);
	539
	540	/convert from bytes to string: /
	541	string=PyBytes_AS_STRING(py_bytes);
[13622]	542
[12073]	543	*pstring=string;
	544	}
	545	/}}}/
	546	#else
[12365]	547	/FUNCTION FetchData(char* pstring,PyObject* py_string){{{*/
[12073]	548	void FetchData(char** pstring,PyObject* py_string){
	549
	550	char* string=NULL;
	551
	552	/extract internal string: /
	553	string=PyString_AsString(py_string);
[13372]	554
	555	/copy string (note strlen does not include trailing NULL): /
	556	*pstring=xNew<char>(strlen(string)+1);
	557	memcpy(pstring,string,(strlen(string)+1)sizeof(char));
[12073]	558	}
	559	/}}}/
	560	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: