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;
1645 PyObject *destroy = data ? data->
destroy : 0;
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 0x020012
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_FLOAT64
2970 #define NPY_PLFLT NPY_FLOAT32
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);
3397 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in,
NPY_PLINT,
3402 if ( PyArray_Check( in ) )
3405 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in,
NPY_PLINT );
3412 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3415 PyObject *resultobj = 0;
3418 PLFLT *arg3 = (PLFLT *) 0 ;
3419 PLFLT *arg4 = (PLFLT *) 0 ;
3429 PyObject * obj0 = 0 ;
3430 PyObject * obj1 = 0 ;
3437 if (!PyArg_ParseTuple(args,(
char *)
"OO:pltr0",&obj0,&obj1))
SWIG_fail;
3442 arg1 = (
PLFLT)(val1);
3447 arg2 = (
PLFLT)(val2);
3448 pltr0(arg1,arg2,arg3,arg4,arg5);
3483 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3490 if ( pltr_xg == 0 || pltr_yg == 0 )
3492 PyErr_SetString( PyExc_ValueError,
"Expected a sequence to two 1D arrays." );
3495 tmpGrid1.
nx = (
PLINT) PyArray_DIMS( pltr_xg )[0];
3496 tmpGrid1.
ny = (
PLINT) PyArray_DIMS( pltr_yg )[0];
3499 if ( Xlen != tmpGrid1.
nx ||
Ylen != tmpGrid1.
ny )
3501 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3507 if ( Xlen != tmpGrid1.
nx - 1 ||
Ylen != tmpGrid1.
ny - 1 )
3509 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3513 tmpGrid1.
xg = (PLFLT *) PyArray_DATA( pltr_xg );
3514 tmpGrid1.
yg = (PLFLT *) PyArray_DATA( pltr_yg );
3521 Py_CLEAR( pltr_xg );
3522 Py_CLEAR( pltr_yg );
3531 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3538 if ( pltr_xg == 0 || pltr_yg == 0 )
3540 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two 2D arrays." );
3543 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3544 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3546 PyErr_SetString( PyExc_ValueError,
"Arrays must be same size." );
3549 tmpGrid2.
nx = (
PLINT) PyArray_DIMS( pltr_xg )[0];
3550 tmpGrid2.
ny = (
PLINT) PyArray_DIMS( pltr_xg )[1];
3553 if ( Xlen != tmpGrid2.
nx ||
Ylen != tmpGrid2.
ny )
3555 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3561 if ( Xlen != tmpGrid2.
nx - 1 ||
Ylen != tmpGrid2.
ny - 1 )
3563 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3568 tmpGrid2.
xg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) tmpGrid2.
nx );
3569 for ( i = 0; i < tmpGrid2.
nx; i++ )
3570 tmpGrid2.
xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3571 tmpGrid2.
yg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) tmpGrid2.
nx );
3572 for ( i = 0; i < tmpGrid2.
nx; i++ )
3573 tmpGrid2.
yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3580 free( tmpGrid2.
xg );
3581 free( tmpGrid2.
yg );
3582 Py_CLEAR( pltr_xg );
3583 Py_CLEAR( pltr_yg );
3587 PyObject *resultobj = 0;
3590 PLFLT *arg3 = (PLFLT *) 0 ;
3591 PLFLT *arg4 = (PLFLT *) 0 ;
3601 PyObject * obj0 = 0 ;
3602 PyObject * obj1 = 0 ;
3603 PyObject * obj2 = 0 ;
3607 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr1",&obj0,&obj1,&obj2))
SWIG_fail;
3612 arg1 = (
PLFLT)(val1);
3617 arg2 = (
PLFLT)(val2);
3623 pltr1(arg1,arg2,arg3,arg4,arg5);
3650 PyObject *resultobj = 0;
3653 PLFLT *arg3 = (PLFLT *) 0 ;
3654 PLFLT *arg4 = (PLFLT *) 0 ;
3664 PyObject * obj0 = 0 ;
3665 PyObject * obj1 = 0 ;
3666 PyObject * obj2 = 0 ;
3670 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr2",&obj0,&obj1,&obj2))
SWIG_fail;
3675 arg1 = (
PLFLT)(val1);
3680 arg2 = (
PLFLT)(val2);
3686 pltr2(arg1,arg2,arg3,arg4,arg5);
3715 static PyInterpreterState *save_interp = NULL;
3725 #define MY_BLOCK_THREADS { \
3726 PyThreadState *prev_state, *new_state; \
3729 PyEval_AcquireLock(); \
3730 new_state = PyThreadState_New( save_interp ); \
3731 prev_state = PyThreadState_Swap( new_state );
3732 #define MY_UNBLOCK_THREADS \
3733 new_state = PyThreadState_Swap( prev_state ); \
3734 PyThreadState_Clear( new_state ); \
3735 PyEval_ReleaseLock(); \
3736 PyThreadState_Delete( new_state ); \
3739 #define MY_BLOCK_THREADS
3740 #define MY_UNBLOCK_THREADS
3763 PyObject *pdata, *arglist, *result;
3767 pdata = (PyObject *) data;
3774 Py_XINCREF( pdata );
3779 arglist = Py_BuildValue(
"(ddO)", x, y, pdata );
3781 arglist = Py_BuildValue(
"(ffO)", x, y, pdata );
3783 if ( arglist == NULL )
3785 fprintf( stderr,
"Py_BuildValue failed to make argument list.\n" );
3790 result = PyEval_CallObject( python_pltr, arglist );
3792 Py_CLEAR( arglist );
3794 if ( result == NULL )
3796 fprintf( stderr,
"call to python pltr function with 3 arguments failed\n" );
3797 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must take 3 argments." );
3803 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3805 fprintf( stderr,
"pltr callback must return a 2 element array or sequence\n" );
3806 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must return a 2-sequence." );
3811 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3826 PyObject *pdata, *arglist, *result;
3827 PLFLT fresult = 0.0;
3830 pdata = (PyObject *) data;
3831 if ( python_f2eval )
3833 Py_XINCREF( pdata );
3837 arglist = Py_BuildValue(
"(iiO)", x, y, pdata );
3839 result = PyEval_CallObject( python_f2eval, arglist );
3841 Py_CLEAR( arglist );
3843 if ( !PyFloat_Check( result ) )
3845 fprintf( stderr,
"f2eval callback must return a float\n" );
3846 PyErr_SetString( PyExc_RuntimeError,
"f2eval callback must return a float." );
3851 fresult = (
PLFLT) PyFloat_AsDouble( result );
3863 PyObject *pdata, *arglist, *result;
3868 pdata = (PyObject *) data;
3873 Py_XINCREF( pdata );
3878 arglist = Py_BuildValue(
"(ldO)", axis, value, pdata );
3880 arglist = Py_BuildValue(
"(lfO)", axis, value, pdata );
3883 result = PyEval_CallObject( python_label, arglist );
3887 if ( result == NULL )
3889 fprintf( stderr,
"label callback failed with 3 arguments\n" );
3890 PyErr_SetString( PyExc_RuntimeError,
"label callback must take 3 arguments." );
3892 else if ( !PyString_Check( result ) )
3894 fprintf( stderr,
"label callback must return a string\n" );
3895 PyErr_SetString( PyExc_RuntimeError,
"label callback must return a string." );
3900 pystring = PyString_AsString( result );
3901 strncpy(
string, pystring, len );
3912 PyObject *px, *py, *pdata, *arglist, *result;
3917 pdata = (PyObject *) data;
3924 Py_XINCREF( pdata );
3928 px = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) xt );
3929 py = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) yt );
3930 arglist = Py_BuildValue(
"(ddOOO)", x, y, px, py, pdata );
3932 result = PyEval_CallObject( python_ct, arglist );
3934 Py_CLEAR( arglist );
3939 if ( result == NULL )
3941 fprintf( stderr,
"call to python coordinate transform function with 5 arguments failed\n" );
3942 PyErr_SetString( PyExc_RuntimeError,
"coordinate transform callback must take 5 arguments." );
3953 PyObject *px, *py, *arglist, *result;
3960 if ( python_mapform )
3964 #ifdef PL_HAVE_PTHREAD
3965 px = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) x );
3966 py = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) y );
3968 px = PyArray_FromDimsAndData( 1, &n,
NPY_PLFLT, (
char *) x );
3969 py = PyArray_FromDimsAndData( 1, &n,
NPY_PLFLT, (
char *) y );
3971 arglist = Py_BuildValue(
"(iOO)", n, px, py );
3973 result = PyEval_CallObject( python_mapform, arglist );
3975 Py_CLEAR( arglist );
3979 if ( result == NULL )
3981 fprintf( stderr,
"call to python mapform function with 3 arguments failed\n" );
3982 PyErr_SetString( PyExc_RuntimeError,
"mapform callback must take 3 arguments." );
3995 PyObject * rep = PyObject_Repr( input );
3998 char* str = PyString_AsString( rep );
3999 if ( strcmp( str,
"<built-in function pltr0>" ) == 0 )
4005 else if ( strcmp( str,
"<built-in function pltr1>" ) == 0 )
4011 else if ( strcmp( str,
"<built-in function pltr2>" ) == 0 )
4019 python_pltr = input;
4021 Py_XINCREF( input );
4027 python_pltr = input;
4029 Py_XINCREF( input );
4036 Py_CLEAR( python_pltr );
4045 Py_XINCREF( input );
4051 Py_CLEAR( python_ct );
4059 python_mapform = input;
4060 Py_XINCREF( input );
4066 Py_CLEAR( python_mapform );
4078 if ( input != Py_None )
4082 if ( input != Py_None )
4086 Py_XINCREF( input );
4090 fprintf( stderr,
"pltr_type is invalid\n" );
4108 Py_CLEAR( python_pltr );
4111 fprintf( stderr,
"pltr_type is invalid\n" );
4120 PyObject *resultobj = 0;
4127 PyObject * obj0 = 0 ;
4128 PyObject * obj1 = 0 ;
4130 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_type_set",&obj0,&obj1))
SWIG_fail;
4141 if (arg1) (arg1)->type = arg2;
4150 PyObject *resultobj = 0;
4154 PyObject * obj0 = 0 ;
4157 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_type_get",&obj0))
SWIG_fail;
4163 result = (int) ((arg1)->type);
4172 PyObject *resultobj = 0;
4179 PyObject * obj0 = 0 ;
4180 PyObject * obj1 = 0 ;
4182 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_state_set",&obj0,&obj1))
SWIG_fail;
4192 arg2 = (
unsigned int)(val2);
4193 if (arg1) (arg1)->state = arg2;
4202 PyObject *resultobj = 0;
4206 PyObject * obj0 = 0 ;
4207 unsigned int result;
4209 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_state_get",&obj0))
SWIG_fail;
4215 result = (
unsigned int) ((arg1)->state);
4224 PyObject *resultobj = 0;
4231 PyObject * obj0 = 0 ;
4232 PyObject * obj1 = 0 ;
4234 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_keysym_set",&obj0,&obj1))
SWIG_fail;
4244 arg2 = (
unsigned int)(val2);
4245 if (arg1) (arg1)->keysym = arg2;
4254 PyObject *resultobj = 0;
4258 PyObject * obj0 = 0 ;
4259 unsigned int result;
4261 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_keysym_get",&obj0))
SWIG_fail;
4267 result = (
unsigned int) ((arg1)->keysym);
4276 PyObject *resultobj = 0;
4283 PyObject * obj0 = 0 ;
4284 PyObject * obj1 = 0 ;
4286 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_button_set",&obj0,&obj1))
SWIG_fail;
4296 arg2 = (
unsigned int)(val2);
4297 if (arg1) (arg1)->button = arg2;
4306 PyObject *resultobj = 0;
4310 PyObject * obj0 = 0 ;
4311 unsigned int result;
4313 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_button_get",&obj0))
SWIG_fail;
4319 result = (
unsigned int) ((arg1)->button);
4328 PyObject *resultobj = 0;
4335 PyObject * obj0 = 0 ;
4336 PyObject * obj1 = 0 ;
4338 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1))
SWIG_fail;
4348 arg2 = (
PLINT)(val2);
4349 if (arg1) (arg1)->subwindow = arg2;
4358 PyObject *resultobj = 0;
4362 PyObject * obj0 = 0 ;
4365 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_subwindow_get",&obj0))
SWIG_fail;
4371 result = (
PLINT) ((arg1)->subwindow);
4380 PyObject *resultobj = 0;
4387 PyObject * obj0 = 0 ;
4388 PyObject * obj1 = 0 ;
4390 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_string_set",&obj0,&obj1))
SWIG_fail;
4400 arg2 = (
char *)(temp2);
4401 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
4402 else memset(arg1->
string,0,16*
sizeof(
char));
4411 PyObject *resultobj = 0;
4415 PyObject * obj0 = 0 ;
4418 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_string_get",&obj0))
SWIG_fail;
4424 result = (
char *)(
char *) ((arg1)->
string);
4428 while (size && (result[size - 1] ==
'\0')) --size;
4439 PyObject *resultobj = 0;
4446 PyObject * obj0 = 0 ;
4447 PyObject * obj1 = 0 ;
4449 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pX_set",&obj0,&obj1))
SWIG_fail;
4460 if (arg1) (arg1)->pX = arg2;
4469 PyObject *resultobj = 0;
4473 PyObject * obj0 = 0 ;
4476 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pX_get",&obj0))
SWIG_fail;
4482 result = (int) ((arg1)->pX);
4491 PyObject *resultobj = 0;
4498 PyObject * obj0 = 0 ;
4499 PyObject * obj1 = 0 ;
4501 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pY_set",&obj0,&obj1))
SWIG_fail;
4512 if (arg1) (arg1)->pY = arg2;
4521 PyObject *resultobj = 0;
4525 PyObject * obj0 = 0 ;
4528 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pY_get",&obj0))
SWIG_fail;
4534 result = (int) ((arg1)->pY);
4543 PyObject *resultobj = 0;
4550 PyObject * obj0 = 0 ;
4551 PyObject * obj1 = 0 ;
4553 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dX_set",&obj0,&obj1))
SWIG_fail;
4563 arg2 = (
PLFLT)(val2);
4564 if (arg1) (arg1)->dX = arg2;
4573 PyObject *resultobj = 0;
4577 PyObject * obj0 = 0 ;
4580 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dX_get",&obj0))
SWIG_fail;
4586 result = (
PLFLT) ((arg1)->dX);
4595 PyObject *resultobj = 0;
4602 PyObject * obj0 = 0 ;
4603 PyObject * obj1 = 0 ;
4605 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dY_set",&obj0,&obj1))
SWIG_fail;
4615 arg2 = (
PLFLT)(val2);
4616 if (arg1) (arg1)->dY = arg2;
4625 PyObject *resultobj = 0;
4629 PyObject * obj0 = 0 ;
4632 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dY_get",&obj0))
SWIG_fail;
4638 result = (
PLFLT) ((arg1)->dY);
4647 PyObject *resultobj = 0;
4654 PyObject * obj0 = 0 ;
4655 PyObject * obj1 = 0 ;
4657 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wX_set",&obj0,&obj1))
SWIG_fail;
4667 arg2 = (
PLFLT)(val2);
4668 if (arg1) (arg1)->wX = arg2;
4677 PyObject *resultobj = 0;
4681 PyObject * obj0 = 0 ;
4684 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wX_get",&obj0))
SWIG_fail;
4690 result = (
PLFLT) ((arg1)->wX);
4699 PyObject *resultobj = 0;
4706 PyObject * obj0 = 0 ;
4707 PyObject * obj1 = 0 ;
4709 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wY_set",&obj0,&obj1))
SWIG_fail;
4719 arg2 = (
PLFLT)(val2);
4720 if (arg1) (arg1)->wY = arg2;
4729 PyObject *resultobj = 0;
4733 PyObject * obj0 = 0 ;
4736 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wY_get",&obj0))
SWIG_fail;
4742 result = (
PLFLT) ((arg1)->wY);
4751 PyObject *resultobj = 0;
4754 if (!PyArg_ParseTuple(args,(
char *)
":new_PLGraphicsIn"))
SWIG_fail;
4764 PyObject *resultobj = 0;
4768 PyObject * obj0 = 0 ;
4770 if (!PyArg_ParseTuple(args,(
char *)
"O:delete_PLGraphicsIn",&obj0))
SWIG_fail;
4776 free((
char *) arg1);
4786 if (!PyArg_ParseTuple(args,(
char*)
"O:swigregister", &obj))
return NULL;
4792 PyObject *resultobj = 0;
4796 PyObject * obj0 = 0 ;
4798 if (!PyArg_ParseTuple(args,(
char *)
"O:plsxwin",&obj0))
SWIG_fail;
4803 arg1 = (
PLINT)(val1);
4813 PyObject *resultobj = 0;
4820 PyObject * obj0 = 0 ;
4821 PyObject * obj1 = 0 ;
4823 if (!PyArg_ParseTuple(args,(
char *)
"OO:pl_setcontlabelformat",&obj0,&obj1))
SWIG_fail;
4828 arg1 = (
PLINT)(val1);
4833 arg2 = (
PLINT)(val2);
4843 PyObject *resultobj = 0;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 PyObject * obj2 = 0 ;
4859 PyObject * obj3 = 0 ;
4861 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
4866 arg1 = (
PLFLT)(val1);
4871 arg2 = (
PLFLT)(val2);
4876 arg3 = (
PLFLT)(val3);
4881 arg4 = (
PLINT)(val4);
4891 PyObject *resultobj = 0;
4895 PyObject * obj0 = 0 ;
4897 if (!PyArg_ParseTuple(args,(
char *)
"O:pladv",&obj0))
SWIG_fail;
4902 arg1 = (
PLINT)(val1);
4912 PyObject *resultobj = 0;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 PyObject * obj3 = 0 ;
4941 PyObject * obj4 = 0 ;
4942 PyObject * obj5 = 0 ;
4943 PyObject * obj6 = 0 ;
4944 PyObject * obj7 = 0 ;
4946 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
4951 arg1 = (
PLFLT)(val1);
4956 arg2 = (
PLFLT)(val2);
4961 arg3 = (
PLFLT)(val3);
4966 arg4 = (
PLFLT)(val4);
4971 arg5 = (
PLFLT)(val5);
4976 arg6 = (
PLFLT)(val6);
4981 arg7 = (
PLFLT)(val7);
4987 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4996 PyObject *resultobj = 0;
4999 char *arg3 = (
char *) 0 ;
5002 char *arg6 = (
char *) 0 ;
5023 PyObject * obj0 = 0 ;
5024 PyObject * obj1 = 0 ;
5025 PyObject * obj2 = 0 ;
5026 PyObject * obj3 = 0 ;
5027 PyObject * obj4 = 0 ;
5028 PyObject * obj5 = 0 ;
5029 PyObject * obj6 = 0 ;
5030 PyObject * obj7 = 0 ;
5032 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5037 arg1 = (
PLFLT)(val1);
5042 arg2 = (
PLFLT)(val2);
5047 arg3 = (
char *)(buf3);
5052 arg4 = (
PLFLT)(val4);
5057 arg5 = (
PLINT)(val5);
5062 arg6 = (
char *)(buf6);
5067 arg7 = (
PLFLT)(val7);
5072 arg8 = (
PLINT)(val8);
5073 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
5086 PyObject *resultobj = 0;
5088 PLFLT *arg2 = (PLFLT *) 0 ;
5089 PLFLT *arg3 = (PLFLT *) 0 ;
5091 PyArrayObject *tmp1 = NULL ;
5092 PyArrayObject *tmp3 = NULL ;
5095 PyObject * obj0 = 0 ;
5096 PyObject * obj1 = 0 ;
5097 PyObject * obj2 = 0 ;
5099 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plbin",&obj0,&obj1,&obj2))
SWIG_fail;
5104 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5105 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5111 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
5113 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
5116 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5122 arg4 = (
PLINT)(val4);
5123 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
5144 PyObject *resultobj = 0;
5145 PLINT *arg1 = (PLINT *) 0 ;
5146 PLINT *arg2 = (PLINT *) 0 ;
5147 PLINT *arg3 = (PLINT *) 0 ;
5148 PLINT *arg4 = (PLINT *) 0 ;
5149 PLINT *arg5 = (PLINT *) 0 ;
5150 PLFLT *arg6 = (PLFLT *) 0 ;
5166 PyObject * obj0 = 0 ;
5174 if (!PyArg_ParseTuple(args,(
char *)
"O:plbtime",&obj0))
SWIG_fail;
5179 arg7 = (
PLFLT)(val7);
5180 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5225 PyObject *resultobj = 0;
5227 if (!PyArg_ParseTuple(args,(
char *)
":plbop"))
SWIG_fail;
5237 PyObject *resultobj = 0;
5238 char *arg1 = (
char *) 0 ;
5241 char *arg4 = (
char *) 0 ;
5258 PyObject * obj0 = 0 ;
5259 PyObject * obj1 = 0 ;
5260 PyObject * obj2 = 0 ;
5261 PyObject * obj3 = 0 ;
5262 PyObject * obj4 = 0 ;
5263 PyObject * obj5 = 0 ;
5265 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5270 arg1 = (
char *)(buf1);
5275 arg2 = (
PLFLT)(val2);
5280 arg3 = (
PLINT)(val3);
5285 arg4 = (
char *)(buf4);
5290 arg5 = (
PLFLT)(val5);
5295 arg6 = (
PLINT)(val6);
5296 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
5309 PyObject *resultobj = 0;
5310 char *arg1 = (
char *) 0 ;
5311 char *arg2 = (
char *) 0 ;
5314 char *arg5 = (
char *) 0 ;
5315 char *arg6 = (
char *) 0 ;
5318 char *arg9 = (
char *) 0 ;
5319 char *arg10 = (
char *) 0 ;
5352 PyObject * obj0 = 0 ;
5353 PyObject * obj1 = 0 ;
5354 PyObject * obj2 = 0 ;
5355 PyObject * obj3 = 0 ;
5356 PyObject * obj4 = 0 ;
5357 PyObject * obj5 = 0 ;
5358 PyObject * obj6 = 0 ;
5359 PyObject * obj7 = 0 ;
5360 PyObject * obj8 = 0 ;
5361 PyObject * obj9 = 0 ;
5362 PyObject * obj10 = 0 ;
5363 PyObject * obj11 = 0 ;
5365 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
5370 arg1 = (
char *)(buf1);
5375 arg2 = (
char *)(buf2);
5380 arg3 = (
PLFLT)(val3);
5385 arg4 = (
PLINT)(val4);
5390 arg5 = (
char *)(buf5);
5395 arg6 = (
char *)(buf6);
5400 arg7 = (
PLFLT)(val7);
5405 arg8 = (
PLINT)(val8);
5410 arg9 = (
char *)(buf9);
5415 arg10 = (
char *)(buf10);
5420 arg11 = (
PLFLT)(val11);
5425 arg12 = (
PLINT)(val12);
5426 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);
5447 PyObject *resultobj = 0;
5450 PLFLT *arg3 = (PLFLT *) 0 ;
5451 PLFLT *arg4 = (PLFLT *) 0 ;
5452 PLINT *arg5 = (PLINT *) 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5469 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcalc_world",&obj0,&obj1))
SWIG_fail;
5474 arg1 = (
PLFLT)(val1);
5479 arg2 = (
PLFLT)(val2);
5507 PyObject *resultobj = 0;
5509 if (!PyArg_ParseTuple(args,(
char *)
":plclear"))
SWIG_fail;
5519 PyObject *resultobj = 0;
5523 PyObject * obj0 = 0 ;
5525 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol0",&obj0))
SWIG_fail;
5530 arg1 = (
PLINT)(val1);
5540 PyObject *resultobj = 0;
5544 PyObject * obj0 = 0 ;
5546 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol1",&obj0))
SWIG_fail;
5551 arg1 = (
PLFLT)(val1);
5561 PyObject *resultobj = 0;
5595 PyObject * obj0 = 0 ;
5596 PyObject * obj1 = 0 ;
5597 PyObject * obj2 = 0 ;
5598 PyObject * obj3 = 0 ;
5599 PyObject * obj4 = 0 ;
5600 PyObject * obj5 = 0 ;
5601 PyObject * obj6 = 0 ;
5602 PyObject * obj7 = 0 ;
5603 PyObject * obj8 = 0 ;
5604 PyObject * obj9 = 0 ;
5605 PyObject * obj10 = 0 ;
5607 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
5612 arg1 = (
PLFLT)(val1);
5617 arg2 = (
PLFLT)(val2);
5622 arg3 = (
PLFLT)(val3);
5627 arg4 = (
PLINT)(val4);
5637 arg6 = (
PLINT)(val6);
5642 arg7 = (
PLINT)(val7);
5647 arg8 = (
PLINT)(val8);
5652 arg9 = (
PLINT)(val9);
5657 arg10 = (
PLINT)(val10);
5662 arg11 = (
PLFLT)(val11);
5663 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5672 PyObject *resultobj = 0;
5673 PLFLT **arg1 = (PLFLT **) 0 ;
5680 PLFLT *arg8 = (PLFLT *) 0 ;
5684 PyArrayObject *tmp1 = NULL ;
5693 PyArrayObject *tmp8 = NULL ;
5694 PyObject * obj0 = 0 ;
5695 PyObject * obj1 = 0 ;
5696 PyObject * obj2 = 0 ;
5697 PyObject * obj3 = 0 ;
5698 PyObject * obj4 = 0 ;
5699 PyObject * obj5 = 0 ;
5700 PyObject * obj6 = 0 ;
5701 PyObject * obj7 = 0 ;
5710 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5716 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5717 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5719 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
5720 for ( i = 0; i < arg2; i++ )
5721 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5727 arg4 = (
PLINT)(val4);
5732 arg5 = (
PLINT)(val5);
5737 arg6 = (
PLINT)(val6);
5742 arg7 = (
PLINT)(val7);
5747 arg9 = PyArray_DIMS( tmp8 )[0];
5748 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5753 if ( obj6 == Py_None )
5759 if ( !PyCallable_Check( (PyObject *) obj6 ) )
5761 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
5770 if ( obj7 == Py_None )
5778 plcont((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11);
5813 PyObject *resultobj = 0;
5820 PLFLT *arg7 = (PLFLT *) 0 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 PyObject * obj2 = 0 ;
5838 PyObject * obj3 = 0 ;
5839 PyObject * obj4 = 0 ;
5840 PyObject * obj5 = 0 ;
5843 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5848 arg1 = (
PLINT)(val1);
5853 arg2 = (
PLINT)(val2);
5858 arg3 = (
PLINT)(val3);
5863 arg4 = (
PLINT)(val4);
5868 arg5 = (
PLINT)(val5);
5873 arg6 = (
PLFLT)(val6);
5874 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5889 PyObject *resultobj = 0;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5899 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcpstrm",&obj0,&obj1))
SWIG_fail;
5904 arg1 = (
PLINT)(val1);
5919 PyObject *resultobj = 0;
5921 if (!PyArg_ParseTuple(args,(
char *)
":plend"))
SWIG_fail;
5931 PyObject *resultobj = 0;
5933 if (!PyArg_ParseTuple(args,(
char *)
":plend1"))
SWIG_fail;
5943 PyObject *resultobj = 0;
5962 PyObject * obj0 = 0 ;
5963 PyObject * obj1 = 0 ;
5964 PyObject * obj2 = 0 ;
5965 PyObject * obj3 = 0 ;
5966 PyObject * obj4 = 0 ;
5967 PyObject * obj5 = 0 ;
5969 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5974 arg1 = (
PLFLT)(val1);
5979 arg2 = (
PLFLT)(val2);
5984 arg3 = (
PLFLT)(val3);
5989 arg4 = (
PLFLT)(val4);
5994 arg5 = (
PLINT)(val5);
5999 arg6 = (
PLINT)(val6);
6000 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6009 PyObject *resultobj = 0;
6028 PyObject * obj0 = 0 ;
6029 PyObject * obj1 = 0 ;
6030 PyObject * obj2 = 0 ;
6031 PyObject * obj3 = 0 ;
6032 PyObject * obj4 = 0 ;
6033 PyObject * obj5 = 0 ;
6035 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
6040 arg1 = (
PLFLT)(val1);
6045 arg2 = (
PLFLT)(val2);
6050 arg3 = (
PLFLT)(val3);
6055 arg4 = (
PLFLT)(val4);
6060 arg5 = (
PLINT)(val5);
6065 arg6 = (
PLINT)(val6);
6066 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6075 PyObject *resultobj = 0;
6077 if (!PyArg_ParseTuple(args,(
char *)
":pleop"))
SWIG_fail;
6087 PyObject *resultobj = 0;
6089 PLFLT *arg2 = (PLFLT *) 0 ;
6090 PLFLT *arg3 = (PLFLT *) 0 ;
6091 PLFLT *arg4 = (PLFLT *) 0 ;
6092 PyArrayObject *tmp1 = NULL ;
6093 PyArrayObject *tmp3 = NULL ;
6094 PyArrayObject *tmp4 = NULL ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 PyObject * obj2 = 0 ;
6099 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerrx",&obj0,&obj1,&obj2))
SWIG_fail;
6104 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6105 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6111 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6113 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6116 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6122 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6124 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6127 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6129 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6156 PyObject *resultobj = 0;
6158 PLFLT *arg2 = (PLFLT *) 0 ;
6159 PLFLT *arg3 = (PLFLT *) 0 ;
6160 PLFLT *arg4 = (PLFLT *) 0 ;
6161 PyArrayObject *tmp1 = NULL ;
6162 PyArrayObject *tmp3 = NULL ;
6163 PyArrayObject *tmp4 = NULL ;
6164 PyObject * obj0 = 0 ;
6165 PyObject * obj1 = 0 ;
6166 PyObject * obj2 = 0 ;
6168 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerry",&obj0,&obj1,&obj2))
SWIG_fail;
6173 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6174 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6180 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6182 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6185 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6191 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6193 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6196 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6198 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6225 PyObject *resultobj = 0;
6227 if (!PyArg_ParseTuple(args,(
char *)
":plfamadv"))
SWIG_fail;
6237 PyObject *resultobj = 0;
6239 PLFLT *arg2 = (PLFLT *) 0 ;
6240 PLFLT *arg3 = (PLFLT *) 0 ;
6241 PyArrayObject *tmp1 = NULL ;
6242 PyArrayObject *tmp3 = NULL ;
6243 PyObject * obj0 = 0 ;
6244 PyObject * obj1 = 0 ;
6246 if (!PyArg_ParseTuple(args,(
char *)
"OO:plfill",&obj0,&obj1))
SWIG_fail;
6251 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6252 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6258 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6260 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6263 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6265 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
6286 PyObject *resultobj = 0;
6288 PLFLT *arg2 = (PLFLT *) 0 ;
6289 PLFLT *arg3 = (PLFLT *) 0 ;
6290 PLFLT *arg4 = (PLFLT *) 0 ;
6291 PyArrayObject *tmp1 = NULL ;
6292 PyArrayObject *tmp3 = NULL ;
6293 PyArrayObject *tmp4 = NULL ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 PyObject * obj2 = 0 ;
6298 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plfill3",&obj0,&obj1,&obj2))
SWIG_fail;
6303 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6304 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6310 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6312 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6315 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6321 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6323 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6326 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6328 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6355 PyObject *resultobj = 0;
6357 PLFLT *arg2 = (PLFLT *) 0 ;
6358 PLFLT *arg3 = (PLFLT *) 0 ;
6360 PyArrayObject *tmp1 = NULL ;
6361 PyArrayObject *tmp3 = NULL ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 PyObject * obj2 = 0 ;
6368 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plgradient",&obj0,&obj1,&obj2))
SWIG_fail;
6373 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6374 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6380 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6382 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6385 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6391 arg4 = (
PLFLT)(val4);
6392 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
6413 PyObject *resultobj = 0;
6415 if (!PyArg_ParseTuple(args,(
char *)
":plflush"))
SWIG_fail;
6425 PyObject *resultobj = 0;
6429 PyObject * obj0 = 0 ;
6431 if (!PyArg_ParseTuple(args,(
char *)
"O:plfont",&obj0))
SWIG_fail;
6436 arg1 = (
PLINT)(val1);
6446 PyObject *resultobj = 0;
6450 PyObject * obj0 = 0 ;
6452 if (!PyArg_ParseTuple(args,(
char *)
"O:plfontld",&obj0))
SWIG_fail;
6457 arg1 = (
PLINT)(val1);
6467 PyObject *resultobj = 0;
6468 PLFLT *arg1 = (PLFLT *) 0 ;
6469 PLFLT *arg2 = (PLFLT *) 0 ;
6477 if (!PyArg_ParseTuple(args,(
char *)
":plgchr"))
SWIG_fail;
6499 PyObject *resultobj = 0;
6501 PLINT *arg2 = (PLINT *) 0 ;
6502 PLINT *arg3 = (PLINT *) 0 ;
6503 PLINT *arg4 = (PLINT *) 0 ;
6512 PyObject * obj0 = 0 ;
6517 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0",&obj0))
SWIG_fail;
6522 arg1 = (
PLINT)(val1);
6550 PyObject *resultobj = 0;
6552 PLINT *arg2 = (PLINT *) 0 ;
6553 PLINT *arg3 = (PLINT *) 0 ;
6554 PLINT *arg4 = (PLINT *) 0 ;
6555 PLFLT *arg5 = (PLFLT *) 0 ;
6566 PyObject * obj0 = 0 ;
6572 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0a",&obj0))
SWIG_fail;
6577 arg1 = (
PLINT)(val1);
6578 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6611 PyObject *resultobj = 0;
6612 PLINT *arg1 = (PLINT *) 0 ;
6613 PLINT *arg2 = (PLINT *) 0 ;
6614 PLINT *arg3 = (PLINT *) 0 ;
6625 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbg"))
SWIG_fail;
6653 PyObject *resultobj = 0;
6654 PLINT *arg1 = (PLINT *) 0 ;
6655 PLINT *arg2 = (PLINT *) 0 ;
6656 PLINT *arg3 = (PLINT *) 0 ;
6657 PLFLT *arg4 = (PLFLT *) 0 ;
6671 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbga"))
SWIG_fail;
6705 PyObject *resultobj = 0;
6706 PLINT *arg1 = (PLINT *) 0 ;
6711 if (!PyArg_ParseTuple(args,(
char *)
":plgcompression"))
SWIG_fail;
6727 PyObject *resultobj = 0;
6728 char *arg1 = (
char *) 0 ;
6734 if (!PyArg_ParseTuple(args,(
char *)
":plgdev"))
SWIG_fail;
6738 PyObject *o = PyString_FromString( arg1 );
6748 PyObject *resultobj = 0;
6749 PLFLT *arg1 = (PLFLT *) 0 ;
6750 PLFLT *arg2 = (PLFLT *) 0 ;
6751 PLFLT *arg3 = (PLFLT *) 0 ;
6752 PLFLT *arg4 = (PLFLT *) 0 ;
6766 if (!PyArg_ParseTuple(args,(
char *)
":plgdidev"))
SWIG_fail;
6800 PyObject *resultobj = 0;
6801 PLFLT *arg1 = (PLFLT *) 0 ;
6806 if (!PyArg_ParseTuple(args,(
char *)
":plgdiori"))
SWIG_fail;
6822 PyObject *resultobj = 0;
6823 PLFLT *arg1 = (PLFLT *) 0 ;
6824 PLFLT *arg2 = (PLFLT *) 0 ;
6825 PLFLT *arg3 = (PLFLT *) 0 ;
6826 PLFLT *arg4 = (PLFLT *) 0 ;
6840 if (!PyArg_ParseTuple(args,(
char *)
":plgdiplt"))
SWIG_fail;
6874 PyObject *resultobj = 0;
6875 PLINT *arg1 = (PLINT *) 0 ;
6876 PLINT *arg2 = (PLINT *) 0 ;
6877 PLINT *arg3 = (PLINT *) 0 ;
6888 if (!PyArg_ParseTuple(args,(
char *)
":plgfam"))
SWIG_fail;
6916 PyObject *resultobj = 0;
6922 if (!PyArg_ParseTuple(args,(
char *)
":plgfci"))
SWIG_fail;
6938 PyObject *resultobj = 0;
6939 char *arg1 = (
char *) 0 ;
6945 if (!PyArg_ParseTuple(args,(
char *)
":plgfnam"))
SWIG_fail;
6949 PyObject *o = PyString_FromString( arg1 );
6959 PyObject *resultobj = 0;
6960 PLINT *arg1 = (PLINT *) 0 ;
6961 PLINT *arg2 = (PLINT *) 0 ;
6962 PLINT *arg3 = (PLINT *) 0 ;
6973 if (!PyArg_ParseTuple(args,(
char *)
":plgfont"))
SWIG_fail;
7001 PyObject *resultobj = 0;
7002 PLINT *arg1 = (PLINT *) 0 ;
7007 if (!PyArg_ParseTuple(args,(
char *)
":plglevel"))
SWIG_fail;
7023 PyObject *resultobj = 0;
7024 PLFLT *arg1 = (PLFLT *) 0 ;
7025 PLFLT *arg2 = (PLFLT *) 0 ;
7026 PLINT *arg3 = (PLINT *) 0 ;
7027 PLINT *arg4 = (PLINT *) 0 ;
7028 PLINT *arg5 = (PLINT *) 0 ;
7029 PLINT *arg6 = (PLINT *) 0 ;
7049 if (!PyArg_ParseTuple(args,(
char *)
":plgpage"))
SWIG_fail;
7050 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7095 PyObject *resultobj = 0;
7097 if (!PyArg_ParseTuple(args,(
char *)
":plgra"))
SWIG_fail;
7107 PyObject *resultobj = 0;
7108 PLFLT *arg1 = (PLFLT *) 0 ;
7109 PLFLT *arg2 = (PLFLT *) 0 ;
7110 PLFLT *arg3 = (PLFLT *) 0 ;
7112 PLFLT *arg5 = (PLFLT *) 0 ;
7114 PLFLT *arg7 = (PLFLT *) 0 ;
7116 PLFLT **arg9 = (PLFLT **) 0 ;
7119 PyArrayObject *tmp1 = NULL ;
7120 PyArrayObject *tmp2 = NULL ;
7121 PyArrayObject *tmp3 = NULL ;
7122 PyArrayObject *tmp5 = NULL ;
7123 PyArrayObject *tmp7 = NULL ;
7124 PyObject *array7 = NULL ;
7129 PyObject * obj0 = 0 ;
7130 PyObject * obj1 = 0 ;
7131 PyObject * obj2 = 0 ;
7132 PyObject * obj3 = 0 ;
7133 PyObject * obj4 = 0 ;
7134 PyObject * obj5 = 0 ;
7135 PyObject * obj6 = 0 ;
7137 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
7142 Alen = PyArray_DIMS( tmp1 )[0];
7143 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7149 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
7151 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7154 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7160 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
7162 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7165 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7166 arg4 = PyArray_DIMS( tmp3 )[0];
7172 Xlen = PyArray_DIMS( tmp5 )[0];
7174 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7182 Ylen = PyArray_DIMS( tmp7 )[0];
7184 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7189 array7 = PyArray_SimpleNew( 2, dims,
NPY_PLFLT );
7193 arg9 = (PLFLT **) malloc(
sizeof (
double * ) * (size_t) Xlen );
7194 for ( i = 0; i <
Xlen; i++ )
7195 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7201 arg10 = (
PLINT)(val10);
7206 arg11 = (
PLFLT)(val11);
7207 plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
7251 PyObject *resultobj = 0;
7252 PLFLT *arg1 = (PLFLT *) 0 ;
7253 PLFLT *arg2 = (PLFLT *) 0 ;
7254 PLFLT *arg3 = (PLFLT *) 0 ;
7255 PLFLT *arg4 = (PLFLT *) 0 ;
7269 if (!PyArg_ParseTuple(args,(
char *)
":plgspa"))
SWIG_fail;
7270 plgspa(arg1,arg2,arg3,arg4);
7303 PyObject *resultobj = 0;
7304 PLINT *arg1 = (PLINT *) 0 ;
7309 if (!PyArg_ParseTuple(args,(
char *)
":plgstrm"))
SWIG_fail;
7325 PyObject *resultobj = 0;
7326 char *arg1 = (
char *) 0 ;
7332 if (!PyArg_ParseTuple(args,(
char *)
":plgver"))
SWIG_fail;
7336 PyObject *o = PyString_FromString( arg1 );
7346 PyObject *resultobj = 0;
7347 PLFLT *arg1 = (PLFLT *) 0 ;
7348 PLFLT *arg2 = (PLFLT *) 0 ;
7349 PLFLT *arg3 = (PLFLT *) 0 ;
7350 PLFLT *arg4 = (PLFLT *) 0 ;
7364 if (!PyArg_ParseTuple(args,(
char *)
":plgvpd"))
SWIG_fail;
7365 plgvpd(arg1,arg2,arg3,arg4);
7398 PyObject *resultobj = 0;
7399 PLFLT *arg1 = (PLFLT *) 0 ;
7400 PLFLT *arg2 = (PLFLT *) 0 ;
7401 PLFLT *arg3 = (PLFLT *) 0 ;
7402 PLFLT *arg4 = (PLFLT *) 0 ;
7416 if (!PyArg_ParseTuple(args,(
char *)
":plgvpw"))
SWIG_fail;
7417 plgvpw(arg1,arg2,arg3,arg4);
7450 PyObject *resultobj = 0;
7451 PLINT *arg1 = (PLINT *) 0 ;
7452 PLINT *arg2 = (PLINT *) 0 ;
7460 if (!PyArg_ParseTuple(args,(
char *)
":plgxax"))
SWIG_fail;
7482 PyObject *resultobj = 0;
7483 PLINT *arg1 = (PLINT *) 0 ;
7484 PLINT *arg2 = (PLINT *) 0 ;
7492 if (!PyArg_ParseTuple(args,(
char *)
":plgyax"))
SWIG_fail;
7514 PyObject *resultobj = 0;
7515 PLINT *arg1 = (PLINT *) 0 ;
7516 PLINT *arg2 = (PLINT *) 0 ;
7524 if (!PyArg_ParseTuple(args,(
char *)
":plgzax"))
SWIG_fail;
7546 PyObject *resultobj = 0;
7548 PLFLT *arg2 = (PLFLT *) 0 ;
7553 PyArrayObject *tmp1 = NULL ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 PyObject * obj2 = 0 ;
7565 PyObject * obj3 = 0 ;
7566 PyObject * obj4 = 0 ;
7568 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
7573 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7574 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7580 arg3 = (
PLFLT)(val3);
7585 arg4 = (
PLFLT)(val4);
7590 arg5 = (
PLINT)(val5);
7595 arg6 = (
PLINT)(val6);
7596 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
7611 PyObject *resultobj = 0;
7615 PLFLT *arg4 = (PLFLT *) 0 ;
7616 PLFLT *arg5 = (PLFLT *) 0 ;
7617 PLFLT *arg6 = (PLFLT *) 0 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 PyObject * obj2 = 0 ;
7637 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plhlsrgb",&obj0,&obj1,&obj2))
SWIG_fail;
7642 arg1 = (
PLFLT)(val1);
7647 arg2 = (
PLFLT)(val2);
7652 arg3 = (
PLFLT)(val3);
7653 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7680 PyObject *resultobj = 0;
7682 if (!PyArg_ParseTuple(args,(
char *)
":plinit"))
SWIG_fail;
7692 PyObject *resultobj = 0;
7705 PyObject * obj0 = 0 ;
7706 PyObject * obj1 = 0 ;
7707 PyObject * obj2 = 0 ;
7708 PyObject * obj3 = 0 ;
7710 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
7715 arg1 = (
PLFLT)(val1);
7720 arg2 = (
PLFLT)(val2);
7725 arg3 = (
PLFLT)(val3);
7730 arg4 = (
PLFLT)(val4);
7731 pljoin(arg1,arg2,arg3,arg4);
7740 PyObject *resultobj = 0;
7741 char *arg1 = (
char *) 0 ;
7742 char *arg2 = (
char *) 0 ;
7743 char *arg3 = (
char *) 0 ;
7753 PyObject * obj0 = 0 ;
7754 PyObject * obj1 = 0 ;
7755 PyObject * obj2 = 0 ;
7757 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllab",&obj0,&obj1,&obj2))
SWIG_fail;
7762 arg1 = (
char *)(buf1);
7767 arg2 = (
char *)(buf2);
7772 arg3 = (
char *)(buf3);
7773 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
7788 PyObject *resultobj = 0;
7789 PLFLT *arg1 = (PLFLT *) 0 ;
7790 PLFLT *arg2 = (PLFLT *) 0 ;
7802 PLINT *arg14 = (PLINT *) 0 ;
7807 PLINT *arg19 = (PLINT *) 0 ;
7808 char **arg20 = (
char **) 0 ;
7809 PLINT *arg21 = (PLINT *) 0 ;
7810 PLINT *arg22 = (PLINT *) 0 ;
7811 PLFLT *arg23 = (PLFLT *) 0 ;
7812 PLFLT *arg24 = (PLFLT *) 0 ;
7813 PLINT *arg25 = (PLINT *) 0 ;
7814 PLINT *arg26 = (PLINT *) 0 ;
7815 PLFLT *arg27 = (PLFLT *) 0 ;
7816 PLINT *arg28 = (PLINT *) 0 ;
7817 PLFLT *arg29 = (PLFLT *) 0 ;
7818 PLINT *arg30 = (PLINT *) 0 ;
7819 char **arg31 = (
char **) 0 ;
7844 PyArrayObject *tmp13 = NULL ;
7853 PyArrayObject *tmp19 = NULL ;
7854 PyArrayObject *tmp20 = NULL ;
7855 PyArrayObject *tmp21 = NULL ;
7856 PyArrayObject *tmp22 = NULL ;
7857 PyArrayObject *tmp23 = NULL ;
7858 PyArrayObject *tmp24 = NULL ;
7859 PyArrayObject *tmp25 = NULL ;
7860 PyArrayObject *tmp26 = NULL ;
7861 PyArrayObject *tmp27 = NULL ;
7862 PyArrayObject *tmp28 = NULL ;
7863 PyArrayObject *tmp29 = NULL ;
7864 PyArrayObject *tmp30 = NULL ;
7865 PyArrayObject *tmp31 = NULL ;
7866 PyObject * obj0 = 0 ;
7867 PyObject * obj1 = 0 ;
7868 PyObject * obj2 = 0 ;
7869 PyObject * obj3 = 0 ;
7870 PyObject * obj4 = 0 ;
7871 PyObject * obj5 = 0 ;
7872 PyObject * obj6 = 0 ;
7873 PyObject * obj7 = 0 ;
7874 PyObject * obj8 = 0 ;
7875 PyObject * obj9 = 0 ;
7876 PyObject * obj10 = 0 ;
7877 PyObject * obj11 = 0 ;
7878 PyObject * obj12 = 0 ;
7879 PyObject * obj13 = 0 ;
7880 PyObject * obj14 = 0 ;
7881 PyObject * obj15 = 0 ;
7882 PyObject * obj16 = 0 ;
7883 PyObject * obj17 = 0 ;
7884 PyObject * obj18 = 0 ;
7885 PyObject * obj19 = 0 ;
7886 PyObject * obj20 = 0 ;
7887 PyObject * obj21 = 0 ;
7888 PyObject * obj22 = 0 ;
7889 PyObject * obj23 = 0 ;
7890 PyObject * obj24 = 0 ;
7891 PyObject * obj25 = 0 ;
7892 PyObject * obj26 = 0 ;
7893 PyObject * obj27 = 0 ;
7897 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;
7902 arg3 = (
PLINT)(val3);
7907 arg4 = (
PLINT)(val4);
7912 arg5 = (
PLFLT)(val5);
7917 arg6 = (
PLFLT)(val6);
7922 arg7 = (
PLFLT)(val7);
7927 arg8 = (
PLINT)(val8);
7932 arg9 = (
PLINT)(val9);
7937 arg10 = (
PLINT)(val10);
7942 arg11 = (
PLINT)(val11);
7947 arg12 = (
PLINT)(val12);
7950 if ( tmp13 == NULL )
7952 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7953 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7959 arg15 = (
PLFLT)(val15);
7964 arg16 = (
PLFLT)(val16);
7969 arg17 = (
PLFLT)(val17);
7974 arg18 = (
PLFLT)(val18);
7977 if ( tmp19 == NULL )
7979 if ( PyArray_DIMS( tmp19 )[0] !=
Alen )
7981 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7984 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7988 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7989 if ( tmp20 == NULL )
7991 if ( PyArray_DIMS( tmp20 )[0] !=
Alen )
7993 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7996 arg20 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
7997 for ( i = 0; i <
Alen; i++ )
7999 arg20[i] = (
char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8000 if ( arg20[i] == NULL )
8009 if ( tmp21 == NULL )
8011 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8013 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8016 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8020 if ( tmp22 == NULL )
8022 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8024 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8027 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8030 if ( obj19 != Py_None )
8033 if ( tmp23 == NULL )
8035 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8037 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8040 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8048 if ( obj20 != Py_None )
8051 if ( tmp24 == NULL )
8053 if ( PyArray_DIMS( tmp24 )[0] !=
Alen )
8055 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8058 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8067 if ( tmp25 == NULL )
8069 if ( PyArray_DIMS( tmp25 )[0] !=
Alen )
8071 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8074 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8078 if ( tmp26 == NULL )
8080 if ( PyArray_DIMS( tmp26 )[0] !=
Alen )
8082 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8085 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8088 if ( obj23 != Py_None )
8091 if ( tmp27 == NULL )
8093 if ( PyArray_DIMS( tmp27 )[0] !=
Alen )
8095 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8098 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8107 if ( tmp28 == NULL )
8109 if ( PyArray_DIMS( tmp28 )[0] !=
Alen )
8111 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8114 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8117 if ( obj25 != Py_None )
8120 if ( tmp29 == NULL )
8122 if ( PyArray_DIMS( tmp29 )[0] !=
Alen )
8124 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8127 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8136 if ( tmp30 == NULL )
8138 if ( PyArray_DIMS( tmp30 )[0] !=
Alen )
8140 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8143 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8147 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8148 if ( tmp31 == NULL )
8150 if ( PyArray_DIMS( tmp31 )[0] !=
Alen )
8152 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8155 arg31 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8156 for ( i = 0; i <
Alen; i++ )
8158 arg31[i] = (
char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8159 if ( arg31[i] == NULL )
8166 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);
8187 Py_CLEAR( tmp20 ); free( arg20 );
8220 Py_CLEAR( tmp31 ); free( arg31 );
8231 Py_CLEAR( tmp20 ); free( arg20 );
8264 Py_CLEAR( tmp31 ); free( arg31 );
8271 PyObject *resultobj = 0;
8272 PLFLT *arg1 = (PLFLT *) 0 ;
8273 PLFLT *arg2 = (PLFLT *) 0 ;
8288 PLINT *arg17 = (PLINT *) 0 ;
8289 char **arg18 = (
char **) 0 ;
8291 char **arg20 = (
char **) 0 ;
8292 PLFLT *arg21 = (PLFLT *) 0 ;
8293 PLINT *arg22 = (PLINT *) 0 ;
8294 PLINT *arg23 = (PLINT *) 0 ;
8295 PLFLT **arg24 = (PLFLT **) 0 ;
8326 PyArrayObject *tmp16 = NULL ;
8327 PyArrayObject *tmp18 = NULL ;
8328 PyArrayObject *tmp19 = NULL ;
8329 PyArrayObject *tmp21 = NULL ;
8330 PyArrayObject *tmp22 = NULL ;
8331 PyArrayObject *tmp23 = NULL ;
8332 PyArrayObject *tmp24 = NULL ;
8333 PyObject * obj0 = 0 ;
8334 PyObject * obj1 = 0 ;
8335 PyObject * obj2 = 0 ;
8336 PyObject * obj3 = 0 ;
8337 PyObject * obj4 = 0 ;
8338 PyObject * obj5 = 0 ;
8339 PyObject * obj6 = 0 ;
8340 PyObject * obj7 = 0 ;
8341 PyObject * obj8 = 0 ;
8342 PyObject * obj9 = 0 ;
8343 PyObject * obj10 = 0 ;
8344 PyObject * obj11 = 0 ;
8345 PyObject * obj12 = 0 ;
8346 PyObject * obj13 = 0 ;
8347 PyObject * obj14 = 0 ;
8348 PyObject * obj15 = 0 ;
8349 PyObject * obj16 = 0 ;
8350 PyObject * obj17 = 0 ;
8351 PyObject * obj18 = 0 ;
8352 PyObject * obj19 = 0 ;
8356 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;
8361 arg3 = (
PLINT)(val3);
8366 arg4 = (
PLINT)(val4);
8371 arg5 = (
PLFLT)(val5);
8376 arg6 = (
PLFLT)(val6);
8381 arg7 = (
PLFLT)(val7);
8386 arg8 = (
PLFLT)(val8);
8391 arg9 = (
PLINT)(val9);
8396 arg10 = (
PLINT)(val10);
8401 arg11 = (
PLINT)(val11);
8406 arg12 = (
PLFLT)(val12);
8411 arg13 = (
PLFLT)(val13);
8416 arg14 = (
PLINT)(val14);
8421 arg15 = (
PLFLT)(val15);
8424 if ( tmp16 == NULL )
8426 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8427 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8431 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8432 if ( tmp18 == NULL )
8434 if ( PyArray_DIMS( tmp18 )[0] !=
Alen )
8436 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8439 arg18 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8440 for ( i = 0; i <
Alen; i++ )
8442 arg18[i] = (
char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8443 if ( arg18[i] == NULL )
8452 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8453 if ( tmp19 == NULL )
8455 Alen = PyArray_DIMS( tmp19 )[0];
8457 arg20 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8458 for ( i = 0; i <
Alen; i++ )
8460 arg20[i] = (
char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8461 if ( arg20[i] == NULL )
8470 if ( tmp21 == NULL )
8472 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8474 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8477 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8481 if ( tmp22 == NULL )
8483 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8485 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8488 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8493 if ( tmp23 == NULL )
8495 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8497 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8500 Xlen = PyArray_DIMS( tmp23 )[0];
8501 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8503 for ( i = 0; i <
Xlen; i++ )
8504 if ( arg23[i] >
Ylen )
8510 if ( tmp24 == NULL )
8512 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] !=
Ylen )
8514 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8518 arg24 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) Xlen );
8519 for ( i = 0; i <
Xlen; i++ )
8520 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8522 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);
8540 Py_CLEAR( tmp18 ); free( arg18 );
8543 Py_CLEAR( tmp19 ); free( arg20 );
8564 Py_CLEAR( tmp18 ); free( arg18 );
8567 Py_CLEAR( tmp19 ); free( arg20 );
8587 PyObject *resultobj = 0;
8597 PyObject * obj0 = 0 ;
8598 PyObject * obj1 = 0 ;
8599 PyObject * obj2 = 0 ;
8601 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllightsource",&obj0,&obj1,&obj2))
SWIG_fail;
8606 arg1 = (
PLFLT)(val1);
8611 arg2 = (
PLFLT)(val2);
8616 arg3 = (
PLFLT)(val3);
8626 PyObject *resultobj = 0;
8628 PLFLT *arg2 = (PLFLT *) 0 ;
8629 PLFLT *arg3 = (PLFLT *) 0 ;
8630 PyArrayObject *tmp1 = NULL ;
8631 PyArrayObject *tmp3 = NULL ;
8632 PyObject * obj0 = 0 ;
8633 PyObject * obj1 = 0 ;
8635 if (!PyArg_ParseTuple(args,(
char *)
"OO:plline",&obj0,&obj1))
SWIG_fail;
8640 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8641 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8647 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8649 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8652 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8654 plline(arg1,(
double const *)arg2,(
double const *)arg3);
8675 PyObject *resultobj = 0;
8677 PLFLT *arg2 = (PLFLT *) 0 ;
8678 PLFLT *arg3 = (PLFLT *) 0 ;
8679 PLFLT *arg4 = (PLFLT *) 0 ;
8680 PyArrayObject *tmp1 = NULL ;
8681 PyArrayObject *tmp3 = NULL ;
8682 PyArrayObject *tmp4 = NULL ;
8683 PyObject * obj0 = 0 ;
8684 PyObject * obj1 = 0 ;
8685 PyObject * obj2 = 0 ;
8687 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plline3",&obj0,&obj1,&obj2))
SWIG_fail;
8692 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8693 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8699 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8701 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8704 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8710 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
8712 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8715 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8717 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
8744 PyObject *resultobj = 0;
8748 PyObject * obj0 = 0 ;
8750 if (!PyArg_ParseTuple(args,(
char *)
"O:pllsty",&obj0))
SWIG_fail;
8755 arg1 = (
PLINT)(val1);
8765 PyObject *resultobj = 0;
8766 PLFLT *arg1 = (PLFLT *) 0 ;
8767 PLFLT *arg2 = (PLFLT *) 0 ;
8768 PLFLT **arg3 = (PLFLT **) 0 ;
8772 PyArrayObject *tmp1 = NULL ;
8773 PyArrayObject *tmp2 = NULL ;
8774 PyArrayObject *tmp3 = NULL ;
8777 PyObject * obj0 = 0 ;
8778 PyObject * obj1 = 0 ;
8779 PyObject * obj2 = 0 ;
8780 PyObject * obj3 = 0 ;
8782 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
8787 Xlen = PyArray_DIMS( tmp1 )[0];
8788 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8794 Ylen = PyArray_DIMS( tmp2 )[0];
8795 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8802 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8804 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8807 arg4 = PyArray_DIMS( tmp3 )[0];
8808 arg5 = PyArray_DIMS( tmp3 )[1];
8810 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
8811 for ( i = 0; i < arg4; i++ )
8812 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8818 arg6 = (
PLINT)(val6);
8819 plmesh((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6);
8848 PyObject *resultobj = 0;
8849 PLFLT *arg1 = (PLFLT *) 0 ;
8850 PLFLT *arg2 = (PLFLT *) 0 ;
8851 PLFLT **arg3 = (PLFLT **) 0 ;
8855 PLFLT *arg7 = (PLFLT *) 0 ;
8857 PyArrayObject *tmp1 = NULL ;
8858 PyArrayObject *tmp2 = NULL ;
8859 PyArrayObject *tmp3 = NULL ;
8862 PyArrayObject *tmp7 = NULL ;
8863 PyObject * obj0 = 0 ;
8864 PyObject * obj1 = 0 ;
8865 PyObject * obj2 = 0 ;
8866 PyObject * obj3 = 0 ;
8867 PyObject * obj4 = 0 ;
8869 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8874 Xlen = PyArray_DIMS( tmp1 )[0];
8875 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8881 Ylen = PyArray_DIMS( tmp2 )[0];
8882 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8889 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8891 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8894 arg4 = PyArray_DIMS( tmp3 )[0];
8895 arg5 = PyArray_DIMS( tmp3 )[1];
8897 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
8898 for ( i = 0; i < arg4; i++ )
8899 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8905 arg6 = (
PLINT)(val6);
8910 arg8 = PyArray_DIMS( tmp7 )[0];
8911 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8913 plmeshc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
8948 PyObject *resultobj = 0;
8949 PLINT *arg1 = (PLINT *) 0 ;
8954 if (!PyArg_ParseTuple(args,(
char *)
":plmkstrm"))
SWIG_fail;
8970 PyObject *resultobj = 0;
8971 char *arg1 = (
char *) 0 ;
8975 char *arg5 = (
char *) 0 ;
8988 PyObject * obj0 = 0 ;
8989 PyObject * obj1 = 0 ;
8990 PyObject * obj2 = 0 ;
8991 PyObject * obj3 = 0 ;
8992 PyObject * obj4 = 0 ;
8994 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8999 arg1 = (
char *)(buf1);
9004 arg2 = (
PLFLT)(val2);
9009 arg3 = (
PLFLT)(val3);
9014 arg4 = (
PLFLT)(val4);
9019 arg5 = (
char *)(buf5);
9020 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
9033 PyObject *resultobj = 0;
9034 char *arg1 = (
char *) 0 ;
9038 char *arg5 = (
char *) 0 ;
9051 PyObject * obj0 = 0 ;
9052 PyObject * obj1 = 0 ;
9053 PyObject * obj2 = 0 ;
9054 PyObject * obj3 = 0 ;
9055 PyObject * obj4 = 0 ;
9057 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9062 arg1 = (
char *)(buf1);
9067 arg2 = (
PLFLT)(val2);
9072 arg3 = (
PLFLT)(val3);
9077 arg4 = (
PLFLT)(val4);
9082 arg5 = (
char *)(buf5);
9083 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
9096 PyObject *resultobj = 0;
9097 PLFLT *arg1 = (PLFLT *) 0 ;
9098 PLFLT *arg2 = (PLFLT *) 0 ;
9099 PLFLT **arg3 = (PLFLT **) 0 ;
9104 PyArrayObject *tmp1 = NULL ;
9105 PyArrayObject *tmp2 = NULL ;
9106 PyArrayObject *tmp3 = NULL ;
9111 PyObject * obj0 = 0 ;
9112 PyObject * obj1 = 0 ;
9113 PyObject * obj2 = 0 ;
9114 PyObject * obj3 = 0 ;
9115 PyObject * obj4 = 0 ;
9117 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9122 Xlen = PyArray_DIMS( tmp1 )[0];
9123 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9129 Ylen = PyArray_DIMS( tmp2 )[0];
9130 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9137 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9139 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9142 arg4 = PyArray_DIMS( tmp3 )[0];
9143 arg5 = PyArray_DIMS( tmp3 )[1];
9145 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9146 for ( i = 0; i < arg4; i++ )
9147 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9153 arg6 = (
PLINT)(val6);
9159 plot3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,arg7);
9188 PyObject *resultobj = 0;
9189 PLFLT *arg1 = (PLFLT *) 0 ;
9190 PLFLT *arg2 = (PLFLT *) 0 ;
9191 PLFLT **arg3 = (PLFLT **) 0 ;
9195 PLFLT *arg7 = (PLFLT *) 0 ;
9197 PyArrayObject *tmp1 = NULL ;
9198 PyArrayObject *tmp2 = NULL ;
9199 PyArrayObject *tmp3 = NULL ;
9202 PyArrayObject *tmp7 = NULL ;
9203 PyObject * obj0 = 0 ;
9204 PyObject * obj1 = 0 ;
9205 PyObject * obj2 = 0 ;
9206 PyObject * obj3 = 0 ;
9207 PyObject * obj4 = 0 ;
9209 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9214 Xlen = PyArray_DIMS( tmp1 )[0];
9215 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9221 Ylen = PyArray_DIMS( tmp2 )[0];
9222 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9229 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9231 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9234 arg4 = PyArray_DIMS( tmp3 )[0];
9235 arg5 = PyArray_DIMS( tmp3 )[1];
9237 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9238 for ( i = 0; i < arg4; i++ )
9239 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9245 arg6 = (
PLINT)(val6);
9250 arg8 = PyArray_DIMS( tmp7 )[0];
9251 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9253 plot3dc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9288 PyObject *resultobj = 0;
9289 PLFLT *arg1 = (PLFLT *) 0 ;
9290 PLFLT *arg2 = (PLFLT *) 0 ;
9291 PLFLT **arg3 = (PLFLT **) 0 ;
9295 PLFLT *arg7 = (PLFLT *) 0 ;
9299 PLINT *arg11 = (PLINT *) 0 ;
9300 PLINT *arg12 = (PLINT *) 0 ;
9301 PyArrayObject *tmp1 = NULL ;
9302 PyArrayObject *tmp2 = NULL ;
9303 PyArrayObject *tmp3 = NULL ;
9306 PyArrayObject *tmp7 = NULL ;
9309 PyArrayObject *tmp10 = NULL ;
9310 PyArrayObject *tmp12 = NULL ;
9311 PyObject * obj0 = 0 ;
9312 PyObject * obj1 = 0 ;
9313 PyObject * obj2 = 0 ;
9314 PyObject * obj3 = 0 ;
9315 PyObject * obj4 = 0 ;
9316 PyObject * obj5 = 0 ;
9317 PyObject * obj6 = 0 ;
9318 PyObject * obj7 = 0 ;
9320 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9325 Xlen = PyArray_DIMS( tmp1 )[0];
9326 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9332 Ylen = PyArray_DIMS( tmp2 )[0];
9333 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9340 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9342 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9345 arg4 = PyArray_DIMS( tmp3 )[0];
9346 arg5 = PyArray_DIMS( tmp3 )[1];
9348 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9349 for ( i = 0; i < arg4; i++ )
9350 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9356 arg6 = (
PLINT)(val6);
9361 arg8 = PyArray_DIMS( tmp7 )[0];
9362 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9368 arg9 = (
PLINT)(val9);
9371 if ( tmp10 == NULL )
9373 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9374 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9378 if ( tmp12 == NULL )
9380 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9382 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9385 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9387 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);
9434 PyObject *resultobj = 0;
9435 PLFLT *arg1 = (PLFLT *) 0 ;
9436 PLFLT *arg2 = (PLFLT *) 0 ;
9437 PLFLT **arg3 = (PLFLT **) 0 ;
9441 PLFLT *arg7 = (PLFLT *) 0 ;
9443 PyArrayObject *tmp1 = NULL ;
9444 PyArrayObject *tmp2 = NULL ;
9445 PyArrayObject *tmp3 = NULL ;
9448 PyArrayObject *tmp7 = NULL ;
9449 PyObject * obj0 = 0 ;
9450 PyObject * obj1 = 0 ;
9451 PyObject * obj2 = 0 ;
9452 PyObject * obj3 = 0 ;
9453 PyObject * obj4 = 0 ;
9455 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9460 Xlen = PyArray_DIMS( tmp1 )[0];
9461 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9467 Ylen = PyArray_DIMS( tmp2 )[0];
9468 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9475 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9477 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9480 arg4 = PyArray_DIMS( tmp3 )[0];
9481 arg5 = PyArray_DIMS( tmp3 )[1];
9483 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9484 for ( i = 0; i < arg4; i++ )
9485 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9491 arg6 = (
PLINT)(val6);
9496 arg8 = PyArray_DIMS( tmp7 )[0];
9497 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9499 plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9534 PyObject *resultobj = 0;
9535 PLFLT *arg1 = (PLFLT *) 0 ;
9536 PLFLT *arg2 = (PLFLT *) 0 ;
9537 PLFLT **arg3 = (PLFLT **) 0 ;
9541 PLFLT *arg7 = (PLFLT *) 0 ;
9545 PLINT *arg11 = (PLINT *) 0 ;
9546 PLINT *arg12 = (PLINT *) 0 ;
9547 PyArrayObject *tmp1 = NULL ;
9548 PyArrayObject *tmp2 = NULL ;
9549 PyArrayObject *tmp3 = NULL ;
9552 PyArrayObject *tmp7 = NULL ;
9555 PyArrayObject *tmp10 = NULL ;
9556 PyArrayObject *tmp12 = NULL ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 PyObject * obj3 = 0 ;
9561 PyObject * obj4 = 0 ;
9562 PyObject * obj5 = 0 ;
9563 PyObject * obj6 = 0 ;
9564 PyObject * obj7 = 0 ;
9566 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9571 Xlen = PyArray_DIMS( tmp1 )[0];
9572 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9578 Ylen = PyArray_DIMS( tmp2 )[0];
9579 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9586 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9588 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9591 arg4 = PyArray_DIMS( tmp3 )[0];
9592 arg5 = PyArray_DIMS( tmp3 )[1];
9594 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9595 for ( i = 0; i < arg4; i++ )
9596 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9602 arg6 = (
PLINT)(val6);
9607 arg8 = PyArray_DIMS( tmp7 )[0];
9608 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9614 arg9 = (
PLINT)(val9);
9617 if ( tmp10 == NULL )
9619 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9620 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9624 if ( tmp12 == NULL )
9626 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9628 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9631 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9633 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);
9680 PyObject *resultobj = 0;
9681 int *arg1 = (
int *) 0 ;
9682 char **arg2 = (
char **) 0 ;
9687 PyObject * obj0 = 0 ;
9688 PyObject * obj1 = 0 ;
9691 if (!PyArg_ParseTuple(args,(
char *)
"OO:plparseopts",&obj0,&obj1))
SWIG_fail;
9694 if ( !PyList_Check( obj0 ) )
9696 PyErr_SetString( PyExc_ValueError,
"Expecting a list" );
9699 tmp1 = PyList_Size( obj0 );
9701 arg2 = (
char **) malloc( (
size_t) ( tmp1 + 1 ) *
sizeof (
char * ) );
9702 for ( i = 0; i < tmp1; i++ )
9704 PyObject *s = PyList_GetItem( obj0, i );
9705 if ( !PyString_Check( s ) )
9708 PyErr_SetString( PyExc_ValueError,
"List items must be strings" );
9711 arg2[i] = PyString_AsString( s );
9719 arg3 = (
PLINT)(val3);
9737 PyObject *resultobj = 0;
9739 PLINT *arg2 = (PLINT *) 0 ;
9740 PLINT *arg3 = (PLINT *) 0 ;
9741 PyArrayObject *tmp1 = NULL ;
9742 PyArrayObject *tmp3 = NULL ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9746 if (!PyArg_ParseTuple(args,(
char *)
"OO:plpat",&obj0,&obj1))
SWIG_fail;
9751 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9752 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9758 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9760 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9763 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9765 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
9786 PyObject *resultobj = 0;
9802 PyObject * obj0 = 0 ;
9803 PyObject * obj1 = 0 ;
9804 PyObject * obj2 = 0 ;
9805 PyObject * obj3 = 0 ;
9806 PyObject * obj4 = 0 ;
9808 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9813 arg1 = (
PLINT)(val1);
9818 arg2 = (
PLFLT)(val2);
9823 arg3 = (
PLFLT)(val3);
9828 arg4 = (
PLFLT)(val4);
9833 arg5 = (
PLFLT)(val5);
9834 plpath(arg1,arg2,arg3,arg4,arg5);
9843 PyObject *resultobj = 0;
9845 PLFLT *arg2 = (PLFLT *) 0 ;
9846 PLFLT *arg3 = (PLFLT *) 0 ;
9848 PyArrayObject *tmp1 = NULL ;
9849 PyArrayObject *tmp3 = NULL ;
9852 PyObject * obj0 = 0 ;
9853 PyObject * obj1 = 0 ;
9854 PyObject * obj2 = 0 ;
9856 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plpoin",&obj0,&obj1,&obj2))
SWIG_fail;
9861 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9862 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9868 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9870 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9873 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9879 arg4 = (
PLINT)(val4);
9880 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
9901 PyObject *resultobj = 0;
9903 PLFLT *arg2 = (PLFLT *) 0 ;
9904 PLFLT *arg3 = (PLFLT *) 0 ;
9905 PLFLT *arg4 = (PLFLT *) 0 ;
9907 PyArrayObject *tmp1 = NULL ;
9908 PyArrayObject *tmp3 = NULL ;
9909 PyArrayObject *tmp4 = NULL ;
9912 PyObject * obj0 = 0 ;
9913 PyObject * obj1 = 0 ;
9914 PyObject * obj2 = 0 ;
9915 PyObject * obj3 = 0 ;
9917 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
9922 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9923 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9929 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9931 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9934 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9940 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
9942 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9945 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9951 arg5 = (
PLINT)(val5);
9952 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
9979 PyObject *resultobj = 0;
9981 PLFLT *arg2 = (PLFLT *) 0 ;
9982 PLFLT *arg3 = (PLFLT *) 0 ;
9983 PLFLT *arg4 = (PLFLT *) 0 ;
9986 PyArrayObject *tmp1 = NULL ;
9987 PyArrayObject *tmp3 = NULL ;
9988 PyArrayObject *tmp4 = NULL ;
9989 PyArrayObject *tmp5 = NULL ;
9992 PyObject * obj0 = 0 ;
9993 PyObject * obj1 = 0 ;
9994 PyObject * obj2 = 0 ;
9995 PyObject * obj3 = 0 ;
9996 PyObject * obj4 = 0 ;
9998 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
10001 if ( tmp1 == NULL )
10003 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10004 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10008 if ( tmp3 == NULL )
10010 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10012 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10015 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10019 if ( tmp4 == NULL )
10021 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10023 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10026 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10030 if ( tmp5 == NULL )
10032 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10034 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10037 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10044 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
10077 PyObject *resultobj = 0;
10084 PyObject * obj0 = 0 ;
10085 PyObject * obj1 = 0 ;
10087 if (!PyArg_ParseTuple(args,(
char *)
"OO:plprec",&obj0,&obj1))
SWIG_fail;
10092 arg1 = (
PLINT)(val1);
10097 arg2 = (
PLINT)(val2);
10107 PyObject *resultobj = 0;
10111 PyObject * obj0 = 0 ;
10113 if (!PyArg_ParseTuple(args,(
char *)
"O:plpsty",&obj0))
SWIG_fail;
10118 arg1 = (
PLINT)(val1);
10128 PyObject *resultobj = 0;
10134 char *arg6 = (
char *) 0 ;
10148 PyObject * obj0 = 0 ;
10149 PyObject * obj1 = 0 ;
10150 PyObject * obj2 = 0 ;
10151 PyObject * obj3 = 0 ;
10152 PyObject * obj4 = 0 ;
10153 PyObject * obj5 = 0 ;
10155 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10160 arg1 = (
PLFLT)(val1);
10165 arg2 = (
PLFLT)(val2);
10170 arg3 = (
PLFLT)(val3);
10175 arg4 = (
PLFLT)(val4);
10180 arg5 = (
PLFLT)(val5);
10185 arg6 = (
char *)(buf6);
10186 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
10197 PyObject *resultobj = 0;
10208 char *arg11 = (
char *) 0 ;
10232 PyObject * obj0 = 0 ;
10233 PyObject * obj1 = 0 ;
10234 PyObject * obj2 = 0 ;
10235 PyObject * obj3 = 0 ;
10236 PyObject * obj4 = 0 ;
10237 PyObject * obj5 = 0 ;
10238 PyObject * obj6 = 0 ;
10239 PyObject * obj7 = 0 ;
10240 PyObject * obj8 = 0 ;
10241 PyObject * obj9 = 0 ;
10242 PyObject * obj10 = 0 ;
10244 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
10249 arg1 = (
PLFLT)(val1);
10254 arg2 = (
PLFLT)(val2);
10259 arg3 = (
PLFLT)(val3);
10264 arg4 = (
PLFLT)(val4);
10269 arg5 = (
PLFLT)(val5);
10274 arg6 = (
PLFLT)(val6);
10279 arg7 = (
PLFLT)(val7);
10284 arg8 = (
PLFLT)(val8);
10289 arg9 = (
PLFLT)(val9);
10294 arg10 = (
PLFLT)(val10);
10299 arg11 = (
char *)(buf11);
10300 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
10311 PyObject *resultobj = 0;
10314 if (!PyArg_ParseTuple(args,(
char *)
":plrandd"))
SWIG_fail;
10324 PyObject *resultobj = 0;
10326 if (!PyArg_ParseTuple(args,(
char *)
":plreplot"))
SWIG_fail;
10336 PyObject *resultobj = 0;
10340 PLFLT *arg4 = (PLFLT *) 0 ;
10341 PLFLT *arg5 = (PLFLT *) 0 ;
10342 PLFLT *arg6 = (PLFLT *) 0 ;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 PyObject * obj2 = 0 ;
10362 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plrgbhls",&obj0,&obj1,&obj2))
SWIG_fail;
10367 arg1 = (
PLFLT)(val1);
10372 arg2 = (
PLFLT)(val2);
10377 arg3 = (
PLFLT)(val3);
10378 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10405 PyObject *resultobj = 0;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10415 if (!PyArg_ParseTuple(args,(
char *)
"OO:plschr",&obj0,&obj1))
SWIG_fail;
10420 arg1 = (
PLFLT)(val1);
10425 arg2 = (
PLFLT)(val2);
10435 PyObject *resultobj = 0;
10436 PLINT *arg1 = (PLINT *) 0 ;
10437 PLINT *arg2 = (PLINT *) 0 ;
10438 PLINT *arg3 = (PLINT *) 0 ;
10440 PyArrayObject *tmp1 = NULL ;
10441 PyArrayObject *tmp2 = NULL ;
10442 PyArrayObject *tmp3 = NULL ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445 PyObject * obj2 = 0 ;
10447 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap0",&obj0,&obj1,&obj2))
SWIG_fail;
10450 if ( tmp1 == NULL )
10452 Alen = PyArray_DIMS( tmp1 )[0];
10453 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10457 if ( tmp2 == NULL )
10459 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10461 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10464 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10468 if ( tmp3 == NULL )
10470 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10472 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10475 arg4 = PyArray_DIMS( tmp3 )[0];
10476 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10478 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10505 PyObject *resultobj = 0;
10506 PLINT *arg1 = (PLINT *) 0 ;
10507 PLINT *arg2 = (PLINT *) 0 ;
10508 PLINT *arg3 = (PLINT *) 0 ;
10509 PLFLT *arg4 = (PLFLT *) 0 ;
10511 PyArrayObject *tmp1 = NULL ;
10512 PyArrayObject *tmp2 = NULL ;
10513 PyArrayObject *tmp3 = NULL ;
10514 PyArrayObject *tmp4 = NULL ;
10515 PyObject * obj0 = 0 ;
10516 PyObject * obj1 = 0 ;
10517 PyObject * obj2 = 0 ;
10518 PyObject * obj3 = 0 ;
10520 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10523 if ( tmp1 == NULL )
10525 Alen = PyArray_DIMS( tmp1 )[0];
10526 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10530 if ( tmp2 == NULL )
10532 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10534 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10537 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10541 if ( tmp3 == NULL )
10543 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10545 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10548 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10552 if ( tmp4 == NULL )
10554 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10556 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10559 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10560 arg5 = PyArray_DIMS( tmp4 )[0];
10562 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10595 PyObject *resultobj = 0;
10599 PyObject * obj0 = 0 ;
10601 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap0n",&obj0))
SWIG_fail;
10606 arg1 = (
PLINT)(val1);
10616 PyObject *resultobj = 0;
10617 PLINT *arg1 = (PLINT *) 0 ;
10618 PLINT *arg2 = (PLINT *) 0 ;
10619 PLINT *arg3 = (PLINT *) 0 ;
10621 PyArrayObject *tmp1 = NULL ;
10622 PyArrayObject *tmp2 = NULL ;
10623 PyArrayObject *tmp3 = NULL ;
10624 PyObject * obj0 = 0 ;
10625 PyObject * obj1 = 0 ;
10626 PyObject * obj2 = 0 ;
10628 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap1",&obj0,&obj1,&obj2))
SWIG_fail;
10631 if ( tmp1 == NULL )
10633 Alen = PyArray_DIMS( tmp1 )[0];
10634 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10638 if ( tmp2 == NULL )
10640 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10642 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10645 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10649 if ( tmp3 == NULL )
10651 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10653 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10656 arg4 = PyArray_DIMS( tmp3 )[0];
10657 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10659 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10686 PyObject *resultobj = 0;
10687 PLINT *arg1 = (PLINT *) 0 ;
10688 PLINT *arg2 = (PLINT *) 0 ;
10689 PLINT *arg3 = (PLINT *) 0 ;
10690 PLFLT *arg4 = (PLFLT *) 0 ;
10692 PyArrayObject *tmp1 = NULL ;
10693 PyArrayObject *tmp2 = NULL ;
10694 PyArrayObject *tmp3 = NULL ;
10695 PyArrayObject *tmp4 = NULL ;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 PyObject * obj2 = 0 ;
10699 PyObject * obj3 = 0 ;
10701 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10704 if ( tmp1 == NULL )
10706 Alen = PyArray_DIMS( tmp1 )[0];
10707 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10711 if ( tmp2 == NULL )
10713 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10715 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10718 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10722 if ( tmp3 == NULL )
10724 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10726 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10729 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10733 if ( tmp4 == NULL )
10735 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10737 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10740 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10741 arg5 = PyArray_DIMS( tmp4 )[0];
10743 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10776 PyObject *resultobj = 0;
10779 PLFLT *arg3 = (PLFLT *) 0 ;
10780 PLFLT *arg4 = (PLFLT *) 0 ;
10781 PLFLT *arg5 = (PLFLT *) 0 ;
10782 PLFLT *arg6 = (PLFLT *) 0 ;
10786 PyArrayObject *tmp2 = NULL ;
10787 PyArrayObject *tmp4 = NULL ;
10788 PyArrayObject *tmp5 = NULL ;
10789 PyArrayObject *tmp6 = NULL ;
10790 PyArrayObject *tmp7 = NULL ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 PyObject * obj2 = 0 ;
10794 PyObject * obj3 = 0 ;
10795 PyObject * obj4 = 0 ;
10796 PyObject * obj5 = 0 ;
10798 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10806 if ( tmp2 == NULL )
10808 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10809 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10813 if ( tmp4 == NULL )
10815 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10817 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10820 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10824 if ( tmp5 == NULL )
10826 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10828 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10831 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10835 if ( tmp6 == NULL )
10837 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10839 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10842 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10846 if ( tmp7 == NULL )
10848 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10850 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10853 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10855 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
10894 PyObject *resultobj = 0;
10897 PLFLT *arg3 = (PLFLT *) 0 ;
10898 PLFLT *arg4 = (PLFLT *) 0 ;
10899 PLFLT *arg5 = (PLFLT *) 0 ;
10900 PLFLT *arg6 = (PLFLT *) 0 ;
10901 PLFLT *arg7 = (PLFLT *) 0 ;
10905 PyArrayObject *tmp2 = NULL ;
10906 PyArrayObject *tmp4 = NULL ;
10907 PyArrayObject *tmp5 = NULL ;
10908 PyArrayObject *tmp6 = NULL ;
10909 PyArrayObject *tmp7 = NULL ;
10910 PyArrayObject *tmp8 = NULL ;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 PyObject * obj2 = 0 ;
10914 PyObject * obj3 = 0 ;
10915 PyObject * obj4 = 0 ;
10916 PyObject * obj5 = 0 ;
10917 PyObject * obj6 = 0 ;
10919 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
10927 if ( tmp2 == NULL )
10929 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10930 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10934 if ( tmp4 == NULL )
10936 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10938 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10941 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10945 if ( tmp5 == NULL )
10947 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10949 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10952 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10956 if ( tmp6 == NULL )
10958 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10960 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10963 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10967 if ( tmp7 == NULL )
10969 if ( PyArray_DIMS( tmp7 )[0] !=
Alen )
10971 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10974 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10978 if ( tmp8 == NULL )
10980 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10982 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10985 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10987 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
11032 PyObject *resultobj = 0;
11036 PyObject * obj0 = 0 ;
11038 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap1n",&obj0))
SWIG_fail;
11043 arg1 = (
PLINT)(val1);
11053 PyObject *resultobj = 0;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11063 if (!PyArg_ParseTuple(args,(
char *)
"OO:plscmap1_range",&obj0,&obj1))
SWIG_fail;
11068 arg1 = (
PLFLT)(val1);
11073 arg2 = (
PLFLT)(val2);
11083 PyObject *resultobj = 0;
11084 PLFLT *arg1 = (PLFLT *) 0 ;
11085 PLFLT *arg2 = (PLFLT *) 0 ;
11093 if (!PyArg_ParseTuple(args,(
char *)
":plgcmap1_range"))
SWIG_fail;
11115 PyObject *resultobj = 0;
11128 PyObject * obj0 = 0 ;
11129 PyObject * obj1 = 0 ;
11130 PyObject * obj2 = 0 ;
11131 PyObject * obj3 = 0 ;
11133 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11138 arg1 = (
PLINT)(val1);
11143 arg2 = (
PLINT)(val2);
11148 arg3 = (
PLINT)(val3);
11153 arg4 = (
PLINT)(val4);
11154 plscol0(arg1,arg2,arg3,arg4);
11163 PyObject *resultobj = 0;
11179 PyObject * obj0 = 0 ;
11180 PyObject * obj1 = 0 ;
11181 PyObject * obj2 = 0 ;
11182 PyObject * obj3 = 0 ;
11183 PyObject * obj4 = 0 ;
11185 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
11190 arg1 = (
PLINT)(val1);
11195 arg2 = (
PLINT)(val2);
11200 arg3 = (
PLINT)(val3);
11205 arg4 = (
PLINT)(val4);
11210 arg5 = (
PLFLT)(val5);
11211 plscol0a(arg1,arg2,arg3,arg4,arg5);
11220 PyObject *resultobj = 0;
11230 PyObject * obj0 = 0 ;
11231 PyObject * obj1 = 0 ;
11232 PyObject * obj2 = 0 ;
11234 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscolbg",&obj0,&obj1,&obj2))
SWIG_fail;
11239 arg1 = (
PLINT)(val1);
11244 arg2 = (
PLINT)(val2);
11249 arg3 = (
PLINT)(val3);
11259 PyObject *resultobj = 0;
11272 PyObject * obj0 = 0 ;
11273 PyObject * obj1 = 0 ;
11274 PyObject * obj2 = 0 ;
11275 PyObject * obj3 = 0 ;
11277 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11282 arg1 = (
PLINT)(val1);
11287 arg2 = (
PLINT)(val2);
11292 arg3 = (
PLINT)(val3);
11297 arg4 = (
PLFLT)(val4);
11307 PyObject *resultobj = 0;
11311 PyObject * obj0 = 0 ;
11313 if (!PyArg_ParseTuple(args,(
char *)
"O:plscolor",&obj0))
SWIG_fail;
11318 arg1 = (
PLINT)(val1);
11328 PyObject *resultobj = 0;
11332 PyObject * obj0 = 0 ;
11334 if (!PyArg_ParseTuple(args,(
char *)
"O:plscompression",&obj0))
SWIG_fail;
11339 arg1 = (
PLINT)(val1);
11349 PyObject *resultobj = 0;
11350 char *arg1 = (
char *) 0 ;
11354 PyObject * obj0 = 0 ;
11356 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdev",&obj0))
SWIG_fail;
11361 arg1 = (
char *)(buf1);
11362 plsdev((
char const *)arg1);
11373 PyObject *resultobj = 0;
11386 PyObject * obj0 = 0 ;
11387 PyObject * obj1 = 0 ;
11388 PyObject * obj2 = 0 ;
11389 PyObject * obj3 = 0 ;
11391 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11396 arg1 = (
PLFLT)(val1);
11401 arg2 = (
PLFLT)(val2);
11406 arg3 = (
PLFLT)(val3);
11411 arg4 = (
PLFLT)(val4);
11421 PyObject *resultobj = 0;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 PyObject * obj2 = 0 ;
11443 PyObject * obj3 = 0 ;
11444 PyObject * obj4 = 0 ;
11445 PyObject * obj5 = 0 ;
11447 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
11452 arg1 = (
PLINT)(val1);
11457 arg2 = (
PLINT)(val2);
11462 arg3 = (
PLINT)(val3);
11467 arg4 = (
PLINT)(val4);
11472 arg5 = (
PLFLT)(val5);
11477 arg6 = (
PLFLT)(val6);
11478 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11487 PyObject *resultobj = 0;
11491 PyObject * obj0 = 0 ;
11493 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdiori",&obj0))
SWIG_fail;
11498 arg1 = (
PLFLT)(val1);
11508 PyObject *resultobj = 0;
11521 PyObject * obj0 = 0 ;
11522 PyObject * obj1 = 0 ;
11523 PyObject * obj2 = 0 ;
11524 PyObject * obj3 = 0 ;
11526 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11531 arg1 = (
PLFLT)(val1);
11536 arg2 = (
PLFLT)(val2);
11541 arg3 = (
PLFLT)(val3);
11546 arg4 = (
PLFLT)(val4);
11556 PyObject *resultobj = 0;
11569 PyObject * obj0 = 0 ;
11570 PyObject * obj1 = 0 ;
11571 PyObject * obj2 = 0 ;
11572 PyObject * obj3 = 0 ;
11574 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11579 arg1 = (
PLFLT)(val1);
11584 arg2 = (
PLFLT)(val2);
11589 arg3 = (
PLFLT)(val3);
11594 arg4 = (
PLFLT)(val4);
11604 PyObject *resultobj = 0;
11605 unsigned int arg1 ;
11606 unsigned int val1 ;
11608 PyObject * obj0 = 0 ;
11610 if (!PyArg_ParseTuple(args,(
char *)
"O:plseed",&obj0))
SWIG_fail;
11615 arg1 = (
unsigned int)(val1);
11625 PyObject *resultobj = 0;
11629 PyObject * obj0 = 0 ;
11631 if (!PyArg_ParseTuple(args,(
char *)
"O:plsesc",&obj0))
SWIG_fail;
11636 arg1 = (char)(val1);
11646 PyObject *resultobj = 0;
11647 char *arg1 = (
char *) 0 ;
11648 char *arg2 = (
char *) 0 ;
11655 PyObject * obj0 = 0 ;
11656 PyObject * obj1 = 0 ;
11659 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsetopt",&obj0,&obj1))
SWIG_fail;
11664 arg1 = (
char *)(buf1);
11669 arg2 = (
char *)(buf2);
11670 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
11683 PyObject *resultobj = 0;
11693 PyObject * obj0 = 0 ;
11694 PyObject * obj1 = 0 ;
11695 PyObject * obj2 = 0 ;
11697 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfam",&obj0,&obj1,&obj2))
SWIG_fail;
11702 arg1 = (
PLINT)(val1);
11707 arg2 = (
PLINT)(val2);
11712 arg3 = (
PLINT)(val3);
11722 PyObject *resultobj = 0;
11724 unsigned int val1 ;
11726 PyObject * obj0 = 0 ;
11728 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfci",&obj0))
SWIG_fail;
11743 PyObject *resultobj = 0;
11744 char *arg1 = (
char *) 0 ;
11748 PyObject * obj0 = 0 ;
11750 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfnam",&obj0))
SWIG_fail;
11755 arg1 = (
char *)(buf1);
11767 PyObject *resultobj = 0;
11777 PyObject * obj0 = 0 ;
11778 PyObject * obj1 = 0 ;
11779 PyObject * obj2 = 0 ;
11781 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfont",&obj0,&obj1,&obj2))
SWIG_fail;
11786 arg1 = (
PLINT)(val1);
11791 arg2 = (
PLINT)(val2);
11796 arg3 = (
PLINT)(val3);
11806 PyObject *resultobj = 0;
11807 PLFLT **arg1 = (PLFLT **) 0 ;
11815 PLFLT *arg9 = (PLFLT *) 0 ;
11824 PyArrayObject *tmp1 = NULL ;
11833 PyArrayObject *tmp9 = NULL ;
11842 PyObject * obj0 = 0 ;
11843 PyObject * obj1 = 0 ;
11844 PyObject * obj2 = 0 ;
11845 PyObject * obj3 = 0 ;
11846 PyObject * obj4 = 0 ;
11847 PyObject * obj5 = 0 ;
11848 PyObject * obj6 = 0 ;
11849 PyObject * obj7 = 0 ;
11850 PyObject * obj8 = 0 ;
11851 PyObject * obj9 = 0 ;
11852 PyObject * obj10 = 0 ;
11853 PyObject * obj11 = 0 ;
11868 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
11872 if ( tmp1 == NULL )
11874 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11875 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11877 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
11878 for ( i = 0; i < arg2; i++ )
11879 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11885 arg5 = (
PLFLT)(val5);
11890 arg6 = (
PLFLT)(val6);
11895 arg7 = (
PLFLT)(val7);
11900 arg8 = (
PLFLT)(val8);
11903 if ( tmp9 == NULL )
11905 arg10 = PyArray_DIMS( tmp9 )[0];
11906 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11912 arg11 = (
PLFLT)(val11);
11917 arg12 = (
PLINT)(val12);
11922 arg13 = (
PLFLT)(val13);
11927 arg15 = (
PLBOOL)(val15);
11931 if ( obj10 == Py_None )
11937 if ( !PyCallable_Check( (PyObject *) obj10 ) )
11939 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
11948 if ( obj11 == Py_None )
11956 plshades((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(
double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11991 PyObject *resultobj = 0;
11992 PLFLT **arg1 = (PLFLT **) 0 ;
12013 PyArrayObject *tmp1 = NULL ;
12042 PyObject * obj0 = 0 ;
12043 PyObject * obj1 = 0 ;
12044 PyObject * obj2 = 0 ;
12045 PyObject * obj3 = 0 ;
12046 PyObject * obj4 = 0 ;
12047 PyObject * obj5 = 0 ;
12048 PyObject * obj6 = 0 ;
12049 PyObject * obj7 = 0 ;
12050 PyObject * obj8 = 0 ;
12051 PyObject * obj9 = 0 ;
12052 PyObject * obj10 = 0 ;
12053 PyObject * obj11 = 0 ;
12054 PyObject * obj12 = 0 ;
12055 PyObject * obj13 = 0 ;
12056 PyObject * obj14 = 0 ;
12057 PyObject * obj15 = 0 ;
12058 PyObject * obj16 = 0 ;
12073 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;
12077 if ( tmp1 == NULL )
12079 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12080 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12082 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
12083 for ( i = 0; i < arg2; i++ )
12084 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12090 arg5 = (
PLFLT)(val5);
12095 arg6 = (
PLFLT)(val6);
12100 arg7 = (
PLFLT)(val7);
12105 arg8 = (
PLFLT)(val8);
12110 arg9 = (
PLFLT)(val9);
12115 arg10 = (
PLFLT)(val10);
12120 arg11 = (
PLINT)(val11);
12125 arg12 = (
PLFLT)(val12);
12130 arg13 = (
PLFLT)(val13);
12135 arg14 = (
PLINT)(val14);
12140 arg15 = (
PLFLT)(val15);
12145 arg16 = (
PLINT)(val16);
12150 arg17 = (
PLFLT)(val17);
12155 arg19 = (
PLBOOL)(val19);
12159 if ( obj15 == Py_None )
12165 if ( !PyCallable_Check( (PyObject *) obj15 ) )
12167 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
12176 if ( obj16 == Py_None )
12184 plshade((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12213 PyObject *resultobj = 0;
12217 PyObject * obj0 = 0 ;
12218 PyObject * obj1 = 0 ;
12220 if (!PyArg_ParseTuple(args,(
char *)
"OO:plslabelfunc",&obj0,&obj1))
SWIG_fail;
12223 if ( python_label )
12225 Py_CLEAR( python_label );
12229 if ( obj0 == Py_None )
12235 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12237 PyErr_SetString( PyExc_ValueError,
"label_func argument must be callable" );
12241 Py_XINCREF( (PyObject *) obj0 );
12242 python_label = (PyObject *) obj0;
12260 PyObject *resultobj = 0;
12267 PyObject * obj0 = 0 ;
12268 PyObject * obj1 = 0 ;
12270 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmaj",&obj0,&obj1))
SWIG_fail;
12275 arg1 = (
PLFLT)(val1);
12280 arg2 = (
PLFLT)(val2);
12290 PyObject *resultobj = 0;
12293 void *arg3 = (
void *) 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 PyObject * obj2 = 0 ;
12305 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmem",&obj0,&obj1,&obj2))
SWIG_fail;
12310 arg1 = (
PLINT)(val1);
12315 arg2 = (
PLINT)(val2);
12317 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12322 arg3 = (
void *) buf3;
12333 PyObject *resultobj = 0;
12336 void *arg3 = (
void *) 0 ;
12344 PyObject * obj0 = 0 ;
12345 PyObject * obj1 = 0 ;
12346 PyObject * obj2 = 0 ;
12348 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmema",&obj0,&obj1,&obj2))
SWIG_fail;
12353 arg1 = (
PLINT)(val1);
12358 arg2 = (
PLINT)(val2);
12360 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12365 arg3 = (
void *) buf3;
12376 PyObject *resultobj = 0;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12386 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmin",&obj0,&obj1))
SWIG_fail;
12391 arg1 = (
PLFLT)(val1);
12396 arg2 = (
PLFLT)(val2);
12406 PyObject *resultobj = 0;
12410 PyObject * obj0 = 0 ;
12412 if (!PyArg_ParseTuple(args,(
char *)
"O:plsori",&obj0))
SWIG_fail;
12417 arg1 = (
PLINT)(val1);
12427 PyObject *resultobj = 0;
12446 PyObject * obj0 = 0 ;
12447 PyObject * obj1 = 0 ;
12448 PyObject * obj2 = 0 ;
12449 PyObject * obj3 = 0 ;
12450 PyObject * obj4 = 0 ;
12451 PyObject * obj5 = 0 ;
12453 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
12458 arg1 = (
PLFLT)(val1);
12463 arg2 = (
PLFLT)(val2);
12468 arg3 = (
PLINT)(val3);
12473 arg4 = (
PLINT)(val4);
12478 arg5 = (
PLINT)(val5);
12483 arg6 = (
PLINT)(val6);
12484 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12493 PyObject *resultobj = 0;
12494 char *arg1 = (
char *) 0 ;
12498 PyObject * obj0 = 0 ;
12500 if (!PyArg_ParseTuple(args,(
char *)
"O:plspal0",&obj0))
SWIG_fail;
12505 arg1 = (
char *)(buf1);
12517 PyObject *resultobj = 0;
12518 char *arg1 = (
char *) 0 ;
12525 PyObject * obj0 = 0 ;
12526 PyObject * obj1 = 0 ;
12528 if (!PyArg_ParseTuple(args,(
char *)
"OO:plspal1",&obj0,&obj1))
SWIG_fail;
12533 arg1 = (
char *)(buf1);
12539 plspal1((
char const *)arg1,arg2);
12550 PyObject *resultobj = 0;
12554 PyObject * obj0 = 0 ;
12556 if (!PyArg_ParseTuple(args,(
char *)
"O:plspause",&obj0))
SWIG_fail;
12571 PyObject *resultobj = 0;
12575 PyObject * obj0 = 0 ;
12577 if (!PyArg_ParseTuple(args,(
char *)
"O:plsstrm",&obj0))
SWIG_fail;
12582 arg1 = (
PLINT)(val1);
12592 PyObject *resultobj = 0;
12599 PyObject * obj0 = 0 ;
12600 PyObject * obj1 = 0 ;
12602 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssub",&obj0,&obj1))
SWIG_fail;
12607 arg1 = (
PLINT)(val1);
12612 arg2 = (
PLINT)(val2);
12622 PyObject *resultobj = 0;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12632 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssym",&obj0,&obj1))
SWIG_fail;
12637 arg1 = (
PLFLT)(val1);
12642 arg2 = (
PLFLT)(val2);
12652 PyObject *resultobj = 0;
12659 PyObject * obj0 = 0 ;
12660 PyObject * obj1 = 0 ;
12662 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstar",&obj0,&obj1))
SWIG_fail;
12667 arg1 = (
PLINT)(val1);
12672 arg2 = (
PLINT)(val2);
12682 PyObject *resultobj = 0;
12683 char *arg1 = (
char *) 0 ;
12693 PyObject * obj0 = 0 ;
12694 PyObject * obj1 = 0 ;
12695 PyObject * obj2 = 0 ;
12697 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstart",&obj0,&obj1,&obj2))
SWIG_fail;
12702 arg1 = (
char *)(buf1);
12707 arg2 = (
PLINT)(val2);
12712 arg3 = (
PLINT)(val3);
12713 plstart((
char const *)arg1,arg2,arg3);
12724 PyObject *resultobj = 0;
12728 PyObject * obj0 = 0 ;
12729 PyObject * obj1 = 0 ;
12735 if (!PyArg_ParseTuple(args,(
char *)
"|OO:plstransform",&obj0,&obj1))
SWIG_fail;
12741 if ( obj0 == Py_None )
12747 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12749 PyErr_SetString( PyExc_ValueError,
"coordinate transform argument must be callable" );
12771 PyObject *resultobj = 0;
12773 PLFLT *arg2 = (PLFLT *) 0 ;
12774 PLFLT *arg3 = (PLFLT *) 0 ;
12775 char *arg4 = (
char *) 0 ;
12776 PyArrayObject *tmp1 = NULL ;
12777 PyArrayObject *tmp3 = NULL ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 PyObject * obj2 = 0 ;
12785 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstring",&obj0,&obj1,&obj2))
SWIG_fail;
12788 if ( tmp1 == NULL )
12790 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12791 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12795 if ( tmp3 == NULL )
12797 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12799 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12802 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12808 arg4 = (
char *)(buf4);
12809 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
12832 PyObject *resultobj = 0;
12834 PLFLT *arg2 = (PLFLT *) 0 ;
12835 PLFLT *arg3 = (PLFLT *) 0 ;
12836 PLFLT *arg4 = (PLFLT *) 0 ;
12837 char *arg5 = (
char *) 0 ;
12838 PyArrayObject *tmp1 = NULL ;
12839 PyArrayObject *tmp3 = NULL ;
12840 PyArrayObject *tmp4 = NULL ;
12844 PyObject * obj0 = 0 ;
12845 PyObject * obj1 = 0 ;
12846 PyObject * obj2 = 0 ;
12847 PyObject * obj3 = 0 ;
12849 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12852 if ( tmp1 == NULL )
12854 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12855 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12859 if ( tmp3 == NULL )
12861 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12863 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12866 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12870 if ( tmp4 == NULL )
12872 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
12874 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12877 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12883 arg5 = (
char *)(buf5);
12884 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
12913 PyObject *resultobj = 0;
12926 PyObject * obj0 = 0 ;
12927 PyObject * obj1 = 0 ;
12928 PyObject * obj2 = 0 ;
12929 PyObject * obj3 = 0 ;
12931 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12936 arg1 = (
PLINT)(val1);
12941 arg2 = (
PLINT)(val2);
12946 arg3 = (
PLFLT)(val3);
12951 arg4 = (
PLFLT)(val4);
12961 PyObject *resultobj = 0;
12962 PLINT *arg1 = (PLINT *) 0 ;
12963 char *arg2 = (
char *) 0 ;
12964 char *arg3 = (
char *) 0 ;
12976 PLINT *arg15 = (PLINT *) 0 ;
12977 PLINT *arg16 = (PLINT *) 0 ;
12979 char *arg18 = (
char *) 0 ;
12980 char *arg19 = (
char *) 0 ;
12981 char *arg20 = (
char *) 0 ;
13012 PyArrayObject *tmp15 = NULL ;
13013 PyArrayObject *tmp16 = NULL ;
13014 char **tmp17 = NULL ;
13024 PyObject * obj0 = 0 ;
13025 PyObject * obj1 = 0 ;
13026 PyObject * obj2 = 0 ;
13027 PyObject * obj3 = 0 ;
13028 PyObject * obj4 = 0 ;
13029 PyObject * obj5 = 0 ;
13030 PyObject * obj6 = 0 ;
13031 PyObject * obj7 = 0 ;
13032 PyObject * obj8 = 0 ;
13033 PyObject * obj9 = 0 ;
13034 PyObject * obj10 = 0 ;
13035 PyObject * obj11 = 0 ;
13036 PyObject * obj12 = 0 ;
13037 PyObject * obj13 = 0 ;
13038 PyObject * obj14 = 0 ;
13039 PyObject * obj15 = 0 ;
13040 PyObject * obj16 = 0 ;
13041 PyObject * obj17 = 0 ;
13042 PyObject * obj18 = 0 ;
13045 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;
13050 arg2 = (
char *)(buf2);
13055 arg3 = (
char *)(buf3);
13060 arg4 = (
PLFLT)(val4);
13065 arg5 = (
PLFLT)(val5);
13070 arg6 = (
PLFLT)(val6);
13075 arg7 = (
PLFLT)(val7);
13080 arg8 = (
PLFLT)(val8);
13085 arg9 = (
PLFLT)(val9);
13090 arg10 = (
PLFLT)(val10);
13095 arg11 = (
PLBOOL)(val11);
13100 arg12 = (
PLBOOL)(val12);
13105 arg13 = (
PLINT)(val13);
13110 arg14 = (
PLINT)(val14);
13113 if ( tmp15 == NULL )
13115 Alen = PyArray_DIMS( tmp15 )[0];
13116 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13120 if ( tmp16 == NULL )
13122 if ( PyArray_DIMS( tmp16 )[0] !=
Alen )
13124 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13127 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13133 PyErr_SetString( PyExc_ValueError,
"Requires a sequence of 4 strings." );
13138 PyErr_SetString( PyExc_ValueError,
"colline and styline args must be length 4." );
13141 tmp17 = (
char **) malloc(
sizeof (
char* ) * 4 );
13142 if ( tmp17 == NULL )
13145 for ( i = 0; i < 4; i++ )
13148 if ( arg17[i] == NULL )
13159 arg18 = (
char *)(buf18);
13164 arg19 = (
char *)(buf19);
13169 arg20 = (
char *)(buf20);
13170 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);
13213 PyObject *resultobj = 0;
13217 PyObject * obj0 = 0 ;
13219 if (!PyArg_ParseTuple(args,(
char *)
"O:plstripd",&obj0))
SWIG_fail;
13224 arg1 = (
PLINT)(val1);
13234 PyObject *resultobj = 0;
13236 PLINT *arg2 = (PLINT *) 0 ;
13237 PLINT *arg3 = (PLINT *) 0 ;
13238 PyArrayObject *tmp1 = NULL ;
13239 PyArrayObject *tmp3 = NULL ;
13240 PyObject * obj0 = 0 ;
13241 PyObject * obj1 = 0 ;
13243 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstyl",&obj0,&obj1))
SWIG_fail;
13246 if ( tmp1 == NULL )
13248 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13249 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13253 if ( tmp3 == NULL )
13255 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13257 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13260 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13262 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
13283 PyObject *resultobj = 0;
13284 PLFLT *arg1 = (PLFLT *) 0 ;
13285 PLFLT *arg2 = (PLFLT *) 0 ;
13288 PyArrayObject *tmp1 = NULL ;
13289 PyArrayObject *tmp2 = NULL ;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 PyObject * obj2 = 0 ;
13296 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsvect",&obj0,&obj1,&obj2))
SWIG_fail;
13298 if ( obj0 != Py_None )
13301 if ( tmp1 == NULL )
13303 Alen = PyArray_DIMS( tmp1 )[0];
13304 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13313 if ( obj1 != Py_None )
13316 if ( tmp2 == NULL )
13318 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
13320 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13323 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13324 arg3 = PyArray_DIMS( tmp2 )[0];
13337 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
13358 PyObject *resultobj = 0;
13371 PyObject * obj0 = 0 ;
13372 PyObject * obj1 = 0 ;
13373 PyObject * obj2 = 0 ;
13374 PyObject * obj3 = 0 ;
13376 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13381 arg1 = (
PLFLT)(val1);
13386 arg2 = (
PLFLT)(val2);
13391 arg3 = (
PLFLT)(val3);
13396 arg4 = (
PLFLT)(val4);
13397 plsvpa(arg1,arg2,arg3,arg4);
13406 PyObject *resultobj = 0;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13416 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsxax",&obj0,&obj1))
SWIG_fail;
13421 arg1 = (
PLINT)(val1);
13426 arg2 = (
PLINT)(val2);
13436 PyObject *resultobj = 0;
13443 PyObject * obj0 = 0 ;
13444 PyObject * obj1 = 0 ;
13446 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsyax",&obj0,&obj1))
SWIG_fail;
13451 arg1 = (
PLINT)(val1);
13456 arg2 = (
PLINT)(val2);
13466 PyObject *resultobj = 0;
13468 PLFLT *arg2 = (PLFLT *) 0 ;
13469 PLFLT *arg3 = (PLFLT *) 0 ;
13471 PyArrayObject *tmp1 = NULL ;
13472 PyArrayObject *tmp3 = NULL ;
13475 PyObject * obj0 = 0 ;
13476 PyObject * obj1 = 0 ;
13477 PyObject * obj2 = 0 ;
13479 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsym",&obj0,&obj1,&obj2))
SWIG_fail;
13482 if ( tmp1 == NULL )
13484 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13485 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13489 if ( tmp3 == NULL )
13491 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13493 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13496 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13502 arg4 = (
PLINT)(val4);
13503 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
13524 PyObject *resultobj = 0;
13531 PyObject * obj0 = 0 ;
13532 PyObject * obj1 = 0 ;
13534 if (!PyArg_ParseTuple(args,(
char *)
"OO:plszax",&obj0,&obj1))
SWIG_fail;
13539 arg1 = (
PLINT)(val1);
13544 arg2 = (
PLINT)(val2);
13554 PyObject *resultobj = 0;
13556 if (!PyArg_ParseTuple(args,(
char *)
":pltext"))
SWIG_fail;
13566 PyObject *resultobj = 0;
13567 char *arg1 = (
char *) 0 ;
13571 PyObject * obj0 = 0 ;
13573 if (!PyArg_ParseTuple(args,(
char *)
"O:pltimefmt",&obj0))
SWIG_fail;
13578 arg1 = (
char *)(buf1);
13590 PyObject *resultobj = 0;
13594 PyObject * obj0 = 0 ;
13596 if (!PyArg_ParseTuple(args,(
char *)
"O:plvasp",&obj0))
SWIG_fail;
13601 arg1 = (
PLFLT)(val1);
13611 PyObject *resultobj = 0;
13612 PLFLT **arg1 = (PLFLT **) 0 ;
13613 PLFLT **arg2 = (PLFLT **) 0 ;
13619 PyArrayObject *tmp1 = NULL ;
13620 PyArrayObject *tmp2 = NULL ;
13623 PyObject * obj0 = 0 ;
13624 PyObject * obj1 = 0 ;
13625 PyObject * obj2 = 0 ;
13626 PyObject * obj3 = 0 ;
13627 PyObject * obj4 = 0 ;
13636 if (!PyArg_ParseTuple(args,(
char *)
"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13640 if ( tmp1 == NULL )
13642 Xlen = PyArray_DIMS( tmp1 )[0];
13643 Ylen = PyArray_DIMS( tmp1 )[1];
13645 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) Xlen );
13646 for ( i = 0; i <
Xlen; i++ )
13647 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13652 if ( tmp2 == NULL )
13654 if ( Xlen != PyArray_DIMS( tmp2 )[0] ||
Ylen != PyArray_DIMS( tmp2 )[1] )
13656 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
13659 arg3 = PyArray_DIMS( tmp2 )[0];
13660 arg4 = PyArray_DIMS( tmp2 )[1];
13662 arg2 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg3 );
13663 for ( i = 0; i < arg3; i++ )
13664 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13670 arg5 = (
PLFLT)(val5);
13674 if ( obj3 == Py_None )
13680 if ( !PyCallable_Check( (PyObject *) obj3 ) )
13682 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
13691 if ( obj4 == Py_None )
13699 plvect((
double const **)arg1,(
double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13736 PyObject *resultobj = 0;
13752 PyObject * obj0 = 0 ;
13753 PyObject * obj1 = 0 ;
13754 PyObject * obj2 = 0 ;
13755 PyObject * obj3 = 0 ;
13756 PyObject * obj4 = 0 ;
13758 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13763 arg1 = (
PLFLT)(val1);
13768 arg2 = (
PLFLT)(val2);
13773 arg3 = (
PLFLT)(val3);
13778 arg4 = (
PLFLT)(val4);
13783 arg5 = (
PLFLT)(val5);
13784 plvpas(arg1,arg2,arg3,arg4,arg5);
13793 PyObject *resultobj = 0;
13806 PyObject * obj0 = 0 ;
13807 PyObject * obj1 = 0 ;
13808 PyObject * obj2 = 0 ;
13809 PyObject * obj3 = 0 ;
13811 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13816 arg1 = (
PLFLT)(val1);
13821 arg2 = (
PLFLT)(val2);
13826 arg3 = (
PLFLT)(val3);
13831 arg4 = (
PLFLT)(val4);
13832 plvpor(arg1,arg2,arg3,arg4);
13841 PyObject *resultobj = 0;
13843 if (!PyArg_ParseTuple(args,(
char *)
":plvsta"))
SWIG_fail;
13853 PyObject *resultobj = 0;
13887 PyObject * obj0 = 0 ;
13888 PyObject * obj1 = 0 ;
13889 PyObject * obj2 = 0 ;
13890 PyObject * obj3 = 0 ;
13891 PyObject * obj4 = 0 ;
13892 PyObject * obj5 = 0 ;
13893 PyObject * obj6 = 0 ;
13894 PyObject * obj7 = 0 ;
13895 PyObject * obj8 = 0 ;
13896 PyObject * obj9 = 0 ;
13897 PyObject * obj10 = 0 ;
13899 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
13904 arg1 = (
PLFLT)(val1);
13909 arg2 = (
PLFLT)(val2);
13914 arg3 = (
PLFLT)(val3);
13919 arg4 = (
PLFLT)(val4);
13924 arg5 = (
PLFLT)(val5);
13929 arg6 = (
PLFLT)(val6);
13934 arg7 = (
PLFLT)(val7);
13939 arg8 = (
PLFLT)(val8);
13944 arg9 = (
PLFLT)(val9);
13949 arg10 = (
PLFLT)(val10);
13954 arg11 = (
PLFLT)(val11);
13955 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13964 PyObject *resultobj = 0;
13968 PyObject * obj0 = 0 ;
13970 if (!PyArg_ParseTuple(args,(
char *)
"O:plwidth",&obj0))
SWIG_fail;
13975 arg1 = (
PLFLT)(val1);
13985 PyObject *resultobj = 0;
13998 PyObject * obj0 = 0 ;
13999 PyObject * obj1 = 0 ;
14000 PyObject * obj2 = 0 ;
14001 PyObject * obj3 = 0 ;
14003 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plwind",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
14008 arg1 = (
PLFLT)(val1);
14013 arg2 = (
PLFLT)(val2);
14018 arg3 = (
PLFLT)(val3);
14023 arg4 = (
PLFLT)(val4);
14024 plwind(arg1,arg2,arg3,arg4);
14033 PyObject *resultobj = 0;
14040 PyObject * obj0 = 0 ;
14043 if (!PyArg_ParseTuple(args,(
char *)
"O:plxormod",&obj0))
SWIG_fail;
14064 PyObject *resultobj = 0;
14066 char *arg2 = (
char *) 0 ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 PyObject * obj2 = 0 ;
14085 PyObject * obj3 = 0 ;
14086 PyObject * obj4 = 0 ;
14087 PyObject * obj5 = 0 ;
14089 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
14092 if ( obj0 == Py_None )
14098 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14100 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14110 arg2 = (
char *)(buf2);
14115 arg3 = (
PLFLT)(val3);
14120 arg4 = (
PLFLT)(val4);
14125 arg5 = (
PLFLT)(val5);
14130 arg6 = (
PLFLT)(val6);
14131 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
14148 PyObject *resultobj = 0;
14150 char *arg2 = (
char *) 0 ;
14155 PLINT *arg7 = (PLINT *) 0 ;
14168 PyArrayObject *tmp7 = NULL ;
14169 PyObject * obj0 = 0 ;
14170 PyObject * obj1 = 0 ;
14171 PyObject * obj2 = 0 ;
14172 PyObject * obj3 = 0 ;
14173 PyObject * obj4 = 0 ;
14174 PyObject * obj5 = 0 ;
14175 PyObject * obj6 = 0 ;
14177 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14180 if ( obj0 == Py_None )
14186 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14188 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14198 arg2 = (
char *)(buf2);
14203 arg3 = (
PLFLT)(val3);
14208 arg4 = (
PLFLT)(val4);
14213 arg5 = (
PLFLT)(val5);
14218 arg6 = (
PLFLT)(val6);
14220 if ( obj6 != Py_None )
14223 if ( tmp7 == NULL )
14225 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14226 arg8 = PyArray_DIMS( tmp7 )[0];
14234 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
14257 PyObject *resultobj = 0;
14259 char *arg2 = (
char *) 0 ;
14260 char *arg3 = (
char *) 0 ;
14265 PLINT *arg8 = (PLINT *) 0 ;
14281 PyArrayObject *tmp8 = NULL ;
14282 PyObject * obj0 = 0 ;
14283 PyObject * obj1 = 0 ;
14284 PyObject * obj2 = 0 ;
14285 PyObject * obj3 = 0 ;
14286 PyObject * obj4 = 0 ;
14287 PyObject * obj5 = 0 ;
14288 PyObject * obj6 = 0 ;
14289 PyObject * obj7 = 0 ;
14291 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
14294 if ( obj0 == Py_None )
14300 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14302 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14312 arg2 = (
char *)(buf2);
14317 arg3 = (
char *)(buf3);
14322 arg4 = (
PLFLT)(val4);
14327 arg5 = (
PLFLT)(val5);
14332 arg6 = (
PLFLT)(val6);
14337 arg7 = (
PLFLT)(val7);
14339 if ( obj7 != Py_None )
14342 if ( tmp8 == NULL )
14344 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14345 arg9 = PyArray_DIMS( tmp8 )[0];
14353 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
14378 PyObject *resultobj = 0;
14380 char *arg2 = (
char *) 0 ;
14384 char *arg6 = (
char *) 0 ;
14412 PyObject * obj0 = 0 ;
14413 PyObject * obj1 = 0 ;
14414 PyObject * obj2 = 0 ;
14415 PyObject * obj3 = 0 ;
14416 PyObject * obj4 = 0 ;
14417 PyObject * obj5 = 0 ;
14418 PyObject * obj6 = 0 ;
14419 PyObject * obj7 = 0 ;
14420 PyObject * obj8 = 0 ;
14421 PyObject * obj9 = 0 ;
14422 PyObject * obj10 = 0 ;
14424 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14427 if ( obj0 == Py_None )
14433 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14435 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14445 arg2 = (
char *)(buf2);
14450 arg3 = (
PLFLT)(val3);
14455 arg4 = (
PLFLT)(val4);
14460 arg5 = (
PLFLT)(val5);
14465 arg6 = (
char *)(buf6);
14470 arg7 = (
PLFLT)(val7);
14475 arg8 = (
PLFLT)(val8);
14480 arg9 = (
PLFLT)(val9);
14485 arg10 = (
PLFLT)(val10);
14490 arg11 = (
PLINT)(val11);
14491 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14510 PyObject *resultobj = 0;
14512 char *arg2 = (
char *) 0 ;
14517 PLINT *arg7 = (PLINT *) 0 ;
14530 PyArrayObject *tmp7 = NULL ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 PyObject * obj2 = 0 ;
14534 PyObject * obj3 = 0 ;
14535 PyObject * obj4 = 0 ;
14536 PyObject * obj5 = 0 ;
14537 PyObject * obj6 = 0 ;
14539 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14542 if ( obj0 == Py_None )
14548 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14550 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14560 arg2 = (
char *)(buf2);
14565 arg3 = (
PLFLT)(val3);
14570 arg4 = (
PLFLT)(val4);
14575 arg5 = (
PLFLT)(val5);
14580 arg6 = (
PLFLT)(val6);
14582 if ( obj6 != Py_None )
14585 if ( tmp7 == NULL )
14587 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14588 arg8 = PyArray_DIMS( tmp7 )[0];
14596 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
14619 PyObject *resultobj = 0;
14639 PyObject * obj0 = 0 ;
14640 PyObject * obj1 = 0 ;
14641 PyObject * obj2 = 0 ;
14642 PyObject * obj3 = 0 ;
14643 PyObject * obj4 = 0 ;
14644 PyObject * obj5 = 0 ;
14645 PyObject * obj6 = 0 ;
14647 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14650 if ( obj0 == Py_None )
14656 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14658 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14668 arg2 = (
PLFLT)(val2);
14673 arg3 = (
PLFLT)(val3);
14678 arg4 = (
PLFLT)(val4);
14683 arg5 = (
PLFLT)(val5);
14688 arg6 = (
PLFLT)(val6);
14693 arg7 = (
PLFLT)(val7);
14709 PyObject *resultobj = 0;
14710 PLFLT **arg1 = (PLFLT **) 0 ;
14723 PyArrayObject *tmp1 = NULL ;
14744 PyObject * obj0 = 0 ;
14745 PyObject * obj1 = 0 ;
14746 PyObject * obj2 = 0 ;
14747 PyObject * obj3 = 0 ;
14748 PyObject * obj4 = 0 ;
14749 PyObject * obj5 = 0 ;
14750 PyObject * obj6 = 0 ;
14751 PyObject * obj7 = 0 ;
14752 PyObject * obj8 = 0 ;
14753 PyObject * obj9 = 0 ;
14754 PyObject * obj10 = 0 ;
14756 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14760 if ( tmp1 == NULL )
14762 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14763 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14765 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
14766 for ( i = 0; i < arg2; i++ )
14767 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14773 arg4 = (
PLFLT)(val4);
14778 arg5 = (
PLFLT)(val5);
14783 arg6 = (
PLFLT)(val6);
14788 arg7 = (
PLFLT)(val7);
14793 arg8 = (
PLFLT)(val8);
14798 arg9 = (
PLFLT)(val9);
14803 arg10 = (
PLFLT)(val10);
14808 arg11 = (
PLFLT)(val11);
14813 arg12 = (
PLFLT)(val12);
14818 arg13 = (
PLFLT)(val13);
14819 plimage((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14836 PyObject *resultobj = 0;
14837 PLFLT **arg1 = (PLFLT **) 0 ;
14850 PyArrayObject *tmp1 = NULL ;
14867 PyObject * obj0 = 0 ;
14868 PyObject * obj1 = 0 ;
14869 PyObject * obj2 = 0 ;
14870 PyObject * obj3 = 0 ;
14871 PyObject * obj4 = 0 ;
14872 PyObject * obj5 = 0 ;
14873 PyObject * obj6 = 0 ;
14874 PyObject * obj7 = 0 ;
14875 PyObject * obj8 = 0 ;
14876 PyObject * obj9 = 0 ;
14877 PyObject * obj10 = 0 ;
14886 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14890 if ( tmp1 == NULL )
14892 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14893 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14895 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
14896 for ( i = 0; i < arg2; i++ )
14897 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14903 arg4 = (
PLFLT)(val4);
14908 arg5 = (
PLFLT)(val5);
14913 arg6 = (
PLFLT)(val6);
14918 arg7 = (
PLFLT)(val7);
14923 arg8 = (
PLFLT)(val8);
14928 arg9 = (
PLFLT)(val9);
14933 arg10 = (
PLFLT)(val10);
14938 arg11 = (
PLFLT)(val11);
14942 if ( obj9 == Py_None )
14948 if ( !PyCallable_Check( (PyObject *) obj9 ) )
14950 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
14959 if ( obj10 == Py_None )
14967 plimagefr((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14996 PyObject *resultobj = 0;
14998 if (!PyArg_ParseTuple(args,(
char *)
":plClearOpts"))
SWIG_fail;
15008 PyObject *resultobj = 0;
15010 if (!PyArg_ParseTuple(args,(
char *)
":plResetOpts"))
SWIG_fail;
15020 PyObject *resultobj = 0;
15021 char *arg1 = (
char *) 0 ;
15022 char *arg2 = (
char *) 0 ;
15029 PyObject * obj0 = 0 ;
15030 PyObject * obj1 = 0 ;
15032 if (!PyArg_ParseTuple(args,(
char *)
"OO:plSetUsage",&obj0,&obj1))
SWIG_fail;
15037 arg1 = (
char *)(buf1);
15042 arg2 = (
char *)(buf2);
15043 plSetUsage((
char const *)arg1,(
char const *)arg2);
15056 PyObject *resultobj = 0;
15058 if (!PyArg_ParseTuple(args,(
char *)
":plOptUsage"))
SWIG_fail;
15068 PyObject *resultobj = 0;
15069 PLFLT **arg1 = (PLFLT **) 0 ;
15072 PLFLT *arg4 = (PLFLT *) 0 ;
15073 PLFLT *arg5 = (PLFLT *) 0 ;
15074 PyArrayObject *tmp1 = NULL ;
15079 PyObject * obj0 = 0 ;
15083 if (!PyArg_ParseTuple(args,(
char *)
"O:plMinMax2dGrid",&obj0))
SWIG_fail;
15087 if ( tmp1 == NULL )
15089 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15090 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15092 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
15093 for ( i = 0; i < arg2; i++ )
15094 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15125 PyObject *resultobj = 0;
15129 PyObject * obj0 = 0 ;
15132 if (!PyArg_ParseTuple(args,(
char *)
"O:plGetCursor",&obj0))
SWIG_fail;
15148 { (
char *)
"pltr0",
_wrap_pltr0, METH_VARARGS, NULL},
15149 { (
char *)
"pltr1",
_wrap_pltr1, METH_VARARGS, NULL},
15150 { (
char *)
"pltr2",
_wrap_pltr2, METH_VARARGS, NULL},
15180 "Set format of numerical label for contours\n"
15184 " Set format of numerical label for contours.\n"
15186 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15188 " This function is used example 9.\n"
15194 "pl_setcontlabelformat(lexp, sigdig)\n"
15198 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15199 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15200 " format is used. Default value of lexp is 4.\n"
15202 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15207 "Set parameters of contour labelling other than format of numerical label\n"
15211 " Set parameters of contour labelling other than those handled by\n"
15212 " pl_setcontlabelformat.\n"
15214 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15216 " This function is used in example 9.\n"
15222 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15226 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15227 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15229 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15230 " Default value is 0.3.\n"
15232 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15233 " Default value is 0.1.\n"
15235 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15236 " contour labels on. Default is off (0).\n"
15239 { (
char *)
"pladv",
_wrap_pladv, METH_VARARGS, (
char *)
"\n"
15240 "Advance the (sub-)page\n"
15244 " Advances to the next subpage if sub=0, performing a page advance if\n"
15245 " there are no remaining subpages on the current page. If subpages\n"
15246 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15247 " PLplot switches to the specified subpage. Note that this allows you\n"
15248 " to overwrite a plot on the specified subpage; if this is not what you\n"
15249 " intended, use pleop followed by plbop to first advance the page. This\n"
15250 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15251 " is not used, pladv must be called after initializing PLplot but before\n"
15252 " defining the viewport.\n"
15254 " Redacted form: pladv(page)\n"
15256 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15267 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15268 " in the top left corner and increasing along the rows) to which to\n"
15269 " advance. Set to zero to advance to the next subpage (or to the\n"
15270 " next page if subpages are not being used).\n"
15273 { (
char *)
"plarc",
_wrap_plarc, METH_VARARGS, (
char *)
"\n"
15274 "Draw a circular or elliptical arc\n"
15278 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15279 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15281 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15285 " This function is used in examples 3 and 27.\n"
15291 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15295 " x (PLFLT, input) : X coordinate of arc center.\n"
15297 " y (PLFLT, input) : Y coordinate of arc center.\n"
15299 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15301 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15303 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15304 " semimajor axis.\n"
15306 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15307 " semimajor axis.\n"
15309 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15312 " fill (PLBOOL, input) : Draw a filled arc.\n"
15315 { (
char *)
"plaxes",
_wrap_plaxes, METH_VARARGS, (
char *)
"\n"
15316 "Draw a box with axes, etc. with arbitrary origin\n"
15320 " Draws a box around the currently defined viewport with arbitrary\n"
15321 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15322 " world coordinate values appropriate to the window. Thus plaxes should\n"
15323 " only be called after defining both viewport and window. The ascii\n"
15324 " character strings xopt and yopt specify how the box should be drawn as\n"
15325 " described below. If ticks and/or subticks are to be drawn for a\n"
15326 " particular axis, the tick intervals and number of subintervals may be\n"
15327 " specified explicitly, or they may be defaulted by setting the\n"
15328 " appropriate arguments to zero.\n"
15330 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15332 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
15336 " This function is not used in any examples.\n"
15342 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15346 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15348 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15350 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15351 " options for the x axis. The string can include any combination of\n"
15352 " the following letters (upper or lower case) in any order: a: Draws\n"
15353 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15355 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15356 " c: Draws top (X) or right (Y) edge of frame.\n"
15357 " d: Plot labels as date / time. Values are assumed to be\n"
15358 " seconds since the epoch (as used by gmtime).\n"
15359 " f: Always use fixed point numeric labels.\n"
15360 " g: Draws a grid at the major tick interval.\n"
15361 " h: Draws a grid at the minor tick interval.\n"
15362 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15364 " l: Labels axis logarithmically. This only affects the labels,\n"
15365 " not the data, and so it is necessary to compute the logarithms\n"
15366 " of data points before passing them to any of the drawing\n"
15368 " m: Writes numeric labels at major tick intervals in the\n"
15369 " unconventional location (above box for X, right of box for Y).\n"
15370 " n: Writes numeric labels at major tick intervals in the\n"
15371 " conventional location (below box for X, left of box for Y).\n"
15372 " o: Use custom labelling function to generate axis label text.\n"
15373 " The custom labelling function can be defined with the\n"
15374 " plslabelfunc command.\n"
15375 " s: Enables subticks between major ticks, only valid if t is\n"
15376 " also specified.\n"
15377 " t: Draws major ticks.\n"
15378 " u: Exactly like \"b\" except don't draw edge line.\n"
15379 " w: Exactly like \"c\" except don't draw edge line.\n"
15380 " x: Exactly like \"t\" (including the side effect of the\n"
15381 " numerical labels for the major ticks) except exclude drawing\n"
15382 " the major and minor tick marks.\n"
15385 " xtick (PLFLT, input) : World coordinate interval between major\n"
15386 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15387 " generates a suitable tick interval.\n"
15389 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15390 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15391 " generates a suitable minor tick interval.\n"
15393 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15394 " options for the y axis. The string can include any combination of\n"
15395 " the letters defined above for xopt, and in addition may contain:\n"
15396 " v: Write numeric labels for the y axis parallel to the base of the\n"
15397 " graph, rather than parallel to the axis.\n"
15400 " ytick (PLFLT, input) : World coordinate interval between major\n"
15401 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15402 " generates a suitable tick interval.\n"
15404 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15405 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15406 " generates a suitable minor tick interval.\n"
15409 { (
char *)
"plbin",
_wrap_plbin, METH_VARARGS, (
char *)
"\n"
15410 "Plot a histogram from binned data\n"
15414 " Plots a histogram consisting of nbin bins. The value associated with\n"
15415 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15416 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15417 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15418 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15419 " placed midway between the values in the x vector. Also see plhist for\n"
15420 " drawing histograms from unbinned data.\n"
15422 " Redacted form: General: plbin(x, y, opt)\n"
15423 " Perl/PDL: plbin(nbin, x, y, opt)\n"
15424 " Python: plbin(nbin, x, y, opt)\n"
15427 " This function is not used in any examples.\n"
15433 "plbin(nbin, x, y, opt)\n"
15437 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15438 " and y vectors.)\n"
15440 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15441 " with bins. These must form a strictly increasing sequence.\n"
15443 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15444 " proportional to the number of points in each bin. This is a PLFLT\n"
15445 " (instead of PLINT) vector so as to allow histograms of\n"
15446 " probabilities, etc.\n"
15448 " opt (PLINT, input) : Is a combination of several flags:\n"
15449 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15450 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15451 " zero height are simply drawn.\n"
15452 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15453 " between the x values. If the values in x are equally spaced,\n"
15454 " the values are the center values of the bins.\n"
15455 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15456 " size as the ones inside.\n"
15457 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15458 " (there is a gap for such bins).\n"
15461 { (
char *)
"plbtime",
_wrap_plbtime, METH_VARARGS, (
char *)
"\n"
15462 "Calculate broken-down time from continuous time for the current stream\n"
15466 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15467 " continuous time, ctime for the current stream. This function is the\n"
15468 " inverse of plctime.\n"
15470 " The PLplot definition of broken-down time is a calendar time that\n"
15471 " completely ignores all time zone offsets, i.e., it is the user's\n"
15472 " responsibility to apply those offsets (if so desired) before using the\n"
15473 " PLplot time API. By default broken-down time is defined using the\n"
15474 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15475 " continuous time is defined as the number of seconds since the Unix\n"
15476 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15477 " broken-down and continuous time are possible, see plconfigtime.\n"
15479 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15481 " Perl/PDL: Not available?\n"
15484 " This function is used in example 29.\n"
15490 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15494 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15495 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15496 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15499 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15500 " the year in the range from 0 (January) to 11 (December).\n"
15502 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15503 " month in the range from 1 to 31.\n"
15505 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15506 " day in the range from 0 to 23.\n"
15508 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15509 " hour in the range from 0 to 59\n"
15511 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15512 " minute in range from 0. to 60.\n"
15514 " ctime (PLFLT, input) : Continous time from which the broken-down\n"
15515 " time is calculated.\n"
15518 { (
char *)
"plbop",
_wrap_plbop, METH_VARARGS, (
char *)
"\n"
15519 "Begin a new page\n"
15523 " Begins a new page. For a file driver, the output file is opened if\n"
15524 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15525 " page break is desired at a particular point when plotting to subpages.\n"
15526 " Another use for pleop and plbop is when plotting pages to different\n"
15527 " files, since you can manually set the file name by calling plsfnam\n"
15528 " after the call to pleop. (In fact some drivers may only support a\n"
15529 " single page per file, making this a necessity.) One way to handle\n"
15530 " this case automatically is to page advance via pladv, but enable\n"
15531 " familying (see plsfam) with a small limit on the file size so that a\n"
15532 " new family member file will be created on each page break.\n"
15534 " Redacted form: plbop()\n"
15536 " This function is used in examples 2 and 20.\n"
15545 { (
char *)
"plbox",
_wrap_plbox, METH_VARARGS, (
char *)
"\n"
15546 "Draw a box with axes, etc\n"
15550 " Draws a box around the currently defined viewport, and labels it with\n"
15551 " world coordinate values appropriate to the window. Thus plbox should\n"
15552 " only be called after defining both viewport and window. The ascii\n"
15553 " character strings xopt and yopt specify how the box should be drawn as\n"
15554 " described below. If ticks and/or subticks are to be drawn for a\n"
15555 " particular axis, the tick intervals and number of subintervals may be\n"
15556 " specified explicitly, or they may be defaulted by setting the\n"
15557 " appropriate arguments to zero.\n"
15559 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15560 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
15563 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15570 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15574 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15575 " options for the x axis. The string can include any combination of\n"
15576 " the following letters (upper or lower case) in any order: a: Draws\n"
15577 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15579 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15580 " c: Draws top (X) or right (Y) edge of frame.\n"
15581 " d: Plot labels as date / time. Values are assumed to be\n"
15582 " seconds since the epoch (as used by gmtime).\n"
15583 " f: Always use fixed point numeric labels.\n"
15584 " g: Draws a grid at the major tick interval.\n"
15585 " h: Draws a grid at the minor tick interval.\n"
15586 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15588 " l: Labels axis logarithmically. This only affects the labels,\n"
15589 " not the data, and so it is necessary to compute the logarithms\n"
15590 " of data points before passing them to any of the drawing\n"
15592 " m: Writes numeric labels at major tick intervals in the\n"
15593 " unconventional location (above box for X, right of box for Y).\n"
15594 " n: Writes numeric labels at major tick intervals in the\n"
15595 " conventional location (below box for X, left of box for Y).\n"
15596 " o: Use custom labelling function to generate axis label text.\n"
15597 " The custom labelling function can be defined with the\n"
15598 " plslabelfunc command.\n"
15599 " s: Enables subticks between major ticks, only valid if t is\n"
15600 " also specified.\n"
15601 " t: Draws major ticks.\n"
15602 " u: Exactly like \"b\" except don't draw edge line.\n"
15603 " w: Exactly like \"c\" except don't draw edge line.\n"
15604 " x: Exactly like \"t\" (including the side effect of the\n"
15605 " numerical labels for the major ticks) except exclude drawing\n"
15606 " the major and minor tick marks.\n"
15609 " xtick (PLFLT, input) : World coordinate interval between major\n"
15610 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15611 " generates a suitable tick interval.\n"
15613 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15614 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15615 " generates a suitable minor tick interval.\n"
15617 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15618 " options for the y axis. The string can include any combination of\n"
15619 " the letters defined above for xopt, and in addition may contain:\n"
15620 " v: Write numeric labels for the y axis parallel to the base of the\n"
15621 " graph, rather than parallel to the axis.\n"
15624 " ytick (PLFLT, input) : World coordinate interval between major\n"
15625 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15626 " generates a suitable tick interval.\n"
15628 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15629 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15630 " generates a suitable minor tick interval.\n"
15633 { (
char *)
"plbox3",
_wrap_plbox3, METH_VARARGS, (
char *)
"\n"
15634 "Draw a box with axes, etc, in 3-d\n"
15638 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15639 " plot. For a more complete description of three-dimensional plotting\n"
15640 " see the PLplot documentation.\n"
15642 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15643 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15644 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15645 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15648 " This function is used in examples 8, 11, 18, and 21.\n"
15654 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15658 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15659 " options for the x axis. The string can include any combination of\n"
15660 " the following letters (upper or lower case) in any order: b: Draws\n"
15661 " axis at base, at height z=\n"
15662 " zmin where zmin is defined by call to plw3d. This character must be\n"
15663 " specified in order to use any of the other options.\n"
15664 " d: Plot labels as date / time. Values are assumed to be\n"
15665 " seconds since the epoch (as used by gmtime).\n"
15666 " f: Always use fixed point numeric labels.\n"
15667 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15669 " l: Labels axis logarithmically. This only affects the labels,\n"
15670 " not the data, and so it is necessary to compute the logarithms\n"
15671 " of data points before passing them to any of the drawing\n"
15673 " n: Writes numeric labels at major tick intervals.\n"
15674 " o: Use custom labelling function to generate axis label text.\n"
15675 " The custom labelling function can be defined with the\n"
15676 " plslabelfunc command.\n"
15677 " s: Enables subticks between major ticks, only valid if t is\n"
15678 " also specified.\n"
15679 " t: Draws major ticks.\n"
15680 " u: If this is specified, the text label for the axis is\n"
15681 " written under the axis.\n"
15684 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15685 " the text label for the x axis. It is only drawn if u is in the\n"
15688 " xtick (PLFLT, input) : World coordinate interval between major\n"
15689 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15690 " generates a suitable tick interval.\n"
15692 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15693 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15694 " generates a suitable minor tick interval.\n"
15696 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15697 " options for the y axis. The string is interpreted in the same way\n"
15700 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15701 " the text label for the y axis. It is only drawn if u is in the\n"
15704 " ytick (PLFLT, input) : World coordinate interval between major\n"
15705 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15706 " generates a suitable tick interval.\n"
15708 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15709 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15710 " generates a suitable minor tick interval.\n"
15712 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15713 " options for the z axis. The string can include any combination of\n"
15714 " the following letters (upper or lower case) in any order: b: Draws\n"
15715 " z axis to the left of the surface plot.\n"
15716 " c: Draws z axis to the right of the surface plot.\n"
15717 " d: Draws grid lines parallel to the x-y plane behind the\n"
15718 " figure. These lines are not drawn until after plot3d or\n"
15719 " plmesh are called because of the need for hidden line removal.\n"
15720 " e: Plot labels as date / time. Values are assumed to be\n"
15721 " seconds since the epoch (as used by gmtime). Note this\n"
15722 " suboption is interpreted the same as the d suboption for xopt\n"
15723 " and yopt, but it has to be identified as e for zopt since d\n"
15724 " has already been used for the different purpose above.\n"
15725 " f: Always use fixed point numeric labels.\n"
15726 " i: Inverts tick marks, so they are drawn away from the center.\n"
15727 " l: Labels axis logarithmically. This only affects the labels,\n"
15728 " not the data, and so it is necessary to compute the logarithms\n"
15729 " of data points before passing them to any of the drawing\n"
15731 " m: Writes numeric labels at major tick intervals on the\n"
15732 " right-hand z axis.\n"
15733 " n: Writes numeric labels at major tick intervals on the\n"
15734 " left-hand z axis.\n"
15735 " o: Use custom labelling function to generate axis label text.\n"
15736 " The custom labelling function can be defined with the\n"
15737 " plslabelfunc command.\n"
15738 " s: Enables subticks between major ticks, only valid if t is\n"
15739 " also specified.\n"
15740 " t: Draws major ticks.\n"
15741 " u: If this is specified, the text label is written beside the\n"
15742 " left-hand axis.\n"
15743 " v: If this is specified, the text label is written beside the\n"
15744 " right-hand axis.\n"
15747 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15748 " the text label for the z axis. It is only drawn if u or v are in\n"
15749 " the zopt string.\n"
15751 " ztick (PLFLT, input) : World coordinate interval between major\n"
15752 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15753 " generates a suitable tick interval.\n"
15755 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15756 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15757 " generates a suitable minor tick interval.\n"
15761 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15765 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15766 " from relative device coordinates, rx and ry.\n"
15768 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15769 " Perl/PDL: Not available?\n"
15772 " This function is used in example 31.\n"
15778 "plcalc_world(rx, ry, wx, wy, window)\n"
15782 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15783 " the x coordinate.\n"
15785 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15786 " the y coordinate.\n"
15788 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15789 " coordinate corresponding to the relative device coordinates rx and\n"
15792 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15793 " coordinate corresponding to the relative device coordinates rx and\n"
15796 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15797 " defined window index that corresponds to the input relative device\n"
15798 " coordinates (and the returned world coordinates). To give some\n"
15799 " background on the window index, for each page the initial window\n"
15800 " index is set to zero, and each time plwind is called within the\n"
15801 " page, world and device coordinates are stored for the window and\n"
15802 " the window index is incremented. Thus, for a simple page layout\n"
15803 " with non-overlapping viewports and one window per viewport, window\n"
15804 " corresponds to the viewport index (in the order which the\n"
15805 " viewport/windows were created) of the only viewport/window\n"
15806 " corresponding to rx and ry. However, for more complicated layouts\n"
15807 " with potentially overlapping viewports and possibly more than one\n"
15808 " window (set of world coordinates) per viewport, window and the\n"
15809 " corresponding output world coordinates corresponds to the last\n"
15810 " window created that fulfills the criterion that the relative\n"
15811 " device coordinates are inside it. Finally, in all cases where the\n"
15812 " input relative device coordinates are not inside any\n"
15813 " viewport/window, then the returned value of the last defined\n"
15814 " window index is set to -1.\n"
15817 { (
char *)
"plclear",
_wrap_plclear, METH_VARARGS, (
char *)
"\n"
15818 "Clear current (sub)page\n"
15822 " Clears the current page, effectively erasing everything that have been\n"
15823 " drawn. This command only works with interactive drivers; if the\n"
15824 " driver does not support this, the page is filled with the background\n"
15825 " color in use. If the current page is divided into subpages, only the\n"
15826 " current subpage is erased. The nth subpage can be selected with\n"
15829 " Redacted form: General: plclear()\n"
15830 " Perl/PDL: Not available?\n"
15833 " This function is not used in any examples.\n"
15842 { (
char *)
"plcol0",
_wrap_plcol0, METH_VARARGS, (
char *)
"\n"
15843 "Set color, cmap0\n"
15847 " Sets the color index for cmap0 (see the PLplot documentation).\n"
15849 " Redacted form: plcol0(icol0)\n"
15851 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15861 " icol0 (PLINT, input) : Integer representing the color. The\n"
15862 " defaults at present are (these may change):\n"
15863 " 0 black (default background)\n"
15864 " 1 red (default foreground)\n"
15880 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15881 " change an individual color in the cmap0 color palette.\n"
15884 { (
char *)
"plcol1",
_wrap_plcol1, METH_VARARGS, (
char *)
"\n"
15885 "Set color, cmap1\n"
15889 " Sets the color for cmap1 (see the PLplot documentation).\n"
15891 " Redacted form: plcol1(col1)\n"
15893 " This function is used in examples 12 and 21.\n"
15903 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15904 " is mapped to color using the continuous cmap1 palette which by\n"
15905 " default ranges from blue to the background color to red. The\n"
15906 " cmap1 palette can also be straightforwardly changed by the user\n"
15907 " with plscmap1 or plscmap1l.\n"
15911 "Configure the transformation between continuous and broken-down time for the current stream\n"
15915 " Configure the transformation between continuous and broken-down time\n"
15916 " for the current stream. This transformation is used by both plbtime\n"
15919 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15920 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15921 " Perl/PDL: Not available?\n"
15924 " This function is used in example 29.\n"
15930 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15934 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15935 " As a special case, if\n"
15936 " scale is 0., then all other arguments are ignored, and the result (the\n"
15937 " default used by PLplot) is the equivalent of a call to\n"
15938 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15939 " That is, for this special case broken-down time is calculated with\n"
15940 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15941 " and the continuous time is defined as the number of seconds since\n"
15942 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15944 " offset1 (PLFLT, input) : If\n"
15945 " ifbtime_offset is true, the parameters\n"
15947 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15948 " (with units in days) specify the epoch of the continuous time\n"
15949 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15950 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15951 " are used to specify the origin to allow users (by specifying\n"
15952 " offset1 as an integer that can be exactly represented by a\n"
15953 " floating-point variable and specifying\n"
15954 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15955 " the numerical errors of the continuous time representation.\n"
15957 " offset2 (PLFLT, input) : See documentation of\n"
15960 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15961 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15962 " calendar is used for broken-down time rather than the proleptic\n"
15963 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15964 " have been historically used to define UTC are inserted into the\n"
15965 " broken-down time. Other possibilities for additional control bits\n"
15966 " for ccontrol exist such as making the historical time corrections\n"
15967 " in the broken-down time corresponding to ET (ephemeris time) or\n"
15968 " making the (slightly non-constant) corrections from international\n"
15969 " atomic time (TAI) to what astronomers define as terrestrial time\n"
15970 " (TT). But those additional possibilities have not been\n"
15971 " implemented yet in the qsastime library (one of the PLplot utility\n"
15974 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15975 " epoch of the continuous time scale is specified by the user. If\n"
15976 " ifbtime_offset is false, then\n"
15978 " offset2 are used to specify the epoch, and the following broken-down\n"
15979 " time parameters are completely ignored. If\n"
15980 " ifbtime_offset is true, then\n"
15982 " offset2 are completely ignored, and the following broken-down time\n"
15983 " parameters are used to specify the epoch.\n"
15985 " year (PLINT, input) : Year of epoch.\n"
15987 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15988 " 11 (December).\n"
15990 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15992 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15994 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15996 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15999 { (
char *)
"plcont",
_wrap_plcont, METH_VARARGS, (
char *)
"\n"
16004 " Draws a contour plot of the data in f[\n"
16006 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16007 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16008 " where all these index ranges are interpreted as one-based for\n"
16009 " historical reasons. A transformation routine pointed to by pltr with\n"
16010 " a generic pointer pltr_data for additional data required by the\n"
16011 " transformation routine is used to map indices within the matrix to the\n"
16012 " world coordinates.\n"
16014 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16015 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16016 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16017 " vectors; or xg and yg matrices.\n"
16019 " This function is used in examples 9, 14, 16, and 22.\n"
16025 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16029 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16031 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16033 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16034 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16035 " zero-based for historical backwards-compatibility reasons.\n"
16037 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16038 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16039 " zero-based for historical backwards-compatibility reasons.\n"
16041 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16042 " which to draw contours.\n"
16044 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16046 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16047 " defines the transformation between the zero-based indices of the\n"
16048 " matrix f and the world coordinates.For the C case, transformation\n"
16049 " functions are provided in the PLplot library: pltr0 for the\n"
16050 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16051 " respectively defined by vectors and matrices. In addition, C\n"
16052 " callback routines for the transformation can be supplied by the\n"
16053 " user such as the mypltr function in examples/c/x09c.c which\n"
16054 " provides a general linear transformation between index coordinates\n"
16055 " and world coordinates.For languages other than C you should\n"
16056 " consult the PLplot documentation for the details concerning how\n"
16057 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16058 " general, a particular pattern of callback-associated arguments\n"
16059 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16060 " yg matrices are respectively interfaced to a linear-transformation\n"
16061 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16062 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16063 " the PLplot documentation) support native language callbacks for\n"
16064 " handling index to world-coordinate transformations. Examples of\n"
16065 " these various approaches are given in examples/<language>x09*,\n"
16066 " examples/<language>x16*, examples/<language>x20*,\n"
16067 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16068 " supported languages.\n"
16070 " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
16071 " pass information to pltr0, pltr1, pltr2, or whatever callback\n"
16072 " routine that is externally supplied.\n"
16075 { (
char *)
"plctime",
_wrap_plctime, METH_VARARGS, (
char *)
"\n"
16076 "Calculate continuous time from broken-down time for the current stream\n"
16080 " Calculate continuous time, ctime, from broken-down time for the\n"
16081 " current stream. The broken-down\n"
16082 " time is specified by the following parameters: year, month, day, hour,\n"
16083 " min, and sec. This function is the inverse of plbtime.\n"
16085 " The PLplot definition of broken-down time is a calendar time that\n"
16086 " completely ignores all time zone offsets, i.e., it is the user's\n"
16087 " responsibility to apply those offsets (if so desired) before using the\n"
16088 " PLplot time API. By default broken-down time is defined using the\n"
16089 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16090 " continuous time is defined as the number of seconds since the Unix\n"
16091 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16092 " broken-down and continuous time are possible, see plconfigtime which\n"
16093 " specifies that transformation for the current stream.\n"
16095 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16097 " Perl/PDL: Not available?\n"
16100 " This function is used in example 29.\n"
16106 "plctime(year, month, day, hour, min, sec, ctime)\n"
16110 " year (PLINT, input) : Input year.\n"
16112 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16115 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16117 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16119 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16121 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16123 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continous\n"
16124 " time calculated from the broken-down time specified by the\n"
16125 " previous parameters.\n"
16128 { (
char *)
"plcpstrm",
_wrap_plcpstrm, METH_VARARGS, (
char *)
"\n"
16129 "Copy state parameters from the reference stream to the current stream\n"
16133 " Copies state parameters from the reference stream to the current\n"
16134 " stream. Tell driver interface to map device coordinates unless flags\n"
16137 " This function is used for making save files of selected plots (e.g.\n"
16138 " from the TK driver). After initializing, you can get a copy of the\n"
16139 " current plot to the specified device by switching to this stream and\n"
16140 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16141 " appropriate. The plot buffer must have previously been enabled (done\n"
16142 " automatically by some display drivers, such as X).\n"
16144 " Redacted form: plcpstrm(iplsr, flags)\n"
16146 " This function is used in example 1,20.\n"
16152 "plcpstrm(iplsr, flags)\n"
16156 " iplsr (PLINT, input) : Number of reference stream.\n"
16158 " flags (PLBOOL, input) : If flags is set to true the device\n"
16159 " coordinates are not copied from the reference to current stream.\n"
16162 { (
char *)
"plend",
_wrap_plend, METH_VARARGS, (
char *)
"\n"
16163 "End plotting session\n"
16167 " Ends a plotting session, tidies up all the output files, switches\n"
16168 " interactive devices back into text mode and frees up any memory that\n"
16169 " was allocated. Must be called before end of program.\n"
16171 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16172 " wait state after a call to plend or other functions which trigger the\n"
16173 " end of a plot page. To avoid this, use the plspause function.\n"
16175 " Redacted form: plend()\n"
16177 " This function is used in all of the examples.\n"
16186 { (
char *)
"plend1",
_wrap_plend1, METH_VARARGS, (
char *)
"\n"
16187 "End plotting session for current stream\n"
16191 " Ends a plotting session for the current output stream only. See\n"
16192 " plsstrm for more info.\n"
16194 " Redacted form: plend1()\n"
16196 " This function is used in examples 1 and 20.\n"
16205 { (
char *)
"plenv",
_wrap_plenv, METH_VARARGS, (
char *)
"\n"
16206 "Set up standard window and draw box\n"
16210 " Sets up plotter environment for simple graphs by calling pladv and\n"
16211 " setting up viewport and window to sensible default values. plenv\n"
16212 " leaves a standard margin (left-hand margin of eight character heights,\n"
16213 " and a margin around the other three sides of five character heights)\n"
16214 " around most graphs for axis labels and a title. When these defaults\n"
16215 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16216 " plvasp for setting up the viewport, plwind for defining the window,\n"
16217 " and plbox for drawing the box.\n"
16219 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16221 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16227 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16231 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16232 " world coordinates).\n"
16234 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16235 " world coordinates).\n"
16237 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16240 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16243 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16244 " scales will not be set, the user must set up the scale before\n"
16245 " calling plenv using plsvpa, plvasp or other.\n"
16246 " 0: the x and y axes are scaled independently to use as much of\n"
16247 " the screen as possible.\n"
16248 " 1: the scales of the x and y axes are made equal.\n"
16249 " 2: the axis of the x and y axes are made equal, and the plot\n"
16250 " box will be square.\n"
16253 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16254 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16255 " -1: draw box only.\n"
16256 " 0: draw box, ticks, and numeric tick labels.\n"
16257 " 1: also draw coordinate axes at x=0 and y=0.\n"
16258 " 2: also draw a grid at major tick positions in both\n"
16260 " 3: also draw a grid at minor tick positions in both\n"
16262 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16263 " have to be converted to logarithms separately.)\n"
16264 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16265 " have to be converted to logarithms separately.)\n"
16266 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16267 " have to be converted to logarithms separately.)\n"
16268 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16269 " have to be converted to logarithms separately.)\n"
16270 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16271 " have to be converted to logarithms separately.)\n"
16272 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16273 " have to be converted to logarithms separately.)\n"
16274 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16275 " have to be converted to logarithms separately.)\n"
16276 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16277 " have to be converted to logarithms separately.)\n"
16278 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16279 " and y data have to be converted to logarithms separately.)\n"
16280 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16281 " and y data have to be converted to logarithms separately.)\n"
16282 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16283 " and y data have to be converted to logarithms separately.)\n"
16284 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16285 " and y data have to be converted to logarithms separately.)\n"
16286 " 40: same as 0 except date / time x labels.\n"
16287 " 41: same as 1 except date / time x labels.\n"
16288 " 42: same as 2 except date / time x labels.\n"
16289 " 43: same as 3 except date / time x labels.\n"
16290 " 50: same as 0 except date / time y labels.\n"
16291 " 51: same as 1 except date / time y labels.\n"
16292 " 52: same as 2 except date / time y labels.\n"
16293 " 53: same as 3 except date / time y labels.\n"
16294 " 60: same as 0 except date / time x and y labels.\n"
16295 " 61: same as 1 except date / time x and y labels.\n"
16296 " 62: same as 2 except date / time x and y labels.\n"
16297 " 63: same as 3 except date / time x and y labels.\n"
16298 " 70: same as 0 except custom x and y labels.\n"
16299 " 71: same as 1 except custom x and y labels.\n"
16300 " 72: same as 2 except custom x and y labels.\n"
16301 " 73: same as 3 except custom x and y labels.\n"
16304 { (
char *)
"plenv0",
_wrap_plenv0, METH_VARARGS, (
char *)
"\n"
16305 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16309 " Sets up plotter environment for simple graphs by calling pladv and\n"
16310 " setting up viewport and window to sensible default values. plenv0\n"
16311 " leaves a standard margin (left-hand margin of eight character heights,\n"
16312 " and a margin around the other three sides of five character heights)\n"
16313 " around most graphs for axis labels and a title. When these defaults\n"
16314 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16315 " plvasp for setting up the viewport, plwind for defining the window,\n"
16316 " and plbox for drawing the box.\n"
16318 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16320 " This function is used in example 21.\n"
16326 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16330 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16331 " world coordinates).\n"
16333 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16334 " world coordinates).\n"
16336 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16339 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16342 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16343 " scales will not be set, the user must set up the scale before\n"
16344 " calling plenv0 using plsvpa, plvasp or other.\n"
16345 " 0: the x and y axes are scaled independently to use as much of\n"
16346 " the screen as possible.\n"
16347 " 1: the scales of the x and y axes are made equal.\n"
16348 " 2: the axis of the x and y axes are made equal, and the plot\n"
16349 " box will be square.\n"
16352 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16353 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16354 " -1: draw box only.\n"
16355 " 0: draw box, ticks, and numeric tick labels.\n"
16356 " 1: also draw coordinate axes at x=0 and y=0.\n"
16357 " 2: also draw a grid at major tick positions in both\n"
16359 " 3: also draw a grid at minor tick positions in both\n"
16361 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16362 " have to be converted to logarithms separately.)\n"
16363 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16364 " have to be converted to logarithms separately.)\n"
16365 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16366 " have to be converted to logarithms separately.)\n"
16367 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16368 " have to be converted to logarithms separately.)\n"
16369 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16370 " have to be converted to logarithms separately.)\n"
16371 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16372 " have to be converted to logarithms separately.)\n"
16373 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16374 " have to be converted to logarithms separately.)\n"
16375 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16376 " have to be converted to logarithms separately.)\n"
16377 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16378 " and y data have to be converted to logarithms separately.)\n"
16379 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16380 " and y data have to be converted to logarithms separately.)\n"
16381 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16382 " and y data have to be converted to logarithms separately.)\n"
16383 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16384 " and y data have to be converted to logarithms separately.)\n"
16385 " 40: same as 0 except date / time x labels.\n"
16386 " 41: same as 1 except date / time x labels.\n"
16387 " 42: same as 2 except date / time x labels.\n"
16388 " 43: same as 3 except date / time x labels.\n"
16389 " 50: same as 0 except date / time y labels.\n"
16390 " 51: same as 1 except date / time y labels.\n"
16391 " 52: same as 2 except date / time y labels.\n"
16392 " 53: same as 3 except date / time y labels.\n"
16393 " 60: same as 0 except date / time x and y labels.\n"
16394 " 61: same as 1 except date / time x and y labels.\n"
16395 " 62: same as 2 except date / time x and y labels.\n"
16396 " 63: same as 3 except date / time x and y labels.\n"
16397 " 70: same as 0 except custom x and y labels.\n"
16398 " 71: same as 1 except custom x and y labels.\n"
16399 " 72: same as 2 except custom x and y labels.\n"
16400 " 73: same as 3 except custom x and y labels.\n"
16403 { (
char *)
"pleop",
_wrap_pleop, METH_VARARGS, (
char *)
"\n"
16404 "Eject current page\n"
16408 " Clears the graphics screen of an interactive device, or ejects a page\n"
16409 " on a plotter. See plbop for more information.\n"
16411 " Redacted form: pleop()\n"
16413 " This function is used in example 2,14.\n"
16422 { (
char *)
"plerrx",
_wrap_plerrx, METH_VARARGS, (
char *)
"\n"
16423 "Draw error bars in x direction\n"
16427 " Draws a set of n error bars in x direction, the i'th error bar\n"
16428 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16429 " of the error bars are of length equal to the minor tick length\n"
16430 " (settable using plsmin).\n"
16432 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16433 " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
16436 " This function is used in example 29.\n"
16442 "plerrx(n, xmin, xmax, y)\n"
16446 " n (PLINT, input) : Number of error bars to draw.\n"
16448 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16449 " of the left-hand endpoints of the error bars.\n"
16451 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16452 " of the right-hand endpoints of the error bars.\n"
16454 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16455 " the error bars.\n"
16458 { (
char *)
"plerry",
_wrap_plerry, METH_VARARGS, (
char *)
"\n"
16459 "Draw error bars in the y direction\n"
16463 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16464 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16465 " of the error bars are of length equal to the minor tick length\n"
16466 " (settable using plsmin).\n"
16468 " Redacted form: General: plerry(x, ymin, ymax)\n"
16469 " Perl/PDL: plerry(n, x, ymin, ymax)\n"
16472 " This function is used in example 29.\n"
16478 "plerry(n, x, ymin, ymax)\n"
16482 " n (PLINT, input) : Number of error bars to draw.\n"
16484 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16485 " the error bars.\n"
16487 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16488 " of the lower endpoints of the error bars.\n"
16490 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16491 " of the upper endpoints of the error bars.\n"
16494 { (
char *)
"plfamadv",
_wrap_plfamadv, METH_VARARGS, (
char *)
"\n"
16495 "Advance to the next family file on the next new page\n"
16499 " Advance to the next family file on the next new page.\n"
16501 " Redacted form: plfamadv()\n"
16503 " This function is not used in any examples.\n"
16512 { (
char *)
"plfill",
_wrap_plfill, METH_VARARGS, (
char *)
"\n"
16513 "Draw filled polygon\n"
16517 " Fills the polygon defined by the n points (\n"
16519 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16520 " style is a solid fill. The routine will automatically close the\n"
16521 " polygon between the last and first vertices. If multiple closed\n"
16522 " polygons are passed in x and y then plfill will fill in between them.\n"
16524 " Redacted form: plfill(x,y)\n"
16526 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16532 "plfill(n, x, y)\n"
16536 " n (PLINT, input) : Number of vertices in polygon.\n"
16538 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16541 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16545 { (
char *)
"plfill3",
_wrap_plfill3, METH_VARARGS, (
char *)
"\n"
16546 "Draw filled polygon in 3D\n"
16550 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16551 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16552 " will automatically close the polygon between the last and first\n"
16553 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16554 " plfill3 will fill in between them.\n"
16556 " Redacted form: General: plfill3(x, y, z)\n"
16557 " Perl/PDL: plfill3(n, x, y, z)\n"
16560 " This function is used in example 15.\n"
16566 "plfill3(n, x, y, z)\n"
16570 " n (PLINT, input) : Number of vertices in polygon.\n"
16572 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16575 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16578 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16583 "Draw linear gradient inside polygon\n"
16587 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16590 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16591 " polygon coordinates and the gradient angle are all expressed in world\n"
16592 " coordinates. The angle from the x axis for both the rotated\n"
16593 " coordinate system and the gradient vector is specified by angle. The\n"
16594 " magnitude of the gradient vector is the difference between the maximum\n"
16595 " and minimum values of x for the vertices in the rotated coordinate\n"
16596 " system. The origin of the gradient vector can be interpreted as being\n"
16597 " anywhere on the line corresponding to the minimum x value for the\n"
16598 " vertices in the rotated coordinate system. The distance along the\n"
16599 " gradient vector is linearly transformed to the independent variable of\n"
16600 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16601 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16602 " color corresponding to the independent variable of cmap1. For more\n"
16603 " information about cmap1 (see the PLplot documentation).\n"
16605 " Redacted form: plgradient(x,y,angle)\n"
16607 " This function is used in examples 25 and 30.\n"
16613 "plgradient(n, x, y, angle)\n"
16617 " n (PLINT, input) : Number of vertices in polygon.\n"
16619 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16622 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16625 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16629 { (
char *)
"plflush",
_wrap_plflush, METH_VARARGS, (
char *)
"\n"
16630 "Flushes the output stream\n"
16634 " Flushes the output stream. Use sparingly, if at all.\n"
16636 " Redacted form: plflush()\n"
16638 " This function is used in examples 1 and 14.\n"
16647 { (
char *)
"plfont",
_wrap_plfont, METH_VARARGS, (
char *)
"\n"
16652 " Sets the font used for subsequent text and symbols. For devices that\n"
16653 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16654 " fonts with extended character set are loaded (see plfontld). For\n"
16655 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16656 " this routine calls the plsfci routine with argument set up\n"
16657 " appropriately for the various cases below. However, this method of\n"
16658 " specifying the font for unicode-aware devices is deprecated, and the\n"
16659 " much more flexible method of calling plsfont directly is recommended\n"
16660 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16662 " Redacted form: plfont(ifont)\n"
16664 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16674 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16675 " (simplest and fastest)\n"
16677 " 3: Italic font\n"
16678 " 4: Script font\n"
16681 { (
char *)
"plfontld",
_wrap_plfontld, METH_VARARGS, (
char *)
"\n"
16682 "Load Hershey fonts\n"
16686 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16687 " be called before or after initializing PLplot. If not explicitly\n"
16688 " called before PLplot initialization, then by default that\n"
16689 " initialization loads Hershey fonts with the extended character set.\n"
16690 " This routine only has a practical effect for devices that still use\n"
16691 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16692 " system fonts instead of Hershey fonts).\n"
16694 " Redacted form: plfontld(fnt)\n"
16696 " This function is used in examples 1 and 7.\n"
16706 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16707 " A zero value specifies Hershey fonts with the standard character\n"
16708 " set and a non-zero value (the default assumed if plfontld is never\n"
16709 " called) specifies Hershey fonts with the extended character set.\n"
16712 { (
char *)
"plgchr",
_wrap_plgchr, METH_VARARGS, (
char *)
"\n"
16713 "Get character default height and current (scaled) height\n"
16717 " Get character default height and current (scaled) height.\n"
16719 " Redacted form: plgchr(p_def, p_ht)\n"
16721 " This function is used in example 23.\n"
16727 "plgchr(p_def, p_ht)\n"
16731 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16732 " character height (mm).\n"
16734 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16735 " character height (mm).\n"
16738 { (
char *)
"plgcol0",
_wrap_plgcol0, METH_VARARGS, (
char *)
"\n"
16739 "Returns 8-bit RGB values for given color index from cmap0\n"
16743 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16744 " PLplot documentation). Values are negative if an invalid color id is\n"
16747 " Redacted form: plgcol0(icol0, r, g, b)\n"
16749 " This function is used in example 2.\n"
16755 "plgcol0(icol0, r, g, b)\n"
16759 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16761 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16764 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16767 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16771 { (
char *)
"plgcol0a",
_wrap_plgcol0a, METH_VARARGS, (
char *)
"\n"
16772 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16776 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16777 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16778 " Values are negative if an invalid color id is given.\n"
16780 " Redacted form: plgcola(r, g, b)\n"
16782 " This function is used in example 30.\n"
16788 "plgcol0a(icol0, r, g, b, alpha)\n"
16792 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16794 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16795 " in the range from 0 to 255.\n"
16797 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16798 " in the range from 0 to 255.\n"
16800 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16801 " in the range from 0 to 255.\n"
16803 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16804 " transparency in the range from (0.0-1.0).\n"
16807 { (
char *)
"plgcolbg",
_wrap_plgcolbg, METH_VARARGS, (
char *)
"\n"
16808 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16812 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16814 " Redacted form: plgcolbg(r, g, b)\n"
16816 " This function is used in example 31.\n"
16822 "plgcolbg(r, g, b)\n"
16826 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16827 " in the range from 0 to 255.\n"
16829 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16830 " in the range from 0 to 255.\n"
16832 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16833 " in the range from 0 to 255.\n"
16837 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16841 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16842 " alpha transparency value.\n"
16844 " This function is used in example 31.\n"
16850 "plgcolbga(r, g, b, alpha)\n"
16854 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16855 " in the range from 0 to 255.\n"
16857 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16858 " in the range from 0 to 255.\n"
16860 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16861 " in the range from 0 to 255.\n"
16863 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16864 " transparency in the range (0.0-1.0).\n"
16868 "Get the current device-compression setting\n"
16872 " Get the current device-compression setting. This parameter is only\n"
16873 " used for drivers that provide compression.\n"
16875 " Redacted form: plgcompression(compression)\n"
16877 " This function is used in example 31.\n"
16883 "plgcompression(compression)\n"
16887 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16888 " compression setting for the current device.\n"
16891 { (
char *)
"plgdev",
_wrap_plgdev, METH_VARARGS, (
char *)
"\n"
16892 "Get the current device (keyword) name\n"
16896 " Get the current device (keyword) name. Note: you must have allocated\n"
16897 " space for this (80 characters is safe).\n"
16899 " Redacted form: plgdev(p_dev)\n"
16901 " This function is used in example 14.\n"
16911 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16912 " (with preallocated length of 80 characters or more) containing the\n"
16913 " device (keyword) name.\n"
16916 { (
char *)
"plgdidev",
_wrap_plgdidev, METH_VARARGS, (
char *)
"\n"
16917 "Get parameters that define current device-space window\n"
16921 " Get relative margin width, aspect ratio, and relative justification\n"
16922 " that define current device-space window. If plsdidev has not been\n"
16923 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16924 " p_jy will all be 0.\n"
16926 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16928 " This function is used in example 31.\n"
16934 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16938 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16941 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16944 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16945 " justification in x.\n"
16947 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16948 " justification in y.\n"
16951 { (
char *)
"plgdiori",
_wrap_plgdiori, METH_VARARGS, (
char *)
"\n"
16952 "Get plot orientation\n"
16956 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16957 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16958 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16959 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16960 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16961 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16962 " not been called the default value pointed to by p_rot will be 0.\n"
16964 " Redacted form: plgdiori(p_rot)\n"
16966 " This function is not used in any examples.\n"
16972 "plgdiori(p_rot)\n"
16976 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16980 { (
char *)
"plgdiplt",
_wrap_plgdiplt, METH_VARARGS, (
char *)
"\n"
16981 "Get parameters that define current plot-space window\n"
16985 " Get relative minima and maxima that define current plot-space window.\n"
16986 " If plsdiplt has not been called the default values pointed to by\n"
16987 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16989 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16991 " This function is used in example 31.\n"
16997 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17001 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17004 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17007 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17010 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17014 { (
char *)
"plgfam",
_wrap_plgfam, METH_VARARGS, (
char *)
"\n"
17015 "Get family file parameters\n"
17019 " Gets information about current family file, if familying is enabled.\n"
17020 " See the PLplot documentation for more information.\n"
17022 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17024 " This function is used in examples 14 and 31.\n"
17030 "plgfam(p_fam, p_num, p_bmax)\n"
17034 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17035 " family flag value. If nonzero, familying is enabled for the\n"
17036 " current device.\n"
17038 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17039 " family file number.\n"
17041 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17042 " file size (in bytes) for a family file.\n"
17045 { (
char *)
"plgfci",
_wrap_plgfci, METH_VARARGS, (
char *)
"\n"
17046 "Get FCI (font characterization integer)\n"
17050 " Gets information about the current font using the FCI approach. See\n"
17051 " the PLplot documentation for more information.\n"
17053 " Redacted form: plgfci(p_fci)\n"
17055 " This function is used in example 23.\n"
17065 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17069 { (
char *)
"plgfnam",
_wrap_plgfnam, METH_VARARGS, (
char *)
"\n"
17070 "Get output file name\n"
17074 " Gets the current output file name, if applicable.\n"
17076 " Redacted form: plgfnam(fnam)\n"
17078 " This function is used in example 31.\n"
17088 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17089 " (with preallocated length of 80 characters or more) containing the\n"
17093 { (
char *)
"plgfont",
_wrap_plgfont, METH_VARARGS, (
char *)
"\n"
17094 "Get family, style and weight of the current font\n"
17098 " Gets information about current font. See the PLplot documentation for\n"
17099 " more information on font selection.\n"
17101 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17103 " This function is used in example 23.\n"
17109 "plgfont(p_family, p_style, p_weight)\n"
17113 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17114 " font family. The available values are given by the PL_FCI_*\n"
17115 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17116 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17117 " p_family is NULL then the font family is not returned.\n"
17119 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17120 " font style. The available values are given by the PL_FCI_*\n"
17121 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17122 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17123 " style is not returned.\n"
17125 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17126 " font weight. The available values are given by the PL_FCI_*\n"
17127 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17128 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17132 { (
char *)
"plglevel",
_wrap_plglevel, METH_VARARGS, (
char *)
"\n"
17133 "Get the (current) run level\n"
17137 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17138 " 1, initialized\n"
17139 " 2, viewport defined\n"
17140 " 3, world coordinates defined\n"
17143 " Redacted form: plglevel(p_level)\n"
17145 " This function is used in example 31.\n"
17151 "plglevel(p_level)\n"
17155 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17159 { (
char *)
"plgpage",
_wrap_plgpage, METH_VARARGS, (
char *)
"\n"
17160 "Get page parameters\n"
17164 " Gets the current page configuration. The length and offset values are\n"
17165 " expressed in units that are specific to the current driver. For\n"
17166 " instance: screen drivers will usually interpret them as number of\n"
17167 " pixels, whereas printer drivers will usually use mm.\n"
17169 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17171 " This function is used in examples 14 and 31.\n"
17177 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17181 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17182 " pixels/inch (DPI) in x.\n"
17184 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17185 " pixels/inch (DPI) in y.\n"
17187 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17190 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17193 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17196 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17200 { (
char *)
"plgra",
_wrap_plgra, METH_VARARGS, (
char *)
"\n"
17201 "Switch to graphics screen\n"
17205 " Sets an interactive device to graphics mode, used in conjunction with\n"
17206 " pltext to allow graphics and text to be interspersed. On a device\n"
17207 " which supports separate text and graphics windows, this command causes\n"
17208 " control to be switched to the graphics window. If already in graphics\n"
17209 " mode, this command is ignored. It is also ignored on devices which\n"
17210 " only support a single window or use a different method for shifting\n"
17211 " focus. See also pltext.\n"
17213 " Redacted form: plgra()\n"
17215 " This function is used in example 1.\n"
17225 "Grid data from irregularly sampled data\n"
17229 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17230 " require data organized as a grid, i.e., with x sample point values\n"
17231 " independent of y coordinate and vice versa. This function takes\n"
17232 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17233 " vectors; reads the desired grid location from the input vectors\n"
17234 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17235 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17236 " interpolate the data to the grid is specified with the argument type\n"
17237 " which can have one parameter specified in argument data.\n"
17239 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17240 " Perl/PDL: Not available?\n"
17241 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17244 " This function is used in example 21.\n"
17250 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17254 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17256 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17258 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17259 " y[i], z[i] represents one data sample coordinate.\n"
17261 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17264 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17265 " in the x direction. Usually xg has nptsx equally spaced values\n"
17266 " from the minimum to the maximum values of the x input vector.\n"
17268 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17270 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17271 " in the y direction. Similar to the xg parameter.\n"
17273 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17275 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17276 " where data lies in the grid specified by xg and yg. Therefore the\n"
17277 " zg matrix must be dimensioned\n"
17281 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17282 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17283 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17284 " GRID_NNI: Natural Neighbors Interpolation\n"
17285 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17286 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17287 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17289 " For details of the algorithms read the source file plgridd.c.\n"
17291 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17292 " which can be specified through this argument. Currently, for\n"
17293 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17294 " use, the lower the value, the noisier (more local) the\n"
17295 " approximation is.\n"
17296 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17297 " range [1. .. 2.]. High values enable the usage of very thin\n"
17298 " triangles for interpolation, possibly resulting in error in\n"
17299 " the approximation.\n"
17300 " GRID_NNI, only weights greater than data will be accepted. If\n"
17301 " 0, all weights will be accepted.\n"
17304 { (
char *)
"plgspa",
_wrap_plgspa, METH_VARARGS, (
char *)
"\n"
17305 "Get current subpage parameters\n"
17309 " Gets the size of the current subpage in millimeters measured from the\n"
17310 " bottom left hand corner of the output device page or screen. Can be\n"
17311 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17312 " absolute coordinates (millimeters).\n"
17314 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17316 " This function is used in example 23.\n"
17322 "plgspa(xmin, xmax, ymin, ymax)\n"
17326 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17327 " the left hand edge of the subpage in millimeters.\n"
17329 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17330 " the right hand edge of the subpage in millimeters.\n"
17332 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17333 " the bottom edge of the subpage in millimeters.\n"
17335 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17336 " the top edge of the subpage in millimeters.\n"
17339 { (
char *)
"plgstrm",
_wrap_plgstrm, METH_VARARGS, (
char *)
"\n"
17340 "Get current stream number\n"
17344 " Gets the number of the current output stream. See also plsstrm.\n"
17346 " Redacted form: plgstrm(p_strm)\n"
17348 " This function is used in example 1,20.\n"
17354 "plgstrm(p_strm)\n"
17358 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17362 { (
char *)
"plgver",
_wrap_plgver, METH_VARARGS, (
char *)
"\n"
17363 "Get the current library version number\n"
17367 " Get the current library version number. Note: you must have allocated\n"
17368 " space for this (80 characters is safe).\n"
17370 " Redacted form: plgver(p_ver)\n"
17372 " This function is used in example 1.\n"
17382 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17383 " (with preallocated length of 80 characters or more) containing the\n"
17384 " PLplot version number.\n"
17387 { (
char *)
"plgvpd",
_wrap_plgvpd, METH_VARARGS, (
char *)
"\n"
17388 "Get viewport limits in normalized device coordinates\n"
17392 " Get viewport limits in normalized device coordinates.\n"
17394 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17395 " Perl/PDL: Not available?\n"
17398 " This function is used in example 31.\n"
17404 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17408 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17409 " viewport limit of the normalized device coordinate in x.\n"
17411 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17412 " viewport limit of the normalized device coordinate in x.\n"
17414 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17415 " viewport limit of the normalized device coordinate in y.\n"
17417 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17418 " viewport limit of the normalized device coordinate in y.\n"
17421 { (
char *)
"plgvpw",
_wrap_plgvpw, METH_VARARGS, (
char *)
"\n"
17422 "Get viewport limits in world coordinates\n"
17426 " Get viewport limits in world coordinates.\n"
17428 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17429 " Perl/PDL: Not available?\n"
17432 " This function is used in example 31.\n"
17438 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17442 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17443 " viewport limit of the world coordinate in x.\n"
17445 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17446 " viewport limit of the world coordinate in x.\n"
17448 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17449 " viewport limit of the world coordinate in y.\n"
17451 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17452 " viewport limit of the world coordinate in y.\n"
17455 { (
char *)
"plgxax",
_wrap_plgxax, METH_VARARGS, (
char *)
"\n"
17456 "Get x axis parameters\n"
17460 " Returns current values of the p_digmax and p_digits flags for the x\n"
17461 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17462 " should only be called after the call to plbox (or plbox3) is complete.\n"
17463 " See the PLplot documentation for more information.\n"
17465 " Redacted form: plgxax(p_digmax, p_digits)\n"
17467 " This function is used in example 31.\n"
17473 "plgxax(p_digmax, p_digits)\n"
17477 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17478 " number of digits for the x axis. If nonzero, the printed label\n"
17479 " has been switched to a floating-point representation when the\n"
17480 " number of digits exceeds this value.\n"
17482 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17483 " number of digits for the numeric labels (x axis) from the last\n"
17487 { (
char *)
"plgyax",
_wrap_plgyax, METH_VARARGS, (
char *)
"\n"
17488 "Get y axis parameters\n"
17492 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17493 " the description of plgxax for more detail.\n"
17495 " Redacted form: plgyax(p_digmax, p_digits)\n"
17497 " This function is used in example 31.\n"
17503 "plgyax(p_digmax, p_digits)\n"
17507 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17508 " number of digits for the y axis. If nonzero, the printed label\n"
17509 " has been switched to a floating-point representation when the\n"
17510 " number of digits exceeds this value.\n"
17512 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17513 " number of digits for the numeric labels (y axis) from the last\n"
17517 { (
char *)
"plgzax",
_wrap_plgzax, METH_VARARGS, (
char *)
"\n"
17518 "Get z axis parameters\n"
17522 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17523 " the description of plgxax for more detail.\n"
17525 " Redacted form: plgzax(p_digmax, p_digits)\n"
17527 " This function is used in example 31.\n"
17533 "plgzax(p_digmax, p_digits)\n"
17537 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17538 " number of digits for the z axis. If nonzero, the printed label\n"
17539 " has been switched to a floating-point representation when the\n"
17540 " number of digits exceeds this value.\n"
17542 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17543 " number of digits for the numeric labels (z axis) from the last\n"
17547 { (
char *)
"plhist",
_wrap_plhist, METH_VARARGS, (
char *)
"\n"
17548 "Plot a histogram from unbinned data\n"
17552 " Plots a histogram from n data points stored in the data vector. This\n"
17553 " routine bins the data into nbin bins equally spaced between datmin and\n"
17554 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17555 " opt allows, among other things, the histogram either to be plotted in\n"
17556 " an existing window or causes plhist to call plenv with suitable limits\n"
17557 " before plotting the histogram.\n"
17559 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17561 " This function is used in example 5.\n"
17567 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17571 " n (PLINT, input) : Number of data points.\n"
17573 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17574 " n data points.\n"
17576 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17578 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17580 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17581 " divide the interval xmin to xmax.\n"
17583 " opt (PLINT, input) : Is a combination of several flags:\n"
17584 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17585 " the histogram data, the outer bins are expanded to fill up the\n"
17586 " entire x-axis, data outside the given extremes are assigned to the\n"
17587 " outer bins and bins of zero height are simply drawn.\n"
17588 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17589 " to fit the histogram data, without this flag, plenv is called\n"
17590 " to set the world coordinates.\n"
17591 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17592 " extremes are not taken into account. This option should\n"
17593 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17594 " properly present the data.\n"
17595 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17596 " size as the ones inside.\n"
17597 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17598 " (there is a gap for such bins).\n"
17601 { (
char *)
"plhlsrgb",
_wrap_plhlsrgb, METH_VARARGS, (
char *)
"\n"
17602 "Convert HLS color to RGB\n"
17606 " Convert HLS color coordinates to RGB.\n"
17608 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17609 " Perl/PDL: Not available? Implemented as plhls?\n"
17612 " This function is used in example 2.\n"
17618 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17622 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17625 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17626 " the axis of the color cylinder.\n"
17628 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17629 " the radius of the color cylinder.\n"
17631 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17632 " (0.0-1.0) of the color.\n"
17634 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17635 " intensity (0.0-1.0) of the color.\n"
17637 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17638 " intensity (0.0-1.0) of the color.\n"
17641 { (
char *)
"plinit",
_wrap_plinit, METH_VARARGS, (
char *)
"\n"
17642 "Initialize PLplot\n"
17646 " Initializing the plotting package. The program prompts for the device\n"
17647 " keyword or number of the desired output device. Hitting a RETURN in\n"
17648 " response to the prompt is the same as selecting the first device.\n"
17649 " plinit will issue no prompt if either the device was specified\n"
17650 " previously (via command line flag, the plsetopt function, or the\n"
17651 " plsdev function), or if only one device is enabled when PLplot is\n"
17652 " installed. If subpages have been specified, the output device is\n"
17653 " divided into nx by ny subpages, each of which may be used\n"
17654 " independently. If plinit is called again during a program, the\n"
17655 " previously opened file will be closed. The subroutine pladv is used\n"
17656 " to advance from one subpage to the next.\n"
17658 " Redacted form: plinit()\n"
17660 " This function is used in all of the examples.\n"
17669 { (
char *)
"pljoin",
_wrap_pljoin, METH_VARARGS, (
char *)
"\n"
17670 "Draw a line between two points\n"
17674 " Joins the point (\n"
17680 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17682 " This function is used in examples 3 and 14.\n"
17688 "pljoin(x1, y1, x2, y2)\n"
17692 " x1 (PLFLT, input) : x coordinate of first point.\n"
17694 " y1 (PLFLT, input) : y coordinate of first point.\n"
17696 " x2 (PLFLT, input) : x coordinate of second point.\n"
17698 " y2 (PLFLT, input) : y coordinate of second point.\n"
17701 { (
char *)
"pllab",
_wrap_pllab, METH_VARARGS, (
char *)
"\n"
17702 "Simple routine to write labels\n"
17706 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17708 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17710 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17716 "pllab(xlabel, ylabel, tlabel)\n"
17720 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17721 " the label for the x axis.\n"
17723 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17724 " the label for the y axis.\n"
17726 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17727 " the title of the plot.\n"
17730 { (
char *)
"pllegend",
_wrap_pllegend, METH_VARARGS, (
char *)
"\n"
17731 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17735 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17736 " line, and/or line of symbols for each annotated legend entry. (See\n"
17737 " plcolorbar for similar functionality for creating continuous color\n"
17738 " bars.) The arguments of pllegend provide control over the location\n"
17739 " and size of the legend as well as the location and characteristics of\n"
17740 " the elements (most of which are optional) within that legend. The\n"
17741 " resulting legend is clipped at the boundaries of the current subpage.\n"
17742 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17743 " defined in the documentation of the position parameter.)\n"
17745 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17746 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17747 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17748 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17749 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17750 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17752 " This function is used in examples 4, 26, and 33.\n"
17758 "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"
17762 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17763 " legend width in adopted coordinates. This quantity is calculated\n"
17764 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17765 " the routine depending on nlegend and nrow), and the length\n"
17766 " (calculated internally) of the longest text string.\n"
17768 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17769 " legend height in adopted coordinates. This quantity is calculated\n"
17770 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17771 " the routine depending on nlegend and nrow).\n"
17773 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17774 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17775 " on the left of the legend and the plotted area on the right.\n"
17776 " Otherwise, put the text area on the right of the legend and the\n"
17777 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17778 " plot a (semitransparent) background for the legend. If the\n"
17779 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17780 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17781 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17782 " plot the resulting array of legend entries in row-major order.\n"
17783 " Otherwise, plot the legend entries in column-major order.\n"
17785 " position (PLINT, input) : position contains bits which control the\n"
17786 " overall position of the legend and the definition of the adopted\n"
17787 " coordinates used for positions just like what is done for the\n"
17788 " position argument for plcolorbar. However, note that the defaults\n"
17789 " for the position bits (see below) are different than the\n"
17790 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17791 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17792 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17793 " the 16 possible standard positions (the 4 corners and centers of\n"
17794 " the 4 sides for both the inside and outside cases) of the legend\n"
17795 " relative to the adopted coordinate system. The corner positions\n"
17796 " are specified by the appropriate combination of two of the\n"
17797 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17798 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17799 " value of one of those bits. The adopted coordinates are\n"
17800 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17801 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17802 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17803 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17804 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17805 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17806 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17807 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17809 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17810 " coordinates from the specified standard position of the legend.\n"
17811 " For positive x, the direction of motion away from the standard\n"
17812 " position is inward/outward from the standard corner positions or\n"
17813 " standard left or right positions if the\n"
17814 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17815 " For the standard top or bottom positions, the direction of motion\n"
17816 " is toward positive X.\n"
17818 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17819 " coordinates from the specified standard position of the legend.\n"
17820 " For positive y, the direction of motion away from the standard\n"
17821 " position is inward/outward from the standard corner positions or\n"
17822 " standard top or bottom positions if the\n"
17823 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17824 " the standard left or right positions, the direction of motion is\n"
17825 " toward positive Y.\n"
17827 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17828 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17829 " symbols are drawn) of the legend.\n"
17831 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17832 " legend (PL_LEGEND_BACKGROUND).\n"
17834 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17835 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17837 " bb_style (PLINT, input) : The pllsty style number for the\n"
17838 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17840 " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17841 " the legend (PL_LEGEND_BACKGROUND).\n"
17843 " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17844 " for the legend (PL_LEGEND_BACKGROUND).\n"
17846 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17847 " vertical height of the legend in adopted coordinates is calculated\n"
17848 " internally from nlegend, text_scale (see below), and text_spacing\n"
17851 " opt_array (PLINT_VECTOR, input) : A vector of\n"
17852 " nlegend values of options to control each individual plotted area\n"
17853 " corresponding to a legend entry. If the\n"
17854 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17856 " PL_LEGEND_COLOR_BOX,\n"
17857 " PL_LEGEND_LINE, and/or\n"
17858 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17859 " entry is plotted with a colored box; a line; and/or a line of\n"
17862 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17863 " area in units of character width. N.B. The total horizontal\n"
17864 " width of the legend in adopted coordinates is calculated\n"
17865 " internally from\n"
17866 " plot_width (see above),\n"
17867 " text_offset, and length (calculated internally) of the longest text\n"
17870 " text_scale (PLFLT, input) : Character height scale for text\n"
17871 " annotations. N.B. The total vertical height of the legend in\n"
17872 " adopted coordinates is calculated internally from\n"
17873 " nlegend (see above),\n"
17874 " text_scale, and\n"
17875 " text_spacing (see below).\n"
17877 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17878 " character height from one legend entry to the next. N.B. The\n"
17879 " total vertical height of the legend in adopted coordinates is\n"
17880 " calculated internally from\n"
17881 " nlegend (see above),\n"
17882 " text_scale (see above), and\n"
17885 " text_justification (PLFLT, input) : Justification parameter used\n"
17886 " for text justification. The most common values of\n"
17887 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17888 " is left justified, centred, or right justified within the text\n"
17889 " area, but other values are allowed as well.\n"
17891 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17892 " nlegend cmap0 text colors.\n"
17894 " text (PLCHAR_MATRIX, input) : A vector of\n"
17895 " nlegend UTF-8 character strings containing the legend annotations.\n"
17897 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17898 " nlegend cmap0 colors for the discrete colored boxes (\n"
17899 " PL_LEGEND_COLOR_BOX).\n"
17901 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17902 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17903 " PL_LEGEND_COLOR_BOX).\n"
17905 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17906 " nlegend scales (units of fraction of character height) for the height\n"
17907 " of the discrete colored boxes (\n"
17908 " PL_LEGEND_COLOR_BOX).\n"
17910 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17911 " nlegend line widths for the patterns specified by box_patterns (\n"
17912 " PL_LEGEND_COLOR_BOX).\n"
17914 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17915 " nlegend cmap0 line colors (\n"
17916 " PL_LEGEND_LINE).\n"
17918 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17919 " nlegend line styles (plsty indices) (\n"
17920 " PL_LEGEND_LINE).\n"
17922 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17923 " nlegend line widths (\n"
17924 " PL_LEGEND_LINE).\n"
17926 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17927 " nlegend cmap0 symbol colors (\n"
17928 " PL_LEGEND_SYMBOL).\n"
17930 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17931 " nlegend scale values for the symbol height (\n"
17932 " PL_LEGEND_SYMBOL).\n"
17934 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17935 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17937 " PL_LEGEND_SYMBOL).\n"
17939 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17940 " nlegend UTF-8 character strings containing the legend symbols. (\n"
17941 " PL_LEGEND_SYMBOL).\n"
17945 "Plot color bar for image, shade or gradient plots\n"
17949 " Routine for creating a continuous color bar for image, shade, or\n"
17950 " gradient plots. (See pllegend for similar functionality for creating\n"
17951 " legends with discrete elements). The arguments of plcolorbar provide\n"
17952 " control over the location and size of the color bar as well as the\n"
17953 " location and characteristics of the elements (most of which are\n"
17954 " optional) within that color bar. The resulting color bar is clipped\n"
17955 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17956 " system used for some of the parameters is defined in the documentation\n"
17957 " of the position parameter.)\n"
17959 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17960 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17961 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17962 " labels, axis_opts, ticks, sub_ticks, values)\n"
17964 " This function is used in examples 16 and 33.\n"
17970 "plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n"
17974 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17975 " labelled and decorated color bar width in adopted coordinates.\n"
17977 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17978 " labelled and decorated color bar height in adopted coordinates.\n"
17980 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17981 " color bar. The orientation (direction of the maximum value) of\n"
17982 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17983 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17984 " specified, the default orientation is toward the top if the\n"
17985 " colorbar is placed on the left or right of the viewport or toward\n"
17986 " the right if the colorbar is placed on the top or bottom of the\n"
17987 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17988 " (semitransparent) background for the color bar. If the\n"
17989 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17990 " color bar. The type of color bar must be specified with one of\n"
17991 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17992 " more than one of those bits is set only the first one in the above\n"
17993 " list is honored. The position of the (optional) label/title can be\n"
17994 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17995 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17996 " will be drawn. If more than one of this list of bits is specified,\n"
17997 " only the first one on the list is honored. End-caps for the color\n"
17998 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17999 " If a particular color bar cap option is not specified then no cap\n"
18000 " will be drawn for that end. As a special case for\n"
18001 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18002 " specified. If this option is provided then any tick marks and tick\n"
18003 " labels will be placed at the breaks between shaded segments. TODO:\n"
18004 " This should be expanded to support custom placement of tick marks\n"
18005 " and tick labels at custom value locations for any color bar type.\n"
18007 " position (PLINT, input) : position contains bits which control the\n"
18008 " overall position of the color bar and the definition of the\n"
18009 " adopted coordinates used for positions just like what is done for\n"
18010 " the position argument for pllegend. However, note that the\n"
18011 " defaults for the position bits (see below) are different than the\n"
18012 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18013 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18014 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18015 " the 16 possible standard positions (the 4 corners and centers of\n"
18016 " the 4 sides for both the inside and outside cases) of the color\n"
18017 " bar relative to the adopted coordinate system. The corner\n"
18018 " positions are specified by the appropriate combination of two of\n"
18019 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18020 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18021 " value of one of those bits. The adopted coordinates are\n"
18022 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18023 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18024 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18025 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18026 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18027 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18028 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18029 " PL_POSITION_VIEWPORT.\n"
18031 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18032 " coordinates from the specified standard position of the color bar.\n"
18033 " For positive x, the direction of motion away from the standard\n"
18034 " position is inward/outward from the standard corner positions or\n"
18035 " standard left or right positions if the\n"
18036 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18037 " For the standard top or bottom positions, the direction of motion\n"
18038 " is toward positive X.\n"
18040 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18041 " coordinates from the specified standard position of the color bar.\n"
18042 " For positive y, the direction of motion away from the standard\n"
18043 " position is inward/outward from the standard corner positions or\n"
18044 " standard top or bottom positions if the\n"
18045 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18046 " For the standard left or right positions, the direction of motion\n"
18047 " is toward positive Y.\n"
18049 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18050 " the X direction in adopted coordinates.\n"
18052 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18053 " the Y direction in adopted coordinates.\n"
18055 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18056 " color bar (PL_COLORBAR_BACKGROUND).\n"
18058 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18059 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18061 " bb_style (PLINT, input) : The pllsty style number for the\n"
18062 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18064 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18065 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18067 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18068 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18070 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18071 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18072 " it will be interpreted according to the design of plshades.\n"
18074 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18075 " plots. This is passed directly to plshades, so it will be\n"
18076 " interpreted according to the design of plshades.\n"
18078 " n_labels (PLINT, input) : Number of labels to place around the\n"
18081 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18082 " n_labels labels.\n"
18084 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18085 " n_labels UTF-8 character strings containing the labels for the color\n"
18086 " bar. Ignored if no label position is specified with one of the\n"
18087 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18088 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18089 " corresponding label_opts field.\n"
18091 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18092 " value must be greater than 0. It is typically 1 (numerical axis\n"
18093 " labels are provided for one of the long edges of the color bar),\n"
18094 " but it can be larger if multiple numerical axis labels for the\n"
18095 " long edges of the color bar are desired.\n"
18097 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18098 " n_axes ascii character strings containing options (interpreted as for\n"
18099 " plbox) for the color bar's axis definitions.\n"
18101 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18102 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18103 " color bar's axis definitions.\n"
18105 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18106 " number of subticks (interpreted as for plbox) for the color bar's\n"
18107 " axis definitions.\n"
18109 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18110 " elements in each of the n_axes rows of the values matrix.\n"
18112 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18113 " values for the data range represented by the color bar. For a row\n"
18114 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18115 " elements in the row is specified by n_values[i_axis]. For\n"
18116 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18117 " is 2, and the corresponding row elements of the values matrix are\n"
18118 " the minimum and maximum value represented by the colorbar. For\n"
18119 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18120 " of the values matrix is interpreted the same as the nlevel and\n"
18121 " clevel arguments of plshades.\n"
18125 "Sets the 3D position of the light source\n"
18129 " Sets the 3D position of the light source for use with plsurf3d and\n"
18132 " Redacted form: pllightsource(x, y, z)\n"
18134 " This function is used in example 8.\n"
18140 "pllightsource(x, y, z)\n"
18144 " x (PLFLT, input) : X-coordinate of the light source.\n"
18146 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18148 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18151 { (
char *)
"plline",
_wrap_plline, METH_VARARGS, (
char *)
"\n"
18156 " Draws line defined by n points in x and y.\n"
18158 " Redacted form: plline(x, y)\n"
18160 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18161 " 25-27, and 29.\n"
18167 "plline(n, x, y)\n"
18171 " n (PLINT, input) : Number of points defining line.\n"
18173 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18176 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18180 { (
char *)
"plline3",
_wrap_plline3, METH_VARARGS, (
char *)
"\n"
18181 "Draw a line in 3 space\n"
18185 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18186 " first set up the viewport, the 2d viewing window (in world\n"
18187 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18190 " Redacted form: plline3(x, y, z)\n"
18192 " This function is used in example 18.\n"
18198 "plline3(n, x, y, z)\n"
18202 " n (PLINT, input) : Number of points defining line.\n"
18204 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18207 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18210 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18214 { (
char *)
"pllsty",
_wrap_pllsty, METH_VARARGS, (
char *)
"\n"
18215 "Select line style\n"
18219 " This sets the line style according to one of eight predefined patterns\n"
18220 " (also see plstyl).\n"
18222 " Redacted form: pllsty(lin)\n"
18224 " This function is used in examples 9, 12, 22, and 25.\n"
18234 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18235 " a continuous line, line style 2 is a line with short dashes and\n"
18236 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18237 " 4 has long dashes and short gaps and so on.\n"
18240 { (
char *)
"plmesh",
_wrap_plmesh, METH_VARARGS, (
char *)
"\n"
18241 "Plot surface mesh\n"
18245 " Plots a surface mesh within the environment set up by plw3d. The\n"
18246 " surface is defined by the matrix z[\n"
18248 " ny] , the point z[i][j] being the value of the function at (\n"
18250 " y[j]). Note that the points in vectors x and y do not need to be\n"
18251 " equally spaced, but must be stored in ascending order. The parameter\n"
18252 " opt controls the way in which the surface is displayed. For further\n"
18253 " details see the PLplot documentation.\n"
18255 " Redacted form: plmesh(x, y, z, opt)\n"
18257 " This function is used in example 11.\n"
18263 "plmesh(x, y, z, nx, ny, opt)\n"
18267 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18268 " which the function is evaluated.\n"
18270 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18271 " which the function is evaluated.\n"
18273 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18274 " plot. Should have dimensions of\n"
18278 " nx (PLINT, input) : Number of x values at which function has been\n"
18281 " ny (PLINT, input) : Number of y values at which function has been\n"
18284 " opt (PLINT, input) : Determines the way in which the surface is\n"
18285 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18286 " function of x for each value of y[j] .\n"
18287 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18288 " for each value of x[i] .\n"
18289 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18290 " at which function is defined.\n"
18293 { (
char *)
"plmeshc",
_wrap_plmeshc, METH_VARARGS, (
char *)
"\n"
18294 "Magnitude colored plot surface mesh with contour\n"
18298 " A more powerful form of plmesh: the surface mesh can be colored\n"
18299 " accordingly to the current z value being plotted, a contour plot can\n"
18300 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18301 " plotted function border and the base XY plane.\n"
18303 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18305 " This function is used in example 11.\n"
18311 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18315 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18316 " which the function is evaluated.\n"
18318 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18319 " which the function is evaluated.\n"
18321 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18322 " plot. Should have dimensions of\n"
18326 " nx (PLINT, input) : Number of x values at which function is\n"
18329 " ny (PLINT, input) : Number of y values at which function is\n"
18332 " opt (PLINT, input) : Determines the way in which the surface is\n"
18333 " represented. To specify more than one option just add the options,\n"
18334 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18335 " showing z as a function of x for each value of y[j] .\n"
18336 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18337 " for each value of x[i] .\n"
18338 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18339 " at which function is defined.\n"
18340 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18341 " the z value being plotted. The color is used from the current\n"
18343 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18344 " using parameters\n"
18347 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18348 " the borders of the plotted function.\n"
18351 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18354 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18357 { (
char *)
"plmkstrm",
_wrap_plmkstrm, METH_VARARGS, (
char *)
"\n"
18358 "Creates a new stream and makes it the default\n"
18362 " Creates a new stream and makes it the default. Differs from using\n"
18363 " plsstrm, in that a free stream number is found, and returned.\n"
18364 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18365 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18366 " that no initial, library-opening call is required. So stream 0 must\n"
18367 " be preallocated, and there is no simple way of determining whether it\n"
18368 " is already in use or not.\n"
18370 " Redacted form: plmkstrm(p_strm)\n"
18372 " This function is used in examples 1 and 20.\n"
18378 "plmkstrm(p_strm)\n"
18382 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18383 " number of the created stream.\n"
18386 { (
char *)
"plmtex",
_wrap_plmtex, METH_VARARGS, (
char *)
"\n"
18387 "Write text relative to viewport boundaries\n"
18391 " Writes text at a specified position relative to the viewport\n"
18392 " boundaries. Text may be written inside or outside the viewport, but\n"
18393 " is clipped at the subpage boundaries. The reference point of a string\n"
18394 " lies along a line passing through the string at half the height of a\n"
18395 " capital letter. The position of the reference point along this line\n"
18396 " is determined by just, and the position of the reference point\n"
18397 " relative to the viewport is set by disp and pos.\n"
18399 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18400 " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
18403 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18410 "plmtex(side, disp, pos, just, text)\n"
18414 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18415 " the side of the viewport along which the text is to be written.\n"
18416 " The string must be one of: b: Bottom of viewport, text written\n"
18417 " parallel to edge.\n"
18418 " bv: Bottom of viewport, text written at right angles to edge.\n"
18419 " l: Left of viewport, text written parallel to edge.\n"
18420 " lv: Left of viewport, text written at right angles to edge.\n"
18421 " r: Right of viewport, text written parallel to edge.\n"
18422 " rv: Right of viewport, text written at right angles to edge.\n"
18423 " t: Top of viewport, text written parallel to edge.\n"
18424 " tv: Top of viewport, text written at right angles to edge.\n"
18427 " disp (PLFLT, input) : Position of the reference point of string,\n"
18428 " measured outwards from the specified viewport edge in units of the\n"
18429 " current character height. Use negative disp to write within the\n"
18432 " pos (PLFLT, input) : Position of the reference point of string\n"
18433 " along the specified edge, expressed as a fraction of the length of\n"
18436 " just (PLFLT, input) : Specifies the position of the string relative\n"
18437 " to its reference point. If just=0. , the reference point is at\n"
18438 " the left and if just=1. , it is at the right of the string. Other\n"
18439 " values of just give intermediate justifications.\n"
18441 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18445 { (
char *)
"plmtex3",
_wrap_plmtex3, METH_VARARGS, (
char *)
"\n"
18446 "Write text relative to viewport boundaries in 3D plots\n"
18450 " Writes text at a specified position relative to the viewport\n"
18451 " boundaries. Text may be written inside or outside the viewport, but\n"
18452 " is clipped at the subpage boundaries. The reference point of a string\n"
18453 " lies along a line passing through the string at half the height of a\n"
18454 " capital letter. The position of the reference point along this line\n"
18455 " is determined by just, and the position of the reference point\n"
18456 " relative to the viewport is set by disp and pos.\n"
18458 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18460 " This function is used in example 28.\n"
18466 "plmtex3(side, disp, pos, just, text)\n"
18470 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18471 " the side of the viewport along which the text is to be written.\n"
18472 " The string should contain one or more of the following characters:\n"
18473 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18474 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18476 " y: Label the Y axis.\n"
18477 " z: Label the Z axis.\n"
18478 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18479 " For X it is the axis that starts at y-min. For Y it is the\n"
18480 " axis that starts at x-min.\n"
18481 " s: Label the secondary axis.\n"
18482 " v: Draw the text perpendicular to the axis.\n"
18485 " disp (PLFLT, input) : Position of the reference point of string,\n"
18486 " measured outwards from the specified viewport edge in units of the\n"
18487 " current character height. Use negative disp to write within the\n"
18490 " pos (PLFLT, input) : Position of the reference point of string\n"
18491 " along the specified edge, expressed as a fraction of the length of\n"
18494 " just (PLFLT, input) : Specifies the position of the string relative\n"
18495 " to its reference point. If just=0. , the reference point is at\n"
18496 " the left and if just=1. , it is at the right of the string. Other\n"
18497 " values of just give intermediate justifications.\n"
18499 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18503 { (
char *)
"plot3d",
_wrap_plot3d, METH_VARARGS, (
char *)
"\n"
18504 "Plot 3-d surface plot\n"
18508 " Plots a three-dimensional surface plot within the environment set up\n"
18509 " by plw3d. The surface is defined by the matrix z[\n"
18511 " ny] , the point z[i][j] being the value of the function at (\n"
18513 " y[j]). Note that the points in vectors x and y do not need to be\n"
18514 " equally spaced, but must be stored in ascending order. The parameter\n"
18515 " opt controls the way in which the surface is displayed. For further\n"
18516 " details see the PLplot documentation. The only difference between\n"
18517 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18518 " while plot3d only draws the surface as viewed from the top.\n"
18520 " Redacted form: plot3d(x, y, z, opt, side)\n"
18522 " This function is used in examples 11 and 21.\n"
18528 "plot3d(x, y, z, nx, ny, opt, side)\n"
18532 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18533 " which the function is evaluated.\n"
18535 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18536 " which the function is evaluated.\n"
18538 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18539 " plot. Should have dimensions of\n"
18543 " nx (PLINT, input) : Number of x values at which function is\n"
18546 " ny (PLINT, input) : Number of y values at which function is\n"
18549 " opt (PLINT, input) : Determines the way in which the surface is\n"
18550 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18551 " function of x for each value of y[j] .\n"
18552 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18553 " for each value of x[i] .\n"
18554 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18555 " at which function is defined.\n"
18558 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18559 " should be draw on the figure. If side is true sides are drawn,\n"
18560 " otherwise no sides are drawn.\n"
18563 { (
char *)
"plot3dc",
_wrap_plot3dc, METH_VARARGS, (
char *)
"\n"
18564 "Magnitude colored plot surface with contour\n"
18568 " Aside from dropping the\n"
18569 " side functionality this is a more powerful form of plot3d: the surface\n"
18570 " mesh can be colored accordingly to the current z value being plotted,\n"
18571 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18572 " drawn between the plotted function border and the base XY plane. The\n"
18573 " arguments are identical to those of plmeshc. The only difference\n"
18574 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18575 " the surface, while plot3dc only draws the surface as viewed from the\n"
18578 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18579 " Perl/PDL: Not available?\n"
18582 " This function is used in example 21.\n"
18588 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18592 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18593 " which the function is evaluated.\n"
18595 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18596 " which the function is evaluated.\n"
18598 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18599 " plot. Should have dimensions of\n"
18603 " nx (PLINT, input) : Number of x values at which function is\n"
18606 " ny (PLINT, input) : Number of y values at which function is\n"
18609 " opt (PLINT, input) : Determines the way in which the surface is\n"
18610 " represented. To specify more than one option just add the options,\n"
18611 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18612 " showing z as a function of x for each value of y[j] .\n"
18613 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18614 " for each value of x[i] .\n"
18615 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18616 " at which function is defined.\n"
18617 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18618 " the z value being plotted. The color is used from the current\n"
18620 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18621 " using parameters\n"
18624 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18625 " the borders of the plotted function.\n"
18628 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18631 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18634 { (
char *)
"plot3dcl",
_wrap_plot3dcl, METH_VARARGS, (
char *)
"\n"
18635 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18639 " When the implementation is completed this variant of plot3dc (see that\n"
18640 " function's documentation for more details) should be suitable for the\n"
18641 " case where the area of the x, y coordinate grid where z is defined can\n"
18642 " be non-rectangular. The implementation is incomplete so the last 4\n"
18643 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18644 " indexymax; are currently ignored and the functionality is otherwise\n"
18645 " identical to that of plot3dc.\n"
18647 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18648 " indexymin, indexymax)\n"
18649 " Perl/PDL: Not available?\n"
18652 " This function is not used in any example.\n"
18658 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18662 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18663 " which the function is evaluated.\n"
18665 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18666 " which the function is evaluated.\n"
18668 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18669 " plot. Should have dimensions of\n"
18673 " nx (PLINT, input) : Number of x values at which the function is\n"
18676 " ny (PLINT, input) : Number of y values at which the function is\n"
18679 " opt (PLINT, input) : Determines the way in which the surface is\n"
18680 " represented. To specify more than one option just add the options,\n"
18681 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18682 " showing z as a function of x for each value of y[j] .\n"
18683 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18684 " for each value of x[i] .\n"
18685 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18686 " at which function is defined.\n"
18687 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18688 " the z value being plotted. The color is used from the current\n"
18690 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18691 " using parameters\n"
18694 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18695 " the borders of the plotted function.\n"
18698 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18701 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18703 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18704 " corresponds to the first x index where z is defined.\n"
18706 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18707 " which corresponds (by convention) to one more than the last x\n"
18708 " index value where z is defined.\n"
18710 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18711 " values which all must be ≥ 0. These values are the first y index\n"
18712 " where z is defined for a particular x index in the range from\n"
18713 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18716 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18717 " values which all must be ≤ ny. These values correspond (by\n"
18718 " convention) to one more than the last y index where z is defined\n"
18719 " for a particular x index in the range from indexxmin to indexxmax\n"
18720 " - 1. The dimension of indexymax is indexxmax.\n"
18723 { (
char *)
"plsurf3d",
_wrap_plsurf3d, METH_VARARGS, (
char *)
"\n"
18724 "Plot shaded 3-d surface plot\n"
18728 " Plots a three-dimensional shaded surface plot within the environment\n"
18729 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18732 " ny], the point z[i][j] being the value of the function at (\n"
18734 " y[j]). Note that the points in vectors x and y do not need to be\n"
18735 " equally spaced, but must be stored in ascending order. For further\n"
18736 " details see the PLplot documentation.\n"
18738 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18740 " This function is not used in any examples.\n"
18746 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18750 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18751 " which the function is evaluated.\n"
18753 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18754 " which the function is evaluated.\n"
18756 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18757 " plot. Should have dimensions of\n"
18761 " nx (PLINT, input) : Number of x values at which function is\n"
18764 " ny (PLINT, input) : Number of y values at which function is\n"
18767 " opt (PLINT, input) : Determines the way in which the surface is\n"
18768 " represented. To specify more than one option just add the options,\n"
18769 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18770 " connecting points at which function is defined.\n"
18771 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18772 " using parameters\n"
18775 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18776 " using parameters\n"
18779 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18780 " the borders of the plotted function.\n"
18781 " opt=MAG_COLOR : the surface is colored according to the value\n"
18782 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18783 " according to the intensity of the reflected light in the\n"
18784 " surface from a light source whose position is set using\n"
18785 " pllightsource.\n"
18788 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18791 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18795 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18799 " This variant of plsurf3d (see that function's documentation for more\n"
18800 " details) should be suitable for the case where the area of the x, y\n"
18801 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18802 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18803 " indexymin, and indexymax.\n"
18805 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18808 " This function is used in example 8.\n"
18814 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18818 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18819 " which the function is evaluated.\n"
18821 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18822 " which the function is evaluated.\n"
18824 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18825 " plot. Should have dimensions of\n"
18829 " nx (PLINT, input) : Number of x values at which function is\n"
18832 " ny (PLINT, input) : Number of y values at which function is\n"
18835 " opt (PLINT, input) : Determines the way in which the surface is\n"
18836 " represented. To specify more than one option just add the options,\n"
18837 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18838 " connecting points at which function is defined.\n"
18839 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18840 " using parameters\n"
18843 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18844 " using parameters\n"
18847 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18848 " the borders of the plotted function.\n"
18849 " opt=MAG_COLOR : the surface is colored according to the value\n"
18850 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18851 " according to the intensity of the reflected light in the\n"
18852 " surface from a light source whose position is set using\n"
18853 " pllightsource.\n"
18856 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18859 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18861 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18862 " corresponds to the first x index where z is defined.\n"
18864 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18865 " which corresponds (by convention) to one more than the last x\n"
18866 " index value where z is defined.\n"
18868 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18869 " values which all must be ≥ 0. These values are the first y index\n"
18870 " where z is defined for a particular x index in the range from\n"
18871 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18874 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18875 " values which all must be ≤ ny. These values correspond (by\n"
18876 " convention) to one more than the last y index where z is defined\n"
18877 " for a particular x index in the range from indexxmin to indexxmax\n"
18878 " - 1. The dimension of indexymax is indexxmax.\n"
18882 "Parse command-line arguments\n"
18886 " Parse command-line arguments.\n"
18888 " plparseopts removes all recognized flags (decreasing argc\n"
18889 " accordingly), so that invalid input may be readily detected. It can\n"
18890 " also be used to process user command line flags. The user can merge\n"
18891 " an option table of type PLOptionTable into the internal option table\n"
18892 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18893 " the external table(s) be parsed by calling plClearOpts before\n"
18896 " The default action taken by plparseopts is as follows:\n"
18897 " Returns with an error if an unrecognized option or badly formed\n"
18898 " option-value pair are encountered. \n"
18899 " Returns immediately (return code 0) when the first non-option command\n"
18900 " line argument is found.\n"
18901 " Returns with the return code of the option handler, if one was called.\n"
18903 " Deletes command line arguments from argv list as they are found, and\n"
18904 " decrements argc accordingly.\n"
18905 " Does not show \"invisible\" options in usage or help messages.\n"
18906 " Assumes the program name is contained in argv[0].\n"
18908 " These behaviors may be controlled through the\n"
18909 " mode argument.\n"
18911 " Redacted form: General: plparseopts(argv, mode)\n"
18912 " Perl/PDL: Not available?\n"
18915 " This function is used in all of the examples.\n"
18921 "PLINT plparseopts(p_argc, argv, mode)\n"
18925 " p_argc (int *, input/output) : Number of arguments.\n"
18927 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18928 " strings containing *p_argc command-line arguments.\n"
18930 " mode (PLINT, input) : Parsing mode with the following\n"
18931 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18932 " and all error messages enabled, including program exit when an\n"
18933 " error occurs. Anything on the command line that isn't recognized\n"
18934 " as a valid option or option argument is flagged as an error.\n"
18935 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18937 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18939 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18940 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18941 " pointer to the program name.\n"
18942 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18943 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18944 " unrecognized arguments.\n"
18947 { (
char *)
"plpat",
_wrap_plpat, METH_VARARGS, (
char *)
"\n"
18948 "Set area line fill pattern\n"
18952 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18953 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18954 " inclinations and spacings. The arguments to this routine are the\n"
18955 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18956 " elements) specifying the inclinations in tenths of a degree and the\n"
18957 " spacing in micrometers. (See also plpsty)\n"
18959 " Redacted form: General: plpat(inc, del)\n"
18960 " Perl/PDL: plpat(nlin, inc, del)\n"
18963 " This function is used in example 15.\n"
18969 "plpat(nlin, inc, del)\n"
18973 " nlin (PLINT, input) : Number of sets of lines making up the\n"
18974 " pattern, either 1 or 2.\n"
18976 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18977 " inclination in tenths of a degree. (Should be between -900 and\n"
18980 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18981 " spacing in micrometers between the lines making up the pattern.\n"
18984 { (
char *)
"plpath",
_wrap_plpath, METH_VARARGS, (
char *)
"\n"
18985 "Draw a line between two points, accounting for coordinate transforms\n"
18989 " Joins the point (\n"
18993 " y2) . If a global coordinate transform is defined then the line is\n"
18994 " broken in to n segments to approximate the path. If no transform is\n"
18995 " defined then this simply acts like a call to pljoin.\n"
18997 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18999 " This function is used in example 22.\n"
19005 "plpath(n, x1, y1, x2, y2)\n"
19009 " n (PLINT, input) : number of points to use to approximate the path.\n"
19011 " x1 (PLFLT, input) : x coordinate of first point.\n"
19013 " y1 (PLFLT, input) : y coordinate of first point.\n"
19015 " x2 (PLFLT, input) : x coordinate of second point.\n"
19017 " y2 (PLFLT, input) : y coordinate of second point.\n"
19020 { (
char *)
"plpoin",
_wrap_plpoin, METH_VARARGS, (
char *)
"\n"
19021 "Plot a glyph at the specified points\n"
19025 " Plot a glyph at the specified points. (This function is largely\n"
19026 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19027 " code=-1 means try to just draw a point. Right now it's just a move\n"
19028 " and a draw at the same place. Not ideal, since a sufficiently\n"
19029 " intelligent output device may optimize it away, or there may be faster\n"
19030 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19031 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19032 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19033 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19034 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19036 " Redacted form: plpoin(x, y, code)\n"
19038 " This function is used in examples 1, 6, 14, and 29.\n"
19044 "plpoin(n, x, y, code)\n"
19048 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19050 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19053 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19056 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19057 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19058 " each of the n points.\n"
19061 { (
char *)
"plpoin3",
_wrap_plpoin3, METH_VARARGS, (
char *)
"\n"
19062 "Plot a glyph at the specified 3D points\n"
19066 " Plot a glyph at the specified 3D points. (This function is largely\n"
19067 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19068 " Set up the call to this function similar to what is done for plline3.\n"
19069 " code=-1 means try to just draw a point. Right now it's just a move\n"
19070 " and a draw at the same place. Not ideal, since a sufficiently\n"
19071 " intelligent output device may optimize it away, or there may be faster\n"
19072 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19073 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19074 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19075 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19076 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19078 " Redacted form: plpoin3(x, y, z, code)\n"
19080 " This function is not used in any example.\n"
19086 "plpoin3(n, x, y, z, code)\n"
19090 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19092 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19095 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19098 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19101 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19102 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19103 " each of the n points.\n"
19106 { (
char *)
"plpoly3",
_wrap_plpoly3, METH_VARARGS, (
char *)
"\n"
19107 "Draw a polygon in 3 space\n"
19111 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19112 " like plline3, but differs from that function in that plpoly3 attempts\n"
19113 " to determine if the polygon is viewable depending on the order of the\n"
19114 " points within the vector and the value of ifcc. If the back of\n"
19115 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19116 " you want, then use plline3 instead.\n"
19118 " The points are assumed to be in a plane, and the directionality of the\n"
19119 " plane is determined from the first three points. Additional points do\n"
19120 " not have to lie on the plane defined by the first three, but if they\n"
19121 " do not, then the determination of visibility obviously can't be 100%\n"
19122 " accurate... So if you're 3 space polygons are too far from planar,\n"
19123 " consider breaking them into smaller polygons. 3 points define a plane\n"
19126 " Bugs: If one of the first two segments is of zero length, or if they\n"
19127 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19128 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19129 " of this problem. (Search for 20.1).\n"
19131 " Redacted form: plpoly3(x, y, z, code)\n"
19133 " This function is used in example 18.\n"
19139 "plpoly3(n, x, y, z, draw, ifcc)\n"
19143 " n (PLINT, input) : Number of points defining line.\n"
19145 " x (PLFLT_VECTOR, input) : A vector containing\n"
19146 " n x coordinates of points.\n"
19148 " y (PLFLT_VECTOR, input) : A vector containing\n"
19149 " n y coordinates of points.\n"
19151 " z (PLFLT_VECTOR, input) : A vector containing\n"
19152 " n z coordinates of points.\n"
19154 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19155 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19156 " If draw[i] is true, then the polygon segment from index [i] to\n"
19157 " [i+1] is drawn, otherwise, not.\n"
19159 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19160 " polygon is determined by assuming the points are laid out in a\n"
19161 " counter-clockwise order. Otherwise, the directionality of the\n"
19162 " polygon is determined by assuming the points are laid out in a\n"
19163 " clockwise order.\n"
19166 { (
char *)
"plprec",
_wrap_plprec, METH_VARARGS, (
char *)
"\n"
19167 "Set precision in numeric labels\n"
19171 " Sets the number of places after the decimal point in numeric labels.\n"
19173 " Redacted form: plprec(setp, prec)\n"
19175 " This function is used in example 29.\n"
19181 "plprec(setp, prec)\n"
19185 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19186 " automatically determines the number of places to use after the\n"
19187 " decimal point in numeric labels (like those used to label axes).\n"
19188 " If setp is 1 then prec sets the number of places.\n"
19190 " prec (PLINT, input) : The number of characters to draw after the\n"
19191 " decimal point in numeric labels.\n"
19194 { (
char *)
"plpsty",
_wrap_plpsty, METH_VARARGS, (
char *)
"\n"
19195 "Select area fill pattern\n"
19200 " patt is zero or less use either a hardware solid fill if the drivers\n"
19201 " have that capability (virtually all do) or fall back to a software\n"
19202 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19204 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19205 " to use (see plpat if you desire other patterns).\n"
19207 " Redacted form: plpsty(patt)\n"
19209 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19219 " patt (PLINT, input) : The desired pattern index. If\n"
19220 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19221 " above) used. For\n"
19222 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19223 " line fill capability itself (most deliberately do not so that line\n"
19224 " fill patterns look identical for those drivers), the patterns\n"
19225 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19226 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19227 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19228 " (8) lines at both 45 degrees and -45 degrees.\n"
19231 { (
char *)
"plptex",
_wrap_plptex, METH_VARARGS, (
char *)
"\n"
19232 "Write text inside the viewport\n"
19236 " Writes text at a specified position and inclination within the\n"
19237 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19238 " point of a string lies along a line passing through the string at half\n"
19239 " the height of a capital letter. The position of the reference point\n"
19240 " along this line is determined by just, the reference point is placed\n"
19241 " at world coordinates (\n"
19243 " y) within the viewport. The inclination of the string is specified\n"
19244 " in terms of differences of world coordinates making it easy to write\n"
19245 " text parallel to a line in a graph.\n"
19247 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19249 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19255 "plptex(x, y, dx, dy, just, text)\n"
19259 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19261 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19263 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19264 " inclination of the string. The baseline of the string is parallel\n"
19265 " to a line joining (\n"
19273 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19274 " inclination of the string.\n"
19276 " just (PLFLT, input) : Specifies the position of the string relative\n"
19277 " to its reference point. If just=0. , the reference point is at\n"
19278 " the left and if just=1. , it is at the right of the string. Other\n"
19279 " values of just give intermediate justifications.\n"
19281 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19285 { (
char *)
"plptex3",
_wrap_plptex3, METH_VARARGS, (
char *)
"\n"
19286 "Write text inside the viewport of a 3D plot\n"
19290 " Writes text at a specified position and inclination and with a\n"
19291 " specified shear within the viewport. Text is clipped at the viewport\n"
19292 " boundaries. The reference point of a string lies along a line passing\n"
19293 " through the string at half the height of a capital letter. The\n"
19294 " position of the reference point along this line is determined by just,\n"
19295 " and the reference point is placed at world coordinates (\n"
19298 " wz) within the viewport. The inclination and shear of the string is\n"
19299 " specified in terms of differences of world coordinates making it easy\n"
19300 " to write text parallel to a line in a graph.\n"
19302 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19304 " This function is used in example 28.\n"
19310 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19314 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19317 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19320 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19323 " dx (PLFLT, input) : Together with dy and\n"
19324 " dz , this specifies the inclination of the string. The baseline of\n"
19325 " the string is parallel to a line joining (\n"
19336 " dy (PLFLT, input) : Together with dx and\n"
19337 " dz, this specifies the inclination of the string.\n"
19339 " dz (PLFLT, input) : Together with dx and\n"
19340 " dy, this specifies the inclination of the string.\n"
19342 " sx (PLFLT, input) : Together with sy and\n"
19343 " sz , this specifies the shear of the string. The string is sheared so\n"
19344 " that the characters are vertically parallel to a line joining (\n"
19355 " sz = 0.) then the text is not sheared.\n"
19357 " sy (PLFLT, input) : Together with sx and\n"
19358 " sz, this specifies shear of the string.\n"
19360 " sz (PLFLT, input) : Together with sx and\n"
19361 " sy, this specifies shear of the string.\n"
19363 " just (PLFLT, input) : Specifies the position of the string relative\n"
19364 " to its reference point. If just=0. , the reference point is at\n"
19365 " the left and if just=1. , it is at the right of the string. Other\n"
19366 " values of just give intermediate justifications.\n"
19368 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19372 { (
char *)
"plrandd",
_wrap_plrandd, METH_VARARGS, (
char *)
"\n"
19373 "Random number generator returning a real random number in the range [0,1]\n"
19377 " Random number generator returning a real random number in the range\n"
19378 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19379 " / compilers provide their own random number generator, and so this is\n"
19380 " provided purely for convenience and to give a consistent random number\n"
19381 " generator across all languages supported by PLplot. This is\n"
19382 " particularly useful for comparing results from the test suite of\n"
19385 " Redacted form: plrandd()\n"
19387 " This function is used in examples 17 and 21.\n"
19396 { (
char *)
"plreplot",
_wrap_plreplot, METH_VARARGS, (
char *)
"\n"
19397 "Replays contents of plot buffer to current device/file\n"
19401 " Replays contents of plot buffer to current device/file.\n"
19403 " Redacted form: plreplot()\n"
19405 " This function is used in example 1,20.\n"
19414 { (
char *)
"plrgbhls",
_wrap_plrgbhls, METH_VARARGS, (
char *)
"\n"
19415 "Convert RGB color to HLS\n"
19419 " Convert RGB color coordinates to HLS\n"
19421 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19422 " Perl/PDL: Not available? Implemented as plrgb/plrgb1?\n"
19425 " This function is used in example 2.\n"
19431 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19435 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19437 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19439 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19441 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19442 " degrees (0.0-360.0) on the color cylinder.\n"
19444 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19445 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19448 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19449 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19453 { (
char *)
"plschr",
_wrap_plschr, METH_VARARGS, (
char *)
"\n"
19454 "Set character size\n"
19458 " This sets up the size of all subsequent characters drawn. The actual\n"
19459 " height of a character is the product of the default character size and\n"
19460 " a scaling factor.\n"
19462 " Redacted form: plschr(def, scale)\n"
19464 " This function is used in examples 2, 13, 23, and 24.\n"
19470 "plschr(def, scale)\n"
19474 " def (PLFLT, input) : The default height of a character in\n"
19475 " millimeters, should be set to zero if the default height is to\n"
19476 " remain unchanged. For rasterized drivers the dx and dy values\n"
19477 " specified in plspage are used to convert from mm to pixels (note\n"
19478 " the different unit systems used). This dpi aware scaling is not\n"
19479 " implemented for all drivers yet.\n"
19481 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19482 " actual character height.\n"
19485 { (
char *)
"plscmap0",
_wrap_plscmap0, METH_VARARGS, (
char *)
"\n"
19486 "Set cmap0 colors by 8-bit RGB values\n"
19490 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19491 " documentation). This sets the entire color map -- only as many colors\n"
19492 " as specified will be allocated.\n"
19494 " Redacted form: plscmap0(r, g, b)\n"
19496 " This function is used in examples 2 and 24.\n"
19502 "plscmap0(r, g, b, ncol0)\n"
19506 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19507 " integers (0-255) representing the degree of red in the color.\n"
19509 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19510 " integers (0-255) representing the degree of green in the color.\n"
19512 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19513 " integers (0-255) representing the degree of blue in the color.\n"
19515 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19519 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19523 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19524 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19525 " only as many colors as specified will be allocated.\n"
19527 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19529 " This function is used in examples 30.\n"
19535 "plscmap0a(r, g, b, alpha, ncol0)\n"
19539 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19540 " integers (0-255) representing the degree of red in the color.\n"
19542 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19543 " integers (0-255) representing the degree of green in the color.\n"
19545 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19546 " integers (0-255) representing the degree of blue in the color.\n"
19548 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19549 " representing the alpha transparency of the color.\n"
19551 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19556 "Set number of colors in cmap0\n"
19560 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19561 " (or reallocate) cmap0, and fill with default values for those colors\n"
19562 " not previously allocated. The first 16 default colors are given in\n"
19563 " the plcol0 documentation. For larger indices the default color is\n"
19566 " The drivers are not guaranteed to support more than 16 colors.\n"
19568 " Redacted form: plscmap0n(ncol0)\n"
19570 " This function is used in examples 15, 16, and 24.\n"
19576 "plscmap0n(ncol0)\n"
19580 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19581 " the cmap0 palette. If this number is zero or less, then the value\n"
19582 " from the previous call to plscmap0n is used and if there is no\n"
19583 " previous call, then a default value is used.\n"
19586 { (
char *)
"plscmap1",
_wrap_plscmap1, METH_VARARGS, (
char *)
"\n"
19587 "Set opaque RGB cmap1 colors values\n"
19591 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19592 " vector values. This function also sets the number of cmap1 colors.\n"
19593 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19594 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19595 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19597 " ncol1-1. So in order for this continuous color model to work\n"
19598 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19599 " that these RGB vectors are continuous functions of their integer\n"
19602 " Redacted form: plscmap1(r, g, b)\n"
19604 " This function is used in example 31.\n"
19610 "plscmap1(r, g, b, ncol1)\n"
19614 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19615 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19616 " color as a continuous function of the integer index of the vector.\n"
19618 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19619 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19620 " color as a continuous function of the integer index of the vector.\n"
19622 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19623 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19624 " color as a continuous function of the integer index of the vector.\n"
19626 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19630 "Set semitransparent cmap1 RGBA colors.\n"
19634 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19635 " RGBA vector values. This function also sets the number of cmap1\n"
19636 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19637 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19638 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19639 " vectors in the range from 0 to\n"
19640 " ncol1-1. So in order for this continuous color model to work\n"
19641 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19642 " that these RGBA vectors are continuous functions of their integer\n"
19645 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19647 " This function is used in example 31.\n"
19653 "plscmap1a(r, g, b, alpha, ncol1)\n"
19657 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19658 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19659 " color as a continuous function of the integer index of the vector.\n"
19661 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19662 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19663 " color as a continuous function of the integer index of the vector.\n"
19665 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19666 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19667 " color as a continuous function of the integer index of the vector.\n"
19669 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19670 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19671 " completely transparent and 1.0 corresponds to completely opaque)\n"
19672 " the alpha transparency of the color as a continuous function of\n"
19673 " the integer index of the vector.\n"
19675 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19680 "Set cmap1 colors using a piece-wise linear relationship\n"
19684 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19685 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19686 " (see the PLplot documentation). May be called at any time.\n"
19688 " The idea here is to specify a number of control points that define the\n"
19689 " mapping between input cmap1 intensity indices and HLS (or RGB).\n"
19690 " Between these points, linear interpolation is used which gives a\n"
19691 " smooth variation of color with intensity index. Any number of control\n"
19692 " points may be specified, located at arbitrary positions, although\n"
19693 " typically 2 - 4 are enough. Another way of stating this is that we are\n"
19694 " traversing a given number of lines through HLS (or RGB) space as we\n"
19695 " move through cmap1 intensity indices. The control points at the\n"
19696 " minimum and maximum position (0 and 1) must always be specified. By\n"
19697 " adding more control points you can get more variation. One good\n"
19698 " technique for plotting functions that vary about some expected average\n"
19699 " is to use an additional 2 control points in the center (position ~=\n"
19700 " 0.5) that are the same lightness as the background (typically white\n"
19701 " for paper output, black for crt), and same hue as the boundary control\n"
19702 " points. This allows the highs and lows to be very easily\n"
19703 " distinguished.\n"
19705 " Each control point must specify the cmap1 intensity index and the\n"
19706 " associated three coordinates in HLS or RGB space. The first point\n"
19707 " must correspond to position = 0, and the last to position = 1.\n"
19709 " The default behaviour is for the hue to be linearly interpolated\n"
19710 " between the control points. Since the hue lies in the range [0, 360]\n"
19711 " this corresponds to interpolation around the \"front\" of the color\n"
19712 " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
19713 " alternative interpolation is used between control points i and i+1. If\n"
19714 " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n"
19715 " - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n"
19716 " this as interpolation around the \"back\" or \"reverse\" of the color\n"
19717 " wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
19718 " alt_hue_path[] = false for every control point.\n"
19720 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19721 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19722 " 240]truegreen-yellow-red-magenta-blue[240\n"
19723 " 120]trueblue-magenta-red-yellow-green\n"
19725 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19726 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19727 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19729 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19732 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19738 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19742 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19744 " npts (PLINT, input) : number of control points\n"
19746 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19747 " intensity index (0.0-1.0) in ascending order for each control\n"
19750 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19751 " coordinate (H or R) for each control point.\n"
19753 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19754 " coordinate (L or G) for each control point.\n"
19756 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19757 " coordinate (S or B) for each control point.\n"
19759 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19760 " npts - 1 elements) containing the alternative interpolation method\n"
19761 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19762 " refers to the interpolation interval between the i and i + 1\n"
19763 " control points).\n"
19767 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19771 " This is a variant of plscmap1l that supports alpha channel\n"
19772 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19773 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19774 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19775 " transparency value (0.0-1.0). It may be called at any time.\n"
19777 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19778 " alpha, alt_hue_path)\n"
19780 " This function is used in example 30.\n"
19786 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19790 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19792 " npts (PLINT, input) : number of control points.\n"
19794 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19795 " intensity index (0.0-1.0) in ascending order for each control\n"
19798 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19799 " coordinate (H or R) for each control point.\n"
19801 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19802 " coordinate (L or G) for each control point.\n"
19804 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19805 " coordinate (S or B) for each control point.\n"
19807 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19808 " transparency value (0.0-1.0) for each control point.\n"
19810 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19811 " npts - 1 elements) containing the alternative interpolation method\n"
19812 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19813 " refers to the interpolation interval between the i and i + 1\n"
19814 " control points).\n"
19818 "Set number of colors in cmap1\n"
19822 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19823 " values if this is the first allocation (see the PLplot documentation).\n"
19825 " Redacted form: plscmap1n(ncol1)\n"
19827 " This function is used in examples 8, 11, 20, and 21.\n"
19833 "plscmap1n(ncol1)\n"
19837 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19838 " the cmap1 palette. If this number is zero or less, then the value\n"
19839 " from the previous call to plscmap1n is used and if there is no\n"
19840 " previous call, then a default value is used.\n"
19844 "Set the cmap1 argument range for continuous color plots\n"
19848 " Set the cmap1 argument range for continuous color plots that\n"
19849 " corresponds to the range of data values. The maximum range\n"
19850 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19851 " the cmap1 argument range that is specified with this routine, the\n"
19852 " smaller the subset of the cmap1 color palette that is used to\n"
19853 " represent the continuous data being plotted. If\n"
19854 " min_color is greater than\n"
19856 " max_color is greater than 1.0 or\n"
19857 " min_color is less than 0.0 then no change is made to the cmap1\n"
19858 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19860 " Redacted form: plscmap1_range(min_color, max_color)\n"
19862 " This function is currently used in example 33.\n"
19868 "plscmap1_range(min_color, max_color)\n"
19872 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19873 " than 0.0, then 0.0 is used instead.\n"
19875 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19876 " than 1.0, then 1.0 is used instead.\n"
19880 "Get the cmap1 argument range for continuous color plots\n"
19884 " Get the cmap1 argument range for continuous color plots. (Use\n"
19885 " plscmap1_range to set the cmap1 argument range.)\n"
19887 " Redacted form: plgcmap1_range(min_color, max_color)\n"
19889 " This function is currently not used in any example.\n"
19895 "plgcmap1_range(min_color, max_color)\n"
19899 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19900 " minimum cmap1 argument.\n"
19902 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19903 " maximum cmap1 argument.\n"
19906 { (
char *)
"plscol0",
_wrap_plscol0, METH_VARARGS, (
char *)
"\n"
19907 "Set 8-bit RGB values for given cmap0 color index\n"
19911 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19912 " index. Overwrites the previous color value for the given index and,\n"
19913 " thus, does not result in any additional allocation of space for\n"
19916 " Redacted form: plscol0(icol0, r, g, b)\n"
19918 " This function is used in any example 31.\n"
19924 "plscol0(icol0, r, g, b)\n"
19928 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19929 " number of colors (which is set by default, by plscmap0n, or even\n"
19932 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19933 " degree of red in the color.\n"
19935 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19936 " degree of green in the color.\n"
19938 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19939 " degree of blue in the color.\n"
19942 { (
char *)
"plscol0a",
_wrap_plscol0a, METH_VARARGS, (
char *)
"\n"
19943 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19947 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19948 " (see the PLplot documentation) index. Overwrites the previous color\n"
19949 " value for the given index and, thus, does not result in any additional\n"
19950 " allocation of space for colors.\n"
19952 " This function is used in example 30.\n"
19958 "plscol0a(icol0, r, g, b, alpha)\n"
19962 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19963 " number of colors (which is set by default, by plscmap0n, or even\n"
19966 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19967 " degree of red in the color.\n"
19969 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19970 " degree of green in the color.\n"
19972 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19973 " degree of blue in the color.\n"
19975 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19979 { (
char *)
"plscolbg",
_wrap_plscolbg, METH_VARARGS, (
char *)
"\n"
19980 "Set the background color by 8-bit RGB value\n"
19984 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19985 " the PLplot documentation).\n"
19987 " Redacted form: plscolbg(r, g, b)\n"
19989 " This function is used in examples 15 and 31.\n"
19995 "plscolbg(r, g, b)\n"
19999 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20000 " degree of red in the color.\n"
20002 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20003 " degree of green in the color.\n"
20005 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20006 " degree of blue in the color.\n"
20010 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20014 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20015 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20017 " This function is used in example 31.\n"
20023 "plscolbga(r, g, b, alpha)\n"
20027 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20028 " degree of red in the color.\n"
20030 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20031 " degree of green in the color.\n"
20033 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20034 " degree of blue in the color.\n"
20036 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20040 { (
char *)
"plscolor",
_wrap_plscolor, METH_VARARGS, (
char *)
"\n"
20041 "Used to globally turn color output on/off\n"
20045 " Used to globally turn color output on/off for those drivers/devices\n"
20046 " that support it.\n"
20048 " Redacted form: plscolor(color)\n"
20050 " This function is used in example 31.\n"
20056 "plscolor(color)\n"
20060 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20061 " turned off. If non-zero, color is turned on.\n"
20065 "Set device-compression level\n"
20069 " Set device-compression level. Only used for drivers that provide\n"
20070 " compression. This function, if used, should be invoked before a call\n"
20073 " Redacted form: plscompression(compression)\n"
20075 " This function is used in example 31.\n"
20081 "plscompression(compression)\n"
20085 " compression (PLINT, input) : The desired compression level. This is\n"
20086 " a device-dependent value. Currently only the jpeg and png devices\n"
20087 " use these values. For jpeg value is the jpeg quality which should\n"
20088 " normally be in the range 0-95. Higher values denote higher quality\n"
20089 " and hence larger image sizes. For png values are in the range -1\n"
20090 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20091 " A value of -1 denotes the default zlib compression level. Values\n"
20092 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20093 " compression level. Higher compression levels correspond to greater\n"
20094 " compression and small file sizes at the expense of more\n"
20098 { (
char *)
"plsdev",
_wrap_plsdev, METH_VARARGS, (
char *)
"\n"
20099 "Set the device (keyword) name\n"
20103 " Set the device (keyword) name.\n"
20105 " Redacted form: plsdev(devname)\n"
20107 " This function is used in examples 1, 14, and 20.\n"
20113 "plsdev(devname)\n"
20117 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20118 " containing the device name keyword of the required output device.\n"
20120 " devname is NULL or if the first character of the string is a ``?'',\n"
20121 " the normal (prompted) start up is used.\n"
20124 { (
char *)
"plsdidev",
_wrap_plsdidev, METH_VARARGS, (
char *)
"\n"
20125 "Set parameters that define current device-space window\n"
20129 " Set relative margin width, aspect ratio, and relative justification\n"
20130 " that define current device-space window. If you want to just use the\n"
20131 " previous value for any of these, just pass in the magic value\n"
20132 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20133 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20134 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20135 " to a device-specific value.\n"
20137 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20139 " This function is used in example 31.\n"
20145 "plsdidev(mar, aspect, jx, jy)\n"
20149 " mar (PLFLT, input) : Relative margin width.\n"
20151 " aspect (PLFLT, input) : Aspect ratio.\n"
20153 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20154 " the range -0.5 to 0.5.\n"
20156 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20157 " the range -0.5 to 0.5.\n"
20160 { (
char *)
"plsdimap",
_wrap_plsdimap, METH_VARARGS, (
char *)
"\n"
20161 "Set up transformation from metafile coordinates\n"
20165 " Set up transformation from metafile coordinates. The size of the plot\n"
20166 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20167 " general-purpose facility just yet (not sure why the user would need\n"
20170 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20173 " This function is not used in any examples.\n"
20179 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20183 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20185 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20187 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20189 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20191 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20193 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20196 { (
char *)
"plsdiori",
_wrap_plsdiori, METH_VARARGS, (
char *)
"\n"
20197 "Set plot orientation\n"
20201 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20202 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20203 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20204 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20205 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20206 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20207 " not called the default value of rot is 0.\n"
20209 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20210 " probably want to change the aspect ratio to a value suitable for the\n"
20211 " plot orientation using a call to plsdidev or the command-line options\n"
20212 " -a or -freeaspect. For more documentation of those options see the\n"
20213 " PLplot documentation. Such command-line options can be set internally\n"
20214 " using plsetopt or set directly using the command line and parsed using\n"
20215 " a call to plparseopts.\n"
20217 " Redacted form: plsdiori(rot)\n"
20219 " This function is not used in any examples.\n"
20229 " rot (PLFLT, input) : Plot orientation parameter.\n"
20232 { (
char *)
"plsdiplt",
_wrap_plsdiplt, METH_VARARGS, (
char *)
"\n"
20233 "Set parameters that define current plot-space window\n"
20237 " Set relative minima and maxima that define the current plot-space\n"
20238 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20239 " xmax, and ymax are 0., 0., 1., and 1.\n"
20241 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20243 " This function is used in example 31.\n"
20249 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20253 " xmin (PLFLT, input) : Relative minimum in x.\n"
20255 " ymin (PLFLT, input) : Relative minimum in y.\n"
20257 " xmax (PLFLT, input) : Relative maximum in x.\n"
20259 " ymax (PLFLT, input) : Relative maximum in y.\n"
20262 { (
char *)
"plsdiplz",
_wrap_plsdiplz, METH_VARARGS, (
char *)
"\n"
20263 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20267 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20268 " the current plot-space window. This function has the same effect as\n"
20269 " plsdiplt if that function has not been previously called. Otherwise,\n"
20270 " this function implements zoom mode using the transformation min_used =\n"
20271 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20272 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20273 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20275 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20277 " This function is used in example 31.\n"
20283 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20287 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20289 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20291 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20293 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20296 { (
char *)
"plseed",
_wrap_plseed, METH_VARARGS, (
char *)
"\n"
20297 "Set seed for internal random number generator.\n"
20301 " Set the seed for the internal random number generator. See plrandd for\n"
20302 " further details.\n"
20304 " Redacted form: plseed(seed)\n"
20306 " This function is used in example 21.\n"
20316 " seed (unsigned int, input) : Seed for random number generator.\n"
20319 { (
char *)
"plsesc",
_wrap_plsesc, METH_VARARGS, (
char *)
"\n"
20320 "Set the escape character for text strings\n"
20324 " Set the escape character for text strings. From C (in contrast to\n"
20325 " Fortran 95, see plsescfortran95) you pass esc as a character. Only\n"
20326 " selected characters are allowed to prevent the user from shooting\n"
20327 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
20328 " with C's use of backslash as a character escape). Here are the\n"
20329 " allowed escape characters and their corresponding decimal ASCII\n"
20330 " values: !, ASCII 33\n"
20341 " Redacted form: General: plsesc(esc)\n"
20342 " Perl/PDL: Not available?\n"
20345 " This function is used in example 29.\n"
20355 " esc (char, input) : Escape character.\n"
20358 { (
char *)
"plsetopt",
_wrap_plsetopt, METH_VARARGS, (
char *)
"\n"
20359 "Set any command-line option\n"
20363 " Set any command-line option internally from a program before it\n"
20364 " invokes plinit. opt is the name of the command-line option and optarg\n"
20365 " is the corresponding command-line option argument.\n"
20367 " This function returns 0 on success.\n"
20369 " Redacted form: plsetopt(opt, optarg)\n"
20371 " This function is used in example 14.\n"
20377 "PLINT plsetopt(opt, optarg)\n"
20381 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20382 " the command-line option.\n"
20384 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20385 " containing the argument of the command-line option.\n"
20388 { (
char *)
"plsfam",
_wrap_plsfam, METH_VARARGS, (
char *)
"\n"
20389 "Set family file parameters\n"
20393 " Sets variables dealing with output file familying. Does nothing if\n"
20394 " familying not supported by the driver. This routine, if used, must be\n"
20395 " called before initializing PLplot. See the PLplot documentation for\n"
20396 " more information.\n"
20398 " Redacted form: plsfam(fam, num, bmax)\n"
20400 " This function is used in examples 14 and 31.\n"
20406 "plsfam(fam, num, bmax)\n"
20410 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20413 " num (PLINT, input) : Current family file number.\n"
20415 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20419 { (
char *)
"plsfci",
_wrap_plsfci, METH_VARARGS, (
char *)
"\n"
20420 "Set FCI (font characterization integer)\n"
20424 " Sets font characteristics to be used at the start of the next string\n"
20425 " using the FCI approach. See the PLplot documentation for more\n"
20426 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20427 " more user-friendly API for setting the font characterisitics.\n"
20429 " Redacted form: General: plsfci(fci)\n"
20430 " Perl/PDL: Not available?\n"
20433 " This function is used in example 23.\n"
20443 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20447 { (
char *)
"plsfnam",
_wrap_plsfnam, METH_VARARGS, (
char *)
"\n"
20448 "Set output file name\n"
20452 " Sets the current output file name, if applicable. If the file name\n"
20453 " has not been specified and is required by the driver, the user will be\n"
20454 " prompted for it. If using the X-windows output driver, this sets the\n"
20455 " display name. This routine, if used, must be called before\n"
20456 " initializing PLplot.\n"
20458 " Redacted form: plsfnam(fnam)\n"
20460 " This function is used in examples 1 and 20.\n"
20470 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20471 " the file name.\n"
20474 { (
char *)
"plsfont",
_wrap_plsfont, METH_VARARGS, (
char *)
"\n"
20475 "Set family, style and weight of the current font\n"
20479 " Sets the current font. See the PLplot documentation for more\n"
20480 " information on font selection.\n"
20482 " Redacted form: plsfont(family, style, weight)\n"
20484 " This function is used in example 23.\n"
20490 "plsfont(family, style, weight)\n"
20494 " family (PLINT, input) : Font family to select for the current font.\n"
20495 " The available values are given by the PL_FCI_* constants in\n"
20496 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20497 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20498 " signifies that the font family should not be altered.\n"
20500 " style (PLINT, input) : Font style to select for the current font.\n"
20501 " The available values are given by the PL_FCI_* constants in\n"
20502 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20503 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20504 " should not be altered.\n"
20506 " weight (PLINT, input) : Font weight to select for the current font.\n"
20507 " The available values are given by the PL_FCI_* constants in\n"
20508 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20509 " negative value signifies that the font weight should not be\n"
20513 { (
char *)
"plshades",
_wrap_plshades, METH_VARARGS, (
char *)
"\n"
20514 "Shade regions on the basis of value\n"
20518 " Shade regions on the basis of value. This is the high-level routine\n"
20519 " for making continuous color shaded plots with cmap1 while plshade\n"
20520 " should be used to plot individual shaded regions using either cmap0 or\n"
20521 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20522 " our supported languages.\n"
20524 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20525 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20527 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
20528 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
20532 " This function is used in examples 16, 21, and 22.\n"
20538 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20542 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20543 " plot. Should have dimensions of\n"
20547 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20549 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20551 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20552 " the region that should be plotted in the shade plot. This\n"
20553 " function accepts x and y coordinates as input arguments and must\n"
20554 " return 1 if the point is to be included in the shade plot and 0\n"
20555 " otherwise. If you want to plot the entire shade plot (the usual\n"
20556 " case), this argument should be set to NULL.\n"
20558 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20559 " pltr below for how these arguments are used (only for the special case\n"
20560 " when the callback function\n"
20561 " pltr is not supplied).\n"
20563 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20564 " corresponding to the edges of each shaded region that will be\n"
20565 " plotted by this function. To work properly the levels should be\n"
20568 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20569 " of shade edge values in clevel).\n"
20571 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20574 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20575 " contours defining edges of shaded regions. The pen color is only\n"
20576 " temporary set for the contour drawing. Set this value to zero or\n"
20577 " less if no shade edge contours are wanted.\n"
20579 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20580 " defining edges of shaded regions. This value may not be honored\n"
20581 " by all drivers. The pen width is only temporary set for the\n"
20582 " contour drawing. Set this value to zero or less if no shade edge\n"
20583 " contours are wanted.\n"
20585 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20586 " region. Use plfill for this purpose.\n"
20588 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20589 " map to rectangles after coordinate transformation with pltrl.\n"
20590 " Otherwise, set rectangular to false. If rectangular is set to\n"
20591 " true, plshade tries to save time by filling large rectangles.\n"
20592 " This optimization fails if the coordinate transformation distorts\n"
20593 " the shape of rectangles. For example a plot in polar coordinates\n"
20594 " has to have rectangular set to false.\n"
20596 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20597 " defines the transformation between the zero-based indices of the\n"
20598 " matrix a and world coordinates. If\n"
20599 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20600 " indices of a are mapped to the range\n"
20602 " xmax and the y indices of a are mapped to the range\n"
20604 " ymax.For the C case, transformation functions are provided in the\n"
20605 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20606 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20607 " matrices. In addition, C callback routines for the transformation\n"
20608 " can be supplied by the user such as the mypltr function in\n"
20609 " examples/c/x09c.c which provides a general linear transformation\n"
20610 " between index coordinates and world coordinates.For languages\n"
20611 " other than C you should consult the PLplot documentation for the\n"
20612 " details concerning how PLTRANSFORM_callback arguments are\n"
20613 " interfaced. However, in general, a particular pattern of\n"
20614 " callback-associated arguments such as a tr vector with 6 elements;\n"
20615 " xg and yg vectors; or xg and yg matrices are respectively\n"
20616 " interfaced to a linear-transformation routine similar to the above\n"
20617 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20618 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20619 " support native language callbacks for handling index to\n"
20620 " world-coordinate transformations. Examples of these various\n"
20621 " approaches are given in examples/<language>x09*,\n"
20622 " examples/<language>x16*, examples/<language>x20*,\n"
20623 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20624 " supported languages.\n"
20626 " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
20627 " pass information to pltr0, pltr1, pltr2, or whatever routine that\n"
20628 " is externally supplied.\n"
20631 { (
char *)
"plshade",
_wrap_plshade, METH_VARARGS, (
char *)
"\n"
20632 "Shade individual region on the basis of value\n"
20636 " Shade individual region on the basis of value. Use plshades if you\n"
20637 " want to shade a number of contiguous regions using continuous colors.\n"
20638 " In particular the edge contours are treated properly in plshades. If\n"
20639 " you attempt to do contiguous regions with plshade the contours at the\n"
20640 " edge of the shade are partially obliterated by subsequent plots of\n"
20641 " contiguous shaded regions.\n"
20643 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20644 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20645 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20648 " This function is used in example 15.\n"
20654 "plshade(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"
20658 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20659 " plot. Should have dimensions of\n"
20663 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20665 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20667 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20668 " the region that should be plotted in the shade plot. This\n"
20669 " function accepts x and y coordinates as input arguments and must\n"
20670 " return 1 if the point is to be included in the shade plot and 0\n"
20671 " otherwise. If you want to plot the entire shade plot (the usual\n"
20672 " case), this argument should be set to NULL.\n"
20674 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20675 " pltr below for how these arguments are used (only for the special case\n"
20676 " when the callback function\n"
20677 " pltr is not supplied).\n"
20679 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20680 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20682 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20683 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20685 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20686 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20687 " then sh_color is interpreted as a cmap1 argument in the range\n"
20690 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20691 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20693 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20695 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20696 " boundary of shaded region. The min values are used for the\n"
20697 " shade_min boundary, and the max values are used on the shade_max\n"
20698 " boundary. Set color and width to zero for no plotted boundaries.\n"
20700 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20701 " boundary of shaded region. The min values are used for the\n"
20702 " shade_min boundary, and the max values are used on the shade_max\n"
20703 " boundary. Set color and width to zero for no plotted boundaries.\n"
20705 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20706 " boundary of shaded region. The min values are used for the\n"
20707 " shade_min boundary, and the max values are used on the shade_max\n"
20708 " boundary. Set color and width to zero for no plotted boundaries.\n"
20710 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20711 " boundary of shaded region. The min values are used for the\n"
20712 " shade_min boundary, and the max values are used on the shade_max\n"
20713 " boundary. Set color and width to zero for no plotted boundaries.\n"
20715 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20716 " Use plfill. Future version of PLplot may have other fill\n"
20719 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20720 " map to rectangles after coordinate transformation with pltrl.\n"
20721 " Otherwise, set rectangular to false. If rectangular is set to\n"
20722 " true, plshade tries to save time by filling large rectangles.\n"
20723 " This optimization fails if the coordinate transformation distorts\n"
20724 " the shape of rectangles. For example a plot in polar coordinates\n"
20725 " has to have rectangular set to false.\n"
20727 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20728 " defines the transformation between the zero-based indices of the\n"
20729 " matrix a and world coordinates. If\n"
20730 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20731 " indices of a are mapped to the range\n"
20733 " xmax and the y indices of a are mapped to the range\n"
20735 " ymax.For the C case, transformation functions are provided in the\n"
20736 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20737 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20738 " matrices. In addition, C callback routines for the transformation\n"
20739 " can be supplied by the user such as the mypltr function in\n"
20740 " examples/c/x09c.c which provides a general linear transformation\n"
20741 " between index coordinates and world coordinates.For languages\n"
20742 " other than C you should consult the PLplot documentation for the\n"
20743 " details concerning how PLTRANSFORM_callback arguments are\n"
20744 " interfaced. However, in general, a particular pattern of\n"
20745 " callback-associated arguments such as a tr vector with 6 elements;\n"
20746 " xg and yg vectors; or xg and yg matrices are respectively\n"
20747 " interfaced to a linear-transformation routine similar to the above\n"
20748 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20749 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20750 " support native language callbacks for handling index to\n"
20751 " world-coordinate transformations. Examples of these various\n"
20752 " approaches are given in examples/<language>x09*,\n"
20753 " examples/<language>x16*, examples/<language>x20*,\n"
20754 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20755 " supported languages.\n"
20757 " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
20758 " pass information to pltr0, pltr1, pltr2, or whatever routine that\n"
20759 " is externally supplied.\n"
20763 "Assign a function to use for generating custom axis labels\n"
20767 " This function allows a user to provide their own function to provide\n"
20768 " axis label text. The user function is given the numeric value for a\n"
20769 " point on an axis and returns a string label to correspond with that\n"
20770 " value. Custom axis labels can be enabled by passing appropriate\n"
20771 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20773 " This function is used in example 19.\n"
20779 "plslabelfunc(label_func, label_data)\n"
20783 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20784 " label function. In order to reset to the default labelling, set\n"
20785 " this to NULL. The labelling function parameters are, in order:\n"
20786 " axis: This indicates which axis a label is being requested for.\n"
20787 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20789 " value: This is the value along the axis which is being labelled.\n"
20791 " label_text: The string representation of the label value.\n"
20793 " length: The maximum length in characters allowed for label_text.\n"
20796 " label_data (PL_GENERIC_POINTER, input) : This parameter may be used\n"
20797 " to pass data to the label_func function.\n"
20800 { (
char *)
"plsmaj",
_wrap_plsmaj, METH_VARARGS, (
char *)
"\n"
20801 "Set length of major ticks\n"
20805 " This sets up the length of the major ticks. The actual length is the\n"
20806 " product of the default length and a scaling factor as for character\n"
20809 " Redacted form: plsmaj(def, scale)\n"
20811 " This function is used in example 29.\n"
20817 "plsmaj(def, scale)\n"
20821 " def (PLFLT, input) : The default length of a major tick in\n"
20822 " millimeters, should be set to zero if the default length is to\n"
20823 " remain unchanged.\n"
20825 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20826 " actual tick length.\n"
20829 { (
char *)
"plsmem",
_wrap_plsmem, METH_VARARGS, (
char *)
"\n"
20830 "Set the memory area to be plotted (RGB)\n"
20834 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20835 " the dev member of the stream structure. Also set the number of pixels\n"
20836 " in the memory passed in\n"
20837 " plotmem, which is a block of memory\n"
20839 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20841 " This memory will have to be freed by the user!\n"
20843 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20845 " This function is not used in any examples.\n"
20851 "plsmem(maxx, maxy, plotmem)\n"
20855 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20857 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20859 " plotmem (PL_NC_GENERIC_POINTER, input) : Pointer to the beginning\n"
20860 " of a user-supplied writeable memory area.\n"
20863 { (
char *)
"plsmema",
_wrap_plsmema, METH_VARARGS, (
char *)
"\n"
20864 "Set the memory area to be plotted (RGBA)\n"
20868 " Set the memory area to be plotted (with the memcairo driver) as the\n"
20869 " dev member of the stream structure. Also set the number of pixels in\n"
20870 " the memory passed in\n"
20871 " plotmem, which is a block of memory\n"
20873 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20875 " This memory will have to be freed by the user!\n"
20877 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20879 " This function is not used in any examples.\n"
20885 "plsmema(maxx, maxy, plotmem)\n"
20889 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20891 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20893 " plotmem (PL_NC_GENERIC_POINTER, input) : Pointer to the beginning\n"
20894 " of a user-supplied writeable memory area.\n"
20897 { (
char *)
"plsmin",
_wrap_plsmin, METH_VARARGS, (
char *)
"\n"
20898 "Set length of minor ticks\n"
20902 " This sets up the length of the minor ticks and the length of the\n"
20903 " terminals on error bars. The actual length is the product of the\n"
20904 " default length and a scaling factor as for character height.\n"
20906 " Redacted form: plsmin(def, scale)\n"
20908 " This function is used in example 29.\n"
20914 "plsmin(def, scale)\n"
20918 " def (PLFLT, input) : The default length of a minor tick in\n"
20919 " millimeters, should be set to zero if the default length is to\n"
20920 " remain unchanged.\n"
20922 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20923 " actual tick length.\n"
20926 { (
char *)
"plsori",
_wrap_plsori, METH_VARARGS, (
char *)
"\n"
20927 "Set orientation\n"
20931 " Set integer plot orientation parameter. This function is identical to\n"
20932 " plsdiori except for the type of the argument, and should be used in\n"
20933 " the same way. See the documentation of plsdiori for details.\n"
20935 " Redacted form: plsori(ori)\n"
20937 " This function is used in example 3.\n"
20947 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20948 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20952 { (
char *)
"plspage",
_wrap_plspage, METH_VARARGS, (
char *)
"\n"
20953 "Set page parameters\n"
20957 " Sets the page configuration (optional). If an individual parameter is\n"
20958 " zero then that parameter value is not updated. Not all parameters are\n"
20959 " recognized by all drivers and the interpretation is device-dependent.\n"
20960 " The X-window driver uses the length and offset parameters to determine\n"
20961 " the window size and location. The length and offset values are\n"
20962 " expressed in units that are specific to the current driver. For\n"
20963 " instance: screen drivers will usually interpret them as number of\n"
20964 " pixels, whereas printer drivers will usually use mm.\n"
20966 " This routine, if used, must be called before initializing PLplot. It\n"
20967 " may be called at later times for interactive drivers to change only\n"
20968 " the dpi for subsequent redraws which you can force via a call to\n"
20969 " plreplot. If this function is not called then the page size defaults\n"
20970 " to landscape A4 for drivers which use real world page sizes and 744\n"
20971 " pixels wide by 538 pixels high for raster drivers. The default value\n"
20972 " for dx and dy is 90 pixels per inch for raster drivers.\n"
20976 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20978 " This function is used in examples 14 and 31.\n"
20984 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20988 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20989 " by raster drivers, ignored by drivers which use \"real world\" units\n"
20992 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20993 " by raster drivers, ignored by drivers which use \"real world\" units\n"
20996 " xleng (PLINT, input) : Page length, x.\n"
20998 " yleng (PLINT, input) : Page length, y.\n"
21000 " xoff (PLINT, input) : Page offset, x.\n"
21002 " yoff (PLINT, input) : Page offset, y.\n"
21005 { (
char *)
"plspal0",
_wrap_plspal0, METH_VARARGS, (
char *)
"\n"
21006 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21010 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21012 " Redacted form: plspal0(filename)\n"
21014 " This function is in example 16.\n"
21020 "plspal0(filename)\n"
21024 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21025 " containing the name of the cmap0*.pal file. If this string is\n"
21026 " empty, use the default cmap0*.pal file.\n"
21029 { (
char *)
"plspal1",
_wrap_plspal1, METH_VARARGS, (
char *)
"\n"
21030 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21034 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21036 " Redacted form: plspal1(filename, interpolate)\n"
21038 " This function is used in example 16.\n"
21044 "plspal1(filename, interpolate)\n"
21048 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21049 " containing the name of the cmap1*.pal file. If this string is\n"
21050 " empty, use the default cmap1*.pal file.\n"
21052 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21053 " columns containing the intensity index, r, g, b, alpha and\n"
21054 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21055 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21056 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21057 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21058 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21059 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21060 " are used instead to set the cmap1 palette directly with a call to\n"
21064 { (
char *)
"plspause",
_wrap_plspause, METH_VARARGS, (
char *)
"\n"
21065 "Set the pause (on end-of-page) status\n"
21069 " Set the pause (on end-of-page) status.\n"
21071 " Redacted form: plspause(pause)\n"
21073 " This function is in examples 14,20.\n"
21079 "plspause(pause)\n"
21083 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21084 " end-of-page for those drivers which support this. Otherwise there\n"
21088 { (
char *)
"plsstrm",
_wrap_plsstrm, METH_VARARGS, (
char *)
"\n"
21089 "Set current output stream\n"
21093 " Sets the number of the current output stream. The stream number\n"
21094 " defaults to 0 unless changed by this routine. The first use of this\n"
21095 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21097 " Redacted form: plsstrm(strm)\n"
21099 " This function is examples 1,14,20.\n"
21109 " strm (PLINT, input) : The current stream number.\n"
21112 { (
char *)
"plssub",
_wrap_plssub, METH_VARARGS, (
char *)
"\n"
21113 "Set the number of subpages in x and y\n"
21117 " Set the number of subpages in x and y.\n"
21119 " Redacted form: plssub(nx, ny)\n"
21121 " This function is examples 1,2,14,21,25,27.\n"
21131 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21132 " of window columns).\n"
21134 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21135 " of window rows).\n"
21138 { (
char *)
"plssym",
_wrap_plssym, METH_VARARGS, (
char *)
"\n"
21139 "Set symbol size\n"
21143 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21144 " plsym. The actual height of a symbol is the product of the default\n"
21145 " symbol size and a scaling factor as for the character height.\n"
21147 " Redacted form: plssym(def, scale)\n"
21149 " This function is used in example 29.\n"
21155 "plssym(def, scale)\n"
21159 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21160 " should be set to zero if the default height is to remain\n"
21163 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21164 " actual symbol height.\n"
21167 { (
char *)
"plstar",
_wrap_plstar, METH_VARARGS, (
char *)
"\n"
21172 " Initializing the plotting package. The program prompts for the device\n"
21173 " keyword or number of the desired output device. Hitting a RETURN in\n"
21174 " response to the prompt is the same as selecting the first device. If\n"
21175 " only one device is enabled when PLplot is installed, plstar will issue\n"
21176 " no prompt. The output device is divided into nx by ny subpages, each\n"
21177 " of which may be used independently. The subroutine pladv is used to\n"
21178 " advance from one subpage to the next.\n"
21180 " Redacted form: plstar(nx, ny)\n"
21182 " This function is used in example 1.\n"
21192 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21195 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21199 { (
char *)
"plstart",
_wrap_plstart, METH_VARARGS, (
char *)
"\n"
21204 " Alternative to plstar for initializing the plotting package. The\n"
21205 " device name keyword for the desired output device must be supplied as\n"
21206 " an argument. These keywords are the same as those printed out by\n"
21207 " plstar. If the requested device is not available, or if the input\n"
21208 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21209 " is used. This routine also divides the output device page into nx by\n"
21210 " ny subpages, each of which may be used independently. The subroutine\n"
21211 " pladv is used to advance from one subpage to the next.\n"
21213 " Redacted form: General: plstart(devname, nx, ny)\n"
21214 " Perl/PDL: plstart(nx, ny, devname)\n"
21217 " This function is not used in any examples.\n"
21223 "plstart(devname, nx, ny)\n"
21227 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21228 " containing the device name keyword of the required output device.\n"
21230 " devname is NULL or if the first character of the string is a ``?'',\n"
21231 " the normal (prompted) start up is used.\n"
21233 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21236 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21241 "Set a global coordinate transform function\n"
21245 " This function can be used to define a coordinate transformation which\n"
21246 " affects all elements drawn within the current plot window. The\n"
21247 " coordinate_transform callback function is similar to that provided for\n"
21248 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21249 " parameter may be used to pass extra data to coordinate_transform.\n"
21251 " Redacted form: General: plstransform(coordinate_transform,\n"
21252 " coordinate_transform_data)\n"
21255 " This function is used in examples 19 and 22.\n"
21261 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21265 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21266 " function that defines the transformation from the input (x, y)\n"
21267 " world coordinates to new PLplot world coordinates. If\n"
21268 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21269 " case), then no transform is applied.\n"
21271 " coordinate_transform_data (PL_GENERIC_POINTER, input) : Optional\n"
21272 " extra data for\n"
21273 " coordinate_transform.\n"
21276 { (
char *)
"plstring",
_wrap_plstring, METH_VARARGS, (
char *)
"\n"
21277 "Plot a glyph at the specified points\n"
21281 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21282 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21283 " is specified with a PLplot user string. Note that the user string is\n"
21284 " not actually limited to one glyph so it is possible (but not normally\n"
21285 " useful) to plot more than one glyph at the specified points with this\n"
21286 " function. As with plmtex and plptex, the user string can contain FCI\n"
21287 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21288 " else PLplot escapes for Hershey or unicode text to determine the\n"
21291 " Redacted form: plstring(x, y, string)\n"
21293 " This function is used in examples 4, 21 and 26.\n"
21299 "plstring(n, x, y, string)\n"
21303 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21305 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21308 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21311 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21312 " the glyph(s) to be plotted at each of the n points.\n"
21316 "Plot a glyph at the specified 3D points\n"
21320 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21321 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21322 " this function similar to what is done for plline3. The glyph is\n"
21323 " specified with a PLplot user string. Note that the user string is not\n"
21324 " actually limited to one glyph so it is possible (but not normally\n"
21325 " useful) to plot more than one glyph at the specified points with this\n"
21326 " function. As with plmtex and plptex, the user string can contain FCI\n"
21327 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21328 " else PLplot escapes for Hershey or unicode text to determine the\n"
21331 " Redacted form: plstring3(x, y, z, string)\n"
21333 " This function is used in example 18.\n"
21339 "plstring3(n, x, y, z, string)\n"
21343 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21345 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21348 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21351 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21354 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21355 " the glyph(s) to be plotted at each of the n points. points.\n"
21358 { (
char *)
"plstripa",
_wrap_plstripa, METH_VARARGS, (
char *)
"\n"
21359 "Add a point to a strip chart\n"
21363 " Add a point to a given pen of a given strip chart. There is no need\n"
21364 " for all pens to have the same number of points or to be equally\n"
21365 " sampled in the x coordinate. Allocates memory and rescales as\n"
21368 " Redacted form: plstripa(id, pen, x, y)\n"
21370 " This function is used in example 17.\n"
21376 "plstripa(id, pen, x, y)\n"
21380 " id (PLINT, input) : Identification number of the strip chart (set\n"
21381 " up in plstripc).\n"
21383 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21385 " x (PLFLT, input) : X coordinate of point to plot.\n"
21387 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21390 { (
char *)
"plstripc",
_wrap_plstripc, METH_VARARGS, (
char *)
"\n"
21391 "Create a 4-pen strip chart\n"
21395 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21397 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21398 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21399 " styline, legline, labx, laby, labz)\n"
21400 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
21401 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
21402 " ypsec, legline, labx, laby, labtop)\n"
21405 " This function is used in example 17.\n"
21411 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21415 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21416 " number of the strip chart to use on plstripa and plstripd.\n"
21418 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21419 " the x-axis specification as in plbox.\n"
21421 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21422 " the y-axis specification as in plbox.\n"
21424 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21425 " change as data are added.\n"
21427 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21428 " change as data are added.\n"
21430 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21431 " is multiplied by the factor (1 +\n"
21434 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21435 " change as data are added.\n"
21437 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21438 " change as data are added.\n"
21440 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21442 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21444 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21445 " true, otherwise not.\n"
21447 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21448 " otherwise slide display.\n"
21450 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21452 " collab (PLINT, input) : Legend color index (cmap0).\n"
21454 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21455 " indices for the 4 pens.\n"
21457 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21458 " indices for the 4 pens.\n"
21460 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21461 " strings containing legends for the 4 pens.\n"
21463 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21464 " the label for the x axis.\n"
21466 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21467 " the label for the y axis.\n"
21469 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21470 " the plot title.\n"
21473 { (
char *)
"plstripd",
_wrap_plstripd, METH_VARARGS, (
char *)
"\n"
21474 "Deletes and releases memory used by a strip chart\n"
21478 " Deletes and releases memory used by a strip chart.\n"
21480 " Redacted form: plstripd(id)\n"
21482 " This function is used in example 17.\n"
21492 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21495 { (
char *)
"plstyl",
_wrap_plstyl, METH_VARARGS, (
char *)
"\n"
21500 " This sets up the line style for all lines subsequently drawn. A line\n"
21501 " consists of segments in which the pen is alternately down and up. The\n"
21502 " lengths of these segments are passed in the vectors mark and space\n"
21503 " respectively. The number of mark-space pairs is specified by nms. In\n"
21504 " order to return the line style to the default continuous line, plstyl\n"
21505 " should be called with nms =0 .(see also pllsty)\n"
21507 " Redacted form: plstyl(mark, space)\n"
21509 " This function is used in examples 1, 9, and 14.\n"
21515 "plstyl(nms, mark, space)\n"
21519 " nms (PLINT, input) : The number of mark and space elements in a\n"
21520 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21521 " . A continuous line is specified by setting nms=0 .\n"
21523 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21524 " segments during which the pen is down, measured in micrometers.\n"
21526 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21527 " the segments during which the pen is up, measured in micrometers.\n"
21530 { (
char *)
"plsvect",
_wrap_plsvect, METH_VARARGS, (
char *)
"\n"
21531 "Set arrow style for vector plots\n"
21535 " Set the style for the arrow used by plvect to plot vectors.\n"
21537 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21539 " This function is used in example 22.\n"
21545 "plsvect(arrowx, arrowy, npts, fill)\n"
21549 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21550 " the x and y points which make up the arrow. The arrow is plotted\n"
21551 " by joining these points to form a polygon. The scaling assumes\n"
21552 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21553 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21554 " will be reset to its default.\n"
21556 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21559 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21560 " fill is false then the arrow is open.\n"
21563 { (
char *)
"plsvpa",
_wrap_plsvpa, METH_VARARGS, (
char *)
"\n"
21564 "Specify viewport in absolute coordinates\n"
21568 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21569 " should be used only if the viewport is required to have a definite\n"
21570 " size in millimeters. The routine plgspa is useful for finding out the\n"
21571 " size of the current subpage.\n"
21573 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21575 " This function is used in example 10.\n"
21581 "plsvpa(xmin, xmax, ymin, ymax)\n"
21585 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21586 " viewport from the left-hand edge of the subpage in millimeters.\n"
21588 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21589 " viewport from the left-hand edge of the subpage in millimeters.\n"
21591 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21592 " viewport from the bottom edge of the subpage in millimeters.\n"
21594 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21595 " from the bottom edge of the subpage in millimeters.\n"
21598 { (
char *)
"plsxax",
_wrap_plsxax, METH_VARARGS, (
char *)
"\n"
21599 "Set x axis parameters\n"
21603 " Sets values of the digmax and digits flags for the x axis. See the\n"
21604 " PLplot documentation for more information.\n"
21606 " Redacted form: plsxax(digmax, digits)\n"
21608 " This function is used in example 31.\n"
21614 "plsxax(digmax, digits)\n"
21618 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21619 " digits for the x axis. If nonzero, the printed label will be\n"
21620 " switched to a floating-point representation when the number of\n"
21621 " digits exceeds digmax.\n"
21623 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21624 " its value here has no effect since it is set only by plbox or\n"
21625 " plbox3. However, the user may obtain its value after a call to\n"
21626 " either of these functions by calling plgxax.\n"
21629 { (
char *)
"plsyax",
_wrap_plsyax, METH_VARARGS, (
char *)
"\n"
21630 "Set y axis parameters\n"
21634 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21635 " the description of plsxax for more detail.\n"
21637 " Redacted form: plsyax(digmax, digits)\n"
21639 " This function is used in examples 1, 14, and 31.\n"
21645 "plsyax(digmax, digits)\n"
21649 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21650 " digits for the y axis. If nonzero, the printed label will be\n"
21651 " switched to a floating-point representation when the number of\n"
21652 " digits exceeds digmax.\n"
21654 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21655 " its value here has no effect since it is set only by plbox or\n"
21656 " plbox3. However, the user may obtain its value after a call to\n"
21657 " either of these functions by calling plgyax.\n"
21660 { (
char *)
"plsym",
_wrap_plsym, METH_VARARGS, (
char *)
"\n"
21661 "Plot a glyph at the specified points\n"
21665 " Plot a glyph at the specified points. (This function is largely\n"
21666 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21668 " Redacted form: plsym(x, y, code)\n"
21670 " This function is used in example 7.\n"
21676 "plsym(n, x, y, code)\n"
21680 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21682 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21685 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21688 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21689 " to be plotted at each of the n points.\n"
21692 { (
char *)
"plszax",
_wrap_plszax, METH_VARARGS, (
char *)
"\n"
21693 "Set z axis parameters\n"
21697 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21698 " the description of plsxax for more detail.\n"
21700 " Redacted form: plszax(digmax, digits)\n"
21702 " This function is used in example 31.\n"
21708 "plszax(digmax, digits)\n"
21712 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21713 " digits for the z axis. If nonzero, the printed label will be\n"
21714 " switched to a floating-point representation when the number of\n"
21715 " digits exceeds digmax.\n"
21717 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21718 " its value here has no effect since it is set only by plbox or\n"
21719 " plbox3. However, the user may obtain its value after a call to\n"
21720 " either of these functions by calling plgzax.\n"
21723 { (
char *)
"pltext",
_wrap_pltext, METH_VARARGS, (
char *)
"\n"
21724 "Switch to text screen\n"
21728 " Sets an interactive device to text mode, used in conjunction with\n"
21729 " plgra to allow graphics and text to be interspersed. On a device\n"
21730 " which supports separate text and graphics windows, this command causes\n"
21731 " control to be switched to the text window. This can be useful for\n"
21732 " printing diagnostic messages or getting user input, which would\n"
21733 " otherwise interfere with the plots. The program must switch back to\n"
21734 " the graphics window before issuing plot commands, as the text (or\n"
21735 " console) device will probably become quite confused otherwise. If\n"
21736 " already in text mode, this command is ignored. It is also ignored on\n"
21737 " devices which only support a single window or use a different method\n"
21738 " for shifting focus (see also plgra).\n"
21740 " Redacted form: pltext()\n"
21742 " This function is used in example 1.\n"
21752 "Set format for date / time labels\n"
21756 " Sets the format for date / time labels. To enable date / time format\n"
21757 " labels see the options to plbox, plbox3, and plenv.\n"
21759 " Redacted form: pltimefmt(fmt)\n"
21761 " This function is used in example 29.\n"
21771 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21772 " interpreted similarly to the format specifier of typical system\n"
21773 " strftime routines except that PLplot ignores locale and also\n"
21774 " supplies some useful extensions in the context of plotting. All\n"
21775 " text in the string is printed as-is other than conversion\n"
21776 " specifications which take the form of a '%' character followed by\n"
21777 " further conversion specification character. The conversion\n"
21778 " specifications which are similar to those provided by system\n"
21779 " strftime routines are the following: %a: The abbreviated (English)\n"
21781 " %A: The full (English) weekday name.\n"
21782 " %b: The abbreviated (English) month name.\n"
21783 " %B: The full (English) month name.\n"
21784 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21785 " %C: The century number (year/100) as a 2-digit integer.\n"
21786 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21787 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21788 " %e: Like %d, but a leading zero is replaced by a space.\n"
21789 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21790 " %h: Equivalent to %b.\n"
21791 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21793 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21795 " %j: The day of the year as a decimal number (range 001 to\n"
21797 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21798 " 23); single digits are preceded by a blank. (See also %H.)\n"
21799 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21800 " 12); single digits are preceded by a blank. (See also %I.)\n"
21801 " %m: The month as a decimal number (range 01 to 12).\n"
21802 " %M: The minute as a decimal number (range 00 to 59).\n"
21803 " %n: A newline character.\n"
21804 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21805 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21806 " %r: Equivalent to %I:%M:%S %p.\n"
21807 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21808 " including the seconds, see %T below.\n"
21809 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21811 " %S: The second as a decimal number (range 00 to 60). (The\n"
21812 " range is up to 60 to allow for occasional leap seconds.)\n"
21813 " %t: A tab character.\n"
21814 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21815 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21816 " being 1. See also %w.\n"
21817 " %U: The week number of the current year as a decimal number,\n"
21818 " range 00 to 53, starting with the first Sunday as the first\n"
21819 " day of week 01. See also %V and %W.\n"
21820 " %v: Equivalent to %e-%b-%Y.\n"
21821 " %V: The ISO 8601 week number of the current year as a decimal\n"
21822 " number, range 01 to 53, where week 1 is the first week that\n"
21823 " has at least 4 days in the new year. See also %U and %W.\n"
21824 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21825 " being 0. See also %u.\n"
21826 " %W: The week number of the current year as a decimal number,\n"
21827 " range 00 to 53, starting with the first Monday as the first\n"
21828 " day of week 01.\n"
21829 " %x: Equivalent to %a %b %d %Y.\n"
21830 " %X: Equivalent to %T.\n"
21831 " %y: The year as a decimal number without a century (range 00\n"
21833 " %Y: The year as a decimal number including a century.\n"
21834 " %z: The UTC time-zone string = \"+0000\".\n"
21835 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21836 " %+: The UTC date and time in default format of the Unix date\n"
21837 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21838 " %%: A literal \"%\" character.\n"
21839 " The conversion specifications which are extensions to those normally\n"
21840 " provided by system strftime routines are the following: %(0-9):\n"
21841 " The fractional part of the seconds field (including leading\n"
21842 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21843 " seconds to millisecond accuracy (00.000).\n"
21844 " %.: The fractional part of the seconds field (including\n"
21845 " leading decimal point) to the maximum available accuracy. Thus\n"
21846 " %S%. would give seconds with fractional part up to 9 decimal\n"
21847 " places if available.\n"
21850 { (
char *)
"plvasp",
_wrap_plvasp, METH_VARARGS, (
char *)
"\n"
21851 "Specify viewport using aspect ratio only\n"
21855 " Selects the largest viewport with the given aspect ratio within the\n"
21856 " subpage that leaves a standard margin (left-hand margin of eight\n"
21857 " character heights, and a margin around the other three sides of five\n"
21858 " character heights).\n"
21860 " Redacted form: plvasp(aspect)\n"
21862 " This function is used in example 13.\n"
21872 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21873 " axis of resulting viewport.\n"
21876 { (
char *)
"plvect",
_wrap_plvect, METH_VARARGS, (
char *)
"\n"
21881 " Draws a plot of vector data contained in the matrices (\n"
21887 " ny]) . The scaling factor for the vectors is given by scale. A\n"
21888 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21889 " additional data required by the transformation routine to map indices\n"
21890 " within the matrices to the world coordinates. The style of the vector\n"
21891 " arrow may be set using plsvect.\n"
21893 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21894 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21895 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21896 " with either one or two dimensions.\n"
21898 " This function is used in example 22.\n"
21904 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21908 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21909 " and y components of the vector data to be plotted.\n"
21911 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21913 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21914 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21915 " automatically calculated for the data. If scale < 0 then the\n"
21916 " scaling factor is automatically calculated for the data and then\n"
21917 " multiplied by -\n"
21918 " scale. If scale > 0 then the scaling factor is set to scale.\n"
21920 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21921 " defines the transformation between the zero-based indices of the\n"
21922 " matrices u and v and world coordinates.For the C case,\n"
21923 " transformation functions are provided in the PLplot library: pltr0\n"
21924 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21925 " mappings respectively defined by vectors and matrices. In\n"
21926 " addition, C callback routines for the transformation can be\n"
21927 " supplied by the user such as the mypltr function in\n"
21928 " examples/c/x09c.c which provides a general linear transformation\n"
21929 " between index coordinates and world coordinates.For languages\n"
21930 " other than C you should consult the PLplot documentation for the\n"
21931 " details concerning how PLTRANSFORM_callback arguments are\n"
21932 " interfaced. However, in general, a particular pattern of\n"
21933 " callback-associated arguments such as a tr vector with 6 elements;\n"
21934 " xg and yg vectors; or xg and yg matrices are respectively\n"
21935 " interfaced to a linear-transformation routine similar to the above\n"
21936 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21937 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21938 " support native language callbacks for handling index to\n"
21939 " world-coordinate transformations. Examples of these various\n"
21940 " approaches are given in examples/<language>x09*,\n"
21941 " examples/<language>x16*, examples/<language>x20*,\n"
21942 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21943 " supported languages.\n"
21945 " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
21946 " pass information to pltr0, pltr1, pltr2, or whatever callback\n"
21947 " routine that is externally supplied.\n"
21950 { (
char *)
"plvpas",
_wrap_plvpas, METH_VARARGS, (
char *)
"\n"
21951 "Specify viewport using coordinates and aspect ratio\n"
21955 " Device-independent routine for setting up the viewport. The viewport\n"
21956 " is chosen to be the largest with the given aspect ratio that fits\n"
21957 " within the specified region (in terms of normalized subpage\n"
21958 " coordinates). This routine is functionally equivalent to plvpor when\n"
21959 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21960 " routine reserves no extra space at the edges for labels.\n"
21962 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21964 " This function is used in example 9.\n"
21970 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21974 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21975 " left-hand edge of the viewport.\n"
21977 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21978 " right-hand edge of the viewport.\n"
21980 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21981 " bottom edge of the viewport.\n"
21983 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21984 " edge of the viewport.\n"
21986 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21990 { (
char *)
"plvpor",
_wrap_plvpor, METH_VARARGS, (
char *)
"\n"
21991 "Specify viewport using normalized subpage coordinates\n"
21995 " Device-independent routine for setting up the viewport. This defines\n"
21996 " the viewport in terms of normalized subpage coordinates which run from\n"
21997 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21998 " current subpage. Use the alternate routine plsvpa in order to create\n"
21999 " a viewport of a definite size.\n"
22001 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22003 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22004 " 24, 26, 27, and 31.\n"
22010 "plvpor(xmin, xmax, ymin, ymax)\n"
22014 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22015 " left-hand edge of the viewport.\n"
22017 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22018 " right-hand edge of the viewport.\n"
22020 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22021 " bottom edge of the viewport.\n"
22023 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22024 " edge of the viewport.\n"
22027 { (
char *)
"plvsta",
_wrap_plvsta, METH_VARARGS, (
char *)
"\n"
22028 "Select standard viewport\n"
22032 " Selects the largest viewport within the subpage that leaves a standard\n"
22033 " margin (left-hand margin of eight character heights, and a margin\n"
22034 " around the other three sides of five character heights).\n"
22036 " Redacted form: plvsta()\n"
22038 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22047 { (
char *)
"plw3d",
_wrap_plw3d, METH_VARARGS, (
char *)
"\n"
22048 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22052 " Configure the transformations required for projecting a 3D surface on\n"
22053 " an existing 2D window. Those transformations (see the PLplot\n"
22054 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22055 " surface which has its limits expressed in 3D world coordinates and\n"
22056 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22057 " azimuth of the viewing angle). The transformations consist of the\n"
22058 " linear transform from 3D world coordinates to normalized 3D\n"
22059 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22060 " align the pole of the new 3D coordinate system with the viewing\n"
22061 " direction specified by altitude and azimuth so that x and y of the\n"
22062 " surface elements in that transformed coordinate system are the\n"
22063 " projection of the 3D surface with given viewing direction on the 2D\n"
22066 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22067 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22068 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22069 " sizes of basex by basey by height so that xmin maps to -\n"
22070 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22071 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22072 " The resulting rectangular cuboid in normalized coordinates is then\n"
22073 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22074 " must be called before plbox3 or any of the 3D surface plotting\n"
22075 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22076 " plsurf3dl or plfill3.\n"
22078 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22079 " zmin, zmax, alt, az)\n"
22081 " This function is examples 8, 11, 18, and 21.\n"
22087 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22091 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22092 " rectangular cuboid.\n"
22094 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22095 " rectangular cuboid.\n"
22097 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22098 " rectangular cuboid.\n"
22100 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22101 " rectangular cuboid.\n"
22103 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22104 " rectangular cuboid.\n"
22106 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22107 " rectangular cuboid.\n"
22109 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22110 " rectangular cuboid.\n"
22112 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22113 " rectangular cuboid.\n"
22115 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22116 " rectangular cuboid.\n"
22118 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22119 " plane of the rectangular cuboid in normalized coordinates.\n"
22121 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22122 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22123 " observer is looking face onto the zx plane of the rectangular\n"
22124 " cuboid in normalized coordinates, and as az is increased, the\n"
22125 " observer moves clockwise around that cuboid when viewed from above\n"
22129 { (
char *)
"plwidth",
_wrap_plwidth, METH_VARARGS, (
char *)
"\n"
22134 " Sets the pen width.\n"
22136 " Redacted form: plwidth(width)\n"
22138 " This function is used in examples 1 and 2.\n"
22148 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22149 " or the same as the previous value no action is taken. width = 0.\n"
22150 " should be interpreted as as the minimum valid pen width for the\n"
22151 " device. The interpretation of positive width values is also\n"
22152 " device dependent.\n"
22155 { (
char *)
"plwind",
_wrap_plwind, METH_VARARGS, (
char *)
"\n"
22160 " Specify the window, i.e., the world coordinates of the edges of the\n"
22163 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22165 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22172 "plwind(xmin, xmax, ymin, ymax)\n"
22176 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22177 " of the viewport.\n"
22179 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22180 " of the viewport.\n"
22182 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22185 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22189 { (
char *)
"plxormod",
_wrap_plxormod, METH_VARARGS, (
char *)
"\n"
22190 "Enter or leave xor mode\n"
22194 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22195 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22196 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22197 " is not capable of xor operation it returns a status of false.\n"
22199 " Redacted form: plxormod(mode, status)\n"
22201 " This function is used in examples 1 and 20.\n"
22207 "plxormod(mode, status)\n"
22211 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22212 " is false means leave xor mode.\n"
22214 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22215 " modestatus of true (false) means driver is capable (incapable) of\n"
22219 { (
char *)
"plmap",
_wrap_plmap, METH_VARARGS, (
char *)
"\n"
22220 "Plot continental outline or shapefile data in world coordinates\n"
22224 " Plots continental outlines or shapefile data in world coordinates. A\n"
22225 " demonstration of how to use this function to create different\n"
22226 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22227 " basic coastal outlines and USA state borders. These can be used\n"
22228 " irrespective of whether Shapefile support is built into PLplot. With\n"
22229 " Shapefile support this function can also be used with user Shapefiles,\n"
22230 " in which case it will plot the entire contents of a Shapefile joining\n"
22231 " each point of each Shapefile element with a line. Shapefiles have\n"
22232 " become a popular standard for geographical data and data in this\n"
22233 " format can be easily found from a number of online sources. Shapefile\n"
22234 " data is actually provided as three or more files with the same\n"
22235 " filename, but different extensions. The .shp and .shx files are\n"
22236 " required for plotting Shapefile data with PLplot.\n"
22238 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22240 " This function is used in example 19.\n"
22246 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22250 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22251 " transform the original map data coordinates to a new coordinate\n"
22252 " system. The PLplot-supplied map data is provided as latitudes and\n"
22253 " longitudes; other Shapefile data may be provided in other\n"
22254 " coordinate systems as can be found in their .prj plain text files.\n"
22255 " For example, by using this transform we can change from a\n"
22256 " longitude, latitude coordinate to a polar stereographic\n"
22257 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22258 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22259 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22260 " data). After the call to mapform(), x[] and y[] should be\n"
22261 " replaced by the corresponding plot coordinates. If no transform is\n"
22262 " desired, mapform can be replaced by NULL.\n"
22264 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22265 " the type of map plotted. This is either one of the PLplot built-in\n"
22266 " maps or the file name of a set of Shapefile files without the file\n"
22267 " extensions. For the PLplot built-in maps the possible values are:\n"
22268 " \"globe\" -- continental outlines\n"
22269 " \"usa\" -- USA and state boundaries\n"
22270 " \"cglobe\" -- continental outlines and countries\n"
22271 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22274 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22275 " drawn. For the built in maps this is a measure of longitude. For\n"
22276 " Shapefiles the units must match the projection. The value of minx\n"
22277 " must be less than the value of maxx. Specifying a useful limit for\n"
22278 " these limits provides a useful optimization for complex or\n"
22279 " detailed maps.\n"
22281 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22284 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22285 " drawn. For the built in maps this is a measure of latitude. For\n"
22286 " Shapefiles the units must match the projection. The value of miny\n"
22287 " must be less than the value of maxy.\n"
22289 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22294 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22298 " Plot all or a subset of Shapefile data using lines in world\n"
22299 " coordinates. Our 19th standard example demonstrates how to use this\n"
22300 " function. This function plots data from a Shapefile using lines as in\n"
22301 " plmap, however it also has the option of also only drawing specified\n"
22302 " elements from the Shapefile. The vector of indices of the required\n"
22303 " elements are passed as a function argument. The Shapefile data should\n"
22304 " include a metadata file (extension.dbf) listing all items within the\n"
22305 " Shapefile. This file can be opened by most popular spreadsheet\n"
22306 " programs and can be used to decide which indices to pass to this\n"
22309 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22312 " This function is used in example 19.\n"
22318 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22322 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22323 " transform the coordinates given in the shapefile into a plot\n"
22324 " coordinate system. By using this transform, we can change from a\n"
22325 " longitude, latitude coordinate to a polar stereographic project,\n"
22326 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22327 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22328 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22329 " plot coordinates. If no transform is desired, mapform can be\n"
22330 " replaced by NULL.\n"
22332 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22333 " the file name of a set of Shapefile files without the file\n"
22336 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22337 " be in the same units as used by the Shapefile. You could use a\n"
22338 " very large negative number to plot everything, but you can improve\n"
22339 " performance by limiting the area drawn. The units must match those\n"
22340 " of the Shapefile projection, which may be for example longitude or\n"
22341 " distance. The value of minx must be less than the value of maxx.\n"
22343 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22344 " use a very large number to plot everything, but you can improve\n"
22345 " performance by limiting the area drawn.\n"
22347 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22348 " be in the same units as used by the Shapefile. You could use a\n"
22349 " very large negative number to plot everything, but you can improve\n"
22350 " performance by limiting the area drawn. The units must match those\n"
22351 " of the Shapefile projection, which may be for example latitude or\n"
22352 " distance. The value of miny must be less than the value of maxy.\n"
22354 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22355 " use a very large number to plot everything, but you can improve\n"
22356 " performance by limiting the area drawn.\n"
22358 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22359 " zero-based indices of the Shapefile elements which will be drawn.\n"
22361 " plotentries to NULL will plot all elements of the Shapefile.\n"
22363 " nplotentries (PLINT, input) : The number of items in\n"
22364 " plotentries. Ignored if\n"
22365 " plotentries is NULL.\n"
22369 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22373 " As per plmapline, however the items are plotted as strings or points\n"
22374 " in the same way as plstring.\n"
22376 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22377 " maxy, plotentries)\n"
22379 " This function is not used in any examples.\n"
22385 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22389 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22390 " transform the coordinates given in the shapefile into a plot\n"
22391 " coordinate system. By using this transform, we can change from a\n"
22392 " longitude, latitude coordinate to a polar stereographic project,\n"
22393 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22394 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22395 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22396 " plot coordinates. If no transform is desired, mapform can be\n"
22397 " replaced by NULL.\n"
22399 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22400 " the file name of a set of Shapefile files without the file\n"
22403 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22406 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22407 " be in the same units as used by the Shapefile. You could use a\n"
22408 " very large negative number to plot everything, but you can improve\n"
22409 " performance by limiting the area drawn. The units must match those\n"
22410 " of the Shapefile projection, which may be for example longitude or\n"
22411 " distance. The value of minx must be less than the value of maxx.\n"
22413 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22414 " use a very large number to plot everything, but you can improve\n"
22415 " performance by limiting the area drawn.\n"
22417 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22418 " be in the same units as used by the Shapefile. You could use a\n"
22419 " very large negative number to plot everything, but you can improve\n"
22420 " performance by limiting the area drawn. The units must match those\n"
22421 " of the Shapefile projection, which may be for example latitude or\n"
22422 " distance. The value of miny must be less than the value of maxy.\n"
22424 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22425 " use a very large number to plot everything, but you can improve\n"
22426 " performance by limiting the area drawn.\n"
22428 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22429 " zero-based indices of the Shapefile elements which will be drawn.\n"
22431 " plotentries to NULL will plot all elements of the Shapefile.\n"
22433 " nplotentries (PLINT, input) : The number of items in\n"
22434 " plotentries. Ignored if\n"
22435 " plotentries is NULL.\n"
22438 { (
char *)
"plmaptex",
_wrap_plmaptex, METH_VARARGS, (
char *)
"\n"
22439 "Draw text at points defined by Shapefile data in world coordinates\n"
22443 " As per plmapline, however the items are plotted as text in the same\n"
22444 " way as plptex.\n"
22446 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22447 " miny, maxy, plotentry)\n"
22449 " This function is used in example 19.\n"
22455 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22459 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22460 " transform the coordinates given in the shapefile into a plot\n"
22461 " coordinate system. By using this transform, we can change from a\n"
22462 " longitude, latitude coordinate to a polar stereographic project,\n"
22463 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22464 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22465 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22466 " plot coordinates. If no transform is desired, mapform can be\n"
22467 " replaced by NULL.\n"
22469 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22470 " the file name of a set of Shapefile files without the file\n"
22473 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22476 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22479 " just (PLFLT, input) : Set the justification of the text. The value\n"
22480 " given will be the fraction of the distance along the string that\n"
22481 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22482 " centralized text and 1.0 gives right aligned text.\n"
22484 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22486 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22487 " be in the same units as used by the Shapefile. You could use a\n"
22488 " very large negative number to plot everything, but you can improve\n"
22489 " performance by limiting the area drawn. The units must match those\n"
22490 " of the Shapefile projection, which may be for example longitude or\n"
22491 " distance. The value of minx must be less than the value of maxx.\n"
22493 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22494 " use a very large number to plot everything, but you can improve\n"
22495 " performance by limiting the area drawn.\n"
22497 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22498 " be in the same units as used by the Shapefile. You could use a\n"
22499 " very large negative number to plot everything, but you can improve\n"
22500 " performance by limiting the area drawn. The units must match those\n"
22501 " of the Shapefile projection, which may be for example latitude or\n"
22502 " distance. The value of miny must be less than the value of maxy.\n"
22504 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22505 " use a very large number to plot everything, but you can improve\n"
22506 " performance by limiting the area drawn.\n"
22508 " plotentry (PLINT, input) : An integer indicating which text string\n"
22509 " of the Shapefile (zero indexed) will be drawn.\n"
22513 "Plot all or a subset of Shapefile data, filling the polygons\n"
22517 " As per plmapline, however the items are filled in the same way as\n"
22520 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22523 " This function is used in example 19.\n"
22529 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22533 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22534 " transform the coordinates given in the shapefile into a plot\n"
22535 " coordinate system. By using this transform, we can change from a\n"
22536 " longitude, latitude coordinate to a polar stereographic project,\n"
22537 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22538 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22539 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22540 " plot coordinates. If no transform is desired, mapform can be\n"
22541 " replaced by NULL.\n"
22543 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22544 " the file name of a set of Shapefile files without the file\n"
22547 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22548 " be in the same units as used by the Shapefile. You could use a\n"
22549 " very large negative number to plot everything, but you can improve\n"
22550 " performance by limiting the area drawn. The units must match those\n"
22551 " of the Shapefile projection, which may be for example longitude or\n"
22552 " distance. The value of minx must be less than the value of maxx.\n"
22554 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22555 " use a very large number to plot everything, but you can improve\n"
22556 " performance by limiting the area drawn.\n"
22558 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22559 " be in the same units as used by the Shapefile. You could use a\n"
22560 " very large negative number to plot everything, but you can improve\n"
22561 " performance by limiting the area drawn. The units must match those\n"
22562 " of the Shapefile projection, which may be for example latitude or\n"
22563 " distance. The value of miny must be less than the value of maxy.\n"
22565 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22566 " use a very large number to plot everything, but you can improve\n"
22567 " performance by limiting the area drawn.\n"
22569 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22570 " zero-based indices of the Shapefile elements which will be drawn.\n"
22572 " plotentries to NULL will plot all elements of the Shapefile.\n"
22574 " nplotentries (PLINT, input) : The number of items in\n"
22575 " plotentries. Ignored if\n"
22576 " plotentries is NULL.\n"
22580 "Plot latitude and longitude lines\n"
22584 " Displays latitude and longitude on the current plot. The lines are\n"
22585 " plotted in the current color and line style.\n"
22587 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22588 " minlat, maxlat)\n"
22590 " This function is used in example 19.\n"
22596 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22600 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22601 " transform the coordinate longitudes and latitudes to a plot\n"
22602 " coordinate system. By using this transform, we can change from a\n"
22603 " longitude, latitude coordinate to a polar stereographic project,\n"
22604 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22605 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22606 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22607 " plot coordinates. If no transform is desired, mapform can be\n"
22608 " replaced by NULL.\n"
22610 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22611 " longitude lines are to be plotted.\n"
22613 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22614 " lines are to be plotted.\n"
22616 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22617 " side of the plot. The value of minlong must be less than the value\n"
22618 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22621 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22622 " side of the plot.\n"
22624 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22625 " background. One can always use -90.0 as the boundary outside the\n"
22626 " plot window will be automatically eliminated. However, the\n"
22627 " program will be faster if one can reduce the size of the\n"
22628 " background plotted.\n"
22630 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22631 " background. One can always use 90.0 as the boundary outside the\n"
22632 " plot window will be automatically eliminated.\n"
22635 { (
char *)
"plimage",
_wrap_plimage, METH_VARARGS, (
char *)
"\n"
22636 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22640 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22641 " automatically adjusted to use the maximum and minimum values in idata\n"
22642 " as valuemin and valuemax in a call to plimagefr.\n"
22644 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22645 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22648 " This function is used in example 20.\n"
22654 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22658 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22659 " to plot. Should have dimensions of\n"
22663 " nx, ny (PLINT, input) : Dimensions of idata\n"
22665 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22666 " are linearly transformed to these world coordinate ranges such\n"
22667 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22668 " - 1] corresponds to (xmax, ymax).\n"
22670 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22671 " (inclusive) will be plotted.\n"
22673 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22674 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22675 " Dymin) to (Dxmax, Dymax).\n"
22679 "Plot a 2D matrix using cmap1\n"
22683 " Plot a 2D matrix using cmap1.\n"
22685 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22686 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22689 " This function is used in example 20.\n"
22695 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22699 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22700 " plot. Should have dimensions of\n"
22704 " nx, ny (PLINT, input) : Dimensions of idata\n"
22706 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22707 " pltr below for how these arguments are used (only for the special case\n"
22708 " when the callback function\n"
22709 " pltr is not supplied).\n"
22711 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22712 " (inclusive) will be plotted.\n"
22714 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22715 " values to use for value to color mappings. A datum equal to or\n"
22716 " less than valuemin will be plotted with color 0.0, while a datum\n"
22717 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22718 " Data between valuemin and valuemax map linearly to colors in the\n"
22719 " range (0.0-1.0).\n"
22721 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22722 " defines the transformation between the zero-based indices of the\n"
22723 " matrix idata and world coordinates. If\n"
22724 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22725 " indices of idata are mapped to the range\n"
22727 " xmax and the y indices of idata are mapped to the range\n"
22729 " ymax.For the C case, transformation functions are provided in the\n"
22730 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22731 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22732 " matrices. In addition, C callback routines for the transformation\n"
22733 " can be supplied by the user such as the mypltr function in\n"
22734 " examples/c/x09c.c which provides a general linear transformation\n"
22735 " between index coordinates and world coordinates.For languages\n"
22736 " other than C you should consult the PLplot documentation for the\n"
22737 " details concerning how PLTRANSFORM_callback arguments are\n"
22738 " interfaced. However, in general, a particular pattern of\n"
22739 " callback-associated arguments such as a tr vector with 6 elements;\n"
22740 " xg and yg vectors; or xg and yg matrices are respectively\n"
22741 " interfaced to a linear-transformation routine similar to the above\n"
22742 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22743 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22744 " support native language callbacks for handling index to\n"
22745 " world-coordinate transformations. Examples of these various\n"
22746 " approaches are given in examples/<language>x09*,\n"
22747 " examples/<language>x16*, examples/<language>x20*,\n"
22748 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22749 " supported languages.\n"
22751 " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
22752 " pass information to pltr0, pltr1, pltr2, or whatever routine is\n"
22753 " externally supplied.\n"
22762 "Wait for graphics input event and translate to world coordinates.\n"
22766 " Wait for graphics input event and translate to world coordinates.\n"
22767 " Returns 0 if no translation to world coordinates is possible.\n"
22769 " This function returns 1 on success and 0 if no translation to world\n"
22770 " coordinates is possible.\n"
22772 " Redacted form: plGetCursor(gin)\n"
22774 " This function is used in examples 1 and 20.\n"
22780 "PLINT plGetCursor(gin)\n"
22784 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22785 " which will contain the output. The structure is not allocated by\n"
22786 " the routine and must exist before the function is called.\n"
22789 { NULL, NULL, 0, NULL }
22863 {0, 0, 0, 0.0, 0, 0}};
22917 #define SWIGRUNTIME_DEBUG
22928 if (swig_module.
next==0) {
22940 if (!module_head) {
22950 if (iter==&swig_module) {
22955 }
while (iter!= module_head);
22960 swig_module.
next = module_head->
next;
22968 if (init == 0)
return;
22971 #ifdef SWIGRUNTIME_DEBUG
22972 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
22974 for (i = 0; i < swig_module.
size; ++i) {
22979 #ifdef SWIGRUNTIME_DEBUG
22980 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
22984 if (swig_module.
next != &swig_module) {
22989 #ifdef SWIGRUNTIME_DEBUG
22990 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
22994 #ifdef SWIGRUNTIME_DEBUG
22995 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
23004 while (cast->
type) {
23007 #ifdef SWIGRUNTIME_DEBUG
23008 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
23010 if (swig_module.
next != &swig_module) {
23012 #ifdef SWIGRUNTIME_DEBUG
23013 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
23018 #ifdef SWIGRUNTIME_DEBUG
23019 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
23026 #ifdef SWIGRUNTIME_DEBUG
23027 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
23029 if (!ocast) ret = 0;
23034 #ifdef SWIGRUNTIME_DEBUG
23035 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
23046 swig_module.
types[i] = type;
23048 swig_module.
types[i] = 0;
23050 #ifdef SWIGRUNTIME_DEBUG
23051 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
23052 for (i = 0; i < swig_module.
size; ++i) {
23055 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
23056 while (cast->
type) {
23057 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
23061 printf(
"---- Total casts: %d\n",j);
23063 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
23076 static int init_run = 0;
23078 if (init_run)
return;
23081 for (i = 0; i < swig_module.
size; i++) {
23089 equiv = equiv->
next;
23110 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23111 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23112 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23120 PyObject *(*get_attr)(void);
23132 #if PY_VERSION_HEX >= 0x03000000
23133 return PyUnicode_InternFromString(
"<Swig global variables>");
23135 return PyString_FromString(
"<Swig global variables>");
23141 #if PY_VERSION_HEX >= 0x03000000
23142 PyObject *str = PyUnicode_InternFromString(
"(");
23146 for (var = v->
vars; var; var=var->
next) {
23147 tail = PyUnicode_FromString(var->
name);
23148 joined = PyUnicode_Concat(str, tail);
23153 tail = PyUnicode_InternFromString(
", ");
23154 joined = PyUnicode_Concat(str, tail);
23160 tail = PyUnicode_InternFromString(
")");
23161 joined = PyUnicode_Concat(str, tail);
23166 PyObject *str = PyString_FromString(
"(");
23168 for (var = v->
vars; var; var=var->
next) {
23169 PyString_ConcatAndDel(&str,PyString_FromString(var->
name));
23170 if (var->
next) PyString_ConcatAndDel(&str,PyString_FromString(
", "));
23172 PyString_ConcatAndDel(&str,PyString_FromString(
")"));
23181 fprintf(fp,
"Swig global variables ");
23201 PyObject *res = NULL;
23204 if (strcmp(var->
name,n) == 0) {
23210 if (res == NULL && !PyErr_Occurred()) {
23211 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
23221 if (strcmp(var->
name,n) == 0) {
23227 if (res == 1 && !PyErr_Occurred()) {
23228 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
23235 static char varlink__doc__[] =
"Swig var link object";
23236 static PyTypeObject varlink_type;
23237 static int type_init = 0;
23239 const PyTypeObject tmp = {
23241 #if PY_VERSION_HEX >= 0x03000000
23242 PyVarObject_HEAD_INIT(NULL, 0)
23244 PyObject_HEAD_INIT(NULL)
23247 (
char *)
"swigvarlink",
23271 #if PY_VERSION_HEX >= 0x02020000
23272 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
23274 #if PY_VERSION_HEX >= 0x02030000
23277 #if PY_VERSION_HEX >= 0x02060000
23280 #ifdef COUNT_ALLOCS
23284 varlink_type = tmp;
23286 #if PY_VERSION_HEX < 0x02020000
23287 varlink_type.ob_type = &PyType_Type;
23289 if (PyType_Ready(&varlink_type) < 0)
23293 return &varlink_type;
23303 return ((PyObject*) result);
23311 size_t size = strlen(name)+1;
23312 gv->
name = (
char *)malloc(size);
23314 strncpy(gv->
name,name,size);
23325 static PyObject *_SWIG_globals = 0;
23327 return _SWIG_globals;
23339 for (i = 0; constants[i].
type; ++i) {
23340 switch(constants[i].type) {
23345 obj =
SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23352 PyDict_SetItemString(d, constants[i].name, obj);
23368 for (i = 0; methods[i].ml_name; ++i) {
23369 const char *c = methods[i].ml_doc;
23370 if (c && (c = strstr(c,
"swig_ptr: "))) {
23373 const char *name = c + 10;
23374 for (j = 0; const_table[j].
type; ++j) {
23375 if (strncmp(const_table[j].name, name,
23376 strlen(const_table[j].name)) == 0) {
23377 ci = &(const_table[j]);
23384 size_t shift = (ci->
ptype) - types;
23386 size_t ldoc = (c - methods[i].ml_doc);
23387 size_t lptr = strlen(ty->
name)+2*
sizeof(
void*)+2;
23388 char *ndoc = (
char*)malloc(ldoc + lptr + 10);
23391 strncpy(buff, methods[i].ml_doc, ldoc);
23393 strncpy(buff,
"swig_ptr: ", 10);
23396 methods[i].ml_doc = ndoc;
23417 #if PY_VERSION_HEX >= 0x03000000
23423 PyObject *m, *d, *md;
23424 #if PY_VERSION_HEX >= 0x03000000
23425 static struct PyModuleDef SWIG_module = {
23426 # if PY_VERSION_HEX >= 0x03020000
23427 PyModuleDef_HEAD_INIT,
23430 PyObject_HEAD_INIT(NULL)
23447 #if defined(SWIGPYTHON_BUILTIN)
23449 0, 0, 0, 0, 0, 0, 0
23451 static PyGetSetDef this_getset_def = {
23452 (
char *)
"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23454 static SwigPyGetSet thisown_getset_closure = {
23458 static PyGetSetDef thisown_getset_def = {
23459 (
char *)
"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23461 PyObject *metatype_args;
23462 PyTypeObject *builtin_pytype;
23463 int builtin_base_count;
23466 PyGetSetDescrObject *static_getset;
23467 PyTypeObject *metatype;
23469 PyObject *public_interface, *public_symbol;
23470 PyObject *this_descr;
23471 PyObject *thisown_descr;
23474 (void)builtin_pytype;
23475 (void)builtin_base_count;
23476 (void)builtin_basetype;
23478 (void)static_getset;
23481 metatype_args = Py_BuildValue(
"(s(O){})",
"SwigPyObjectType", &PyType_Type);
23482 assert(metatype_args);
23483 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
23485 Py_DECREF(metatype_args);
23486 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
23487 assert(PyType_Ready(metatype) >= 0);
23493 #if PY_VERSION_HEX >= 0x03000000
23494 m = PyModule_Create(&SWIG_module);
23496 m = Py_InitModule((
char *)
SWIG_name, SwigMethods);
23498 md = d = PyModule_GetDict(m);
23503 #ifdef SWIGPYTHON_BUILTIN
23505 assert(SwigPyObject_stype);
23508 SwigPyObject_stype->
clientdata = &SwigPyObject_clientdata;
23511 PyErr_SetString(PyExc_RuntimeError,
"Import error: attempted to load two incompatible swig-generated modules.");
23512 # if PY_VERSION_HEX >= 0x03000000
23525 (void)thisown_descr;
23527 public_interface = PyList_New(0);
23529 (void)public_symbol;
23531 PyDict_SetItemString(md,
"__all__", public_interface);
23532 Py_DECREF(public_interface);
23533 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23534 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23536 SwigPyBuiltin_AddPublicSymbol(public_interface,
swig_const_table[i].name);
23718 #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
#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)
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)
PLINT plGetCursor(PLGraphicsIn *plg)
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[]
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(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)
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)
PL_NC_GENERIC_POINTER PLPointer
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)
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 plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
#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)
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
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
#define SWIG_as_voidptrptr(a)
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)
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)
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)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
getreadbufferproc readbufferproc
swig_converter_func converter
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
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[]
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 PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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[]
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[]
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)
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
#define PyInt_FromSize_t(x)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
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)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
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)
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)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(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
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[]
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
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)
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
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)
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)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT(* defined_func)(PLFLT, PLFLT)
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