12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
20 #ifndef SWIGTEMPLATEDISAMBIGUATOR
21 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22 # define SWIGTEMPLATEDISAMBIGUATOR template
23 # elif defined(__HP_aCC)
26 # define SWIGTEMPLATEDISAMBIGUATOR template
28 # define SWIGTEMPLATEDISAMBIGUATOR
34 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35 # define SWIGINLINE inline
43 # if defined(__GNUC__)
44 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45 # define SWIGUNUSED __attribute__ ((__unused__))
50 # define SWIGUNUSED __attribute__ ((__unused__))
56 #ifndef SWIG_MSC_UNSUPPRESS_4505
57 # if defined(_MSC_VER)
58 # pragma warning(disable : 4505)
62 #ifndef SWIGUNUSEDPARM
64 # define SWIGUNUSEDPARM(p)
66 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
72 # define SWIGINTERN static SWIGUNUSED
76 #ifndef SWIGINTERNINLINE
77 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
81 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
82 # ifndef GCC_HASCLASSVISIBILITY
83 # define GCC_HASCLASSVISIBILITY
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # if defined(STATIC_LINKED)
92 # define SWIGEXPORT __declspec(dllexport)
95 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
96 # define SWIGEXPORT __attribute__ ((visibility("default")))
105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
106 # define SWIGSTDCALL __stdcall
113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
114 # define _CRT_SECURE_NO_DEPRECATE
118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
119 # define _SCL_SECURE_NO_DEPRECATE
124 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
142 #define SWIG_RUNTIME_VERSION "4"
145 #ifdef SWIG_TYPE_TABLE
146 # define SWIG_QUOTE_STRING(x) #x
147 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
148 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
150 # define SWIG_TYPE_TABLE_NAME
163 # define SWIGRUNTIME SWIGINTERN
166 #ifndef SWIGRUNTIMEINLINE
167 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
171 #ifndef SWIG_BUFFER_SIZE
172 # define SWIG_BUFFER_SIZE 1024
176 #define SWIG_POINTER_DISOWN 0x1
177 #define SWIG_CAST_NEW_MEMORY 0x2
180 #define SWIG_POINTER_OWN 0x1
263 #define SWIG_ERROR (-1)
264 #define SWIG_IsOK(r) (r >= 0)
265 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
268 #define SWIG_CASTRANKLIMIT (1 << 8)
270 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
272 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
274 #define SWIG_BADOBJ (SWIG_ERROR)
275 #define SWIG_OLDOBJ (SWIG_OK)
276 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
277 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
279 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
280 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
281 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
282 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
283 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
284 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
287 #if defined(SWIG_CASTRANK_MODE)
288 # ifndef SWIG_TypeRank
289 # define SWIG_TypeRank unsigned long
291 # ifndef SWIG_MAXCASTRANK
292 # define SWIG_MAXCASTRANK (2)
294 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
295 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
300 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
303 # define SWIG_AddCast(r) (r)
304 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
314 typedef void *(*swig_converter_func)(
void *,
int *);
356 const char *f2,
const char *l2) {
357 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
358 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
359 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
360 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
362 return (
int)((l1 - f1) - (l2 - f2));
372 const char* te = tb + strlen(tb);
374 while (equiv != 0 && *ne) {
375 for (nb = ne; *ne; ++ne) {
376 if (*ne ==
'|')
break;
401 if (strcmp(iter->
type->
name, c) == 0) {
402 if (iter == ty->
cast)
428 if (iter->
type == from) {
429 if (iter == ty->
cast)
461 if (!ty || !ty->
dcast)
return ty;
462 while (ty && (ty->
dcast)) {
463 ty = (*ty->
dcast)(ptr);
487 if (!type)
return NULL;
488 if (type->
str != NULL) {
489 const char *last_name = type->
str;
491 for (s = type->
str; *s; s++)
492 if (*s ==
'|') last_name = s+1;
539 register size_t l = 0;
540 register size_t r = iter->
size - 1;
543 register size_t i = (l + r) >> 1;
544 const char *iname = iter->
types[i]->
name;
546 register int compare = strcmp(name, iname);
548 return iter->
types[i];
549 }
else if (compare < 0) {
555 }
else if (compare > 0) {
564 }
while (iter != end);
590 register size_t i = 0;
591 for (; i < iter->
size; ++i) {
593 return iter->
types[i];
596 }
while (iter != end);
608 static const char hex[17] =
"0123456789abcdef";
609 register const unsigned char *u = (
unsigned char *) ptr;
610 register const unsigned char *eu = u + sz;
611 for (; u != eu; ++u) {
612 register unsigned char uu = *u;
613 *(c++) = hex[(uu & 0xf0) >> 4];
614 *(c++) = hex[uu & 0xf];
624 register unsigned char *u = (
unsigned char *) ptr;
625 register const unsigned char *eu = u + sz;
626 for (; u != eu; ++u) {
627 register char d = *(c++);
628 register unsigned char uu;
629 if ((d >=
'0') && (d <=
'9'))
630 uu = ((d -
'0') << 4);
631 else if ((d >=
'a') && (d <=
'f'))
632 uu = ((d - (
'a'-10)) << 4);
636 if ((d >=
'0') && (d <=
'9'))
638 else if ((d >=
'a') && (d <=
'f'))
639 uu |= (d - (
'a'-10));
653 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
656 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
664 if (strcmp(c,
"NULL") == 0) {
677 size_t lname = (name ? strlen(name) : 0);
678 if ((2*sz + 2 + lname) > bsz)
return 0;
682 strncpy(r,name,lname+1);
692 if (strcmp(c,
"NULL") == 0) {
707 #define SWIG_UnknownError -1
708 #define SWIG_IOError -2
709 #define SWIG_RuntimeError -3
710 #define SWIG_IndexError -4
711 #define SWIG_TypeError -5
712 #define SWIG_DivisionByZero -6
713 #define SWIG_OverflowError -7
714 #define SWIG_SyntaxError -8
715 #define SWIG_ValueError -9
716 #define SWIG_SystemError -10
717 #define SWIG_AttributeError -11
718 #define SWIG_MemoryError -12
719 #define SWIG_NullReferenceError -13
724 #if PY_VERSION_HEX >= 0x03000000
726 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
727 #define PyInt_Check(x) PyLong_Check(x)
728 #define PyInt_AsLong(x) PyLong_AsLong(x)
729 #define PyInt_FromLong(x) PyLong_FromLong(x)
730 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
731 #define PyString_Check(name) PyBytes_Check(name)
732 #define PyString_FromString(x) PyUnicode_FromString(x)
733 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
734 #define PyString_AsString(str) PyBytes_AsString(str)
735 #define PyString_Size(str) PyBytes_Size(str)
736 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
737 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
738 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
739 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
744 # define Py_TYPE(op) ((op)->ob_type)
749 #if PY_VERSION_HEX >= 0x03000000
750 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
752 # define SWIG_Python_str_FromFormat PyString_FromFormat
762 #if PY_VERSION_HEX >= 0x03000000
766 str = PyUnicode_AsUTF8String(str);
767 PyBytes_AsStringAndSize(str, &cstr, &len);
768 newstr = (
char *) malloc(len+1);
769 memcpy(newstr, cstr, len+1);
773 return PyString_AsString(str);
777 #if PY_VERSION_HEX >= 0x03000000
778 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
780 # define SWIG_Python_str_DelForPy3(x)
787 #if PY_VERSION_HEX >= 0x03000000
788 return PyUnicode_FromString(c);
790 return PyString_FromString(c);
795 #if PY_VERSION_HEX < 0x02020000
796 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
797 # define PyOS_snprintf _snprintf
799 # define PyOS_snprintf snprintf
804 #if PY_VERSION_HEX < 0x02020000
806 #ifndef SWIG_PYBUFFER_SIZE
807 # define SWIG_PYBUFFER_SIZE 1024
816 res = vsnprintf(buf,
sizeof(buf), fmt, ap);
818 return (res < 0 || res >= (
int)
sizeof(buf)) ? 0 : PyString_FromString(buf);
823 #if PY_VERSION_HEX < 0x01060000
824 # define PyObject_Del(op) PyMem_DEL((op))
827 # define PyObject_DEL PyObject_Del
831 #if PY_VERSION_HEX < 0x02020000
832 # ifndef PyExc_StopIteration
833 # define PyExc_StopIteration PyExc_RuntimeError
835 # ifndef PyObject_GenericGetAttr
836 # define PyObject_GenericGetAttr 0
841 #if PY_VERSION_HEX < 0x02010000
842 # ifndef Py_NotImplemented
843 # define Py_NotImplemented PyExc_RuntimeError
848 #if PY_VERSION_HEX < 0x02010000
849 # ifndef PyString_AsStringAndSize
850 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
855 #if PY_VERSION_HEX < 0x02000000
856 # ifndef PySequence_Size
857 # define PySequence_Size PySequence_Length
862 #if PY_VERSION_HEX < 0x02030000
866 PyObject *result = ok ? Py_True : Py_False;
875 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
877 # define PY_SSIZE_T_MAX INT_MAX
878 # define PY_SSIZE_T_MIN INT_MIN
891 PyObject *i = PyNumber_Int(x);
893 result = PyInt_AsLong(i);
900 #if PY_VERSION_HEX < 0x02050000
901 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
904 #if PY_VERSION_HEX < 0x02040000
905 #define Py_VISIT(op) \
908 int vret = visit((op), arg); \
915 #if PY_VERSION_HEX < 0x02030000
926 #if PY_VERSION_HEX < 0x02030000
930 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
931 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
932 (PY_MAJOR_VERSION > 3))
933 # define SWIGPY_USE_CAPSULE
934 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
937 #if PY_VERSION_HEX < 0x03020000
938 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
939 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
951 type = PyExc_MemoryError;
954 type = PyExc_IOError;
957 type = PyExc_RuntimeError;
960 type = PyExc_IndexError;
963 type = PyExc_TypeError;
966 type = PyExc_ZeroDivisionError;
969 type = PyExc_OverflowError;
972 type = PyExc_SyntaxError;
975 type = PyExc_ValueError;
978 type = PyExc_SystemError;
981 type = PyExc_AttributeError;
984 type = PyExc_RuntimeError;
995 PyObject *traceback = 0;
997 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1000 PyObject *old_str = PyObject_Str(value);
1009 PyErr_SetString(PyExc_RuntimeError, mesg);
1013 #if defined(SWIG_PYTHON_NO_THREADS)
1014 # if defined(SWIG_PYTHON_THREADS)
1015 # undef SWIG_PYTHON_THREADS
1018 #if defined(SWIG_PYTHON_THREADS)
1019 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1020 # if (PY_VERSION_HEX >= 0x02030000)
1021 # define SWIG_PYTHON_USE_GIL
1024 # if defined(SWIG_PYTHON_USE_GIL)
1025 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1026 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1029 class SWIG_Python_Thread_Block {
1031 PyGILState_STATE state;
1033 void end() {
if (status) { PyGILState_Release(state); status =
false;} }
1034 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1035 ~SWIG_Python_Thread_Block() { end(); }
1037 class SWIG_Python_Thread_Allow {
1039 PyThreadState *save;
1041 void end() {
if (status) { PyEval_RestoreThread(save); status =
false; }}
1042 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1043 ~SWIG_Python_Thread_Allow() { end(); }
1045 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1046 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1047 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1048 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1050 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1051 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1052 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1053 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1056 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1057 # define SWIG_PYTHON_INITIALIZE_THREADS
1059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1060 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1062 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1063 # define SWIG_PYTHON_THREAD_END_BLOCK
1065 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1066 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1068 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1069 # define SWIG_PYTHON_THREAD_END_ALLOW
1073 # define SWIG_PYTHON_INITIALIZE_THREADS
1074 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1075 # define SWIG_PYTHON_THREAD_END_BLOCK
1076 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1077 # define SWIG_PYTHON_THREAD_END_ALLOW
1093 #define SWIG_PY_POINTER 4
1094 #define SWIG_PY_BINARY 5
1111 #if PY_VERSION_HEX >= 0x03000000
1114 return PyInstanceMethod_New(func);
1140 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1141 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1142 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1144 #ifdef SWIGPYTHON_BUILTIN
1145 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1147 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1150 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1152 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1153 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1154 #define swig_owntype int
1157 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1158 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1161 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1162 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1165 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1166 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1169 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1170 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1175 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1176 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1177 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1179 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1180 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1181 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1182 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1183 #define SWIG_fail goto fail
1193 PyErr_SetObject(errtype, obj);
1201 PyErr_SetString(errtype, msg);
1205 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1209 #if defined(SWIGPYTHON_BUILTIN)
1212 SwigPyBuiltin_AddPublicSymbol(PyObject *seq,
const char *key) {
1213 PyObject *s = PyString_InternFromString(key);
1214 PyList_Append(seq, s);
1220 #if PY_VERSION_HEX < 0x02030000
1221 PyDict_SetItemString(d, (
char *)name, obj);
1223 PyDict_SetItemString(d, name, obj);
1226 if (public_interface)
1227 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1234 #if PY_VERSION_HEX < 0x02030000
1235 PyDict_SetItemString(d, (
char *)name, obj);
1237 PyDict_SetItemString(d, name, obj);
1248 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1251 }
else if (result == Py_None) {
1255 if (!PyList_Check(result)) {
1256 PyObject *o2 = result;
1257 result = PyList_New(1);
1258 PyList_SetItem(result, 0, o2);
1260 PyList_Append(result,obj);
1269 }
else if (result == Py_None) {
1273 if (!PyTuple_Check(result)) {
1275 result = PyTuple_New(1);
1276 PyTuple_SET_ITEM(result, 0, o2);
1278 o3 = PyTuple_New(1);
1279 PyTuple_SET_ITEM(o3, 0, obj);
1281 result = PySequence_Concat(o2, o3);
1298 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got none",
1299 name, (min == max ?
"" :
"at least "), (
int)min);
1303 if (!PyTuple_Check(args)) {
1304 if (min <= 1 && max >= 1) {
1307 for (i = 1; i <
max; ++i) {
1312 PyErr_SetString(PyExc_SystemError,
"UnpackTuple() argument list is not a tuple");
1315 register Py_ssize_t l = PyTuple_GET_SIZE(args);
1317 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1318 name, (min == max ?
"" :
"at least "), (
int)min, (
int)l);
1320 }
else if (l > max) {
1321 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1322 name, (min == max ?
"" :
"at most "), (
int)max, (
int)l);
1326 for (i = 0; i < l; ++i) {
1327 objs[i] = PyTuple_GET_ITEM(args, i);
1329 for (; l <
max; ++l) {
1338 #if PY_VERSION_HEX >= 0x02020000
1339 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1341 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1349 #define SWIG_STATIC_POINTER(var) var
1351 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1359 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1360 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1362 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1364 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1365 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1372 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1373 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1374 # ifndef SWIG_PYTHON_BUILD_NONE
1375 # define SWIG_PYTHON_BUILD_NONE
1380 #ifdef SWIG_PYTHON_BUILD_NONE
1383 # define Py_None SWIG_Py_None()
1388 PyObject *none = Py_BuildValue((
char*)
"");
1405 PyObject *none = Py_None;
1432 PyObject *klass = data ? data->
klass : 0;
1433 return (klass ? klass : PyExc_RuntimeError);
1446 Py_INCREF(data->
klass);
1448 if (PyClass_Check(obj)) {
1453 #if (PY_VERSION_HEX < 0x02020000)
1456 data->
newraw = PyObject_GetAttrString(data->
klass, (
char *)
"__new__");
1460 data->
newargs = PyTuple_New(1);
1461 PyTuple_SetItem(data->
newargs, 0, obj);
1468 data->
destroy = PyObject_GetAttrString(data->
klass, (
char *)
"__swig_destroy__");
1469 if (PyErr_Occurred()) {
1476 flags = PyCFunction_GET_FLAGS(data->
destroy);
1478 data->
delargs = !(flags & (METH_O));
1493 Py_XDECREF(data->
newraw);
1506 #ifdef SWIGPYTHON_BUILTIN
1514 return PyLong_FromVoidPtr(v->
ptr);
1520 PyObject *res = NULL;
1521 PyObject *args = PyTuple_New(1);
1526 #if PY_VERSION_HEX >= 0x03000000
1527 res = PyUnicode_Format(ofmt,args);
1529 res = PyString_Format(ofmt,args);
1566 # if PY_VERSION_HEX >= 0x03000000
1567 PyObject *joined = PyUnicode_Concat(repr, nrep);
1572 PyString_ConcatAndDel(&repr,nrep);
1583 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1591 if( op != Py_EQ && op != Py_NE ) {
1602 #ifdef SWIGPYTHON_BUILTIN
1607 assert(SwigPyObject_stype);
1623 #ifdef SWIGPYTHON_BUILTIN
1625 if (PyType_IsSubtype(op->ob_type, target_tp))
1627 return (strcmp(op->ob_type->tp_name,
"SwigPyObject") == 0);
1630 || (strcmp(
Py_TYPE(op)->tp_name,
"SwigPyObject") == 0);
1641 PyObject *next = sobj->
next;
1655 PyCFunction meth = PyCFunction_GET_FUNCTION(
destroy);
1656 PyObject *mself = PyCFunction_GET_SELF(
destroy);
1657 res = ((*meth)(mself, v));
1661 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1664 printf(
"swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name :
"unknown"));
1678 if (!PyArg_ParseTuple(next,(
char *)
"O:append", &tmp))
return NULL;
1698 Py_INCREF(sobj->
next);
1733 #if (PY_VERSION_HEX < 0x02020000)
1734 if (!PyArg_ParseTuple(args,(
char *)
"|O:own",&val))
1735 #elif (PY_VERSION_HEX < 0x02050000)
1736 if (!PyArg_UnpackTuple(args, (
char *)
"own", 0, 1, &val))
1738 if (!PyArg_UnpackTuple(args,
"own", 0, 1, &val))
1749 if (PyObject_IsTrue(val)) {
1755 if (PyObject_IsTrue(val)) {
1769 {(
char *)
"disown", (PyCFunction)
SwigPyObject_disown, METH_NOARGS, (
char *)
"releases ownership of the pointer"},
1770 {(
char *)
"acquire", (PyCFunction)
SwigPyObject_acquire, METH_NOARGS, (
char *)
"acquires ownership of the pointer"},
1771 {(
char *)
"own", (PyCFunction)
SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1772 {(
char *)
"append", (PyCFunction)
SwigPyObject_append, METH_O, (
char *)
"appends another 'this' object"},
1773 {(
char *)
"next", (PyCFunction)
SwigPyObject_next, METH_NOARGS, (
char *)
"returns the next 'this' object"},
1774 {(
char *)
"__repr__",(PyCFunction)
SwigPyObject_repr, METH_NOARGS, (
char *)
"returns object representation"},
1779 swigobject_methods[] = {
1780 {(
char *)
"disown", (PyCFunction)
SwigPyObject_disown, METH_VARARGS, (
char *)
"releases ownership of the pointer"},
1781 {(
char *)
"acquire", (PyCFunction)
SwigPyObject_acquire, METH_VARARGS, (
char *)
"aquires ownership of the pointer"},
1782 {(
char *)
"own", (PyCFunction)
SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1783 {(
char *)
"append", (PyCFunction)
SwigPyObject_append, METH_VARARGS, (
char *)
"appends another 'this' object"},
1784 {(
char *)
"next", (PyCFunction)
SwigPyObject_next, METH_VARARGS, (
char *)
"returns the next 'this' object"},
1785 {(
char *)
"__repr__",(PyCFunction)
SwigPyObject_repr, METH_VARARGS, (
char *)
"returns object representation"},
1790 #if PY_VERSION_HEX < 0x02020000
1794 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1800 static char swigobject_doc[] =
"Swig object carries a C/C++ instance pointer";
1802 static PyNumberMethods SwigPyObject_as_number = {
1807 #
if PY_VERSION_HEX < 0x03000000
1823 #
if PY_VERSION_HEX < 0x03000000
1827 #if PY_VERSION_HEX < 0x03000000
1833 #if PY_VERSION_HEX < 0x03000000
1837 #if PY_VERSION_HEX >= 0x03000000
1838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1839 #elif PY_VERSION_HEX >= 0x02050000
1840 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1841 #elif PY_VERSION_HEX >= 0x02020000
1842 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1843 #elif PY_VERSION_HEX >= 0x02000000
1844 0,0,0,0,0,0,0,0,0,0,0
1848 static PyTypeObject swigpyobject_type;
1849 static int type_init = 0;
1851 const PyTypeObject tmp = {
1853 #if PY_VERSION_HEX >= 0x03000000
1854 PyVarObject_HEAD_INIT(NULL, 0)
1856 PyObject_HEAD_INIT(NULL)
1859 (
char *)
"SwigPyObject",
1864 #
if PY_VERSION_HEX < 0x02020000
1870 #if PY_VERSION_HEX >= 0x03000000
1876 &SwigPyObject_as_number,
1891 #
if PY_VERSION_HEX >= 0x02020000
1913 #
if PY_VERSION_HEX >= 0x02030000
1916 #
if PY_VERSION_HEX >= 0x02060000
1923 swigpyobject_type = tmp;
1925 #if PY_VERSION_HEX < 0x02020000
1926 swigpyobject_type.ob_type = &PyType_Type;
1928 if (PyType_Ready(&swigpyobject_type) < 0)
1932 return &swigpyobject_type;
1945 return (PyObject *)sobj;
1963 fputs(
"<Swig Packed ", fp);
2000 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2001 return s ? s : strncmp((
char *)v->
pack, (
char *)w->
pack, 2*v->
size);
2015 || (strcmp((op)->ob_type->tp_name,
"SwigPyPacked") == 0);
2030 static char swigpacked_doc[] =
"Swig object carries a C/C++ instance pointer";
2031 static PyTypeObject swigpypacked_type;
2032 static int type_init = 0;
2034 const PyTypeObject tmp = {
2036 #if PY_VERSION_HEX>=0x03000000
2037 PyVarObject_HEAD_INIT(NULL, 0)
2039 PyObject_HEAD_INIT(NULL)
2042 (
char *)
"SwigPyPacked",
2049 #if PY_VERSION_HEX>=0x03000000
2070 #
if PY_VERSION_HEX >= 0x02020000
2092 #
if PY_VERSION_HEX >= 0x02030000
2095 #
if PY_VERSION_HEX >= 0x02060000
2102 swigpypacked_type = tmp;
2104 #if PY_VERSION_HEX < 0x02020000
2105 swigpypacked_type.ob_type = &PyType_Type;
2107 if (PyType_Ready(&swigpypacked_type) < 0)
2111 return &swigpypacked_type;
2119 void *pack = malloc(size);
2121 memcpy(pack, ptr, size);
2130 return (PyObject *) sobj;
2138 if (sobj->
size != size)
return 0;
2139 memcpy(ptr, sobj->
pack, size);
2161 if (swig_this == NULL)
2169 #if PY_VERSION_HEX>=0x03000000
2170 #define SWIG_PYTHON_SLOW_GETSET_THIS
2181 #ifdef SWIGPYTHON_BUILTIN
2183 # ifdef PyWeakref_CheckProxy
2184 if (PyWeakref_CheckProxy(pyobj)) {
2185 pyobj = PyWeakref_GET_OBJECT(pyobj);
2195 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2196 if (PyInstance_Check(pyobj)) {
2197 obj = _PyInstance_Lookup(pyobj,
SWIG_This());
2199 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2200 if (dictptr != NULL) {
2201 PyObject *dict = *dictptr;
2202 obj = dict ? PyDict_GetItem(dict,
SWIG_This()) : 0;
2204 #ifdef PyWeakref_CheckProxy
2205 if (PyWeakref_CheckProxy(pyobj)) {
2206 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2210 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2214 if (PyErr_Occurred()) PyErr_Clear();
2220 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2224 if (PyErr_Occurred()) PyErr_Clear();
2244 int oldown = sobj->
own;
2262 if (obj == Py_None && !implicit_conv) {
2274 void *vptr = sobj->
ptr;
2279 if (ptr) *ptr = vptr;
2299 if (ptr) *ptr = vptr;
2305 *own = *own | sobj->
own;
2311 if (implicit_conv) {
2314 PyObject *klass = data->
klass;
2320 if (PyErr_Occurred()) {
2346 if (!
SWIG_IsOK(res) && obj == Py_None) {
2349 if (PyErr_Occurred())
2361 if (!PyCFunction_Check(obj)) {
2367 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2368 const char *desc = doc ? strstr(doc,
"swig_ptr: ") : 0;
2417 #if (PY_VERSION_HEX >= 0x02020000)
2419 PyObject *newraw = data->
newraw;
2421 inst = PyObject_Call(newraw, data->
newargs, NULL);
2423 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2424 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2425 if (dictptr != NULL) {
2426 PyObject *dict = *dictptr;
2428 dict = PyDict_New();
2430 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2435 PyObject_SetAttr(inst, key, swig_this);
2439 #if PY_VERSION_HEX >= 0x03000000
2440 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->
newargs, Py_None, Py_None);
2442 PyObject_SetAttr(inst,
SWIG_This(), swig_this);
2443 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2446 PyObject *dict = PyDict_New();
2448 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2449 inst = PyInstance_NewRaw(data->
newargs, dict);
2456 #if (PY_VERSION_HEX >= 0x02010000)
2458 PyObject *dict = PyDict_New();
2460 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2461 inst = PyInstance_NewRaw(data->
newargs, dict);
2464 return (PyObject *) inst;
2466 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2470 inst->in_class = (PyClassObject *)data->
newargs;
2471 Py_INCREF(inst->in_class);
2472 inst->in_dict = PyDict_New();
2473 if (inst->in_dict == NULL) {
2477 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2478 inst->in_weakreflist = NULL;
2480 #ifdef Py_TPFLAGS_GC
2481 PyObject_GC_Init(inst);
2483 PyDict_SetItem(inst->in_dict,
SWIG_This(), swig_this);
2484 return (PyObject *) inst;
2493 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2494 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2495 if (dictptr != NULL) {
2498 dict = PyDict_New();
2501 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2505 dict = PyObject_GetAttrString(inst, (
char*)
"__dict__");
2506 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2540 if (clientdata && clientdata->
pytype) {
2545 PyObject *next_self = clientdata->
pytype->tp_alloc(clientdata->
pytype, 0);
2546 while (newobj->
next)
2548 newobj->
next = next_self;
2559 #ifdef SWIGPYTHON_BUILTIN
2562 return (PyObject*) newobj;
2589 #ifdef SWIG_LINK_RUNTIME
2590 void *SWIG_ReturnGlobalTypeList(
void *);
2595 static void *type_pointer = (
void *)0;
2597 if (!type_pointer) {
2598 #ifdef SWIG_LINK_RUNTIME
2599 type_pointer = SWIG_ReturnGlobalTypeList((
void *)0);
2601 # ifdef SWIGPY_USE_CAPSULE
2602 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2607 if (PyErr_Occurred()) {
2609 type_pointer = (
void *)0;
2616 #if PY_MAJOR_VERSION < 2
2623 if (!PyModule_Check(m)) {
2624 PyErr_SetString(PyExc_TypeError,
2625 "PyModule_AddObject() needs module as first arg");
2629 PyErr_SetString(PyExc_TypeError,
2630 "PyModule_AddObject() needs non-NULL value");
2634 dict = PyModule_GetDict(m);
2637 PyErr_Format(PyExc_SystemError,
"module '%s' has no __dict__",
2638 PyModule_GetName(m));
2641 if (PyDict_SetItemString(dict, name, o))
2649 #ifdef SWIGPY_USE_CAPSULE
2655 #ifdef SWIGPY_USE_CAPSULE
2662 for (i =0; i < swig_module->
size; ++i) {
2675 #if PY_VERSION_HEX >= 0x03000000
2679 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };
2680 PyObject *module = Py_InitModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2682 #ifdef SWIGPY_USE_CAPSULE
2684 if (pointer && module) {
2687 Py_XDECREF(pointer);
2691 if (pointer && module) {
2694 Py_XDECREF(pointer);
2711 PyObject *obj = PyDict_GetItem(cache, key);
2714 #ifdef SWIGPY_USE_CAPSULE
2723 #ifdef SWIGPY_USE_CAPSULE
2724 obj = PyCapsule_New((
void*) descriptor, NULL, NULL);
2726 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2728 PyDict_SetItem(cache, key, obj);
2739 #define SWIG_POINTER_EXCEPTION 0
2740 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2741 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2746 if (PyErr_Occurred()) {
2748 PyObject *
value = 0;
2749 PyObject *traceback = 0;
2750 PyErr_Fetch(&type, &value, &traceback);
2753 PyObject *old_str = PyObject_Str(value);
2773 if (PyErr_Occurred()) {
2776 PyOS_snprintf(mesg,
sizeof(mesg),
"argument number %d:", argnum);
2788 return ty ? ty->
str :
"";
2795 #if defined(SWIG_COBJECT_TYPES)
2799 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, 'SwigPyObject(%s)' is received",
2806 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2808 PyObject *str = PyObject_Str(obj);
2811 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s(%s)' is received",
2815 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s' is received",
2822 PyErr_Format(PyExc_TypeError,
"a '%s' is expected", type);
2824 PyErr_Format(PyExc_TypeError,
"unexpected type is received");
2835 #if SWIG_POINTER_EXCEPTION
2845 #ifdef SWIGPYTHON_BUILTIN
2847 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *
value) {
2848 PyTypeObject *tp = obj->ob_type;
2850 PyObject *encoded_name;
2854 # ifdef Py_USING_UNICODE
2855 if (PyString_Check(name)) {
2856 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2859 }
else if (!PyUnicode_Check(name))
2861 if (!PyString_Check(name))
2864 PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2871 if (PyType_Ready(tp) < 0)
2875 descr = _PyType_Lookup(tp, name);
2878 f = descr->ob_type->tp_descr_set;
2880 if (PyString_Check(name)) {
2881 encoded_name =
name;
2884 encoded_name = PyUnicode_AsUTF8String(name);
2886 PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2887 Py_DECREF(encoded_name);
2889 res = f(descr, obj, value);
2905 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2907 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2913 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2914 #define SWIGTYPE_p_PLcGrid swig_types[1]
2915 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2916 #define SWIGTYPE_p_char swig_types[3]
2917 #define SWIGTYPE_p_double swig_types[4]
2918 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2919 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2920 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2921 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2922 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2923 #define SWIGTYPE_p_int swig_types[10]
2924 #define SWIGTYPE_p_p_char swig_types[11]
2925 #define SWIGTYPE_p_p_double swig_types[12]
2926 #define SWIGTYPE_p_unsigned_int swig_types[13]
2929 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2930 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2934 #if (PY_VERSION_HEX <= 0x02000000)
2935 # if !defined(SWIG_PYTHON_CLASSIC)
2936 # error "This python version requires swig to be run with the '-classic' option"
2943 #if PY_VERSION_HEX >= 0x03000000
2944 # define SWIG_init PyInit__plplotc
2947 # define SWIG_init init_plplotc
2950 #define SWIG_name "_plplotc"
2952 #define SWIGVERSION 0x020011
2953 #define SWIG_VERSION SWIGVERSION
2956 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2957 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2960 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2961 #include <arrayobject.h>
2965 #define NPY_PLINT NPY_INT32
2968 #define NPY_PLFLT NPY_DOUBLE
2970 #define NPY_PLFLT NPY_FLOAT
2974 #if !defined ( PySequence_Fast_GET_ITEM )
2975 #define PySequence_Fast_GET_ITEM PySequence_GetItem
2977 #define PySequence_Size PySequence_Length
2988 if (PyFloat_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2991 }
else if (PyInt_Check(obj)) {
2992 if (val) *val = PyInt_AsLong(obj);
2994 }
else if (PyLong_Check(obj)) {
2995 double v = PyLong_AsDouble(obj);
2996 if (!PyErr_Occurred()) {
3003 #ifdef SWIG_PYTHON_CAST_MODE
3006 double d = PyFloat_AsDouble(obj);
3007 if (!PyErr_Occurred()) {
3014 long v = PyLong_AsLong(obj);
3015 if (!PyErr_Occurred()) {
3028 #define SWIG_From_double PyFloat_FromDouble
3043 return PyInt_FromLong((
long) value);
3048 #if !defined(SWIG_NO_LLONG_MAX)
3049 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3050 # define LLONG_MAX __LONG_LONG_MAX__
3051 # define LLONG_MIN (-LLONG_MAX - 1LL)
3052 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3066 if ((min <= x && x <= max)) {
3067 double fx = floor(x);
3068 double cx = ceil(x);
3069 double rd = ((x - fx) < 0.5) ? fx : cx;
3070 if ((errno == EDOM) || (errno == ERANGE)) {
3073 double summ, reps, diff;
3076 }
else if (rd > x) {
3083 if (reps < 8*DBL_EPSILON) {
3096 if (PyInt_Check(obj)) {
3097 if (val) *val = PyInt_AsLong(obj);
3099 }
else if (PyLong_Check(obj)) {
3100 long v = PyLong_AsLong(obj);
3101 if (!PyErr_Occurred()) {
3108 #ifdef SWIG_PYTHON_CAST_MODE
3111 long v = PyInt_AsLong(obj);
3112 if (!PyErr_Occurred()) {
3122 if (val) *val = (long)(d);
3138 if ((v < INT_MIN || v > INT_MAX)) {
3141 if (val) *val = (int)(v);
3151 #if PY_VERSION_HEX < 0x03000000
3152 if (PyInt_Check(obj)) {
3153 long v = PyInt_AsLong(obj);
3162 if (PyLong_Check(obj)) {
3163 unsigned long v = PyLong_AsUnsignedLong(obj);
3164 if (!PyErr_Occurred()) {
3169 #if PY_VERSION_HEX >= 0x03000000
3171 long v = PyLong_AsLong(obj);
3172 if (!PyErr_Occurred()) {
3183 #ifdef SWIG_PYTHON_CAST_MODE
3186 unsigned long v = PyLong_AsUnsignedLong(obj);
3187 if (!PyErr_Occurred()) {
3197 if (val) *val = (
unsigned long)(d);
3213 if ((v > UINT_MAX)) {
3216 if (val) *val = (
unsigned int)(v);
3233 static int init = 0;
3246 #if PY_VERSION_HEX>=0x03000000
3247 if (PyUnicode_Check(obj))
3249 if (PyString_Check(obj))
3253 #if PY_VERSION_HEX>=0x03000000
3254 if (!alloc && cptr) {
3261 obj = PyUnicode_AsUTF8String(obj);
3262 PyBytes_AsStringAndSize(obj, &cstr, &len);
3278 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3284 *cptr = (
char *)memcpy((
char *)malloc((len + 1)*
sizeof(
char)), cstr,
sizeof(char)*(len + 1));
3292 #if PY_VERSION_HEX>=0x03000000
3298 if (psize) *psize = len + 1;
3299 #if PY_VERSION_HEX>=0x03000000
3305 if (pchar_descriptor) {
3308 if (cptr) *cptr = (
char *) vptr;
3309 if (psize) *psize = vptr ? (strlen((
char *)vptr) + 1) : 0;
3322 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3325 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3326 if (csize <= size) {
3328 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3329 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3347 if (size > INT_MAX) {
3349 return pchar_descriptor ?
3352 #if PY_VERSION_HEX >= 0x03000000
3353 return PyUnicode_FromStringAndSize(carray, (
int)(size));
3355 return PyString_FromStringAndSize(carray, (
int)(size));
3367 #define t_output_helper SWIG_Python_AppendOutput
3378 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379 if (val) *val = (char)(v);
3395 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in,
NPY_PLINT,
3400 if ( PyArray_Check( in ) )
3403 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in,
NPY_PLINT );
3410 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3413 PyObject *resultobj = 0;
3416 PLFLT *arg3 = (PLFLT *) 0 ;
3417 PLFLT *arg4 = (PLFLT *) 0 ;
3427 PyObject * obj0 = 0 ;
3428 PyObject * obj1 = 0 ;
3435 if (!PyArg_ParseTuple(args,(
char *)
"OO:pltr0",&obj0,&obj1))
SWIG_fail;
3440 arg1 = (
PLFLT)(val1);
3445 arg2 = (
PLFLT)(val2);
3446 pltr0(arg1,arg2,arg3,arg4,arg5);
3476 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3483 if ( pltr_xg == 0 || pltr_yg == 0 )
3485 PyErr_SetString( PyExc_ValueError,
"Expected a sequence to two 1D arrays." );
3488 tmpGrid1.
nx = PyArray_DIMS( pltr_xg )[0];
3489 tmpGrid1.
ny = PyArray_DIMS( pltr_yg )[0];
3492 if ( Xlen != tmpGrid1.
nx ||
Ylen != tmpGrid1.
ny )
3494 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3500 if ( Xlen != tmpGrid1.
nx - 1 ||
Ylen != tmpGrid1.
ny - 1 )
3502 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3506 tmpGrid1.
xg = (PLFLT *) PyArray_DATA( pltr_xg );
3507 tmpGrid1.
yg = (PLFLT *) PyArray_DATA( pltr_yg );
3514 Py_DECREF( pltr_xg );
3515 Py_DECREF( pltr_yg );
3524 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3531 if ( pltr_xg == 0 || pltr_yg == 0 )
3533 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two 2D arrays." );
3536 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3537 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3539 PyErr_SetString( PyExc_ValueError,
"Arrays must be same size." );
3542 tmpGrid2.
nx = PyArray_DIMS( pltr_xg )[0];
3543 tmpGrid2.
ny = PyArray_DIMS( pltr_xg )[1];
3546 if ( Xlen != tmpGrid2.
nx ||
Ylen != tmpGrid2.
ny )
3548 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3554 if ( Xlen != tmpGrid2.
nx - 1 ||
Ylen != tmpGrid2.
ny - 1 )
3556 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3560 size =
sizeof (
PLFLT ) * tmpGrid2.
ny;
3561 tmpGrid2.
xg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * tmpGrid2.
nx );
3562 for ( i = 0; i < tmpGrid2.
nx; i++ )
3563 tmpGrid2.
xg[i] = (PLFLT *) ( PyArray_DATA( pltr_xg ) + i * size );
3564 tmpGrid2.
yg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * tmpGrid2.
nx );
3565 for ( i = 0; i < tmpGrid2.
nx; i++ )
3566 tmpGrid2.
yg[i] = (PLFLT *) ( PyArray_DATA( pltr_yg ) + i * size );
3573 free( tmpGrid2.
xg );
3574 free( tmpGrid2.
yg );
3575 Py_DECREF( pltr_xg );
3576 Py_DECREF( pltr_yg );
3580 PyObject *resultobj = 0;
3583 PLFLT *arg3 = (PLFLT *) 0 ;
3584 PLFLT *arg4 = (PLFLT *) 0 ;
3594 PyObject * obj0 = 0 ;
3595 PyObject * obj1 = 0 ;
3596 PyObject * obj2 = 0 ;
3600 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr1",&obj0,&obj1,&obj2))
SWIG_fail;
3605 arg1 = (
PLFLT)(val1);
3610 arg2 = (
PLFLT)(val2);
3616 pltr1(arg1,arg2,arg3,arg4,arg5);
3643 PyObject *resultobj = 0;
3646 PLFLT *arg3 = (PLFLT *) 0 ;
3647 PLFLT *arg4 = (PLFLT *) 0 ;
3657 PyObject * obj0 = 0 ;
3658 PyObject * obj1 = 0 ;
3659 PyObject * obj2 = 0 ;
3663 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr2",&obj0,&obj1,&obj2))
SWIG_fail;
3668 arg1 = (
PLFLT)(val1);
3673 arg2 = (
PLFLT)(val2);
3679 pltr2(arg1,arg2,arg3,arg4,arg5);
3708 static PyInterpreterState *save_interp = NULL;
3718 #define MY_BLOCK_THREADS { \
3719 PyThreadState *prev_state, *new_state; \
3722 PyEval_AcquireLock(); \
3723 new_state = PyThreadState_New( save_interp ); \
3724 prev_state = PyThreadState_Swap( new_state );
3725 #define MY_UNBLOCK_THREADS \
3726 new_state = PyThreadState_Swap( prev_state ); \
3727 PyThreadState_Clear( new_state ); \
3728 PyEval_ReleaseLock(); \
3729 PyThreadState_Delete( new_state ); \
3732 #define MY_BLOCK_THREADS
3733 #define MY_UNBLOCK_THREADS
3740 PyObject *pdata, *arglist, *result;
3744 pdata = (PyObject *) data;
3751 Py_XINCREF( pdata );
3756 arglist = Py_BuildValue(
"(ddO)", x, y, pdata );
3758 arglist = Py_BuildValue(
"(ffO)", x, y, pdata );
3760 if ( arglist == NULL )
3762 fprintf( stderr,
"Py_BuildValue failed to make argument list.\n" );
3767 result = PyEval_CallObject( python_pltr, arglist );
3769 Py_XDECREF( arglist );
3771 if ( result == NULL )
3773 fprintf( stderr,
"call to python pltr function with 3 arguments failed\n" );
3774 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must take 3 argments." );
3780 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3782 fprintf( stderr,
"pltr callback must return a 2 element array or sequence\n" );
3783 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must return a 2-sequence." );
3788 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3795 Py_XDECREF( result );
3803 PyObject *pdata, *arglist, *result;
3804 PLFLT fresult = 0.0;
3807 pdata = (PyObject *) data;
3808 if ( python_f2eval )
3810 Py_XINCREF( pdata );
3814 arglist = Py_BuildValue(
"(iiO)", x, y, pdata );
3816 result = PyEval_CallObject( python_f2eval, arglist );
3818 Py_DECREF( arglist );
3820 if ( !PyFloat_Check( result ) )
3822 fprintf( stderr,
"f2eval callback must return a float\n" );
3823 PyErr_SetString( PyExc_RuntimeError,
"f2eval callback must return a float." );
3828 fresult = (
PLFLT) PyFloat_AsDouble( result );
3831 Py_XDECREF( result );
3840 PyObject *pdata, *arglist, *result;
3842 PLFLT fresult = 0.0;
3846 pdata = (PyObject *) data;
3851 Py_XINCREF( pdata );
3856 arglist = Py_BuildValue(
"(ldO)", axis, value, pdata );
3858 arglist = Py_BuildValue(
"(lfO)", axis, value, pdata );
3861 result = PyEval_CallObject( python_label, arglist );
3865 if ( result == NULL )
3867 fprintf( stderr,
"label callback failed with 3 arguments\n" );
3868 PyErr_SetString( PyExc_RuntimeError,
"label callback must take 3 arguments." );
3870 else if ( !PyString_Check( result ) )
3872 fprintf( stderr,
"label callback must return a string\n" );
3873 PyErr_SetString( PyExc_RuntimeError,
"label callback must return a string." );
3878 pystring = PyString_AsString( result );
3879 strncpy(
string, pystring, len );
3882 Py_XDECREF( result );
3890 PyObject *px, *py, *pdata, *arglist, *result;
3895 pdata = (PyObject *) data;
3902 Py_XINCREF( pdata );
3906 px = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) xt );
3907 py = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) yt );
3908 arglist = Py_BuildValue(
"(ddOOO)", x, y, px, py, pdata );
3910 result = PyEval_CallObject( python_ct, arglist );
3912 Py_DECREF( arglist );
3917 if ( result == NULL )
3919 fprintf( stderr,
"call to python coordinate transform function with 5 arguments failed\n" );
3920 PyErr_SetString( PyExc_RuntimeError,
"coordinate transform callback must take 5 arguments." );
3923 Py_XDECREF( result );
3931 PyObject *px, *py, *arglist, *result;
3938 if ( python_mapform )
3942 #ifdef PL_HAVE_PTHREAD
3943 px = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) x );
3944 py = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) y );
3946 px = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (
char *) x );
3947 py = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (
char *) y );
3949 arglist = Py_BuildValue(
"(iOO)", n, px, py );
3951 result = PyEval_CallObject( python_mapform, arglist );
3953 Py_DECREF( arglist );
3957 if ( result == NULL )
3959 fprintf( stderr,
"call to python mapform function with 3 arguments failed\n" );
3960 PyErr_SetString( PyExc_RuntimeError,
"mapform callback must take 3 arguments." );
3963 Py_XDECREF( result );
3973 PyObject * rep = PyObject_Repr( input );
3976 char* str = PyString_AsString( rep );
3977 if ( strcmp( str,
"<built-in function pltr0>" ) == 0 )
3983 else if ( strcmp( str,
"<built-in function pltr1>" ) == 0 )
3989 else if ( strcmp( str,
"<built-in function pltr2>" ) == 0 )
3997 python_pltr = input;
3999 Py_XINCREF( input );
4005 python_pltr = input;
4007 Py_XINCREF( input );
4014 Py_XDECREF( python_pltr );
4023 Py_XINCREF( input );
4029 Py_XDECREF( python_ct );
4037 python_mapform = input;
4038 Py_XINCREF( input );
4044 Py_XDECREF( python_mapform );
4056 if ( input != Py_None )
4060 if ( input != Py_None )
4064 Py_XINCREF( input );
4068 fprintf( stderr,
"pltr_type is invalid\n" );
4086 Py_XDECREF( python_pltr );
4089 fprintf( stderr,
"pltr_type is invalid\n" );
4098 PyObject *resultobj = 0;
4105 PyObject * obj0 = 0 ;
4106 PyObject * obj1 = 0 ;
4108 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_type_set",&obj0,&obj1))
SWIG_fail;
4119 if (arg1) (arg1)->type = arg2;
4128 PyObject *resultobj = 0;
4132 PyObject * obj0 = 0 ;
4135 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_type_get",&obj0))
SWIG_fail;
4141 result = (int) ((arg1)->type);
4150 PyObject *resultobj = 0;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4160 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_state_set",&obj0,&obj1))
SWIG_fail;
4170 arg2 = (
unsigned int)(val2);
4171 if (arg1) (arg1)->state = arg2;
4180 PyObject *resultobj = 0;
4184 PyObject * obj0 = 0 ;
4185 unsigned int result;
4187 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_state_get",&obj0))
SWIG_fail;
4193 result = (
unsigned int) ((arg1)->state);
4202 PyObject *resultobj = 0;
4209 PyObject * obj0 = 0 ;
4210 PyObject * obj1 = 0 ;
4212 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_keysym_set",&obj0,&obj1))
SWIG_fail;
4222 arg2 = (
unsigned int)(val2);
4223 if (arg1) (arg1)->keysym = arg2;
4232 PyObject *resultobj = 0;
4236 PyObject * obj0 = 0 ;
4237 unsigned int result;
4239 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_keysym_get",&obj0))
SWIG_fail;
4245 result = (
unsigned int) ((arg1)->keysym);
4254 PyObject *resultobj = 0;
4261 PyObject * obj0 = 0 ;
4262 PyObject * obj1 = 0 ;
4264 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_button_set",&obj0,&obj1))
SWIG_fail;
4274 arg2 = (
unsigned int)(val2);
4275 if (arg1) (arg1)->button = arg2;
4284 PyObject *resultobj = 0;
4288 PyObject * obj0 = 0 ;
4289 unsigned int result;
4291 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_button_get",&obj0))
SWIG_fail;
4297 result = (
unsigned int) ((arg1)->button);
4306 PyObject *resultobj = 0;
4313 PyObject * obj0 = 0 ;
4314 PyObject * obj1 = 0 ;
4316 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1))
SWIG_fail;
4326 arg2 = (
PLINT)(val2);
4327 if (arg1) (arg1)->subwindow = arg2;
4336 PyObject *resultobj = 0;
4340 PyObject * obj0 = 0 ;
4343 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_subwindow_get",&obj0))
SWIG_fail;
4349 result = (
PLINT) ((arg1)->subwindow);
4358 PyObject *resultobj = 0;
4365 PyObject * obj0 = 0 ;
4366 PyObject * obj1 = 0 ;
4368 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_string_set",&obj0,&obj1))
SWIG_fail;
4378 arg2 = (
char *)(temp2);
4379 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
4380 else memset(arg1->
string,0,16*
sizeof(
char));
4389 PyObject *resultobj = 0;
4393 PyObject * obj0 = 0 ;
4396 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_string_get",&obj0))
SWIG_fail;
4402 result = (
char *)(
char *) ((arg1)->
string);
4406 while (size && (result[size - 1] ==
'\0')) --size;
4417 PyObject *resultobj = 0;
4424 PyObject * obj0 = 0 ;
4425 PyObject * obj1 = 0 ;
4427 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pX_set",&obj0,&obj1))
SWIG_fail;
4438 if (arg1) (arg1)->pX = arg2;
4447 PyObject *resultobj = 0;
4451 PyObject * obj0 = 0 ;
4454 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pX_get",&obj0))
SWIG_fail;
4460 result = (int) ((arg1)->pX);
4469 PyObject *resultobj = 0;
4476 PyObject * obj0 = 0 ;
4477 PyObject * obj1 = 0 ;
4479 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pY_set",&obj0,&obj1))
SWIG_fail;
4490 if (arg1) (arg1)->pY = arg2;
4499 PyObject *resultobj = 0;
4503 PyObject * obj0 = 0 ;
4506 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pY_get",&obj0))
SWIG_fail;
4512 result = (int) ((arg1)->pY);
4521 PyObject *resultobj = 0;
4528 PyObject * obj0 = 0 ;
4529 PyObject * obj1 = 0 ;
4531 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dX_set",&obj0,&obj1))
SWIG_fail;
4541 arg2 = (
PLFLT)(val2);
4542 if (arg1) (arg1)->dX = arg2;
4551 PyObject *resultobj = 0;
4555 PyObject * obj0 = 0 ;
4558 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dX_get",&obj0))
SWIG_fail;
4564 result = (
PLFLT) ((arg1)->dX);
4573 PyObject *resultobj = 0;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4583 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dY_set",&obj0,&obj1))
SWIG_fail;
4593 arg2 = (
PLFLT)(val2);
4594 if (arg1) (arg1)->dY = arg2;
4603 PyObject *resultobj = 0;
4607 PyObject * obj0 = 0 ;
4610 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dY_get",&obj0))
SWIG_fail;
4616 result = (
PLFLT) ((arg1)->dY);
4625 PyObject *resultobj = 0;
4632 PyObject * obj0 = 0 ;
4633 PyObject * obj1 = 0 ;
4635 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wX_set",&obj0,&obj1))
SWIG_fail;
4645 arg2 = (
PLFLT)(val2);
4646 if (arg1) (arg1)->wX = arg2;
4655 PyObject *resultobj = 0;
4659 PyObject * obj0 = 0 ;
4662 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wX_get",&obj0))
SWIG_fail;
4668 result = (
PLFLT) ((arg1)->wX);
4677 PyObject *resultobj = 0;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4687 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wY_set",&obj0,&obj1))
SWIG_fail;
4697 arg2 = (
PLFLT)(val2);
4698 if (arg1) (arg1)->wY = arg2;
4707 PyObject *resultobj = 0;
4711 PyObject * obj0 = 0 ;
4714 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wY_get",&obj0))
SWIG_fail;
4720 result = (
PLFLT) ((arg1)->wY);
4729 PyObject *resultobj = 0;
4732 if (!PyArg_ParseTuple(args,(
char *)
":new_PLGraphicsIn"))
SWIG_fail;
4742 PyObject *resultobj = 0;
4746 PyObject * obj0 = 0 ;
4748 if (!PyArg_ParseTuple(args,(
char *)
"O:delete_PLGraphicsIn",&obj0))
SWIG_fail;
4754 free((
char *) arg1);
4764 if (!PyArg_ParseTuple(args,(
char*)
"O:swigregister", &obj))
return NULL;
4770 PyObject *resultobj = 0;
4774 PyObject * obj0 = 0 ;
4776 if (!PyArg_ParseTuple(args,(
char *)
"O:plsxwin",&obj0))
SWIG_fail;
4781 arg1 = (
PLINT)(val1);
4791 PyObject *resultobj = 0;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4801 if (!PyArg_ParseTuple(args,(
char *)
"OO:pl_setcontlabelformat",&obj0,&obj1))
SWIG_fail;
4806 arg1 = (
PLINT)(val1);
4811 arg2 = (
PLINT)(val2);
4821 PyObject *resultobj = 0;
4834 PyObject * obj0 = 0 ;
4835 PyObject * obj1 = 0 ;
4836 PyObject * obj2 = 0 ;
4837 PyObject * obj3 = 0 ;
4839 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
4844 arg1 = (
PLFLT)(val1);
4849 arg2 = (
PLFLT)(val2);
4854 arg3 = (
PLFLT)(val3);
4859 arg4 = (
PLINT)(val4);
4869 PyObject *resultobj = 0;
4873 PyObject * obj0 = 0 ;
4875 if (!PyArg_ParseTuple(args,(
char *)
"O:pladv",&obj0))
SWIG_fail;
4880 arg1 = (
PLINT)(val1);
4890 PyObject *resultobj = 0;
4915 PyObject * obj0 = 0 ;
4916 PyObject * obj1 = 0 ;
4917 PyObject * obj2 = 0 ;
4918 PyObject * obj3 = 0 ;
4919 PyObject * obj4 = 0 ;
4920 PyObject * obj5 = 0 ;
4921 PyObject * obj6 = 0 ;
4922 PyObject * obj7 = 0 ;
4924 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
4929 arg1 = (
PLFLT)(val1);
4934 arg2 = (
PLFLT)(val2);
4939 arg3 = (
PLFLT)(val3);
4944 arg4 = (
PLFLT)(val4);
4949 arg5 = (
PLFLT)(val5);
4954 arg6 = (
PLFLT)(val6);
4959 arg7 = (
PLFLT)(val7);
4965 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4974 PyObject *resultobj = 0;
4977 char *arg3 = (
char *) 0 ;
4980 char *arg6 = (
char *) 0 ;
5001 PyObject * obj0 = 0 ;
5002 PyObject * obj1 = 0 ;
5003 PyObject * obj2 = 0 ;
5004 PyObject * obj3 = 0 ;
5005 PyObject * obj4 = 0 ;
5006 PyObject * obj5 = 0 ;
5007 PyObject * obj6 = 0 ;
5008 PyObject * obj7 = 0 ;
5010 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5015 arg1 = (
PLFLT)(val1);
5020 arg2 = (
PLFLT)(val2);
5025 arg3 = (
char *)(buf3);
5030 arg4 = (
PLFLT)(val4);
5035 arg5 = (
PLINT)(val5);
5040 arg6 = (
char *)(buf6);
5045 arg7 = (
PLFLT)(val7);
5050 arg8 = (
PLINT)(val8);
5051 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
5064 PyObject *resultobj = 0;
5066 PLFLT *arg2 = (PLFLT *) 0 ;
5067 PLFLT *arg3 = (PLFLT *) 0 ;
5069 PyArrayObject *tmp1 ;
5070 PyArrayObject *tmp3 ;
5073 PyObject * obj0 = 0 ;
5074 PyObject * obj1 = 0 ;
5075 PyObject * obj2 = 0 ;
5077 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plbin",&obj0,&obj1,&obj2))
SWIG_fail;
5082 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5083 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5089 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
5091 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
5094 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5100 arg4 = (
PLINT)(val4);
5101 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
5122 PyObject *resultobj = 0;
5123 PLINT *arg1 = (PLINT *) 0 ;
5124 PLINT *arg2 = (PLINT *) 0 ;
5125 PLINT *arg3 = (PLINT *) 0 ;
5126 PLINT *arg4 = (PLINT *) 0 ;
5127 PLINT *arg5 = (PLINT *) 0 ;
5128 PLFLT *arg6 = (PLFLT *) 0 ;
5144 PyObject * obj0 = 0 ;
5152 if (!PyArg_ParseTuple(args,(
char *)
"O:plbtime",&obj0))
SWIG_fail;
5157 arg7 = (
PLFLT)(val7);
5158 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5203 PyObject *resultobj = 0;
5205 if (!PyArg_ParseTuple(args,(
char *)
":plbop"))
SWIG_fail;
5215 PyObject *resultobj = 0;
5216 char *arg1 = (
char *) 0 ;
5219 char *arg4 = (
char *) 0 ;
5236 PyObject * obj0 = 0 ;
5237 PyObject * obj1 = 0 ;
5238 PyObject * obj2 = 0 ;
5239 PyObject * obj3 = 0 ;
5240 PyObject * obj4 = 0 ;
5241 PyObject * obj5 = 0 ;
5243 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5248 arg1 = (
char *)(buf1);
5253 arg2 = (
PLFLT)(val2);
5258 arg3 = (
PLINT)(val3);
5263 arg4 = (
char *)(buf4);
5268 arg5 = (
PLFLT)(val5);
5273 arg6 = (
PLINT)(val6);
5274 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
5287 PyObject *resultobj = 0;
5288 char *arg1 = (
char *) 0 ;
5289 char *arg2 = (
char *) 0 ;
5292 char *arg5 = (
char *) 0 ;
5293 char *arg6 = (
char *) 0 ;
5296 char *arg9 = (
char *) 0 ;
5297 char *arg10 = (
char *) 0 ;
5330 PyObject * obj0 = 0 ;
5331 PyObject * obj1 = 0 ;
5332 PyObject * obj2 = 0 ;
5333 PyObject * obj3 = 0 ;
5334 PyObject * obj4 = 0 ;
5335 PyObject * obj5 = 0 ;
5336 PyObject * obj6 = 0 ;
5337 PyObject * obj7 = 0 ;
5338 PyObject * obj8 = 0 ;
5339 PyObject * obj9 = 0 ;
5340 PyObject * obj10 = 0 ;
5341 PyObject * obj11 = 0 ;
5343 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
5348 arg1 = (
char *)(buf1);
5353 arg2 = (
char *)(buf2);
5358 arg3 = (
PLFLT)(val3);
5363 arg4 = (
PLINT)(val4);
5368 arg5 = (
char *)(buf5);
5373 arg6 = (
char *)(buf6);
5378 arg7 = (
PLFLT)(val7);
5383 arg8 = (
PLINT)(val8);
5388 arg9 = (
char *)(buf9);
5393 arg10 = (
char *)(buf10);
5398 arg11 = (
PLFLT)(val11);
5403 arg12 = (
PLINT)(val12);
5404 plbox3((
char const *)arg1,(
char const *)arg2,arg3,arg4,(
char const *)arg5,(
char const *)arg6,arg7,arg8,(
char const *)arg9,(
char const *)arg10,arg11,arg12);
5425 PyObject *resultobj = 0;
5428 PLFLT *arg3 = (PLFLT *) 0 ;
5429 PLFLT *arg4 = (PLFLT *) 0 ;
5430 PLINT *arg5 = (PLINT *) 0 ;
5441 PyObject * obj0 = 0 ;
5442 PyObject * obj1 = 0 ;
5447 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcalc_world",&obj0,&obj1))
SWIG_fail;
5452 arg1 = (
PLFLT)(val1);
5457 arg2 = (
PLFLT)(val2);
5485 PyObject *resultobj = 0;
5487 if (!PyArg_ParseTuple(args,(
char *)
":plclear"))
SWIG_fail;
5497 PyObject *resultobj = 0;
5501 PyObject * obj0 = 0 ;
5503 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol0",&obj0))
SWIG_fail;
5508 arg1 = (
PLINT)(val1);
5518 PyObject *resultobj = 0;
5522 PyObject * obj0 = 0 ;
5524 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol1",&obj0))
SWIG_fail;
5529 arg1 = (
PLFLT)(val1);
5539 PyObject *resultobj = 0;
5573 PyObject * obj0 = 0 ;
5574 PyObject * obj1 = 0 ;
5575 PyObject * obj2 = 0 ;
5576 PyObject * obj3 = 0 ;
5577 PyObject * obj4 = 0 ;
5578 PyObject * obj5 = 0 ;
5579 PyObject * obj6 = 0 ;
5580 PyObject * obj7 = 0 ;
5581 PyObject * obj8 = 0 ;
5582 PyObject * obj9 = 0 ;
5583 PyObject * obj10 = 0 ;
5585 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
5590 arg1 = (
PLFLT)(val1);
5595 arg2 = (
PLFLT)(val2);
5600 arg3 = (
PLFLT)(val3);
5605 arg4 = (
PLINT)(val4);
5615 arg6 = (
PLINT)(val6);
5620 arg7 = (
PLINT)(val7);
5625 arg8 = (
PLINT)(val8);
5630 arg9 = (
PLINT)(val9);
5635 arg10 = (
PLINT)(val10);
5640 arg11 = (
PLFLT)(val11);
5641 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5650 PyObject *resultobj = 0;
5651 PLFLT **arg1 = (PLFLT **) 0 ;
5658 PLFLT *arg8 = (PLFLT *) 0 ;
5662 PyArrayObject *tmp1 ;
5671 PyArrayObject *tmp8 ;
5672 PyObject * obj0 = 0 ;
5673 PyObject * obj1 = 0 ;
5674 PyObject * obj2 = 0 ;
5675 PyObject * obj3 = 0 ;
5676 PyObject * obj4 = 0 ;
5677 PyObject * obj5 = 0 ;
5678 PyObject * obj6 = 0 ;
5679 PyObject * obj7 = 0 ;
5688 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5694 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5695 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5696 size =
sizeof (
PLFLT ) * arg3;
5697 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
5698 for ( i = 0; i < arg2; i++ )
5699 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
5705 arg4 = (
PLINT)(val4);
5710 arg5 = (
PLINT)(val5);
5715 arg6 = (
PLINT)(val6);
5720 arg7 = (
PLINT)(val7);
5725 arg9 = PyArray_DIMS( tmp8 )[0];
5726 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5731 if ( obj6 == Py_None )
5737 if ( !PyCallable_Check( (PyObject *) obj6 ) )
5739 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
5748 if ( obj7 == Py_None )
5756 plcont((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11);
5791 PyObject *resultobj = 0;
5798 PLFLT *arg7 = (PLFLT *) 0 ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 PyObject * obj2 = 0 ;
5816 PyObject * obj3 = 0 ;
5817 PyObject * obj4 = 0 ;
5818 PyObject * obj5 = 0 ;
5821 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5826 arg1 = (
PLINT)(val1);
5831 arg2 = (
PLINT)(val2);
5836 arg3 = (
PLINT)(val3);
5841 arg4 = (
PLINT)(val4);
5846 arg5 = (
PLINT)(val5);
5851 arg6 = (
PLFLT)(val6);
5852 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5867 PyObject *resultobj = 0;
5874 PyObject * obj0 = 0 ;
5875 PyObject * obj1 = 0 ;
5877 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcpstrm",&obj0,&obj1))
SWIG_fail;
5882 arg1 = (
PLINT)(val1);
5897 PyObject *resultobj = 0;
5899 if (!PyArg_ParseTuple(args,(
char *)
":plend"))
SWIG_fail;
5909 PyObject *resultobj = 0;
5911 if (!PyArg_ParseTuple(args,(
char *)
":plend1"))
SWIG_fail;
5921 PyObject *resultobj = 0;
5940 PyObject * obj0 = 0 ;
5941 PyObject * obj1 = 0 ;
5942 PyObject * obj2 = 0 ;
5943 PyObject * obj3 = 0 ;
5944 PyObject * obj4 = 0 ;
5945 PyObject * obj5 = 0 ;
5947 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5952 arg1 = (
PLFLT)(val1);
5957 arg2 = (
PLFLT)(val2);
5962 arg3 = (
PLFLT)(val3);
5967 arg4 = (
PLFLT)(val4);
5972 arg5 = (
PLINT)(val5);
5977 arg6 = (
PLINT)(val6);
5978 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5987 PyObject *resultobj = 0;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 PyObject * obj2 = 0 ;
6009 PyObject * obj3 = 0 ;
6010 PyObject * obj4 = 0 ;
6011 PyObject * obj5 = 0 ;
6013 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
6018 arg1 = (
PLFLT)(val1);
6023 arg2 = (
PLFLT)(val2);
6028 arg3 = (
PLFLT)(val3);
6033 arg4 = (
PLFLT)(val4);
6038 arg5 = (
PLINT)(val5);
6043 arg6 = (
PLINT)(val6);
6044 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6053 PyObject *resultobj = 0;
6055 if (!PyArg_ParseTuple(args,(
char *)
":pleop"))
SWIG_fail;
6065 PyObject *resultobj = 0;
6067 PLFLT *arg2 = (PLFLT *) 0 ;
6068 PLFLT *arg3 = (PLFLT *) 0 ;
6069 PLFLT *arg4 = (PLFLT *) 0 ;
6070 PyArrayObject *tmp1 ;
6071 PyArrayObject *tmp3 ;
6072 PyArrayObject *tmp4 ;
6073 PyObject * obj0 = 0 ;
6074 PyObject * obj1 = 0 ;
6075 PyObject * obj2 = 0 ;
6077 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerrx",&obj0,&obj1,&obj2))
SWIG_fail;
6082 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6083 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6089 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6091 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6094 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6100 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6102 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6105 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6107 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6134 PyObject *resultobj = 0;
6136 PLFLT *arg2 = (PLFLT *) 0 ;
6137 PLFLT *arg3 = (PLFLT *) 0 ;
6138 PLFLT *arg4 = (PLFLT *) 0 ;
6139 PyArrayObject *tmp1 ;
6140 PyArrayObject *tmp3 ;
6141 PyArrayObject *tmp4 ;
6142 PyObject * obj0 = 0 ;
6143 PyObject * obj1 = 0 ;
6144 PyObject * obj2 = 0 ;
6146 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerry",&obj0,&obj1,&obj2))
SWIG_fail;
6151 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6152 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6158 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6160 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6163 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6169 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6171 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6174 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6176 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6203 PyObject *resultobj = 0;
6205 if (!PyArg_ParseTuple(args,(
char *)
":plfamadv"))
SWIG_fail;
6215 PyObject *resultobj = 0;
6217 PLFLT *arg2 = (PLFLT *) 0 ;
6218 PLFLT *arg3 = (PLFLT *) 0 ;
6219 PyArrayObject *tmp1 ;
6220 PyArrayObject *tmp3 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6224 if (!PyArg_ParseTuple(args,(
char *)
"OO:plfill",&obj0,&obj1))
SWIG_fail;
6229 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6230 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6236 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6238 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6241 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6243 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
6264 PyObject *resultobj = 0;
6266 PLFLT *arg2 = (PLFLT *) 0 ;
6267 PLFLT *arg3 = (PLFLT *) 0 ;
6268 PLFLT *arg4 = (PLFLT *) 0 ;
6269 PyArrayObject *tmp1 ;
6270 PyArrayObject *tmp3 ;
6271 PyArrayObject *tmp4 ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 PyObject * obj2 = 0 ;
6276 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plfill3",&obj0,&obj1,&obj2))
SWIG_fail;
6281 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6282 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6288 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6290 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6293 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6299 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6301 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6304 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6306 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6333 PyObject *resultobj = 0;
6335 PLFLT *arg2 = (PLFLT *) 0 ;
6336 PLFLT *arg3 = (PLFLT *) 0 ;
6338 PyArrayObject *tmp1 ;
6339 PyArrayObject *tmp3 ;
6342 PyObject * obj0 = 0 ;
6343 PyObject * obj1 = 0 ;
6344 PyObject * obj2 = 0 ;
6346 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plgradient",&obj0,&obj1,&obj2))
SWIG_fail;
6351 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6352 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6358 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6360 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6363 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6369 arg4 = (
PLFLT)(val4);
6370 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
6391 PyObject *resultobj = 0;
6393 if (!PyArg_ParseTuple(args,(
char *)
":plflush"))
SWIG_fail;
6403 PyObject *resultobj = 0;
6407 PyObject * obj0 = 0 ;
6409 if (!PyArg_ParseTuple(args,(
char *)
"O:plfont",&obj0))
SWIG_fail;
6414 arg1 = (
PLINT)(val1);
6424 PyObject *resultobj = 0;
6428 PyObject * obj0 = 0 ;
6430 if (!PyArg_ParseTuple(args,(
char *)
"O:plfontld",&obj0))
SWIG_fail;
6435 arg1 = (
PLINT)(val1);
6445 PyObject *resultobj = 0;
6446 PLFLT *arg1 = (PLFLT *) 0 ;
6447 PLFLT *arg2 = (PLFLT *) 0 ;
6455 if (!PyArg_ParseTuple(args,(
char *)
":plgchr"))
SWIG_fail;
6477 PyObject *resultobj = 0;
6479 PLINT *arg2 = (PLINT *) 0 ;
6480 PLINT *arg3 = (PLINT *) 0 ;
6481 PLINT *arg4 = (PLINT *) 0 ;
6490 PyObject * obj0 = 0 ;
6495 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0",&obj0))
SWIG_fail;
6500 arg1 = (
PLINT)(val1);
6528 PyObject *resultobj = 0;
6530 PLINT *arg2 = (PLINT *) 0 ;
6531 PLINT *arg3 = (PLINT *) 0 ;
6532 PLINT *arg4 = (PLINT *) 0 ;
6533 PLFLT *arg5 = (PLFLT *) 0 ;
6544 PyObject * obj0 = 0 ;
6550 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0a",&obj0))
SWIG_fail;
6555 arg1 = (
PLINT)(val1);
6556 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6589 PyObject *resultobj = 0;
6590 PLINT *arg1 = (PLINT *) 0 ;
6591 PLINT *arg2 = (PLINT *) 0 ;
6592 PLINT *arg3 = (PLINT *) 0 ;
6603 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbg"))
SWIG_fail;
6631 PyObject *resultobj = 0;
6632 PLINT *arg1 = (PLINT *) 0 ;
6633 PLINT *arg2 = (PLINT *) 0 ;
6634 PLINT *arg3 = (PLINT *) 0 ;
6635 PLFLT *arg4 = (PLFLT *) 0 ;
6649 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbga"))
SWIG_fail;
6683 PyObject *resultobj = 0;
6684 PLINT *arg1 = (PLINT *) 0 ;
6689 if (!PyArg_ParseTuple(args,(
char *)
":plgcompression"))
SWIG_fail;
6705 PyObject *resultobj = 0;
6706 char *arg1 = (
char *) 0 ;
6712 if (!PyArg_ParseTuple(args,(
char *)
":plgdev"))
SWIG_fail;
6716 PyObject *o = PyString_FromString( arg1 );
6726 PyObject *resultobj = 0;
6727 PLFLT *arg1 = (PLFLT *) 0 ;
6728 PLFLT *arg2 = (PLFLT *) 0 ;
6729 PLFLT *arg3 = (PLFLT *) 0 ;
6730 PLFLT *arg4 = (PLFLT *) 0 ;
6744 if (!PyArg_ParseTuple(args,(
char *)
":plgdidev"))
SWIG_fail;
6778 PyObject *resultobj = 0;
6779 PLFLT *arg1 = (PLFLT *) 0 ;
6784 if (!PyArg_ParseTuple(args,(
char *)
":plgdiori"))
SWIG_fail;
6800 PyObject *resultobj = 0;
6801 PLFLT *arg1 = (PLFLT *) 0 ;
6802 PLFLT *arg2 = (PLFLT *) 0 ;
6803 PLFLT *arg3 = (PLFLT *) 0 ;
6804 PLFLT *arg4 = (PLFLT *) 0 ;
6818 if (!PyArg_ParseTuple(args,(
char *)
":plgdiplt"))
SWIG_fail;
6852 PyObject *resultobj = 0;
6853 PLINT *arg1 = (PLINT *) 0 ;
6854 PLINT *arg2 = (PLINT *) 0 ;
6855 PLINT *arg3 = (PLINT *) 0 ;
6866 if (!PyArg_ParseTuple(args,(
char *)
":plgfam"))
SWIG_fail;
6894 PyObject *resultobj = 0;
6900 if (!PyArg_ParseTuple(args,(
char *)
":plgfci"))
SWIG_fail;
6916 PyObject *resultobj = 0;
6917 char *arg1 = (
char *) 0 ;
6923 if (!PyArg_ParseTuple(args,(
char *)
":plgfnam"))
SWIG_fail;
6927 PyObject *o = PyString_FromString( arg1 );
6937 PyObject *resultobj = 0;
6938 PLINT *arg1 = (PLINT *) 0 ;
6939 PLINT *arg2 = (PLINT *) 0 ;
6940 PLINT *arg3 = (PLINT *) 0 ;
6951 if (!PyArg_ParseTuple(args,(
char *)
":plgfont"))
SWIG_fail;
6979 PyObject *resultobj = 0;
6980 PLINT *arg1 = (PLINT *) 0 ;
6985 if (!PyArg_ParseTuple(args,(
char *)
":plglevel"))
SWIG_fail;
7001 PyObject *resultobj = 0;
7002 PLFLT *arg1 = (PLFLT *) 0 ;
7003 PLFLT *arg2 = (PLFLT *) 0 ;
7004 PLINT *arg3 = (PLINT *) 0 ;
7005 PLINT *arg4 = (PLINT *) 0 ;
7006 PLINT *arg5 = (PLINT *) 0 ;
7007 PLINT *arg6 = (PLINT *) 0 ;
7027 if (!PyArg_ParseTuple(args,(
char *)
":plgpage"))
SWIG_fail;
7028 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7073 PyObject *resultobj = 0;
7075 if (!PyArg_ParseTuple(args,(
char *)
":plgra"))
SWIG_fail;
7085 PyObject *resultobj = 0;
7086 PLFLT *arg1 = (PLFLT *) 0 ;
7087 PLFLT *arg2 = (PLFLT *) 0 ;
7088 PLFLT *arg3 = (PLFLT *) 0 ;
7090 PLFLT *arg5 = (PLFLT *) 0 ;
7092 PLFLT *arg7 = (PLFLT *) 0 ;
7094 PLFLT **arg9 = (PLFLT **) 0 ;
7097 PyArrayObject *tmp1 ;
7098 PyArrayObject *tmp2 ;
7099 PyArrayObject *tmp3 ;
7100 PyArrayObject *tmp5 ;
7101 PyArrayObject *tmp7 ;
7102 PyObject *array7 = NULL ;
7107 PyObject * obj0 = 0 ;
7108 PyObject * obj1 = 0 ;
7109 PyObject * obj2 = 0 ;
7110 PyObject * obj3 = 0 ;
7111 PyObject * obj4 = 0 ;
7112 PyObject * obj5 = 0 ;
7113 PyObject * obj6 = 0 ;
7115 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
7120 Alen = PyArray_DIMS( tmp1 )[0];
7121 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7127 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
7129 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7132 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7138 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
7140 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7143 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7144 arg4 = PyArray_DIMS( tmp3 )[0];
7150 Xlen = PyArray_DIMS( tmp5 )[0];
7152 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7160 Ylen = PyArray_DIMS( tmp7 )[0];
7162 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7167 array7 = PyArray_SimpleNew( 2, dims, NPY_DOUBLE );
7170 size = (int) (
sizeof (
double ) *
Ylen );
7171 arg9 = (
double **) malloc(
sizeof (
double * ) *
Xlen );
7172 for ( i = 0; i <
Xlen; i++ )
7173 arg9[i] = (
double *) ( PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7179 arg10 = (
PLINT)(val10);
7184 arg11 = (
PLFLT)(val11);
7185 plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
7229 PyObject *resultobj = 0;
7230 PLFLT *arg1 = (PLFLT *) 0 ;
7231 PLFLT *arg2 = (PLFLT *) 0 ;
7232 PLFLT *arg3 = (PLFLT *) 0 ;
7233 PLFLT *arg4 = (PLFLT *) 0 ;
7247 if (!PyArg_ParseTuple(args,(
char *)
":plgspa"))
SWIG_fail;
7248 plgspa(arg1,arg2,arg3,arg4);
7281 PyObject *resultobj = 0;
7282 PLINT *arg1 = (PLINT *) 0 ;
7287 if (!PyArg_ParseTuple(args,(
char *)
":plgstrm"))
SWIG_fail;
7303 PyObject *resultobj = 0;
7304 char *arg1 = (
char *) 0 ;
7310 if (!PyArg_ParseTuple(args,(
char *)
":plgver"))
SWIG_fail;
7314 PyObject *o = PyString_FromString( arg1 );
7324 PyObject *resultobj = 0;
7325 PLFLT *arg1 = (PLFLT *) 0 ;
7326 PLFLT *arg2 = (PLFLT *) 0 ;
7327 PLFLT *arg3 = (PLFLT *) 0 ;
7328 PLFLT *arg4 = (PLFLT *) 0 ;
7342 if (!PyArg_ParseTuple(args,(
char *)
":plgvpd"))
SWIG_fail;
7343 plgvpd(arg1,arg2,arg3,arg4);
7376 PyObject *resultobj = 0;
7377 PLFLT *arg1 = (PLFLT *) 0 ;
7378 PLFLT *arg2 = (PLFLT *) 0 ;
7379 PLFLT *arg3 = (PLFLT *) 0 ;
7380 PLFLT *arg4 = (PLFLT *) 0 ;
7394 if (!PyArg_ParseTuple(args,(
char *)
":plgvpw"))
SWIG_fail;
7395 plgvpw(arg1,arg2,arg3,arg4);
7428 PyObject *resultobj = 0;
7429 PLINT *arg1 = (PLINT *) 0 ;
7430 PLINT *arg2 = (PLINT *) 0 ;
7438 if (!PyArg_ParseTuple(args,(
char *)
":plgxax"))
SWIG_fail;
7460 PyObject *resultobj = 0;
7461 PLINT *arg1 = (PLINT *) 0 ;
7462 PLINT *arg2 = (PLINT *) 0 ;
7470 if (!PyArg_ParseTuple(args,(
char *)
":plgyax"))
SWIG_fail;
7492 PyObject *resultobj = 0;
7493 PLINT *arg1 = (PLINT *) 0 ;
7494 PLINT *arg2 = (PLINT *) 0 ;
7502 if (!PyArg_ParseTuple(args,(
char *)
":plgzax"))
SWIG_fail;
7524 PyObject *resultobj = 0;
7526 PLFLT *arg2 = (PLFLT *) 0 ;
7531 PyArrayObject *tmp1 ;
7540 PyObject * obj0 = 0 ;
7541 PyObject * obj1 = 0 ;
7542 PyObject * obj2 = 0 ;
7543 PyObject * obj3 = 0 ;
7544 PyObject * obj4 = 0 ;
7546 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
7551 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7552 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7558 arg3 = (
PLFLT)(val3);
7563 arg4 = (
PLFLT)(val4);
7568 arg5 = (
PLINT)(val5);
7573 arg6 = (
PLINT)(val6);
7574 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
7589 PyObject *resultobj = 0;
7593 PLFLT *arg4 = (PLFLT *) 0 ;
7594 PLFLT *arg5 = (PLFLT *) 0 ;
7595 PLFLT *arg6 = (PLFLT *) 0 ;
7608 PyObject * obj0 = 0 ;
7609 PyObject * obj1 = 0 ;
7610 PyObject * obj2 = 0 ;
7615 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plhlsrgb",&obj0,&obj1,&obj2))
SWIG_fail;
7620 arg1 = (
PLFLT)(val1);
7625 arg2 = (
PLFLT)(val2);
7630 arg3 = (
PLFLT)(val3);
7631 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7658 PyObject *resultobj = 0;
7660 if (!PyArg_ParseTuple(args,(
char *)
":plinit"))
SWIG_fail;
7670 PyObject *resultobj = 0;
7683 PyObject * obj0 = 0 ;
7684 PyObject * obj1 = 0 ;
7685 PyObject * obj2 = 0 ;
7686 PyObject * obj3 = 0 ;
7688 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
7693 arg1 = (
PLFLT)(val1);
7698 arg2 = (
PLFLT)(val2);
7703 arg3 = (
PLFLT)(val3);
7708 arg4 = (
PLFLT)(val4);
7709 pljoin(arg1,arg2,arg3,arg4);
7718 PyObject *resultobj = 0;
7719 char *arg1 = (
char *) 0 ;
7720 char *arg2 = (
char *) 0 ;
7721 char *arg3 = (
char *) 0 ;
7731 PyObject * obj0 = 0 ;
7732 PyObject * obj1 = 0 ;
7733 PyObject * obj2 = 0 ;
7735 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllab",&obj0,&obj1,&obj2))
SWIG_fail;
7740 arg1 = (
char *)(buf1);
7745 arg2 = (
char *)(buf2);
7750 arg3 = (
char *)(buf3);
7751 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
7766 PyObject *resultobj = 0;
7767 PLFLT *arg1 = (PLFLT *) 0 ;
7768 PLFLT *arg2 = (PLFLT *) 0 ;
7780 PLINT *arg14 = (PLINT *) 0 ;
7785 PLINT *arg19 = (PLINT *) 0 ;
7786 char **arg20 = (
char **) 0 ;
7787 PLINT *arg21 = (PLINT *) 0 ;
7788 PLINT *arg22 = (PLINT *) 0 ;
7789 PLFLT *arg23 = (PLFLT *) 0 ;
7790 PLFLT *arg24 = (PLFLT *) 0 ;
7791 PLINT *arg25 = (PLINT *) 0 ;
7792 PLINT *arg26 = (PLINT *) 0 ;
7793 PLFLT *arg27 = (PLFLT *) 0 ;
7794 PLINT *arg28 = (PLINT *) 0 ;
7795 PLFLT *arg29 = (PLFLT *) 0 ;
7796 PLINT *arg30 = (PLINT *) 0 ;
7797 char **arg31 = (
char **) 0 ;
7822 PyArrayObject *tmp13 ;
7831 PyArrayObject *tmp19 ;
7832 PyArrayObject *tmp20 ;
7833 PyArrayObject *tmp21 ;
7834 PyArrayObject *tmp22 ;
7835 PyArrayObject *tmp23 ;
7836 PyArrayObject *tmp24 ;
7837 PyArrayObject *tmp25 ;
7838 PyArrayObject *tmp26 ;
7839 PyArrayObject *tmp27 ;
7840 PyArrayObject *tmp28 ;
7841 PyArrayObject *tmp29 ;
7842 PyArrayObject *tmp30 ;
7843 PyArrayObject *tmp31 ;
7844 PyObject * obj0 = 0 ;
7845 PyObject * obj1 = 0 ;
7846 PyObject * obj2 = 0 ;
7847 PyObject * obj3 = 0 ;
7848 PyObject * obj4 = 0 ;
7849 PyObject * obj5 = 0 ;
7850 PyObject * obj6 = 0 ;
7851 PyObject * obj7 = 0 ;
7852 PyObject * obj8 = 0 ;
7853 PyObject * obj9 = 0 ;
7854 PyObject * obj10 = 0 ;
7855 PyObject * obj11 = 0 ;
7856 PyObject * obj12 = 0 ;
7857 PyObject * obj13 = 0 ;
7858 PyObject * obj14 = 0 ;
7859 PyObject * obj15 = 0 ;
7860 PyObject * obj16 = 0 ;
7861 PyObject * obj17 = 0 ;
7862 PyObject * obj18 = 0 ;
7863 PyObject * obj19 = 0 ;
7864 PyObject * obj20 = 0 ;
7865 PyObject * obj21 = 0 ;
7866 PyObject * obj22 = 0 ;
7867 PyObject * obj23 = 0 ;
7868 PyObject * obj24 = 0 ;
7869 PyObject * obj25 = 0 ;
7870 PyObject * obj26 = 0 ;
7871 PyObject * obj27 = 0 ;
7875 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:pllegend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27))
SWIG_fail;
7880 arg3 = (
PLINT)(val3);
7885 arg4 = (
PLINT)(val4);
7890 arg5 = (
PLFLT)(val5);
7895 arg6 = (
PLFLT)(val6);
7900 arg7 = (
PLFLT)(val7);
7905 arg8 = (
PLINT)(val8);
7910 arg9 = (
PLINT)(val9);
7915 arg10 = (
PLINT)(val10);
7920 arg11 = (
PLINT)(val11);
7925 arg12 = (
PLINT)(val12);
7928 if ( tmp13 == NULL )
7930 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7931 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7937 arg15 = (
PLFLT)(val15);
7942 arg16 = (
PLFLT)(val16);
7947 arg17 = (
PLFLT)(val17);
7952 arg18 = (
PLFLT)(val18);
7955 if ( tmp19 == NULL )
7957 if ( PyArray_DIMS( tmp19 )[0] !=
Alen )
7959 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7962 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7966 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7967 if ( tmp20 == NULL )
7969 if ( PyArray_DIMS( tmp20 )[0] !=
Alen )
7971 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7974 arg20 = (
char **) malloc(
sizeof (
char* ) *
Alen );
7975 for ( i = 0; i <
Alen; i++ )
7977 arg20[i] = PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7978 if ( arg20[i] == NULL )
7987 if ( tmp21 == NULL )
7989 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
7991 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7994 arg21 = (PLINT *) PyArray_DATA( tmp21 );
7998 if ( tmp22 == NULL )
8000 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8002 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8005 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8009 if ( tmp23 == NULL )
8011 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8013 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8016 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8020 if ( tmp24 == NULL )
8022 if ( PyArray_DIMS( tmp24 )[0] !=
Alen )
8024 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8027 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8031 if ( tmp25 == NULL )
8033 if ( PyArray_DIMS( tmp25 )[0] !=
Alen )
8035 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8038 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8042 if ( tmp26 == NULL )
8044 if ( PyArray_DIMS( tmp26 )[0] !=
Alen )
8046 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8049 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8053 if ( tmp27 == NULL )
8055 if ( PyArray_DIMS( tmp27 )[0] !=
Alen )
8057 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8060 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8064 if ( tmp28 == NULL )
8066 if ( PyArray_DIMS( tmp28 )[0] !=
Alen )
8068 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8071 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8075 if ( tmp29 == NULL )
8077 if ( PyArray_DIMS( tmp29 )[0] !=
Alen )
8079 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8082 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8086 if ( tmp30 == NULL )
8088 if ( PyArray_DIMS( tmp30 )[0] !=
Alen )
8090 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8093 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8097 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8098 if ( tmp31 == NULL )
8100 if ( PyArray_DIMS( tmp31 )[0] !=
Alen )
8102 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8105 arg31 = (
char **) malloc(
sizeof (
char* ) *
Alen );
8106 for ( i = 0; i <
Alen; i++ )
8108 arg31[i] = PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8109 if ( arg31[i] == NULL )
8116 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(
int const *)arg14,arg15,arg16,arg17,arg18,(
int const *)arg19,(
char const **)arg20,(
int const *)arg21,(
int const *)arg22,(
double const *)arg23,(
double const *)arg24,(
int const *)arg25,(
int const *)arg26,(
double const *)arg27,(
int const *)arg28,(
double const *)arg29,(
int const *)arg30,(
char const **)arg31);
8137 Py_DECREF( tmp20 ); free( arg20 );
8170 Py_DECREF( tmp31 ); free( arg31 );
8181 Py_DECREF( tmp20 ); free( arg20 );
8214 Py_DECREF( tmp31 ); free( arg31 );
8221 PyObject *resultobj = 0;
8222 PLFLT *arg1 = (PLFLT *) 0 ;
8223 PLFLT *arg2 = (PLFLT *) 0 ;
8238 PLINT *arg17 = (PLINT *) 0 ;
8239 char **arg18 = (
char **) 0 ;
8241 char **arg20 = (
char **) 0 ;
8242 PLFLT *arg21 = (PLFLT *) 0 ;
8243 PLINT *arg22 = (PLINT *) 0 ;
8244 PLINT *arg23 = (PLINT *) 0 ;
8245 PLFLT **arg24 = (PLFLT **) 0 ;
8276 PyArrayObject *tmp16 ;
8277 PyArrayObject *tmp18 ;
8278 PyArrayObject *tmp19 ;
8279 PyArrayObject *tmp21 ;
8280 PyArrayObject *tmp22 ;
8281 PyArrayObject *tmp23 ;
8282 PyArrayObject *tmp24 ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 PyObject * obj2 = 0 ;
8286 PyObject * obj3 = 0 ;
8287 PyObject * obj4 = 0 ;
8288 PyObject * obj5 = 0 ;
8289 PyObject * obj6 = 0 ;
8290 PyObject * obj7 = 0 ;
8291 PyObject * obj8 = 0 ;
8292 PyObject * obj9 = 0 ;
8293 PyObject * obj10 = 0 ;
8294 PyObject * obj11 = 0 ;
8295 PyObject * obj12 = 0 ;
8296 PyObject * obj13 = 0 ;
8297 PyObject * obj14 = 0 ;
8298 PyObject * obj15 = 0 ;
8299 PyObject * obj16 = 0 ;
8300 PyObject * obj17 = 0 ;
8301 PyObject * obj18 = 0 ;
8302 PyObject * obj19 = 0 ;
8306 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOOOOOOOOOO:plcolorbar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19))
SWIG_fail;
8311 arg3 = (
PLINT)(val3);
8316 arg4 = (
PLINT)(val4);
8321 arg5 = (
PLFLT)(val5);
8326 arg6 = (
PLFLT)(val6);
8331 arg7 = (
PLFLT)(val7);
8336 arg8 = (
PLFLT)(val8);
8341 arg9 = (
PLINT)(val9);
8346 arg10 = (
PLINT)(val10);
8351 arg11 = (
PLINT)(val11);
8356 arg12 = (
PLFLT)(val12);
8361 arg13 = (
PLFLT)(val13);
8366 arg14 = (
PLINT)(val14);
8371 arg15 = (
PLFLT)(val15);
8374 if ( tmp16 == NULL )
8376 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8377 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8381 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8382 if ( tmp18 == NULL )
8384 if ( PyArray_DIMS( tmp18 )[0] !=
Alen )
8386 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8389 arg18 = (
char **) malloc(
sizeof (
char* ) *
Alen );
8390 for ( i = 0; i <
Alen; i++ )
8392 arg18[i] = PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8393 if ( arg18[i] == NULL )
8402 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8403 if ( tmp19 == NULL )
8405 Alen = PyArray_DIMS( tmp19 )[0];
8407 arg20 = (
char **) malloc(
sizeof (
char* ) *
Alen );
8408 for ( i = 0; i <
Alen; i++ )
8410 arg20[i] = PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8411 if ( arg20[i] == NULL )
8420 if ( tmp21 == NULL )
8422 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8424 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8427 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8431 if ( tmp22 == NULL )
8433 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8435 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8438 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8443 if ( tmp23 == NULL )
8445 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8447 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8450 Xlen = PyArray_DIMS( tmp23 )[0];
8451 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8453 for ( i = 0; i <
Xlen; i++ )
8454 if ( arg23[i] >
Ylen )
8460 if ( tmp24 == NULL )
8462 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] !=
Ylen )
8464 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8468 arg24 = (PLFLT **) malloc(
sizeof ( PLFLT* ) *
Xlen );
8469 for ( i = 0; i <
Xlen; i++ )
8470 arg24[i] = (PLFLT *) ( PyArray_DATA( tmp24 ) + i * size );
8472 plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(
int const *)arg17,(
char const **)arg18,arg19,(
char const **)arg20,(
double const *)arg21,(
int const *)arg22,(
int const *)arg23,(
double const **)arg24);
8490 Py_DECREF( tmp18 ); free( arg18 );
8493 Py_DECREF( tmp19 ); free( arg20 );
8514 Py_DECREF( tmp18 ); free( arg18 );
8517 Py_DECREF( tmp19 ); free( arg20 );
8537 PyObject *resultobj = 0;
8547 PyObject * obj0 = 0 ;
8548 PyObject * obj1 = 0 ;
8549 PyObject * obj2 = 0 ;
8551 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllightsource",&obj0,&obj1,&obj2))
SWIG_fail;
8556 arg1 = (
PLFLT)(val1);
8561 arg2 = (
PLFLT)(val2);
8566 arg3 = (
PLFLT)(val3);
8576 PyObject *resultobj = 0;
8578 PLFLT *arg2 = (PLFLT *) 0 ;
8579 PLFLT *arg3 = (PLFLT *) 0 ;
8580 PyArrayObject *tmp1 ;
8581 PyArrayObject *tmp3 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8585 if (!PyArg_ParseTuple(args,(
char *)
"OO:plline",&obj0,&obj1))
SWIG_fail;
8590 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8591 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8597 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8599 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8602 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8604 plline(arg1,(
double const *)arg2,(
double const *)arg3);
8625 PyObject *resultobj = 0;
8627 PLFLT *arg2 = (PLFLT *) 0 ;
8628 PLFLT *arg3 = (PLFLT *) 0 ;
8629 PLFLT *arg4 = (PLFLT *) 0 ;
8630 PyArrayObject *tmp1 ;
8631 PyArrayObject *tmp3 ;
8632 PyArrayObject *tmp4 ;
8633 PyObject * obj0 = 0 ;
8634 PyObject * obj1 = 0 ;
8635 PyObject * obj2 = 0 ;
8637 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plline3",&obj0,&obj1,&obj2))
SWIG_fail;
8642 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8643 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8649 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8651 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8654 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8660 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
8662 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8665 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8667 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
8694 PyObject *resultobj = 0;
8698 PyObject * obj0 = 0 ;
8700 if (!PyArg_ParseTuple(args,(
char *)
"O:pllsty",&obj0))
SWIG_fail;
8705 arg1 = (
PLINT)(val1);
8715 PyObject *resultobj = 0;
8716 PLFLT *arg1 = (PLFLT *) 0 ;
8717 PLFLT *arg2 = (PLFLT *) 0 ;
8718 PLFLT **arg3 = (PLFLT **) 0 ;
8722 PyArrayObject *tmp1 ;
8723 PyArrayObject *tmp2 ;
8724 PyArrayObject *tmp3 ;
8727 PyObject * obj0 = 0 ;
8728 PyObject * obj1 = 0 ;
8729 PyObject * obj2 = 0 ;
8730 PyObject * obj3 = 0 ;
8732 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
8737 Xlen = PyArray_DIMS( tmp1 )[0];
8738 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8744 Ylen = PyArray_DIMS( tmp2 )[0];
8745 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8752 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8754 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8757 arg4 = PyArray_DIMS( tmp3 )[0];
8758 arg5 = PyArray_DIMS( tmp3 )[1];
8759 size =
sizeof (
PLFLT ) * arg5;
8760 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
8761 for ( i = 0; i < arg4; i++ )
8762 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8768 arg6 = (
PLINT)(val6);
8769 plmesh((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6);
8798 PyObject *resultobj = 0;
8799 PLFLT *arg1 = (PLFLT *) 0 ;
8800 PLFLT *arg2 = (PLFLT *) 0 ;
8801 PLFLT **arg3 = (PLFLT **) 0 ;
8805 PLFLT *arg7 = (PLFLT *) 0 ;
8807 PyArrayObject *tmp1 ;
8808 PyArrayObject *tmp2 ;
8809 PyArrayObject *tmp3 ;
8812 PyArrayObject *tmp7 ;
8813 PyObject * obj0 = 0 ;
8814 PyObject * obj1 = 0 ;
8815 PyObject * obj2 = 0 ;
8816 PyObject * obj3 = 0 ;
8817 PyObject * obj4 = 0 ;
8819 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8824 Xlen = PyArray_DIMS( tmp1 )[0];
8825 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8831 Ylen = PyArray_DIMS( tmp2 )[0];
8832 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8839 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8841 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8844 arg4 = PyArray_DIMS( tmp3 )[0];
8845 arg5 = PyArray_DIMS( tmp3 )[1];
8846 size =
sizeof (
PLFLT ) * arg5;
8847 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
8848 for ( i = 0; i < arg4; i++ )
8849 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8855 arg6 = (
PLINT)(val6);
8860 arg8 = PyArray_DIMS( tmp7 )[0];
8861 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8863 plmeshc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
8898 PyObject *resultobj = 0;
8899 PLINT *arg1 = (PLINT *) 0 ;
8904 if (!PyArg_ParseTuple(args,(
char *)
":plmkstrm"))
SWIG_fail;
8920 PyObject *resultobj = 0;
8921 char *arg1 = (
char *) 0 ;
8925 char *arg5 = (
char *) 0 ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 PyObject * obj2 = 0 ;
8941 PyObject * obj3 = 0 ;
8942 PyObject * obj4 = 0 ;
8944 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8949 arg1 = (
char *)(buf1);
8954 arg2 = (
PLFLT)(val2);
8959 arg3 = (
PLFLT)(val3);
8964 arg4 = (
PLFLT)(val4);
8969 arg5 = (
char *)(buf5);
8970 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
8983 PyObject *resultobj = 0;
8984 char *arg1 = (
char *) 0 ;
8988 char *arg5 = (
char *) 0 ;
9001 PyObject * obj0 = 0 ;
9002 PyObject * obj1 = 0 ;
9003 PyObject * obj2 = 0 ;
9004 PyObject * obj3 = 0 ;
9005 PyObject * obj4 = 0 ;
9007 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9012 arg1 = (
char *)(buf1);
9017 arg2 = (
PLFLT)(val2);
9022 arg3 = (
PLFLT)(val3);
9027 arg4 = (
PLFLT)(val4);
9032 arg5 = (
char *)(buf5);
9033 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
9046 PyObject *resultobj = 0;
9047 PLFLT *arg1 = (PLFLT *) 0 ;
9048 PLFLT *arg2 = (PLFLT *) 0 ;
9049 PLFLT **arg3 = (PLFLT **) 0 ;
9054 PyArrayObject *tmp1 ;
9055 PyArrayObject *tmp2 ;
9056 PyArrayObject *tmp3 ;
9061 PyObject * obj0 = 0 ;
9062 PyObject * obj1 = 0 ;
9063 PyObject * obj2 = 0 ;
9064 PyObject * obj3 = 0 ;
9065 PyObject * obj4 = 0 ;
9067 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9072 Xlen = PyArray_DIMS( tmp1 )[0];
9073 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9079 Ylen = PyArray_DIMS( tmp2 )[0];
9080 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9087 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9089 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9092 arg4 = PyArray_DIMS( tmp3 )[0];
9093 arg5 = PyArray_DIMS( tmp3 )[1];
9094 size =
sizeof (
PLFLT ) * arg5;
9095 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9096 for ( i = 0; i < arg4; i++ )
9097 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9103 arg6 = (
PLINT)(val6);
9109 plot3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,arg7);
9138 PyObject *resultobj = 0;
9139 PLFLT *arg1 = (PLFLT *) 0 ;
9140 PLFLT *arg2 = (PLFLT *) 0 ;
9141 PLFLT **arg3 = (PLFLT **) 0 ;
9145 PLFLT *arg7 = (PLFLT *) 0 ;
9147 PyArrayObject *tmp1 ;
9148 PyArrayObject *tmp2 ;
9149 PyArrayObject *tmp3 ;
9152 PyArrayObject *tmp7 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 PyObject * obj2 = 0 ;
9156 PyObject * obj3 = 0 ;
9157 PyObject * obj4 = 0 ;
9159 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9164 Xlen = PyArray_DIMS( tmp1 )[0];
9165 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9171 Ylen = PyArray_DIMS( tmp2 )[0];
9172 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9179 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9181 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9184 arg4 = PyArray_DIMS( tmp3 )[0];
9185 arg5 = PyArray_DIMS( tmp3 )[1];
9186 size =
sizeof (
PLFLT ) * arg5;
9187 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9188 for ( i = 0; i < arg4; i++ )
9189 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9195 arg6 = (
PLINT)(val6);
9200 arg8 = PyArray_DIMS( tmp7 )[0];
9201 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9203 plot3dc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9238 PyObject *resultobj = 0;
9239 PLFLT *arg1 = (PLFLT *) 0 ;
9240 PLFLT *arg2 = (PLFLT *) 0 ;
9241 PLFLT **arg3 = (PLFLT **) 0 ;
9245 PLFLT *arg7 = (PLFLT *) 0 ;
9249 PLINT *arg11 = (PLINT *) 0 ;
9250 PLINT *arg12 = (PLINT *) 0 ;
9251 PyArrayObject *tmp1 ;
9252 PyArrayObject *tmp2 ;
9253 PyArrayObject *tmp3 ;
9256 PyArrayObject *tmp7 ;
9259 PyArrayObject *tmp10 ;
9260 PyArrayObject *tmp12 ;
9261 PyObject * obj0 = 0 ;
9262 PyObject * obj1 = 0 ;
9263 PyObject * obj2 = 0 ;
9264 PyObject * obj3 = 0 ;
9265 PyObject * obj4 = 0 ;
9266 PyObject * obj5 = 0 ;
9267 PyObject * obj6 = 0 ;
9268 PyObject * obj7 = 0 ;
9270 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9275 Xlen = PyArray_DIMS( tmp1 )[0];
9276 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9282 Ylen = PyArray_DIMS( tmp2 )[0];
9283 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9290 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9292 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9295 arg4 = PyArray_DIMS( tmp3 )[0];
9296 arg5 = PyArray_DIMS( tmp3 )[1];
9297 size =
sizeof (
PLFLT ) * arg5;
9298 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9299 for ( i = 0; i < arg4; i++ )
9300 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9306 arg6 = (
PLINT)(val6);
9311 arg8 = PyArray_DIMS( tmp7 )[0];
9312 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9318 arg9 = (
PLINT)(val9);
9321 if ( tmp10 == NULL )
9323 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9324 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9328 if ( tmp12 == NULL )
9330 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9332 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9335 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9337 plot3dcl((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
9384 PyObject *resultobj = 0;
9385 PLFLT *arg1 = (PLFLT *) 0 ;
9386 PLFLT *arg2 = (PLFLT *) 0 ;
9387 PLFLT **arg3 = (PLFLT **) 0 ;
9391 PLFLT *arg7 = (PLFLT *) 0 ;
9393 PyArrayObject *tmp1 ;
9394 PyArrayObject *tmp2 ;
9395 PyArrayObject *tmp3 ;
9398 PyArrayObject *tmp7 ;
9399 PyObject * obj0 = 0 ;
9400 PyObject * obj1 = 0 ;
9401 PyObject * obj2 = 0 ;
9402 PyObject * obj3 = 0 ;
9403 PyObject * obj4 = 0 ;
9405 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9410 Xlen = PyArray_DIMS( tmp1 )[0];
9411 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9417 Ylen = PyArray_DIMS( tmp2 )[0];
9418 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9425 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9427 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9430 arg4 = PyArray_DIMS( tmp3 )[0];
9431 arg5 = PyArray_DIMS( tmp3 )[1];
9432 size =
sizeof (
PLFLT ) * arg5;
9433 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9434 for ( i = 0; i < arg4; i++ )
9435 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9441 arg6 = (
PLINT)(val6);
9446 arg8 = PyArray_DIMS( tmp7 )[0];
9447 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9449 plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9484 PyObject *resultobj = 0;
9485 PLFLT *arg1 = (PLFLT *) 0 ;
9486 PLFLT *arg2 = (PLFLT *) 0 ;
9487 PLFLT **arg3 = (PLFLT **) 0 ;
9491 PLFLT *arg7 = (PLFLT *) 0 ;
9495 PLINT *arg11 = (PLINT *) 0 ;
9496 PLINT *arg12 = (PLINT *) 0 ;
9497 PyArrayObject *tmp1 ;
9498 PyArrayObject *tmp2 ;
9499 PyArrayObject *tmp3 ;
9502 PyArrayObject *tmp7 ;
9505 PyArrayObject *tmp10 ;
9506 PyArrayObject *tmp12 ;
9507 PyObject * obj0 = 0 ;
9508 PyObject * obj1 = 0 ;
9509 PyObject * obj2 = 0 ;
9510 PyObject * obj3 = 0 ;
9511 PyObject * obj4 = 0 ;
9512 PyObject * obj5 = 0 ;
9513 PyObject * obj6 = 0 ;
9514 PyObject * obj7 = 0 ;
9516 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9521 Xlen = PyArray_DIMS( tmp1 )[0];
9522 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9528 Ylen = PyArray_DIMS( tmp2 )[0];
9529 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9536 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9538 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9541 arg4 = PyArray_DIMS( tmp3 )[0];
9542 arg5 = PyArray_DIMS( tmp3 )[1];
9543 size =
sizeof (
PLFLT ) * arg5;
9544 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9545 for ( i = 0; i < arg4; i++ )
9546 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9552 arg6 = (
PLINT)(val6);
9557 arg8 = PyArray_DIMS( tmp7 )[0];
9558 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9564 arg9 = (
PLINT)(val9);
9567 if ( tmp10 == NULL )
9569 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9570 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9574 if ( tmp12 == NULL )
9576 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9578 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9581 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9583 plsurf3dl((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
9630 PyObject *resultobj = 0;
9631 int *arg1 = (
int *) 0 ;
9632 char **arg2 = (
char **) 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9641 if (!PyArg_ParseTuple(args,(
char *)
"OO:plparseopts",&obj0,&obj1))
SWIG_fail;
9644 if ( !PyList_Check( obj0 ) )
9646 PyErr_SetString( PyExc_ValueError,
"Expecting a list" );
9649 tmp1 = PyList_Size( obj0 );
9651 arg2 = (
char **) malloc( ( tmp1 + 1 ) *
sizeof (
char * ) );
9652 for ( i = 0; i < tmp1; i++ )
9654 PyObject *s = PyList_GetItem( obj0, i );
9655 if ( !PyString_Check( s ) )
9658 PyErr_SetString( PyExc_ValueError,
"List items must be strings" );
9661 arg2[i] = PyString_AsString( s );
9669 arg3 = (
PLINT)(val3);
9687 PyObject *resultobj = 0;
9689 PLINT *arg2 = (PLINT *) 0 ;
9690 PLINT *arg3 = (PLINT *) 0 ;
9691 PyArrayObject *tmp1 ;
9692 PyArrayObject *tmp3 ;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9696 if (!PyArg_ParseTuple(args,(
char *)
"OO:plpat",&obj0,&obj1))
SWIG_fail;
9701 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9702 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9708 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9710 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9713 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9715 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
9736 PyObject *resultobj = 0;
9738 PLFLT *arg2 = (PLFLT *) 0 ;
9739 PLFLT *arg3 = (PLFLT *) 0 ;
9741 PyArrayObject *tmp1 ;
9742 PyArrayObject *tmp3 ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 PyObject * obj2 = 0 ;
9749 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plpoin",&obj0,&obj1,&obj2))
SWIG_fail;
9754 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9755 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9761 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9763 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9766 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9772 arg4 = (
PLINT)(val4);
9773 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
9794 PyObject *resultobj = 0;
9796 PLFLT *arg2 = (PLFLT *) 0 ;
9797 PLFLT *arg3 = (PLFLT *) 0 ;
9798 PLFLT *arg4 = (PLFLT *) 0 ;
9800 PyArrayObject *tmp1 ;
9801 PyArrayObject *tmp3 ;
9802 PyArrayObject *tmp4 ;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 PyObject * obj2 = 0 ;
9808 PyObject * obj3 = 0 ;
9810 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
9815 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9816 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9822 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9824 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9827 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9833 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
9835 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9838 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9844 arg5 = (
PLINT)(val5);
9845 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
9872 PyObject *resultobj = 0;
9874 PLFLT *arg2 = (PLFLT *) 0 ;
9875 PLFLT *arg3 = (PLFLT *) 0 ;
9876 PLFLT *arg4 = (PLFLT *) 0 ;
9879 PyArrayObject *tmp1 ;
9880 PyArrayObject *tmp3 ;
9881 PyArrayObject *tmp4 ;
9882 PyArrayObject *tmp5 ;
9885 PyObject * obj0 = 0 ;
9886 PyObject * obj1 = 0 ;
9887 PyObject * obj2 = 0 ;
9888 PyObject * obj3 = 0 ;
9889 PyObject * obj4 = 0 ;
9891 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9896 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9897 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9903 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9905 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9908 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9914 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
9916 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9919 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9925 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9927 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
9930 arg5 = (PLINT *) PyArray_DATA( tmp5 );
9937 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
9970 PyObject *resultobj = 0;
9977 PyObject * obj0 = 0 ;
9978 PyObject * obj1 = 0 ;
9980 if (!PyArg_ParseTuple(args,(
char *)
"OO:plprec",&obj0,&obj1))
SWIG_fail;
9985 arg1 = (
PLINT)(val1);
9990 arg2 = (
PLINT)(val2);
10000 PyObject *resultobj = 0;
10004 PyObject * obj0 = 0 ;
10006 if (!PyArg_ParseTuple(args,(
char *)
"O:plpsty",&obj0))
SWIG_fail;
10011 arg1 = (
PLINT)(val1);
10021 PyObject *resultobj = 0;
10027 char *arg6 = (
char *) 0 ;
10041 PyObject * obj0 = 0 ;
10042 PyObject * obj1 = 0 ;
10043 PyObject * obj2 = 0 ;
10044 PyObject * obj3 = 0 ;
10045 PyObject * obj4 = 0 ;
10046 PyObject * obj5 = 0 ;
10048 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10053 arg1 = (
PLFLT)(val1);
10058 arg2 = (
PLFLT)(val2);
10063 arg3 = (
PLFLT)(val3);
10068 arg4 = (
PLFLT)(val4);
10073 arg5 = (
PLFLT)(val5);
10078 arg6 = (
char *)(buf6);
10079 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
10090 PyObject *resultobj = 0;
10101 char *arg11 = (
char *) 0 ;
10125 PyObject * obj0 = 0 ;
10126 PyObject * obj1 = 0 ;
10127 PyObject * obj2 = 0 ;
10128 PyObject * obj3 = 0 ;
10129 PyObject * obj4 = 0 ;
10130 PyObject * obj5 = 0 ;
10131 PyObject * obj6 = 0 ;
10132 PyObject * obj7 = 0 ;
10133 PyObject * obj8 = 0 ;
10134 PyObject * obj9 = 0 ;
10135 PyObject * obj10 = 0 ;
10137 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
10142 arg1 = (
PLFLT)(val1);
10147 arg2 = (
PLFLT)(val2);
10152 arg3 = (
PLFLT)(val3);
10157 arg4 = (
PLFLT)(val4);
10162 arg5 = (
PLFLT)(val5);
10167 arg6 = (
PLFLT)(val6);
10172 arg7 = (
PLFLT)(val7);
10177 arg8 = (
PLFLT)(val8);
10182 arg9 = (
PLFLT)(val9);
10187 arg10 = (
PLFLT)(val10);
10192 arg11 = (
char *)(buf11);
10193 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
10204 PyObject *resultobj = 0;
10207 if (!PyArg_ParseTuple(args,(
char *)
":plrandd"))
SWIG_fail;
10217 PyObject *resultobj = 0;
10219 if (!PyArg_ParseTuple(args,(
char *)
":plreplot"))
SWIG_fail;
10229 PyObject *resultobj = 0;
10233 PLFLT *arg4 = (PLFLT *) 0 ;
10234 PLFLT *arg5 = (PLFLT *) 0 ;
10235 PLFLT *arg6 = (PLFLT *) 0 ;
10248 PyObject * obj0 = 0 ;
10249 PyObject * obj1 = 0 ;
10250 PyObject * obj2 = 0 ;
10255 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plrgbhls",&obj0,&obj1,&obj2))
SWIG_fail;
10260 arg1 = (
PLFLT)(val1);
10265 arg2 = (
PLFLT)(val2);
10270 arg3 = (
PLFLT)(val3);
10271 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10298 PyObject *resultobj = 0;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10308 if (!PyArg_ParseTuple(args,(
char *)
"OO:plschr",&obj0,&obj1))
SWIG_fail;
10313 arg1 = (
PLFLT)(val1);
10318 arg2 = (
PLFLT)(val2);
10328 PyObject *resultobj = 0;
10329 PLINT *arg1 = (PLINT *) 0 ;
10330 PLINT *arg2 = (PLINT *) 0 ;
10331 PLINT *arg3 = (PLINT *) 0 ;
10333 PyArrayObject *tmp1 ;
10334 PyArrayObject *tmp2 ;
10335 PyArrayObject *tmp3 ;
10336 PyObject * obj0 = 0 ;
10337 PyObject * obj1 = 0 ;
10338 PyObject * obj2 = 0 ;
10340 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap0",&obj0,&obj1,&obj2))
SWIG_fail;
10343 if ( tmp1 == NULL )
10345 Alen = PyArray_DIMS( tmp1 )[0];
10346 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10350 if ( tmp2 == NULL )
10352 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10354 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10357 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10361 if ( tmp3 == NULL )
10363 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10365 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10368 arg4 = PyArray_DIMS( tmp3 )[0];
10369 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10371 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10398 PyObject *resultobj = 0;
10399 PLINT *arg1 = (PLINT *) 0 ;
10400 PLINT *arg2 = (PLINT *) 0 ;
10401 PLINT *arg3 = (PLINT *) 0 ;
10402 PLFLT *arg4 = (PLFLT *) 0 ;
10404 PyArrayObject *tmp1 ;
10405 PyArrayObject *tmp2 ;
10406 PyArrayObject *tmp3 ;
10407 PyArrayObject *tmp4 ;
10408 PyObject * obj0 = 0 ;
10409 PyObject * obj1 = 0 ;
10410 PyObject * obj2 = 0 ;
10411 PyObject * obj3 = 0 ;
10413 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10416 if ( tmp1 == NULL )
10418 Alen = PyArray_DIMS( tmp1 )[0];
10419 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10423 if ( tmp2 == NULL )
10425 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10427 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10430 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10434 if ( tmp3 == NULL )
10436 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10438 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10441 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10445 if ( tmp4 == NULL )
10447 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10449 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10452 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10453 arg5 = PyArray_DIMS( tmp4 )[0];
10455 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10488 PyObject *resultobj = 0;
10492 PyObject * obj0 = 0 ;
10494 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap0n",&obj0))
SWIG_fail;
10499 arg1 = (
PLINT)(val1);
10509 PyObject *resultobj = 0;
10510 PLINT *arg1 = (PLINT *) 0 ;
10511 PLINT *arg2 = (PLINT *) 0 ;
10512 PLINT *arg3 = (PLINT *) 0 ;
10514 PyArrayObject *tmp1 ;
10515 PyArrayObject *tmp2 ;
10516 PyArrayObject *tmp3 ;
10517 PyObject * obj0 = 0 ;
10518 PyObject * obj1 = 0 ;
10519 PyObject * obj2 = 0 ;
10521 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap1",&obj0,&obj1,&obj2))
SWIG_fail;
10524 if ( tmp1 == NULL )
10526 Alen = PyArray_DIMS( tmp1 )[0];
10527 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10531 if ( tmp2 == NULL )
10533 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10535 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10538 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10542 if ( tmp3 == NULL )
10544 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10546 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10549 arg4 = PyArray_DIMS( tmp3 )[0];
10550 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10552 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10579 PyObject *resultobj = 0;
10580 PLINT *arg1 = (PLINT *) 0 ;
10581 PLINT *arg2 = (PLINT *) 0 ;
10582 PLINT *arg3 = (PLINT *) 0 ;
10583 PLFLT *arg4 = (PLFLT *) 0 ;
10585 PyArrayObject *tmp1 ;
10586 PyArrayObject *tmp2 ;
10587 PyArrayObject *tmp3 ;
10588 PyArrayObject *tmp4 ;
10589 PyObject * obj0 = 0 ;
10590 PyObject * obj1 = 0 ;
10591 PyObject * obj2 = 0 ;
10592 PyObject * obj3 = 0 ;
10594 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10597 if ( tmp1 == NULL )
10599 Alen = PyArray_DIMS( tmp1 )[0];
10600 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10604 if ( tmp2 == NULL )
10606 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10608 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10611 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10615 if ( tmp3 == NULL )
10617 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10619 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10622 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10626 if ( tmp4 == NULL )
10628 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10630 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10633 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10634 arg5 = PyArray_DIMS( tmp4 )[0];
10636 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10669 PyObject *resultobj = 0;
10672 PLFLT *arg3 = (PLFLT *) 0 ;
10673 PLFLT *arg4 = (PLFLT *) 0 ;
10674 PLFLT *arg5 = (PLFLT *) 0 ;
10675 PLFLT *arg6 = (PLFLT *) 0 ;
10679 PyArrayObject *tmp2 ;
10680 PyArrayObject *tmp4 ;
10681 PyArrayObject *tmp5 ;
10682 PyArrayObject *tmp6 ;
10683 PyArrayObject *tmp7 ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 PyObject * obj2 = 0 ;
10687 PyObject * obj3 = 0 ;
10688 PyObject * obj4 = 0 ;
10689 PyObject * obj5 = 0 ;
10691 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10699 if ( tmp2 == NULL )
10701 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10702 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10706 if ( tmp4 == NULL )
10708 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10710 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10713 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10717 if ( tmp5 == NULL )
10719 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10721 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10724 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10728 if ( tmp6 == NULL )
10730 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10732 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10735 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10739 if ( tmp7 == NULL )
10741 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10743 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10746 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10748 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
10787 PyObject *resultobj = 0;
10790 PLFLT *arg3 = (PLFLT *) 0 ;
10791 PLFLT *arg4 = (PLFLT *) 0 ;
10792 PLFLT *arg5 = (PLFLT *) 0 ;
10793 PLFLT *arg6 = (PLFLT *) 0 ;
10794 PLFLT *arg7 = (PLFLT *) 0 ;
10798 PyArrayObject *tmp2 ;
10799 PyArrayObject *tmp4 ;
10800 PyArrayObject *tmp5 ;
10801 PyArrayObject *tmp6 ;
10802 PyArrayObject *tmp7 ;
10803 PyArrayObject *tmp8 ;
10804 PyObject * obj0 = 0 ;
10805 PyObject * obj1 = 0 ;
10806 PyObject * obj2 = 0 ;
10807 PyObject * obj3 = 0 ;
10808 PyObject * obj4 = 0 ;
10809 PyObject * obj5 = 0 ;
10810 PyObject * obj6 = 0 ;
10812 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
10820 if ( tmp2 == NULL )
10822 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10823 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10827 if ( tmp4 == NULL )
10829 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10831 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10834 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10838 if ( tmp5 == NULL )
10840 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10842 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10845 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10849 if ( tmp6 == NULL )
10851 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10853 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10856 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10860 if ( tmp7 == NULL )
10862 if ( PyArray_DIMS( tmp7 )[0] !=
Alen )
10864 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10867 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10871 if ( tmp8 == NULL )
10873 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10875 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10878 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10880 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
10925 PyObject *resultobj = 0;
10929 PyObject * obj0 = 0 ;
10931 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap1n",&obj0))
SWIG_fail;
10936 arg1 = (
PLINT)(val1);
10946 PyObject *resultobj = 0;
10953 PyObject * obj0 = 0 ;
10954 PyObject * obj1 = 0 ;
10956 if (!PyArg_ParseTuple(args,(
char *)
"OO:plscmap1_range",&obj0,&obj1))
SWIG_fail;
10961 arg1 = (
PLFLT)(val1);
10966 arg2 = (
PLFLT)(val2);
10976 PyObject *resultobj = 0;
10977 PLFLT *arg1 = (PLFLT *) 0 ;
10978 PLFLT *arg2 = (PLFLT *) 0 ;
10986 if (!PyArg_ParseTuple(args,(
char *)
":plgcmap1_range"))
SWIG_fail;
11008 PyObject *resultobj = 0;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 PyObject * obj2 = 0 ;
11024 PyObject * obj3 = 0 ;
11026 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11031 arg1 = (
PLINT)(val1);
11036 arg2 = (
PLINT)(val2);
11041 arg3 = (
PLINT)(val3);
11046 arg4 = (
PLINT)(val4);
11047 plscol0(arg1,arg2,arg3,arg4);
11056 PyObject *resultobj = 0;
11072 PyObject * obj0 = 0 ;
11073 PyObject * obj1 = 0 ;
11074 PyObject * obj2 = 0 ;
11075 PyObject * obj3 = 0 ;
11076 PyObject * obj4 = 0 ;
11078 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
11083 arg1 = (
PLINT)(val1);
11088 arg2 = (
PLINT)(val2);
11093 arg3 = (
PLINT)(val3);
11098 arg4 = (
PLINT)(val4);
11103 arg5 = (
PLFLT)(val5);
11104 plscol0a(arg1,arg2,arg3,arg4,arg5);
11113 PyObject *resultobj = 0;
11123 PyObject * obj0 = 0 ;
11124 PyObject * obj1 = 0 ;
11125 PyObject * obj2 = 0 ;
11127 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscolbg",&obj0,&obj1,&obj2))
SWIG_fail;
11132 arg1 = (
PLINT)(val1);
11137 arg2 = (
PLINT)(val2);
11142 arg3 = (
PLINT)(val3);
11152 PyObject *resultobj = 0;
11165 PyObject * obj0 = 0 ;
11166 PyObject * obj1 = 0 ;
11167 PyObject * obj2 = 0 ;
11168 PyObject * obj3 = 0 ;
11170 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11175 arg1 = (
PLINT)(val1);
11180 arg2 = (
PLINT)(val2);
11185 arg3 = (
PLINT)(val3);
11190 arg4 = (
PLFLT)(val4);
11200 PyObject *resultobj = 0;
11204 PyObject * obj0 = 0 ;
11206 if (!PyArg_ParseTuple(args,(
char *)
"O:plscolor",&obj0))
SWIG_fail;
11211 arg1 = (
PLINT)(val1);
11221 PyObject *resultobj = 0;
11225 PyObject * obj0 = 0 ;
11227 if (!PyArg_ParseTuple(args,(
char *)
"O:plscompression",&obj0))
SWIG_fail;
11232 arg1 = (
PLINT)(val1);
11242 PyObject *resultobj = 0;
11243 char *arg1 = (
char *) 0 ;
11247 PyObject * obj0 = 0 ;
11249 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdev",&obj0))
SWIG_fail;
11254 arg1 = (
char *)(buf1);
11255 plsdev((
char const *)arg1);
11266 PyObject *resultobj = 0;
11279 PyObject * obj0 = 0 ;
11280 PyObject * obj1 = 0 ;
11281 PyObject * obj2 = 0 ;
11282 PyObject * obj3 = 0 ;
11284 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11289 arg1 = (
PLFLT)(val1);
11294 arg2 = (
PLFLT)(val2);
11299 arg3 = (
PLFLT)(val3);
11304 arg4 = (
PLFLT)(val4);
11314 PyObject *resultobj = 0;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 PyObject * obj3 = 0 ;
11337 PyObject * obj4 = 0 ;
11338 PyObject * obj5 = 0 ;
11340 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
11345 arg1 = (
PLINT)(val1);
11350 arg2 = (
PLINT)(val2);
11355 arg3 = (
PLINT)(val3);
11360 arg4 = (
PLINT)(val4);
11365 arg5 = (
PLFLT)(val5);
11370 arg6 = (
PLFLT)(val6);
11371 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11380 PyObject *resultobj = 0;
11384 PyObject * obj0 = 0 ;
11386 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdiori",&obj0))
SWIG_fail;
11391 arg1 = (
PLFLT)(val1);
11401 PyObject *resultobj = 0;
11414 PyObject * obj0 = 0 ;
11415 PyObject * obj1 = 0 ;
11416 PyObject * obj2 = 0 ;
11417 PyObject * obj3 = 0 ;
11419 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11424 arg1 = (
PLFLT)(val1);
11429 arg2 = (
PLFLT)(val2);
11434 arg3 = (
PLFLT)(val3);
11439 arg4 = (
PLFLT)(val4);
11449 PyObject *resultobj = 0;
11462 PyObject * obj0 = 0 ;
11463 PyObject * obj1 = 0 ;
11464 PyObject * obj2 = 0 ;
11465 PyObject * obj3 = 0 ;
11467 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11472 arg1 = (
PLFLT)(val1);
11477 arg2 = (
PLFLT)(val2);
11482 arg3 = (
PLFLT)(val3);
11487 arg4 = (
PLFLT)(val4);
11497 PyObject *resultobj = 0;
11498 unsigned int arg1 ;
11499 unsigned int val1 ;
11501 PyObject * obj0 = 0 ;
11503 if (!PyArg_ParseTuple(args,(
char *)
"O:plseed",&obj0))
SWIG_fail;
11508 arg1 = (
unsigned int)(val1);
11518 PyObject *resultobj = 0;
11522 PyObject * obj0 = 0 ;
11524 if (!PyArg_ParseTuple(args,(
char *)
"O:plsesc",&obj0))
SWIG_fail;
11529 arg1 = (char)(val1);
11539 PyObject *resultobj = 0;
11540 char *arg1 = (
char *) 0 ;
11541 char *arg2 = (
char *) 0 ;
11548 PyObject * obj0 = 0 ;
11549 PyObject * obj1 = 0 ;
11552 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsetopt",&obj0,&obj1))
SWIG_fail;
11557 arg1 = (
char *)(buf1);
11562 arg2 = (
char *)(buf2);
11563 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
11576 PyObject *resultobj = 0;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11590 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfam",&obj0,&obj1,&obj2))
SWIG_fail;
11595 arg1 = (
PLINT)(val1);
11600 arg2 = (
PLINT)(val2);
11605 arg3 = (
PLINT)(val3);
11615 PyObject *resultobj = 0;
11617 unsigned int val1 ;
11619 PyObject * obj0 = 0 ;
11621 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfci",&obj0))
SWIG_fail;
11636 PyObject *resultobj = 0;
11637 char *arg1 = (
char *) 0 ;
11641 PyObject * obj0 = 0 ;
11643 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfnam",&obj0))
SWIG_fail;
11648 arg1 = (
char *)(buf1);
11660 PyObject *resultobj = 0;
11670 PyObject * obj0 = 0 ;
11671 PyObject * obj1 = 0 ;
11672 PyObject * obj2 = 0 ;
11674 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfont",&obj0,&obj1,&obj2))
SWIG_fail;
11679 arg1 = (
PLINT)(val1);
11684 arg2 = (
PLINT)(val2);
11689 arg3 = (
PLINT)(val3);
11699 PyObject *resultobj = 0;
11700 PLFLT **arg1 = (PLFLT **) 0 ;
11708 PLFLT *arg9 = (PLFLT *) 0 ;
11717 PyArrayObject *tmp1 ;
11726 PyArrayObject *tmp9 ;
11735 PyObject * obj0 = 0 ;
11736 PyObject * obj1 = 0 ;
11737 PyObject * obj2 = 0 ;
11738 PyObject * obj3 = 0 ;
11739 PyObject * obj4 = 0 ;
11740 PyObject * obj5 = 0 ;
11741 PyObject * obj6 = 0 ;
11742 PyObject * obj7 = 0 ;
11743 PyObject * obj8 = 0 ;
11744 PyObject * obj9 = 0 ;
11745 PyObject * obj10 = 0 ;
11746 PyObject * obj11 = 0 ;
11761 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
11765 if ( tmp1 == NULL )
11767 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11768 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11769 size =
sizeof (
PLFLT ) * arg3;
11770 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
11771 for ( i = 0; i < arg2; i++ )
11772 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11778 arg5 = (
PLFLT)(val5);
11783 arg6 = (
PLFLT)(val6);
11788 arg7 = (
PLFLT)(val7);
11793 arg8 = (
PLFLT)(val8);
11796 if ( tmp9 == NULL )
11798 arg10 = PyArray_DIMS( tmp9 )[0];
11799 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11805 arg11 = (
PLFLT)(val11);
11810 arg12 = (
PLINT)(val12);
11815 arg13 = (
PLFLT)(val13);
11820 arg15 = (
PLBOOL)(val15);
11824 if ( obj10 == Py_None )
11830 if ( !PyCallable_Check( (PyObject *) obj10 ) )
11832 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
11841 if ( obj11 == Py_None )
11849 plshades((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(
double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11884 PyObject *resultobj = 0;
11885 PLFLT **arg1 = (PLFLT **) 0 ;
11906 PyArrayObject *tmp1 ;
11935 PyObject * obj0 = 0 ;
11936 PyObject * obj1 = 0 ;
11937 PyObject * obj2 = 0 ;
11938 PyObject * obj3 = 0 ;
11939 PyObject * obj4 = 0 ;
11940 PyObject * obj5 = 0 ;
11941 PyObject * obj6 = 0 ;
11942 PyObject * obj7 = 0 ;
11943 PyObject * obj8 = 0 ;
11944 PyObject * obj9 = 0 ;
11945 PyObject * obj10 = 0 ;
11946 PyObject * obj11 = 0 ;
11947 PyObject * obj12 = 0 ;
11948 PyObject * obj13 = 0 ;
11949 PyObject * obj14 = 0 ;
11950 PyObject * obj15 = 0 ;
11951 PyObject * obj16 = 0 ;
11966 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOOOOO|OO:plshade",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16))
SWIG_fail;
11970 if ( tmp1 == NULL )
11972 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11973 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11974 size =
sizeof (
PLFLT ) * arg3;
11975 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
11976 for ( i = 0; i < arg2; i++ )
11977 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11983 arg5 = (
PLFLT)(val5);
11988 arg6 = (
PLFLT)(val6);
11993 arg7 = (
PLFLT)(val7);
11998 arg8 = (
PLFLT)(val8);
12003 arg9 = (
PLFLT)(val9);
12008 arg10 = (
PLFLT)(val10);
12013 arg11 = (
PLINT)(val11);
12018 arg12 = (
PLFLT)(val12);
12023 arg13 = (
PLFLT)(val13);
12028 arg14 = (
PLINT)(val14);
12033 arg15 = (
PLFLT)(val15);
12038 arg16 = (
PLINT)(val16);
12043 arg17 = (
PLFLT)(val17);
12048 arg19 = (
PLBOOL)(val19);
12052 if ( obj15 == Py_None )
12058 if ( !PyCallable_Check( (PyObject *) obj15 ) )
12060 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
12069 if ( obj16 == Py_None )
12077 plshade((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12106 PyObject *resultobj = 0;
12110 PyObject * obj0 = 0 ;
12111 PyObject * obj1 = 0 ;
12113 if (!PyArg_ParseTuple(args,(
char *)
"OO:plslabelfunc",&obj0,&obj1))
SWIG_fail;
12116 if ( python_label )
12118 Py_XDECREF( python_label );
12122 if ( obj0 == Py_None )
12128 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12130 PyErr_SetString( PyExc_ValueError,
"label_func argument must be callable" );
12134 Py_XINCREF( (PyObject *) obj0 );
12135 python_label = (PyObject *) obj0;
12153 PyObject *resultobj = 0;
12160 PyObject * obj0 = 0 ;
12161 PyObject * obj1 = 0 ;
12163 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmaj",&obj0,&obj1))
SWIG_fail;
12168 arg1 = (
PLFLT)(val1);
12173 arg2 = (
PLFLT)(val2);
12183 PyObject *resultobj = 0;
12186 void *arg3 = (
void *) 0 ;
12194 PyObject * obj0 = 0 ;
12195 PyObject * obj1 = 0 ;
12196 PyObject * obj2 = 0 ;
12198 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmem",&obj0,&obj1,&obj2))
SWIG_fail;
12203 arg1 = (
PLINT)(val1);
12208 arg2 = (
PLINT)(val2);
12210 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12215 arg3 = (
void *) buf3;
12226 PyObject *resultobj = 0;
12229 void *arg3 = (
void *) 0 ;
12237 PyObject * obj0 = 0 ;
12238 PyObject * obj1 = 0 ;
12239 PyObject * obj2 = 0 ;
12241 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmema",&obj0,&obj1,&obj2))
SWIG_fail;
12246 arg1 = (
PLINT)(val1);
12251 arg2 = (
PLINT)(val2);
12253 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12258 arg3 = (
void *) buf3;
12269 PyObject *resultobj = 0;
12276 PyObject * obj0 = 0 ;
12277 PyObject * obj1 = 0 ;
12279 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmin",&obj0,&obj1))
SWIG_fail;
12284 arg1 = (
PLFLT)(val1);
12289 arg2 = (
PLFLT)(val2);
12299 PyObject *resultobj = 0;
12303 PyObject * obj0 = 0 ;
12305 if (!PyArg_ParseTuple(args,(
char *)
"O:plsori",&obj0))
SWIG_fail;
12310 arg1 = (
PLINT)(val1);
12320 PyObject *resultobj = 0;
12339 PyObject * obj0 = 0 ;
12340 PyObject * obj1 = 0 ;
12341 PyObject * obj2 = 0 ;
12342 PyObject * obj3 = 0 ;
12343 PyObject * obj4 = 0 ;
12344 PyObject * obj5 = 0 ;
12346 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
12351 arg1 = (
PLFLT)(val1);
12356 arg2 = (
PLFLT)(val2);
12361 arg3 = (
PLINT)(val3);
12366 arg4 = (
PLINT)(val4);
12371 arg5 = (
PLINT)(val5);
12376 arg6 = (
PLINT)(val6);
12377 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12386 PyObject *resultobj = 0;
12387 char *arg1 = (
char *) 0 ;
12391 PyObject * obj0 = 0 ;
12393 if (!PyArg_ParseTuple(args,(
char *)
"O:plspal0",&obj0))
SWIG_fail;
12398 arg1 = (
char *)(buf1);
12410 PyObject *resultobj = 0;
12411 char *arg1 = (
char *) 0 ;
12418 PyObject * obj0 = 0 ;
12419 PyObject * obj1 = 0 ;
12421 if (!PyArg_ParseTuple(args,(
char *)
"OO:plspal1",&obj0,&obj1))
SWIG_fail;
12426 arg1 = (
char *)(buf1);
12432 plspal1((
char const *)arg1,arg2);
12443 PyObject *resultobj = 0;
12447 PyObject * obj0 = 0 ;
12449 if (!PyArg_ParseTuple(args,(
char *)
"O:plspause",&obj0))
SWIG_fail;
12464 PyObject *resultobj = 0;
12468 PyObject * obj0 = 0 ;
12470 if (!PyArg_ParseTuple(args,(
char *)
"O:plsstrm",&obj0))
SWIG_fail;
12475 arg1 = (
PLINT)(val1);
12485 PyObject *resultobj = 0;
12492 PyObject * obj0 = 0 ;
12493 PyObject * obj1 = 0 ;
12495 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssub",&obj0,&obj1))
SWIG_fail;
12500 arg1 = (
PLINT)(val1);
12505 arg2 = (
PLINT)(val2);
12515 PyObject *resultobj = 0;
12522 PyObject * obj0 = 0 ;
12523 PyObject * obj1 = 0 ;
12525 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssym",&obj0,&obj1))
SWIG_fail;
12530 arg1 = (
PLFLT)(val1);
12535 arg2 = (
PLFLT)(val2);
12545 PyObject *resultobj = 0;
12552 PyObject * obj0 = 0 ;
12553 PyObject * obj1 = 0 ;
12555 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstar",&obj0,&obj1))
SWIG_fail;
12560 arg1 = (
PLINT)(val1);
12565 arg2 = (
PLINT)(val2);
12575 PyObject *resultobj = 0;
12576 char *arg1 = (
char *) 0 ;
12586 PyObject * obj0 = 0 ;
12587 PyObject * obj1 = 0 ;
12588 PyObject * obj2 = 0 ;
12590 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstart",&obj0,&obj1,&obj2))
SWIG_fail;
12595 arg1 = (
char *)(buf1);
12600 arg2 = (
PLINT)(val2);
12605 arg3 = (
PLINT)(val3);
12606 plstart((
char const *)arg1,arg2,arg3);
12617 PyObject *resultobj = 0;
12621 PyObject * obj0 = 0 ;
12622 PyObject * obj1 = 0 ;
12628 if (!PyArg_ParseTuple(args,(
char *)
"|OO:plstransform",&obj0,&obj1))
SWIG_fail;
12634 if ( obj0 == Py_None )
12640 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12642 PyErr_SetString( PyExc_ValueError,
"coordinate transform argument must be callable" );
12664 PyObject *resultobj = 0;
12666 PLFLT *arg2 = (PLFLT *) 0 ;
12667 PLFLT *arg3 = (PLFLT *) 0 ;
12668 char *arg4 = (
char *) 0 ;
12669 PyArrayObject *tmp1 ;
12670 PyArrayObject *tmp3 ;
12674 PyObject * obj0 = 0 ;
12675 PyObject * obj1 = 0 ;
12676 PyObject * obj2 = 0 ;
12678 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstring",&obj0,&obj1,&obj2))
SWIG_fail;
12681 if ( tmp1 == NULL )
12683 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12684 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12688 if ( tmp3 == NULL )
12690 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12692 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12695 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12701 arg4 = (
char *)(buf4);
12702 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
12725 PyObject *resultobj = 0;
12727 PLFLT *arg2 = (PLFLT *) 0 ;
12728 PLFLT *arg3 = (PLFLT *) 0 ;
12729 PLFLT *arg4 = (PLFLT *) 0 ;
12730 char *arg5 = (
char *) 0 ;
12731 PyArrayObject *tmp1 ;
12732 PyArrayObject *tmp3 ;
12733 PyArrayObject *tmp4 ;
12737 PyObject * obj0 = 0 ;
12738 PyObject * obj1 = 0 ;
12739 PyObject * obj2 = 0 ;
12740 PyObject * obj3 = 0 ;
12742 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12745 if ( tmp1 == NULL )
12747 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12748 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12752 if ( tmp3 == NULL )
12754 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12756 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12759 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12763 if ( tmp4 == NULL )
12765 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
12767 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12770 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12776 arg5 = (
char *)(buf5);
12777 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
12806 PyObject *resultobj = 0;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 PyObject * obj2 = 0 ;
12822 PyObject * obj3 = 0 ;
12824 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12829 arg1 = (
PLINT)(val1);
12834 arg2 = (
PLINT)(val2);
12839 arg3 = (
PLFLT)(val3);
12844 arg4 = (
PLFLT)(val4);
12854 PyObject *resultobj = 0;
12855 PLINT *arg1 = (PLINT *) 0 ;
12856 char *arg2 = (
char *) 0 ;
12857 char *arg3 = (
char *) 0 ;
12869 PLINT *arg15 = (PLINT *) 0 ;
12870 PLINT *arg16 = (PLINT *) 0 ;
12872 char *arg18 = (
char *) 0 ;
12873 char *arg19 = (
char *) 0 ;
12874 char *arg20 = (
char *) 0 ;
12905 PyArrayObject *tmp15 ;
12906 PyArrayObject *tmp16 ;
12916 PyObject * obj0 = 0 ;
12917 PyObject * obj1 = 0 ;
12918 PyObject * obj2 = 0 ;
12919 PyObject * obj3 = 0 ;
12920 PyObject * obj4 = 0 ;
12921 PyObject * obj5 = 0 ;
12922 PyObject * obj6 = 0 ;
12923 PyObject * obj7 = 0 ;
12924 PyObject * obj8 = 0 ;
12925 PyObject * obj9 = 0 ;
12926 PyObject * obj10 = 0 ;
12927 PyObject * obj11 = 0 ;
12928 PyObject * obj12 = 0 ;
12929 PyObject * obj13 = 0 ;
12930 PyObject * obj14 = 0 ;
12931 PyObject * obj15 = 0 ;
12932 PyObject * obj16 = 0 ;
12933 PyObject * obj17 = 0 ;
12934 PyObject * obj18 = 0 ;
12937 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOOOOOOOOO:plstripc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18))
SWIG_fail;
12942 arg2 = (
char *)(buf2);
12947 arg3 = (
char *)(buf3);
12952 arg4 = (
PLFLT)(val4);
12957 arg5 = (
PLFLT)(val5);
12962 arg6 = (
PLFLT)(val6);
12967 arg7 = (
PLFLT)(val7);
12972 arg8 = (
PLFLT)(val8);
12977 arg9 = (
PLFLT)(val9);
12982 arg10 = (
PLFLT)(val10);
12987 arg11 = (
PLBOOL)(val11);
12992 arg12 = (
PLBOOL)(val12);
12997 arg13 = (
PLINT)(val13);
13002 arg14 = (
PLINT)(val14);
13005 if ( tmp15 == NULL )
13007 Alen = PyArray_DIMS( tmp15 )[0];
13008 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13012 if ( tmp16 == NULL )
13014 if ( PyArray_DIMS( tmp16 )[0] !=
Alen )
13016 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13019 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13025 PyErr_SetString( PyExc_ValueError,
"Requires a sequence of 4 strings." );
13030 PyErr_SetString( PyExc_ValueError,
"colline and styline args must be length 4." );
13033 arg17 = malloc(
sizeof (
char* ) * 4 );
13034 for ( i = 0; i < 4; i++ )
13037 if ( arg17[i] == NULL )
13048 arg18 = (
char *)(buf18);
13053 arg19 = (
char *)(buf19);
13058 arg20 = (
char *)(buf20);
13059 plstripc(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(
int const *)arg15,(
int const *)arg16,(
char const *(*))arg17,(
char const *)arg18,(
char const *)arg19,(
char const *)arg20);
13070 Py_DECREF( tmp15 );
13073 Py_DECREF( tmp16 );
13086 Py_DECREF( tmp15 );
13089 Py_DECREF( tmp16 );
13102 PyObject *resultobj = 0;
13106 PyObject * obj0 = 0 ;
13108 if (!PyArg_ParseTuple(args,(
char *)
"O:plstripd",&obj0))
SWIG_fail;
13113 arg1 = (
PLINT)(val1);
13123 PyObject *resultobj = 0;
13125 PLINT *arg2 = (PLINT *) 0 ;
13126 PLINT *arg3 = (PLINT *) 0 ;
13127 PyArrayObject *tmp1 ;
13128 PyArrayObject *tmp3 ;
13129 PyObject * obj0 = 0 ;
13130 PyObject * obj1 = 0 ;
13132 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstyl",&obj0,&obj1))
SWIG_fail;
13135 if ( tmp1 == NULL )
13137 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13138 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13142 if ( tmp3 == NULL )
13144 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13146 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13149 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13151 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
13172 PyObject *resultobj = 0;
13173 PLFLT *arg1 = (PLFLT *) 0 ;
13174 PLFLT *arg2 = (PLFLT *) 0 ;
13177 PyArrayObject *tmp1 ;
13178 PyArrayObject *tmp2 ;
13181 PyObject * obj0 = 0 ;
13182 PyObject * obj1 = 0 ;
13183 PyObject * obj2 = 0 ;
13185 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsvect",&obj0,&obj1,&obj2))
SWIG_fail;
13188 if ( tmp1 == NULL )
13190 Alen = PyArray_DIMS( tmp1 )[0];
13191 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13195 if ( tmp2 == NULL )
13197 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
13199 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13202 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13203 arg3 = PyArray_DIMS( tmp2 )[0];
13210 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
13231 PyObject *resultobj = 0;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 PyObject * obj2 = 0 ;
13247 PyObject * obj3 = 0 ;
13249 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13254 arg1 = (
PLFLT)(val1);
13259 arg2 = (
PLFLT)(val2);
13264 arg3 = (
PLFLT)(val3);
13269 arg4 = (
PLFLT)(val4);
13270 plsvpa(arg1,arg2,arg3,arg4);
13279 PyObject *resultobj = 0;
13286 PyObject * obj0 = 0 ;
13287 PyObject * obj1 = 0 ;
13289 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsxax",&obj0,&obj1))
SWIG_fail;
13294 arg1 = (
PLINT)(val1);
13299 arg2 = (
PLINT)(val2);
13309 PyObject *resultobj = 0;
13316 PyObject * obj0 = 0 ;
13317 PyObject * obj1 = 0 ;
13319 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsyax",&obj0,&obj1))
SWIG_fail;
13324 arg1 = (
PLINT)(val1);
13329 arg2 = (
PLINT)(val2);
13339 PyObject *resultobj = 0;
13341 PLFLT *arg2 = (PLFLT *) 0 ;
13342 PLFLT *arg3 = (PLFLT *) 0 ;
13344 PyArrayObject *tmp1 ;
13345 PyArrayObject *tmp3 ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 PyObject * obj2 = 0 ;
13352 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsym",&obj0,&obj1,&obj2))
SWIG_fail;
13355 if ( tmp1 == NULL )
13357 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13358 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13362 if ( tmp3 == NULL )
13364 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13366 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13369 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13375 arg4 = (
PLINT)(val4);
13376 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
13397 PyObject *resultobj = 0;
13404 PyObject * obj0 = 0 ;
13405 PyObject * obj1 = 0 ;
13407 if (!PyArg_ParseTuple(args,(
char *)
"OO:plszax",&obj0,&obj1))
SWIG_fail;
13412 arg1 = (
PLINT)(val1);
13417 arg2 = (
PLINT)(val2);
13427 PyObject *resultobj = 0;
13429 if (!PyArg_ParseTuple(args,(
char *)
":pltext"))
SWIG_fail;
13439 PyObject *resultobj = 0;
13440 char *arg1 = (
char *) 0 ;
13444 PyObject * obj0 = 0 ;
13446 if (!PyArg_ParseTuple(args,(
char *)
"O:pltimefmt",&obj0))
SWIG_fail;
13451 arg1 = (
char *)(buf1);
13463 PyObject *resultobj = 0;
13467 PyObject * obj0 = 0 ;
13469 if (!PyArg_ParseTuple(args,(
char *)
"O:plvasp",&obj0))
SWIG_fail;
13474 arg1 = (
PLFLT)(val1);
13484 PyObject *resultobj = 0;
13485 PLFLT **arg1 = (PLFLT **) 0 ;
13486 PLFLT **arg2 = (PLFLT **) 0 ;
13492 PyArrayObject *tmp1 ;
13493 PyArrayObject *tmp2 ;
13496 PyObject * obj0 = 0 ;
13497 PyObject * obj1 = 0 ;
13498 PyObject * obj2 = 0 ;
13499 PyObject * obj3 = 0 ;
13500 PyObject * obj4 = 0 ;
13509 if (!PyArg_ParseTuple(args,(
char *)
"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13513 if ( tmp1 == NULL )
13515 Xlen = PyArray_DIMS( tmp1 )[0];
13516 Ylen = PyArray_DIMS( tmp1 )[1];
13518 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) *
Xlen );
13519 for ( i = 0; i <
Xlen; i++ )
13520 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
13525 if ( tmp2 == NULL )
13527 if ( Xlen != PyArray_DIMS( tmp2 )[0] ||
Ylen != PyArray_DIMS( tmp2 )[1] )
13529 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
13532 arg3 = PyArray_DIMS( tmp2 )[0];
13533 arg4 = PyArray_DIMS( tmp2 )[1];
13534 size =
sizeof (
PLFLT ) * arg4;
13535 arg2 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg3 );
13536 for ( i = 0; i < arg3; i++ )
13537 arg2[i] = (PLFLT *) ( PyArray_DATA( tmp2 ) + i * size );
13543 arg5 = (
PLFLT)(val5);
13547 if ( obj3 == Py_None )
13553 if ( !PyCallable_Check( (PyObject *) obj3 ) )
13555 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
13564 if ( obj4 == Py_None )
13572 plvect((
double const **)arg1,(
double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13609 PyObject *resultobj = 0;
13625 PyObject * obj0 = 0 ;
13626 PyObject * obj1 = 0 ;
13627 PyObject * obj2 = 0 ;
13628 PyObject * obj3 = 0 ;
13629 PyObject * obj4 = 0 ;
13631 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13636 arg1 = (
PLFLT)(val1);
13641 arg2 = (
PLFLT)(val2);
13646 arg3 = (
PLFLT)(val3);
13651 arg4 = (
PLFLT)(val4);
13656 arg5 = (
PLFLT)(val5);
13657 plvpas(arg1,arg2,arg3,arg4,arg5);
13666 PyObject *resultobj = 0;
13679 PyObject * obj0 = 0 ;
13680 PyObject * obj1 = 0 ;
13681 PyObject * obj2 = 0 ;
13682 PyObject * obj3 = 0 ;
13684 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13689 arg1 = (
PLFLT)(val1);
13694 arg2 = (
PLFLT)(val2);
13699 arg3 = (
PLFLT)(val3);
13704 arg4 = (
PLFLT)(val4);
13705 plvpor(arg1,arg2,arg3,arg4);
13714 PyObject *resultobj = 0;
13716 if (!PyArg_ParseTuple(args,(
char *)
":plvsta"))
SWIG_fail;
13726 PyObject *resultobj = 0;
13760 PyObject * obj0 = 0 ;
13761 PyObject * obj1 = 0 ;
13762 PyObject * obj2 = 0 ;
13763 PyObject * obj3 = 0 ;
13764 PyObject * obj4 = 0 ;
13765 PyObject * obj5 = 0 ;
13766 PyObject * obj6 = 0 ;
13767 PyObject * obj7 = 0 ;
13768 PyObject * obj8 = 0 ;
13769 PyObject * obj9 = 0 ;
13770 PyObject * obj10 = 0 ;
13772 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
13777 arg1 = (
PLFLT)(val1);
13782 arg2 = (
PLFLT)(val2);
13787 arg3 = (
PLFLT)(val3);
13792 arg4 = (
PLFLT)(val4);
13797 arg5 = (
PLFLT)(val5);
13802 arg6 = (
PLFLT)(val6);
13807 arg7 = (
PLFLT)(val7);
13812 arg8 = (
PLFLT)(val8);
13817 arg9 = (
PLFLT)(val9);
13822 arg10 = (
PLFLT)(val10);
13827 arg11 = (
PLFLT)(val11);
13828 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13837 PyObject *resultobj = 0;
13841 PyObject * obj0 = 0 ;
13843 if (!PyArg_ParseTuple(args,(
char *)
"O:plwidth",&obj0))
SWIG_fail;
13848 arg1 = (
PLINT)(val1);
13858 PyObject *resultobj = 0;
13871 PyObject * obj0 = 0 ;
13872 PyObject * obj1 = 0 ;
13873 PyObject * obj2 = 0 ;
13874 PyObject * obj3 = 0 ;
13876 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plwind",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13881 arg1 = (
PLFLT)(val1);
13886 arg2 = (
PLFLT)(val2);
13891 arg3 = (
PLFLT)(val3);
13896 arg4 = (
PLFLT)(val4);
13897 plwind(arg1,arg2,arg3,arg4);
13906 PyObject *resultobj = 0;
13913 PyObject * obj0 = 0 ;
13916 if (!PyArg_ParseTuple(args,(
char *)
"O:plxormod",&obj0))
SWIG_fail;
13937 PyObject *resultobj = 0;
13939 char *arg2 = (
char *) 0 ;
13955 PyObject * obj0 = 0 ;
13956 PyObject * obj1 = 0 ;
13957 PyObject * obj2 = 0 ;
13958 PyObject * obj3 = 0 ;
13959 PyObject * obj4 = 0 ;
13960 PyObject * obj5 = 0 ;
13963 python_mapform = 0;
13966 if (!PyArg_ParseTuple(args,(
char *)
"|OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
13970 if ( obj0 == Py_None )
13976 if ( !PyCallable_Check( (PyObject *) obj0 ) )
13978 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
13990 arg2 = (
char *)(buf2);
13997 arg3 = (
PLFLT)(val3);
14004 arg4 = (
PLFLT)(val4);
14011 arg5 = (
PLFLT)(val5);
14018 arg6 = (
PLFLT)(val6);
14020 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
14037 PyObject *resultobj = 0;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 PyObject * obj2 = 0 ;
14060 PyObject * obj3 = 0 ;
14061 PyObject * obj4 = 0 ;
14062 PyObject * obj5 = 0 ;
14063 PyObject * obj6 = 0 ;
14066 python_mapform = 0;
14069 if (!PyArg_ParseTuple(args,(
char *)
"|OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14073 if ( obj0 == Py_None )
14079 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14081 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14093 arg2 = (
PLFLT)(val2);
14100 arg3 = (
PLFLT)(val3);
14107 arg4 = (
PLFLT)(val4);
14114 arg5 = (
PLFLT)(val5);
14121 arg6 = (
PLFLT)(val6);
14128 arg7 = (
PLFLT)(val7);
14145 PyObject *resultobj = 0;
14146 PLFLT **arg1 = (PLFLT **) 0 ;
14159 PyArrayObject *tmp1 ;
14180 PyObject * obj0 = 0 ;
14181 PyObject * obj1 = 0 ;
14182 PyObject * obj2 = 0 ;
14183 PyObject * obj3 = 0 ;
14184 PyObject * obj4 = 0 ;
14185 PyObject * obj5 = 0 ;
14186 PyObject * obj6 = 0 ;
14187 PyObject * obj7 = 0 ;
14188 PyObject * obj8 = 0 ;
14189 PyObject * obj9 = 0 ;
14190 PyObject * obj10 = 0 ;
14192 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14196 if ( tmp1 == NULL )
14198 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14199 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14200 size =
sizeof (
PLFLT ) * arg3;
14201 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
14202 for ( i = 0; i < arg2; i++ )
14203 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14209 arg4 = (
PLFLT)(val4);
14214 arg5 = (
PLFLT)(val5);
14219 arg6 = (
PLFLT)(val6);
14224 arg7 = (
PLFLT)(val7);
14229 arg8 = (
PLFLT)(val8);
14234 arg9 = (
PLFLT)(val9);
14239 arg10 = (
PLFLT)(val10);
14244 arg11 = (
PLFLT)(val11);
14249 arg12 = (
PLFLT)(val12);
14254 arg13 = (
PLFLT)(val13);
14255 plimage((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14272 PyObject *resultobj = 0;
14273 PLFLT **arg1 = (PLFLT **) 0 ;
14286 PyArrayObject *tmp1 ;
14303 PyObject * obj0 = 0 ;
14304 PyObject * obj1 = 0 ;
14305 PyObject * obj2 = 0 ;
14306 PyObject * obj3 = 0 ;
14307 PyObject * obj4 = 0 ;
14308 PyObject * obj5 = 0 ;
14309 PyObject * obj6 = 0 ;
14310 PyObject * obj7 = 0 ;
14311 PyObject * obj8 = 0 ;
14312 PyObject * obj9 = 0 ;
14313 PyObject * obj10 = 0 ;
14322 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14326 if ( tmp1 == NULL )
14328 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14329 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14330 size =
sizeof (
PLFLT ) * arg3;
14331 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
14332 for ( i = 0; i < arg2; i++ )
14333 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14339 arg4 = (
PLFLT)(val4);
14344 arg5 = (
PLFLT)(val5);
14349 arg6 = (
PLFLT)(val6);
14354 arg7 = (
PLFLT)(val7);
14359 arg8 = (
PLFLT)(val8);
14364 arg9 = (
PLFLT)(val9);
14369 arg10 = (
PLFLT)(val10);
14374 arg11 = (
PLFLT)(val11);
14378 if ( obj9 == Py_None )
14384 if ( !PyCallable_Check( (PyObject *) obj9 ) )
14386 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
14395 if ( obj10 == Py_None )
14403 plimagefr((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14432 PyObject *resultobj = 0;
14434 if (!PyArg_ParseTuple(args,(
char *)
":plClearOpts"))
SWIG_fail;
14444 PyObject *resultobj = 0;
14446 if (!PyArg_ParseTuple(args,(
char *)
":plResetOpts"))
SWIG_fail;
14456 PyObject *resultobj = 0;
14457 char *arg1 = (
char *) 0 ;
14458 char *arg2 = (
char *) 0 ;
14465 PyObject * obj0 = 0 ;
14466 PyObject * obj1 = 0 ;
14468 if (!PyArg_ParseTuple(args,(
char *)
"OO:plSetUsage",&obj0,&obj1))
SWIG_fail;
14473 arg1 = (
char *)(buf1);
14478 arg2 = (
char *)(buf2);
14479 plSetUsage((
char const *)arg1,(
char const *)arg2);
14492 PyObject *resultobj = 0;
14494 if (!PyArg_ParseTuple(args,(
char *)
":plOptUsage"))
SWIG_fail;
14504 PyObject *resultobj = 0;
14505 PLFLT **arg1 = (PLFLT **) 0 ;
14508 PLFLT *arg4 = (PLFLT *) 0 ;
14509 PLFLT *arg5 = (PLFLT *) 0 ;
14510 PyArrayObject *tmp1 ;
14515 PyObject * obj0 = 0 ;
14519 if (!PyArg_ParseTuple(args,(
char *)
"O:plMinMax2dGrid",&obj0))
SWIG_fail;
14523 if ( tmp1 == NULL )
14525 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14526 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14527 size =
sizeof (
PLFLT ) * arg3;
14528 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
14529 for ( i = 0; i < arg2; i++ )
14530 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14561 PyObject *resultobj = 0;
14565 PyObject * obj0 = 0 ;
14568 if (!PyArg_ParseTuple(args,(
char *)
"O:plGetCursor",&obj0))
SWIG_fail;
14584 { (
char *)
"pltr0",
_wrap_pltr0, METH_VARARGS, NULL},
14585 { (
char *)
"pltr1",
_wrap_pltr1, METH_VARARGS, NULL},
14586 { (
char *)
"pltr2",
_wrap_pltr2, METH_VARARGS, NULL},
14616 "Set format of numerical label for contours\n"
14620 " Set format of numerical label for contours. \n"
14622 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14624 " This function is used example 9. \n"
14630 "pl_setcontlabelformat(lexp, sigdig)\n"
14634 " lexp (PLINT, input) : If the contour numerical label is greater\n"
14635 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14636 " format is used. Default value of lexp is 4. \n"
14638 " sigdig (PLINT, input) : Number of significant digits. Default\n"
14643 "Set parameters of contour labelling other than format of numerical label\n"
14647 " Set parameters of contour labelling other than those handled by\n"
14648 " pl_setcontlabelformat. \n"
14650 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14652 " This function is used in example 9. \n"
14658 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14662 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14663 " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
14665 " size (PLFLT, input) : Font height for contour labels (normalized). \n"
14666 " Default value is 0.3. \n"
14668 " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
14669 " Default value is 0.1. \n"
14671 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14672 " contour labels on. Default is off (0). \n"
14675 { (
char *)
"pladv",
_wrap_pladv, METH_VARARGS, (
char *)
"\n"
14676 "Advance the (sub-)page\n"
14680 " Advances to the next subpage if sub=0, performing a page advance if\n"
14681 " there are no remaining subpages on the current page. If subpages\n"
14682 " aren't being used, pladv(0) will always advance the page. If sub>0,\n"
14683 " PLplot switches to the specified subpage. Note that this allows you\n"
14684 " to overwrite a plot on the specified subpage; if this is not what you\n"
14685 " intended, use pleop followed by plbop to first advance the page. This\n"
14686 " routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14687 " not used, pladv must be called after initializing PLplot but before\n"
14688 " defining the viewport. \n"
14690 " Redacted form: pladv(sub)\n"
14692 " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14702 " sub (PLINT, input) : Specifies the subpage number (starting from 1\n"
14703 " in the top left corner and increasing along the rows) to which to\n"
14704 " advance. Set to zero to advance to the next subpage. \n"
14707 { (
char *)
"plarc",
_wrap_plarc, METH_VARARGS, (
char *)
"\n"
14708 "Draw a circular or elliptical arc \n"
14712 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14713 " semiminor axis b, starting at angle1 and ending at angle2. \n"
14715 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14719 " This function is used in examples 3 and 27. \n"
14725 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14729 " x (PLFLT, input) : X coordinate of arc center. \n"
14731 " y (PLFLT, input) : Y coordinate of arc center. \n"
14733 " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
14735 " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
14737 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14738 " semimajor axis. \n"
14740 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14741 " semimajor axis. \n"
14743 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14746 " fill (PLBOOL, input) : Draw a filled arc. \n"
14749 { (
char *)
"plaxes",
_wrap_plaxes, METH_VARARGS, (
char *)
"\n"
14750 "Draw a box with axes, etc. with arbitrary origin \n"
14754 " Draws a box around the currently defined viewport with arbitrary\n"
14755 " world-coordinate origin specified by x0 and y0 and labels it with\n"
14756 " world coordinate values appropriate to the window. Thus plaxes should\n"
14757 " only be called after defining both viewport and window. The character\n"
14758 " strings xopt and yopt specify how the box should be drawn as described\n"
14759 " below. If ticks and/or subticks are to be drawn for a particular\n"
14760 " axis, the tick intervals and number of subintervals may be specified\n"
14761 " explicitly, or they may be defaulted by setting the appropriate\n"
14762 " arguments to zero. \n"
14764 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14766 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14770 " This function is not used in any examples. \n"
14776 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14780 " x0 (PLFLT, input) : World X coordinate of origin. \n"
14782 " y0 (PLFLT, input) : World Y coordinate of origin. \n"
14784 " xopt (const char *, input) : Pointer to character string specifying\n"
14785 " options for horizontal axis. The string can include any\n"
14786 " combination of the following letters (upper or lower case) in any\n"
14787 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14788 " is vertical line (x=0). \n"
14789 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14790 " c: Draws top (X) or right (Y) edge of frame. \n"
14791 " d: Plot labels as date / time. Values are assumed to be\n"
14792 " seconds since the epoch (as used by gmtime). \n"
14793 " f: Always use fixed point numeric labels. \n"
14794 " g: Draws a grid at the major tick interval. \n"
14795 " h: Draws a grid at the minor tick interval. \n"
14796 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14798 " l: Labels axis logarithmically. This only affects the labels,\n"
14799 " not the data, and so it is necessary to compute the logarithms\n"
14800 " of data points before passing them to any of the drawing\n"
14802 " m: Writes numeric labels at major tick intervals in the\n"
14803 " unconventional location (above box for X, right of box for Y). \n"
14804 " n: Writes numeric labels at major tick intervals in the\n"
14805 " conventional location (below box for X, left of box for Y). \n"
14806 " o: Use custom labeling function to generate axis label text. \n"
14807 " The custom labeling function can be defined with the\n"
14808 " plslabelfuncplslabelfunc; command. \n"
14809 " s: Enables subticks between major ticks, only valid if t is\n"
14810 " also specified. \n"
14811 " t: Draws major ticks. \n"
14814 " xtick (PLFLT, input) : World coordinate interval between major\n"
14815 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14816 " generates a suitable tick interval. \n"
14818 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14819 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14820 " generates a suitable minor tick interval. \n"
14822 " yopt (const char *, input) : Pointer to character string specifying\n"
14823 " options for vertical axis. The string can include any combination\n"
14824 " of the letters defined above for xopt, and in addition may\n"
14825 " contain: v: Write numeric labels for vertical axis parallel to the\n"
14826 " base of the graph, rather than parallel to the axis. \n"
14829 " ytick (PLFLT, input) : World coordinate interval between major\n"
14830 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14831 " generates a suitable tick interval. \n"
14833 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14834 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14835 " generates a suitable minor tick interval. \n"
14838 { (
char *)
"plbin",
_wrap_plbin, METH_VARARGS, (
char *)
"\n"
14839 "Plot a histogram from binned data \n"
14843 " Plots a histogram consisting of nbin bins. The value associated with\n"
14844 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14845 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14846 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14847 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14848 " placed midway between the values in the x array. Also see plhist for\n"
14849 " drawing histograms from unbinned data. \n"
14851 " Redacted form: General: plbin(x, y, opt)\n"
14852 " Perl/PDL: plbin(nbin, x, y, opt)\n"
14853 " Python: plbin(nbin, x, y, opt)\n"
14856 " This function is not used in any examples. \n"
14862 "plbin(nbin, x, y, opt)\n"
14866 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14867 " and y arrays.) \n"
14869 " x (PLFLT *, input) : Pointer to array containing values associated\n"
14870 " with bins. These must form a strictly increasing sequence. \n"
14872 " y (PLFLT *, input) : Pointer to array containing number of points\n"
14873 " in bin. This is a PLFLT (instead of PLINT) array so as to allow\n"
14874 " histograms of probabilities, etc. \n"
14876 " opt (PLINT, input) : Is a combination of several flags:\n"
14877 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14878 " outer bins are expanded to fill up the entire x-axis and bins of\n"
14879 " zero height are simply drawn. \n"
14880 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14881 " between the x values. If the values in x are equally spaced,\n"
14882 " the values are the center values of the bins. \n"
14883 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14884 " size as the ones inside. \n"
14885 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14886 " (there is a gap for such bins). \n"
14890 { (
char *)
"plbop",
_wrap_plbop, METH_VARARGS, (
char *)
"\n"
14891 "Begin a new page\n"
14895 " Begins a new page. For a file driver, the output file is opened if\n"
14896 " necessary. Advancing the page via pleop and plbop is useful when a\n"
14897 " page break is desired at a particular point when plotting to subpages.\n"
14898 " Another use for pleop and plbop is when plotting pages to different\n"
14899 " files, since you can manually set the file name by calling plsfnam\n"
14900 " after the call to pleop. (In fact some drivers may only support a\n"
14901 " single page per file, making this a necessity.) One way to handle\n"
14902 " this case automatically is to page advance via pladv, but enable\n"
14903 " familying (see plsfam) with a small limit on the file size so that a\n"
14904 " new family member file will be created on each page break. \n"
14906 " Redacted form: plbop()\n"
14908 " This function is used in examples 2,20. \n"
14917 { (
char *)
"plbox",
_wrap_plbox, METH_VARARGS, (
char *)
"\n"
14918 "Draw a box with axes, etc\n"
14922 " Draws a box around the currently defined viewport, and labels it with\n"
14923 " world coordinate values appropriate to the window. Thus plbox should\n"
14924 " only be called after defining both viewport and window. The character\n"
14925 " strings xopt and yopt specify how the box should be drawn as described\n"
14926 " below. If ticks and/or subticks are to be drawn for a particular\n"
14927 " axis, the tick intervals and number of subintervals may be specified\n"
14928 " explicitly, or they may be defaulted by setting the appropriate\n"
14929 " arguments to zero. \n"
14931 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14932 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
14935 " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
14941 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14945 " xopt (const char *, input) : Pointer to character string specifying\n"
14946 " options for horizontal axis. The string can include any\n"
14947 " combination of the following letters (upper or lower case) in any\n"
14948 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14949 " is vertical line (x=0). \n"
14950 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14951 " c: Draws top (X) or right (Y) edge of frame. \n"
14952 " d: Plot labels as date / time. Values are assumed to be\n"
14953 " seconds since the epoch (as used by gmtime). \n"
14954 " f: Always use fixed point numeric labels. \n"
14955 " g: Draws a grid at the major tick interval. \n"
14956 " h: Draws a grid at the minor tick interval. \n"
14957 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14959 " l: Labels axis logarithmically. This only affects the labels,\n"
14960 " not the data, and so it is necessary to compute the logarithms\n"
14961 " of data points before passing them to any of the drawing\n"
14963 " m: Writes numeric labels at major tick intervals in the\n"
14964 " unconventional location (above box for X, right of box for Y). \n"
14965 " n: Writes numeric labels at major tick intervals in the\n"
14966 " conventional location (below box for X, left of box for Y). \n"
14967 " o: Use custom labeling function to generate axis label text. \n"
14968 " The custom labeling function can be defined with the\n"
14969 " plslabelfuncplslabelfunc; command. \n"
14970 " s: Enables subticks between major ticks, only valid if t is\n"
14971 " also specified. \n"
14972 " t: Draws major ticks. \n"
14973 " u: Exactly like \"b\" except don't draw edge line. \n"
14974 " w: Exactly like \"c\" except don't draw edge line. \n"
14977 " xtick (PLFLT, input) : World coordinate interval between major\n"
14978 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14979 " generates a suitable tick interval. \n"
14981 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14982 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14983 " generates a suitable minor tick interval. \n"
14985 " yopt (const char *, input) : Pointer to character string specifying\n"
14986 " options for vertical axis. The string can include any combination\n"
14987 " of the letters defined above for xopt, and in addition may\n"
14988 " contain: v: Write numeric labels for vertical axis parallel to the\n"
14989 " base of the graph, rather than parallel to the axis. \n"
14992 " ytick (PLFLT, input) : World coordinate interval between major\n"
14993 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14994 " generates a suitable tick interval. \n"
14996 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14997 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14998 " generates a suitable minor tick interval. \n"
15001 { (
char *)
"plbox3",
_wrap_plbox3, METH_VARARGS, (
char *)
"\n"
15002 "Draw a box with axes, etc, in 3-d \n"
15006 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15007 " plot. For a more complete description of three-dimensional plotting\n"
15008 " see the PLplot documentation. \n"
15010 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15011 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15012 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15013 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15016 " This function is used in examples 8,11,18,21. \n"
15022 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15026 " xopt (const char *, input) : Pointer to character string specifying\n"
15027 " options for the x axis. The string can include any combination of\n"
15028 " the following letters (upper or lower case) in any order: b: Draws\n"
15029 " axis at base, at height z=\n"
15030 " zmin where zmin is defined by call to plw3d. This character must be\n"
15031 " specified in order to use any of the other options. \n"
15032 " f: Always use fixed point numeric labels. \n"
15033 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15034 " than upwards. \n"
15035 " l: Labels axis logarithmically. This only affects the labels,\n"
15036 " not the data, and so it is necessary to compute the logarithms\n"
15037 " of data points before passing them to any of the drawing\n"
15039 " n: Writes numeric labels at major tick intervals. \n"
15040 " o: Use custom labeling function to generate axis label text. \n"
15041 " The custom labeling function can be defined with the\n"
15042 " plslabelfuncplslabelfunc; command. \n"
15043 " s: Enables subticks between major ticks, only valid if t is\n"
15044 " also specified. \n"
15045 " t: Draws major ticks. \n"
15046 " u: If this is specified, the text label for the axis is\n"
15047 " written under the axis. \n"
15050 " xlabel (const char *, input) : Pointer to character string\n"
15051 " specifying text label for the x axis. It is only drawn if u is in\n"
15052 " the xopt string. \n"
15054 " xtick (PLFLT, input) : World coordinate interval between major\n"
15055 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15056 " generates a suitable tick interval. \n"
15058 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15059 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15060 " generates a suitable minor tick interval. \n"
15062 " yopt (const char *, input) : Pointer to character string specifying\n"
15063 " options for the y axis. The string is interpreted in the same way\n"
15066 " ylabel (const char *, input) : Pointer to character string\n"
15067 " specifying text label for the y axis. It is only drawn if u is in\n"
15068 " the yopt string. \n"
15070 " ytick (PLFLT, input) : World coordinate interval between major\n"
15071 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15072 " generates a suitable tick interval. \n"
15074 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15075 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15076 " generates a suitable minor tick interval. \n"
15078 " zopt (const char *, input) : Pointer to character string specifying\n"
15079 " options for the z axis. The string can include any combination of\n"
15080 " the following letters (upper or lower case) in any order: b: Draws\n"
15081 " z axis to the left of the surface plot. \n"
15082 " c: Draws z axis to the right of the surface plot. \n"
15083 " d: Draws grid lines parallel to the x-y plane behind the\n"
15084 " figure. These lines are not drawn until after plot3d or\n"
15085 " plmesh are called because of the need for hidden line removal. \n"
15086 " f: Always use fixed point numeric labels. \n"
15087 " i: Inverts tick marks, so they are drawn away from the center. \n"
15088 " l: Labels axis logarithmically. This only affects the labels,\n"
15089 " not the data, and so it is necessary to compute the logarithms\n"
15090 " of data points before passing them to any of the drawing\n"
15092 " m: Writes numeric labels at major tick intervals on the\n"
15093 " right-hand vertical axis. \n"
15094 " n: Writes numeric labels at major tick intervals on the\n"
15095 " left-hand vertical axis. \n"
15096 " o: Use custom labeling function to generate axis label text. \n"
15097 " The custom labeling function can be defined with the\n"
15098 " plslabelfuncplslabelfunc; command. \n"
15099 " s: Enables subticks between major ticks, only valid if t is\n"
15100 " also specified. \n"
15101 " t: Draws major ticks. \n"
15102 " u: If this is specified, the text label is written beside the\n"
15103 " left-hand axis. \n"
15104 " v: If this is specified, the text label is written beside the\n"
15105 " right-hand axis. \n"
15108 " zlabel (const char *, input) : Pointer to character string\n"
15109 " specifying text label for the z axis. It is only drawn if u or v\n"
15110 " are in the zopt string. \n"
15112 " ztick (PLFLT, input) : World coordinate interval between major\n"
15113 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15114 " generates a suitable tick interval. \n"
15116 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15117 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15118 " generates a suitable minor tick interval. \n"
15122 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15126 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15127 " from relative device coordinates, rx and ry. \n"
15129 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15130 " Perl/PDL: Not available? \n"
15133 " This function is used in example 31. \n"
15139 "plcalc_world(rx, ry, wx, wy, window)\n"
15143 " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15144 " 0. to 1.) for the x coordinate. \n"
15146 " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15147 " 0. to 1.) for the y coordinate. \n"
15149 " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15150 " x corresponding to the relative device coordinates rx and ry. \n"
15152 " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15153 " y corresponding to the relative device coordinates rx and ry. \n"
15155 " window (PLINT *, output) : Pointer to the returned last defined\n"
15156 " window index that corresponds to the input relative device\n"
15157 " coordinates (and the returned world coordinates). To give some\n"
15158 " background on the window index, for each page the initial window\n"
15159 " index is set to zero, and each time plwind is called within the\n"
15160 " page, world and device coordinates are stored for the window and\n"
15161 " the window index is incremented. Thus, for a simple page layout\n"
15162 " with non-overlapping viewports and one window per viewport, window\n"
15163 " corresponds to the viewport index (in the order which the\n"
15164 " viewport/windows were created) of the only viewport/window\n"
15165 " corresponding to rx and ry. However, for more complicated layouts\n"
15166 " with potentially overlapping viewports and possibly more than one\n"
15167 " window (set of world coordinates) per viewport, window and the\n"
15168 " corresponding output world coordinates corresponds to the last\n"
15169 " window created that fulfils the criterion that the relative device\n"
15170 " coordinates are inside it. Finally, in all cases where the input\n"
15171 " relative device coordinates are not inside any viewport/window,\n"
15172 " then window is set to -1. \n"
15175 { (
char *)
"plclear",
_wrap_plclear, METH_VARARGS, (
char *)
"\n"
15176 "Clear current (sub)page \n"
15180 " Clears the current page, effectively erasing everything that have been\n"
15181 " drawn. This command only works with interactive drivers; if the\n"
15182 " driver does not support this, the page is filled with the background\n"
15183 " color in use. If the current page is divided into subpages, only the\n"
15184 " current subpage is erased. The nth subpage can be selected with\n"
15187 " Redacted form: General: plclear()\n"
15188 " Perl/PDL: Not available? \n"
15191 " This function is not used in any examples. \n"
15200 { (
char *)
"plcol0",
_wrap_plcol0, METH_VARARGS, (
char *)
"\n"
15201 "Set color, map0 \n"
15205 " Sets the color for color map0 (see the PLplot documentation). \n"
15207 " Redacted form: plcol0(color)\n"
15209 " This function is used in examples 1-9,11-16,18-27,29. \n"
15219 " color (PLINT, input) : Integer representing the color. The\n"
15220 " defaults at present are (these may change): \n"
15221 " 0 black (default background) \n"
15222 " 1 red (default foreground) \n"
15231 " 10 BlueViolet \n"
15238 " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15239 " change an individual color in the map0 color palette. \n"
15242 { (
char *)
"plcol1",
_wrap_plcol1, METH_VARARGS, (
char *)
"\n"
15243 "Set color, map1 \n"
15247 " Sets the color for color map1 (see the PLplot documentation). \n"
15249 " Redacted form: plcol1(col1)\n"
15251 " This function is used in examples 12 and 21. \n"
15261 " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15262 " and is mapped to color using the continuous map1 color palette\n"
15263 " which by default ranges from blue to the background color to red. \n"
15264 " The map1 palette can also be straightforwardly changed by the user\n"
15265 " with plscmap1 or plscmap1l. \n"
15269 { (
char *)
"plcont",
_wrap_plcont, METH_VARARGS, (
char *)
"\n"
15274 " Draws a contour plot of the data in z[\n"
15276 " ny], using the nlevel contour levels specified by clevel. Only the\n"
15277 " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15278 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15279 " additional data required by the transformation routine is used to map\n"
15280 " indices within the array to the world coordinates. See the following\n"
15281 " discussion of the arguments and the PLplot documentation for more\n"
15284 " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
15285 " plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
15286 " clevel, xgrid, ygrid)\n"
15287 " Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
15288 " Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15289 " Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
15292 " This function is used in examples 9,14,16,22. \n"
15298 "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15302 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
15303 " containing data to be contoured. \n"
15305 " nx, ny (PLINT, input) : Physical dimensions of array z. \n"
15307 " kx, lx (PLINT, input) : Range of x indices to consider. \n"
15309 " ky, ly (PLINT, input) : Range of y indices to consider. \n"
15311 " clevel (PLFLT *, input) : Pointer to array specifying levels at\n"
15312 " which to draw contours. \n"
15314 " nlevel (PLINT, input) : Number of contour levels to draw. \n"
15316 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
15317 " Pointer to function that defines transformation between indices\n"
15318 " in array z and the world coordinates (C only). Transformation\n"
15319 " functions are provided in the PLplot library: pltr0 for identity\n"
15320 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
15321 " defined by one- and two-dimensional arrays. In addition,\n"
15322 " user-supplied routines for the transformation can be used as well.\n"
15323 " Examples of all of these approaches are given in the PLplot\n"
15324 " documentation. The transformation function should have the form\n"
15325 " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
15326 " and similar PLplot functions which have a pltr argument, plcont\n"
15327 " requires that a transformation function be provided in the C\n"
15328 " interface. Leaving pltr NULL will result in an error. \n"
15330 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15331 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
15332 " externally supplied. \n"
15336 { (
char *)
"plcpstrm",
_wrap_plcpstrm, METH_VARARGS, (
char *)
"\n"
15337 "Copy state parameters from the reference stream to the current stream \n"
15341 " Copies state parameters from the reference stream to the current\n"
15342 " stream. Tell driver interface to map device coordinates unless flags\n"
15345 " This function is used for making save files of selected plots (e.g.\n"
15346 " from the TK driver). After initializing, you can get a copy of the\n"
15347 " current plot to the specified device by switching to this stream and\n"
15348 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15349 " appropriate. The plot buffer must have previously been enabled (done\n"
15350 " automatically by some display drivers, such as X). \n"
15352 " Redacted form: plcpstrm(iplsr, flags)\n"
15354 " This function is used in example 1,20. \n"
15360 "plcpstrm(iplsr, flags)\n"
15364 " iplsr (PLINT, input) : Number of reference stream. \n"
15366 " flags (PLBOOL, input) : If flags is set to true the device\n"
15367 " coordinates are not copied from the reference to current stream. \n"
15370 { (
char *)
"plend",
_wrap_plend, METH_VARARGS, (
char *)
"\n"
15371 "End plotting session \n"
15375 " Ends a plotting session, tidies up all the output files, switches\n"
15376 " interactive devices back into text mode and frees up any memory that\n"
15377 " was allocated. Must be called before end of program. \n"
15379 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15380 " wait state after a call to plend or other functions which trigger the\n"
15381 " end of a plot page. To avoid this, use the plspause function. \n"
15383 " Redacted form: plend()\n"
15385 " This function is used in all of the examples. \n"
15394 { (
char *)
"plend1",
_wrap_plend1, METH_VARARGS, (
char *)
"\n"
15395 "End plotting session for current stream \n"
15399 " Ends a plotting session for the current output stream only. See\n"
15400 " plsstrm for more info. \n"
15402 " Redacted form: plend1()\n"
15404 " This function is used in examples 1,20. \n"
15413 { (
char *)
"plenv",
_wrap_plenv, METH_VARARGS, (
char *)
"\n"
15414 "Set up standard window and draw box \n"
15418 " Sets up plotter environment for simple graphs by calling pladv and\n"
15419 " setting up viewport and window to sensible default values. plenv\n"
15420 " leaves enough room around most graphs for axis labels and a title.\n"
15421 " When these defaults are not suitable, use the individual routines\n"
15422 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15423 " defining the window, and plbox for drawing the box. \n"
15425 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15427 " This function is used in example 1,3,9,13,14,19-22,29. \n"
15433 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15437 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15438 " world coordinates). \n"
15440 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15441 " world coordinates). \n"
15443 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15444 " coordinates). \n"
15446 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15447 " coordinates). \n"
15449 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15450 " scales will not be set, the user must set up the scale before\n"
15451 " calling plenv using plsvpa, plvasp or other. \n"
15452 " 0: the x and y axes are scaled independently to use as much of\n"
15453 " the screen as possible. \n"
15454 " 1: the scales of the x and y axes are made equal. \n"
15455 " 2: the axis of the x and y axes are made equal, and the plot\n"
15456 " box will be square. \n"
15459 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15460 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15461 " -1: draw box only. \n"
15462 " 0: draw box, ticks, and numeric tick labels. \n"
15463 " 1: also draw coordinate axes at x=0 and y=0. \n"
15464 " 2: also draw a grid at major tick positions in both\n"
15466 " 3: also draw a grid at minor tick positions in both\n"
15468 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15469 " have to be converted to logarithms separately.) \n"
15470 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15471 " have to be converted to logarithms separately.) \n"
15472 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15473 " have to be converted to logarithms separately.) \n"
15474 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15475 " have to be converted to logarithms separately.) \n"
15476 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15477 " have to be converted to logarithms separately.) \n"
15478 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15479 " have to be converted to logarithms separately.) \n"
15480 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15481 " have to be converted to logarithms separately.) \n"
15482 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15483 " have to be converted to logarithms separately.) \n"
15484 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15485 " and y data have to be converted to logarithms separately.) \n"
15486 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15487 " and y data have to be converted to logarithms separately.) \n"
15488 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15489 " and y data have to be converted to logarithms separately.) \n"
15490 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15491 " and y data have to be converted to logarithms separately.) \n"
15492 " 40: same as 0 except date / time x labels. \n"
15493 " 41: same as 1 except date / time x labels. \n"
15494 " 42: same as 2 except date / time x labels. \n"
15495 " 43: same as 3 except date / time x labels. \n"
15496 " 50: same as 0 except date / time y labels. \n"
15497 " 51: same as 1 except date / time y labels. \n"
15498 " 52: same as 2 except date / time y labels. \n"
15499 " 53: same as 3 except date / time y labels. \n"
15500 " 60: same as 0 except date / time x and y labels. \n"
15501 " 61: same as 1 except date / time x and y labels. \n"
15502 " 62: same as 2 except date / time x and y labels. \n"
15503 " 63: same as 3 except date / time x and y labels. \n"
15504 " 70: same as 0 except custom x and y labels. \n"
15505 " 71: same as 1 except custom x and y labels. \n"
15506 " 72: same as 2 except custom x and y labels. \n"
15507 " 73: same as 3 except custom x and y labels. \n"
15510 { (
char *)
"plenv0",
_wrap_plenv0, METH_VARARGS, (
char *)
"\n"
15511 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
15515 " Sets up plotter environment for simple graphs by calling pladv and\n"
15516 " setting up viewport and window to sensible default values. plenv0\n"
15517 " leaves enough room around most graphs for axis labels and a title.\n"
15518 " When these defaults are not suitable, use the individual routines\n"
15519 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15520 " defining the window, and plbox for drawing the box. \n"
15522 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15524 " This function is used in example 21. \n"
15530 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15534 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15535 " world coordinates). \n"
15537 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15538 " world coordinates). \n"
15540 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15541 " coordinates). \n"
15543 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15544 " coordinates). \n"
15546 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15547 " scales will not be set, the user must set up the scale before\n"
15548 " calling plenv0 using plsvpa, plvasp or other. \n"
15549 " 0: the x and y axes are scaled independently to use as much of\n"
15550 " the screen as possible. \n"
15551 " 1: the scales of the x and y axes are made equal. \n"
15552 " 2: the axis of the x and y axes are made equal, and the plot\n"
15553 " box will be square. \n"
15556 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15557 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15558 " -1: draw box only. \n"
15559 " 0: draw box, ticks, and numeric tick labels. \n"
15560 " 1: also draw coordinate axes at x=0 and y=0. \n"
15561 " 2: also draw a grid at major tick positions in both\n"
15563 " 3: also draw a grid at minor tick positions in both\n"
15565 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15566 " have to be converted to logarithms separately.) \n"
15567 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15568 " have to be converted to logarithms separately.) \n"
15569 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15570 " have to be converted to logarithms separately.) \n"
15571 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15572 " have to be converted to logarithms separately.) \n"
15573 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15574 " have to be converted to logarithms separately.) \n"
15575 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15576 " have to be converted to logarithms separately.) \n"
15577 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15578 " have to be converted to logarithms separately.) \n"
15579 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15580 " have to be converted to logarithms separately.) \n"
15581 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15582 " and y data have to be converted to logarithms separately.) \n"
15583 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15584 " and y data have to be converted to logarithms separately.) \n"
15585 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15586 " and y data have to be converted to logarithms separately.) \n"
15587 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15588 " and y data have to be converted to logarithms separately.) \n"
15589 " 40: same as 0 except date / time x labels. \n"
15590 " 41: same as 1 except date / time x labels. \n"
15591 " 42: same as 2 except date / time x labels. \n"
15592 " 43: same as 3 except date / time x labels. \n"
15593 " 50: same as 0 except date / time y labels. \n"
15594 " 51: same as 1 except date / time y labels. \n"
15595 " 52: same as 2 except date / time y labels. \n"
15596 " 53: same as 3 except date / time y labels. \n"
15597 " 60: same as 0 except date / time x and y labels. \n"
15598 " 61: same as 1 except date / time x and y labels. \n"
15599 " 62: same as 2 except date / time x and y labels. \n"
15600 " 63: same as 3 except date / time x and y labels. \n"
15601 " 70: same as 0 except custom x and y labels. \n"
15602 " 71: same as 1 except custom x and y labels. \n"
15603 " 72: same as 2 except custom x and y labels. \n"
15604 " 73: same as 3 except custom x and y labels. \n"
15607 { (
char *)
"pleop",
_wrap_pleop, METH_VARARGS, (
char *)
"\n"
15608 "Eject current page \n"
15612 " Clears the graphics screen of an interactive device, or ejects a page\n"
15613 " on a plotter. See plbop for more information. \n"
15615 " Redacted form: pleop()\n"
15617 " This function is used in example 2,14. \n"
15626 { (
char *)
"plerrx",
_wrap_plerrx, METH_VARARGS, (
char *)
"\n"
15627 "Draw x error bar \n"
15631 " Draws a set of n horizontal error bars, the i'th error bar extending\n"
15632 " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
15633 " error bar are of length equal to the minor tick length (settable using\n"
15636 " Redacted form: General: plerrx(xmin, ymax, y)\n"
15637 " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15640 " This function is used in example 29. \n"
15646 "plerrx(n, xmin, xmax, y)\n"
15650 " n (PLINT, input) : Number of error bars to draw. \n"
15652 " xmin (PLFLT *, input) : Pointer to array with x coordinates of\n"
15653 " left-hand endpoint of error bars. \n"
15655 " xmax (PLFLT *, input) : Pointer to array with x coordinates of\n"
15656 " right-hand endpoint of error bars. \n"
15658 " y (PLFLT *, input) : Pointer to array with y coordinates of error\n"
15662 { (
char *)
"plerry",
_wrap_plerry, METH_VARARGS, (
char *)
"\n"
15663 "Draw y error bar \n"
15667 " Draws a set of n vertical error bars, the i'th error bar extending\n"
15668 " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
15669 " error bar are of length equal to the minor tick length (settable using\n"
15672 " Redacted form: General: plerry(x, ymin, ymax)\n"
15673 " Perl/PDL: plerry(n, x, ymin, ymax)\n"
15676 " This function is used in example 29. \n"
15682 "plerry(n, x, ymin, ymax)\n"
15686 " n (PLINT, input) : Number of error bars to draw. \n"
15688 " x (PLFLT *, input) : Pointer to array with x coordinates of error\n"
15691 " ymin (PLFLT *, input) : Pointer to array with y coordinates of\n"
15692 " lower endpoint of error bars. \n"
15694 " ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n"
15695 " endpoint of error bar. \n"
15698 { (
char *)
"plfamadv",
_wrap_plfamadv, METH_VARARGS, (
char *)
"\n"
15699 "Advance to the next family file on the next new page \n"
15703 " Advance to the next family file on the next new page. \n"
15705 " Redacted form: plfamadv()\n"
15707 " This function is not used in any examples. \n"
15716 { (
char *)
"plfill",
_wrap_plfill, METH_VARARGS, (
char *)
"\n"
15717 "Draw filled polygon \n"
15721 " Fills the polygon defined by the n points (\n"
15723 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15724 " style is a solid fill. The routine will automatically close the\n"
15725 " polygon between the last and first vertices. If multiple closed\n"
15726 " polygons are passed in x and y then plfill will fill in between them. \n"
15728 " Redacted form: plfill(x,y)\n"
15730 " This function is used in examples 12,13,15,16,21,24,25. \n"
15736 "plfill(n, x, y)\n"
15740 " n (PLINT, input) : Number of vertices in polygon. \n"
15742 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15745 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15749 { (
char *)
"plfill3",
_wrap_plfill3, METH_VARARGS, (
char *)
"\n"
15750 "Draw filled polygon in 3D \n"
15754 " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15755 " using the pattern defined by plpsty or plpat. The routine will\n"
15756 " automatically close the polygon between the last and first vertices. \n"
15757 " If multiple closed polygons are passed in x, y, and z then plfill3\n"
15758 " will fill in between them. \n"
15760 " Redacted form: General: plfill3(x, y, z)\n"
15761 " Perl/PDL: plfill3(n, x, y, z)\n"
15764 " This function is used in example 15. \n"
15770 "plfill3(n, x, y, z)\n"
15774 " n (PLINT, input) : Number of vertices in polygon. \n"
15776 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15779 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15782 " z (PLFLT *, input) : Pointer to array with z coordinates of\n"
15787 "Draw linear gradient inside polygon \n"
15791 " Draw a linear gradient using colour map 1 inside the polygon defined\n"
15792 " by the n points (\n"
15794 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15795 " polygon coordinates and the gradient angle are all expressed in world\n"
15796 " coordinates. The angle from the x axis for both the rotated\n"
15797 " coordinate system and the gradient vector is specified by angle. The\n"
15798 " magnitude of the gradient vector is the difference between the maximum\n"
15799 " and minimum values of x for the vertices in the rotated coordinate\n"
15800 " system. The origin of the gradient vector can be interpreted as being\n"
15801 " anywhere on the line corresponding to the minimum x value for the\n"
15802 " vertices in the rotated coordinate system. The distance along the\n"
15803 " gradient vector is linearly transformed to the independent variable of\n"
15804 " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15805 " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15806 " colour corresponding to the independent variable of colour map 1. For\n"
15807 " more information about colour map 1 (see the PLplot documentation). \n"
15809 " Redacted form: plgradient(x,y,angle)\n"
15811 " This function is used in examples 25,30. \n"
15817 "plgradient(n, x, y, angle)\n"
15821 " n (PLINT, input) : Number of vertices in polygon. \n"
15823 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15826 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15829 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
15833 { (
char *)
"plflush",
_wrap_plflush, METH_VARARGS, (
char *)
"\n"
15834 "Flushes the output stream \n"
15838 " Flushes the output stream. Use sparingly, if at all. \n"
15840 " Redacted form: plflush()\n"
15842 " This function is used in examples 1,14. \n"
15851 { (
char *)
"plfont",
_wrap_plfont, METH_VARARGS, (
char *)
"\n"
15852 "Set character font \n"
15856 " Sets the default character font for subsequent character drawing. Also\n"
15857 " affects symbols produced by plpoin. This routine has no effect unless\n"
15858 " the extended character set is loaded (see plfontld). \n"
15860 " Redacted form: plfont(font)\n"
15862 " This function is used in examples 1,2,4,7,13,24,26. \n"
15872 " font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
15874 " 2: Roman font \n"
15875 " 3: Italic font \n"
15876 " 4: Script font \n"
15879 { (
char *)
"plfontld",
_wrap_plfontld, METH_VARARGS, (
char *)
"\n"
15880 "Load character font \n"
15884 " Sets the character set to use for subsequent character drawing. May\n"
15885 " be called before initializing PLplot. \n"
15887 " Redacted form: plfontld(set)\n"
15889 " This function is used in examples 1,7. \n"
15899 " set (PLINT, input) : Specifies the character set to load: 0:\n"
15900 " Standard character set \n"
15901 " 1: Extended character set \n"
15904 { (
char *)
"plgchr",
_wrap_plgchr, METH_VARARGS, (
char *)
"\n"
15905 "Get character default height and current (scaled) height \n"
15909 " Get character default height and current (scaled) height. \n"
15911 " Redacted form: plgchr(p_def, p_ht)\n"
15913 " This function is used in example 23. \n"
15919 "plgchr(p_def, p_ht)\n"
15923 " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
15925 " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
15929 { (
char *)
"plgcol0",
_wrap_plgcol0, METH_VARARGS, (
char *)
"\n"
15930 "Returns 8-bit RGB values for given color from color map0 \n"
15934 " Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
15935 " the PLplot documentation). Values are negative if an invalid color id\n"
15938 " Redacted form: plgcol0(icol0, r, g, b)\n"
15940 " This function is used in example 2. \n"
15946 "plgcol0(icol0, r, g, b)\n"
15950 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15952 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15954 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15956 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15959 { (
char *)
"plgcol0a",
_wrap_plgcol0a, METH_VARARGS, (
char *)
"\n"
15960 "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
15964 " Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
15965 " for given color from color map0 (see the PLplot documentation). \n"
15966 " Values are negative if an invalid color id is given. \n"
15968 " This function is used in example 30. \n"
15974 "plgcol0a(icol0, r, g, b, a)\n"
15978 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15980 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15982 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15984 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15986 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
15989 { (
char *)
"plgcolbg",
_wrap_plgcolbg, METH_VARARGS, (
char *)
"\n"
15990 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
15994 " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
15996 " Redacted form: plgcolbg(r, g, b)\n"
15998 " This function is used in example 31. \n"
16004 "lgcolbg(r, g, b)\n"
16008 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16009 " representing the degree of red in the color. \n"
16011 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16012 " representing the degree of green in the color. \n"
16014 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16015 " representing the degree of blue in the color. \n"
16019 "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n"
16023 " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16026 " This function is used in example 31. \n"
16032 "lgcolbga(r, g, b, a)\n"
16036 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16037 " representing the degree of red in the color. \n"
16039 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16040 " representing the degree of green in the color. \n"
16042 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16043 " representing the degree of blue in the color. \n"
16045 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16049 "Get the current device-compression setting \n"
16053 " Get the current device-compression setting. This parameter is only\n"
16054 " used for drivers that provide compression. \n"
16056 " Redacted form: plgcompression(compression)\n"
16058 " This function is used in example 31. \n"
16064 "plgcompression(compression)\n"
16068 " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16069 " with the current device-compression setting. \n"
16072 { (
char *)
"plgdev",
_wrap_plgdev, METH_VARARGS, (
char *)
"\n"
16073 "Get the current device (keyword) name \n"
16077 " Get the current device (keyword) name. Note: you must have allocated\n"
16078 " space for this (80 characters is safe). \n"
16080 " Redacted form: plgdev(p_dev)\n"
16082 " This function is used in example 14. \n"
16092 " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16095 { (
char *)
"plgdidev",
_wrap_plgdidev, METH_VARARGS, (
char *)
"\n"
16096 "Get parameters that define current device-space window \n"
16100 " Get relative margin width, aspect ratio, and relative justification\n"
16101 " that define current device-space window. If plsdidev has not been\n"
16102 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16103 " p_jy will all be 0. \n"
16105 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16107 " This function is used in example 31. \n"
16113 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16117 " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16119 " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16121 " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16123 " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16126 { (
char *)
"plgdiori",
_wrap_plgdiori, METH_VARARGS, (
char *)
"\n"
16127 "Get plot orientation \n"
16131 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16132 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16133 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16134 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16135 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16136 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16137 " not been called the default value pointed to by p_rot will be 0. \n"
16139 " Redacted form: plgdiori(p_rot)\n"
16141 " This function is not used in any examples. \n"
16147 "plgdiori(p_rot)\n"
16151 " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16154 { (
char *)
"plgdiplt",
_wrap_plgdiplt, METH_VARARGS, (
char *)
"\n"
16155 "Get parameters that define current plot-space window \n"
16159 " Get relative minima and maxima that define current plot-space window.\n"
16160 " If plsdiplt has not been called the default values pointed to by\n"
16161 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16163 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16165 " This function is used in example 31. \n"
16171 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16175 " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16177 " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16179 " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16181 " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16184 { (
char *)
"plgfam",
_wrap_plgfam, METH_VARARGS, (
char *)
"\n"
16185 "Get family file parameters \n"
16189 " Gets information about current family file, if familying is enabled. \n"
16190 " See the PLplot documentation for more information. \n"
16192 " Redacted form: plgfam(fam, num, bmax)\n"
16194 " This function is used in examples 14,31. \n"
16200 "plgfam(fam, num, bmax)\n"
16204 " fam (PLINT *, output) : Pointer to variable with the Boolean family\n"
16205 " flag value. If nonzero, familying is enabled. \n"
16207 " num (PLINT *, output) : Pointer to variable with the current family\n"
16210 " bmax (PLINT *, output) : Pointer to variable with the maximum file\n"
16211 " size (in bytes) for a family file. \n"
16214 { (
char *)
"plgfci",
_wrap_plgfci, METH_VARARGS, (
char *)
"\n"
16215 "Get FCI (font characterization integer) \n"
16219 " Gets information about the current font using the FCI approach. See\n"
16220 " the PLplot documentation for more information. \n"
16222 " Redacted form: plgfci(fci)\n"
16224 " This function is used in example 23. \n"
16234 " fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
16235 " integer) variable which is updated with current FCI value. \n"
16238 { (
char *)
"plgfnam",
_wrap_plgfnam, METH_VARARGS, (
char *)
"\n"
16239 "Get output file name \n"
16243 " Gets the current output file name, if applicable. \n"
16245 " Redacted form: plgfnam(fnam)\n"
16247 " This function is used in example 31. \n"
16257 " fnam (char *, output) : Pointer to file name string (a preallocated\n"
16258 " string of 80 characters or more). \n"
16261 { (
char *)
"plgfont",
_wrap_plgfont, METH_VARARGS, (
char *)
"\n"
16262 "Get family, style and weight of the current font \n"
16266 " Gets information about current font. See the PLplot documentation for\n"
16267 " more information on font selection. \n"
16269 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16271 " This function is used in example 23. \n"
16277 "plgfont(p_family, p_style, p_weight)\n"
16281 " p_family (PLINT *, output) : Pointer to variable with the current\n"
16282 " font family. The available values are given by the PL_FCI_*\n"
16283 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16284 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16285 " p_family is NULL then the font family is not returned. \n"
16287 " p_style (PLINT *, output) : Pointer to variable with the current\n"
16288 " font style. The available values are given by the PL_FCI_*\n"
16289 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16290 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
16291 " font style is not returned. \n"
16293 " p_weight (PLINT *, output) : Pointer to variable with the current\n"
16294 " font weight. The available values are given by the PL_FCI_*\n"
16295 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16296 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16300 { (
char *)
"plglevel",
_wrap_plglevel, METH_VARARGS, (
char *)
"\n"
16301 "Get the (current) run level \n"
16305 " Get the (current) run level. Valid settings are: 0, uninitialized \n"
16306 " 1, initialized \n"
16307 " 2, viewport defined \n"
16308 " 3, world coordinates defined \n"
16311 " Redacted form: plglevel(p_level)\n"
16313 " This function is used in example 31. \n"
16319 "plglevel(p_level)\n"
16323 " p_level (PLINT *, output) : Pointer to the run level. \n"
16326 { (
char *)
"plgpage",
_wrap_plgpage, METH_VARARGS, (
char *)
"\n"
16327 "Get page parameters \n"
16331 " Gets the current page configuration. The length and offset values are\n"
16332 " expressed in units that are specific to the current driver. For\n"
16333 " instance: screen drivers will usually interpret them as number of\n"
16334 " pixels, whereas printer drivers will usually use mm. \n"
16336 " Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16338 " This function is used in examples 14 and 31. \n"
16344 "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16348 " xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
16350 " yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n"
16352 " xleng (PLINT *, output) : Pointer to x page length value. \n"
16354 " yleng (PLINT *, output) : Pointer to y page length value. \n"
16356 " xoff (PLINT *, output) : Pointer to x page offset. \n"
16358 " yoff (PLINT *, output) : Pointer to y page offset. \n"
16361 { (
char *)
"plgra",
_wrap_plgra, METH_VARARGS, (
char *)
"\n"
16362 "Switch to graphics screen \n"
16366 " Sets an interactive device to graphics mode, used in conjunction with\n"
16367 " pltext to allow graphics and text to be interspersed. On a device\n"
16368 " which supports separate text and graphics windows, this command causes\n"
16369 " control to be switched to the graphics window. If already in graphics\n"
16370 " mode, this command is ignored. It is also ignored on devices which\n"
16371 " only support a single window or use a different method for shifting\n"
16372 " focus. See also pltext. \n"
16374 " Redacted form: plgra()\n"
16376 " This function is used in example 1. \n"
16386 "Grid data from irregularly sampled data \n"
16390 " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
16391 " plots require data placed in a uniform grid. This function takes\n"
16392 " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
16393 " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
16394 " and yg[nptsy], and returns the gridded data into output array\n"
16395 " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
16396 " with the argument type which can have one parameter specified in\n"
16397 " argument data. \n"
16399 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16400 " Perl/PDL: Not available? \n"
16401 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16404 " This function is used in example 21. \n"
16410 "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16414 " x (PLFLT *, input) : The input x array. \n"
16416 " y (PLFLT *, input) : The input y array. \n"
16418 " z (PLFLT *, input) : The input z array. Each triple x[i], y[i],\n"
16419 " z[i] represents one data sample coordinate. \n"
16421 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16424 " xg (PLFLT *, input) : The input array that specifies the grid\n"
16425 " spacing in the x direction. Usually xg has nptsx equally spaced\n"
16426 " values from the minimum to the maximum values of the x input\n"
16429 " nptsx (PLINT, input) : The number of points in the xg array. \n"
16431 " yg (PLFLT *, input) : The input array that specifies the grid\n"
16432 " spacing in the y direction. Similar to the xg parameter. \n"
16434 " nptsy (PLINT, input) : The number of points in the yg array. \n"
16436 " zg (PLFLT **, output) : The output array, where data lies in the\n"
16437 " regular grid specified by xg and yg. the zg array must exist or be\n"
16438 " allocated by the user prior to the call, and must have dimension\n"
16439 " zg[nptsx][nptsy]. \n"
16441 " type (PLINT, input) : The type of gridding algorithm to use, which\n"
16442 " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
16443 " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
16444 " GRID_NNI: Natural Neighbors Interpolation \n"
16445 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
16446 " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
16447 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16449 " For details of the algorithms read the source file plgridd.c. \n"
16451 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16452 " which can be specified through this argument. Currently, for\n"
16453 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16454 " use, the lower the value, the noisier (more local) the\n"
16455 " approximation is. \n"
16456 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16457 " range [1. .. 2.]. High values enable the usage of very thin\n"
16458 " triangles for interpolation, possibly resulting in error in\n"
16459 " the approximation. \n"
16460 " GRID_NNI, only weights greater than data will be accepted. If\n"
16461 " 0, all weights will be accepted. \n"
16464 { (
char *)
"plgspa",
_wrap_plgspa, METH_VARARGS, (
char *)
"\n"
16465 "Get current subpage parameters \n"
16469 " Gets the size of the current subpage in millimeters measured from the\n"
16470 " bottom left hand corner of the output device page or screen. Can be\n"
16471 " used in conjunction with plsvpa for setting the size of a viewport in\n"
16472 " absolute coordinates (millimeters). \n"
16474 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16476 " This function is used in example 23. \n"
16482 "plgspa(xmin, xmax, ymin, ymax)\n"
16486 " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
16487 " hand edge of subpage in millimeters. \n"
16489 " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
16490 " hand edge of subpage in millimeters. \n"
16492 " ymin (PLFLT *, output) : Pointer to variable with position of\n"
16493 " bottom edge of subpage in millimeters. \n"
16495 " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
16496 " edge of subpage in millimeters. \n"
16499 { (
char *)
"plgstrm",
_wrap_plgstrm, METH_VARARGS, (
char *)
"\n"
16500 "Get current stream number \n"
16504 " Gets the number of the current output stream. See also plsstrm. \n"
16506 " Redacted form: plgstrm(strm)\n"
16508 " This function is used in example 1,20. \n"
16518 " strm (PLINT *, output) : Pointer to current stream value. \n"
16521 { (
char *)
"plgver",
_wrap_plgver, METH_VARARGS, (
char *)
"\n"
16522 "Get the current library version number \n"
16526 " Get the current library version number. Note: you must have allocated\n"
16527 " space for this (80 characters is safe). \n"
16529 " Redacted form: plgver(p_ver)\n"
16531 " This function is used in example 1. \n"
16541 " p_ver (char *, output) : Pointer to the current library version\n"
16545 { (
char *)
"plgvpd",
_wrap_plgvpd, METH_VARARGS, (
char *)
"\n"
16546 "Get viewport limits in normalized device coordinates \n"
16550 " Get viewport limits in normalized device coordinates. \n"
16552 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16553 " Perl/PDL: Not available? \n"
16556 " This function is used in example 31. \n"
16562 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16566 " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16567 " device coordinate in x. \n"
16569 " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16570 " device coordinate in x. \n"
16572 " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16573 " device coordinate in y. \n"
16575 " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16576 " device coordinate in y. \n"
16579 { (
char *)
"plgvpw",
_wrap_plgvpw, METH_VARARGS, (
char *)
"\n"
16580 "Get viewport limits in world coordinates \n"
16584 " Get viewport limits in world coordinates. \n"
16586 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16587 " Perl/PDL: Not available? \n"
16590 " This function is used in example 31. \n"
16596 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16600 " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
16601 " coordinate in x. \n"
16603 " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
16604 " coordinate in x. \n"
16606 " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
16607 " coordinate in y. \n"
16609 " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
16610 " coordinate in y. \n"
16613 { (
char *)
"plgxax",
_wrap_plgxax, METH_VARARGS, (
char *)
"\n"
16614 "Get x axis parameters \n"
16618 " Returns current values of the digmax and digits flags for the x axis. \n"
16619 " digits is updated after the plot is drawn, so this routine should only\n"
16620 " be called after the call to plbox (or plbox3) is complete. See the\n"
16621 " PLplot documentation for more information. \n"
16623 " Redacted form: plgxax(digmax, digits)\n"
16625 " This function is used in example 31. \n"
16631 "plgxax(digmax, digits)\n"
16635 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16636 " number of digits for the x axis. If nonzero, the printed label\n"
16637 " has been switched to a floating point representation when the\n"
16638 " number of digits exceeds digmax. \n"
16640 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16641 " number of digits for the numeric labels (x axis) from the last\n"
16645 { (
char *)
"plgyax",
_wrap_plgyax, METH_VARARGS, (
char *)
"\n"
16646 "Get y axis parameters \n"
16650 " Identical to plgxax, except that arguments are flags for y axis. See\n"
16651 " the description of plgxax for more detail. \n"
16653 " Redacted form: plgyax(digmax, digits)\n"
16655 " This function is used in example 31. \n"
16661 "plgyax(digmax, digits)\n"
16665 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16666 " number of digits for the y axis. If nonzero, the printed label\n"
16667 " has been switched to a floating point representation when the\n"
16668 " number of digits exceeds digmax. \n"
16670 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16671 " number of digits for the numeric labels (y axis) from the last\n"
16675 { (
char *)
"plgzax",
_wrap_plgzax, METH_VARARGS, (
char *)
"\n"
16676 "Get z axis parameters \n"
16680 " Identical to plgxax, except that arguments are flags for z axis. See\n"
16681 " the description of plgxax for more detail. \n"
16683 " Redacted form: plgzax(digmax, digits)\n"
16685 " This function is used in example 31. \n"
16691 "plgzax(digmax, digits)\n"
16695 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16696 " number of digits for the z axis. If nonzero, the printed label\n"
16697 " has been switched to a floating point representation when the\n"
16698 " number of digits exceeds digmax. \n"
16700 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16701 " number of digits for the numeric labels (z axis) from the last\n"
16705 { (
char *)
"plhist",
_wrap_plhist, METH_VARARGS, (
char *)
"\n"
16706 "Plot a histogram from unbinned data \n"
16710 " Plots a histogram from n data points stored in the array data. This\n"
16711 " routine bins the data into nbin bins equally spaced between datmin and\n"
16712 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16713 " opt allows, among other things, the histogram either to be plotted in\n"
16714 " an existing window or causes plhist to call plenv with suitable limits\n"
16715 " before plotting the histogram. \n"
16717 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16719 " This function is used in example 5. \n"
16725 "plhist(n, data, datmin, datmax, nbin, opt)\n"
16729 " n (PLINT, input) : Number of data points. \n"
16731 " data (PLFLT *, input) : Pointer to array with values of the n data\n"
16734 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
16736 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
16738 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16739 " divide the interval xmin to xmax. \n"
16741 " opt (PLINT, input) : Is a combination of several flags:\n"
16742 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16743 " the histogram data, the outer bins are expanded to fill up the\n"
16744 " entire x-axis, data outside the given extremes are assigned to the\n"
16745 " outer bins and bins of zero height are simply drawn. \n"
16746 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16747 " to fit the histogram data, without this flag, plenv is called\n"
16748 " to set the world coordinates. \n"
16749 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16750 " extremes are not taken into account. This option should\n"
16751 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16752 " properly present the data. \n"
16753 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16754 " size as the ones inside. \n"
16755 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16756 " (there is a gap for such bins). \n"
16759 { (
char *)
"plhlsrgb",
_wrap_plhlsrgb, METH_VARARGS, (
char *)
"\n"
16760 "Convert HLS color to RGB \n"
16764 " Convert HLS color coordinates to RGB. \n"
16766 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16767 " Perl/PDL: Not available? Implemented as plhls? \n"
16770 " This function is used in example 2. \n"
16776 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16780 " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
16782 " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
16783 " of the colour cone (0.0-1.0) \n"
16785 " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
16786 " radius of the colour cone (0.0-1.0) \n"
16788 " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
16791 " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
16794 " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
16798 { (
char *)
"plinit",
_wrap_plinit, METH_VARARGS, (
char *)
"\n"
16799 "Initialize PLplot \n"
16803 " Initializing the plotting package. The program prompts for the device\n"
16804 " keyword or number of the desired output device. Hitting a RETURN in\n"
16805 " response to the prompt is the same as selecting the first device. \n"
16806 " plinit will issue no prompt if either the device was specified\n"
16807 " previously (via command line flag, the plsetopt function, or the\n"
16808 " plsdev function), or if only one device is enabled when PLplot is\n"
16809 " installed. If subpages have been specified, the output device is\n"
16810 " divided into nx by ny subpages, each of which may be used\n"
16811 " independently. If plinit is called again during a program, the\n"
16812 " previously opened file will be closed. The subroutine pladv is used\n"
16813 " to advance from one subpage to the next. \n"
16815 " Redacted form: plinit()\n"
16817 " This function is used in all of the examples. \n"
16826 { (
char *)
"pljoin",
_wrap_pljoin, METH_VARARGS, (
char *)
"\n"
16827 "Draw a line between two points \n"
16831 " Joins the point (\n"
16837 " Redacted form: pljoin(x1,y1,x2,y2)\n"
16839 " This function is used in examples 3,14. \n"
16845 "pljoin(x1, y1, x2, y2)\n"
16849 " x1 (PLFLT, input) : x coordinate of first point. \n"
16851 " y1 (PLFLT, input) : y coordinate of first point. \n"
16853 " x2 (PLFLT, input) : x coordinate of second point. \n"
16855 " y2 (PLFLT, input) : y coordinate of second point. \n"
16858 { (
char *)
"pllab",
_wrap_pllab, METH_VARARGS, (
char *)
"\n"
16859 "Simple routine to write labels \n"
16863 " Routine for writing simple labels. Use plmtex for more complex labels. \n"
16865 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16867 " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16873 "pllab(xlabel, ylabel, tlabel)\n"
16877 " xlabel (const char *, input) : Label for horizontal axis. \n"
16879 " ylabel (const char *, input) : Label for vertical axis. \n"
16881 " tlabel (const char *, input) : Title of graph. \n"
16884 { (
char *)
"pllegend",
_wrap_pllegend, METH_VARARGS, (
char *)
"\n"
16885 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
16889 " Routine for creating a discrete plot legend with a plotted filled box,\n"
16890 " line, and/or line of symbols for each annotated legend entry. The\n"
16891 " arguments of pllegend provide control over the location and size of\n"
16892 " the legend as well as the location and characteristics of the elements\n"
16893 " (most of which are optional) within that legend. The resulting legend\n"
16894 " is clipped at the boundaries of the current subpage. (N.B. the adopted\n"
16895 " coordinate system used for some of the parameters is defined in the\n"
16896 " documentation of the position parameter.) \n"
16898 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
16899 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
16900 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
16901 " test_justification, text_colors, text, box_colors, box_patterns,\n"
16902 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
16903 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16905 " This function is used in examples 4 and 26. \n"
16911 "pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16915 " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
16916 " contains (after the call) the legend width in adopted coordinates.\n"
16917 " This quantity is calculated from plot_width, text_offset, ncolumn\n"
16918 " (possibly modified inside the routine depending on nlegend and\n"
16919 " nrow), and the length (calculated internally) of the longest text\n"
16922 " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
16923 " contains (after the call) the legend height in adopted\n"
16924 " coordinates. This quantity is calculated from text_scale,\n"
16925 " text_spacing, and nrow (possibly modified inside the routine\n"
16926 " depending on nlegend and nrow). \n"
16928 " opt (PLINT, input) : opt contains bits controlling the overall\n"
16929 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
16930 " on the left of the legend and the plotted area on the right.\n"
16931 " Otherwise, put the text area on the right of the legend and the\n"
16932 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
16933 " plot a (semi-transparent) background for the legend. If the\n"
16934 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
16935 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
16936 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
16937 " plot the resulting array of legend entries in row-major order.\n"
16938 " Otherwise, plot the legend entries in column-major order. \n"
16940 " position (PLINT, input) : position contains bits controlling the\n"
16941 " overall position of the legend and the definition of the adopted\n"
16942 " coordinates used for positions. The combination of the\n"
16943 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP,\n"
16944 " PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE\n"
16945 " bits specifies one of the 16 possible standard positions (the 4\n"
16946 " corners and 4 side centers for both the inside and outside cases)\n"
16947 " of the legend relative to the adopted coordinate system. The\n"
16948 " adopted coordinates are normalized viewport coordinates if the\n"
16949 " PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates\n"
16950 " if the PL_POSITION_SUBPAGE bit is set. Default position bits: If\n"
16951 " none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or\n"
16952 " PL_POSITION_BOTTOM are set, then use the combination of\n"
16953 " PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of\n"
16954 " PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use\n"
16955 " PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
16956 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
16958 " x (PLFLT, input) : X offset of the legend position in adopted\n"
16959 " coordinates from the specified standard position of the legend.\n"
16960 " For positive x, the direction of motion away from the standard\n"
16961 " position is inward/outward from the standard corner positions or\n"
16962 " standard left or right positions if the\n"
16963 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16964 " For the standard top or bottom positions, the direction of motion\n"
16965 " is toward positive X. \n"
16967 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
16968 " coordinates from the specified standard position of the legend.\n"
16969 " For positive y, the direction of motion away from the standard\n"
16970 " position is inward/outward from the standard corner positions or\n"
16971 " standard top or bottom positions if the\n"
16972 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16973 " For the standard left or right positions, the direction of motion\n"
16974 " is toward positive Y. \n"
16976 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
16977 " of the plot area (where the colored boxes, lines, and/or lines of\n"
16978 " symbols are drawn) of the legend. \n"
16980 " bg_color (PLINT, input) : The cmap0 index of the background color\n"
16981 " for the legend (PL_LEGEND_BACKGROUND). \n"
16983 " bb_color (PLINT, input) : The cmap0 index of the color of the\n"
16984 " bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX). \n"
16986 " bb_style (PLINT, input) : The cmap0 index of the background color\n"
16987 " for the legend (PL_LEGEND_BACKGROUND). \n"
16989 " nrow (PLINT, input) : The cmap0 index of the background color for\n"
16990 " the legend (PL_LEGEND_BACKGROUND). \n"
16992 " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
16993 " for the legend (PL_LEGEND_BACKGROUND). \n"
16995 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
16996 " vertical height of the legend in adopted coordinates is calculated\n"
16997 " internally from nlegend, text_scale (see below), and text_spacing\n"
17000 " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17001 " options to control each individual plotted area corresponding to a\n"
17002 " legend entry. If the \n"
17003 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17005 " PL_LEGEND_COLOR_BOX, \n"
17006 " PL_LEGEND_LINE, and/or \n"
17007 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17008 " entry is plotted with a colored box; a line; and/or a line of\n"
17011 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17012 " area in units of character width. N.B. The total horizontal\n"
17013 " width of the legend in adopted coordinates is calculated\n"
17014 " internally from \n"
17015 " plot_width (see above), \n"
17016 " text_offset, and length (calculated internally) of the longest text\n"
17019 " text_scale (PLFLT, input) : Character height scale for text\n"
17020 " annotations. N.B. The total vertical height of the legend in\n"
17021 " adopted coordinates is calculated internally from \n"
17022 " nlegend (see above), \n"
17023 " text_scale, and \n"
17024 " text_spacing (see below). \n"
17026 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17027 " character height from one legend entry to the next. N.B. The\n"
17028 " total vertical height of the legend in adopted coordinates is\n"
17029 " calculated internally from \n"
17030 " nlegend (see above), \n"
17031 " text_scale (see above), and \n"
17032 " text_spacing. \n"
17034 " text_justification (PLFLT, input) : Justification parameter used\n"
17035 " for text justification. The most common values of\n"
17036 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17037 " is left justified, centred, or right justified within the text\n"
17038 " area, but other values are allowed as well. \n"
17040 " text_colors (const PLINT *, input) : Array of nlegend text colors\n"
17041 " (cmap0 indices). \n"
17043 " text (const char **, input) : Array of nlegend text string\n"
17046 " box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n"
17047 " indices) for the discrete colored boxes (\n"
17048 " PL_LEGEND_COLOR_BOX). \n"
17050 " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17051 " (plpsty indices) for the discrete colored boxes (\n"
17052 " PL_LEGEND_COLOR_BOX). \n"
17054 " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17055 " of fraction of character height) for the height of the discrete\n"
17056 " colored boxes (\n"
17057 " PL_LEGEND_COLOR_BOX). \n"
17059 " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17060 " widths for the patterns specified by box_patterns (\n"
17061 " PL_LEGEND_COLOR_BOX). \n"
17063 " line_colors (const PLINT *, input) : Array of nlegend line colors\n"
17064 " (cmap0 indices) (\n"
17065 " PL_LEGEND_LINE). \n"
17067 " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17068 " (plsty indices) (\n"
17069 " PL_LEGEND_LINE). \n"
17071 " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17072 " PL_LEGEND_LINE). \n"
17074 " symbol_colors (const PLINT *, input) : Array of nlegend symbol\n"
17075 " colors (cmap0 indices) (\n"
17076 " PL_LEGEND_SYMBOL). \n"
17078 " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17079 " values for the symbol height (\n"
17080 " PL_LEGEND_SYMBOL). \n"
17082 " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17083 " symbols to be drawn across the width of the plotted area (\n"
17084 " PL_LEGEND_SYMBOL). \n"
17086 " symbols (const char **, input) : Array of nlegend symbols (plpoin\n"
17088 " PL_LEGEND_SYMBOL). \n"
17093 "Sets the 3D position of the light source \n"
17097 " Sets the 3D position of the light source for use with plsurf3d. \n"
17099 " Redacted form: pllightsource(x, y, z)\n"
17101 " This function is used in example 8. \n"
17107 "pllightsource(x, y, z)\n"
17111 " x (PLFLT, input) : X-coordinate of the light source. \n"
17113 " y (PLFLT, input) : Y-coordinate of the light source. \n"
17115 " z (PLFLT, input) : Z-coordinate of the light source. \n"
17118 { (
char *)
"plline",
_wrap_plline, METH_VARARGS, (
char *)
"\n"
17123 " Draws line defined by n points in x and y. \n"
17125 " Redacted form: plline(x, y)\n"
17127 " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
17133 "plline(n, x, y)\n"
17137 " n (PLINT, input) : Number of points defining line. \n"
17139 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17141 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17144 { (
char *)
"plline3",
_wrap_plline3, METH_VARARGS, (
char *)
"\n"
17145 "Draw a line in 3 space \n"
17149 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17150 " first set up the viewport, the 2d viewing window (in world\n"
17151 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17154 " Redacted form: plline3(x, y, z)\n"
17156 " This function is used in example 18. \n"
17162 "plline3(n, x, y, z)\n"
17166 " n (PLINT, input) : Number of points defining line. \n"
17168 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17170 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17172 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17175 { (
char *)
"pllsty",
_wrap_pllsty, METH_VARARGS, (
char *)
"\n"
17176 "Select line style \n"
17180 " This sets the line style according to one of eight predefined patterns\n"
17181 " (also see plstyl). \n"
17183 " Redacted form: pllsty(n)\n"
17185 " This function is used in examples 9,12,22,25. \n"
17195 " n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n"
17196 " continuous line, line style 2 is a line with short dashes and\n"
17197 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17198 " 4 has long dashes and short gaps and so on. \n"
17201 { (
char *)
"plmesh",
_wrap_plmesh, METH_VARARGS, (
char *)
"\n"
17202 "Plot surface mesh \n"
17206 " Plots a surface mesh within the environment set up by plw3d. The\n"
17207 " surface is defined by the two-dimensional array z[\n"
17209 " ny], the point z[i][j] being the value of the function at (\n"
17211 " y[j]). Note that the points in arrays x and y do not need to be\n"
17212 " equally spaced, but must be stored in ascending order. The parameter\n"
17213 " opt controls the way in which the surface is displayed. For further\n"
17214 " details see the PLplot documentation. \n"
17216 " Redacted form: plmesh(x, y, z, opt)\n"
17218 " This function is used in example 11. \n"
17224 "plmesh(x, y, z, nx, ny, opt)\n"
17228 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17229 " the function is evaluated. \n"
17231 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17232 " the function is evaluated. \n"
17234 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17235 " with set of function values. \n"
17237 " nx (PLINT, input) : Number of x values at which function is\n"
17240 " ny (PLINT, input) : Number of y values at which function is\n"
17243 " opt (PLINT, input) : Determines the way in which the surface is\n"
17244 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17245 " function of x for each value of y[j]. \n"
17246 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17247 " for each value of x[i]. \n"
17248 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17249 " at which function is defined. \n"
17252 { (
char *)
"plmeshc",
_wrap_plmeshc, METH_VARARGS, (
char *)
"\n"
17253 "Magnitude colored plot surface mesh with contour. \n"
17257 " Identical to plmesh but with extra functionalities: the surface mesh\n"
17258 " can be colored accordingly to the current z value being plotted, a\n"
17259 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17260 " drawn between the plotted function border and the base XY plane. \n"
17262 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17264 " This function is used in example 11. \n"
17270 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17274 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17275 " the function is evaluated. \n"
17277 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17278 " the function is evaluated. \n"
17280 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17281 " with set of function values. \n"
17283 " nx (PLINT, input) : Number of x values at which function is\n"
17286 " ny (PLINT, input) : Number of y values at which function is\n"
17289 " opt (PLINT, input) : Determines the way in which the surface is\n"
17290 " represented. To specify more than one option just add the options,\n"
17291 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
17292 " showing z as a function of x for each value of y[j]. \n"
17293 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17294 " for each value of x[i]. \n"
17295 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17296 " at which function is defined. \n"
17297 " opt=MAG_COLOR: Each line in the mesh is colored according to\n"
17298 " the z value being plotted. The color is used from the current\n"
17300 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17301 " using parameters \n"
17304 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17305 " the borders of the plotted function. \n"
17308 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17309 " contour level spacing. \n"
17311 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17314 { (
char *)
"plmkstrm",
_wrap_plmkstrm, METH_VARARGS, (
char *)
"\n"
17315 "Creates a new stream and makes it the default \n"
17319 " Creates a new stream and makes it the default. Differs from using\n"
17320 " plsstrm, in that a free stream number is found, and returned.\n"
17321 " Unfortunately, I have to start at stream 1 and work upward, since\n"
17322 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17323 " that no initial, library-opening call is required. So stream 0 must\n"
17324 " be preallocated, and there is no simple way of determining whether it\n"
17325 " is already in use or not. \n"
17327 " Redacted form: plmkstrm(p_strm)\n"
17329 " This function is used in examples 1,20. \n"
17335 "plmkstrm(p_strm)\n"
17339 " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
17343 { (
char *)
"plmtex",
_wrap_plmtex, METH_VARARGS, (
char *)
"\n"
17344 "Write text relative to viewport boundaries \n"
17348 " Writes text at a specified position relative to the viewport\n"
17349 " boundaries. Text may be written inside or outside the viewport, but\n"
17350 " is clipped at the subpage boundaries. The reference point of a string\n"
17351 " lies along a line passing through the string at half the height of a\n"
17352 " capital letter. The position of the reference point along this line\n"
17353 " is determined by just, and the position of the reference point\n"
17354 " relative to the viewport is set by disp and pos. \n"
17356 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17357 " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
17360 " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
17366 "plmtex(side, disp, pos, just, text)\n"
17370 " side (const char *, input) : Specifies the side of the viewport\n"
17371 " along which the text is to be written. The string must be one of:\n"
17372 " b: Bottom of viewport, text written parallel to edge. \n"
17373 " bv: Bottom of viewport, text written at right angles to edge. \n"
17374 " l: Left of viewport, text written parallel to edge. \n"
17375 " lv: Left of viewport, text written at right angles to edge. \n"
17376 " r: Right of viewport, text written parallel to edge. \n"
17377 " rv: Right of viewport, text written at right angles to edge. \n"
17378 " t: Top of viewport, text written parallel to edge. \n"
17379 " tv: Top of viewport, text written at right angles to edge. \n"
17382 " disp (PLFLT, input) : Position of the reference point of string,\n"
17383 " measured outwards from the specified viewport edge in units of the\n"
17384 " current character height. Use negative disp to write within the\n"
17387 " pos (PLFLT, input) : Position of the reference point of string\n"
17388 " along the specified edge, expressed as a fraction of the length of\n"
17391 " just (PLFLT, input) : Specifies the position of the string relative\n"
17392 " to its reference point. If just=0., the reference point is at the\n"
17393 " left and if just=1., it is at the right of the string. Other\n"
17394 " values of just give intermediate justifications. \n"
17396 " text (const char *, input) : The string to be written out. \n"
17399 { (
char *)
"plmtex3",
_wrap_plmtex3, METH_VARARGS, (
char *)
"\n"
17400 "Write text relative to viewport boundaries in 3D plots. \n"
17404 " Writes text at a specified position relative to the viewport\n"
17405 " boundaries. Text may be written inside or outside the viewport, but\n"
17406 " is clipped at the subpage boundaries. The reference point of a string\n"
17407 " lies along a line passing through the string at half the height of a\n"
17408 " capital letter. The position of the reference point along this line\n"
17409 " is determined by just, and the position of the reference point\n"
17410 " relative to the viewport is set by disp and pos. \n"
17412 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17414 " This function is used in example 28. \n"
17420 "plmtex3(side, disp, pos, just, text)\n"
17424 " side (const char *, input) : Specifies the side of the viewport\n"
17425 " along which the text is to be written. The string should contain\n"
17426 " one or more of the following characters: [xyz][ps][v]. Only one\n"
17427 " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
17428 " both the X and Y axes. x: Label the X axis. \n"
17429 " y: Label the Y axis. \n"
17430 " z: Label the Z axis. \n"
17431 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17432 " For X it is the axis that starts at y-min. For Y it is the\n"
17433 " axis that starts at x-min. \n"
17434 " s: Label the secondary axis. \n"
17435 " v: Draw the text perpendicular to the axis. \n"
17438 " disp (PLFLT, input) : Position of the reference point of string,\n"
17439 " measured outwards from the specified viewport edge in units of the\n"
17440 " current character height. Use negative disp to write within the\n"
17443 " pos (PLFLT, input) : Position of the reference point of string\n"
17444 " along the specified edge, expressed as a fraction of the length of\n"
17447 " just (PLFLT, input) : Specifies the position of the string relative\n"
17448 " to its reference point. If just=0., the reference point is at the\n"
17449 " left and if just=1., it is at the right of the string. Other\n"
17450 " values of just give intermediate justifications. \n"
17452 " text (const char *, input) : The string to be written out. \n"
17455 { (
char *)
"plot3d",
_wrap_plot3d, METH_VARARGS, (
char *)
"\n"
17456 "Plot 3-d surface plot \n"
17460 " Plots a three dimensional surface plot within the environment set up\n"
17461 " by plw3d. The surface is defined by the two-dimensional array z[\n"
17463 " ny], the point z[i][j] being the value of the function at (\n"
17465 " y[j]). Note that the points in arrays x and y do not need to be\n"
17466 " equally spaced, but must be stored in ascending order. The parameter\n"
17467 " opt controls the way in which the surface is displayed. For further\n"
17468 " details see the PLplot documentation. The only difference between\n"
17469 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17470 " while plot3d only draws the surface as viewed from the top. \n"
17472 " Redacted form: plot3d(x, y, z, opt, side)\n"
17474 " This function is used in examples 11,21. \n"
17480 "plot3d(x, y, z, nx, ny, opt, side)\n"
17484 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17485 " the function is evaluated. \n"
17487 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17488 " the function is evaluated. \n"
17490 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17491 " with set of function values. \n"
17493 " nx (PLINT, input) : Number of x values at which function is\n"
17496 " ny (PLINT, input) : Number of y values at which function is\n"
17499 " opt (PLINT, input) : Determines the way in which the surface is\n"
17500 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17501 " function of x for each value of y[j]. \n"
17502 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17503 " for each value of x[i]. \n"
17504 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17505 " at which function is defined. \n"
17508 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17509 " should be draw on the figure. If side is true sides are drawn,\n"
17510 " otherwise no sides are drawn. \n"
17513 { (
char *)
"plot3dc",
_wrap_plot3dc, METH_VARARGS, (
char *)
"\n"
17514 "Magnitude colored plot surface with contour. \n"
17518 " Identical to plot3d but with extra functionalities: the surface mesh\n"
17519 " can be colored accordingly to the current z value being plotted, a\n"
17520 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17521 " drawn between the plotted function border and the base XY plane. The\n"
17522 " arguments are identical to plmeshc. The only difference between\n"
17523 " plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
17524 " surface, while plot3dc only draws the surface as viewed from the top. \n"
17526 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17527 " Perl/PDL: Not available? \n"
17530 " This function is used in example 21. \n"
17536 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17540 { (
char *)
"plsurf3d",
_wrap_plsurf3d, METH_VARARGS, (
char *)
"\n"
17541 "Plot shaded 3-d surface plot \n"
17545 " Plots a three dimensional shaded surface plot within the environment\n"
17546 " set up by plw3d. The surface is defined by the two-dimensional array\n"
17549 " ny], the point z[i][j] being the value of the function at (\n"
17551 " y[j]). Note that the points in arrays x and y do not need to be\n"
17552 " equally spaced, but must be stored in ascending order. For further\n"
17553 " details see the PLplot documentation. \n"
17555 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
17557 " This function is not used in any examples. \n"
17563 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17567 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17568 " the function is evaluated. \n"
17570 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17571 " the function is evaluated. \n"
17573 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17574 " with set of function values. \n"
17576 " nx (PLINT, input) : Number of x values at which function is\n"
17579 " ny (PLINT, input) : Number of y values at which function is\n"
17582 " opt (PLINT, input) : Determines the way in which the surface is\n"
17583 " represented. To specify more than one option just add the options,\n"
17584 " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
17585 " connecting points at which function is defined. \n"
17586 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17587 " using parameters \n"
17590 " opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
17591 " using parameters \n"
17594 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17595 " the borders of the plotted function. \n"
17596 " opt=MAG_COLOR: the surface is colored according to the value\n"
17597 " of Z; if MAG_COLOR is not used, then the default the surface\n"
17598 " is colored according to the intensity of the reflected light\n"
17599 " in the surface from a light source whose position is set using\n"
17600 " pllightsource. \n"
17603 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17604 " contour level spacing. \n"
17606 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17611 "Parse command-line arguments \n"
17615 " Parse command-line arguments. \n"
17617 " plparseopts removes all recognized flags (decreasing argc\n"
17618 " accordingly), so that invalid input may be readily detected. It can\n"
17619 " also be used to process user command line flags. The user can merge\n"
17620 " an option table of type PLOptionTable into the internal option table\n"
17621 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
17622 " the external table(s) be parsed by calling plClearOpts before\n"
17625 " The default action taken by plparseopts is as follows: \n"
17626 " Returns with an error if an unrecognized option or badly formed\n"
17627 " option-value pair are encountered. \n"
17628 " Returns immediately (return code 0) when the first non-option command\n"
17629 " line argument is found. \n"
17630 " Returns with the return code of the option handler, if one was called.\n"
17632 " Deletes command line arguments from argv list as they are found, and\n"
17633 " decrements argc accordingly. \n"
17634 " Does not show \"invisible\" options in usage or help messages. \n"
17635 " Assumes the program name is contained in argv[0]. \n"
17637 " These behaviors may be controlled through the \n"
17638 " mode argument. \n"
17640 " Redacted form: General: plparseopts(argv, mode)\n"
17641 " Perl/PDL: Not available? \n"
17644 " This function is used in all of the examples. \n"
17650 "int plparseopts(p_argc, argv, mode)\n"
17654 " p_argc (int *, input) : pointer to number of arguments. \n"
17656 " argv (char **, input) : Pointer to character array containing\n"
17657 " *p_argc command-line arguments. \n"
17659 " mode (PLINT, input) : Parsing mode with the following\n"
17660 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
17661 " and all error messages enabled, including program exit when an\n"
17662 " error occurs. Anything on the command line that isn't recognized\n"
17663 " as a valid option or option argument is flagged as an error. \n"
17664 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
17666 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
17668 " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17669 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17670 " pointer to the program name. \n"
17671 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17672 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17673 " unrecognized arguments. \n"
17676 { (
char *)
"plpat",
_wrap_plpat, METH_VARARGS, (
char *)
"\n"
17677 "Set area fill pattern \n"
17681 " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
17682 " parallel lines with specified inclinations and spacings. The\n"
17683 " arguments to this routine are the number of sets to use (1 or 2)\n"
17684 " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17685 " specifying the inclinations in tenths of a degree and the spacing in\n"
17686 " micrometers. (also see plpsty) \n"
17688 " Redacted form: General: plpat(inc, del)\n"
17689 " Perl/PDL: plpat(nlin, inc, del)\n"
17692 " This function is used in example 15. \n"
17698 "plpat(nlin, inc, del)\n"
17702 " nlin (PLINT, input) : Number of sets of lines making up the\n"
17703 " pattern, either 1 or 2. \n"
17705 " inc (PLINT *, input) : Pointer to array with nlin elements.\n"
17706 " Specifies the line inclination in tenths of a degree. (Should be\n"
17707 " between -900 and 900). \n"
17709 " del (PLINT *, input) : Pointer to array with nlin elements.\n"
17710 " Specifies the spacing in micrometers between the lines making up\n"
17714 { (
char *)
"plpoin",
_wrap_plpoin, METH_VARARGS, (
char *)
"\n"
17715 "Plot a glyph at the specified points \n"
17719 " Plot a glyph at the specified points. (This function is largely\n"
17720 " superseded by plstring which gives access to many[!] more glyphs.)\n"
17721 " code=-1 means try to just draw a point. Right now it's just a move\n"
17722 " and a draw at the same place. Not ideal, since a sufficiently\n"
17723 " intelligent output device may optimize it away, or there may be faster\n"
17724 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17725 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17726 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17727 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17728 " code <= 127 the corresponding printable ASCII character is plotted. \n"
17730 " Redacted form: plpoin(x, y, code)\n"
17732 " This function is used in examples 1,6,14,29. \n"
17738 "plpoin(n, x, y, code)\n"
17742 " n (PLINT, input) : Number of points in the x and y arrays. \n"
17744 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17747 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17750 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17751 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17752 " each of the n points. \n"
17755 { (
char *)
"plpoin3",
_wrap_plpoin3, METH_VARARGS, (
char *)
"\n"
17756 "Plot a glyph at the specified 3D points \n"
17760 " Plot a glyph at the specified 3D points. (This function is largely\n"
17761 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
17762 " Set up the call to this function similar to what is done for plline3.\n"
17763 " code=-1 means try to just draw a point. Right now it's just a move\n"
17764 " and a draw at the same place. Not ideal, since a sufficiently\n"
17765 " intelligent output device may optimize it away, or there may be faster\n"
17766 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17767 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17768 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17769 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17770 " code <= 127 the corresponding printable ASCII character is plotted. \n"
17772 " Redacted form: plpoin3(x, y, z, code)\n"
17774 " This function is not used in any example. \n"
17780 "plpoin3(n, x, y, z, code)\n"
17784 " n (PLINT, input) : Number of points in the x and y arrays. \n"
17786 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17789 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17792 " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
17795 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17796 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17797 " each of the n points. \n"
17800 { (
char *)
"plpoly3",
_wrap_plpoly3, METH_VARARGS, (
char *)
"\n"
17801 "Draw a polygon in 3 space \n"
17805 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
17806 " like plline3, but differs from that function in that plpoly3 attempts\n"
17807 " to determine if the polygon is viewable depending on the order of the\n"
17808 " points within the arrays and the value of ifcc. If the back of\n"
17809 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
17810 " you want, then use plline3 instead. \n"
17812 " The points are assumed to be in a plane, and the directionality of the\n"
17813 " plane is determined from the first three points. Additional points do\n"
17814 " not have to lie on the plane defined by the first three, but if they\n"
17815 " do not, then the determination of visibility obviously can't be 100%\n"
17816 " accurate... So if you're 3 space polygons are too far from planar,\n"
17817 " consider breaking them into smaller polygons. 3 points define a plane\n"
17820 " Bugs: If one of the first two segments is of zero length, or if they\n"
17821 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
17822 " being correct. Avoid such situations :-). See x18c.c for an example\n"
17823 " of this problem. (Search for 20.1). \n"
17825 " Redacted form: plpoly3(x, y, z, code)\n"
17827 " This function is used in example 18. \n"
17833 "plpoly3(n, x, y, z, draw, ifcc)\n"
17837 " n (PLINT, input) : Number of points defining line. \n"
17839 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17841 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17843 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17845 " draw (PLBOOL *, input) : Pointer to array which controls drawing\n"
17846 " the segments of the polygon. If draw[i] is true, then the polygon\n"
17847 " segment from index [i] to [i+1] is drawn, otherwise, not. \n"
17849 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
17850 " polygon is determined by assuming the points are laid out in a\n"
17851 " counter-clockwise order. Otherwise, the directionality of the\n"
17852 " polygon is determined by assuming the points are laid out in a\n"
17853 " clockwise order. \n"
17856 { (
char *)
"plprec",
_wrap_plprec, METH_VARARGS, (
char *)
"\n"
17857 "Set precision in numeric labels \n"
17861 " Sets the number of places after the decimal point in numeric labels. \n"
17863 " Redacted form: plprec(set, prec)\n"
17865 " This function is used in example 29. \n"
17871 "plprec(set, prec)\n"
17875 " set (PLINT, input) : If set is equal to 0 then PLplot automatically\n"
17876 " determines the number of places to use after the decimal point in\n"
17877 " numeric labels (like those used to label axes). If set is 1 then\n"
17878 " prec sets the number of places. \n"
17880 " prec (PLINT, input) : The number of characters to draw after the\n"
17881 " decimal point in numeric labels. \n"
17884 { (
char *)
"plpsty",
_wrap_plpsty, METH_VARARGS, (
char *)
"\n"
17885 "Select area fill pattern \n"
17889 " Select one of eight predefined area fill patterns to use (also see\n"
17890 " plpat). Setting the fill style to 0 gives a solid fill. \n"
17892 " Redacted form: plpsty(n)\n"
17894 " This function is used in examples 12,13,15,16,25. \n"
17904 " n (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
17905 " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
17906 " consists of lines at 45 degrees angle (upward), and so on. \n"
17909 { (
char *)
"plptex",
_wrap_plptex, METH_VARARGS, (
char *)
"\n"
17910 "Write text inside the viewport \n"
17914 " Writes text at a specified position and inclination within the\n"
17915 " viewport. Text is clipped at the viewport boundaries. The reference\n"
17916 " point of a string lies along a line passing through the string at half\n"
17917 " the height of a capital letter. The position of the reference point\n"
17918 " along this line is determined by just, the reference point is placed\n"
17919 " at world coordinates (\n"
17921 " y) within the viewport. The inclination of the string is specified in\n"
17922 " terms of differences of world coordinates making it easy to write text\n"
17923 " parallel to a line in a graph. \n"
17925 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
17927 " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
17933 "plptex(x, y, dx, dy, just, text)\n"
17937 " x (PLFLT, input) : x coordinate of reference point of string. \n"
17939 " y (PLFLT, input) : y coordinate of reference point of string. \n"
17941 " dx (PLFLT, input) : Together with dy, this specifies the\n"
17942 " inclination of the string. The baseline of the string is parallel\n"
17943 " to a line joining (\n"
17951 " dy (PLFLT, input) : Together with dx, this specifies the\n"
17952 " inclination of the string. \n"
17954 " just (PLFLT, input) : Specifies the position of the string relative\n"
17955 " to its reference point. If just=0., the reference point is at the\n"
17956 " left and if just=1., it is at the right of the string. Other\n"
17957 " values of just give intermediate justifications. \n"
17959 " text (const char *, input) : The string to be written out. \n"
17962 { (
char *)
"plptex3",
_wrap_plptex3, METH_VARARGS, (
char *)
"\n"
17963 "Write text inside the viewport of a 3D plot. \n"
17967 " Writes text at a specified position and inclination and with a\n"
17968 " specified shear within the viewport. Text is clipped at the viewport\n"
17969 " boundaries. The reference point of a string lies along a line passing\n"
17970 " through the string at half the height of a capital letter. The\n"
17971 " position of the reference point along this line is determined by just,\n"
17972 " and the reference point is placed at world coordinates (\n"
17975 " z) within the viewport. The inclination and shear of the string is\n"
17976 " specified in terms of differences of world coordinates making it easy\n"
17977 " to write text parallel to a line in a graph. \n"
17979 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17981 " This function is used in example 28. \n"
17987 "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17991 " x (PLFLT, input) : x coordinate of reference point of string. \n"
17993 " y (PLFLT, input) : y coordinate of reference point of string. \n"
17995 " z (PLFLT, input) : z coordinate of reference point of string. \n"
17997 " dx (PLFLT, input) : Together with dy and \n"
17998 " dz, this specifies the inclination of the string. The baseline of\n"
17999 " the string is parallel to a line joining (\n"
18010 " dy (PLFLT, input) : Together with dx and \n"
18011 " dz, this specifies the inclination of the string. \n"
18013 " dz (PLFLT, input) : Together with dx and \n"
18014 " dy, this specifies the inclination of the string. \n"
18016 " sx (PLFLT, input) : Together with sy and \n"
18017 " sz, this specifies the shear of the string. The string is sheared so\n"
18018 " that the characters are vertically parallel to a line joining (\n"
18029 " sz = 0.) then the text is not sheared. \n"
18031 " sy (PLFLT, input) : Together with sx and \n"
18032 " sz, this specifies shear of the string. \n"
18034 " sz (PLFLT, input) : Together with sx and \n"
18035 " sy, this specifies shear of the string. \n"
18037 " just (PLFLT, input) : Specifies the position of the string relative\n"
18038 " to its reference point. If just=0., the reference point is at the\n"
18039 " left and if just=1., it is at the right of the string. Other\n"
18040 " values of just give intermediate justifications. \n"
18042 " text (const char *, input) : The string to be written out. \n"
18045 { (
char *)
"plrandd",
_wrap_plrandd, METH_VARARGS, (
char *)
"\n"
18046 "Random number generator returning a real random number in the range [0,1]. \n"
18050 " Random number generator returning a real random number in the range\n"
18051 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18052 " / compilers provide their own random number generator, and so this is\n"
18053 " provided purely for convenience and to give a consistent random number\n"
18054 " generator across all languages supported by PLplot. This is\n"
18055 " particularly useful for comparing results from the test suite of\n"
18058 " Redacted form: plrandd()\n"
18060 " This function is used in examples 17,21. \n"
18069 { (
char *)
"plreplot",
_wrap_plreplot, METH_VARARGS, (
char *)
"\n"
18070 "Replays contents of plot buffer to current device/file \n"
18074 " Replays contents of plot buffer to current device/file. \n"
18076 " Redacted form: plreplot()\n"
18078 " This function is used in example 1,20. \n"
18087 { (
char *)
"plrgbhls",
_wrap_plrgbhls, METH_VARARGS, (
char *)
"\n"
18088 "Convert RGB color to HLS \n"
18092 " Convert RGB color coordinates to HLS \n"
18094 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18095 " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
18098 " This function is used in example 2. \n"
18104 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18108 " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
18110 " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
18112 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
18114 " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
18115 " cone (0.0-360.0) \n"
18117 " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
18118 " fraction of the axis of the colour cone (0.0-1.0) \n"
18120 " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
18121 " fraction of the radius of the colour cone (0.0-1.0) \n"
18124 { (
char *)
"plschr",
_wrap_plschr, METH_VARARGS, (
char *)
"\n"
18125 "Set character size \n"
18129 " This sets up the size of all subsequent characters drawn. The actual\n"
18130 " height of a character is the product of the default character size and\n"
18131 " a scaling factor. \n"
18133 " Redacted form: plschr(def, scale)\n"
18135 " This function is used in example 2,13,23,24. \n"
18141 "plschr(def, scale)\n"
18145 " def (PLFLT, input) : The default height of a character in\n"
18146 " millimeters, should be set to zero if the default height is to\n"
18147 " remain unchanged. \n"
18149 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18150 " actual character height. \n"
18153 { (
char *)
"plscmap0",
_wrap_plscmap0, METH_VARARGS, (
char *)
"\n"
18154 "Set color map0 colors by 8-bit RGB values \n"
18158 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18159 " documentation). This sets the entire color map -- only as many colors\n"
18160 " as specified will be allocated. \n"
18162 " Redacted form: plscmap0(r, g, b, ncol0)\n"
18164 " This function is used in examples 2,24. \n"
18170 "plscmap0(r, g, b, ncol0)\n"
18174 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18175 " integers (0-255) representing the degree of red in the color. \n"
18177 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18178 " integers (0-255) representing the degree of green in the color. \n"
18180 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18181 " integers (0-255) representing the degree of blue in the color. \n"
18183 " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18187 "Set color map0 colors by 8-bit RGB values and double alpha value. \n"
18191 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18192 " documentation) and floating point alpha value. This sets the entire\n"
18193 " color map -- only as many colors as specified will be allocated. \n"
18195 " This function is used in examples 30. \n"
18201 "plscmap0a(r, g, b, a, ncol0)\n"
18205 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18206 " integers (0-255) representing the degree of red in the color. \n"
18208 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18209 " integers (0-255) representing the degree of green in the color. \n"
18211 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18212 " integers (0-255) representing the degree of blue in the color. \n"
18214 " a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n"
18215 " - 1.0) representing the transparency of the color. \n"
18217 " ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n"
18222 "Set number of colors in color map0 \n"
18226 " Set number of colors in color map0 (see the PLplot documentation).\n"
18227 " Allocate (or reallocate) color map0, and fill with default values for\n"
18228 " those colors not previously allocated. The first 16 default colors are\n"
18229 " given in the plcol0 documentation. For larger indices the default\n"
18230 " color is red. \n"
18232 " The drivers are not guaranteed to support more than 16 colors. \n"
18234 " Redacted form: plscmap0n(ncol0)\n"
18236 " This function is used in examples 15,16,24. \n"
18242 "plscmap0n(ncol0)\n"
18246 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18247 " the map0 palette. If this number is zero or less, then the value\n"
18248 " from the previous call to plscmap0n is used and if there is no\n"
18249 " previous call, then a default value is used. \n"
18252 { (
char *)
"plscmap1",
_wrap_plscmap1, METH_VARARGS, (
char *)
"\n"
18253 "Set color map1 colors using 8-bit RGB values \n"
18257 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18258 " documentation). This also sets the number of colors. \n"
18260 " Redacted form: plscmap1(r, g, b, ncol1)\n"
18262 " This function is used in example 31. \n"
18268 "plscmap1(r, g, b, ncol1)\n"
18272 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18273 " integers (0-255) representing the degree of red in the color. \n"
18275 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18276 " integers (0-255) representing the degree of green in the color. \n"
18278 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18279 " integers (0-255) representing the degree of blue in the color. \n"
18281 " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18285 "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
18289 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18290 " documentation) and double alpha values. This also sets the number of\n"
18293 " This function is used in example 31. \n"
18299 "plscmap1a(r, g, b, a, ncol1)\n"
18303 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18304 " integers (0-255) representing the degree of red in the color. \n"
18306 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18307 " integers (0-255) representing the degree of green in the color. \n"
18309 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18310 " integers (0-255) representing the degree of blue in the color. \n"
18312 " a (PLFLT *, input) : Pointer to array with set of double values\n"
18313 " (0.0-1.0) representing the alpha value of the color. \n"
18315 " ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n"
18320 "Set color map1 colors using a piece-wise linear relationship \n"
18324 " Set color map1 colors using a piece-wise linear relationship between\n"
18325 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18326 " color space (see the PLplot documentation). May be called at any\n"
18329 " The idea here is to specify a number of control points that define the\n"
18330 " mapping between palette 1 input positions (intensities) and HLS (or\n"
18331 " RGB). Between these points, linear interpolation is used which gives\n"
18332 " a smooth variation of color with input position. Any number of\n"
18333 " control points may be specified, located at arbitrary positions,\n"
18334 " although typically 2 - 4 are enough. Another way of stating this is\n"
18335 " that we are traversing a given number of lines through HLS (or RGB)\n"
18336 " space as we move through color map1 entries. The control points at\n"
18337 " the minimum and maximum position (0 and 1) must always be specified. \n"
18338 " By adding more control points you can get more variation. One good\n"
18339 " technique for plotting functions that vary about some expected average\n"
18340 " is to use an additional 2 control points in the center (position ~=\n"
18341 " 0.5) that are the same lightness as the background (typically white\n"
18342 " for paper output, black for crt), and same hue as the boundary control\n"
18343 " points. This allows the highs and lows to be very easily\n"
18344 " distinguished. \n"
18346 " Each control point must specify the position in color map1 as well as\n"
18347 " three coordinates in HLS or RGB space. The first point must\n"
18348 " correspond to position = 0, and the last to position = 1. \n"
18350 " The default behaviour is for the hue to be linearly interpolated \n"
18351 " between the control points. Since the hue lies in the range [0, 360]\n"
18352 " this corresponds to interpolation around the \"front\" of the color\n"
18353 " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
18354 " alternative interpolation is used between control points i and i+1. If\n"
18355 " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n"
18356 " hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n"
18357 " consider this as interpolation around the \"back\" or \"reverse\" of the\n"
18358 " color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
18359 " alt_hue_path[] = false for every control point. \n"
18361 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
18362 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
18363 " 240]truegreen-yellow-red-magenta-blue[240\n"
18364 " 120]trueblue-magenta-red-yellow-green\n"
18366 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
18367 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
18368 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
18370 " Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n"
18373 " This function is used in examples 8,11,12,15,20,21. \n"
18379 "plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n"
18383 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18385 " npts (PLINT, input) : number of control points \n"
18387 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18388 " and 1.0, in ascending order) \n"
18390 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18391 " control point \n"
18393 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18394 " control point \n"
18396 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18397 " control point \n"
18399 " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18400 " flag for each control point. (alt_hue_path[i] refers to the\n"
18401 " interpolation interval between the i and i + 1 control points). \n"
18405 "Set color map1 colors using a piece-wise linear relationship \n"
18409 " This is a version of plscmap1l that supports alpha transparency. It\n"
18410 " sets color map1 colors using a piece-wise linear relationship between\n"
18411 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18412 " color space (see the PLplot documentation) with alpha value (0.0 -\n"
18413 " 1.0). It may be called at any time. \n"
18415 " This function is used in example 30. \n"
18421 "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n"
18425 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18427 " npts (PLINT, input) : number of control points \n"
18429 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18430 " and 1.0, in ascending order) \n"
18432 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18433 " control point \n"
18435 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18436 " control point \n"
18438 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18439 " control point \n"
18441 " coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n"
18442 " each control point \n"
18444 " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18445 " flag for each control point. (alt_hue_path[i] refers to the\n"
18446 " interpolation interval between the i and i + 1 control points). \n"
18450 "Set number of colors in color map1 \n"
18454 " Set number of colors in color map1, (re-)allocate color map1, and set\n"
18455 " default values if this is the first allocation (see the PLplot\n"
18456 " documentation). \n"
18458 " Redacted form: plscmap1n(ncol1)\n"
18460 " This function is used in examples 8,11,20,21. \n"
18466 "plscmap1n(ncol1)\n"
18470 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
18471 " the map1 palette. If this number is zero or less, then the value\n"
18472 " from the previous call to plscmap1n is used and if there is no\n"
18473 " previous call, then a default value is used. \n"
18478 { (
char *)
"plscol0",
_wrap_plscol0, METH_VARARGS, (
char *)
"\n"
18479 "Set a given color from color map0 by 8 bit RGB value \n"
18483 " Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
18484 " documentation). Overwrites the previous color value for the given\n"
18485 " index and, thus, does not result in any additional allocation of space\n"
18488 " Redacted form: plscol0(icol0, r, g, b)\n"
18490 " This function is not used in any examples. \n"
18496 "lscol0(icol0, r, g, b)\n"
18500 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18501 " number of colors (which is set by default, by plscmap0n, or even\n"
18502 " by plscmap0). \n"
18504 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18505 " degree of red in the color. \n"
18507 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18508 " degree of green in the color. \n"
18510 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18511 " degree of blue in the color. \n"
18514 { (
char *)
"plscol0a",
_wrap_plscol0a, METH_VARARGS, (
char *)
"\n"
18515 "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
18519 " Set a given color by 8-bit RGB value and double alpha value for color \n"
18520 " map0 (see the PLplot documentation). Overwrites the previous color\n"
18521 " value for the given index and, thus, does not result in any\n"
18522 " additional allocation of space for colors. \n"
18524 " This function is used in example 30. \n"
18530 "lscol0a(icol0, r, g, b, a)\n"
18534 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18535 " number of colors (which is set by default, by plscmap0n, or even\n"
18536 " by plscmap0). \n"
18538 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18539 " degree of red in the color. \n"
18541 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18542 " degree of green in the color. \n"
18544 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18545 " degree of blue in the color. \n"
18547 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18548 " value of the color. \n"
18551 { (
char *)
"plscolbg",
_wrap_plscolbg, METH_VARARGS, (
char *)
"\n"
18552 "Set the background color by 8-bit RGB value \n"
18556 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18557 " (see the PLplot documentation). \n"
18559 " Redacted form: plscolbg(r, g, b)\n"
18561 " This function is used in examples 15,31. \n"
18567 "plscolbg(r, g, b)\n"
18571 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18572 " degree of red in the color. \n"
18574 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18575 " degree of green in the color. \n"
18577 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18578 " degree of blue in the color. \n"
18582 "Set the background color by 8-bit RGB value and double alpha value. \n"
18586 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18587 " (see the PLplot documentation) and double alpha value. \n"
18589 " This function is used in example 31. \n"
18595 "plscolbga(r, g, b, a)\n"
18599 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18600 " degree of red in the color. \n"
18602 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18603 " degree of green in the color. \n"
18605 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18606 " degree of blue in the color. \n"
18608 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18609 " value of the color. \n"
18612 { (
char *)
"plscolor",
_wrap_plscolor, METH_VARARGS, (
char *)
"\n"
18613 "Used to globally turn color output on/off \n"
18617 " Used to globally turn color output on/off for those drivers/devices\n"
18618 " that support it. \n"
18620 " Redacted form: plscolor(color)\n"
18622 " This function is used in example 31. \n"
18628 "plscolor(color)\n"
18632 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
18633 " turned off. If non-zero, color is turned on. \n"
18637 "Set device-compression level \n"
18641 " Set device-compression level. Only used for drivers that provide\n"
18642 " compression. This function, if used, should be invoked before a call\n"
18645 " Redacted form: plscompression(compression)\n"
18647 " This function is used in example 31. \n"
18653 "plscompression(compression)\n"
18657 " compression (PLINT, input) : The desired compression level. This is\n"
18658 " a device-dependent value. Currently only the jpeg and png devices\n"
18659 " use these values. For jpeg value is the jpeg quality which should\n"
18660 " normally be in the range 0-95. Higher values denote higher quality\n"
18661 " and hence larger image sizes. For png values are in the range -1\n"
18662 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
18663 " A value of -1 denotes the default zlib compression level. Values\n"
18664 " in the range 10-99 are divided by 10 and then used as the zlib\n"
18665 " compression level. Higher compression levels correspond to greater\n"
18666 " compression and small file sizes at the expense of more\n"
18670 { (
char *)
"plsdev",
_wrap_plsdev, METH_VARARGS, (
char *)
"\n"
18671 "Set the device (keyword) name \n"
18675 " Set the device (keyword) name. \n"
18677 " Redacted form: plsdev(devname)\n"
18679 " This function is used in examples 1,14,20. \n"
18685 "plsdev(devname)\n"
18689 " devname (const char *, input) : Pointer to device (keyword) name\n"
18693 { (
char *)
"plsdidev",
_wrap_plsdidev, METH_VARARGS, (
char *)
"\n"
18694 "Set parameters that define current device-space window \n"
18698 " Set relative margin width, aspect ratio, and relative justification\n"
18699 " that define current device-space window. If you want to just use the\n"
18700 " previous value for any of these, just pass in the magic value\n"
18701 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
18702 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
18703 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
18704 " to a device-specific value. \n"
18706 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
18708 " This function is used in example 31. \n"
18714 "plsdidev(mar, aspect, jx, jy)\n"
18718 " mar (PLFLT, input) : Relative margin width. \n"
18720 " aspect (PLFLT, input) : Aspect ratio. \n"
18722 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
18723 " the range -0.5 to 0.5. \n"
18725 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
18726 " the range -0.5 to 0.5. \n"
18729 { (
char *)
"plsdimap",
_wrap_plsdimap, METH_VARARGS, (
char *)
"\n"
18730 "Set up transformation from metafile coordinates \n"
18734 " Set up transformation from metafile coordinates. The size of the plot\n"
18735 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
18736 " general-purpose facility just yet (not sure why the user would need\n"
18737 " it, for one). \n"
18739 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
18742 " This function is not used in any examples. \n"
18748 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
18752 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
18754 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
18756 " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
18758 " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
18760 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18762 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18765 { (
char *)
"plsdiori",
_wrap_plsdiori, METH_VARARGS, (
char *)
"\n"
18766 "Set plot orientation \n"
18770 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
18771 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
18772 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
18773 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
18774 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
18775 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
18776 " not called the default value of rot is 0. \n"
18778 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
18779 " probably want to change the aspect ratio to a value suitable for the\n"
18780 " plot orientation using a call to plsdidev or the command-line options\n"
18781 " -a or -freeaspect. For more documentation of those options see the\n"
18782 " PLplot documentation. Such command-line options can be set internally\n"
18783 " using plsetopt or set directly using the command line and parsed using\n"
18784 " a call to plparseopts. \n"
18786 " Redacted form: plsdiori(rot)\n"
18788 " This function is not used in any examples. \n"
18798 " rot (PLFLT, input) : Plot orientation parameter. \n"
18801 { (
char *)
"plsdiplt",
_wrap_plsdiplt, METH_VARARGS, (
char *)
"\n"
18802 "Set parameters that define current plot-space window \n"
18806 " Set relative minima and maxima that define the current plot-space\n"
18807 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
18808 " xmax, and ymax are 0., 0., 1., and 1. \n"
18810 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
18812 " This function is used in example 31. \n"
18818 "plsdiplt(xmin, ymin, xmax, ymax)\n"
18822 " xmin (PLFLT, input) : Relative minimum in x. \n"
18824 " ymin (PLFLT, input) : Relative minimum in y. \n"
18826 " xmax (PLFLT, input) : Relative maximum in x. \n"
18828 " ymax (PLFLT, input) : Relative maximum in y. \n"
18831 { (
char *)
"plsdiplz",
_wrap_plsdiplz, METH_VARARGS, (
char *)
"\n"
18832 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
18836 " Set relative minima and maxima incrementally (zoom mode) that define\n"
18837 " the current plot-space window. This function has the same effect as\n"
18838 " plsdiplt if that function has not been previously called. Otherwise,\n"
18839 " this function implements zoom mode using the transformation min_used =\n"
18840 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
18841 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
18842 " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
18844 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
18846 " This function is used in example 31. \n"
18852 "plsdiplz(xmin, ymin, xmax, ymax)\n"
18856 " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
18858 " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
18860 " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
18862 " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
18865 { (
char *)
"plseed",
_wrap_plseed, METH_VARARGS, (
char *)
"\n"
18866 "Set seed for internal random number generator. \n"
18870 " Set the seed for the internal random number generator. See plrandd for\n"
18871 " further details. \n"
18873 " Redacted form: plseed(seed)\n"
18875 " This function is used in example 21. \n"
18885 " seed (unsigned int, input) : Seed for random number generator. \n"
18888 { (
char *)
"plsesc",
_wrap_plsesc, METH_VARARGS, (
char *)
"\n"
18889 "Set the escape character for text strings \n"
18893 " Set the escape character for text strings. From C (in contrast to\n"
18894 " Fortran 77, see plsescfortran77) you pass esc as a character. Only\n"
18895 " selected characters are allowed to prevent the user from shooting\n"
18896 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
18897 " with C's use of backslash as a character escape). Here are the\n"
18898 " allowed escape characters and their corresponding decimal ASCII\n"
18899 " values: !, ASCII 33 \n"
18910 " Redacted form: General: plsesc(esc)\n"
18911 " Perl/PDL: Not available? \n"
18914 " This function is used in example 29. \n"
18924 " esc (char, input) : Escape character. \n"
18927 { (
char *)
"plsetopt",
_wrap_plsetopt, METH_VARARGS, (
char *)
"\n"
18928 "Set any command-line option \n"
18932 " Set any command-line option internally from a program before it\n"
18933 " invokes plinit. opt is the name of the command-line option and optarg\n"
18934 " is the corresponding command-line option argument. \n"
18936 " This function returns 0 on success. \n"
18938 " Redacted form: plsetopt(opt, optarg)\n"
18940 " This function is used in example 14. \n"
18946 "int plsetopt(opt, optarg)\n"
18950 " opt (const char *, input) : Pointer to string containing the\n"
18951 " command-line option. \n"
18953 " optarg (const char *, input) : Pointer to string containing the\n"
18954 " argument of the command-line option. \n"
18957 { (
char *)
"plsfam",
_wrap_plsfam, METH_VARARGS, (
char *)
"\n"
18958 "Set family file parameters \n"
18962 " Sets variables dealing with output file familying. Does nothing if\n"
18963 " familying not supported by the driver. This routine, if used, must be\n"
18964 " called before initializing PLplot. See the PLplot documentation for\n"
18965 " more information. \n"
18967 " Redacted form: plsfam(fam, num, bmax)\n"
18969 " This function is used in examples 14,31. \n"
18975 "plsfam(fam, num, bmax)\n"
18979 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
18982 " num (PLINT, input) : Current family file number. \n"
18984 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
18988 { (
char *)
"plsfci",
_wrap_plsfci, METH_VARARGS, (
char *)
"\n"
18989 "Set FCI (font characterization integer) \n"
18993 " Sets font characteristics to be used at the start of the next string\n"
18994 " using the FCI approach. See the PLplot documentation for more\n"
18997 " Redacted form: General: plsfci(fci)\n"
18998 " Perl/PDL: Not available? \n"
19001 " This function is used in example 23. \n"
19011 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19015 { (
char *)
"plsfnam",
_wrap_plsfnam, METH_VARARGS, (
char *)
"\n"
19016 "Set output file name \n"
19020 " Sets the current output file name, if applicable. If the file name\n"
19021 " has not been specified and is required by the driver, the user will be\n"
19022 " prompted for it. If using the X-windows output driver, this sets the\n"
19023 " display name. This routine, if used, must be called before\n"
19024 " initializing PLplot. \n"
19026 " Redacted form: plsfnam(fnam)\n"
19028 " This function is used in examples 1,20. \n"
19038 " fnam (const char *, input) : Pointer to file name string. \n"
19041 { (
char *)
"plsfont",
_wrap_plsfont, METH_VARARGS, (
char *)
"\n"
19042 "Set family, style and weight of the current font \n"
19046 " Sets the current font. See the PLplot documentation for more\n"
19047 " information on font selection. \n"
19049 " Redacted form: plsfont(family, style, weight)\n"
19051 " This function is used in example 23. \n"
19057 "plsfont(family, style, weight)\n"
19061 " family (PLINT, input) : Font family to select for the current font.\n"
19062 " The available values are given by the PL_FCI_* constants in\n"
19063 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
19064 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19065 " signifies that the font family should not be altered. \n"
19067 " style (PLINT, input) : Font style to select for the current font.\n"
19068 " The available values are given by the PL_FCI_* constants in\n"
19069 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19070 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19071 " should not be altered. \n"
19073 " weight (PLINT, input) : Font weight to select for the current font.\n"
19074 " The available values are given by the PL_FCI_* constants in\n"
19075 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19076 " negative value signifies that the font weight should not be\n"
19080 { (
char *)
"plshades",
_wrap_plshades, METH_VARARGS, (
char *)
"\n"
19081 "Shade regions on the basis of value \n"
19085 " Shade regions on the basis of value. This is the high-level routine\n"
19086 " for making continuous color shaded plots with cmap1 while plshade (or\n"
19087 " plshade1) are used for individual shaded regions using either cmap0 or\n"
19088 " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
19089 " function. See the following discussion of the arguments and the PLplot\n"
19090 " documentation for more information. \n"
19092 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19093 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19095 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
19096 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
19100 " This function is used in examples 16,21. \n"
19106 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19110 " a (PLFLT **, input) : Contains ** pointer to array to be plotted.\n"
19111 " The array must have been declared as PLFLT a[nx][ny]. \n"
19113 " nx (PLINT, input) : First dimension of array \"a\". \n"
19115 " ny (PLINT, input) : Second dimension of array \"a\". \n"
19117 " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
19118 " specifying regions excluded from the shading plot. This function\n"
19119 " accepts x and y coordinates as input arguments and must return 0\n"
19120 " if the point is in the excluded region or 1 otherwise. This\n"
19121 " argument can be NULL if all the values are valid. \n"
19123 " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19124 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19125 " at (xmax,ymin) and so on. \n"
19127 " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19128 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19129 " at (xmax,ymin) and so on. \n"
19131 " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19132 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19133 " at (xmax,ymin) and so on. \n"
19135 " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19136 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19137 " at (xmax,ymin) and so on. \n"
19139 " clevel (PLFLT *, input) : Pointer to array containing the data\n"
19140 " levels corresponding to the edges of each shaded region that will\n"
19141 " be plotted by this function. To work properly the levels should\n"
19142 " be monotonic. \n"
19144 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19145 " of shade edge values in clevel). \n"
19147 " fill_width (PLFLT, input) : Defines line width used by the fill\n"
19150 " cont_color (PLINT, input) : Defines pen color used for contours\n"
19151 " defining edges of shaded regions. The pen color is only temporary\n"
19152 " set for the contour drawing. Set this value to zero or less if no\n"
19153 " shade edge contours are wanted. \n"
19155 " cont_width (PLFLT, input) : Defines line width used for contours\n"
19156 " defining edges of shaded regions. This value may not be honored\n"
19157 " by all drivers. The pen width is only temporary set for the\n"
19158 " contour drawing. Set this value to zero or less if no shade edge\n"
19159 " contours are wanted. \n"
19161 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : Routine used to\n"
19162 " fill the region. Use plfill. Future version of PLplot may have\n"
19163 " other fill routines. \n"
19165 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19166 " map to rectangles after coordinate transformation with pltrl. \n"
19167 " Otherwise, set rectangular to false. If rectangular is set to\n"
19168 " true, plshade tries to save time by filling large rectangles. \n"
19169 " This optimization fails if the coordinate transformation distorts\n"
19170 " the shape of rectangles. For example a plot in polar coordinates\n"
19171 " has to have rectangular set to false. \n"
19173 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19174 " Pointer to function that defines transformation between indices\n"
19175 " in array z and the world coordinates (C only). Transformation\n"
19176 " functions are provided in the PLplot library: pltr0 for identity\n"
19177 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19178 " defined by one- and two-dimensional arrays. In addition,\n"
19179 " user-supplied routines for the transformation can be used as well.\n"
19180 " Examples of all of these approaches are given in the PLplot\n"
19181 " documentation. The transformation function should have the form\n"
19182 " given by any of pltr0, pltr1, or pltr2. \n"
19184 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
19185 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19186 " externally supplied. \n"
19189 { (
char *)
"plshade",
_wrap_plshade, METH_VARARGS, (
char *)
"\n"
19190 "Shade individual region on the basis of value \n"
19194 " Shade individual region on the basis of value. Use plshades if you\n"
19195 " want to shade a number of regions using continuous colors. plshade is\n"
19196 " identical to plshade1 except for the type of the first parameter. See\n"
19197 " plshade1 for further discussion. \n"
19199 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
19200 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
19201 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19202 " Perl/PDL: Not available? \n"
19205 " This function is used in example 15. \n"
19211 "lshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19215 " a (PLFLT **, input) : \n"
19217 " nx (PLINT, input) : \n"
19219 " ny (PLINT, input) : \n"
19221 " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
19223 " xmin (PLFLT, input) : \n"
19225 " xmax (PLFLT, input) : \n"
19227 " ymin (PLFLT, input) : \n"
19229 " ymax (PLFLT, input) : \n"
19231 " shade_min (PLFLT, input) : \n"
19233 " shade_max (PLFLT, input) : \n"
19235 " sh_cmap (PLINT, input) : \n"
19237 " sh_color (PLFLT, input) : \n"
19239 " sh_width (PLFLT, input) : \n"
19241 " min_color (PLINT, input) : \n"
19243 " min_width (PLFLT, input) : \n"
19245 " max_color (PLINT, input) : \n"
19247 " max_width (PLFLT, input) : \n"
19249 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : \n"
19251 " rectangular (PLBOOL, input) : \n"
19253 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19255 " pltr_data (PLPointer, input) : \n"
19259 "Assign a function to use for generating custom axis labels \n"
19263 " This function allows a user to provide their own function to provide\n"
19264 " axis label text. The user function is given the numeric value for a\n"
19265 " point on an axis and returns a string label to correspond with that\n"
19266 " value. Custom axis labels can be enabled by passing appropriate\n"
19267 " arguments to plenv, plbox, plbox3 and similar functions. \n"
19269 " This function is used in example 19. \n"
19275 "plslabelfunc(label_func, label_data)\n"
19279 " label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n"
19280 " This is the custom label function. In order to reset to the\n"
19281 " default labeling, set this to NULL. The labeling function\n"
19282 " parameters are, in order: axis: This indicates which axis a\n"
19283 " label is being requested for. The value will be one of PL_X_AXIS,\n"
19284 " PL_Y_AXIS or PL_Z_AXIS. \n"
19286 " value: This is the value along the axis which is being labeled. \n"
19288 " label_text: The string representation of the label value. \n"
19290 " length: The maximum length in characters allowed for label_text. \n"
19293 " label_data (void *, input) : This parameter may be used to pass\n"
19294 " data to the label_func function. \n"
19297 { (
char *)
"plsmaj",
_wrap_plsmaj, METH_VARARGS, (
char *)
"\n"
19298 "Set length of major ticks \n"
19302 " This sets up the length of the major ticks. The actual length is the\n"
19303 " product of the default length and a scaling factor as for character\n"
19306 " Redacted form: plsmaj(def, scale)\n"
19308 " This function is used in example 29. \n"
19314 "plsmaj(def, scale)\n"
19318 " def (PLFLT, input) : The default length of a major tick in\n"
19319 " millimeters, should be set to zero if the default length is to\n"
19320 " remain unchanged. \n"
19322 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19323 " actual tick length. \n"
19326 { (
char *)
"plsmem",
_wrap_plsmem, METH_VARARGS, (
char *)
"\n"
19327 "Set the memory area to be plotted (RGB) \n"
19331 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
19332 " the dev member of the stream structure. Also set the number of pixels\n"
19333 " in the memory passed in \n"
19334 " plotmem, which is a block of memory \n"
19336 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
19338 " This memory will have to be freed by the user! \n"
19340 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
19342 " This function is not used in any examples. \n"
19348 "plsmem(maxx, maxy, plotmem)\n"
19352 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19354 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19356 " plotmem (void *, input) : Pointer to the beginning of the\n"
19357 " user-supplied memory area. \n"
19360 { (
char *)
"plsmema",
_wrap_plsmema, METH_VARARGS, (
char *)
"\n"
19361 "Set the memory area to be plotted (RGBA) \n"
19365 " Set the memory area to be plotted (with the memcairo driver) as the\n"
19366 " dev member of the stream structure. Also set the number of pixels in\n"
19367 " the memory passed in \n"
19368 " plotmem, which is a block of memory \n"
19370 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
19372 " This memory will have to be freed by the user! \n"
19374 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
19376 " This function is not used in any examples. \n"
19382 "plsmema(maxx, maxy, plotmem)\n"
19386 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19388 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19390 " plotmem (void *, input) : Pointer to the beginning of the\n"
19391 " user-supplied memory area. \n"
19394 { (
char *)
"plsmin",
_wrap_plsmin, METH_VARARGS, (
char *)
"\n"
19395 "Set length of minor ticks \n"
19399 " This sets up the length of the minor ticks and the length of the\n"
19400 " terminals on error bars. The actual length is the product of the\n"
19401 " default length and a scaling factor as for character height. \n"
19403 " Redacted form: plsmin(def, scale)\n"
19405 " This function is used in example 29. \n"
19411 "plsmin(def, scale)\n"
19415 " def (PLFLT, input) : The default length of a minor tick in\n"
19416 " millimeters, should be set to zero if the default length is to\n"
19417 " remain unchanged. \n"
19419 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19420 " actual tick length. \n"
19423 { (
char *)
"plsori",
_wrap_plsori, METH_VARARGS, (
char *)
"\n"
19424 "Set orientation \n"
19428 " Set integer plot orientation parameter. This function is identical to\n"
19429 " plsdiori except for the type of the argument, and should be used in\n"
19430 " the same way. See the PLplot documentation for details. \n"
19432 " Redacted form: plsori(ori)\n"
19434 " This function is used in example 3. \n"
19444 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
19445 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
19449 { (
char *)
"plspage",
_wrap_plspage, METH_VARARGS, (
char *)
"\n"
19450 "Set page parameters \n"
19454 " Sets the page configuration (optional). If an individual parameter is\n"
19455 " zero then that parameter value is not updated. Not all parameters are\n"
19456 " recognized by all drivers and the interpretation is device-dependent.\n"
19457 " The X-window driver uses the length and offset parameters to determine\n"
19458 " the window size and location. The length and offset values are\n"
19459 " expressed in units that are specific to the current driver. For\n"
19460 " instance: screen drivers will usually interpret them as number of\n"
19461 " pixels, whereas printer drivers will usually use mm. This routine, if\n"
19462 " used, must be called before initializing PLplot. \n"
19464 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19466 " This function is used in examples 14 and 31. \n"
19472 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19476 " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
19478 " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
19480 " xleng (PLINT , input) : Page length, x. \n"
19482 " yleng (PLINT, input) : Page length, y. \n"
19484 " xoff (PLINT, input) : Page offset, x. \n"
19486 " yoff (PLINT, input) : Page offset, y. \n"
19489 { (
char *)
"plspal0",
_wrap_plspal0, METH_VARARGS, (
char *)
"\n"
19490 "Set the colors for color table 0 from a cmap0 file \n"
19494 " Set the colors for color table 0 from a cmap0 file \n"
19496 " Redacted form: plspal0(filename)\n"
19498 " This function is in example 16. \n"
19504 "plspal0(filename)\n"
19508 " filename (const char *, input) : The name of the cmap0 file, or a\n"
19509 " empty to string to specify the default cmap0 file. \n"
19512 { (
char *)
"plspal1",
_wrap_plspal1, METH_VARARGS, (
char *)
"\n"
19513 "Set the colors for color table 1 from a cmap1 file \n"
19517 " Set the colors for color table 1 from a cmap1 file \n"
19519 " Redacted form: plspal1(filename)\n"
19521 " This function is in example 16. \n"
19527 "plspal1(filename)\n"
19531 " filename (const char *, input) : The name of the cmap1 file, or a\n"
19532 " empty to string to specify the default cmap1 file. \n"
19535 { (
char *)
"plspause",
_wrap_plspause, METH_VARARGS, (
char *)
"\n"
19536 "Set the pause (on end-of-page) status \n"
19540 " Set the pause (on end-of-page) status. \n"
19542 " Redacted form: plspause(pause)\n"
19544 " This function is in examples 14,20. \n"
19550 "plspause(pause)\n"
19554 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
19555 " end-of-page for those drivers which support this. Otherwise there\n"
19559 { (
char *)
"plsstrm",
_wrap_plsstrm, METH_VARARGS, (
char *)
"\n"
19560 "Set current output stream \n"
19564 " Sets the number of the current output stream. The stream number\n"
19565 " defaults to 0 unless changed by this routine. The first use of this\n"
19566 " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
19568 " Redacted form: plsstrm(strm)\n"
19570 " This function is examples 1,14,20. \n"
19580 " strm (PLINT, input) : The current stream number. \n"
19583 { (
char *)
"plssub",
_wrap_plssub, METH_VARARGS, (
char *)
"\n"
19584 "Set the number of subpages in x and y \n"
19588 " Set the number of subpages in x and y. \n"
19590 " Redacted form: plssub(nx, ny)\n"
19592 " This function is examples 1,2,14,21,25,27. \n"
19602 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
19603 " of window columns). \n"
19605 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
19606 " of window rows). \n"
19609 { (
char *)
"plssym",
_wrap_plssym, METH_VARARGS, (
char *)
"\n"
19610 "Set symbol size \n"
19614 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
19615 " plsym. The actual height of a symbol is the product of the default\n"
19616 " symbol size and a scaling factor as for the character height. \n"
19618 " Redacted form: plssym(def, scale)\n"
19620 " This function is used in example 29. \n"
19626 "plssym(def, scale)\n"
19630 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
19631 " should be set to zero if the default height is to remain\n"
19634 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19635 " actual symbol height. \n"
19638 { (
char *)
"plstar",
_wrap_plstar, METH_VARARGS, (
char *)
"\n"
19639 "Initialization \n"
19643 " Initializing the plotting package. The program prompts for the device\n"
19644 " keyword or number of the desired output device. Hitting a RETURN in\n"
19645 " response to the prompt is the same as selecting the first device. If\n"
19646 " only one device is enabled when PLplot is installed, plstar will issue\n"
19647 " no prompt. The output device is divided into nx by ny subpages, each\n"
19648 " of which may be used independently. The subroutine pladv is used to\n"
19649 " advance from one subpage to the next. \n"
19651 " Redacted form: plstar(nx, ny)\n"
19653 " This function is used in example 1. \n"
19663 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19664 " horizontal direction. \n"
19666 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19667 " vertical direction. \n"
19670 { (
char *)
"plstart",
_wrap_plstart, METH_VARARGS, (
char *)
"\n"
19671 "Initialization \n"
19675 " Alternative to plstar for initializing the plotting package. The\n"
19676 " device name keyword for the desired output device must be supplied as\n"
19677 " an argument. The device keywords are the same as those printed out by\n"
19678 " plstar. If the requested device is not available, or if the input\n"
19679 " string is empty or begins with ``?'', the prompted startup of plstar\n"
19680 " is used. This routine also divides the output device into nx by ny\n"
19681 " subpages, each of which may be used independently. The subroutine\n"
19682 " pladv is used to advance from one subpage to the next. \n"
19684 " Redacted form: General: plstart(device, nx, ny)\n"
19685 " Perl/PDL: plstart(nx, ny, device)\n"
19688 " This function is not used in any examples. \n"
19694 "plstart(device, nx, ny)\n"
19698 " device (const char *, input) : Device name (keyword) of the\n"
19699 " required output device. If NULL or if the first character is a\n"
19700 " ``?'', the normal (prompted) startup is used. \n"
19702 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19703 " horizontal direction. \n"
19705 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19706 " vertical direction. \n"
19710 "Set a global coordinate transform function \n"
19714 " This function can be used to define a coordinate transformation which\n"
19715 " affects all elements drawn within the current plot window. The\n"
19716 " transformation function is similar to that provided for the plmap and\n"
19717 " plmeridians functions. The data parameter may be used to pass extra\n"
19718 " data to transform_fun. \n"
19720 " Redacted form: General: plstransform(transform_fun, data)\n"
19723 " This function is used in example 19. \n"
19729 "plstransform(transform_fun, data)\n"
19733 " transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
19734 " input) : Pointer to a function that defines a transformation\n"
19735 " from the input (x, y) coordinate to a new plot world coordiante. \n"
19737 " data (PLPointer, input) : Optional extra data for \n"
19738 " transform_fun. \n"
19741 { (
char *)
"plstring",
_wrap_plstring, METH_VARARGS, (
char *)
"\n"
19742 "Plot a glyph at the specified points \n"
19746 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
19747 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
19748 " is specified with a PLplot user string. Note that the user string is\n"
19749 " not actually limited to one glyph so it is possible (but not normally\n"
19750 " useful) to plot more than one glyph at the specified points with this\n"
19751 " function. As with plmtex and plptex, the user string can contain FCI\n"
19752 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19753 " else PLplot escapes for Hershey or unicode text to determine the\n"
19756 " Redacted form: plstring(x, y, string)\n"
19758 " This function is used in examples 4, 21 and 26. \n"
19764 "plstring(n, x, y, string)\n"
19768 " n (PLINT, input) : Number of points in the x and y arrays. \n"
19770 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19773 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19776 " string (const char *, input) : PLplot user string corresponding to\n"
19777 " the glyph to be plotted at each of the n points. \n"
19781 "Plot a glyph at the specified 3D points \n"
19785 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
19786 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
19787 " this function similar to what is done for plline3. The glyph is\n"
19788 " specified with a PLplot user string. Note that the user string is not\n"
19789 " actually limited to one glyph so it is possible (but not normally\n"
19790 " useful) to plot more than one glyph at the specified points with this\n"
19791 " function. As with plmtex and plptex, the user string can contain FCI\n"
19792 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19793 " else PLplot escapes for Hershey or unicode text to determine the\n"
19796 " Redacted form: plstring3(x, y, z, string)\n"
19798 " This function is used in example 18. \n"
19804 "plstring3(n, x, y, z, string)\n"
19808 " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
19810 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19813 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19816 " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
19819 " string (const char *, input) : PLplot user string corresponding to\n"
19820 " the glyph to be plotted at each of the n points. \n"
19823 { (
char *)
"plstripa",
_wrap_plstripa, METH_VARARGS, (
char *)
"\n"
19824 "Add a point to a stripchart \n"
19828 " Add a point to a given pen of a given stripchart. There is no need for\n"
19829 " all pens to have the same number of points or to be equally sampled in\n"
19830 " the x coordinate. Allocates memory and rescales as necessary. \n"
19832 " Redacted form: plstripa(id, p, x, y)\n"
19834 " This function is used in example 17. \n"
19840 "plstripa(id, p, x, y)\n"
19844 " id (PLINT, input) : Identification number (set up in plstripc) of\n"
19845 " the stripchart. \n"
19847 " p (PLINT, input) : Pen number (ranges from 0 to 3). \n"
19849 " x (PLFLT, input) : X coordinate of point to plot. \n"
19851 " y (PLFLT, input) : Y coordinate of point to plot. \n"
19854 { (
char *)
"plstripc",
_wrap_plstripc, METH_VARARGS, (
char *)
"\n"
19855 "Create a 4-pen stripchart \n"
19859 " Create a 4-pen stripchart, to be used afterwards by plstripa\n"
19861 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
19862 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
19863 " styline, legline, labx, laby, labz)\n"
19864 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
19865 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
19866 " ypsec, legline, labx, laby, labtop)\n"
19869 " This function is used in example 17. \n"
19875 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
19879 " id (PLINT *, output) : Identification number of stripchart to use\n"
19880 " on plstripa and plstripd. \n"
19882 " xspec (char *, input) : X-axis specification as in plbox. \n"
19884 " yspec (char *, input) : Y-axis specification as in plbox. \n"
19886 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19887 " change as data are added. \n"
19889 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19890 " change as data are added. \n"
19892 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
19893 " is multiplied by the factor (1 + \n"
19896 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19897 " change as data are added. \n"
19899 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19900 " change as data are added. \n"
19902 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
19904 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
19906 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
19907 " true, otherwise not. \n"
19909 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
19910 " otherwise slide display. \n"
19912 " colbox (PLINT, input) : Plot box color index (cmap0). \n"
19914 " collab (PLINT, input) : Legend color index (cmap0). \n"
19916 " colline (PLINT *, input) : Pointer to array with color indices\n"
19917 " (cmap0) for the 4 pens. \n"
19919 " styline (PLINT *, input) : Pointer to array with line styles for\n"
19922 " legline (char **, input) : Pointer to character array containing\n"
19923 " legends for the 4 pens. \n"
19925 " labx (char *, input) : X-axis label. \n"
19927 " laby (char *, input) : Y-axis label. \n"
19929 " labtop (char *, input) : Plot title. \n"
19932 { (
char *)
"plstripd",
_wrap_plstripd, METH_VARARGS, (
char *)
"\n"
19933 "Deletes and releases memory used by a stripchart \n"
19937 " Deletes and releases memory used by a stripchart. \n"
19939 " Redacted form: plstripd(id)\n"
19941 " This function is used in example 17. \n"
19951 " id (PLINT, input) : Identification number of stripchart to delete. \n"
19954 { (
char *)
"plstyl",
_wrap_plstyl, METH_VARARGS, (
char *)
"\n"
19955 "Set line style \n"
19959 " This sets up the line style for all lines subsequently drawn. A line\n"
19960 " consists of segments in which the pen is alternately down and up. The\n"
19961 " lengths of these segments are passed in the arrays mark and space\n"
19962 " respectively. The number of mark-space pairs is specified by nels. \n"
19963 " In order to return the line style to the default continuous line,\n"
19964 " plstyl should be called with nels=0.(see also pllsty) \n"
19966 " Redacted form: plstyl(mark, space)\n"
19968 " This function is used in examples 1,9,14. \n"
19974 "plstyl(nels, mark, space)\n"
19978 " nels (PLINT, input) : The number of mark and space elements in a\n"
19979 " line. Thus a simple broken line can be obtained by setting\n"
19980 " nels=1. A continuous line is specified by setting nels=0. \n"
19982 " mark (PLINT *, input) : Pointer to array with the lengths of the\n"
19983 " segments during which the pen is down, measured in micrometers. \n"
19985 " space (PLINT *, input) : Pointer to array with the lengths of the\n"
19986 " segments during which the pen is up, measured in micrometers. \n"
19989 { (
char *)
"plsvect",
_wrap_plsvect, METH_VARARGS, (
char *)
"\n"
19990 "Set arrow style for vector plots \n"
19994 " Set the style for the arrow used by plvect to plot vectors. \n"
19996 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
19998 " This function is used in example 22. \n"
20004 "plsvect(arrowx, arrowy, npts, fill)\n"
20008 " arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n"
20009 " containing the x and y points which make up the arrow. The arrow\n"
20010 " is plotted by joining these points to form a polygon. The scaling\n"
20011 " assumes that the x and y points in the arrow lie in the range -0.5\n"
20012 " <= x,y <= 0.5. \n"
20014 " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
20017 " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
20018 " fill is false then the arrow is open. \n"
20021 { (
char *)
"plsvpa",
_wrap_plsvpa, METH_VARARGS, (
char *)
"\n"
20022 "Specify viewport in absolute coordinates \n"
20026 " Alternate routine to plvpor for setting up the viewport. This routine\n"
20027 " should be used only if the viewport is required to have a definite\n"
20028 " size in millimeters. The routine plgspa is useful for finding out the\n"
20029 " size of the current subpage. \n"
20031 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20033 " This function is used in example 10. \n"
20039 "plsvpa(xmin, xmax, ymin, ymax)\n"
20043 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20044 " viewport from the left-hand edge of the subpage in millimeters. \n"
20046 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20047 " viewport from the left-hand edge of the subpage in millimeters. \n"
20049 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20050 " viewport from the bottom edge of the subpage in millimeters. \n"
20052 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20053 " from the bottom edge of the subpage in millimeters. \n"
20056 { (
char *)
"plsxax",
_wrap_plsxax, METH_VARARGS, (
char *)
"\n"
20057 "Set x axis parameters \n"
20061 " Sets values of the digmax and digits flags for the x axis. See the\n"
20062 " PLplot documentation for more information. \n"
20064 " Redacted form: plsxax(digmax, digits)\n"
20066 " This function is used in example 31. \n"
20072 "plsxax(digmax, digits)\n"
20076 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20077 " digits for the x axis. If nonzero, the printed label will be\n"
20078 " switched to a floating point representation when the number of\n"
20079 " digits exceeds digmax. \n"
20081 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20082 " its value here has no effect since it is set only by plbox or\n"
20083 " plbox3. However, the user may obtain its value after a call to\n"
20084 " either of these functions by calling plgxax. \n"
20087 { (
char *)
"plsyax",
_wrap_plsyax, METH_VARARGS, (
char *)
"\n"
20088 "Set y axis parameters \n"
20092 " Identical to plsxax, except that arguments are flags for y axis. See\n"
20093 " the description of plsxax for more detail. \n"
20095 " Redacted form: plsyax(digmax, digits)\n"
20097 " This function is used in examples 1,14,31. \n"
20103 "plsyax(digmax, digits)\n"
20107 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20108 " digits for the y axis. If nonzero, the printed label will be\n"
20109 " switched to a floating point representation when the number of\n"
20110 " digits exceeds digmax. \n"
20112 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20113 " its value here has no effect since it is set only by plbox or\n"
20114 " plbox3. However, the user may obtain its value after a call to\n"
20115 " either of these functions by calling plgyax. \n"
20118 { (
char *)
"plsym",
_wrap_plsym, METH_VARARGS, (
char *)
"\n"
20119 "Plot a glyph at the specified points \n"
20123 " Plot a glyph at the specified points. (This function is largely\n"
20124 " superseded by plstring which gives access to many[!] more glyphs.) \n"
20126 " Redacted form: plsym(x, y, code)\n"
20128 " This function is used in example 7. \n"
20134 "plsym(n, x, y, code)\n"
20138 " n (PLINT, input) : Number of points in the x and y arrays. \n"
20140 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20143 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20146 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
20147 " to be plotted at each of the n points. \n"
20150 { (
char *)
"plszax",
_wrap_plszax, METH_VARARGS, (
char *)
"\n"
20151 "Set z axis parameters \n"
20155 " Identical to plsxax, except that arguments are flags for z axis. See\n"
20156 " the description of plsxax for more detail. \n"
20158 " Redacted form: plszax(digmax, digits)\n"
20160 " This function is used in example 31. \n"
20166 "plszax(digmax, digits)\n"
20170 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20171 " digits for the z axis. If nonzero, the printed label will be\n"
20172 " switched to a floating point representation when the number of\n"
20173 " digits exceeds digmax. \n"
20175 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20176 " its value here has no effect since it is set only by plbox or\n"
20177 " plbox3. However, the user may obtain its value after a call to\n"
20178 " either of these functions by calling plgzax. \n"
20181 { (
char *)
"pltext",
_wrap_pltext, METH_VARARGS, (
char *)
"\n"
20182 "Switch to text screen \n"
20186 " Sets an interactive device to text mode, used in conjunction with\n"
20187 " plgra to allow graphics and text to be interspersed. On a device\n"
20188 " which supports separate text and graphics windows, this command causes\n"
20189 " control to be switched to the text window. This can be useful for\n"
20190 " printing diagnostic messages or getting user input, which would\n"
20191 " otherwise interfere with the plots. The program must switch back to\n"
20192 " the graphics window before issuing plot commands, as the text (or\n"
20193 " console) device will probably become quite confused otherwise. If\n"
20194 " already in text mode, this command is ignored. It is also ignored on\n"
20195 " devices which only support a single window or use a different method\n"
20196 " for shifting focus (see also plgra). \n"
20198 " Redacted form: pltext()\n"
20200 " This function is used in example 1. \n"
20210 "Set format for date / time labels \n"
20214 " Sets the format for date / time labels. To enable date / time format\n"
20215 " labels see the options to plbox and plenv. \n"
20217 " Redacted form: pltimefmt(fmt)\n"
20219 " This function is used in example 29. \n"
20229 " fmt (const char *, fmt) : This string is passed directly to the\n"
20230 " system strftime. See the system documentation for a full list of\n"
20231 " conversion specifications for your system. All conversion\n"
20232 " specifications take the form of a '%' character followed by\n"
20233 " further conversion specification character. All other text is\n"
20234 " printed as-is. Common options include: %c: The preferred date and\n"
20235 " time representation for the current locale. \n"
20236 " %d: The day of the month as a decimal number. \n"
20237 " %H: The hour as a decimal number using a 24-hour clock. \n"
20238 " %j: The day of the year as a decimal number. \n"
20239 " %m: The month as a decimal number. \n"
20240 " %M: The minute as a decimal number. \n"
20241 " %S: The second as a decimal number. \n"
20242 " %y: The year as a decimal number without a century. \n"
20243 " %Y: The year as a decimal number including a century. \n"
20246 { (
char *)
"plvasp",
_wrap_plvasp, METH_VARARGS, (
char *)
"\n"
20247 "Specify viewport using aspect ratio only \n"
20251 " Sets the viewport so that the ratio of the length of the y axis to\n"
20252 " that of the x axis is equal to aspect. \n"
20254 " Redacted form: plvasp(aspect)\n"
20256 " This function is used in example 13. \n"
20266 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20270 { (
char *)
"plvect",
_wrap_plvect, METH_VARARGS, (
char *)
"\n"
20275 " Draws a vector plot of the vector (\n"
20281 " ny]). The scaling factor for the vectors is given by scale. A\n"
20282 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
20283 " additional data required by the transformation routine is used to map\n"
20284 " indices within the array to the world coordinates. The style of the\n"
20285 " vector arrow may be set using plsvect. \n"
20287 " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
20289 " This function is used in example 22. \n"
20295 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
20299 " u, v (PLFLT **, input) : Pointers to a pair of vectored\n"
20300 " two-dimensional arrays containing the x and y components of the\n"
20301 " vector data to be plotted. \n"
20303 " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
20305 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
20306 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
20307 " automatically calculated for the data. If scale < 0 then the\n"
20308 " scaling factor is automatically calculated for the data and then\n"
20309 " multiplied by -\n"
20310 " scale. If scale > 0 then the scaling factor is set to scale. \n"
20312 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20313 " Pointer to function that defines transformation between indices\n"
20314 " in array z and the world coordinates (C only). Transformation\n"
20315 " functions are provided in the PLplot library: pltr0 for identity\n"
20316 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20317 " defined by one- and two-dimensional arrays. In addition,\n"
20318 " user-supplied routines for the transformation can be used as well.\n"
20319 " Examples of all of these approaches are given in the PLplot\n"
20320 " documentation. The transformation function should have the form\n"
20321 " given by any of pltr0, pltr1, or pltr2. \n"
20323 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20324 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20325 " externally supplied. \n"
20328 { (
char *)
"plvpas",
_wrap_plvpas, METH_VARARGS, (
char *)
"\n"
20329 "Specify viewport using coordinates and aspect ratio \n"
20333 " Device-independent routine for setting up the viewport. The viewport\n"
20334 " is chosen to be the largest with the given aspect ratio that fits\n"
20335 " within the specified region (in terms of normalized subpage\n"
20336 " coordinates). This routine is functionally equivalent to plvpor when\n"
20337 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
20338 " routine reserves no extra space at the edges for labels. \n"
20340 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20342 " This function is used in example 9. \n"
20348 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20352 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20353 " left-hand edge of the viewport. \n"
20355 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20356 " right-hand edge of the viewport. \n"
20358 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20359 " bottom edge of the viewport. \n"
20361 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20362 " edge of the viewport. \n"
20364 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20368 { (
char *)
"plvpor",
_wrap_plvpor, METH_VARARGS, (
char *)
"\n"
20369 "Specify viewport using coordinates \n"
20373 " Device-independent routine for setting up the viewport. This defines\n"
20374 " the viewport in terms of normalized subpage coordinates which run from\n"
20375 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
20376 " current subpage. Use the alternate routine plsvpa in order to create\n"
20377 " a viewport of a definite size. \n"
20379 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
20381 " This function is used in examples\n"
20382 " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
20388 "plvpor(xmin, xmax, ymin, ymax)\n"
20392 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20393 " left-hand edge of the viewport. \n"
20395 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20396 " right-hand edge of the viewport. \n"
20398 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20399 " bottom edge of the viewport. \n"
20401 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20402 " edge of the viewport. \n"
20405 { (
char *)
"plvsta",
_wrap_plvsta, METH_VARARGS, (
char *)
"\n"
20406 "Select standard viewport \n"
20410 " Sets up a standard viewport, leaving a left-hand margin of seven\n"
20411 " character heights, and four character heights around the other three\n"
20414 " Redacted form: plvsta()\n"
20416 " This function is used in examples 1,12,14,17,25,29. \n"
20425 { (
char *)
"plw3d",
_wrap_plw3d, METH_VARARGS, (
char *)
"\n"
20426 "Set up window for 3-d plotting \n"
20430 " Sets up a window for a three-dimensional surface plot within the\n"
20431 " currently defined two-dimensional window. The enclosing box for the\n"
20432 " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
20433 " user-coordinate space is mapped into a box of world coordinate size\n"
20434 " basex by basey by height so that xmin maps to -\n"
20435 " basex/2, xmax maps to basex/2, ymin maps to -\n"
20436 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
20437 " The resulting world-coordinate box is then viewed by an observer at\n"
20438 " altitude alt and azimuth az. This routine must be called before\n"
20439 " plbox3 or plot3d. For a more complete description of\n"
20440 " three-dimensional plotting see the PLplot documentation. \n"
20442 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
20443 " zmin, zmax, alt, az)\n"
20445 " This function is examples 8,11,18,21. \n"
20451 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
20455 " basex (PLFLT, input) : The x coordinate size of the\n"
20456 " world-coordinate box. \n"
20458 " basey (PLFLT, input) : The y coordinate size of the\n"
20459 " world-coordinate box. \n"
20461 " height (PLFLT, input) : The z coordinate size of the\n"
20462 " world-coordinate box. \n"
20464 " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
20466 " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
20468 " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
20470 " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
20472 " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
20474 " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
20476 " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
20479 " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n"
20480 " observer is looking face onto the ZX plane, and as az is\n"
20481 " increased, the observer moves clockwise around the box when viewed\n"
20482 " from above the XY plane. \n"
20485 { (
char *)
"plwidth",
_wrap_plwidth, METH_VARARGS, (
char *)
"\n"
20490 " Sets the pen width. \n"
20492 " Redacted form: plwidth(width)\n"
20494 " This function is used in examples 1,2. \n"
20504 " width (PLINT, input) : The desired pen width. If width is negative\n"
20505 " or the same as the previous value no action is taken. width = 0\n"
20506 " should be interpreted as as the minimum valid pen width for the\n"
20507 " device. The interpretation of positive width values is also\n"
20508 " device dependent. \n"
20511 { (
char *)
"plwind",
_wrap_plwind, METH_VARARGS, (
char *)
"\n"
20512 "Specify world coordinates of viewport boundaries \n"
20516 " Sets up the world coordinates of the edges of the viewport. \n"
20518 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
20520 " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
20526 "plwind(xmin, xmax, ymin, ymax)\n"
20530 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
20531 " of the viewport. \n"
20533 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
20534 " of the viewport. \n"
20536 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
20537 " the viewport. \n"
20539 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
20543 { (
char *)
"plxormod",
_wrap_plxormod, METH_VARARGS, (
char *)
"\n"
20544 "Enter or leave xor mode \n"
20548 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
20549 " those drivers (e.g., the xwin driver) that support it. Enables\n"
20550 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
20551 " is not capable of xor operation it returns a status of false. \n"
20553 " Redacted form: plxormod(mode, status)\n"
20555 " This function is used in examples 1,20. \n"
20561 "plxormod(mode, status)\n"
20565 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
20566 " is false means leave xor mode. \n"
20568 " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
20569 " of true (false) means driver is capable (incapable) of xor mode. \n"
20572 { (
char *)
"plmap",
_wrap_plmap, METH_VARARGS, (
char *)
"\n"
20573 "Plot continental outline in world coordinates. \n"
20577 " Plots continental outlines in world coordinates. examples/c/x19c\n"
20578 " demonstrates how to use this function to create different\n"
20581 " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n"
20582 " minlat, maxlat)\n"
20583 " F95, Java, Perl/PDL, Python: Not implemented? \n"
20586 " This function is used in example 19. \n"
20592 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
20596 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20597 " supplied function to transform the coordinate longitudes and\n"
20598 " latitudes to a plot coordinate system. By using this transform,\n"
20599 " we can change from a longitude, latitude coordinate to a polar\n"
20600 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20601 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20602 " After the call to mapform(), x[] and y[] should be replaced by\n"
20603 " the corresponding plot coordinates. If no transform is desired,\n"
20604 " mapform can be replaced by NULL. \n"
20606 " type (char *, input) : type is a character string. The value of\n"
20607 " this parameter determines the type of background. The possible\n"
20608 " values are: \"globe\" -- continental outlines \n"
20609 " \"usa\" -- USA and state boundaries \n"
20610 " \"cglobe\" -- continental outlines and countries \n"
20611 " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
20614 " minlong (PLFLT, input) : The value of the longitude on the left\n"
20615 " side of the plot. The value of minlong must be less than the\n"
20616 " value of maxlong, and the quantity maxlong-minlong must be less\n"
20617 " than or equal to 360. \n"
20619 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20620 " side of the plot. \n"
20622 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20623 " background. One can always use -90.0 as the boundary outside the\n"
20624 " plot window will be automatically eliminated. However, the\n"
20625 " program will be faster if one can reduce the size of the\n"
20626 " background plotted. \n"
20628 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20629 " background. One can always use 90.0 as the boundary outside the\n"
20630 " plot window will be automatically eliminated. \n"
20634 "Plot latitude and longitude lines. \n"
20638 " Displays latitude and longitude on the current plot. The lines are\n"
20639 " plotted in the current color and line style. \n"
20641 " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n"
20642 " maxlong, minlat, maxlat)\n"
20643 " F95, Java, Perl/PDL, Python: Not implemented? \n"
20646 " This function is used in example 19. \n"
20652 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
20656 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20657 " supplied function to transform the coordinate longitudes and\n"
20658 " latitudes to a plot coordinate system. By using this transform,\n"
20659 " we can change from a longitude, latitude coordinate to a polar\n"
20660 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20661 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20662 " After the call to mapform(), x[] and y[] should be replaced by\n"
20663 " the corresponding plot coordinates. If no transform is desired,\n"
20664 " mapform can be replaced by NULL. \n"
20666 " dlong (PLFLT, input) : The interval in degrees at which the\n"
20667 " longitude lines are to be plotted. \n"
20669 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
20670 " lines are to be plotted. \n"
20672 " minlong (PLFLT, input) : The value of the longitude on the left\n"
20673 " side of the plot. The value of minlong must be less than the\n"
20674 " value of maxlong, and the quantity maxlong-minlong must be less\n"
20675 " than or equal to 360. \n"
20677 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20678 " side of the plot. \n"
20680 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20681 " background. One can always use -90.0 as the boundary outside the\n"
20682 " plot window will be automatically eliminated. However, the\n"
20683 " program will be faster if one can reduce the size of the\n"
20684 " background plotted. \n"
20686 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20687 " background. One can always use 90.0 as the boundary outside the\n"
20688 " plot window will be automatically eliminated. \n"
20691 { (
char *)
"plimage",
_wrap_plimage, METH_VARARGS, (
char *)
"\n"
20692 "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
20696 " Plot a 2D matrix using color palette 1. The color scale is\n"
20697 " automatically adjusted to use the maximum and minimum values in idata\n"
20698 " as valuemin and valuemax in a call to plimagefr. \n"
20700 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
20701 " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
20704 " This function is used in example 20. \n"
20710 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
20714 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20715 " plot. Should have dimensions idata[nx][ny]. \n"
20717 " nx, ny (PLINT, input) : Dimensions of idata \n"
20719 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to strecth\n"
20720 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
20721 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20723 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20724 " (inclusive) will be plotted. \n"
20726 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
20727 " points whose plot coordinates fall inside the window of (Dxmin,\n"
20728 " Dymin) to (Dxmax, Dymax). \n"
20732 "Plot a 2D matrix using color map1 \n"
20736 " Plot a 2D matrix using color map1. \n"
20738 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
20739 " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
20742 " This function is used in example 20. \n"
20748 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
20752 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20753 " plot. Should have dimensions idata[nx][ny]. \n"
20755 " nx, ny (PLINT, input) : Dimensions of idata \n"
20757 " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
20758 " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
20759 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20761 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20762 " (inclusive) will be plotted. \n"
20764 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
20765 " values to use for value to color mappings. A datum equal to or\n"
20766 " less than valuemin will be plotted with color 0.0, while a datum\n"
20767 " equal to or greater than valuemax will be plotted with color 1.0. \n"
20768 " Data between valuemin and valuemax map linearly to colors between\n"
20771 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20772 " Pointer to function that defines a transformation between the\n"
20773 " data in the array idata and world coordinates. An input\n"
20774 " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
20775 " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
20776 " Some transformation functions are provided in the PLplot library:\n"
20777 " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
20778 " mappings respectively defined by one- and two-dimensional arrays. \n"
20779 " In addition, user-supplied routines for the transformation can be\n"
20780 " used as well. Examples of all of these approaches are given in\n"
20781 " the PLplot documentation. The transformation function should have\n"
20782 " the form given by any of pltr0, pltr1, or pltr2. \n"
20784 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20785 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
20786 " externally supplied. \n"
20795 { NULL, NULL, 0, NULL }
20869 {0, 0, 0, 0.0, 0, 0}};
20923 #define SWIGRUNTIME_DEBUG
20934 if (swig_module.
next==0) {
20946 if (!module_head) {
20956 if (iter==&swig_module) {
20961 }
while (iter!= module_head);
20966 swig_module.
next = module_head->
next;
20974 if (init == 0)
return;
20977 #ifdef SWIGRUNTIME_DEBUG
20978 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
20980 for (i = 0; i < swig_module.
size; ++i) {
20985 #ifdef SWIGRUNTIME_DEBUG
20986 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
20990 if (swig_module.
next != &swig_module) {
20995 #ifdef SWIGRUNTIME_DEBUG
20996 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
21000 #ifdef SWIGRUNTIME_DEBUG
21001 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
21010 while (cast->
type) {
21013 #ifdef SWIGRUNTIME_DEBUG
21014 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
21016 if (swig_module.
next != &swig_module) {
21018 #ifdef SWIGRUNTIME_DEBUG
21019 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
21024 #ifdef SWIGRUNTIME_DEBUG
21025 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
21032 #ifdef SWIGRUNTIME_DEBUG
21033 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
21035 if (!ocast) ret = 0;
21040 #ifdef SWIGRUNTIME_DEBUG
21041 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
21052 swig_module.
types[i] = type;
21054 swig_module.
types[i] = 0;
21056 #ifdef SWIGRUNTIME_DEBUG
21057 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21058 for (i = 0; i < swig_module.
size; ++i) {
21061 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
21062 while (cast->
type) {
21063 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
21067 printf(
"---- Total casts: %d\n",j);
21069 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21082 static int init_run = 0;
21084 if (init_run)
return;
21087 for (i = 0; i < swig_module.
size; i++) {
21095 equiv = equiv->
next;
21116 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21117 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21118 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21138 #if PY_VERSION_HEX >= 0x03000000
21139 return PyUnicode_InternFromString(
"<Swig global variables>");
21141 return PyString_FromString(
"<Swig global variables>");
21147 #if PY_VERSION_HEX >= 0x03000000
21148 PyObject *str = PyUnicode_InternFromString(
"(");
21152 for (var = v->
vars; var; var=var->
next) {
21153 tail = PyUnicode_FromString(var->
name);
21154 joined = PyUnicode_Concat(str, tail);
21159 tail = PyUnicode_InternFromString(
", ");
21160 joined = PyUnicode_Concat(str, tail);
21166 tail = PyUnicode_InternFromString(
")");
21167 joined = PyUnicode_Concat(str, tail);
21172 PyObject *str = PyString_FromString(
"(");
21174 for (var = v->
vars; var; var=var->
next) {
21175 PyString_ConcatAndDel(&str,PyString_FromString(var->
name));
21176 if (var->
next) PyString_ConcatAndDel(&str,PyString_FromString(
", "));
21178 PyString_ConcatAndDel(&str,PyString_FromString(
")"));
21187 fprintf(fp,
"Swig global variables ");
21207 PyObject *res = NULL;
21210 if (strcmp(var->
name,n) == 0) {
21216 if (res == NULL && !PyErr_Occurred()) {
21217 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
21227 if (strcmp(var->
name,n) == 0) {
21233 if (res == 1 && !PyErr_Occurred()) {
21234 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
21241 static char varlink__doc__[] =
"Swig var link object";
21242 static PyTypeObject varlink_type;
21243 static int type_init = 0;
21245 const PyTypeObject tmp = {
21247 #if PY_VERSION_HEX >= 0x03000000
21248 PyVarObject_HEAD_INIT(NULL, 0)
21250 PyObject_HEAD_INIT(NULL)
21253 (
char *)
"swigvarlink",
21277 #if PY_VERSION_HEX >= 0x02020000
21278 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
21280 #if PY_VERSION_HEX >= 0x02030000
21283 #if PY_VERSION_HEX >= 0x02060000
21286 #ifdef COUNT_ALLOCS
21290 varlink_type = tmp;
21292 #if PY_VERSION_HEX < 0x02020000
21293 varlink_type.ob_type = &PyType_Type;
21295 if (PyType_Ready(&varlink_type) < 0)
21299 return &varlink_type;
21309 return ((PyObject*) result);
21317 size_t size = strlen(name)+1;
21318 gv->
name = (
char *)malloc(size);
21320 strncpy(gv->
name,name,size);
21331 static PyObject *_SWIG_globals = 0;
21333 return _SWIG_globals;
21345 for (i = 0; constants[i].
type; ++i) {
21346 switch(constants[i].type) {
21351 obj =
SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21358 PyDict_SetItemString(d, constants[i].name, obj);
21374 for (i = 0; methods[i].ml_name; ++i) {
21375 const char *c = methods[i].ml_doc;
21376 if (c && (c = strstr(c,
"swig_ptr: "))) {
21379 const char *name = c + 10;
21380 for (j = 0; const_table[j].
type; ++j) {
21381 if (strncmp(const_table[j].name, name,
21382 strlen(const_table[j].name)) == 0) {
21383 ci = &(const_table[j]);
21390 size_t shift = (ci->
ptype) - types;
21392 size_t ldoc = (c - methods[i].ml_doc);
21393 size_t lptr = strlen(ty->
name)+2*
sizeof(
void*)+2;
21394 char *ndoc = (
char*)malloc(ldoc + lptr + 10);
21397 strncpy(buff, methods[i].ml_doc, ldoc);
21399 strncpy(buff,
"swig_ptr: ", 10);
21402 methods[i].ml_doc = ndoc;
21423 #if PY_VERSION_HEX >= 0x03000000
21429 PyObject *m, *d, *md;
21430 #if PY_VERSION_HEX >= 0x03000000
21431 static struct PyModuleDef SWIG_module = {
21432 # if PY_VERSION_HEX >= 0x03020000
21433 PyModuleDef_HEAD_INIT,
21436 PyObject_HEAD_INIT(NULL)
21453 #if defined(SWIGPYTHON_BUILTIN)
21455 0, 0, 0, 0, 0, 0, 0
21457 static PyGetSetDef this_getset_def = {
21458 (
char *)
"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
21460 static SwigPyGetSet thisown_getset_closure = {
21464 static PyGetSetDef thisown_getset_def = {
21465 (
char *)
"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
21467 PyObject *metatype_args;
21468 PyTypeObject *builtin_pytype;
21469 int builtin_base_count;
21472 PyGetSetDescrObject *static_getset;
21473 PyTypeObject *metatype;
21475 PyObject *public_interface, *public_symbol;
21476 PyObject *this_descr;
21477 PyObject *thisown_descr;
21480 (
void)builtin_pytype;
21481 (
void)builtin_base_count;
21482 (
void)builtin_basetype;
21484 (
void)static_getset;
21487 metatype_args = Py_BuildValue(
"(s(O){})",
"SwigPyObjectType", &PyType_Type);
21488 assert(metatype_args);
21489 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
21491 Py_DECREF(metatype_args);
21492 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
21493 assert(PyType_Ready(metatype) >= 0);
21499 #if PY_VERSION_HEX >= 0x03000000
21500 m = PyModule_Create(&SWIG_module);
21502 m = Py_InitModule((
char *)
SWIG_name, SwigMethods);
21504 md = d = PyModule_GetDict(m);
21509 #ifdef SWIGPYTHON_BUILTIN
21511 assert(SwigPyObject_stype);
21514 SwigPyObject_stype->
clientdata = &SwigPyObject_clientdata;
21517 PyErr_SetString(PyExc_RuntimeError,
"Import error: attempted to load two incompatible swig-generated modules.");
21518 # if PY_VERSION_HEX >= 0x03000000
21531 (
void)thisown_descr;
21533 public_interface = PyList_New(0);
21535 (
void)public_symbol;
21537 PyDict_SetItemString(md,
"__all__", public_interface);
21538 Py_DECREF(public_interface);
21539 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
21540 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
21542 SwigPyBuiltin_AddPublicSymbol(public_interface,
swig_const_table[i].name);
21678 #if PY_VERSION_HEX >= 0x03000000
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
intobjargproc ssizeobjargproc
subroutine plbox(xopt, xtick, nxsub, yopt, ytick, nysub)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid2(void)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_globalvar swig_globalvar
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject_HEAD swig_globalvar * vars
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OverflowError
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_str_FromFormat
static swig_cast_info _swigc__p_char[]
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
subroutine plmtex3(side, disp, pos, xjust, text)
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * swig_this
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define PyObject_GenericGetAttr
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static long PyNumber_AsSsize_t(PyObject *x, void *SWIGUNUSEDPARM(exc))
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CAST_NEW_MEMORY
struct swig_globalvar * next
#define SWIG_STATIC_POINTER(var)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
subroutine plstring3(x, y, z, string)
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
static swig_type_info _swigt__p_char
static swig_cast_info _swigc__p_int[]
static swig_type_info _swigt__p_f_double_double__int
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
void plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, int npts, PLFLT *xg, int nptsx, PLFLT *yg, int nptsy, PLFLT **zg, int type, PLFLT data)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLcGrid
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject_HEAD void * pack
void plimage(PLFLT **data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
subroutine plmtex(side, disp, pos, xjust, text)
#define pl_setcontlabelparam
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
intintargfunc ssizessizeargfunc
struct swig_cast_info * cast
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
void destroy(GtkWidget *widget, gpointer data)
subroutine plstring(x, y, string)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
SWIGRUNTIME void SWIG_Python_DestroyModule(void *vptr)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_p_char
#define SWIG_RuntimeError
#define Py_NotImplemented
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_as_voidptrptr(a)
void PLFLT PLINT PLINT PLFLT x
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_double_double__int[]
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLGraphicsIn
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyMappingMethods as_mapping
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
void cleanup_mapform(void)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
subroutine plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
#define SWIG_RUNTIME_VERSION
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
#define SWIGRUNTIMEINLINE
#define SWIG_NewClientData(obj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
#define SWIG_GetModule(clientdata)
#define myArray_ContiguousFromObject
static PyMethodDef swigobject_methods[]
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
PyNumberMethods as_number
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
SWIGRUNTIME void SWIG_PropagateClientData(void)
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
#define PyString_AsStringAndSize(obj, s, len)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
#define SWIG_DelNewMask(r)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
struct swig_module_info * next
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_PYBUFFER_SIZE
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
void PLFLT PLINT PLINT PLFLT PLFLT y
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
getreadbufferproc readbufferproc
swig_converter_func converter
subroutine plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
int(* set_attr)(PyObject *)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_module_info swig_module
#define SWIG_POINTER_DISOWN
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
static swig_cast_info _swigc__p_PLcGrid[]
subroutine plspal0(filename)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
#define SWIG_exception_fail(code, msg)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
SWIGINTERN int SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPointerObj(ptr, type, flags)
static swig_cast_info _swigc__p_double[]
subroutine plsetopt(opt, optarg)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
static swig_type_info * swig_type_initial[]
subroutine plptex(x, y, dx, dy, xjust, text)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_MangledTypeQuery(name)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject *(* get_attr)(void)
#define SWIG_BUILTIN_TP_INIT
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
PyObject * python_mapform
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PySequenceMethods as_sequence
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define PyInt_FromSize_t(x)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
subroutine pllab(xlab, ylab, title)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
#define SWIG_as_voidptr(a)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static PLFLT value(double n1, double n2, double hue)
static swig_type_info _swigt__p_unsigned_int
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_p_double
static swig_type_info _swigt__p_PLcGrid2
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
pltr_func marshal_pltr(PyObject *input)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * _SWIG_This(void)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
getwritebufferproc writebufferproc
PLPointer marshal_PLPointer(PyObject *input, int isimg)
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
intintobjargproc ssizessizeobjargproc
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TypeQuery(name)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * PyString_FromFormat(const char *fmt,...)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_DivisionByZero
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
struct swig_cast_info * next
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plspal1(filename, interpolate)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_module_info swig_module_info
static swig_cast_info * swig_cast_initial[]
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plstart(devname, nx, ny)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
getsegcountproc segcountproc
subroutine plptex3(x, y, z, dx, dy, dz, sx, sy, sz, xjust, text)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
#define SWIG_newvarlink()
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static tclMatrixXtnsnDescr * tail
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_cast_info * prev
struct swig_const_info swig_const_info
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
getcharbufferproc charbufferproc
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_cast_info ** cast_initial
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
ct_func marshal_ct(PyObject *input)
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_cast_info _swigc__p_p_double[]
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o)
SWIGRUNTIME PyObject * SWIG_This(void)
#define SWIG_InstallConstants(d, constants)
mapform_func marshal_mapform(PyObject *input)
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_type_info ** type_initial
#define MY_UNBLOCK_THREADS
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
static swig_type_info _swigt__p_int
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * PyBool_FromLong(long ok)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static swig_type_info * swig_types[15]
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
subroutine pltimefmt(fmt)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT(* defined_func)(PLFLT, PLFLT)
void plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char *const *label, PLINT n_axes, const char *const *axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *const *values) void my_plcolorbar(PLFLT *p_colorbar_width
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SwigPyObject_getattr(SwigPyObject *sobj, char *name)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
static swig_const_info swig_const_table[]
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV