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
136 #define SWIG_RUNTIME_VERSION "4"
139 #ifdef SWIG_TYPE_TABLE
140 # define SWIG_QUOTE_STRING(x) #x
141 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
142 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
144 # define SWIG_TYPE_TABLE_NAME
157 # define SWIGRUNTIME SWIGINTERN
160 #ifndef SWIGRUNTIMEINLINE
161 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
165 #ifndef SWIG_BUFFER_SIZE
166 # define SWIG_BUFFER_SIZE 1024
170 #define SWIG_POINTER_DISOWN 0x1
171 #define SWIG_CAST_NEW_MEMORY 0x2
174 #define SWIG_POINTER_OWN 0x1
257 #define SWIG_ERROR (-1)
258 #define SWIG_IsOK(r) (r >= 0)
259 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
262 #define SWIG_CASTRANKLIMIT (1 << 8)
264 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
266 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
268 #define SWIG_BADOBJ (SWIG_ERROR)
269 #define SWIG_OLDOBJ (SWIG_OK)
270 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
271 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
273 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
274 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
277 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
281 #if defined(SWIG_CASTRANK_MODE)
282 # ifndef SWIG_TypeRank
283 # define SWIG_TypeRank unsigned long
285 # ifndef SWIG_MAXCASTRANK
286 # define SWIG_MAXCASTRANK (2)
288 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
289 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
294 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
297 # define SWIG_AddCast
298 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
308 typedef void *(*swig_converter_func)(
void *,
int *);
350 const char *f2,
const char *l2) {
351 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
352 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
353 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
354 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
356 return (
int)((l1 - f1) - (l2 - f2));
366 const char* te = tb + strlen(tb);
368 while (!equiv && *ne) {
369 for (nb = ne; *ne; ++ne) {
370 if (*ne ==
'|')
break;
385 const char* te = tb + strlen(tb);
387 while (!equiv && *ne) {
388 for (nb = ne; *ne; ++ne) {
389 if (*ne ==
'|')
break;
406 if (strcmp(iter->
type->
name, c) == 0) {
407 if (iter == ty->
cast)
433 if (iter->
type == from) {
434 if (iter == ty->
cast)
466 if (!ty || !ty->
dcast)
return ty;
467 while (ty && (ty->
dcast)) {
468 ty = (*ty->
dcast)(ptr);
492 if (!type)
return NULL;
493 if (type->
str != NULL) {
494 const char *last_name = type->
str;
496 for (s = type->
str; *s; s++)
497 if (*s ==
'|') last_name = s+1;
544 register size_t l = 0;
545 register size_t r = iter->
size - 1;
548 register size_t i = (l + r) >> 1;
549 const char *iname = iter->
types[i]->
name;
551 register int compare = strcmp(name, iname);
553 return iter->
types[i];
554 }
else if (compare < 0) {
560 }
else if (compare > 0) {
569 }
while (iter != end);
595 register size_t i = 0;
596 for (; i < iter->
size; ++i) {
598 return iter->
types[i];
601 }
while (iter != end);
613 static const char hex[17] =
"0123456789abcdef";
614 register const unsigned char *u = (
unsigned char *) ptr;
615 register const unsigned char *eu = u + sz;
616 for (; u != eu; ++u) {
617 register unsigned char uu = *u;
618 *(c++) = hex[(uu & 0xf0) >> 4];
619 *(c++) = hex[uu & 0xf];
629 register unsigned char *u = (
unsigned char *) ptr;
630 register const unsigned char *eu = u + sz;
631 for (; u != eu; ++u) {
632 register char d = *(c++);
633 register unsigned char uu;
634 if ((d >=
'0') && (d <=
'9'))
635 uu = ((d -
'0') << 4);
636 else if ((d >=
'a') && (d <=
'f'))
637 uu = ((d - (
'a'-10)) << 4);
641 if ((d >=
'0') && (d <=
'9'))
643 else if ((d >=
'a') && (d <=
'f'))
644 uu |= (d - (
'a'-10));
658 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
661 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
669 if (strcmp(c,
"NULL") == 0) {
682 size_t lname = (name ? strlen(name) : 0);
683 if ((2*sz + 2 + lname) > bsz)
return 0;
687 strncpy(r,name,lname+1);
697 if (strcmp(c,
"NULL") == 0) {
712 #define SWIG_UnknownError -1
713 #define SWIG_IOError -2
714 #define SWIG_RuntimeError -3
715 #define SWIG_IndexError -4
716 #define SWIG_TypeError -5
717 #define SWIG_DivisionByZero -6
718 #define SWIG_OverflowError -7
719 #define SWIG_SyntaxError -8
720 #define SWIG_ValueError -9
721 #define SWIG_SystemError -10
722 #define SWIG_AttributeError -11
723 #define SWIG_MemoryError -12
724 #define SWIG_NullReferenceError -13
729 #if PY_VERSION_HEX >= 0x03000000
731 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
732 #define PyInt_Check(x) PyLong_Check(x)
733 #define PyInt_AsLong(x) PyLong_AsLong(x)
734 #define PyInt_FromLong(x) PyLong_FromLong(x)
735 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
736 #define PyString_Check(name) PyBytes_Check(name)
737 #define PyString_FromString(x) PyUnicode_FromString(x)
738 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
739 #define PyString_AsString(str) PyBytes_AsString(str)
740 #define PyString_Size(str) PyBytes_Size(str)
741 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
742 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
743 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
744 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
749 # define Py_TYPE(op) ((op)->ob_type)
754 #if PY_VERSION_HEX >= 0x03000000
755 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
757 # define SWIG_Python_str_FromFormat PyString_FromFormat
767 #if PY_VERSION_HEX >= 0x03000000
771 str = PyUnicode_AsUTF8String(str);
772 PyBytes_AsStringAndSize(str, &cstr, &len);
773 newstr = (
char *) malloc(len+1);
774 memcpy(newstr, cstr, len+1);
778 return PyString_AsString(str);
782 #if PY_VERSION_HEX >= 0x03000000
783 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
785 # define SWIG_Python_str_DelForPy3(x)
792 #if PY_VERSION_HEX >= 0x03000000
793 return PyUnicode_FromString(c);
795 return PyString_FromString(c);
800 #if PY_VERSION_HEX < 0x02020000
801 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
802 # define PyOS_snprintf _snprintf
804 # define PyOS_snprintf snprintf
809 #if PY_VERSION_HEX < 0x02020000
811 #ifndef SWIG_PYBUFFER_SIZE
812 # define SWIG_PYBUFFER_SIZE 1024
821 res = vsnprintf(buf,
sizeof(buf), fmt, ap);
823 return (res < 0 || res >= (
int)
sizeof(buf)) ? 0 : PyString_FromString(buf);
828 #if PY_VERSION_HEX < 0x01060000
829 # define PyObject_Del(op) PyMem_DEL((op))
832 # define PyObject_DEL PyObject_Del
836 #if PY_VERSION_HEX < 0x02020000
837 # ifndef PyExc_StopIteration
838 # define PyExc_StopIteration PyExc_RuntimeError
840 # ifndef PyObject_GenericGetAttr
841 # define PyObject_GenericGetAttr 0
846 #if PY_VERSION_HEX < 0x02010000
847 # ifndef Py_NotImplemented
848 # define Py_NotImplemented PyExc_RuntimeError
853 #if PY_VERSION_HEX < 0x02010000
854 # ifndef PyString_AsStringAndSize
855 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
860 #if PY_VERSION_HEX < 0x02000000
861 # ifndef PySequence_Size
862 # define PySequence_Size PySequence_Length
867 #if PY_VERSION_HEX < 0x02030000
871 PyObject *result = ok ? Py_True : Py_False;
880 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
882 # define PY_SSIZE_T_MAX INT_MAX
883 # define PY_SSIZE_T_MIN INT_MIN
896 PyObject *i = PyNumber_Int(x);
898 result = PyInt_AsLong(i);
905 #if PY_VERSION_HEX < 0x02040000
906 #define Py_VISIT(op) \
909 int vret = visit((op), arg); \
916 #if PY_VERSION_HEX < 0x02030000
927 #if PY_VERSION_HEX < 0x02030000
931 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
932 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
933 (PY_MAJOR_VERSION > 3))
934 # define SWIGPY_USE_CAPSULE
935 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
938 #if PY_VERSION_HEX < 0x03020000
939 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
940 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
952 type = PyExc_MemoryError;
955 type = PyExc_IOError;
958 type = PyExc_RuntimeError;
961 type = PyExc_IndexError;
964 type = PyExc_TypeError;
967 type = PyExc_ZeroDivisionError;
970 type = PyExc_OverflowError;
973 type = PyExc_SyntaxError;
976 type = PyExc_ValueError;
979 type = PyExc_SystemError;
982 type = PyExc_AttributeError;
985 type = PyExc_RuntimeError;
996 PyObject *traceback = 0;
998 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1001 PyObject *old_str = PyObject_Str(value);
1010 PyErr_SetString(PyExc_RuntimeError, mesg);
1014 #if defined(SWIG_PYTHON_NO_THREADS)
1015 # if defined(SWIG_PYTHON_THREADS)
1016 # undef SWIG_PYTHON_THREADS
1019 #if defined(SWIG_PYTHON_THREADS)
1020 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1021 # if (PY_VERSION_HEX >= 0x02030000)
1022 # define SWIG_PYTHON_USE_GIL
1025 # if defined(SWIG_PYTHON_USE_GIL)
1026 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1027 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1030 class SWIG_Python_Thread_Block {
1032 PyGILState_STATE state;
1034 void end() {
if (status) { PyGILState_Release(state); status =
false;} }
1035 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1036 ~SWIG_Python_Thread_Block() { end(); }
1038 class SWIG_Python_Thread_Allow {
1040 PyThreadState *save;
1042 void end() {
if (status) { PyEval_RestoreThread(save); status =
false; }}
1043 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1044 ~SWIG_Python_Thread_Allow() { end(); }
1046 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1047 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1048 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1049 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1051 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1052 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1053 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1054 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1057 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1058 # define SWIG_PYTHON_INITIALIZE_THREADS
1060 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1061 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1063 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1064 # define SWIG_PYTHON_THREAD_END_BLOCK
1066 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1067 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1069 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1070 # define SWIG_PYTHON_THREAD_END_ALLOW
1074 # define SWIG_PYTHON_INITIALIZE_THREADS
1075 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1076 # define SWIG_PYTHON_THREAD_END_BLOCK
1077 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1078 # define SWIG_PYTHON_THREAD_END_ALLOW
1094 #define SWIG_PY_POINTER 4
1095 #define SWIG_PY_BINARY 5
1112 #if PY_VERSION_HEX >= 0x03000000
1115 return PyInstanceMethod_New(func);
1141 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1142 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1143 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1145 #ifdef SWIGPYTHON_BUILTIN
1146 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1148 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1151 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1153 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1154 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1155 #define swig_owntype int
1158 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1159 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1162 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1163 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1166 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1167 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1170 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1171 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1176 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1177 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1178 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1180 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1181 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1182 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1183 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1184 #define SWIG_fail goto fail
1194 PyErr_SetObject(errtype, obj);
1202 PyErr_SetString(errtype, msg);
1206 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1210 #if defined(SWIGPYTHON_BUILTIN)
1213 SwigPyBuiltin_AddPublicSymbol(PyObject *seq,
const char *key) {
1214 PyObject *s = PyString_InternFromString(key);
1215 PyList_Append(seq, s);
1221 #if PY_VERSION_HEX < 0x02030000
1222 PyDict_SetItemString(d, (
char *)name, obj);
1224 PyDict_SetItemString(d, name, obj);
1227 if (public_interface)
1228 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1235 #if PY_VERSION_HEX < 0x02030000
1236 PyDict_SetItemString(d, (
char *)name, obj);
1238 PyDict_SetItemString(d, name, obj);
1249 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1252 }
else if (result == Py_None) {
1256 if (!PyList_Check(result)) {
1257 PyObject *o2 = result;
1258 result = PyList_New(1);
1259 PyList_SetItem(result, 0, o2);
1261 PyList_Append(result,obj);
1270 }
else if (result == Py_None) {
1274 if (!PyTuple_Check(result)) {
1276 result = PyTuple_New(1);
1277 PyTuple_SET_ITEM(result, 0, o2);
1279 o3 = PyTuple_New(1);
1280 PyTuple_SET_ITEM(o3, 0, obj);
1282 result = PySequence_Concat(o2, o3);
1299 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got none",
1300 name, (min == max ?
"" :
"at least "), (
int)min);
1304 if (!PyTuple_Check(args)) {
1305 if (min <= 1 && max >= 1) {
1308 for (i = 1; i <
max; ++i) {
1313 PyErr_SetString(PyExc_SystemError,
"UnpackTuple() argument list is not a tuple");
1316 register Py_ssize_t l = PyTuple_GET_SIZE(args);
1318 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1319 name, (min == max ?
"" :
"at least "), (
int)min, (
int)l);
1321 }
else if (l > max) {
1322 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1323 name, (min == max ?
"" :
"at most "), (
int)max, (
int)l);
1327 for (i = 0; i < l; ++i) {
1328 objs[i] = PyTuple_GET_ITEM(args, i);
1330 for (; l <
max; ++l) {
1339 #if PY_VERSION_HEX >= 0x02020000
1340 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1342 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1350 #define SWIG_STATIC_POINTER(var) var
1352 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1360 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1361 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1363 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1365 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1366 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1373 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1374 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1375 # ifndef SWIG_PYTHON_BUILD_NONE
1376 # define SWIG_PYTHON_BUILD_NONE
1381 #ifdef SWIG_PYTHON_BUILD_NONE
1384 # define Py_None SWIG_Py_None()
1389 PyObject *none = Py_BuildValue((
char*)
"");
1406 PyObject *none = Py_None;
1433 PyObject *klass = data ? data->
klass : 0;
1434 return (klass ? klass : PyExc_RuntimeError);
1447 Py_INCREF(data->
klass);
1449 if (PyClass_Check(obj)) {
1454 #if (PY_VERSION_HEX < 0x02020000)
1457 data->
newraw = PyObject_GetAttrString(data->
klass, (
char *)
"__new__");
1461 data->
newargs = PyTuple_New(1);
1462 PyTuple_SetItem(data->
newargs, 0, obj);
1469 data->
destroy = PyObject_GetAttrString(data->
klass, (
char *)
"__swig_destroy__");
1470 if (PyErr_Occurred()) {
1477 flags = PyCFunction_GET_FLAGS(data->
destroy);
1479 data->
delargs = !(flags & (METH_O));
1494 Py_XDECREF(data->
newraw);
1507 #ifdef SWIGPYTHON_BUILTIN
1515 return PyLong_FromVoidPtr(v->
ptr);
1521 PyObject *res = NULL;
1522 PyObject *args = PyTuple_New(1);
1527 #if PY_VERSION_HEX >= 0x03000000
1528 res = PyUnicode_Format(ofmt,args);
1530 res = PyString_Format(ofmt,args);
1567 # if PY_VERSION_HEX >= 0x03000000
1568 PyObject *joined = PyUnicode_Concat(repr, nrep);
1573 PyString_ConcatAndDel(&repr,nrep);
1612 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1620 if( op != Py_EQ && op != Py_NE ) {
1631 #ifdef SWIGPYTHON_BUILTIN
1636 assert(SwigPyObject_stype);
1652 #ifdef SWIGPYTHON_BUILTIN
1654 if (PyType_IsSubtype(op->ob_type, target_tp))
1656 return (strcmp(op->ob_type->tp_name,
"SwigPyObject") == 0);
1659 || (strcmp(
Py_TYPE(op)->tp_name,
"SwigPyObject") == 0);
1670 PyObject *next = sobj->
next;
1684 PyCFunction meth = PyCFunction_GET_FUNCTION(
destroy);
1685 PyObject *mself = PyCFunction_GET_SELF(
destroy);
1686 res = ((*meth)(mself, v));
1690 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1693 printf(
"swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name :
"unknown"));
1707 if (!PyArg_ParseTuple(next,(
char *)
"O:append", &tmp))
return NULL;
1727 Py_INCREF(sobj->
next);
1762 #if (PY_VERSION_HEX < 0x02020000)
1763 if (!PyArg_ParseTuple(args,(
char *)
"|O:own",&val))
1764 #elif (PY_VERSION_HEX < 0x02050000)
1765 if (!PyArg_UnpackTuple(args, (
char *)
"own", 0, 1, &val))
1767 if (!PyArg_UnpackTuple(args,
"own", 0, 1, &val))
1778 if (PyObject_IsTrue(val)) {
1784 if (PyObject_IsTrue(val)) {
1798 {(
char *)
"disown", (PyCFunction)
SwigPyObject_disown, METH_NOARGS, (
char *)
"releases ownership of the pointer"},
1799 {(
char *)
"acquire", (PyCFunction)
SwigPyObject_acquire, METH_NOARGS, (
char *)
"aquires ownership of the pointer"},
1800 {(
char *)
"own", (PyCFunction)
SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1801 {(
char *)
"append", (PyCFunction)
SwigPyObject_append, METH_O, (
char *)
"appends another 'this' object"},
1802 {(
char *)
"next", (PyCFunction)
SwigPyObject_next, METH_NOARGS, (
char *)
"returns the next 'this' object"},
1803 {(
char *)
"__repr__",(PyCFunction)
SwigPyObject_repr, METH_NOARGS, (
char *)
"returns object representation"},
1808 swigobject_methods[] = {
1809 {(
char *)
"disown", (PyCFunction)
SwigPyObject_disown, METH_VARARGS, (
char *)
"releases ownership of the pointer"},
1810 {(
char *)
"acquire", (PyCFunction)
SwigPyObject_acquire, METH_VARARGS, (
char *)
"aquires ownership of the pointer"},
1811 {(
char *)
"own", (PyCFunction)
SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1812 {(
char *)
"append", (PyCFunction)
SwigPyObject_append, METH_VARARGS, (
char *)
"appends another 'this' object"},
1813 {(
char *)
"next", (PyCFunction)
SwigPyObject_next, METH_VARARGS, (
char *)
"returns the next 'this' object"},
1814 {(
char *)
"__repr__",(PyCFunction)
SwigPyObject_repr, METH_VARARGS, (
char *)
"returns object representation"},
1819 #if PY_VERSION_HEX < 0x02020000
1823 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1829 static char swigobject_doc[] =
"Swig object carries a C/C++ instance pointer";
1831 static PyNumberMethods SwigPyObject_as_number = {
1836 #
if PY_VERSION_HEX < 0x03000000
1852 #
if PY_VERSION_HEX < 0x03000000
1856 #if PY_VERSION_HEX < 0x03000000
1862 #if PY_VERSION_HEX < 0x03000000
1866 #if PY_VERSION_HEX >= 0x03000000
1867 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1868 #elif PY_VERSION_HEX >= 0x02050000
1869 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1870 #elif PY_VERSION_HEX >= 0x02020000
1871 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1872 #elif PY_VERSION_HEX >= 0x02000000
1873 0,0,0,0,0,0,0,0,0,0,0
1877 static PyTypeObject swigpyobject_type;
1878 static int type_init = 0;
1880 const PyTypeObject tmp = {
1882 #if PY_VERSION_HEX >= 0x03000000
1883 PyVarObject_HEAD_INIT(NULL, 0)
1885 PyObject_HEAD_INIT(NULL)
1888 (
char *)
"SwigPyObject",
1893 #if PY_VERSION_HEX < 0x02020000
1899 #
if PY_VERSION_HEX >= 0x03000000
1905 &SwigPyObject_as_number,
1920 #
if PY_VERSION_HEX >= 0x02020000
1942 #
if PY_VERSION_HEX >= 0x02030000
1945 #
if PY_VERSION_HEX >= 0x02060000
1952 swigpyobject_type = tmp;
1954 #if PY_VERSION_HEX < 0x02020000
1955 swigpyobject_type.ob_type = &PyType_Type;
1957 if (PyType_Ready(&swigpyobject_type) < 0)
1961 return &swigpyobject_type;
1974 return (PyObject *)sobj;
1992 fputs(
"<Swig Packed ", fp);
2029 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2030 return s ? s : strncmp((
char *)v->
pack, (
char *)w->
pack, 2*v->
size);
2044 || (strcmp((op)->ob_type->tp_name,
"SwigPyPacked") == 0);
2059 static char swigpacked_doc[] =
"Swig object carries a C/C++ instance pointer";
2060 static PyTypeObject swigpypacked_type;
2061 static int type_init = 0;
2063 const PyTypeObject tmp = {
2065 #if PY_VERSION_HEX>=0x03000000
2066 PyVarObject_HEAD_INIT(NULL, 0)
2068 PyObject_HEAD_INIT(NULL)
2071 (
char *)
"SwigPyPacked",
2078 #if PY_VERSION_HEX>=0x03000000
2099 #
if PY_VERSION_HEX >= 0x02020000
2121 #
if PY_VERSION_HEX >= 0x02030000
2124 #
if PY_VERSION_HEX >= 0x02060000
2131 swigpypacked_type = tmp;
2133 #if PY_VERSION_HEX < 0x02020000
2134 swigpypacked_type.ob_type = &PyType_Type;
2136 if (PyType_Ready(&swigpypacked_type) < 0)
2140 return &swigpypacked_type;
2148 void *pack = malloc(size);
2150 memcpy(pack, ptr, size);
2159 return (PyObject *) sobj;
2167 if (sobj->
size != size)
return 0;
2168 memcpy(ptr, sobj->
pack, size);
2190 if (swig_this == NULL)
2198 #if PY_VERSION_HEX>=0x03000000
2199 #define SWIG_PYTHON_SLOW_GETSET_THIS
2210 #ifdef SWIGPYTHON_BUILTIN
2212 # ifdef PyWeakref_CheckProxy
2213 if (PyWeakref_CheckProxy(pyobj)) {
2214 pyobj = PyWeakref_GET_OBJECT(pyobj);
2224 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2225 if (PyInstance_Check(pyobj)) {
2226 obj = _PyInstance_Lookup(pyobj,
SWIG_This());
2228 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2229 if (dictptr != NULL) {
2230 PyObject *dict = *dictptr;
2231 obj = dict ? PyDict_GetItem(dict,
SWIG_This()) : 0;
2233 #ifdef PyWeakref_CheckProxy
2234 if (PyWeakref_CheckProxy(pyobj)) {
2235 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2239 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2243 if (PyErr_Occurred()) PyErr_Clear();
2249 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2253 if (PyErr_Occurred()) PyErr_Clear();
2273 int oldown = sobj->
own;
2290 if (obj == Py_None) {
2302 void *vptr = sobj->
ptr;
2307 if (ptr) *ptr = vptr;
2327 if (ptr) *ptr = vptr;
2333 *own = *own | sobj->
own;
2342 PyObject *klass = data->
klass;
2348 if (PyErr_Occurred()) {
2382 if (!PyCFunction_Check(obj)) {
2388 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2389 const char *desc = doc ? strstr(doc,
"swig_ptr: ") : 0;
2438 #if (PY_VERSION_HEX >= 0x02020000)
2440 PyObject *newraw = data->
newraw;
2442 inst = PyObject_Call(newraw, data->
newargs, NULL);
2444 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2445 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2446 if (dictptr != NULL) {
2447 PyObject *dict = *dictptr;
2449 dict = PyDict_New();
2451 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2456 PyObject_SetAttr(inst, key, swig_this);
2460 #if PY_VERSION_HEX >= 0x03000000
2461 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->
newargs, Py_None, Py_None);
2462 PyObject_SetAttr(inst,
SWIG_This(), swig_this);
2463 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2465 PyObject *dict = PyDict_New();
2466 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2467 inst = PyInstance_NewRaw(data->
newargs, dict);
2473 #if (PY_VERSION_HEX >= 0x02010000)
2475 PyObject *dict = PyDict_New();
2476 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2477 inst = PyInstance_NewRaw(data->
newargs, dict);
2479 return (PyObject *) inst;
2481 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2485 inst->in_class = (PyClassObject *)data->
newargs;
2486 Py_INCREF(inst->in_class);
2487 inst->in_dict = PyDict_New();
2488 if (inst->in_dict == NULL) {
2492 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2493 inst->in_weakreflist = NULL;
2495 #ifdef Py_TPFLAGS_GC
2496 PyObject_GC_Init(inst);
2498 PyDict_SetItem(inst->in_dict,
SWIG_This(), swig_this);
2499 return (PyObject *) inst;
2508 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2509 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2510 if (dictptr != NULL) {
2513 dict = PyDict_New();
2516 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2520 dict = PyObject_GetAttrString(inst, (
char*)
"__dict__");
2521 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2555 if (clientdata && clientdata->
pytype) {
2560 PyObject *next_self = clientdata->
pytype->tp_alloc(clientdata->
pytype, 0);
2561 while (newobj->
next)
2563 newobj->
next = next_self;
2574 #ifdef SWIGPYTHON_BUILTIN
2577 return (PyObject*) newobj;
2606 #ifdef SWIG_LINK_RUNTIME
2607 void *SWIG_ReturnGlobalTypeList(
void *);
2612 static void *type_pointer = (
void *)0;
2614 if (!type_pointer) {
2615 #ifdef SWIG_LINK_RUNTIME
2616 type_pointer = SWIG_ReturnGlobalTypeList((
void *)0);
2618 # ifdef SWIGPY_USE_CAPSULE
2619 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2624 if (PyErr_Occurred()) {
2626 type_pointer = (
void *)0;
2633 #if PY_MAJOR_VERSION < 2
2640 if (!PyModule_Check(m)) {
2641 PyErr_SetString(PyExc_TypeError,
2642 "PyModule_AddObject() needs module as first arg");
2646 PyErr_SetString(PyExc_TypeError,
2647 "PyModule_AddObject() needs non-NULL value");
2651 dict = PyModule_GetDict(m);
2654 PyErr_Format(PyExc_SystemError,
"module '%s' has no __dict__",
2655 PyModule_GetName(m));
2658 if (PyDict_SetItemString(dict, name, o))
2666 #ifdef SWIGPY_USE_CAPSULE
2672 #ifdef SWIGPY_USE_CAPSULE
2679 for (i =0; i < swig_module->
size; ++i) {
2692 #if PY_VERSION_HEX >= 0x03000000
2696 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };
2697 PyObject *module = Py_InitModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2699 #ifdef SWIGPY_USE_CAPSULE
2701 if (pointer && module) {
2704 Py_XDECREF(pointer);
2708 if (pointer && module) {
2711 Py_XDECREF(pointer);
2728 PyObject *obj = PyDict_GetItem(cache, key);
2731 #ifdef SWIGPY_USE_CAPSULE
2740 #ifdef SWIGPY_USE_CAPSULE
2741 obj = PyCapsule_New((
void*) descriptor, NULL, NULL);
2743 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2745 PyDict_SetItem(cache, key, obj);
2756 #define SWIG_POINTER_EXCEPTION 0
2757 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2758 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2763 if (PyErr_Occurred()) {
2765 PyObject *
value = 0;
2766 PyObject *traceback = 0;
2767 PyErr_Fetch(&type, &value, &traceback);
2770 PyObject *old_str = PyObject_Str(value);
2790 if (PyErr_Occurred()) {
2793 PyOS_snprintf(mesg,
sizeof(mesg),
"argument number %d:", argnum);
2805 return ty ? ty->
str :
"";
2812 #if defined(SWIG_COBJECT_TYPES)
2816 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, 'SwigPyObject(%s)' is received",
2823 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2825 PyObject *str = PyObject_Str(obj);
2828 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s(%s)' is received",
2832 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s' is received",
2839 PyErr_Format(PyExc_TypeError,
"a '%s' is expected", type);
2841 PyErr_Format(PyExc_TypeError,
"unexpected type is received");
2852 #if SWIG_POINTER_EXCEPTION
2862 #ifdef SWIGPYTHON_BUILTIN
2864 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *
value) {
2865 PyTypeObject *tp = obj->ob_type;
2867 PyObject *encoded_name;
2871 # ifdef Py_USING_UNICODE
2872 if (PyString_Check(name)) {
2873 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2876 }
else if (!PyUnicode_Check(name))
2878 if (!PyString_Check(name))
2881 PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2888 if (PyType_Ready(tp) < 0)
2893 descr = _PyType_Lookup(tp, name);
2896 f = descr->ob_type->tp_descr_set;
2898 if (PyString_Check(name)) {
2899 encoded_name =
name;
2902 encoded_name = PyUnicode_AsUTF8String(name);
2904 PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2905 Py_DECREF(encoded_name);
2907 res = f(descr, obj, value);
2923 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2925 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2931 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2932 #define SWIGTYPE_p_PLcGrid swig_types[1]
2933 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2934 #define SWIGTYPE_p_char swig_types[3]
2935 #define SWIGTYPE_p_double swig_types[4]
2936 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2937 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2938 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2939 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2940 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2941 #define SWIGTYPE_p_int swig_types[10]
2942 #define SWIGTYPE_p_p_char swig_types[11]
2943 #define SWIGTYPE_p_p_double swig_types[12]
2944 #define SWIGTYPE_p_unsigned_int swig_types[13]
2947 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2948 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2952 #if (PY_VERSION_HEX <= 0x02000000)
2953 # if !defined(SWIG_PYTHON_CLASSIC)
2954 # error "This python version requires swig to be run with the '-classic' option"
2961 #if PY_VERSION_HEX >= 0x03000000
2962 # define SWIG_init PyInit__plplotc
2965 # define SWIG_init init_plplotc
2968 #define SWIG_name "_plplotc"
2970 #define SWIGVERSION 0x020007
2971 #define SWIG_VERSION SWIGVERSION
2974 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2975 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2978 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2979 #include <arrayobject.h>
2983 #define NPY_PLINT NPY_INT32
2986 #define NPY_PLFLT NPY_FLOAT64
2988 #define NPY_PLFLT NPY_FLOAT32
2992 #if !defined ( PySequence_Fast_GET_ITEM )
2993 #define PySequence_Fast_GET_ITEM PySequence_GetItem
2995 #define PySequence_Size PySequence_Length
3006 if (PyFloat_Check(obj)) {
3007 if (val) *val = PyFloat_AsDouble(obj);
3009 }
else if (PyInt_Check(obj)) {
3010 if (val) *val = PyInt_AsLong(obj);
3012 }
else if (PyLong_Check(obj)) {
3013 double v = PyLong_AsDouble(obj);
3014 if (!PyErr_Occurred()) {
3021 #ifdef SWIG_PYTHON_CAST_MODE
3024 double d = PyFloat_AsDouble(obj);
3025 if (!PyErr_Occurred()) {
3032 long v = PyLong_AsLong(obj);
3033 if (!PyErr_Occurred()) {
3046 #define SWIG_From_double PyFloat_FromDouble
3061 return PyInt_FromLong((
long) value);
3066 #if !defined(SWIG_NO_LLONG_MAX)
3067 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3068 # define LLONG_MAX __LONG_LONG_MAX__
3069 # define LLONG_MIN (-LLONG_MAX - 1LL)
3070 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3084 if ((min <= x && x <= max)) {
3085 double fx = floor(x);
3086 double cx = ceil(x);
3087 double rd = ((x - fx) < 0.5) ? fx : cx;
3088 if ((errno == EDOM) || (errno == ERANGE)) {
3091 double summ, reps, diff;
3094 }
else if (rd > x) {
3101 if (reps < 8*DBL_EPSILON) {
3114 if (PyInt_Check(obj)) {
3115 if (val) *val = PyInt_AsLong(obj);
3117 }
else if (PyLong_Check(obj)) {
3118 long v = PyLong_AsLong(obj);
3119 if (!PyErr_Occurred()) {
3126 #ifdef SWIG_PYTHON_CAST_MODE
3129 long v = PyInt_AsLong(obj);
3130 if (!PyErr_Occurred()) {
3140 if (val) *val = (long)(d);
3156 if ((v < INT_MIN || v > INT_MAX)) {
3159 if (val) *val = (int)(v);
3169 if (PyInt_Check(obj)) {
3170 long v = PyInt_AsLong(obj);
3177 }
else if (PyLong_Check(obj)) {
3178 unsigned long v = PyLong_AsUnsignedLong(obj);
3179 if (!PyErr_Occurred()) {
3186 #ifdef SWIG_PYTHON_CAST_MODE
3189 unsigned long v = PyLong_AsUnsignedLong(obj);
3190 if (!PyErr_Occurred()) {
3200 if (val) *val = (
unsigned long)(d);
3216 if ((v > UINT_MAX)) {
3219 if (val) *val = (
unsigned int)(v);
3229 return PyInt_FromSize_t((
size_t) value);
3236 static int init = 0;
3249 #if PY_VERSION_HEX>=0x03000000
3250 if (PyUnicode_Check(obj))
3252 if (PyString_Check(obj))
3256 #if PY_VERSION_HEX>=0x03000000
3257 if (!alloc && cptr) {
3264 obj = PyUnicode_AsUTF8String(obj);
3265 PyBytes_AsStringAndSize(obj, &cstr, &len);
3281 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3287 *cptr = (
char *)memcpy((
char *)malloc((len + 1)*
sizeof(
char)), cstr,
sizeof(char)*(len + 1));
3295 #if PY_VERSION_HEX>=0x03000000
3301 if (psize) *psize = len + 1;
3302 #if PY_VERSION_HEX>=0x03000000
3308 if (pchar_descriptor) {
3311 if (cptr) *cptr = (
char *) vptr;
3312 if (psize) *psize = vptr ? (strlen((
char *)vptr) + 1) : 0;
3325 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3328 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3329 if (csize <= size) {
3331 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3332 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3350 if (size > INT_MAX) {
3352 return pchar_descriptor ?
3355 #if PY_VERSION_HEX >= 0x03000000
3356 return PyUnicode_FromStringAndSize(carray, (
int)(size));
3358 return PyString_FromStringAndSize(carray, (
int)(size));
3370 #define t_output_helper SWIG_Python_AppendOutput
3381 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3382 if (val) *val = (char)(v);
3400 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in,
NPY_PLINT,
3405 if ( PyArray_Check( in ) )
3408 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in,
NPY_PLINT );
3415 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3418 PyObject *resultobj = 0;
3421 PLFLT *arg3 = (PLFLT *) 0 ;
3422 PLFLT *arg4 = (PLFLT *) 0 ;
3432 PyObject * obj0 = 0 ;
3433 PyObject * obj1 = 0 ;
3440 if (!PyArg_ParseTuple(args,(
char *)
"OO:pltr0",&obj0,&obj1))
SWIG_fail;
3445 arg1 = (
PLFLT)(val1);
3450 arg2 = (
PLFLT)(val2);
3451 pltr0(arg1,arg2,arg3,arg4,arg5);
3486 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3493 if ( pltr_xg == 0 || pltr_yg == 0 )
3495 PyErr_SetString( PyExc_ValueError,
"Expected a sequence to two 1D arrays." );
3498 tmpGrid1.
nx = (
PLINT) PyArray_DIMS( pltr_xg )[0];
3499 tmpGrid1.
ny = (
PLINT) PyArray_DIMS( pltr_yg )[0];
3502 if ( Xlen != tmpGrid1.
nx ||
Ylen != tmpGrid1.
ny )
3504 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3510 if ( Xlen != tmpGrid1.
nx - 1 ||
Ylen != tmpGrid1.
ny - 1 )
3512 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3516 tmpGrid1.
xg = (PLFLT *) PyArray_DATA( pltr_xg );
3517 tmpGrid1.
yg = (PLFLT *) PyArray_DATA( pltr_yg );
3524 Py_CLEAR( pltr_xg );
3525 Py_CLEAR( pltr_yg );
3534 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3541 if ( pltr_xg == 0 || pltr_yg == 0 )
3543 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two 2D arrays." );
3546 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3547 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3549 PyErr_SetString( PyExc_ValueError,
"Arrays must be same size." );
3552 tmpGrid2.
nx = (
PLINT) PyArray_DIMS( pltr_xg )[0];
3553 tmpGrid2.
ny = (
PLINT) PyArray_DIMS( pltr_xg )[1];
3556 if ( Xlen != tmpGrid2.
nx ||
Ylen != tmpGrid2.
ny )
3558 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3564 if ( Xlen != tmpGrid2.
nx - 1 ||
Ylen != tmpGrid2.
ny - 1 )
3566 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3571 tmpGrid2.
xg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) tmpGrid2.
nx );
3572 for ( i = 0; i < tmpGrid2.
nx; i++ )
3573 tmpGrid2.
xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3574 tmpGrid2.
yg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) tmpGrid2.
nx );
3575 for ( i = 0; i < tmpGrid2.
nx; i++ )
3576 tmpGrid2.
yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3583 free( tmpGrid2.
xg );
3584 free( tmpGrid2.
yg );
3585 Py_CLEAR( pltr_xg );
3586 Py_CLEAR( pltr_yg );
3590 PyObject *resultobj = 0;
3593 PLFLT *arg3 = (PLFLT *) 0 ;
3594 PLFLT *arg4 = (PLFLT *) 0 ;
3604 PyObject * obj0 = 0 ;
3605 PyObject * obj1 = 0 ;
3606 PyObject * obj2 = 0 ;
3610 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr1",&obj0,&obj1,&obj2))
SWIG_fail;
3615 arg1 = (
PLFLT)(val1);
3620 arg2 = (
PLFLT)(val2);
3626 pltr1(arg1,arg2,arg3,arg4,arg5);
3653 PyObject *resultobj = 0;
3656 PLFLT *arg3 = (PLFLT *) 0 ;
3657 PLFLT *arg4 = (PLFLT *) 0 ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 PyObject * obj2 = 0 ;
3673 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr2",&obj0,&obj1,&obj2))
SWIG_fail;
3678 arg1 = (
PLFLT)(val1);
3683 arg2 = (
PLFLT)(val2);
3689 pltr2(arg1,arg2,arg3,arg4,arg5);
3718 static PyInterpreterState *save_interp = NULL;
3728 #define MY_BLOCK_THREADS { \
3729 PyThreadState *prev_state, *new_state; \
3732 PyEval_AcquireLock(); \
3733 new_state = PyThreadState_New( save_interp ); \
3734 prev_state = PyThreadState_Swap( new_state );
3735 #define MY_UNBLOCK_THREADS \
3736 new_state = PyThreadState_Swap( prev_state ); \
3737 PyThreadState_Clear( new_state ); \
3738 PyEval_ReleaseLock(); \
3739 PyThreadState_Delete( new_state ); \
3742 #define MY_BLOCK_THREADS
3743 #define MY_UNBLOCK_THREADS
3766 PyObject *pdata, *arglist, *result;
3770 pdata = (PyObject *) data;
3777 Py_XINCREF( pdata );
3782 arglist = Py_BuildValue(
"(ddO)", x, y, pdata );
3784 arglist = Py_BuildValue(
"(ffO)", x, y, pdata );
3786 if ( arglist == NULL )
3788 fprintf( stderr,
"Py_BuildValue failed to make argument list.\n" );
3793 result = PyEval_CallObject( python_pltr, arglist );
3795 Py_CLEAR( arglist );
3797 if ( result == NULL )
3799 fprintf( stderr,
"call to python pltr function with 3 arguments failed\n" );
3800 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must take 3 argments." );
3806 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3808 fprintf( stderr,
"pltr callback must return a 2 element array or sequence\n" );
3809 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must return a 2-sequence." );
3814 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3829 PyObject *pdata, *arglist, *result;
3830 PLFLT fresult = 0.0;
3833 pdata = (PyObject *) data;
3834 if ( python_f2eval )
3836 Py_XINCREF( pdata );
3840 arglist = Py_BuildValue(
"(iiO)", x, y, pdata );
3842 result = PyEval_CallObject( python_f2eval, arglist );
3844 Py_CLEAR( arglist );
3846 if ( !PyFloat_Check( result ) )
3848 fprintf( stderr,
"f2eval callback must return a float\n" );
3849 PyErr_SetString( PyExc_RuntimeError,
"f2eval callback must return a float." );
3854 fresult = (
PLFLT) PyFloat_AsDouble( result );
3866 PyObject *pdata, *arglist, *result;
3871 pdata = (PyObject *) data;
3876 Py_XINCREF( pdata );
3881 arglist = Py_BuildValue(
"(ldO)", axis, value, pdata );
3883 arglist = Py_BuildValue(
"(lfO)", axis, value, pdata );
3886 result = PyEval_CallObject( python_label, arglist );
3890 if ( result == NULL )
3892 fprintf( stderr,
"label callback failed with 3 arguments\n" );
3893 PyErr_SetString( PyExc_RuntimeError,
"label callback must take 3 arguments." );
3895 else if ( !PyString_Check( result ) )
3897 fprintf( stderr,
"label callback must return a string\n" );
3898 PyErr_SetString( PyExc_RuntimeError,
"label callback must return a string." );
3903 pystring = PyString_AsString( result );
3904 strncpy(
string, pystring, len );
3915 PyObject *px, *py, *pdata, *arglist, *result;
3920 pdata = (PyObject *) data;
3927 Py_XINCREF( pdata );
3931 px = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) xt );
3932 py = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) yt );
3933 arglist = Py_BuildValue(
"(ddOOO)", x, y, px, py, pdata );
3935 result = PyEval_CallObject( python_ct, arglist );
3937 Py_CLEAR( arglist );
3942 if ( result == NULL )
3944 fprintf( stderr,
"call to python coordinate transform function with 5 arguments failed\n" );
3945 PyErr_SetString( PyExc_RuntimeError,
"coordinate transform callback must take 5 arguments." );
3956 PyObject *px, *py, *arglist, *result;
3963 if ( python_mapform )
3967 #ifdef PL_HAVE_PTHREAD
3968 px = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) x );
3969 py = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) y );
3971 px = PyArray_FromDimsAndData( 1, &n,
NPY_PLFLT, (
char *) x );
3972 py = PyArray_FromDimsAndData( 1, &n,
NPY_PLFLT, (
char *) y );
3974 arglist = Py_BuildValue(
"(iOO)", n, px, py );
3976 result = PyEval_CallObject( python_mapform, arglist );
3978 Py_CLEAR( arglist );
3982 if ( result == NULL )
3984 fprintf( stderr,
"call to python mapform function with 3 arguments failed\n" );
3985 PyErr_SetString( PyExc_RuntimeError,
"mapform callback must take 3 arguments." );
3998 PyObject * rep = PyObject_Repr( input );
4001 char* str = PyString_AsString( rep );
4002 if ( strcmp( str,
"<built-in function pltr0>" ) == 0 )
4008 else if ( strcmp( str,
"<built-in function pltr1>" ) == 0 )
4014 else if ( strcmp( str,
"<built-in function pltr2>" ) == 0 )
4022 python_pltr = input;
4024 Py_XINCREF( input );
4030 python_pltr = input;
4032 Py_XINCREF( input );
4039 Py_CLEAR( python_pltr );
4048 Py_XINCREF( input );
4054 Py_CLEAR( python_ct );
4062 python_mapform = input;
4063 Py_XINCREF( input );
4069 Py_CLEAR( python_mapform );
4081 if ( input != Py_None )
4085 if ( input != Py_None )
4089 Py_XINCREF( input );
4093 fprintf( stderr,
"pltr_type is invalid\n" );
4111 Py_CLEAR( python_pltr );
4114 fprintf( stderr,
"pltr_type is invalid\n" );
4123 PyObject *resultobj = 0;
4130 PyObject * obj0 = 0 ;
4131 PyObject * obj1 = 0 ;
4133 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_type_set",&obj0,&obj1))
SWIG_fail;
4144 if (arg1) (arg1)->type = arg2;
4153 PyObject *resultobj = 0;
4157 PyObject * obj0 = 0 ;
4160 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_type_get",&obj0))
SWIG_fail;
4166 result = (int) ((arg1)->type);
4175 PyObject *resultobj = 0;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4185 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_state_set",&obj0,&obj1))
SWIG_fail;
4195 arg2 = (
unsigned int)(val2);
4196 if (arg1) (arg1)->state = arg2;
4205 PyObject *resultobj = 0;
4209 PyObject * obj0 = 0 ;
4210 unsigned int result;
4212 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_state_get",&obj0))
SWIG_fail;
4218 result = (
unsigned int) ((arg1)->state);
4227 PyObject *resultobj = 0;
4234 PyObject * obj0 = 0 ;
4235 PyObject * obj1 = 0 ;
4237 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_keysym_set",&obj0,&obj1))
SWIG_fail;
4247 arg2 = (
unsigned int)(val2);
4248 if (arg1) (arg1)->keysym = arg2;
4257 PyObject *resultobj = 0;
4261 PyObject * obj0 = 0 ;
4262 unsigned int result;
4264 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_keysym_get",&obj0))
SWIG_fail;
4270 result = (
unsigned int) ((arg1)->keysym);
4279 PyObject *resultobj = 0;
4286 PyObject * obj0 = 0 ;
4287 PyObject * obj1 = 0 ;
4289 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_button_set",&obj0,&obj1))
SWIG_fail;
4299 arg2 = (
unsigned int)(val2);
4300 if (arg1) (arg1)->button = arg2;
4309 PyObject *resultobj = 0;
4313 PyObject * obj0 = 0 ;
4314 unsigned int result;
4316 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_button_get",&obj0))
SWIG_fail;
4322 result = (
unsigned int) ((arg1)->button);
4331 PyObject *resultobj = 0;
4338 PyObject * obj0 = 0 ;
4339 PyObject * obj1 = 0 ;
4341 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1))
SWIG_fail;
4351 arg2 = (
PLINT)(val2);
4352 if (arg1) (arg1)->subwindow = arg2;
4361 PyObject *resultobj = 0;
4365 PyObject * obj0 = 0 ;
4368 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_subwindow_get",&obj0))
SWIG_fail;
4374 result = (
PLINT) ((arg1)->subwindow);
4383 PyObject *resultobj = 0;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4393 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_string_set",&obj0,&obj1))
SWIG_fail;
4403 arg2 = (
char *)(temp2);
4404 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
4405 else memset(arg1->
string,0,16*
sizeof(
char));
4414 PyObject *resultobj = 0;
4418 PyObject * obj0 = 0 ;
4421 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_string_get",&obj0))
SWIG_fail;
4427 result = (
char *)(
char *) ((arg1)->
string);
4431 while (size && (result[size - 1] ==
'\0')) --size;
4442 PyObject *resultobj = 0;
4449 PyObject * obj0 = 0 ;
4450 PyObject * obj1 = 0 ;
4452 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pX_set",&obj0,&obj1))
SWIG_fail;
4463 if (arg1) (arg1)->pX = arg2;
4472 PyObject *resultobj = 0;
4476 PyObject * obj0 = 0 ;
4479 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pX_get",&obj0))
SWIG_fail;
4485 result = (int) ((arg1)->pX);
4494 PyObject *resultobj = 0;
4501 PyObject * obj0 = 0 ;
4502 PyObject * obj1 = 0 ;
4504 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pY_set",&obj0,&obj1))
SWIG_fail;
4515 if (arg1) (arg1)->pY = arg2;
4524 PyObject *resultobj = 0;
4528 PyObject * obj0 = 0 ;
4531 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pY_get",&obj0))
SWIG_fail;
4537 result = (int) ((arg1)->pY);
4546 PyObject *resultobj = 0;
4553 PyObject * obj0 = 0 ;
4554 PyObject * obj1 = 0 ;
4556 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dX_set",&obj0,&obj1))
SWIG_fail;
4566 arg2 = (
PLFLT)(val2);
4567 if (arg1) (arg1)->dX = arg2;
4576 PyObject *resultobj = 0;
4580 PyObject * obj0 = 0 ;
4583 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dX_get",&obj0))
SWIG_fail;
4589 result = (
PLFLT) ((arg1)->dX);
4598 PyObject *resultobj = 0;
4605 PyObject * obj0 = 0 ;
4606 PyObject * obj1 = 0 ;
4608 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dY_set",&obj0,&obj1))
SWIG_fail;
4618 arg2 = (
PLFLT)(val2);
4619 if (arg1) (arg1)->dY = arg2;
4628 PyObject *resultobj = 0;
4632 PyObject * obj0 = 0 ;
4635 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dY_get",&obj0))
SWIG_fail;
4641 result = (
PLFLT) ((arg1)->dY);
4650 PyObject *resultobj = 0;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4660 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wX_set",&obj0,&obj1))
SWIG_fail;
4670 arg2 = (
PLFLT)(val2);
4671 if (arg1) (arg1)->wX = arg2;
4680 PyObject *resultobj = 0;
4684 PyObject * obj0 = 0 ;
4687 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wX_get",&obj0))
SWIG_fail;
4693 result = (
PLFLT) ((arg1)->wX);
4702 PyObject *resultobj = 0;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4712 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wY_set",&obj0,&obj1))
SWIG_fail;
4722 arg2 = (
PLFLT)(val2);
4723 if (arg1) (arg1)->wY = arg2;
4732 PyObject *resultobj = 0;
4736 PyObject * obj0 = 0 ;
4739 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wY_get",&obj0))
SWIG_fail;
4745 result = (
PLFLT) ((arg1)->wY);
4754 PyObject *resultobj = 0;
4757 if (!PyArg_ParseTuple(args,(
char *)
":new_PLGraphicsIn"))
SWIG_fail;
4767 PyObject *resultobj = 0;
4771 PyObject * obj0 = 0 ;
4773 if (!PyArg_ParseTuple(args,(
char *)
"O:delete_PLGraphicsIn",&obj0))
SWIG_fail;
4779 free((
char *) arg1);
4789 if (!PyArg_ParseTuple(args,(
char*)
"O:swigregister", &obj))
return NULL;
4795 PyObject *resultobj = 0;
4799 PyObject * obj0 = 0 ;
4801 if (!PyArg_ParseTuple(args,(
char *)
"O:plsxwin",&obj0))
SWIG_fail;
4806 arg1 = (
PLINT)(val1);
4816 PyObject *resultobj = 0;
4823 PyObject * obj0 = 0 ;
4824 PyObject * obj1 = 0 ;
4826 if (!PyArg_ParseTuple(args,(
char *)
"OO:pl_setcontlabelformat",&obj0,&obj1))
SWIG_fail;
4831 arg1 = (
PLINT)(val1);
4836 arg2 = (
PLINT)(val2);
4846 PyObject *resultobj = 0;
4859 PyObject * obj0 = 0 ;
4860 PyObject * obj1 = 0 ;
4861 PyObject * obj2 = 0 ;
4862 PyObject * obj3 = 0 ;
4864 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
4869 arg1 = (
PLFLT)(val1);
4874 arg2 = (
PLFLT)(val2);
4879 arg3 = (
PLFLT)(val3);
4884 arg4 = (
PLINT)(val4);
4894 PyObject *resultobj = 0;
4898 PyObject * obj0 = 0 ;
4900 if (!PyArg_ParseTuple(args,(
char *)
"O:pladv",&obj0))
SWIG_fail;
4905 arg1 = (
PLINT)(val1);
4915 PyObject *resultobj = 0;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 PyObject * obj2 = 0 ;
4943 PyObject * obj3 = 0 ;
4944 PyObject * obj4 = 0 ;
4945 PyObject * obj5 = 0 ;
4946 PyObject * obj6 = 0 ;
4947 PyObject * obj7 = 0 ;
4949 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
4954 arg1 = (
PLFLT)(val1);
4959 arg2 = (
PLFLT)(val2);
4964 arg3 = (
PLFLT)(val3);
4969 arg4 = (
PLFLT)(val4);
4974 arg5 = (
PLFLT)(val5);
4979 arg6 = (
PLFLT)(val6);
4984 arg7 = (
PLFLT)(val7);
4990 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4999 PyObject *resultobj = 0;
5002 char *arg3 = (
char *) 0 ;
5005 char *arg6 = (
char *) 0 ;
5026 PyObject * obj0 = 0 ;
5027 PyObject * obj1 = 0 ;
5028 PyObject * obj2 = 0 ;
5029 PyObject * obj3 = 0 ;
5030 PyObject * obj4 = 0 ;
5031 PyObject * obj5 = 0 ;
5032 PyObject * obj6 = 0 ;
5033 PyObject * obj7 = 0 ;
5035 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5040 arg1 = (
PLFLT)(val1);
5045 arg2 = (
PLFLT)(val2);
5050 arg3 = (
char *)(buf3);
5055 arg4 = (
PLFLT)(val4);
5060 arg5 = (
PLINT)(val5);
5065 arg6 = (
char *)(buf6);
5070 arg7 = (
PLFLT)(val7);
5075 arg8 = (
PLINT)(val8);
5076 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
5089 PyObject *resultobj = 0;
5091 PLFLT *arg2 = (PLFLT *) 0 ;
5092 PLFLT *arg3 = (PLFLT *) 0 ;
5094 PyArrayObject *tmp1 = NULL ;
5095 PyArrayObject *tmp3 = NULL ;
5098 PyObject * obj0 = 0 ;
5099 PyObject * obj1 = 0 ;
5100 PyObject * obj2 = 0 ;
5102 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plbin",&obj0,&obj1,&obj2))
SWIG_fail;
5107 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5108 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5114 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
5116 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
5119 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5125 arg4 = (
PLINT)(val4);
5126 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
5147 PyObject *resultobj = 0;
5148 PLINT *arg1 = (PLINT *) 0 ;
5149 PLINT *arg2 = (PLINT *) 0 ;
5150 PLINT *arg3 = (PLINT *) 0 ;
5151 PLINT *arg4 = (PLINT *) 0 ;
5152 PLINT *arg5 = (PLINT *) 0 ;
5153 PLFLT *arg6 = (PLFLT *) 0 ;
5169 PyObject * obj0 = 0 ;
5177 if (!PyArg_ParseTuple(args,(
char *)
"O:plbtime",&obj0))
SWIG_fail;
5182 arg7 = (
PLFLT)(val7);
5183 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5228 PyObject *resultobj = 0;
5230 if (!PyArg_ParseTuple(args,(
char *)
":plbop"))
SWIG_fail;
5240 PyObject *resultobj = 0;
5241 char *arg1 = (
char *) 0 ;
5244 char *arg4 = (
char *) 0 ;
5261 PyObject * obj0 = 0 ;
5262 PyObject * obj1 = 0 ;
5263 PyObject * obj2 = 0 ;
5264 PyObject * obj3 = 0 ;
5265 PyObject * obj4 = 0 ;
5266 PyObject * obj5 = 0 ;
5268 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5273 arg1 = (
char *)(buf1);
5278 arg2 = (
PLFLT)(val2);
5283 arg3 = (
PLINT)(val3);
5288 arg4 = (
char *)(buf4);
5293 arg5 = (
PLFLT)(val5);
5298 arg6 = (
PLINT)(val6);
5299 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
5312 PyObject *resultobj = 0;
5313 char *arg1 = (
char *) 0 ;
5314 char *arg2 = (
char *) 0 ;
5317 char *arg5 = (
char *) 0 ;
5318 char *arg6 = (
char *) 0 ;
5321 char *arg9 = (
char *) 0 ;
5322 char *arg10 = (
char *) 0 ;
5355 PyObject * obj0 = 0 ;
5356 PyObject * obj1 = 0 ;
5357 PyObject * obj2 = 0 ;
5358 PyObject * obj3 = 0 ;
5359 PyObject * obj4 = 0 ;
5360 PyObject * obj5 = 0 ;
5361 PyObject * obj6 = 0 ;
5362 PyObject * obj7 = 0 ;
5363 PyObject * obj8 = 0 ;
5364 PyObject * obj9 = 0 ;
5365 PyObject * obj10 = 0 ;
5366 PyObject * obj11 = 0 ;
5368 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
5373 arg1 = (
char *)(buf1);
5378 arg2 = (
char *)(buf2);
5383 arg3 = (
PLFLT)(val3);
5388 arg4 = (
PLINT)(val4);
5393 arg5 = (
char *)(buf5);
5398 arg6 = (
char *)(buf6);
5403 arg7 = (
PLFLT)(val7);
5408 arg8 = (
PLINT)(val8);
5413 arg9 = (
char *)(buf9);
5418 arg10 = (
char *)(buf10);
5423 arg11 = (
PLFLT)(val11);
5428 arg12 = (
PLINT)(val12);
5429 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);
5450 PyObject *resultobj = 0;
5453 PLFLT *arg3 = (PLFLT *) 0 ;
5454 PLFLT *arg4 = (PLFLT *) 0 ;
5455 PLINT *arg5 = (PLINT *) 0 ;
5466 PyObject * obj0 = 0 ;
5467 PyObject * obj1 = 0 ;
5472 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcalc_world",&obj0,&obj1))
SWIG_fail;
5477 arg1 = (
PLFLT)(val1);
5482 arg2 = (
PLFLT)(val2);
5510 PyObject *resultobj = 0;
5512 if (!PyArg_ParseTuple(args,(
char *)
":plclear"))
SWIG_fail;
5522 PyObject *resultobj = 0;
5526 PyObject * obj0 = 0 ;
5528 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol0",&obj0))
SWIG_fail;
5533 arg1 = (
PLINT)(val1);
5543 PyObject *resultobj = 0;
5547 PyObject * obj0 = 0 ;
5549 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol1",&obj0))
SWIG_fail;
5554 arg1 = (
PLFLT)(val1);
5564 PyObject *resultobj = 0;
5598 PyObject * obj0 = 0 ;
5599 PyObject * obj1 = 0 ;
5600 PyObject * obj2 = 0 ;
5601 PyObject * obj3 = 0 ;
5602 PyObject * obj4 = 0 ;
5603 PyObject * obj5 = 0 ;
5604 PyObject * obj6 = 0 ;
5605 PyObject * obj7 = 0 ;
5606 PyObject * obj8 = 0 ;
5607 PyObject * obj9 = 0 ;
5608 PyObject * obj10 = 0 ;
5610 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
5615 arg1 = (
PLFLT)(val1);
5620 arg2 = (
PLFLT)(val2);
5625 arg3 = (
PLFLT)(val3);
5630 arg4 = (
PLINT)(val4);
5640 arg6 = (
PLINT)(val6);
5645 arg7 = (
PLINT)(val7);
5650 arg8 = (
PLINT)(val8);
5655 arg9 = (
PLINT)(val9);
5660 arg10 = (
PLINT)(val10);
5665 arg11 = (
PLFLT)(val11);
5666 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5675 PyObject *resultobj = 0;
5676 PLFLT **arg1 = (PLFLT **) 0 ;
5683 PLFLT *arg8 = (PLFLT *) 0 ;
5687 PyArrayObject *tmp1 = NULL ;
5696 PyArrayObject *tmp8 = NULL ;
5697 PyObject * obj0 = 0 ;
5698 PyObject * obj1 = 0 ;
5699 PyObject * obj2 = 0 ;
5700 PyObject * obj3 = 0 ;
5701 PyObject * obj4 = 0 ;
5702 PyObject * obj5 = 0 ;
5703 PyObject * obj6 = 0 ;
5704 PyObject * obj7 = 0 ;
5713 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5719 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5720 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5722 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
5723 for ( i = 0; i < arg2; i++ )
5724 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5730 arg4 = (
PLINT)(val4);
5735 arg5 = (
PLINT)(val5);
5740 arg6 = (
PLINT)(val6);
5745 arg7 = (
PLINT)(val7);
5750 arg9 = PyArray_DIMS( tmp8 )[0];
5751 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5756 if ( obj6 == Py_None )
5762 if ( !PyCallable_Check( (PyObject *) obj6 ) )
5764 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
5773 if ( obj7 == Py_None )
5781 plcont((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11);
5816 PyObject *resultobj = 0;
5823 PLFLT *arg7 = (PLFLT *) 0 ;
5838 PyObject * obj0 = 0 ;
5839 PyObject * obj1 = 0 ;
5840 PyObject * obj2 = 0 ;
5841 PyObject * obj3 = 0 ;
5842 PyObject * obj4 = 0 ;
5843 PyObject * obj5 = 0 ;
5846 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5851 arg1 = (
PLINT)(val1);
5856 arg2 = (
PLINT)(val2);
5861 arg3 = (
PLINT)(val3);
5866 arg4 = (
PLINT)(val4);
5871 arg5 = (
PLINT)(val5);
5876 arg6 = (
PLFLT)(val6);
5877 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5892 PyObject *resultobj = 0;
5899 PyObject * obj0 = 0 ;
5900 PyObject * obj1 = 0 ;
5902 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcpstrm",&obj0,&obj1))
SWIG_fail;
5907 arg1 = (
PLINT)(val1);
5922 PyObject *resultobj = 0;
5924 if (!PyArg_ParseTuple(args,(
char *)
":plend"))
SWIG_fail;
5934 PyObject *resultobj = 0;
5936 if (!PyArg_ParseTuple(args,(
char *)
":plend1"))
SWIG_fail;
5946 PyObject *resultobj = 0;
5965 PyObject * obj0 = 0 ;
5966 PyObject * obj1 = 0 ;
5967 PyObject * obj2 = 0 ;
5968 PyObject * obj3 = 0 ;
5969 PyObject * obj4 = 0 ;
5970 PyObject * obj5 = 0 ;
5972 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5977 arg1 = (
PLFLT)(val1);
5982 arg2 = (
PLFLT)(val2);
5987 arg3 = (
PLFLT)(val3);
5992 arg4 = (
PLFLT)(val4);
5997 arg5 = (
PLINT)(val5);
6002 arg6 = (
PLINT)(val6);
6003 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6012 PyObject *resultobj = 0;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 PyObject * obj2 = 0 ;
6034 PyObject * obj3 = 0 ;
6035 PyObject * obj4 = 0 ;
6036 PyObject * obj5 = 0 ;
6038 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
6043 arg1 = (
PLFLT)(val1);
6048 arg2 = (
PLFLT)(val2);
6053 arg3 = (
PLFLT)(val3);
6058 arg4 = (
PLFLT)(val4);
6063 arg5 = (
PLINT)(val5);
6068 arg6 = (
PLINT)(val6);
6069 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6078 PyObject *resultobj = 0;
6080 if (!PyArg_ParseTuple(args,(
char *)
":pleop"))
SWIG_fail;
6090 PyObject *resultobj = 0;
6092 PLFLT *arg2 = (PLFLT *) 0 ;
6093 PLFLT *arg3 = (PLFLT *) 0 ;
6094 PLFLT *arg4 = (PLFLT *) 0 ;
6095 PyArrayObject *tmp1 = NULL ;
6096 PyArrayObject *tmp3 = NULL ;
6097 PyArrayObject *tmp4 = NULL ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 PyObject * obj2 = 0 ;
6102 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerrx",&obj0,&obj1,&obj2))
SWIG_fail;
6107 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6108 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6114 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6116 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6119 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6125 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6127 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6130 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6132 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6159 PyObject *resultobj = 0;
6161 PLFLT *arg2 = (PLFLT *) 0 ;
6162 PLFLT *arg3 = (PLFLT *) 0 ;
6163 PLFLT *arg4 = (PLFLT *) 0 ;
6164 PyArrayObject *tmp1 = NULL ;
6165 PyArrayObject *tmp3 = NULL ;
6166 PyArrayObject *tmp4 = NULL ;
6167 PyObject * obj0 = 0 ;
6168 PyObject * obj1 = 0 ;
6169 PyObject * obj2 = 0 ;
6171 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerry",&obj0,&obj1,&obj2))
SWIG_fail;
6176 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6177 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6183 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6185 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6188 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6194 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6196 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6199 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6201 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6228 PyObject *resultobj = 0;
6230 if (!PyArg_ParseTuple(args,(
char *)
":plfamadv"))
SWIG_fail;
6240 PyObject *resultobj = 0;
6242 PLFLT *arg2 = (PLFLT *) 0 ;
6243 PLFLT *arg3 = (PLFLT *) 0 ;
6244 PyArrayObject *tmp1 = NULL ;
6245 PyArrayObject *tmp3 = NULL ;
6246 PyObject * obj0 = 0 ;
6247 PyObject * obj1 = 0 ;
6249 if (!PyArg_ParseTuple(args,(
char *)
"OO:plfill",&obj0,&obj1))
SWIG_fail;
6254 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6255 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6261 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6263 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6266 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6268 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
6289 PyObject *resultobj = 0;
6291 PLFLT *arg2 = (PLFLT *) 0 ;
6292 PLFLT *arg3 = (PLFLT *) 0 ;
6293 PLFLT *arg4 = (PLFLT *) 0 ;
6294 PyArrayObject *tmp1 = NULL ;
6295 PyArrayObject *tmp3 = NULL ;
6296 PyArrayObject *tmp4 = NULL ;
6297 PyObject * obj0 = 0 ;
6298 PyObject * obj1 = 0 ;
6299 PyObject * obj2 = 0 ;
6301 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plfill3",&obj0,&obj1,&obj2))
SWIG_fail;
6306 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6307 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6313 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6315 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6318 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6324 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6326 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6329 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6331 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6358 PyObject *resultobj = 0;
6360 PLFLT *arg2 = (PLFLT *) 0 ;
6361 PLFLT *arg3 = (PLFLT *) 0 ;
6363 PyArrayObject *tmp1 = NULL ;
6364 PyArrayObject *tmp3 = NULL ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6371 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plgradient",&obj0,&obj1,&obj2))
SWIG_fail;
6376 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6377 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6383 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6385 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6388 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6394 arg4 = (
PLFLT)(val4);
6395 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
6416 PyObject *resultobj = 0;
6418 if (!PyArg_ParseTuple(args,(
char *)
":plflush"))
SWIG_fail;
6428 PyObject *resultobj = 0;
6432 PyObject * obj0 = 0 ;
6434 if (!PyArg_ParseTuple(args,(
char *)
"O:plfont",&obj0))
SWIG_fail;
6439 arg1 = (
PLINT)(val1);
6449 PyObject *resultobj = 0;
6453 PyObject * obj0 = 0 ;
6455 if (!PyArg_ParseTuple(args,(
char *)
"O:plfontld",&obj0))
SWIG_fail;
6460 arg1 = (
PLINT)(val1);
6470 PyObject *resultobj = 0;
6471 PLFLT *arg1 = (PLFLT *) 0 ;
6472 PLFLT *arg2 = (PLFLT *) 0 ;
6480 if (!PyArg_ParseTuple(args,(
char *)
":plgchr"))
SWIG_fail;
6502 PyObject *resultobj = 0;
6504 PLINT *arg2 = (PLINT *) 0 ;
6505 PLINT *arg3 = (PLINT *) 0 ;
6506 PLINT *arg4 = (PLINT *) 0 ;
6515 PyObject * obj0 = 0 ;
6520 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0",&obj0))
SWIG_fail;
6525 arg1 = (
PLINT)(val1);
6553 PyObject *resultobj = 0;
6555 PLINT *arg2 = (PLINT *) 0 ;
6556 PLINT *arg3 = (PLINT *) 0 ;
6557 PLINT *arg4 = (PLINT *) 0 ;
6558 PLFLT *arg5 = (PLFLT *) 0 ;
6569 PyObject * obj0 = 0 ;
6575 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0a",&obj0))
SWIG_fail;
6580 arg1 = (
PLINT)(val1);
6581 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6614 PyObject *resultobj = 0;
6615 PLINT *arg1 = (PLINT *) 0 ;
6616 PLINT *arg2 = (PLINT *) 0 ;
6617 PLINT *arg3 = (PLINT *) 0 ;
6628 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbg"))
SWIG_fail;
6656 PyObject *resultobj = 0;
6657 PLINT *arg1 = (PLINT *) 0 ;
6658 PLINT *arg2 = (PLINT *) 0 ;
6659 PLINT *arg3 = (PLINT *) 0 ;
6660 PLFLT *arg4 = (PLFLT *) 0 ;
6674 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbga"))
SWIG_fail;
6708 PyObject *resultobj = 0;
6709 PLINT *arg1 = (PLINT *) 0 ;
6714 if (!PyArg_ParseTuple(args,(
char *)
":plgcompression"))
SWIG_fail;
6730 PyObject *resultobj = 0;
6731 char *arg1 = (
char *) 0 ;
6737 if (!PyArg_ParseTuple(args,(
char *)
":plgdev"))
SWIG_fail;
6741 PyObject *o = PyString_FromString( arg1 );
6751 PyObject *resultobj = 0;
6752 PLFLT *arg1 = (PLFLT *) 0 ;
6753 PLFLT *arg2 = (PLFLT *) 0 ;
6754 PLFLT *arg3 = (PLFLT *) 0 ;
6755 PLFLT *arg4 = (PLFLT *) 0 ;
6769 if (!PyArg_ParseTuple(args,(
char *)
":plgdidev"))
SWIG_fail;
6803 PyObject *resultobj = 0;
6804 PLFLT *arg1 = (PLFLT *) 0 ;
6809 if (!PyArg_ParseTuple(args,(
char *)
":plgdiori"))
SWIG_fail;
6825 PyObject *resultobj = 0;
6826 PLFLT *arg1 = (PLFLT *) 0 ;
6827 PLFLT *arg2 = (PLFLT *) 0 ;
6828 PLFLT *arg3 = (PLFLT *) 0 ;
6829 PLFLT *arg4 = (PLFLT *) 0 ;
6843 if (!PyArg_ParseTuple(args,(
char *)
":plgdiplt"))
SWIG_fail;
6877 PyObject *resultobj = 0;
6878 PLINT *arg1 = (PLINT *) 0 ;
6879 PLINT *arg2 = (PLINT *) 0 ;
6880 PLINT *arg3 = (PLINT *) 0 ;
6891 if (!PyArg_ParseTuple(args,(
char *)
":plgfam"))
SWIG_fail;
6919 PyObject *resultobj = 0;
6925 if (!PyArg_ParseTuple(args,(
char *)
":plgfci"))
SWIG_fail;
6941 PyObject *resultobj = 0;
6942 char *arg1 = (
char *) 0 ;
6948 if (!PyArg_ParseTuple(args,(
char *)
":plgfnam"))
SWIG_fail;
6952 PyObject *o = PyString_FromString( arg1 );
6962 PyObject *resultobj = 0;
6963 PLINT *arg1 = (PLINT *) 0 ;
6964 PLINT *arg2 = (PLINT *) 0 ;
6965 PLINT *arg3 = (PLINT *) 0 ;
6976 if (!PyArg_ParseTuple(args,(
char *)
":plgfont"))
SWIG_fail;
7004 PyObject *resultobj = 0;
7005 PLINT *arg1 = (PLINT *) 0 ;
7010 if (!PyArg_ParseTuple(args,(
char *)
":plglevel"))
SWIG_fail;
7026 PyObject *resultobj = 0;
7027 PLFLT *arg1 = (PLFLT *) 0 ;
7028 PLFLT *arg2 = (PLFLT *) 0 ;
7029 PLINT *arg3 = (PLINT *) 0 ;
7030 PLINT *arg4 = (PLINT *) 0 ;
7031 PLINT *arg5 = (PLINT *) 0 ;
7032 PLINT *arg6 = (PLINT *) 0 ;
7052 if (!PyArg_ParseTuple(args,(
char *)
":plgpage"))
SWIG_fail;
7053 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7098 PyObject *resultobj = 0;
7100 if (!PyArg_ParseTuple(args,(
char *)
":plgra"))
SWIG_fail;
7110 PyObject *resultobj = 0;
7111 PLFLT *arg1 = (PLFLT *) 0 ;
7112 PLFLT *arg2 = (PLFLT *) 0 ;
7113 PLFLT *arg3 = (PLFLT *) 0 ;
7115 PLFLT *arg5 = (PLFLT *) 0 ;
7117 PLFLT *arg7 = (PLFLT *) 0 ;
7119 PLFLT **arg9 = (PLFLT **) 0 ;
7122 PyArrayObject *tmp1 = NULL ;
7123 PyArrayObject *tmp2 = NULL ;
7124 PyArrayObject *tmp3 = NULL ;
7125 PyArrayObject *tmp5 = NULL ;
7126 PyArrayObject *tmp7 = NULL ;
7127 PyObject *array7 = NULL ;
7132 PyObject * obj0 = 0 ;
7133 PyObject * obj1 = 0 ;
7134 PyObject * obj2 = 0 ;
7135 PyObject * obj3 = 0 ;
7136 PyObject * obj4 = 0 ;
7137 PyObject * obj5 = 0 ;
7138 PyObject * obj6 = 0 ;
7140 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
7145 Alen = PyArray_DIMS( tmp1 )[0];
7146 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7152 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
7154 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7157 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7163 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
7165 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7168 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7169 arg4 = PyArray_DIMS( tmp3 )[0];
7175 Xlen = PyArray_DIMS( tmp5 )[0];
7177 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7185 Ylen = PyArray_DIMS( tmp7 )[0];
7187 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7192 array7 = PyArray_SimpleNew( 2, dims, NPY_FLOAT64 );
7196 arg9 = (
double **) malloc(
sizeof (
double * ) * (size_t) Xlen );
7197 for ( i = 0; i <
Xlen; i++ )
7198 arg9[i] = ( (
double *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7204 arg10 = (
PLINT)(val10);
7209 arg11 = (
PLFLT)(val11);
7210 plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
7254 PyObject *resultobj = 0;
7255 PLFLT *arg1 = (PLFLT *) 0 ;
7256 PLFLT *arg2 = (PLFLT *) 0 ;
7257 PLFLT *arg3 = (PLFLT *) 0 ;
7258 PLFLT *arg4 = (PLFLT *) 0 ;
7272 if (!PyArg_ParseTuple(args,(
char *)
":plgspa"))
SWIG_fail;
7273 plgspa(arg1,arg2,arg3,arg4);
7306 PyObject *resultobj = 0;
7307 PLINT *arg1 = (PLINT *) 0 ;
7312 if (!PyArg_ParseTuple(args,(
char *)
":plgstrm"))
SWIG_fail;
7328 PyObject *resultobj = 0;
7329 char *arg1 = (
char *) 0 ;
7335 if (!PyArg_ParseTuple(args,(
char *)
":plgver"))
SWIG_fail;
7339 PyObject *o = PyString_FromString( arg1 );
7349 PyObject *resultobj = 0;
7350 PLFLT *arg1 = (PLFLT *) 0 ;
7351 PLFLT *arg2 = (PLFLT *) 0 ;
7352 PLFLT *arg3 = (PLFLT *) 0 ;
7353 PLFLT *arg4 = (PLFLT *) 0 ;
7367 if (!PyArg_ParseTuple(args,(
char *)
":plgvpd"))
SWIG_fail;
7368 plgvpd(arg1,arg2,arg3,arg4);
7401 PyObject *resultobj = 0;
7402 PLFLT *arg1 = (PLFLT *) 0 ;
7403 PLFLT *arg2 = (PLFLT *) 0 ;
7404 PLFLT *arg3 = (PLFLT *) 0 ;
7405 PLFLT *arg4 = (PLFLT *) 0 ;
7419 if (!PyArg_ParseTuple(args,(
char *)
":plgvpw"))
SWIG_fail;
7420 plgvpw(arg1,arg2,arg3,arg4);
7453 PyObject *resultobj = 0;
7454 PLINT *arg1 = (PLINT *) 0 ;
7455 PLINT *arg2 = (PLINT *) 0 ;
7463 if (!PyArg_ParseTuple(args,(
char *)
":plgxax"))
SWIG_fail;
7485 PyObject *resultobj = 0;
7486 PLINT *arg1 = (PLINT *) 0 ;
7487 PLINT *arg2 = (PLINT *) 0 ;
7495 if (!PyArg_ParseTuple(args,(
char *)
":plgyax"))
SWIG_fail;
7517 PyObject *resultobj = 0;
7518 PLINT *arg1 = (PLINT *) 0 ;
7519 PLINT *arg2 = (PLINT *) 0 ;
7527 if (!PyArg_ParseTuple(args,(
char *)
":plgzax"))
SWIG_fail;
7549 PyObject *resultobj = 0;
7551 PLFLT *arg2 = (PLFLT *) 0 ;
7556 PyArrayObject *tmp1 = NULL ;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 PyObject * obj2 = 0 ;
7568 PyObject * obj3 = 0 ;
7569 PyObject * obj4 = 0 ;
7571 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
7576 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7577 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7583 arg3 = (
PLFLT)(val3);
7588 arg4 = (
PLFLT)(val4);
7593 arg5 = (
PLINT)(val5);
7598 arg6 = (
PLINT)(val6);
7599 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
7614 PyObject *resultobj = 0;
7618 PLFLT *arg4 = (PLFLT *) 0 ;
7619 PLFLT *arg5 = (PLFLT *) 0 ;
7620 PLFLT *arg6 = (PLFLT *) 0 ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 PyObject * obj2 = 0 ;
7640 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plhlsrgb",&obj0,&obj1,&obj2))
SWIG_fail;
7645 arg1 = (
PLFLT)(val1);
7650 arg2 = (
PLFLT)(val2);
7655 arg3 = (
PLFLT)(val3);
7656 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7683 PyObject *resultobj = 0;
7685 if (!PyArg_ParseTuple(args,(
char *)
":plinit"))
SWIG_fail;
7695 PyObject *resultobj = 0;
7708 PyObject * obj0 = 0 ;
7709 PyObject * obj1 = 0 ;
7710 PyObject * obj2 = 0 ;
7711 PyObject * obj3 = 0 ;
7713 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
7718 arg1 = (
PLFLT)(val1);
7723 arg2 = (
PLFLT)(val2);
7728 arg3 = (
PLFLT)(val3);
7733 arg4 = (
PLFLT)(val4);
7734 pljoin(arg1,arg2,arg3,arg4);
7743 PyObject *resultobj = 0;
7744 char *arg1 = (
char *) 0 ;
7745 char *arg2 = (
char *) 0 ;
7746 char *arg3 = (
char *) 0 ;
7756 PyObject * obj0 = 0 ;
7757 PyObject * obj1 = 0 ;
7758 PyObject * obj2 = 0 ;
7760 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllab",&obj0,&obj1,&obj2))
SWIG_fail;
7765 arg1 = (
char *)(buf1);
7770 arg2 = (
char *)(buf2);
7775 arg3 = (
char *)(buf3);
7776 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
7791 PyObject *resultobj = 0;
7792 PLFLT *arg1 = (PLFLT *) 0 ;
7793 PLFLT *arg2 = (PLFLT *) 0 ;
7805 PLINT *arg14 = (PLINT *) 0 ;
7810 PLINT *arg19 = (PLINT *) 0 ;
7811 char **arg20 = (
char **) 0 ;
7812 PLINT *arg21 = (PLINT *) 0 ;
7813 PLINT *arg22 = (PLINT *) 0 ;
7814 PLFLT *arg23 = (PLFLT *) 0 ;
7815 PLFLT *arg24 = (PLFLT *) 0 ;
7816 PLINT *arg25 = (PLINT *) 0 ;
7817 PLINT *arg26 = (PLINT *) 0 ;
7818 PLFLT *arg27 = (PLFLT *) 0 ;
7819 PLINT *arg28 = (PLINT *) 0 ;
7820 PLFLT *arg29 = (PLFLT *) 0 ;
7821 PLINT *arg30 = (PLINT *) 0 ;
7822 char **arg31 = (
char **) 0 ;
7847 PyArrayObject *tmp13 = NULL ;
7856 PyArrayObject *tmp19 = NULL ;
7857 PyArrayObject *tmp20 = NULL ;
7858 PyArrayObject *tmp21 = NULL ;
7859 PyArrayObject *tmp22 = NULL ;
7860 PyArrayObject *tmp23 = NULL ;
7861 PyArrayObject *tmp24 = NULL ;
7862 PyArrayObject *tmp25 = NULL ;
7863 PyArrayObject *tmp26 = NULL ;
7864 PyArrayObject *tmp27 = NULL ;
7865 PyArrayObject *tmp28 = NULL ;
7866 PyArrayObject *tmp29 = NULL ;
7867 PyArrayObject *tmp30 = NULL ;
7868 PyArrayObject *tmp31 = NULL ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 PyObject * obj2 = 0 ;
7872 PyObject * obj3 = 0 ;
7873 PyObject * obj4 = 0 ;
7874 PyObject * obj5 = 0 ;
7875 PyObject * obj6 = 0 ;
7876 PyObject * obj7 = 0 ;
7877 PyObject * obj8 = 0 ;
7878 PyObject * obj9 = 0 ;
7879 PyObject * obj10 = 0 ;
7880 PyObject * obj11 = 0 ;
7881 PyObject * obj12 = 0 ;
7882 PyObject * obj13 = 0 ;
7883 PyObject * obj14 = 0 ;
7884 PyObject * obj15 = 0 ;
7885 PyObject * obj16 = 0 ;
7886 PyObject * obj17 = 0 ;
7887 PyObject * obj18 = 0 ;
7888 PyObject * obj19 = 0 ;
7889 PyObject * obj20 = 0 ;
7890 PyObject * obj21 = 0 ;
7891 PyObject * obj22 = 0 ;
7892 PyObject * obj23 = 0 ;
7893 PyObject * obj24 = 0 ;
7894 PyObject * obj25 = 0 ;
7895 PyObject * obj26 = 0 ;
7896 PyObject * obj27 = 0 ;
7900 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;
7905 arg3 = (
PLINT)(val3);
7910 arg4 = (
PLINT)(val4);
7915 arg5 = (
PLFLT)(val5);
7920 arg6 = (
PLFLT)(val6);
7925 arg7 = (
PLFLT)(val7);
7930 arg8 = (
PLINT)(val8);
7935 arg9 = (
PLINT)(val9);
7940 arg10 = (
PLINT)(val10);
7945 arg11 = (
PLINT)(val11);
7950 arg12 = (
PLINT)(val12);
7953 if ( tmp13 == NULL )
7955 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7956 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7962 arg15 = (
PLFLT)(val15);
7967 arg16 = (
PLFLT)(val16);
7972 arg17 = (
PLFLT)(val17);
7977 arg18 = (
PLFLT)(val18);
7980 if ( tmp19 == NULL )
7982 if ( PyArray_DIMS( tmp19 )[0] !=
Alen )
7984 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7987 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7991 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7992 if ( tmp20 == NULL )
7994 if ( PyArray_DIMS( tmp20 )[0] !=
Alen )
7996 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7999 arg20 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8000 for ( i = 0; i <
Alen; i++ )
8002 arg20[i] = (
char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8003 if ( arg20[i] == NULL )
8012 if ( tmp21 == NULL )
8014 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8016 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8019 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8023 if ( tmp22 == NULL )
8025 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8027 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8030 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8033 if ( obj19 != Py_None )
8036 if ( tmp23 == NULL )
8038 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8040 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8043 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8051 if ( obj20 != Py_None )
8054 if ( tmp24 == NULL )
8056 if ( PyArray_DIMS( tmp24 )[0] !=
Alen )
8058 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8061 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8070 if ( tmp25 == NULL )
8072 if ( PyArray_DIMS( tmp25 )[0] !=
Alen )
8074 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8077 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8081 if ( tmp26 == NULL )
8083 if ( PyArray_DIMS( tmp26 )[0] !=
Alen )
8085 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8088 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8091 if ( obj23 != Py_None )
8094 if ( tmp27 == NULL )
8096 if ( PyArray_DIMS( tmp27 )[0] !=
Alen )
8098 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8101 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8110 if ( tmp28 == NULL )
8112 if ( PyArray_DIMS( tmp28 )[0] !=
Alen )
8114 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8117 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8120 if ( obj25 != Py_None )
8123 if ( tmp29 == NULL )
8125 if ( PyArray_DIMS( tmp29 )[0] !=
Alen )
8127 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8130 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8139 if ( tmp30 == NULL )
8141 if ( PyArray_DIMS( tmp30 )[0] !=
Alen )
8143 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8146 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8150 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8151 if ( tmp31 == NULL )
8153 if ( PyArray_DIMS( tmp31 )[0] !=
Alen )
8155 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8158 arg31 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8159 for ( i = 0; i <
Alen; i++ )
8161 arg31[i] = (
char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8162 if ( arg31[i] == NULL )
8169 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);
8190 Py_CLEAR( tmp20 ); free( arg20 );
8223 Py_CLEAR( tmp31 ); free( arg31 );
8234 Py_CLEAR( tmp20 ); free( arg20 );
8267 Py_CLEAR( tmp31 ); free( arg31 );
8274 PyObject *resultobj = 0;
8275 PLFLT *arg1 = (PLFLT *) 0 ;
8276 PLFLT *arg2 = (PLFLT *) 0 ;
8291 PLINT *arg17 = (PLINT *) 0 ;
8292 char **arg18 = (
char **) 0 ;
8294 char **arg20 = (
char **) 0 ;
8295 PLFLT *arg21 = (PLFLT *) 0 ;
8296 PLINT *arg22 = (PLINT *) 0 ;
8297 PLINT *arg23 = (PLINT *) 0 ;
8298 PLFLT **arg24 = (PLFLT **) 0 ;
8329 PyArrayObject *tmp16 = NULL ;
8330 PyArrayObject *tmp18 = NULL ;
8331 PyArrayObject *tmp19 = NULL ;
8332 PyArrayObject *tmp21 = NULL ;
8333 PyArrayObject *tmp22 = NULL ;
8334 PyArrayObject *tmp23 = NULL ;
8335 PyArrayObject *tmp24 = NULL ;
8336 PyObject * obj0 = 0 ;
8337 PyObject * obj1 = 0 ;
8338 PyObject * obj2 = 0 ;
8339 PyObject * obj3 = 0 ;
8340 PyObject * obj4 = 0 ;
8341 PyObject * obj5 = 0 ;
8342 PyObject * obj6 = 0 ;
8343 PyObject * obj7 = 0 ;
8344 PyObject * obj8 = 0 ;
8345 PyObject * obj9 = 0 ;
8346 PyObject * obj10 = 0 ;
8347 PyObject * obj11 = 0 ;
8348 PyObject * obj12 = 0 ;
8349 PyObject * obj13 = 0 ;
8350 PyObject * obj14 = 0 ;
8351 PyObject * obj15 = 0 ;
8352 PyObject * obj16 = 0 ;
8353 PyObject * obj17 = 0 ;
8354 PyObject * obj18 = 0 ;
8355 PyObject * obj19 = 0 ;
8359 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;
8364 arg3 = (
PLINT)(val3);
8369 arg4 = (
PLINT)(val4);
8374 arg5 = (
PLFLT)(val5);
8379 arg6 = (
PLFLT)(val6);
8384 arg7 = (
PLFLT)(val7);
8389 arg8 = (
PLFLT)(val8);
8394 arg9 = (
PLINT)(val9);
8399 arg10 = (
PLINT)(val10);
8404 arg11 = (
PLINT)(val11);
8409 arg12 = (
PLFLT)(val12);
8414 arg13 = (
PLFLT)(val13);
8419 arg14 = (
PLINT)(val14);
8424 arg15 = (
PLFLT)(val15);
8427 if ( tmp16 == NULL )
8429 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8430 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8434 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8435 if ( tmp18 == NULL )
8437 if ( PyArray_DIMS( tmp18 )[0] !=
Alen )
8439 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8442 arg18 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8443 for ( i = 0; i <
Alen; i++ )
8445 arg18[i] = (
char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8446 if ( arg18[i] == NULL )
8455 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8456 if ( tmp19 == NULL )
8458 Alen = PyArray_DIMS( tmp19 )[0];
8460 arg20 = (
char **) malloc(
sizeof (
char* ) * (size_t) Alen );
8461 for ( i = 0; i <
Alen; i++ )
8463 arg20[i] = (
char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8464 if ( arg20[i] == NULL )
8473 if ( tmp21 == NULL )
8475 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8477 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8480 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8484 if ( tmp22 == NULL )
8486 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8488 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8491 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8496 if ( tmp23 == NULL )
8498 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8500 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8503 Xlen = PyArray_DIMS( tmp23 )[0];
8504 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8506 for ( i = 0; i <
Xlen; i++ )
8507 if ( arg23[i] >
Ylen )
8513 if ( tmp24 == NULL )
8515 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] !=
Ylen )
8517 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8521 arg24 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) Xlen );
8522 for ( i = 0; i <
Xlen; i++ )
8523 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8525 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);
8543 Py_CLEAR( tmp18 ); free( arg18 );
8546 Py_CLEAR( tmp19 ); free( arg20 );
8567 Py_CLEAR( tmp18 ); free( arg18 );
8570 Py_CLEAR( tmp19 ); free( arg20 );
8590 PyObject *resultobj = 0;
8600 PyObject * obj0 = 0 ;
8601 PyObject * obj1 = 0 ;
8602 PyObject * obj2 = 0 ;
8604 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllightsource",&obj0,&obj1,&obj2))
SWIG_fail;
8609 arg1 = (
PLFLT)(val1);
8614 arg2 = (
PLFLT)(val2);
8619 arg3 = (
PLFLT)(val3);
8629 PyObject *resultobj = 0;
8631 PLFLT *arg2 = (PLFLT *) 0 ;
8632 PLFLT *arg3 = (PLFLT *) 0 ;
8633 PyArrayObject *tmp1 = NULL ;
8634 PyArrayObject *tmp3 = NULL ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8638 if (!PyArg_ParseTuple(args,(
char *)
"OO:plline",&obj0,&obj1))
SWIG_fail;
8643 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8644 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8650 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8652 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8655 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8657 plline(arg1,(
double const *)arg2,(
double const *)arg3);
8678 PyObject *resultobj = 0;
8680 PLFLT *arg2 = (PLFLT *) 0 ;
8681 PLFLT *arg3 = (PLFLT *) 0 ;
8682 PLFLT *arg4 = (PLFLT *) 0 ;
8683 PyArrayObject *tmp1 = NULL ;
8684 PyArrayObject *tmp3 = NULL ;
8685 PyArrayObject *tmp4 = NULL ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 PyObject * obj2 = 0 ;
8690 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plline3",&obj0,&obj1,&obj2))
SWIG_fail;
8695 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8696 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8702 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8704 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8707 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8713 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
8715 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8718 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8720 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
8747 PyObject *resultobj = 0;
8751 PyObject * obj0 = 0 ;
8753 if (!PyArg_ParseTuple(args,(
char *)
"O:pllsty",&obj0))
SWIG_fail;
8758 arg1 = (
PLINT)(val1);
8768 PyObject *resultobj = 0;
8769 PLFLT *arg1 = (PLFLT *) 0 ;
8770 PLFLT *arg2 = (PLFLT *) 0 ;
8771 PLFLT **arg3 = (PLFLT **) 0 ;
8775 PyArrayObject *tmp1 = NULL ;
8776 PyArrayObject *tmp2 = NULL ;
8777 PyArrayObject *tmp3 = NULL ;
8780 PyObject * obj0 = 0 ;
8781 PyObject * obj1 = 0 ;
8782 PyObject * obj2 = 0 ;
8783 PyObject * obj3 = 0 ;
8785 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
8790 Xlen = PyArray_DIMS( tmp1 )[0];
8791 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8797 Ylen = PyArray_DIMS( tmp2 )[0];
8798 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8805 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8807 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8810 arg4 = PyArray_DIMS( tmp3 )[0];
8811 arg5 = PyArray_DIMS( tmp3 )[1];
8813 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
8814 for ( i = 0; i < arg4; i++ )
8815 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8821 arg6 = (
PLINT)(val6);
8822 plmesh((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6);
8851 PyObject *resultobj = 0;
8852 PLFLT *arg1 = (PLFLT *) 0 ;
8853 PLFLT *arg2 = (PLFLT *) 0 ;
8854 PLFLT **arg3 = (PLFLT **) 0 ;
8858 PLFLT *arg7 = (PLFLT *) 0 ;
8860 PyArrayObject *tmp1 = NULL ;
8861 PyArrayObject *tmp2 = NULL ;
8862 PyArrayObject *tmp3 = NULL ;
8865 PyArrayObject *tmp7 = NULL ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 PyObject * obj2 = 0 ;
8869 PyObject * obj3 = 0 ;
8870 PyObject * obj4 = 0 ;
8872 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8877 Xlen = PyArray_DIMS( tmp1 )[0];
8878 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8884 Ylen = PyArray_DIMS( tmp2 )[0];
8885 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8892 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8894 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8897 arg4 = PyArray_DIMS( tmp3 )[0];
8898 arg5 = PyArray_DIMS( tmp3 )[1];
8900 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
8901 for ( i = 0; i < arg4; i++ )
8902 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8908 arg6 = (
PLINT)(val6);
8913 arg8 = PyArray_DIMS( tmp7 )[0];
8914 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8916 plmeshc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
8951 PyObject *resultobj = 0;
8952 PLINT *arg1 = (PLINT *) 0 ;
8957 if (!PyArg_ParseTuple(args,(
char *)
":plmkstrm"))
SWIG_fail;
8973 PyObject *resultobj = 0;
8974 char *arg1 = (
char *) 0 ;
8978 char *arg5 = (
char *) 0 ;
8991 PyObject * obj0 = 0 ;
8992 PyObject * obj1 = 0 ;
8993 PyObject * obj2 = 0 ;
8994 PyObject * obj3 = 0 ;
8995 PyObject * obj4 = 0 ;
8997 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9002 arg1 = (
char *)(buf1);
9007 arg2 = (
PLFLT)(val2);
9012 arg3 = (
PLFLT)(val3);
9017 arg4 = (
PLFLT)(val4);
9022 arg5 = (
char *)(buf5);
9023 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
9036 PyObject *resultobj = 0;
9037 char *arg1 = (
char *) 0 ;
9041 char *arg5 = (
char *) 0 ;
9054 PyObject * obj0 = 0 ;
9055 PyObject * obj1 = 0 ;
9056 PyObject * obj2 = 0 ;
9057 PyObject * obj3 = 0 ;
9058 PyObject * obj4 = 0 ;
9060 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9065 arg1 = (
char *)(buf1);
9070 arg2 = (
PLFLT)(val2);
9075 arg3 = (
PLFLT)(val3);
9080 arg4 = (
PLFLT)(val4);
9085 arg5 = (
char *)(buf5);
9086 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
9099 PyObject *resultobj = 0;
9100 PLFLT *arg1 = (PLFLT *) 0 ;
9101 PLFLT *arg2 = (PLFLT *) 0 ;
9102 PLFLT **arg3 = (PLFLT **) 0 ;
9107 PyArrayObject *tmp1 = NULL ;
9108 PyArrayObject *tmp2 = NULL ;
9109 PyArrayObject *tmp3 = NULL ;
9114 PyObject * obj0 = 0 ;
9115 PyObject * obj1 = 0 ;
9116 PyObject * obj2 = 0 ;
9117 PyObject * obj3 = 0 ;
9118 PyObject * obj4 = 0 ;
9120 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9125 Xlen = PyArray_DIMS( tmp1 )[0];
9126 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9132 Ylen = PyArray_DIMS( tmp2 )[0];
9133 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9140 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9142 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9145 arg4 = PyArray_DIMS( tmp3 )[0];
9146 arg5 = PyArray_DIMS( tmp3 )[1];
9148 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9149 for ( i = 0; i < arg4; i++ )
9150 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9156 arg6 = (
PLINT)(val6);
9162 plot3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,arg7);
9191 PyObject *resultobj = 0;
9192 PLFLT *arg1 = (PLFLT *) 0 ;
9193 PLFLT *arg2 = (PLFLT *) 0 ;
9194 PLFLT **arg3 = (PLFLT **) 0 ;
9198 PLFLT *arg7 = (PLFLT *) 0 ;
9200 PyArrayObject *tmp1 = NULL ;
9201 PyArrayObject *tmp2 = NULL ;
9202 PyArrayObject *tmp3 = NULL ;
9205 PyArrayObject *tmp7 = NULL ;
9206 PyObject * obj0 = 0 ;
9207 PyObject * obj1 = 0 ;
9208 PyObject * obj2 = 0 ;
9209 PyObject * obj3 = 0 ;
9210 PyObject * obj4 = 0 ;
9212 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9217 Xlen = PyArray_DIMS( tmp1 )[0];
9218 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9224 Ylen = PyArray_DIMS( tmp2 )[0];
9225 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9232 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9234 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9237 arg4 = PyArray_DIMS( tmp3 )[0];
9238 arg5 = PyArray_DIMS( tmp3 )[1];
9240 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9241 for ( i = 0; i < arg4; i++ )
9242 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9248 arg6 = (
PLINT)(val6);
9253 arg8 = PyArray_DIMS( tmp7 )[0];
9254 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9256 plot3dc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9291 PyObject *resultobj = 0;
9292 PLFLT *arg1 = (PLFLT *) 0 ;
9293 PLFLT *arg2 = (PLFLT *) 0 ;
9294 PLFLT **arg3 = (PLFLT **) 0 ;
9298 PLFLT *arg7 = (PLFLT *) 0 ;
9302 PLINT *arg11 = (PLINT *) 0 ;
9303 PLINT *arg12 = (PLINT *) 0 ;
9304 PyArrayObject *tmp1 = NULL ;
9305 PyArrayObject *tmp2 = NULL ;
9306 PyArrayObject *tmp3 = NULL ;
9309 PyArrayObject *tmp7 = NULL ;
9312 PyArrayObject *tmp10 = NULL ;
9313 PyArrayObject *tmp12 = NULL ;
9314 PyObject * obj0 = 0 ;
9315 PyObject * obj1 = 0 ;
9316 PyObject * obj2 = 0 ;
9317 PyObject * obj3 = 0 ;
9318 PyObject * obj4 = 0 ;
9319 PyObject * obj5 = 0 ;
9320 PyObject * obj6 = 0 ;
9321 PyObject * obj7 = 0 ;
9323 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9328 Xlen = PyArray_DIMS( tmp1 )[0];
9329 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9335 Ylen = PyArray_DIMS( tmp2 )[0];
9336 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9343 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9345 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9348 arg4 = PyArray_DIMS( tmp3 )[0];
9349 arg5 = PyArray_DIMS( tmp3 )[1];
9351 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9352 for ( i = 0; i < arg4; i++ )
9353 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9359 arg6 = (
PLINT)(val6);
9364 arg8 = PyArray_DIMS( tmp7 )[0];
9365 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9371 arg9 = (
PLINT)(val9);
9374 if ( tmp10 == NULL )
9376 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9377 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9381 if ( tmp12 == NULL )
9383 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9385 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9388 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9390 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);
9437 PyObject *resultobj = 0;
9438 PLFLT *arg1 = (PLFLT *) 0 ;
9439 PLFLT *arg2 = (PLFLT *) 0 ;
9440 PLFLT **arg3 = (PLFLT **) 0 ;
9444 PLFLT *arg7 = (PLFLT *) 0 ;
9446 PyArrayObject *tmp1 = NULL ;
9447 PyArrayObject *tmp2 = NULL ;
9448 PyArrayObject *tmp3 = NULL ;
9451 PyArrayObject *tmp7 = NULL ;
9452 PyObject * obj0 = 0 ;
9453 PyObject * obj1 = 0 ;
9454 PyObject * obj2 = 0 ;
9455 PyObject * obj3 = 0 ;
9456 PyObject * obj4 = 0 ;
9458 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9463 Xlen = PyArray_DIMS( tmp1 )[0];
9464 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9470 Ylen = PyArray_DIMS( tmp2 )[0];
9471 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9478 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9480 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9483 arg4 = PyArray_DIMS( tmp3 )[0];
9484 arg5 = PyArray_DIMS( tmp3 )[1];
9486 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9487 for ( i = 0; i < arg4; i++ )
9488 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9494 arg6 = (
PLINT)(val6);
9499 arg8 = PyArray_DIMS( tmp7 )[0];
9500 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9502 plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9537 PyObject *resultobj = 0;
9538 PLFLT *arg1 = (PLFLT *) 0 ;
9539 PLFLT *arg2 = (PLFLT *) 0 ;
9540 PLFLT **arg3 = (PLFLT **) 0 ;
9544 PLFLT *arg7 = (PLFLT *) 0 ;
9548 PLINT *arg11 = (PLINT *) 0 ;
9549 PLINT *arg12 = (PLINT *) 0 ;
9550 PyArrayObject *tmp1 = NULL ;
9551 PyArrayObject *tmp2 = NULL ;
9552 PyArrayObject *tmp3 = NULL ;
9555 PyArrayObject *tmp7 = NULL ;
9558 PyArrayObject *tmp10 = NULL ;
9559 PyArrayObject *tmp12 = NULL ;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 PyObject * obj2 = 0 ;
9563 PyObject * obj3 = 0 ;
9564 PyObject * obj4 = 0 ;
9565 PyObject * obj5 = 0 ;
9566 PyObject * obj6 = 0 ;
9567 PyObject * obj7 = 0 ;
9569 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9574 Xlen = PyArray_DIMS( tmp1 )[0];
9575 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9581 Ylen = PyArray_DIMS( tmp2 )[0];
9582 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9589 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9591 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9594 arg4 = PyArray_DIMS( tmp3 )[0];
9595 arg5 = PyArray_DIMS( tmp3 )[1];
9597 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg4 );
9598 for ( i = 0; i < arg4; i++ )
9599 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9605 arg6 = (
PLINT)(val6);
9610 arg8 = PyArray_DIMS( tmp7 )[0];
9611 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9617 arg9 = (
PLINT)(val9);
9620 if ( tmp10 == NULL )
9622 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9623 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9627 if ( tmp12 == NULL )
9629 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9631 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9634 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9636 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);
9683 PyObject *resultobj = 0;
9684 int *arg1 = (
int *) 0 ;
9685 char **arg2 = (
char **) 0 ;
9690 PyObject * obj0 = 0 ;
9691 PyObject * obj1 = 0 ;
9694 if (!PyArg_ParseTuple(args,(
char *)
"OO:plparseopts",&obj0,&obj1))
SWIG_fail;
9697 if ( !PyList_Check( obj0 ) )
9699 PyErr_SetString( PyExc_ValueError,
"Expecting a list" );
9702 tmp1 = PyList_Size( obj0 );
9704 arg2 = (
char **) malloc( (
size_t) ( tmp1 + 1 ) *
sizeof (
char * ) );
9705 for ( i = 0; i < tmp1; i++ )
9707 PyObject *s = PyList_GetItem( obj0, i );
9708 if ( !PyString_Check( s ) )
9711 PyErr_SetString( PyExc_ValueError,
"List items must be strings" );
9714 arg2[i] = PyString_AsString( s );
9722 arg3 = (
PLINT)(val3);
9740 PyObject *resultobj = 0;
9742 PLINT *arg2 = (PLINT *) 0 ;
9743 PLINT *arg3 = (PLINT *) 0 ;
9744 PyArrayObject *tmp1 = NULL ;
9745 PyArrayObject *tmp3 = NULL ;
9746 PyObject * obj0 = 0 ;
9747 PyObject * obj1 = 0 ;
9749 if (!PyArg_ParseTuple(args,(
char *)
"OO:plpat",&obj0,&obj1))
SWIG_fail;
9754 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9755 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9761 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9763 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9766 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9768 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
9789 PyObject *resultobj = 0;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 PyObject * obj2 = 0 ;
9808 PyObject * obj3 = 0 ;
9809 PyObject * obj4 = 0 ;
9811 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9816 arg1 = (
PLINT)(val1);
9821 arg2 = (
PLFLT)(val2);
9826 arg3 = (
PLFLT)(val3);
9831 arg4 = (
PLFLT)(val4);
9836 arg5 = (
PLFLT)(val5);
9837 plpath(arg1,arg2,arg3,arg4,arg5);
9846 PyObject *resultobj = 0;
9848 PLFLT *arg2 = (PLFLT *) 0 ;
9849 PLFLT *arg3 = (PLFLT *) 0 ;
9851 PyArrayObject *tmp1 = NULL ;
9852 PyArrayObject *tmp3 = NULL ;
9855 PyObject * obj0 = 0 ;
9856 PyObject * obj1 = 0 ;
9857 PyObject * obj2 = 0 ;
9859 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plpoin",&obj0,&obj1,&obj2))
SWIG_fail;
9864 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9865 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9871 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9873 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9876 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9882 arg4 = (
PLINT)(val4);
9883 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
9904 PyObject *resultobj = 0;
9906 PLFLT *arg2 = (PLFLT *) 0 ;
9907 PLFLT *arg3 = (PLFLT *) 0 ;
9908 PLFLT *arg4 = (PLFLT *) 0 ;
9910 PyArrayObject *tmp1 = NULL ;
9911 PyArrayObject *tmp3 = NULL ;
9912 PyArrayObject *tmp4 = NULL ;
9915 PyObject * obj0 = 0 ;
9916 PyObject * obj1 = 0 ;
9917 PyObject * obj2 = 0 ;
9918 PyObject * obj3 = 0 ;
9920 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
9925 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9926 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9932 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9934 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9937 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9943 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
9945 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9948 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9954 arg5 = (
PLINT)(val5);
9955 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
9982 PyObject *resultobj = 0;
9984 PLFLT *arg2 = (PLFLT *) 0 ;
9985 PLFLT *arg3 = (PLFLT *) 0 ;
9986 PLFLT *arg4 = (PLFLT *) 0 ;
9989 PyArrayObject *tmp1 = NULL ;
9990 PyArrayObject *tmp3 = NULL ;
9991 PyArrayObject *tmp4 = NULL ;
9992 PyArrayObject *tmp5 = NULL ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 PyObject * obj2 = 0 ;
9998 PyObject * obj3 = 0 ;
9999 PyObject * obj4 = 0 ;
10001 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
10004 if ( tmp1 == NULL )
10006 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10007 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10011 if ( tmp3 == NULL )
10013 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10015 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10018 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10022 if ( tmp4 == NULL )
10024 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10026 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10029 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10033 if ( tmp5 == NULL )
10035 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10037 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10040 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10047 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
10080 PyObject *resultobj = 0;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10090 if (!PyArg_ParseTuple(args,(
char *)
"OO:plprec",&obj0,&obj1))
SWIG_fail;
10095 arg1 = (
PLINT)(val1);
10100 arg2 = (
PLINT)(val2);
10110 PyObject *resultobj = 0;
10114 PyObject * obj0 = 0 ;
10116 if (!PyArg_ParseTuple(args,(
char *)
"O:plpsty",&obj0))
SWIG_fail;
10121 arg1 = (
PLINT)(val1);
10131 PyObject *resultobj = 0;
10137 char *arg6 = (
char *) 0 ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 PyObject * obj2 = 0 ;
10154 PyObject * obj3 = 0 ;
10155 PyObject * obj4 = 0 ;
10156 PyObject * obj5 = 0 ;
10158 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10163 arg1 = (
PLFLT)(val1);
10168 arg2 = (
PLFLT)(val2);
10173 arg3 = (
PLFLT)(val3);
10178 arg4 = (
PLFLT)(val4);
10183 arg5 = (
PLFLT)(val5);
10188 arg6 = (
char *)(buf6);
10189 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
10200 PyObject *resultobj = 0;
10211 char *arg11 = (
char *) 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 PyObject * obj2 = 0 ;
10238 PyObject * obj3 = 0 ;
10239 PyObject * obj4 = 0 ;
10240 PyObject * obj5 = 0 ;
10241 PyObject * obj6 = 0 ;
10242 PyObject * obj7 = 0 ;
10243 PyObject * obj8 = 0 ;
10244 PyObject * obj9 = 0 ;
10245 PyObject * obj10 = 0 ;
10247 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
10252 arg1 = (
PLFLT)(val1);
10257 arg2 = (
PLFLT)(val2);
10262 arg3 = (
PLFLT)(val3);
10267 arg4 = (
PLFLT)(val4);
10272 arg5 = (
PLFLT)(val5);
10277 arg6 = (
PLFLT)(val6);
10282 arg7 = (
PLFLT)(val7);
10287 arg8 = (
PLFLT)(val8);
10292 arg9 = (
PLFLT)(val9);
10297 arg10 = (
PLFLT)(val10);
10302 arg11 = (
char *)(buf11);
10303 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
10314 PyObject *resultobj = 0;
10317 if (!PyArg_ParseTuple(args,(
char *)
":plrandd"))
SWIG_fail;
10327 PyObject *resultobj = 0;
10329 if (!PyArg_ParseTuple(args,(
char *)
":plreplot"))
SWIG_fail;
10339 PyObject *resultobj = 0;
10343 PLFLT *arg4 = (PLFLT *) 0 ;
10344 PLFLT *arg5 = (PLFLT *) 0 ;
10345 PLFLT *arg6 = (PLFLT *) 0 ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 PyObject * obj2 = 0 ;
10365 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plrgbhls",&obj0,&obj1,&obj2))
SWIG_fail;
10370 arg1 = (
PLFLT)(val1);
10375 arg2 = (
PLFLT)(val2);
10380 arg3 = (
PLFLT)(val3);
10381 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10408 PyObject *resultobj = 0;
10415 PyObject * obj0 = 0 ;
10416 PyObject * obj1 = 0 ;
10418 if (!PyArg_ParseTuple(args,(
char *)
"OO:plschr",&obj0,&obj1))
SWIG_fail;
10423 arg1 = (
PLFLT)(val1);
10428 arg2 = (
PLFLT)(val2);
10438 PyObject *resultobj = 0;
10439 PLINT *arg1 = (PLINT *) 0 ;
10440 PLINT *arg2 = (PLINT *) 0 ;
10441 PLINT *arg3 = (PLINT *) 0 ;
10443 PyArrayObject *tmp1 = NULL ;
10444 PyArrayObject *tmp2 = NULL ;
10445 PyArrayObject *tmp3 = NULL ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 PyObject * obj2 = 0 ;
10450 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap0",&obj0,&obj1,&obj2))
SWIG_fail;
10453 if ( tmp1 == NULL )
10455 Alen = PyArray_DIMS( tmp1 )[0];
10456 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10460 if ( tmp2 == NULL )
10462 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10464 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10467 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10471 if ( tmp3 == NULL )
10473 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10475 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10478 arg4 = PyArray_DIMS( tmp3 )[0];
10479 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10481 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10508 PyObject *resultobj = 0;
10509 PLINT *arg1 = (PLINT *) 0 ;
10510 PLINT *arg2 = (PLINT *) 0 ;
10511 PLINT *arg3 = (PLINT *) 0 ;
10512 PLFLT *arg4 = (PLFLT *) 0 ;
10514 PyArrayObject *tmp1 = NULL ;
10515 PyArrayObject *tmp2 = NULL ;
10516 PyArrayObject *tmp3 = NULL ;
10517 PyArrayObject *tmp4 = NULL ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520 PyObject * obj2 = 0 ;
10521 PyObject * obj3 = 0 ;
10523 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10526 if ( tmp1 == NULL )
10528 Alen = PyArray_DIMS( tmp1 )[0];
10529 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10533 if ( tmp2 == NULL )
10535 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10537 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10540 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10544 if ( tmp3 == NULL )
10546 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10548 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10551 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10555 if ( tmp4 == NULL )
10557 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10559 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10562 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10563 arg5 = PyArray_DIMS( tmp4 )[0];
10565 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10598 PyObject *resultobj = 0;
10602 PyObject * obj0 = 0 ;
10604 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap0n",&obj0))
SWIG_fail;
10609 arg1 = (
PLINT)(val1);
10619 PyObject *resultobj = 0;
10620 PLINT *arg1 = (PLINT *) 0 ;
10621 PLINT *arg2 = (PLINT *) 0 ;
10622 PLINT *arg3 = (PLINT *) 0 ;
10624 PyArrayObject *tmp1 = NULL ;
10625 PyArrayObject *tmp2 = NULL ;
10626 PyArrayObject *tmp3 = NULL ;
10627 PyObject * obj0 = 0 ;
10628 PyObject * obj1 = 0 ;
10629 PyObject * obj2 = 0 ;
10631 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap1",&obj0,&obj1,&obj2))
SWIG_fail;
10634 if ( tmp1 == NULL )
10636 Alen = PyArray_DIMS( tmp1 )[0];
10637 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10641 if ( tmp2 == NULL )
10643 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10645 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10648 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10652 if ( tmp3 == NULL )
10654 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10656 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10659 arg4 = PyArray_DIMS( tmp3 )[0];
10660 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10662 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10689 PyObject *resultobj = 0;
10690 PLINT *arg1 = (PLINT *) 0 ;
10691 PLINT *arg2 = (PLINT *) 0 ;
10692 PLINT *arg3 = (PLINT *) 0 ;
10693 PLFLT *arg4 = (PLFLT *) 0 ;
10695 PyArrayObject *tmp1 = NULL ;
10696 PyArrayObject *tmp2 = NULL ;
10697 PyArrayObject *tmp3 = NULL ;
10698 PyArrayObject *tmp4 = NULL ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 PyObject * obj3 = 0 ;
10704 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10707 if ( tmp1 == NULL )
10709 Alen = PyArray_DIMS( tmp1 )[0];
10710 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10714 if ( tmp2 == NULL )
10716 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10718 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10721 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10725 if ( tmp3 == NULL )
10727 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10729 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10732 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10736 if ( tmp4 == NULL )
10738 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10740 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10743 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10744 arg5 = PyArray_DIMS( tmp4 )[0];
10746 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10779 PyObject *resultobj = 0;
10782 PLFLT *arg3 = (PLFLT *) 0 ;
10783 PLFLT *arg4 = (PLFLT *) 0 ;
10784 PLFLT *arg5 = (PLFLT *) 0 ;
10785 PLFLT *arg6 = (PLFLT *) 0 ;
10789 PyArrayObject *tmp2 = NULL ;
10790 PyArrayObject *tmp4 = NULL ;
10791 PyArrayObject *tmp5 = NULL ;
10792 PyArrayObject *tmp6 = NULL ;
10793 PyArrayObject *tmp7 = NULL ;
10794 PyObject * obj0 = 0 ;
10795 PyObject * obj1 = 0 ;
10796 PyObject * obj2 = 0 ;
10797 PyObject * obj3 = 0 ;
10798 PyObject * obj4 = 0 ;
10799 PyObject * obj5 = 0 ;
10801 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10809 if ( tmp2 == NULL )
10811 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10812 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10816 if ( tmp4 == NULL )
10818 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10820 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10823 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10827 if ( tmp5 == NULL )
10829 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10831 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10834 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10838 if ( tmp6 == NULL )
10840 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10842 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10845 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10849 if ( tmp7 == NULL )
10851 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10853 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10856 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10858 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
10897 PyObject *resultobj = 0;
10900 PLFLT *arg3 = (PLFLT *) 0 ;
10901 PLFLT *arg4 = (PLFLT *) 0 ;
10902 PLFLT *arg5 = (PLFLT *) 0 ;
10903 PLFLT *arg6 = (PLFLT *) 0 ;
10904 PLFLT *arg7 = (PLFLT *) 0 ;
10908 PyArrayObject *tmp2 = NULL ;
10909 PyArrayObject *tmp4 = NULL ;
10910 PyArrayObject *tmp5 = NULL ;
10911 PyArrayObject *tmp6 = NULL ;
10912 PyArrayObject *tmp7 = NULL ;
10913 PyArrayObject *tmp8 = NULL ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 PyObject * obj2 = 0 ;
10917 PyObject * obj3 = 0 ;
10918 PyObject * obj4 = 0 ;
10919 PyObject * obj5 = 0 ;
10920 PyObject * obj6 = 0 ;
10922 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
10930 if ( tmp2 == NULL )
10932 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10933 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10937 if ( tmp4 == NULL )
10939 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10941 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10944 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10948 if ( tmp5 == NULL )
10950 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10952 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10955 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10959 if ( tmp6 == NULL )
10961 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10963 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10966 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10970 if ( tmp7 == NULL )
10972 if ( PyArray_DIMS( tmp7 )[0] !=
Alen )
10974 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10977 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10981 if ( tmp8 == NULL )
10983 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10985 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10988 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10990 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
11035 PyObject *resultobj = 0;
11039 PyObject * obj0 = 0 ;
11041 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap1n",&obj0))
SWIG_fail;
11046 arg1 = (
PLINT)(val1);
11056 PyObject *resultobj = 0;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11066 if (!PyArg_ParseTuple(args,(
char *)
"OO:plscmap1_range",&obj0,&obj1))
SWIG_fail;
11071 arg1 = (
PLFLT)(val1);
11076 arg2 = (
PLFLT)(val2);
11086 PyObject *resultobj = 0;
11087 PLFLT *arg1 = (PLFLT *) 0 ;
11088 PLFLT *arg2 = (PLFLT *) 0 ;
11096 if (!PyArg_ParseTuple(args,(
char *)
":plgcmap1_range"))
SWIG_fail;
11118 PyObject *resultobj = 0;
11131 PyObject * obj0 = 0 ;
11132 PyObject * obj1 = 0 ;
11133 PyObject * obj2 = 0 ;
11134 PyObject * obj3 = 0 ;
11136 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11141 arg1 = (
PLINT)(val1);
11146 arg2 = (
PLINT)(val2);
11151 arg3 = (
PLINT)(val3);
11156 arg4 = (
PLINT)(val4);
11157 plscol0(arg1,arg2,arg3,arg4);
11166 PyObject *resultobj = 0;
11182 PyObject * obj0 = 0 ;
11183 PyObject * obj1 = 0 ;
11184 PyObject * obj2 = 0 ;
11185 PyObject * obj3 = 0 ;
11186 PyObject * obj4 = 0 ;
11188 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
11193 arg1 = (
PLINT)(val1);
11198 arg2 = (
PLINT)(val2);
11203 arg3 = (
PLINT)(val3);
11208 arg4 = (
PLINT)(val4);
11213 arg5 = (
PLFLT)(val5);
11214 plscol0a(arg1,arg2,arg3,arg4,arg5);
11223 PyObject *resultobj = 0;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11237 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscolbg",&obj0,&obj1,&obj2))
SWIG_fail;
11242 arg1 = (
PLINT)(val1);
11247 arg2 = (
PLINT)(val2);
11252 arg3 = (
PLINT)(val3);
11262 PyObject *resultobj = 0;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 PyObject * obj3 = 0 ;
11280 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11285 arg1 = (
PLINT)(val1);
11290 arg2 = (
PLINT)(val2);
11295 arg3 = (
PLINT)(val3);
11300 arg4 = (
PLFLT)(val4);
11310 PyObject *resultobj = 0;
11314 PyObject * obj0 = 0 ;
11316 if (!PyArg_ParseTuple(args,(
char *)
"O:plscolor",&obj0))
SWIG_fail;
11321 arg1 = (
PLINT)(val1);
11331 PyObject *resultobj = 0;
11335 PyObject * obj0 = 0 ;
11337 if (!PyArg_ParseTuple(args,(
char *)
"O:plscompression",&obj0))
SWIG_fail;
11342 arg1 = (
PLINT)(val1);
11352 PyObject *resultobj = 0;
11353 char *arg1 = (
char *) 0 ;
11357 PyObject * obj0 = 0 ;
11359 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdev",&obj0))
SWIG_fail;
11364 arg1 = (
char *)(buf1);
11365 plsdev((
char const *)arg1);
11376 PyObject *resultobj = 0;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391 PyObject * obj2 = 0 ;
11392 PyObject * obj3 = 0 ;
11394 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11399 arg1 = (
PLFLT)(val1);
11404 arg2 = (
PLFLT)(val2);
11409 arg3 = (
PLFLT)(val3);
11414 arg4 = (
PLFLT)(val4);
11424 PyObject *resultobj = 0;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 PyObject * obj2 = 0 ;
11446 PyObject * obj3 = 0 ;
11447 PyObject * obj4 = 0 ;
11448 PyObject * obj5 = 0 ;
11450 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
11455 arg1 = (
PLINT)(val1);
11460 arg2 = (
PLINT)(val2);
11465 arg3 = (
PLINT)(val3);
11470 arg4 = (
PLINT)(val4);
11475 arg5 = (
PLFLT)(val5);
11480 arg6 = (
PLFLT)(val6);
11481 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11490 PyObject *resultobj = 0;
11494 PyObject * obj0 = 0 ;
11496 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdiori",&obj0))
SWIG_fail;
11501 arg1 = (
PLFLT)(val1);
11511 PyObject *resultobj = 0;
11524 PyObject * obj0 = 0 ;
11525 PyObject * obj1 = 0 ;
11526 PyObject * obj2 = 0 ;
11527 PyObject * obj3 = 0 ;
11529 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11534 arg1 = (
PLFLT)(val1);
11539 arg2 = (
PLFLT)(val2);
11544 arg3 = (
PLFLT)(val3);
11549 arg4 = (
PLFLT)(val4);
11559 PyObject *resultobj = 0;
11572 PyObject * obj0 = 0 ;
11573 PyObject * obj1 = 0 ;
11574 PyObject * obj2 = 0 ;
11575 PyObject * obj3 = 0 ;
11577 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11582 arg1 = (
PLFLT)(val1);
11587 arg2 = (
PLFLT)(val2);
11592 arg3 = (
PLFLT)(val3);
11597 arg4 = (
PLFLT)(val4);
11607 PyObject *resultobj = 0;
11608 unsigned int arg1 ;
11609 unsigned int val1 ;
11611 PyObject * obj0 = 0 ;
11613 if (!PyArg_ParseTuple(args,(
char *)
"O:plseed",&obj0))
SWIG_fail;
11618 arg1 = (
unsigned int)(val1);
11628 PyObject *resultobj = 0;
11632 PyObject * obj0 = 0 ;
11634 if (!PyArg_ParseTuple(args,(
char *)
"O:plsesc",&obj0))
SWIG_fail;
11639 arg1 = (char)(val1);
11649 PyObject *resultobj = 0;
11650 char *arg1 = (
char *) 0 ;
11651 char *arg2 = (
char *) 0 ;
11658 PyObject * obj0 = 0 ;
11659 PyObject * obj1 = 0 ;
11662 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsetopt",&obj0,&obj1))
SWIG_fail;
11667 arg1 = (
char *)(buf1);
11672 arg2 = (
char *)(buf2);
11673 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
11686 PyObject *resultobj = 0;
11696 PyObject * obj0 = 0 ;
11697 PyObject * obj1 = 0 ;
11698 PyObject * obj2 = 0 ;
11700 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfam",&obj0,&obj1,&obj2))
SWIG_fail;
11705 arg1 = (
PLINT)(val1);
11710 arg2 = (
PLINT)(val2);
11715 arg3 = (
PLINT)(val3);
11725 PyObject *resultobj = 0;
11727 unsigned int val1 ;
11729 PyObject * obj0 = 0 ;
11731 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfci",&obj0))
SWIG_fail;
11746 PyObject *resultobj = 0;
11747 char *arg1 = (
char *) 0 ;
11751 PyObject * obj0 = 0 ;
11753 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfnam",&obj0))
SWIG_fail;
11758 arg1 = (
char *)(buf1);
11770 PyObject *resultobj = 0;
11780 PyObject * obj0 = 0 ;
11781 PyObject * obj1 = 0 ;
11782 PyObject * obj2 = 0 ;
11784 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfont",&obj0,&obj1,&obj2))
SWIG_fail;
11789 arg1 = (
PLINT)(val1);
11794 arg2 = (
PLINT)(val2);
11799 arg3 = (
PLINT)(val3);
11809 PyObject *resultobj = 0;
11810 PLFLT **arg1 = (PLFLT **) 0 ;
11818 PLFLT *arg9 = (PLFLT *) 0 ;
11827 PyArrayObject *tmp1 = NULL ;
11836 PyArrayObject *tmp9 = NULL ;
11845 PyObject * obj0 = 0 ;
11846 PyObject * obj1 = 0 ;
11847 PyObject * obj2 = 0 ;
11848 PyObject * obj3 = 0 ;
11849 PyObject * obj4 = 0 ;
11850 PyObject * obj5 = 0 ;
11851 PyObject * obj6 = 0 ;
11852 PyObject * obj7 = 0 ;
11853 PyObject * obj8 = 0 ;
11854 PyObject * obj9 = 0 ;
11855 PyObject * obj10 = 0 ;
11856 PyObject * obj11 = 0 ;
11871 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
11875 if ( tmp1 == NULL )
11877 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11878 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11880 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
11881 for ( i = 0; i < arg2; i++ )
11882 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11888 arg5 = (
PLFLT)(val5);
11893 arg6 = (
PLFLT)(val6);
11898 arg7 = (
PLFLT)(val7);
11903 arg8 = (
PLFLT)(val8);
11906 if ( tmp9 == NULL )
11908 arg10 = PyArray_DIMS( tmp9 )[0];
11909 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11915 arg11 = (
PLFLT)(val11);
11920 arg12 = (
PLINT)(val12);
11925 arg13 = (
PLFLT)(val13);
11930 arg15 = (
PLBOOL)(val15);
11934 if ( obj10 == Py_None )
11940 if ( !PyCallable_Check( (PyObject *) obj10 ) )
11942 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
11951 if ( obj11 == Py_None )
11959 plshades((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(
double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11994 PyObject *resultobj = 0;
11995 PLFLT **arg1 = (PLFLT **) 0 ;
12016 PyArrayObject *tmp1 = NULL ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 PyObject * obj2 = 0 ;
12048 PyObject * obj3 = 0 ;
12049 PyObject * obj4 = 0 ;
12050 PyObject * obj5 = 0 ;
12051 PyObject * obj6 = 0 ;
12052 PyObject * obj7 = 0 ;
12053 PyObject * obj8 = 0 ;
12054 PyObject * obj9 = 0 ;
12055 PyObject * obj10 = 0 ;
12056 PyObject * obj11 = 0 ;
12057 PyObject * obj12 = 0 ;
12058 PyObject * obj13 = 0 ;
12059 PyObject * obj14 = 0 ;
12060 PyObject * obj15 = 0 ;
12061 PyObject * obj16 = 0 ;
12076 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;
12080 if ( tmp1 == NULL )
12082 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12083 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12085 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
12086 for ( i = 0; i < arg2; i++ )
12087 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12093 arg5 = (
PLFLT)(val5);
12098 arg6 = (
PLFLT)(val6);
12103 arg7 = (
PLFLT)(val7);
12108 arg8 = (
PLFLT)(val8);
12113 arg9 = (
PLFLT)(val9);
12118 arg10 = (
PLFLT)(val10);
12123 arg11 = (
PLINT)(val11);
12128 arg12 = (
PLFLT)(val12);
12133 arg13 = (
PLFLT)(val13);
12138 arg14 = (
PLINT)(val14);
12143 arg15 = (
PLFLT)(val15);
12148 arg16 = (
PLINT)(val16);
12153 arg17 = (
PLFLT)(val17);
12158 arg19 = (
PLBOOL)(val19);
12162 if ( obj15 == Py_None )
12168 if ( !PyCallable_Check( (PyObject *) obj15 ) )
12170 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
12179 if ( obj16 == Py_None )
12187 plshade((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12216 PyObject *resultobj = 0;
12220 PyObject * obj0 = 0 ;
12221 PyObject * obj1 = 0 ;
12223 if (!PyArg_ParseTuple(args,(
char *)
"OO:plslabelfunc",&obj0,&obj1))
SWIG_fail;
12226 if ( python_label )
12228 Py_CLEAR( python_label );
12232 if ( obj0 == Py_None )
12238 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12240 PyErr_SetString( PyExc_ValueError,
"label_func argument must be callable" );
12244 Py_XINCREF( (PyObject *) obj0 );
12245 python_label = (PyObject *) obj0;
12263 PyObject *resultobj = 0;
12270 PyObject * obj0 = 0 ;
12271 PyObject * obj1 = 0 ;
12273 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmaj",&obj0,&obj1))
SWIG_fail;
12278 arg1 = (
PLFLT)(val1);
12283 arg2 = (
PLFLT)(val2);
12293 PyObject *resultobj = 0;
12296 void *arg3 = (
void *) 0 ;
12304 PyObject * obj0 = 0 ;
12305 PyObject * obj1 = 0 ;
12306 PyObject * obj2 = 0 ;
12308 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmem",&obj0,&obj1,&obj2))
SWIG_fail;
12313 arg1 = (
PLINT)(val1);
12318 arg2 = (
PLINT)(val2);
12320 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12325 arg3 = (
void *) buf3;
12336 PyObject *resultobj = 0;
12339 void *arg3 = (
void *) 0 ;
12347 PyObject * obj0 = 0 ;
12348 PyObject * obj1 = 0 ;
12349 PyObject * obj2 = 0 ;
12351 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmema",&obj0,&obj1,&obj2))
SWIG_fail;
12356 arg1 = (
PLINT)(val1);
12361 arg2 = (
PLINT)(val2);
12363 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12368 arg3 = (
void *) buf3;
12379 PyObject *resultobj = 0;
12386 PyObject * obj0 = 0 ;
12387 PyObject * obj1 = 0 ;
12389 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmin",&obj0,&obj1))
SWIG_fail;
12394 arg1 = (
PLFLT)(val1);
12399 arg2 = (
PLFLT)(val2);
12409 PyObject *resultobj = 0;
12413 PyObject * obj0 = 0 ;
12415 if (!PyArg_ParseTuple(args,(
char *)
"O:plsori",&obj0))
SWIG_fail;
12420 arg1 = (
PLINT)(val1);
12430 PyObject *resultobj = 0;
12449 PyObject * obj0 = 0 ;
12450 PyObject * obj1 = 0 ;
12451 PyObject * obj2 = 0 ;
12452 PyObject * obj3 = 0 ;
12453 PyObject * obj4 = 0 ;
12454 PyObject * obj5 = 0 ;
12456 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
12461 arg1 = (
PLFLT)(val1);
12466 arg2 = (
PLFLT)(val2);
12471 arg3 = (
PLINT)(val3);
12476 arg4 = (
PLINT)(val4);
12481 arg5 = (
PLINT)(val5);
12486 arg6 = (
PLINT)(val6);
12487 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12496 PyObject *resultobj = 0;
12497 char *arg1 = (
char *) 0 ;
12501 PyObject * obj0 = 0 ;
12503 if (!PyArg_ParseTuple(args,(
char *)
"O:plspal0",&obj0))
SWIG_fail;
12508 arg1 = (
char *)(buf1);
12520 PyObject *resultobj = 0;
12521 char *arg1 = (
char *) 0 ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12531 if (!PyArg_ParseTuple(args,(
char *)
"OO:plspal1",&obj0,&obj1))
SWIG_fail;
12536 arg1 = (
char *)(buf1);
12542 plspal1((
char const *)arg1,arg2);
12553 PyObject *resultobj = 0;
12557 PyObject * obj0 = 0 ;
12559 if (!PyArg_ParseTuple(args,(
char *)
"O:plspause",&obj0))
SWIG_fail;
12574 PyObject *resultobj = 0;
12578 PyObject * obj0 = 0 ;
12580 if (!PyArg_ParseTuple(args,(
char *)
"O:plsstrm",&obj0))
SWIG_fail;
12585 arg1 = (
PLINT)(val1);
12595 PyObject *resultobj = 0;
12602 PyObject * obj0 = 0 ;
12603 PyObject * obj1 = 0 ;
12605 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssub",&obj0,&obj1))
SWIG_fail;
12610 arg1 = (
PLINT)(val1);
12615 arg2 = (
PLINT)(val2);
12625 PyObject *resultobj = 0;
12632 PyObject * obj0 = 0 ;
12633 PyObject * obj1 = 0 ;
12635 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssym",&obj0,&obj1))
SWIG_fail;
12640 arg1 = (
PLFLT)(val1);
12645 arg2 = (
PLFLT)(val2);
12655 PyObject *resultobj = 0;
12662 PyObject * obj0 = 0 ;
12663 PyObject * obj1 = 0 ;
12665 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstar",&obj0,&obj1))
SWIG_fail;
12670 arg1 = (
PLINT)(val1);
12675 arg2 = (
PLINT)(val2);
12685 PyObject *resultobj = 0;
12686 char *arg1 = (
char *) 0 ;
12696 PyObject * obj0 = 0 ;
12697 PyObject * obj1 = 0 ;
12698 PyObject * obj2 = 0 ;
12700 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstart",&obj0,&obj1,&obj2))
SWIG_fail;
12705 arg1 = (
char *)(buf1);
12710 arg2 = (
PLINT)(val2);
12715 arg3 = (
PLINT)(val3);
12716 plstart((
char const *)arg1,arg2,arg3);
12727 PyObject *resultobj = 0;
12731 PyObject * obj0 = 0 ;
12732 PyObject * obj1 = 0 ;
12738 if (!PyArg_ParseTuple(args,(
char *)
"|OO:plstransform",&obj0,&obj1))
SWIG_fail;
12744 if ( obj0 == Py_None )
12750 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12752 PyErr_SetString( PyExc_ValueError,
"coordinate transform argument must be callable" );
12774 PyObject *resultobj = 0;
12776 PLFLT *arg2 = (PLFLT *) 0 ;
12777 PLFLT *arg3 = (PLFLT *) 0 ;
12778 char *arg4 = (
char *) 0 ;
12779 PyArrayObject *tmp1 = NULL ;
12780 PyArrayObject *tmp3 = NULL ;
12784 PyObject * obj0 = 0 ;
12785 PyObject * obj1 = 0 ;
12786 PyObject * obj2 = 0 ;
12788 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstring",&obj0,&obj1,&obj2))
SWIG_fail;
12791 if ( tmp1 == NULL )
12793 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12794 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12798 if ( tmp3 == NULL )
12800 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12802 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12805 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12811 arg4 = (
char *)(buf4);
12812 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
12835 PyObject *resultobj = 0;
12837 PLFLT *arg2 = (PLFLT *) 0 ;
12838 PLFLT *arg3 = (PLFLT *) 0 ;
12839 PLFLT *arg4 = (PLFLT *) 0 ;
12840 char *arg5 = (
char *) 0 ;
12841 PyArrayObject *tmp1 = NULL ;
12842 PyArrayObject *tmp3 = NULL ;
12843 PyArrayObject *tmp4 = NULL ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 PyObject * obj3 = 0 ;
12852 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12855 if ( tmp1 == NULL )
12857 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12858 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12862 if ( tmp3 == NULL )
12864 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12866 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12869 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12873 if ( tmp4 == NULL )
12875 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
12877 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12880 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12886 arg5 = (
char *)(buf5);
12887 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
12916 PyObject *resultobj = 0;
12929 PyObject * obj0 = 0 ;
12930 PyObject * obj1 = 0 ;
12931 PyObject * obj2 = 0 ;
12932 PyObject * obj3 = 0 ;
12934 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12939 arg1 = (
PLINT)(val1);
12944 arg2 = (
PLINT)(val2);
12949 arg3 = (
PLFLT)(val3);
12954 arg4 = (
PLFLT)(val4);
12964 PyObject *resultobj = 0;
12965 PLINT *arg1 = (PLINT *) 0 ;
12966 char *arg2 = (
char *) 0 ;
12967 char *arg3 = (
char *) 0 ;
12979 PLINT *arg15 = (PLINT *) 0 ;
12980 PLINT *arg16 = (PLINT *) 0 ;
12982 char *arg18 = (
char *) 0 ;
12983 char *arg19 = (
char *) 0 ;
12984 char *arg20 = (
char *) 0 ;
13015 PyArrayObject *tmp15 = NULL ;
13016 PyArrayObject *tmp16 = NULL ;
13017 char **tmp17 = NULL ;
13027 PyObject * obj0 = 0 ;
13028 PyObject * obj1 = 0 ;
13029 PyObject * obj2 = 0 ;
13030 PyObject * obj3 = 0 ;
13031 PyObject * obj4 = 0 ;
13032 PyObject * obj5 = 0 ;
13033 PyObject * obj6 = 0 ;
13034 PyObject * obj7 = 0 ;
13035 PyObject * obj8 = 0 ;
13036 PyObject * obj9 = 0 ;
13037 PyObject * obj10 = 0 ;
13038 PyObject * obj11 = 0 ;
13039 PyObject * obj12 = 0 ;
13040 PyObject * obj13 = 0 ;
13041 PyObject * obj14 = 0 ;
13042 PyObject * obj15 = 0 ;
13043 PyObject * obj16 = 0 ;
13044 PyObject * obj17 = 0 ;
13045 PyObject * obj18 = 0 ;
13048 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;
13053 arg2 = (
char *)(buf2);
13058 arg3 = (
char *)(buf3);
13063 arg4 = (
PLFLT)(val4);
13068 arg5 = (
PLFLT)(val5);
13073 arg6 = (
PLFLT)(val6);
13078 arg7 = (
PLFLT)(val7);
13083 arg8 = (
PLFLT)(val8);
13088 arg9 = (
PLFLT)(val9);
13093 arg10 = (
PLFLT)(val10);
13098 arg11 = (
PLBOOL)(val11);
13103 arg12 = (
PLBOOL)(val12);
13108 arg13 = (
PLINT)(val13);
13113 arg14 = (
PLINT)(val14);
13116 if ( tmp15 == NULL )
13118 Alen = PyArray_DIMS( tmp15 )[0];
13119 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13123 if ( tmp16 == NULL )
13125 if ( PyArray_DIMS( tmp16 )[0] !=
Alen )
13127 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13130 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13136 PyErr_SetString( PyExc_ValueError,
"Requires a sequence of 4 strings." );
13141 PyErr_SetString( PyExc_ValueError,
"colline and styline args must be length 4." );
13144 tmp17 = (
char **) malloc(
sizeof (
char* ) * 4 );
13145 if ( tmp17 == NULL )
13148 for ( i = 0; i < 4; i++ )
13151 if ( arg17[i] == NULL )
13162 arg18 = (
char *)(buf18);
13167 arg19 = (
char *)(buf19);
13172 arg20 = (
char *)(buf20);
13173 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);
13216 PyObject *resultobj = 0;
13220 PyObject * obj0 = 0 ;
13222 if (!PyArg_ParseTuple(args,(
char *)
"O:plstripd",&obj0))
SWIG_fail;
13227 arg1 = (
PLINT)(val1);
13237 PyObject *resultobj = 0;
13239 PLINT *arg2 = (PLINT *) 0 ;
13240 PLINT *arg3 = (PLINT *) 0 ;
13241 PyArrayObject *tmp1 = NULL ;
13242 PyArrayObject *tmp3 = NULL ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13246 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstyl",&obj0,&obj1))
SWIG_fail;
13249 if ( tmp1 == NULL )
13251 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13252 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13256 if ( tmp3 == NULL )
13258 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13260 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13263 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13265 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
13286 PyObject *resultobj = 0;
13287 PLFLT *arg1 = (PLFLT *) 0 ;
13288 PLFLT *arg2 = (PLFLT *) 0 ;
13291 PyArrayObject *tmp1 = NULL ;
13292 PyArrayObject *tmp2 = NULL ;
13295 PyObject * obj0 = 0 ;
13296 PyObject * obj1 = 0 ;
13297 PyObject * obj2 = 0 ;
13299 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsvect",&obj0,&obj1,&obj2))
SWIG_fail;
13301 if ( obj0 != Py_None )
13304 if ( tmp1 == NULL )
13306 Alen = PyArray_DIMS( tmp1 )[0];
13307 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13316 if ( obj1 != Py_None )
13319 if ( tmp2 == NULL )
13321 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
13323 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13326 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13327 arg3 = PyArray_DIMS( tmp2 )[0];
13340 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
13361 PyObject *resultobj = 0;
13374 PyObject * obj0 = 0 ;
13375 PyObject * obj1 = 0 ;
13376 PyObject * obj2 = 0 ;
13377 PyObject * obj3 = 0 ;
13379 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13384 arg1 = (
PLFLT)(val1);
13389 arg2 = (
PLFLT)(val2);
13394 arg3 = (
PLFLT)(val3);
13399 arg4 = (
PLFLT)(val4);
13400 plsvpa(arg1,arg2,arg3,arg4);
13409 PyObject *resultobj = 0;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13419 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsxax",&obj0,&obj1))
SWIG_fail;
13424 arg1 = (
PLINT)(val1);
13429 arg2 = (
PLINT)(val2);
13439 PyObject *resultobj = 0;
13446 PyObject * obj0 = 0 ;
13447 PyObject * obj1 = 0 ;
13449 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsyax",&obj0,&obj1))
SWIG_fail;
13454 arg1 = (
PLINT)(val1);
13459 arg2 = (
PLINT)(val2);
13469 PyObject *resultobj = 0;
13471 PLFLT *arg2 = (PLFLT *) 0 ;
13472 PLFLT *arg3 = (PLFLT *) 0 ;
13474 PyArrayObject *tmp1 = NULL ;
13475 PyArrayObject *tmp3 = NULL ;
13478 PyObject * obj0 = 0 ;
13479 PyObject * obj1 = 0 ;
13480 PyObject * obj2 = 0 ;
13482 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsym",&obj0,&obj1,&obj2))
SWIG_fail;
13485 if ( tmp1 == NULL )
13487 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13488 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13492 if ( tmp3 == NULL )
13494 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13496 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13499 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13505 arg4 = (
PLINT)(val4);
13506 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
13527 PyObject *resultobj = 0;
13534 PyObject * obj0 = 0 ;
13535 PyObject * obj1 = 0 ;
13537 if (!PyArg_ParseTuple(args,(
char *)
"OO:plszax",&obj0,&obj1))
SWIG_fail;
13542 arg1 = (
PLINT)(val1);
13547 arg2 = (
PLINT)(val2);
13557 PyObject *resultobj = 0;
13559 if (!PyArg_ParseTuple(args,(
char *)
":pltext"))
SWIG_fail;
13569 PyObject *resultobj = 0;
13570 char *arg1 = (
char *) 0 ;
13574 PyObject * obj0 = 0 ;
13576 if (!PyArg_ParseTuple(args,(
char *)
"O:pltimefmt",&obj0))
SWIG_fail;
13581 arg1 = (
char *)(buf1);
13593 PyObject *resultobj = 0;
13597 PyObject * obj0 = 0 ;
13599 if (!PyArg_ParseTuple(args,(
char *)
"O:plvasp",&obj0))
SWIG_fail;
13604 arg1 = (
PLFLT)(val1);
13614 PyObject *resultobj = 0;
13615 PLFLT **arg1 = (PLFLT **) 0 ;
13616 PLFLT **arg2 = (PLFLT **) 0 ;
13622 PyArrayObject *tmp1 = NULL ;
13623 PyArrayObject *tmp2 = NULL ;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 PyObject * obj2 = 0 ;
13629 PyObject * obj3 = 0 ;
13630 PyObject * obj4 = 0 ;
13639 if (!PyArg_ParseTuple(args,(
char *)
"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13643 if ( tmp1 == NULL )
13645 Xlen = PyArray_DIMS( tmp1 )[0];
13646 Ylen = PyArray_DIMS( tmp1 )[1];
13648 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) Xlen );
13649 for ( i = 0; i <
Xlen; i++ )
13650 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13655 if ( tmp2 == NULL )
13657 if ( Xlen != PyArray_DIMS( tmp2 )[0] ||
Ylen != PyArray_DIMS( tmp2 )[1] )
13659 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
13662 arg3 = PyArray_DIMS( tmp2 )[0];
13663 arg4 = PyArray_DIMS( tmp2 )[1];
13665 arg2 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg3 );
13666 for ( i = 0; i < arg3; i++ )
13667 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13673 arg5 = (
PLFLT)(val5);
13677 if ( obj3 == Py_None )
13683 if ( !PyCallable_Check( (PyObject *) obj3 ) )
13685 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
13694 if ( obj4 == Py_None )
13702 plvect((
double const **)arg1,(
double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13739 PyObject *resultobj = 0;
13755 PyObject * obj0 = 0 ;
13756 PyObject * obj1 = 0 ;
13757 PyObject * obj2 = 0 ;
13758 PyObject * obj3 = 0 ;
13759 PyObject * obj4 = 0 ;
13761 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13766 arg1 = (
PLFLT)(val1);
13771 arg2 = (
PLFLT)(val2);
13776 arg3 = (
PLFLT)(val3);
13781 arg4 = (
PLFLT)(val4);
13786 arg5 = (
PLFLT)(val5);
13787 plvpas(arg1,arg2,arg3,arg4,arg5);
13796 PyObject *resultobj = 0;
13809 PyObject * obj0 = 0 ;
13810 PyObject * obj1 = 0 ;
13811 PyObject * obj2 = 0 ;
13812 PyObject * obj3 = 0 ;
13814 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13819 arg1 = (
PLFLT)(val1);
13824 arg2 = (
PLFLT)(val2);
13829 arg3 = (
PLFLT)(val3);
13834 arg4 = (
PLFLT)(val4);
13835 plvpor(arg1,arg2,arg3,arg4);
13844 PyObject *resultobj = 0;
13846 if (!PyArg_ParseTuple(args,(
char *)
":plvsta"))
SWIG_fail;
13856 PyObject *resultobj = 0;
13890 PyObject * obj0 = 0 ;
13891 PyObject * obj1 = 0 ;
13892 PyObject * obj2 = 0 ;
13893 PyObject * obj3 = 0 ;
13894 PyObject * obj4 = 0 ;
13895 PyObject * obj5 = 0 ;
13896 PyObject * obj6 = 0 ;
13897 PyObject * obj7 = 0 ;
13898 PyObject * obj8 = 0 ;
13899 PyObject * obj9 = 0 ;
13900 PyObject * obj10 = 0 ;
13902 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
13907 arg1 = (
PLFLT)(val1);
13912 arg2 = (
PLFLT)(val2);
13917 arg3 = (
PLFLT)(val3);
13922 arg4 = (
PLFLT)(val4);
13927 arg5 = (
PLFLT)(val5);
13932 arg6 = (
PLFLT)(val6);
13937 arg7 = (
PLFLT)(val7);
13942 arg8 = (
PLFLT)(val8);
13947 arg9 = (
PLFLT)(val9);
13952 arg10 = (
PLFLT)(val10);
13957 arg11 = (
PLFLT)(val11);
13958 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13967 PyObject *resultobj = 0;
13971 PyObject * obj0 = 0 ;
13973 if (!PyArg_ParseTuple(args,(
char *)
"O:plwidth",&obj0))
SWIG_fail;
13978 arg1 = (
PLFLT)(val1);
13988 PyObject *resultobj = 0;
14001 PyObject * obj0 = 0 ;
14002 PyObject * obj1 = 0 ;
14003 PyObject * obj2 = 0 ;
14004 PyObject * obj3 = 0 ;
14006 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plwind",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
14011 arg1 = (
PLFLT)(val1);
14016 arg2 = (
PLFLT)(val2);
14021 arg3 = (
PLFLT)(val3);
14026 arg4 = (
PLFLT)(val4);
14027 plwind(arg1,arg2,arg3,arg4);
14036 PyObject *resultobj = 0;
14043 PyObject * obj0 = 0 ;
14046 if (!PyArg_ParseTuple(args,(
char *)
"O:plxormod",&obj0))
SWIG_fail;
14067 PyObject *resultobj = 0;
14069 char *arg2 = (
char *) 0 ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 PyObject * obj2 = 0 ;
14088 PyObject * obj3 = 0 ;
14089 PyObject * obj4 = 0 ;
14090 PyObject * obj5 = 0 ;
14092 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
14095 if ( obj0 == Py_None )
14101 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14103 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14113 arg2 = (
char *)(buf2);
14118 arg3 = (
PLFLT)(val3);
14123 arg4 = (
PLFLT)(val4);
14128 arg5 = (
PLFLT)(val5);
14133 arg6 = (
PLFLT)(val6);
14134 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
14151 PyObject *resultobj = 0;
14153 char *arg2 = (
char *) 0 ;
14158 PLINT *arg7 = (PLINT *) 0 ;
14171 PyArrayObject *tmp7 = NULL ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 PyObject * obj2 = 0 ;
14175 PyObject * obj3 = 0 ;
14176 PyObject * obj4 = 0 ;
14177 PyObject * obj5 = 0 ;
14178 PyObject * obj6 = 0 ;
14180 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14183 if ( obj0 == Py_None )
14189 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14191 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14201 arg2 = (
char *)(buf2);
14206 arg3 = (
PLFLT)(val3);
14211 arg4 = (
PLFLT)(val4);
14216 arg5 = (
PLFLT)(val5);
14221 arg6 = (
PLFLT)(val6);
14223 if ( obj6 != Py_None )
14226 if ( tmp7 == NULL )
14228 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14229 arg8 = PyArray_DIMS( tmp7 )[0];
14237 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
14260 PyObject *resultobj = 0;
14262 char *arg2 = (
char *) 0 ;
14263 char *arg3 = (
char *) 0 ;
14268 PLINT *arg8 = (PLINT *) 0 ;
14284 PyArrayObject *tmp8 = NULL ;
14285 PyObject * obj0 = 0 ;
14286 PyObject * obj1 = 0 ;
14287 PyObject * obj2 = 0 ;
14288 PyObject * obj3 = 0 ;
14289 PyObject * obj4 = 0 ;
14290 PyObject * obj5 = 0 ;
14291 PyObject * obj6 = 0 ;
14292 PyObject * obj7 = 0 ;
14294 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
14297 if ( obj0 == Py_None )
14303 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14305 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14315 arg2 = (
char *)(buf2);
14320 arg3 = (
char *)(buf3);
14325 arg4 = (
PLFLT)(val4);
14330 arg5 = (
PLFLT)(val5);
14335 arg6 = (
PLFLT)(val6);
14340 arg7 = (
PLFLT)(val7);
14342 if ( obj7 != Py_None )
14345 if ( tmp8 == NULL )
14347 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14348 arg9 = PyArray_DIMS( tmp8 )[0];
14356 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
14381 PyObject *resultobj = 0;
14383 char *arg2 = (
char *) 0 ;
14387 char *arg6 = (
char *) 0 ;
14415 PyObject * obj0 = 0 ;
14416 PyObject * obj1 = 0 ;
14417 PyObject * obj2 = 0 ;
14418 PyObject * obj3 = 0 ;
14419 PyObject * obj4 = 0 ;
14420 PyObject * obj5 = 0 ;
14421 PyObject * obj6 = 0 ;
14422 PyObject * obj7 = 0 ;
14423 PyObject * obj8 = 0 ;
14424 PyObject * obj9 = 0 ;
14425 PyObject * obj10 = 0 ;
14427 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14430 if ( obj0 == Py_None )
14436 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14438 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14448 arg2 = (
char *)(buf2);
14453 arg3 = (
PLFLT)(val3);
14458 arg4 = (
PLFLT)(val4);
14463 arg5 = (
PLFLT)(val5);
14468 arg6 = (
char *)(buf6);
14473 arg7 = (
PLFLT)(val7);
14478 arg8 = (
PLFLT)(val8);
14483 arg9 = (
PLFLT)(val9);
14488 arg10 = (
PLFLT)(val10);
14493 arg11 = (
PLINT)(val11);
14494 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14513 PyObject *resultobj = 0;
14515 char *arg2 = (
char *) 0 ;
14520 PLINT *arg7 = (PLINT *) 0 ;
14533 PyArrayObject *tmp7 = NULL ;
14534 PyObject * obj0 = 0 ;
14535 PyObject * obj1 = 0 ;
14536 PyObject * obj2 = 0 ;
14537 PyObject * obj3 = 0 ;
14538 PyObject * obj4 = 0 ;
14539 PyObject * obj5 = 0 ;
14540 PyObject * obj6 = 0 ;
14542 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14545 if ( obj0 == Py_None )
14551 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14553 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14563 arg2 = (
char *)(buf2);
14568 arg3 = (
PLFLT)(val3);
14573 arg4 = (
PLFLT)(val4);
14578 arg5 = (
PLFLT)(val5);
14583 arg6 = (
PLFLT)(val6);
14585 if ( obj6 != Py_None )
14588 if ( tmp7 == NULL )
14590 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14591 arg8 = PyArray_DIMS( tmp7 )[0];
14599 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
14622 PyObject *resultobj = 0;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 PyObject * obj2 = 0 ;
14645 PyObject * obj3 = 0 ;
14646 PyObject * obj4 = 0 ;
14647 PyObject * obj5 = 0 ;
14648 PyObject * obj6 = 0 ;
14650 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14653 if ( obj0 == Py_None )
14659 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14661 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14671 arg2 = (
PLFLT)(val2);
14676 arg3 = (
PLFLT)(val3);
14681 arg4 = (
PLFLT)(val4);
14686 arg5 = (
PLFLT)(val5);
14691 arg6 = (
PLFLT)(val6);
14696 arg7 = (
PLFLT)(val7);
14712 PyObject *resultobj = 0;
14713 PLFLT **arg1 = (PLFLT **) 0 ;
14726 PyArrayObject *tmp1 = NULL ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 PyObject * obj3 = 0 ;
14751 PyObject * obj4 = 0 ;
14752 PyObject * obj5 = 0 ;
14753 PyObject * obj6 = 0 ;
14754 PyObject * obj7 = 0 ;
14755 PyObject * obj8 = 0 ;
14756 PyObject * obj9 = 0 ;
14757 PyObject * obj10 = 0 ;
14759 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14763 if ( tmp1 == NULL )
14765 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14766 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14768 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
14769 for ( i = 0; i < arg2; i++ )
14770 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14776 arg4 = (
PLFLT)(val4);
14781 arg5 = (
PLFLT)(val5);
14786 arg6 = (
PLFLT)(val6);
14791 arg7 = (
PLFLT)(val7);
14796 arg8 = (
PLFLT)(val8);
14801 arg9 = (
PLFLT)(val9);
14806 arg10 = (
PLFLT)(val10);
14811 arg11 = (
PLFLT)(val11);
14816 arg12 = (
PLFLT)(val12);
14821 arg13 = (
PLFLT)(val13);
14822 plimage((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14839 PyObject *resultobj = 0;
14840 PLFLT **arg1 = (PLFLT **) 0 ;
14853 PyArrayObject *tmp1 = NULL ;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 PyObject * obj2 = 0 ;
14873 PyObject * obj3 = 0 ;
14874 PyObject * obj4 = 0 ;
14875 PyObject * obj5 = 0 ;
14876 PyObject * obj6 = 0 ;
14877 PyObject * obj7 = 0 ;
14878 PyObject * obj8 = 0 ;
14879 PyObject * obj9 = 0 ;
14880 PyObject * obj10 = 0 ;
14889 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14893 if ( tmp1 == NULL )
14895 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14896 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14898 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
14899 for ( i = 0; i < arg2; i++ )
14900 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14906 arg4 = (
PLFLT)(val4);
14911 arg5 = (
PLFLT)(val5);
14916 arg6 = (
PLFLT)(val6);
14921 arg7 = (
PLFLT)(val7);
14926 arg8 = (
PLFLT)(val8);
14931 arg9 = (
PLFLT)(val9);
14936 arg10 = (
PLFLT)(val10);
14941 arg11 = (
PLFLT)(val11);
14945 if ( obj9 == Py_None )
14951 if ( !PyCallable_Check( (PyObject *) obj9 ) )
14953 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
14962 if ( obj10 == Py_None )
14970 plimagefr((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14999 PyObject *resultobj = 0;
15001 if (!PyArg_ParseTuple(args,(
char *)
":plClearOpts"))
SWIG_fail;
15011 PyObject *resultobj = 0;
15013 if (!PyArg_ParseTuple(args,(
char *)
":plResetOpts"))
SWIG_fail;
15023 PyObject *resultobj = 0;
15024 char *arg1 = (
char *) 0 ;
15025 char *arg2 = (
char *) 0 ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15035 if (!PyArg_ParseTuple(args,(
char *)
"OO:plSetUsage",&obj0,&obj1))
SWIG_fail;
15040 arg1 = (
char *)(buf1);
15045 arg2 = (
char *)(buf2);
15046 plSetUsage((
char const *)arg1,(
char const *)arg2);
15059 PyObject *resultobj = 0;
15061 if (!PyArg_ParseTuple(args,(
char *)
":plOptUsage"))
SWIG_fail;
15071 PyObject *resultobj = 0;
15072 PLFLT **arg1 = (PLFLT **) 0 ;
15075 PLFLT *arg4 = (PLFLT *) 0 ;
15076 PLFLT *arg5 = (PLFLT *) 0 ;
15077 PyArrayObject *tmp1 = NULL ;
15082 PyObject * obj0 = 0 ;
15086 if (!PyArg_ParseTuple(args,(
char *)
"O:plMinMax2dGrid",&obj0))
SWIG_fail;
15090 if ( tmp1 == NULL )
15092 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15093 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15095 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * (size_t) arg2 );
15096 for ( i = 0; i < arg2; i++ )
15097 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15128 PyObject *resultobj = 0;
15132 PyObject * obj0 = 0 ;
15135 if (!PyArg_ParseTuple(args,(
char *)
"O:plGetCursor",&obj0))
SWIG_fail;
15151 { (
char *)
"pltr0",
_wrap_pltr0, METH_VARARGS, NULL},
15152 { (
char *)
"pltr1",
_wrap_pltr1, METH_VARARGS, NULL},
15153 { (
char *)
"pltr2",
_wrap_pltr2, METH_VARARGS, NULL},
15183 "Set format of numerical label for contours\n"
15187 " Set format of numerical label for contours. \n"
15189 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15191 " This function is used example 9. \n"
15197 "pl_setcontlabelformat(lexp, sigdig)\n"
15201 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15202 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15203 " format is used. Default value of lexp is 4. \n"
15205 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15210 "Set parameters of contour labelling other than format of numerical label\n"
15214 " Set parameters of contour labelling other than those handled by\n"
15215 " pl_setcontlabelformat. \n"
15217 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15219 " This function is used in example 9. \n"
15225 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15229 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15230 " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
15232 " size (PLFLT, input) : Font height for contour labels (normalized). \n"
15233 " Default value is 0.3. \n"
15235 " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
15236 " Default value is 0.1. \n"
15238 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15239 " contour labels on. Default is off (0). \n"
15242 { (
char *)
"pladv",
_wrap_pladv, METH_VARARGS, (
char *)
"\n"
15243 "Advance the (sub-)page\n"
15247 " Advances to the next subpage if sub=0, performing a page advance if\n"
15248 " there are no remaining subpages on the current page. If subpages\n"
15249 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15250 " PLplot switches to the specified subpage. Note that this allows you\n"
15251 " to overwrite a plot on the specified subpage; if this is not what you\n"
15252 " intended, use pleop followed by plbop to first advance the page. This\n"
15253 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15254 " is not used, pladv must be called after initializing PLplot but before\n"
15255 " defining the viewport. \n"
15257 " Redacted form: pladv(page)\n"
15259 " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
15269 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15270 " in the top left corner and increasing along the rows) to which to\n"
15271 " advance. Set to zero to advance to the next subpage (or to the\n"
15272 " next page if subpages are not being used). \n"
15275 { (
char *)
"plarc",
_wrap_plarc, METH_VARARGS, (
char *)
"\n"
15276 "Draw a circular or elliptical arc \n"
15280 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15281 " semiminor axis b, starting at angle1 and ending at angle2. \n"
15283 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15287 " This function is used in examples 3 and 27. \n"
15293 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15297 " x (PLFLT, input) : X coordinate of arc center. \n"
15299 " y (PLFLT, input) : Y coordinate of arc center. \n"
15301 " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
15303 " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
15305 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15306 " semimajor axis. \n"
15308 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15309 " semimajor axis. \n"
15311 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15314 " fill (PLBOOL, input) : Draw a filled arc. \n"
15317 { (
char *)
"plaxes",
_wrap_plaxes, METH_VARARGS, (
char *)
"\n"
15318 "Draw a box with axes, etc. with arbitrary origin \n"
15322 " Draws a box around the currently defined viewport with arbitrary\n"
15323 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15324 " world coordinate values appropriate to the window. Thus plaxes should\n"
15325 " only be called after defining both viewport and window. The character\n"
15326 " strings xopt and yopt specify how the box should be drawn as described\n"
15327 " below. If ticks and/or subticks are to be drawn for a particular\n"
15328 " axis, the tick intervals and number of subintervals may be specified\n"
15329 " explicitly, or they may be defaulted by setting the appropriate\n"
15330 " arguments to zero. \n"
15332 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15334 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
15338 " This function is not used in any examples. \n"
15344 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15348 " x0 (PLFLT, input) : World X coordinate of origin. \n"
15350 " y0 (PLFLT, input) : World Y coordinate of origin. \n"
15352 " xopt (const char *, input) : Pointer to character string specifying\n"
15353 " options for horizontal axis. The string can include any\n"
15354 " combination of the following letters (upper or lower case) in any\n"
15355 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
15356 " is vertical line (x=0). \n"
15357 " b: Draws bottom (X) or left (Y) edge of frame. \n"
15358 " c: Draws top (X) or right (Y) edge of frame. \n"
15359 " d: Plot labels as date / time. Values are assumed to be\n"
15360 " seconds since the epoch (as used by gmtime). \n"
15361 " f: Always use fixed point numeric labels. \n"
15362 " g: Draws a grid at the major tick interval. \n"
15363 " h: Draws a grid at the minor tick interval. \n"
15364 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15366 " l: Labels axis logarithmically. This only affects the labels,\n"
15367 " not the data, and so it is necessary to compute the logarithms\n"
15368 " of data points before passing them to any of the drawing\n"
15370 " m: Writes numeric labels at major tick intervals in the\n"
15371 " unconventional location (above box for X, right of box for Y). \n"
15372 " n: Writes numeric labels at major tick intervals in the\n"
15373 " conventional location (below box for X, left of box for Y). \n"
15374 " o: Use custom labelling function to generate axis label text. \n"
15375 " The custom labelling function can be defined with the\n"
15376 " plslabelfunc command. \n"
15377 " s: Enables subticks between major ticks, only valid if t is\n"
15378 " also specified. \n"
15379 " t: Draws major ticks. \n"
15380 " u: Exactly like \"b\" except don't draw edge line. \n"
15381 " w: Exactly like \"c\" except don't draw edge line. \n"
15382 " x: Exactly like \"t\" (including the side effect of the\n"
15383 " numerical labels for the major ticks) except exclude drawing\n"
15384 " the major and minor tick marks. \n"
15387 " xtick (PLFLT, input) : World coordinate interval between major\n"
15388 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15389 " generates a suitable tick interval. \n"
15391 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15392 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15393 " generates a suitable minor tick interval. \n"
15395 " yopt (const char *, input) : Pointer to character string specifying\n"
15396 " options for vertical axis. The string can include any combination\n"
15397 " of the letters defined above for xopt, and in addition may\n"
15398 " contain: v: Write numeric labels for vertical axis parallel to the\n"
15399 " base of the graph, rather than parallel to the axis. \n"
15402 " ytick (PLFLT, input) : World coordinate interval between major\n"
15403 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15404 " generates a suitable tick interval. \n"
15406 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15407 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15408 " generates a suitable minor tick interval. \n"
15411 { (
char *)
"plbin",
_wrap_plbin, METH_VARARGS, (
char *)
"\n"
15412 "Plot a histogram from binned data \n"
15416 " Plots a histogram consisting of nbin bins. The value associated with\n"
15417 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15418 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15419 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15420 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15421 " placed midway between the values in the x array. Also see plhist for\n"
15422 " drawing histograms from unbinned data. \n"
15424 " Redacted form: General: plbin(x, y, opt)\n"
15425 " Perl/PDL: plbin(nbin, x, y, opt)\n"
15426 " Python: plbin(nbin, x, y, opt)\n"
15429 " This function is not used in any examples. \n"
15435 "plbin(nbin, x, y, opt)\n"
15439 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15440 " and y arrays.) \n"
15442 " x (const PLFLT *, input) : Pointer to array containing values\n"
15443 " associated with bins. These must form a strictly increasing\n"
15446 " y (const PLFLT *, input) : Pointer to array containing number of\n"
15447 " points in bin. This is a PLFLT (instead of PLINT) array so as to\n"
15448 " allow histograms of probabilities, etc. \n"
15450 " opt (PLINT, input) : Is a combination of several flags:\n"
15451 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15452 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15453 " zero height are simply drawn. \n"
15454 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15455 " between the x values. If the values in x are equally spaced,\n"
15456 " the values are the center values of the bins. \n"
15457 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15458 " size as the ones inside. \n"
15459 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15460 " (there is a gap for such bins). \n"
15463 { (
char *)
"plbtime",
_wrap_plbtime, METH_VARARGS, (
char *)
"\n"
15464 "Calculate broken-down time from continuous time for the current stream \n"
15468 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15469 " continuous time, ctime for the current stream. This function is the\n"
15470 " inverse of plctime. \n"
15472 " The PLplot definition of broken-down time is a calendar time that\n"
15473 " completely ignores all time zone offsets, i.e., it is the user's\n"
15474 " responsibility to apply those offsets (if so desired) before using the\n"
15475 " PLplot time API. By default broken-down time is defined using the\n"
15476 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15477 " continuous time is defined as the number of seconds since the Unix\n"
15478 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15479 " broken-down and continuous time are possible, see plconfigtime. \n"
15481 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15483 " Perl/PDL: Not available? \n"
15486 " This function is used in example 29. \n"
15492 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15496 " year (PLINT *, output) : Output year. \n"
15498 " month (PLINT *, output) : Output month in range from 0 (January) to\n"
15499 " 11 (December). \n"
15501 " day (PLINT *, output) : Output day in range from 1 to 31. \n"
15503 " hour (PLINT *, output) : Output hour in range from 0 to 23. \n"
15505 " min (PLINT *, output) : Output minute in range from 0 to 59 \n"
15507 " sec (PLFLT *, output) : Output second in floating range from 0. to\n"
15510 " ctime (PLFLT, input) : Continous time from which the broken-down\n"
15511 " time is calculated. \n"
15514 { (
char *)
"plbop",
_wrap_plbop, METH_VARARGS, (
char *)
"\n"
15515 "Begin a new page\n"
15519 " Begins a new page. For a file driver, the output file is opened if\n"
15520 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15521 " page break is desired at a particular point when plotting to subpages.\n"
15522 " Another use for pleop and plbop is when plotting pages to different\n"
15523 " files, since you can manually set the file name by calling plsfnam\n"
15524 " after the call to pleop. (In fact some drivers may only support a\n"
15525 " single page per file, making this a necessity.) One way to handle\n"
15526 " this case automatically is to page advance via pladv, but enable\n"
15527 " familying (see plsfam) with a small limit on the file size so that a\n"
15528 " new family member file will be created on each page break. \n"
15530 " Redacted form: plbop()\n"
15532 " This function is used in examples 2,20. \n"
15541 { (
char *)
"plbox",
_wrap_plbox, METH_VARARGS, (
char *)
"\n"
15542 "Draw a box with axes, etc\n"
15546 " Draws a box around the currently defined viewport, and labels it with\n"
15547 " world coordinate values appropriate to the window. Thus plbox should\n"
15548 " only be called after defining both viewport and window. The character\n"
15549 " strings xopt and yopt specify how the box should be drawn as described\n"
15550 " below. If ticks and/or subticks are to be drawn for a particular\n"
15551 " axis, the tick intervals and number of subintervals may be specified\n"
15552 " explicitly, or they may be defaulted by setting the appropriate\n"
15553 " arguments to zero. \n"
15555 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15556 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
15559 " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
15565 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15569 " xopt (const char *, input) : Pointer to character string specifying\n"
15570 " options for horizontal axis. The string can include any\n"
15571 " combination of the following letters (upper or lower case) in any\n"
15572 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
15573 " is vertical line (x=0). \n"
15574 " b: Draws bottom (X) or left (Y) edge of frame. \n"
15575 " c: Draws top (X) or right (Y) edge of frame. \n"
15576 " d: Plot labels as date / time. Values are assumed to be\n"
15577 " seconds since the epoch (as used by gmtime). \n"
15578 " f: Always use fixed point numeric labels. \n"
15579 " g: Draws a grid at the major tick interval. \n"
15580 " h: Draws a grid at the minor tick interval. \n"
15581 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15583 " l: Labels axis logarithmically. This only affects the labels,\n"
15584 " not the data, and so it is necessary to compute the logarithms\n"
15585 " of data points before passing them to any of the drawing\n"
15587 " m: Writes numeric labels at major tick intervals in the\n"
15588 " unconventional location (above box for X, right of box for Y). \n"
15589 " n: Writes numeric labels at major tick intervals in the\n"
15590 " conventional location (below box for X, left of box for Y). \n"
15591 " o: Use custom labelling function to generate axis label text. \n"
15592 " The custom labelling function can be defined with the\n"
15593 " plslabelfunc command. \n"
15594 " s: Enables subticks between major ticks, only valid if t is\n"
15595 " also specified. \n"
15596 " t: Draws major ticks. \n"
15597 " u: Exactly like \"b\" except don't draw edge line. \n"
15598 " w: Exactly like \"c\" except don't draw edge line. \n"
15599 " x: Exactly like \"t\" (including the side effect of the\n"
15600 " numerical labels for the major ticks) except exclude drawing\n"
15601 " the major and minor tick marks. \n"
15604 " xtick (PLFLT, input) : World coordinate interval between major\n"
15605 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15606 " generates a suitable tick interval. \n"
15608 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15609 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15610 " generates a suitable minor tick interval. \n"
15612 " yopt (const char *, input) : Pointer to character string specifying\n"
15613 " options for vertical axis. The string can include any combination\n"
15614 " of the letters defined above for xopt, and in addition may\n"
15615 " contain: v: Write numeric labels for vertical axis parallel to the\n"
15616 " base of the graph, rather than parallel to the axis. \n"
15619 " ytick (PLFLT, input) : World coordinate interval between major\n"
15620 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15621 " generates a suitable tick interval. \n"
15623 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15624 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15625 " generates a suitable minor tick interval. \n"
15628 { (
char *)
"plbox3",
_wrap_plbox3, METH_VARARGS, (
char *)
"\n"
15629 "Draw a box with axes, etc, in 3-d \n"
15633 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15634 " plot. For a more complete description of three-dimensional plotting\n"
15635 " see the PLplot documentation. \n"
15637 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15638 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15639 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15640 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15643 " This function is used in examples 8,11,18,21. \n"
15649 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15653 " xopt (const char *, input) : Pointer to character string specifying\n"
15654 " options for the x axis. The string can include any combination of\n"
15655 " the following letters (upper or lower case) in any order: b: Draws\n"
15656 " axis at base, at height z=\n"
15657 " zmin where zmin is defined by call to plw3d. This character must be\n"
15658 " specified in order to use any of the other options. \n"
15659 " f: Always use fixed point numeric labels. \n"
15660 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15661 " than upwards. \n"
15662 " l: Labels axis logarithmically. This only affects the labels,\n"
15663 " not the data, and so it is necessary to compute the logarithms\n"
15664 " of data points before passing them to any of the drawing\n"
15666 " n: Writes numeric labels at major tick intervals. \n"
15667 " o: Use custom labelling function to generate axis label text. \n"
15668 " The custom labelling function can be defined with the\n"
15669 " plslabelfunc command. \n"
15670 " s: Enables subticks between major ticks, only valid if t is\n"
15671 " also specified. \n"
15672 " t: Draws major ticks. \n"
15673 " u: If this is specified, the text label for the axis is\n"
15674 " written under the axis. \n"
15677 " xlabel (const char *, input) : Pointer to character string\n"
15678 " specifying text label for the x axis. It is only drawn if u is in\n"
15679 " the xopt string. \n"
15681 " xtick (PLFLT, input) : World coordinate interval between major\n"
15682 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15683 " generates a suitable tick interval. \n"
15685 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15686 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15687 " generates a suitable minor tick interval. \n"
15689 " yopt (const char *, input) : Pointer to character string specifying\n"
15690 " options for the y axis. The string is interpreted in the same way\n"
15693 " ylabel (const char *, input) : Pointer to character string\n"
15694 " specifying text label for the y axis. It is only drawn if u is in\n"
15695 " the yopt string. \n"
15697 " ytick (PLFLT, input) : World coordinate interval between major\n"
15698 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15699 " generates a suitable tick interval. \n"
15701 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15702 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15703 " generates a suitable minor tick interval. \n"
15705 " zopt (const char *, input) : Pointer to character string specifying\n"
15706 " options for the z axis. The string can include any combination of\n"
15707 " the following letters (upper or lower case) in any order: b: Draws\n"
15708 " z axis to the left of the surface plot. \n"
15709 " c: Draws z axis to the right of the surface plot. \n"
15710 " d: Draws grid lines parallel to the x-y plane behind the\n"
15711 " figure. These lines are not drawn until after plot3d or\n"
15712 " plmesh are called because of the need for hidden line removal. \n"
15713 " f: Always use fixed point numeric labels. \n"
15714 " i: Inverts tick marks, so they are drawn away from the center. \n"
15715 " l: Labels axis logarithmically. This only affects the labels,\n"
15716 " not the data, and so it is necessary to compute the logarithms\n"
15717 " of data points before passing them to any of the drawing\n"
15719 " m: Writes numeric labels at major tick intervals on the\n"
15720 " right-hand vertical axis. \n"
15721 " n: Writes numeric labels at major tick intervals on the\n"
15722 " left-hand vertical axis. \n"
15723 " o: Use custom labelling function to generate axis label text. \n"
15724 " The custom labelling function can be defined with the\n"
15725 " plslabelfunc command. \n"
15726 " s: Enables subticks between major ticks, only valid if t is\n"
15727 " also specified. \n"
15728 " t: Draws major ticks. \n"
15729 " u: If this is specified, the text label is written beside the\n"
15730 " left-hand axis. \n"
15731 " v: If this is specified, the text label is written beside the\n"
15732 " right-hand axis. \n"
15735 " zlabel (const char *, input) : Pointer to character string\n"
15736 " specifying text label for the z axis. It is only drawn if u or v\n"
15737 " are in the zopt string. \n"
15739 " ztick (PLFLT, input) : World coordinate interval between major\n"
15740 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15741 " generates a suitable tick interval. \n"
15743 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15744 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15745 " generates a suitable minor tick interval. \n"
15749 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15753 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15754 " from relative device coordinates, rx and ry. \n"
15756 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15757 " Perl/PDL: Not available? \n"
15760 " This function is used in example 31. \n"
15766 "plcalc_world(rx, ry, wx, wy, window)\n"
15770 " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15771 " 0. to 1.) for the x coordinate. \n"
15773 " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15774 " 0. to 1.) for the y coordinate. \n"
15776 " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15777 " x corresponding to the relative device coordinates rx and ry. \n"
15779 " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15780 " y corresponding to the relative device coordinates rx and ry. \n"
15782 " window (PLINT *, output) : Pointer to the returned last defined\n"
15783 " window index that corresponds to the input relative device\n"
15784 " coordinates (and the returned world coordinates). To give some\n"
15785 " background on the window index, for each page the initial window\n"
15786 " index is set to zero, and each time plwind is called within the\n"
15787 " page, world and device coordinates are stored for the window and\n"
15788 " the window index is incremented. Thus, for a simple page layout\n"
15789 " with non-overlapping viewports and one window per viewport, window\n"
15790 " corresponds to the viewport index (in the order which the\n"
15791 " viewport/windows were created) of the only viewport/window\n"
15792 " corresponding to rx and ry. However, for more complicated layouts\n"
15793 " with potentially overlapping viewports and possibly more than one\n"
15794 " window (set of world coordinates) per viewport, window and the\n"
15795 " corresponding output world coordinates corresponds to the last\n"
15796 " window created that fulfills the criterion that the relative\n"
15797 " device coordinates are inside it. Finally, in all cases where the\n"
15798 " input relative device coordinates are not inside any\n"
15799 " viewport/window, then window is set to -1. \n"
15802 { (
char *)
"plclear",
_wrap_plclear, METH_VARARGS, (
char *)
"\n"
15803 "Clear current (sub)page \n"
15807 " Clears the current page, effectively erasing everything that have been\n"
15808 " drawn. This command only works with interactive drivers; if the\n"
15809 " driver does not support this, the page is filled with the background\n"
15810 " color in use. If the current page is divided into subpages, only the\n"
15811 " current subpage is erased. The nth subpage can be selected with\n"
15814 " Redacted form: General: plclear()\n"
15815 " Perl/PDL: Not available? \n"
15818 " This function is not used in any examples. \n"
15827 { (
char *)
"plcol0",
_wrap_plcol0, METH_VARARGS, (
char *)
"\n"
15828 "Set color, cmap0 \n"
15832 " Sets the color index for cmap0 (see the PLplot documentation). \n"
15834 " Redacted form: plcol0(icol0)\n"
15836 " This function is used in examples 1-9,11-16,18-27,29. \n"
15846 " icol0 (PLINT, input) : Integer representing the color. The\n"
15847 " defaults at present are (these may change): \n"
15848 " 0 black (default background) \n"
15849 " 1 red (default foreground) \n"
15858 " 10 BlueViolet \n"
15865 " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15866 " change an individual color in the map0 color palette. \n"
15869 { (
char *)
"plcol1",
_wrap_plcol1, METH_VARARGS, (
char *)
"\n"
15870 "Set color, cmap1 \n"
15874 " Sets the color for cmap1 (see the PLplot documentation). \n"
15876 " Redacted form: plcol1(col1)\n"
15878 " This function is used in examples 12 and 21. \n"
15888 " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15889 " and is mapped to color using the continuous map1 color palette\n"
15890 " which by default ranges from blue to the background color to red. \n"
15891 " The map1 palette can also be straightforwardly changed by the user\n"
15892 " with plscmap1 or plscmap1l. \n"
15896 "Configure the transformation between continuous and broken-down time for the current stream \n"
15900 " Configure the transformation between continuous and broken-down time\n"
15901 " for the current stream. This transformation is used by both plbtime\n"
15904 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15905 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15906 " Perl/PDL: Not available? \n"
15909 " This function is used in example 29. \n"
15915 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15919 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15920 " As a special case, if \n"
15921 " scale is 0., then all other arguments are ignored, and the result (the\n"
15922 " default used by PLplot) is the equivalent of a call to\n"
15923 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15924 " That is, for this special case broken-down time is calculated with\n"
15925 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15926 " and the continuous time is defined as the number of seconds since\n"
15927 " the Unix epoch of 1970-01-01T00:00:00Z. \n"
15929 " offset1 (PLFLT, input) : If \n"
15930 " ifbtime_offset is true, the parameters \n"
15932 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15933 " (with units in days) specify the epoch of the continuous time\n"
15934 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15935 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15936 " are used to specify the origin to allow users (by specifying \n"
15937 " offset1 as an integer that can be exactly represented by a\n"
15938 " floating-point variable and specifying \n"
15939 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15940 " the numerical errors of the continuous time representation. \n"
15942 " offset2 (PLFLT, input) : See documentation of \n"
15945 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15946 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15947 " calendar is used for broken-down time rather than the proleptic\n"
15948 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15949 " have been historically used to define UTC are inserted into the\n"
15950 " broken-down time. Other possibilities for additional control bits\n"
15951 " for ccontrol exist such as making the historical time corrections\n"
15952 " in the broken-down time corresponding to ET (ephemeris time) or\n"
15953 " making the (slightly non-constant) corrections from international\n"
15954 " atomic time (TAI) to what astronomers define as terrestrial time\n"
15955 " (TT). But those additional possibilities have not been\n"
15956 " implemented yet in the qsastime library (one of the PLplot utility\n"
15959 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15960 " epoch of the continuous time scale is specified by the user. If \n"
15961 " ifbtime_offset is false, then \n"
15963 " offset2 are used to specify the epoch, and the following broken-down\n"
15964 " time parameters are completely ignored. If \n"
15965 " ifbtime_offset is true, then \n"
15967 " offset2 are completely ignored, and the following broken-down time\n"
15968 " parameters are used to specify the epoch. \n"
15970 " year (PLINT, input) : Year of epoch. \n"
15972 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15973 " 11 (December). \n"
15975 " day (PLINT, input) : Day of epoch in range from 1 to 31. \n"
15977 " hour (PLINT, input) : Hour of epoch in range from 0 to 23 \n"
15979 " min (PLINT, input) : Minute of epoch in range from 0 to 59. \n"
15981 " sec (PLFLT, input) : Second of epoch in floating range from 0. to\n"
15985 { (
char *)
"plcont",
_wrap_plcont, METH_VARARGS, (
char *)
"\n"
15990 " Draws a contour plot of the data in f[\n"
15992 " ny], using the nlevel contour levels specified by clevel. Only the\n"
15993 " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15994 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15995 " additional data required by the transformation routine is used to map\n"
15996 " indices within the array to the world coordinates. See the following\n"
15997 " discussion of the arguments and the PLplot documentation for more\n"
16000 " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
16001 " plcont(f, kx, lx, ky, ly, clevel, tr?) or plcont(f, kx, lx, ky, ly,\n"
16002 " clevel, xgrid, ygrid)\n"
16003 " Java: pls.cont(f, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
16004 " Perl/PDL: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16005 " Python: plcont2(f, kx, lx, ky, ly, clevel)\n"
16008 " This function is used in examples 9,14,16,22. \n"
16014 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16018 " f (const PLFLT * const *, input) : Pointer to a vectored\n"
16019 " two-dimensional array containing data to be contoured. \n"
16021 " nx, ny (PLINT, input) : Physical dimensions of array f. \n"
16023 " kx, lx (PLINT, input) : Range of x indices to consider. \n"
16025 " ky, ly (PLINT, input) : Range of y indices to consider. \n"
16027 " clevel (const PLFLT *, input) : Pointer to array specifying levels\n"
16028 " at which to draw contours. \n"
16030 " nlevel (PLINT, input) : Number of contour levels to draw. \n"
16032 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
16033 " Pointer to function that defines transformation between indices\n"
16034 " in array f and the world coordinates (C only). Transformation\n"
16035 " functions are provided in the PLplot library: pltr0 for identity\n"
16036 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
16037 " defined by one- and two-dimensional arrays. In addition,\n"
16038 " user-supplied routines for the transformation can be used as well.\n"
16039 " Examples of all of these approaches are given in the PLplot\n"
16040 " documentation. The transformation function should have the form\n"
16041 " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
16042 " and similar PLplot functions which have a pltr argument, plcont\n"
16043 " requires that a transformation function be provided in the C\n"
16044 " interface. Leaving pltr NULL will result in an error. \n"
16046 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16047 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
16048 " externally supplied. \n"
16051 { (
char *)
"plctime",
_wrap_plctime, METH_VARARGS, (
char *)
"\n"
16052 "Calculate continuous time from broken-down time for the current stream \n"
16056 " Calculate continuous time, ctime, from broken-down time for the\n"
16057 " current stream. The broken-down\n"
16058 " time is specified by the following parameters: year, month, day, hour,\n"
16059 " min, and sec. This function is the inverse of plbtime. \n"
16061 " The PLplot definition of broken-down time is a calendar time that\n"
16062 " completely ignores all time zone offsets, i.e., it is the user's\n"
16063 " responsibility to apply those offsets (if so desired) before using the\n"
16064 " PLplot time API. By default broken-down time is defined using the\n"
16065 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16066 " continuous time is defined as the number of seconds since the Unix\n"
16067 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16068 " broken-down and continuous time are possible, see plconfigtime which\n"
16069 " specifies that transformation for the current stream. \n"
16071 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16073 " Perl/PDL: Not available? \n"
16076 " This function is used in example 29. \n"
16082 "plctime(year, month, day, hour, min, sec, ctime)\n"
16086 " year (PLINT, input) : Input year. \n"
16088 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16091 " day (PLINT, input) : Input day in range from 1 to 31. \n"
16093 " hour (PLINT, input) : Input hour in range from 0 to 23 \n"
16095 " min (PLINT, input) : Input minute in range from 0 to 59. \n"
16097 " sec (PLFLT, input) : Input second in floating range from 0. to 60. \n"
16099 " ctime (PLFLT *, output) : Continous time calculated from the\n"
16100 " broken-down time specified by the previous parameters. \n"
16103 { (
char *)
"plcpstrm",
_wrap_plcpstrm, METH_VARARGS, (
char *)
"\n"
16104 "Copy state parameters from the reference stream to the current stream \n"
16108 " Copies state parameters from the reference stream to the current\n"
16109 " stream. Tell driver interface to map device coordinates unless flags\n"
16112 " This function is used for making save files of selected plots (e.g.\n"
16113 " from the TK driver). After initializing, you can get a copy of the\n"
16114 " current plot to the specified device by switching to this stream and\n"
16115 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16116 " appropriate. The plot buffer must have previously been enabled (done\n"
16117 " automatically by some display drivers, such as X). \n"
16119 " Redacted form: plcpstrm(iplsr, flags)\n"
16121 " This function is used in example 1,20. \n"
16127 "plcpstrm(iplsr, flags)\n"
16131 " iplsr (PLINT, input) : Number of reference stream. \n"
16133 " flags (PLBOOL, input) : If flags is set to true the device\n"
16134 " coordinates are not copied from the reference to current stream. \n"
16137 { (
char *)
"plend",
_wrap_plend, METH_VARARGS, (
char *)
"\n"
16138 "End plotting session \n"
16142 " Ends a plotting session, tidies up all the output files, switches\n"
16143 " interactive devices back into text mode and frees up any memory that\n"
16144 " was allocated. Must be called before end of program. \n"
16146 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16147 " wait state after a call to plend or other functions which trigger the\n"
16148 " end of a plot page. To avoid this, use the plspause function. \n"
16150 " Redacted form: plend()\n"
16152 " This function is used in all of the examples. \n"
16161 { (
char *)
"plend1",
_wrap_plend1, METH_VARARGS, (
char *)
"\n"
16162 "End plotting session for current stream \n"
16166 " Ends a plotting session for the current output stream only. See\n"
16167 " plsstrm for more info. \n"
16169 " Redacted form: plend1()\n"
16171 " This function is used in examples 1,20. \n"
16180 { (
char *)
"plenv",
_wrap_plenv, METH_VARARGS, (
char *)
"\n"
16181 "Set up standard window and draw box \n"
16185 " Sets up plotter environment for simple graphs by calling pladv and\n"
16186 " setting up viewport and window to sensible default values. plenv\n"
16187 " leaves enough room around most graphs for axis labels and a title.\n"
16188 " When these defaults are not suitable, use the individual routines\n"
16189 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
16190 " defining the window, and plbox for drawing the box. \n"
16192 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16194 " This function is used in example 1,3,9,13,14,19-22,29. \n"
16200 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16204 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16205 " world coordinates). \n"
16207 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16208 " world coordinates). \n"
16210 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16211 " coordinates). \n"
16213 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16214 " coordinates). \n"
16216 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16217 " scales will not be set, the user must set up the scale before\n"
16218 " calling plenv using plsvpa, plvasp or other. \n"
16219 " 0: the x and y axes are scaled independently to use as much of\n"
16220 " the screen as possible. \n"
16221 " 1: the scales of the x and y axes are made equal. \n"
16222 " 2: the axis of the x and y axes are made equal, and the plot\n"
16223 " box will be square. \n"
16226 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16227 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
16228 " -1: draw box only. \n"
16229 " 0: draw box, ticks, and numeric tick labels. \n"
16230 " 1: also draw coordinate axes at x=0 and y=0. \n"
16231 " 2: also draw a grid at major tick positions in both\n"
16233 " 3: also draw a grid at minor tick positions in both\n"
16235 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16236 " have to be converted to logarithms separately.) \n"
16237 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16238 " have to be converted to logarithms separately.) \n"
16239 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16240 " have to be converted to logarithms separately.) \n"
16241 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16242 " have to be converted to logarithms separately.) \n"
16243 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16244 " have to be converted to logarithms separately.) \n"
16245 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16246 " have to be converted to logarithms separately.) \n"
16247 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16248 " have to be converted to logarithms separately.) \n"
16249 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16250 " have to be converted to logarithms separately.) \n"
16251 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16252 " and y data have to be converted to logarithms separately.) \n"
16253 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16254 " and y data have to be converted to logarithms separately.) \n"
16255 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16256 " and y data have to be converted to logarithms separately.) \n"
16257 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16258 " and y data have to be converted to logarithms separately.) \n"
16259 " 40: same as 0 except date / time x labels. \n"
16260 " 41: same as 1 except date / time x labels. \n"
16261 " 42: same as 2 except date / time x labels. \n"
16262 " 43: same as 3 except date / time x labels. \n"
16263 " 50: same as 0 except date / time y labels. \n"
16264 " 51: same as 1 except date / time y labels. \n"
16265 " 52: same as 2 except date / time y labels. \n"
16266 " 53: same as 3 except date / time y labels. \n"
16267 " 60: same as 0 except date / time x and y labels. \n"
16268 " 61: same as 1 except date / time x and y labels. \n"
16269 " 62: same as 2 except date / time x and y labels. \n"
16270 " 63: same as 3 except date / time x and y labels. \n"
16271 " 70: same as 0 except custom x and y labels. \n"
16272 " 71: same as 1 except custom x and y labels. \n"
16273 " 72: same as 2 except custom x and y labels. \n"
16274 " 73: same as 3 except custom x and y labels. \n"
16277 { (
char *)
"plenv0",
_wrap_plenv0, METH_VARARGS, (
char *)
"\n"
16278 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it \n"
16282 " Sets up plotter environment for simple graphs by calling pladv and\n"
16283 " setting up viewport and window to sensible default values. plenv0\n"
16284 " leaves enough room around most graphs for axis labels and a title.\n"
16285 " When these defaults are not suitable, use the individual routines\n"
16286 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
16287 " defining the window, and plbox for drawing the box. \n"
16289 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16291 " This function is used in example 21. \n"
16297 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16301 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16302 " world coordinates). \n"
16304 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16305 " world coordinates). \n"
16307 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16308 " coordinates). \n"
16310 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16311 " coordinates). \n"
16313 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16314 " scales will not be set, the user must set up the scale before\n"
16315 " calling plenv0 using plsvpa, plvasp or other. \n"
16316 " 0: the x and y axes are scaled independently to use as much of\n"
16317 " the screen as possible. \n"
16318 " 1: the scales of the x and y axes are made equal. \n"
16319 " 2: the axis of the x and y axes are made equal, and the plot\n"
16320 " box will be square. \n"
16323 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16324 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
16325 " -1: draw box only. \n"
16326 " 0: draw box, ticks, and numeric tick labels. \n"
16327 " 1: also draw coordinate axes at x=0 and y=0. \n"
16328 " 2: also draw a grid at major tick positions in both\n"
16330 " 3: also draw a grid at minor tick positions in both\n"
16332 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16333 " have to be converted to logarithms separately.) \n"
16334 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16335 " have to be converted to logarithms separately.) \n"
16336 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16337 " have to be converted to logarithms separately.) \n"
16338 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16339 " have to be converted to logarithms separately.) \n"
16340 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16341 " have to be converted to logarithms separately.) \n"
16342 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16343 " have to be converted to logarithms separately.) \n"
16344 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16345 " have to be converted to logarithms separately.) \n"
16346 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16347 " have to be converted to logarithms separately.) \n"
16348 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16349 " and y data have to be converted to logarithms separately.) \n"
16350 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16351 " and y data have to be converted to logarithms separately.) \n"
16352 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16353 " and y data have to be converted to logarithms separately.) \n"
16354 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16355 " and y data have to be converted to logarithms separately.) \n"
16356 " 40: same as 0 except date / time x labels. \n"
16357 " 41: same as 1 except date / time x labels. \n"
16358 " 42: same as 2 except date / time x labels. \n"
16359 " 43: same as 3 except date / time x labels. \n"
16360 " 50: same as 0 except date / time y labels. \n"
16361 " 51: same as 1 except date / time y labels. \n"
16362 " 52: same as 2 except date / time y labels. \n"
16363 " 53: same as 3 except date / time y labels. \n"
16364 " 60: same as 0 except date / time x and y labels. \n"
16365 " 61: same as 1 except date / time x and y labels. \n"
16366 " 62: same as 2 except date / time x and y labels. \n"
16367 " 63: same as 3 except date / time x and y labels. \n"
16368 " 70: same as 0 except custom x and y labels. \n"
16369 " 71: same as 1 except custom x and y labels. \n"
16370 " 72: same as 2 except custom x and y labels. \n"
16371 " 73: same as 3 except custom x and y labels. \n"
16374 { (
char *)
"pleop",
_wrap_pleop, METH_VARARGS, (
char *)
"\n"
16375 "Eject current page \n"
16379 " Clears the graphics screen of an interactive device, or ejects a page\n"
16380 " on a plotter. See plbop for more information. \n"
16382 " Redacted form: pleop()\n"
16384 " This function is used in example 2,14. \n"
16393 { (
char *)
"plerrx",
_wrap_plerrx, METH_VARARGS, (
char *)
"\n"
16394 "Draw x error bar \n"
16398 " Draws a set of n horizontal error bars, the i'th error bar extending\n"
16399 " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
16400 " error bar are of length equal to the minor tick length (settable using\n"
16403 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16404 " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
16407 " This function is used in example 29. \n"
16413 "plerrx(n, xmin, xmax, y)\n"
16417 " n (PLINT, input) : Number of error bars to draw. \n"
16419 " xmin (const PLFLT *, input) : Pointer to array with x coordinates\n"
16420 " of left-hand endpoint of error bars. \n"
16422 " xmax (const PLFLT *, input) : Pointer to array with x coordinates\n"
16423 " of right-hand endpoint of error bars. \n"
16425 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16429 { (
char *)
"plerry",
_wrap_plerry, METH_VARARGS, (
char *)
"\n"
16430 "Draw y error bar \n"
16434 " Draws a set of n vertical error bars, the i'th error bar extending\n"
16435 " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
16436 " error bar are of length equal to the minor tick length (settable using\n"
16439 " Redacted form: General: plerry(x, ymin, ymax)\n"
16440 " Perl/PDL: plerry(n, x, ymin, ymax)\n"
16443 " This function is used in example 29. \n"
16449 "plerry(n, x, ymin, ymax)\n"
16453 " n (PLINT, input) : Number of error bars to draw. \n"
16455 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16458 " ymin (const PLFLT *, input) : Pointer to array with y coordinates\n"
16459 " of lower endpoint of error bars. \n"
16461 " ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n"
16462 " upper endpoint of error bar. \n"
16465 { (
char *)
"plfamadv",
_wrap_plfamadv, METH_VARARGS, (
char *)
"\n"
16466 "Advance to the next family file on the next new page \n"
16470 " Advance to the next family file on the next new page. \n"
16472 " Redacted form: plfamadv()\n"
16474 " This function is not used in any examples. \n"
16483 { (
char *)
"plfill",
_wrap_plfill, METH_VARARGS, (
char *)
"\n"
16484 "Draw filled polygon \n"
16488 " Fills the polygon defined by the n points (\n"
16490 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16491 " style is a solid fill. The routine will automatically close the\n"
16492 " polygon between the last and first vertices. If multiple closed\n"
16493 " polygons are passed in x and y then plfill will fill in between them. \n"
16495 " Redacted form: plfill(x,y)\n"
16497 " This function is used in examples 12,13,15,16,21,24,25. \n"
16503 "plfill(n, x, y)\n"
16507 " n (PLINT, input) : Number of vertices in polygon. \n"
16509 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16512 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16516 { (
char *)
"plfill3",
_wrap_plfill3, METH_VARARGS, (
char *)
"\n"
16517 "Draw filled polygon in 3D \n"
16521 " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
16522 " using the pattern defined by plpsty or plpat. The routine will\n"
16523 " automatically close the polygon between the last and first vertices. \n"
16524 " If multiple closed polygons are passed in x, y, and z then plfill3\n"
16525 " will fill in between them. \n"
16527 " Redacted form: General: plfill3(x, y, z)\n"
16528 " Perl/PDL: plfill3(n, x, y, z)\n"
16531 " This function is used in example 15. \n"
16537 "plfill3(n, x, y, z)\n"
16541 " n (PLINT, input) : Number of vertices in polygon. \n"
16543 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16546 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16549 " z (const PLFLT *, input) : Pointer to array with z coordinates of\n"
16554 "Draw linear gradient inside polygon \n"
16558 " Draw a linear gradient using colour map 1 inside the polygon defined\n"
16559 " by the n points (\n"
16561 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16562 " polygon coordinates and the gradient angle are all expressed in world\n"
16563 " coordinates. The angle from the x axis for both the rotated\n"
16564 " coordinate system and the gradient vector is specified by angle. The\n"
16565 " magnitude of the gradient vector is the difference between the maximum\n"
16566 " and minimum values of x for the vertices in the rotated coordinate\n"
16567 " system. The origin of the gradient vector can be interpreted as being\n"
16568 " anywhere on the line corresponding to the minimum x value for the\n"
16569 " vertices in the rotated coordinate system. The distance along the\n"
16570 " gradient vector is linearly transformed to the independent variable of\n"
16571 " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
16572 " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16573 " colour corresponding to the independent variable of colour map 1. For\n"
16574 " more information about colour map 1 (see the PLplot documentation). \n"
16576 " Redacted form: plgradient(x,y,angle)\n"
16578 " This function is used in examples 25,30. \n"
16584 "plgradient(n, x, y, angle)\n"
16588 " n (PLINT, input) : Number of vertices in polygon. \n"
16590 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16593 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16596 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16600 { (
char *)
"plflush",
_wrap_plflush, METH_VARARGS, (
char *)
"\n"
16601 "Flushes the output stream \n"
16605 " Flushes the output stream. Use sparingly, if at all. \n"
16607 " Redacted form: plflush()\n"
16609 " This function is used in examples 1,14. \n"
16618 { (
char *)
"plfont",
_wrap_plfont, METH_VARARGS, (
char *)
"\n"
16619 "Set character font \n"
16623 " Sets the default character font for subsequent character drawing. Also\n"
16624 " affects symbols produced by plpoin. This routine has no effect unless\n"
16625 " the extended character set is loaded (see plfontld). \n"
16627 " Redacted form: plfont(ifont)\n"
16629 " This function is used in examples 1,2,4,7,13,24,26. \n"
16639 " ifont (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
16641 " 2: Roman font \n"
16642 " 3: Italic font \n"
16643 " 4: Script font \n"
16646 { (
char *)
"plfontld",
_wrap_plfontld, METH_VARARGS, (
char *)
"\n"
16647 "Load character font \n"
16651 " Sets the character set to use for subsequent character drawing. May\n"
16652 " be called before initializing PLplot. \n"
16654 " Redacted form: plfontld(fnt)\n"
16656 " This function is used in examples 1,7. \n"
16666 " fnt (PLINT, input) : Specifies the character set to load: 0:\n"
16667 " Standard character set \n"
16668 " 1: Extended character set \n"
16671 { (
char *)
"plgchr",
_wrap_plgchr, METH_VARARGS, (
char *)
"\n"
16672 "Get character default height and current (scaled) height \n"
16676 " Get character default height and current (scaled) height. \n"
16678 " Redacted form: plgchr(p_def, p_ht)\n"
16680 " This function is used in example 23. \n"
16686 "plgchr(p_def, p_ht)\n"
16690 " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
16692 " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
16696 { (
char *)
"plgcol0",
_wrap_plgcol0, METH_VARARGS, (
char *)
"\n"
16697 "Returns 8-bit RGB values for given color index from cmap0 \n"
16701 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16702 " PLplot documentation). Values are negative if an invalid color id is\n"
16705 " Redacted form: plgcol0(icol0, r, g, b)\n"
16707 " This function is used in example 2. \n"
16713 "plgcol0(icol0, r, g, b)\n"
16717 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
16719 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
16721 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
16723 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16726 { (
char *)
"plgcol0a",
_wrap_plgcol0a, METH_VARARGS, (
char *)
"\n"
16727 "Returns 8-bit RGB values and double alpha transparency value for given color index from cmap0 \n"
16731 " Returns 8-bit RGB values (0-255) and double alpha transparency value\n"
16732 " (0.0 - 1.0) for given color from cmap0 (see the PLplot\n"
16733 " documentation). Values are negative if an invalid color id is given. \n"
16735 " This function is used in example 30. \n"
16741 "plgcol0a(icol0, r, g, b, alpha)\n"
16745 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
16747 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
16749 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
16751 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16753 " alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n"
16757 { (
char *)
"plgcolbg",
_wrap_plgcolbg, METH_VARARGS, (
char *)
"\n"
16758 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
16762 " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
16764 " Redacted form: plgcolbg(r, g, b)\n"
16766 " This function is used in example 31. \n"
16772 "lgcolbg(r, g, b)\n"
16776 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16777 " representing the degree of red in the color. \n"
16779 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16780 " representing the degree of green in the color. \n"
16782 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16783 " representing the degree of blue in the color. \n"
16787 "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n"
16791 " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16792 " alpha transparency value. \n"
16794 " This function is used in example 31. \n"
16800 "lgcolbga(r, g, b, alpha)\n"
16804 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16805 " representing the degree of red in the color. \n"
16807 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16808 " representing the degree of green in the color. \n"
16810 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16811 " representing the degree of blue in the color. \n"
16813 " alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n"
16818 "Get the current device-compression setting \n"
16822 " Get the current device-compression setting. This parameter is only\n"
16823 " used for drivers that provide compression. \n"
16825 " Redacted form: plgcompression(compression)\n"
16827 " This function is used in example 31. \n"
16833 "plgcompression(compression)\n"
16837 " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16838 " with the current device-compression setting. \n"
16841 { (
char *)
"plgdev",
_wrap_plgdev, METH_VARARGS, (
char *)
"\n"
16842 "Get the current device (keyword) name \n"
16846 " Get the current device (keyword) name. Note: you must have allocated\n"
16847 " space for this (80 characters is safe). \n"
16849 " Redacted form: plgdev(p_dev)\n"
16851 " This function is used in example 14. \n"
16861 " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16864 { (
char *)
"plgdidev",
_wrap_plgdidev, METH_VARARGS, (
char *)
"\n"
16865 "Get parameters that define current device-space window \n"
16869 " Get relative margin width, aspect ratio, and relative justification\n"
16870 " that define current device-space window. If plsdidev has not been\n"
16871 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16872 " p_jy will all be 0. \n"
16874 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16876 " This function is used in example 31. \n"
16882 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16886 " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16888 " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16890 " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16892 " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16895 { (
char *)
"plgdiori",
_wrap_plgdiori, METH_VARARGS, (
char *)
"\n"
16896 "Get plot orientation \n"
16900 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16901 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16902 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16903 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16904 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16905 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16906 " not been called the default value pointed to by p_rot will be 0. \n"
16908 " Redacted form: plgdiori(p_rot)\n"
16910 " This function is not used in any examples. \n"
16916 "plgdiori(p_rot)\n"
16920 " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16923 { (
char *)
"plgdiplt",
_wrap_plgdiplt, METH_VARARGS, (
char *)
"\n"
16924 "Get parameters that define current plot-space window \n"
16928 " Get relative minima and maxima that define current plot-space window.\n"
16929 " If plsdiplt has not been called the default values pointed to by\n"
16930 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16932 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16934 " This function is used in example 31. \n"
16940 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16944 " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16946 " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16948 " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16950 " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16953 { (
char *)
"plgfam",
_wrap_plgfam, METH_VARARGS, (
char *)
"\n"
16954 "Get family file parameters \n"
16958 " Gets information about current family file, if familying is enabled. \n"
16959 " See the PLplot documentation for more information. \n"
16961 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16963 " This function is used in examples 14,31. \n"
16969 "plgfam(p_fam, p_num, p_bmax)\n"
16973 " p_fam (PLINT *, output) : Pointer to variable with the Boolean\n"
16974 " family flag value. If nonzero, familying is enabled. \n"
16976 " p_num (PLINT *, output) : Pointer to variable with the current\n"
16977 " family file number. \n"
16979 " p_bmax (PLINT *, output) : Pointer to variable with the maximum\n"
16980 " file size (in bytes) for a family file. \n"
16983 { (
char *)
"plgfci",
_wrap_plgfci, METH_VARARGS, (
char *)
"\n"
16984 "Get FCI (font characterization integer) \n"
16988 " Gets information about the current font using the FCI approach. See\n"
16989 " the PLplot documentation for more information. \n"
16991 " Redacted form: plgfci(p_fci)\n"
16993 " This function is used in example 23. \n"
17003 " p_fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
17004 " integer) variable which is updated with current FCI value. \n"
17007 { (
char *)
"plgfnam",
_wrap_plgfnam, METH_VARARGS, (
char *)
"\n"
17008 "Get output file name \n"
17012 " Gets the current output file name, if applicable. \n"
17014 " Redacted form: plgfnam(fnam)\n"
17016 " This function is used in example 31. \n"
17026 " fnam (char *, output) : Pointer to file name string (a preallocated\n"
17027 " string of 80 characters or more). \n"
17030 { (
char *)
"plgfont",
_wrap_plgfont, METH_VARARGS, (
char *)
"\n"
17031 "Get family, style and weight of the current font \n"
17035 " Gets information about current font. See the PLplot documentation for\n"
17036 " more information on font selection. \n"
17038 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17040 " This function is used in example 23. \n"
17046 "plgfont(p_family, p_style, p_weight)\n"
17050 " p_family (PLINT *, output) : Pointer to variable with the current\n"
17051 " font family. The available values are given by the PL_FCI_*\n"
17052 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17053 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17054 " p_family is NULL then the font family is not returned. \n"
17056 " p_style (PLINT *, output) : Pointer to variable with the current\n"
17057 " font style. The available values are given by the PL_FCI_*\n"
17058 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17059 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
17060 " font style is not returned. \n"
17062 " p_weight (PLINT *, output) : Pointer to variable with the current\n"
17063 " font weight. The available values are given by the PL_FCI_*\n"
17064 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17065 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17069 { (
char *)
"plglevel",
_wrap_plglevel, METH_VARARGS, (
char *)
"\n"
17070 "Get the (current) run level \n"
17074 " Get the (current) run level. Valid settings are: 0, uninitialized \n"
17075 " 1, initialized \n"
17076 " 2, viewport defined \n"
17077 " 3, world coordinates defined \n"
17080 " Redacted form: plglevel(p_level)\n"
17082 " This function is used in example 31. \n"
17088 "plglevel(p_level)\n"
17092 " p_level (PLINT *, output) : Pointer to the run level. \n"
17095 { (
char *)
"plgpage",
_wrap_plgpage, METH_VARARGS, (
char *)
"\n"
17096 "Get page parameters \n"
17100 " Gets the current page configuration. The length and offset values are\n"
17101 " expressed in units that are specific to the current driver. For\n"
17102 " instance: screen drivers will usually interpret them as number of\n"
17103 " pixels, whereas printer drivers will usually use mm. \n"
17105 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17107 " This function is used in examples 14 and 31. \n"
17113 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17117 " p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
17119 " p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n"
17122 " p_xleng (PLINT *, output) : Pointer to x page length value. \n"
17124 " p_yleng (PLINT *, output) : Pointer to y page length value. \n"
17126 " p_xoff (PLINT *, output) : Pointer to x page offset. \n"
17128 " p_yoff (PLINT *, output) : Pointer to y page offset. \n"
17131 { (
char *)
"plgra",
_wrap_plgra, METH_VARARGS, (
char *)
"\n"
17132 "Switch to graphics screen \n"
17136 " Sets an interactive device to graphics mode, used in conjunction with\n"
17137 " pltext to allow graphics and text to be interspersed. On a device\n"
17138 " which supports separate text and graphics windows, this command causes\n"
17139 " control to be switched to the graphics window. If already in graphics\n"
17140 " mode, this command is ignored. It is also ignored on devices which\n"
17141 " only support a single window or use a different method for shifting\n"
17142 " focus. See also pltext. \n"
17144 " Redacted form: plgra()\n"
17146 " This function is used in example 1. \n"
17156 "Grid data from irregularly sampled data \n"
17160 " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
17161 " plots require data placed in a uniform grid. This function takes\n"
17162 " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
17163 " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
17164 " and yg[nptsy], and returns the gridded data into output array\n"
17165 " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
17166 " with the argument type which can have one parameter specified in\n"
17167 " argument data. \n"
17169 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17170 " Perl/PDL: Not available? \n"
17171 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17174 " This function is used in example 21. \n"
17180 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17184 " x (const PLFLT *, input) : The input x array. \n"
17186 " y (const PLFLT *, input) : The input y array. \n"
17188 " z (const PLFLT *, input) : The input z array. Each triple x[i],\n"
17189 " y[i], z[i] represents one data sample coordinate. \n"
17191 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17194 " xg (const PLFLT *, input) : The input array that specifies the grid\n"
17195 " spacing in the x direction. Usually xg has nptsx equally spaced\n"
17196 " values from the minimum to the maximum values of the x input\n"
17199 " nptsx (PLINT, input) : The number of points in the xg array. \n"
17201 " yg (const PLFLT *, input) : The input array that specifies the grid\n"
17202 " spacing in the y direction. Similar to the xg parameter. \n"
17204 " nptsy (PLINT, input) : The number of points in the yg array. \n"
17206 " zg (PLFLT **, output) : The output array, where data lies in the\n"
17207 " regular grid specified by xg and yg. the zg array must exist or be\n"
17208 " allocated by the user prior to the call, and must have dimension\n"
17209 " zg[nptsx][nptsy]. \n"
17211 " type (PLINT, input) : The type of gridding algorithm to use, which\n"
17212 " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
17213 " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
17214 " GRID_NNI: Natural Neighbors Interpolation \n"
17215 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
17216 " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
17217 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17219 " For details of the algorithms read the source file plgridd.c. \n"
17221 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17222 " which can be specified through this argument. Currently, for\n"
17223 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17224 " use, the lower the value, the noisier (more local) the\n"
17225 " approximation is. \n"
17226 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17227 " range [1. .. 2.]. High values enable the usage of very thin\n"
17228 " triangles for interpolation, possibly resulting in error in\n"
17229 " the approximation. \n"
17230 " GRID_NNI, only weights greater than data will be accepted. If\n"
17231 " 0, all weights will be accepted. \n"
17234 { (
char *)
"plgspa",
_wrap_plgspa, METH_VARARGS, (
char *)
"\n"
17235 "Get current subpage parameters \n"
17239 " Gets the size of the current subpage in millimeters measured from the\n"
17240 " bottom left hand corner of the output device page or screen. Can be\n"
17241 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17242 " absolute coordinates (millimeters). \n"
17244 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17246 " This function is used in example 23. \n"
17252 "plgspa(xmin, xmax, ymin, ymax)\n"
17256 " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
17257 " hand edge of subpage in millimeters. \n"
17259 " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
17260 " hand edge of subpage in millimeters. \n"
17262 " ymin (PLFLT *, output) : Pointer to variable with position of\n"
17263 " bottom edge of subpage in millimeters. \n"
17265 " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
17266 " edge of subpage in millimeters. \n"
17269 { (
char *)
"plgstrm",
_wrap_plgstrm, METH_VARARGS, (
char *)
"\n"
17270 "Get current stream number \n"
17274 " Gets the number of the current output stream. See also plsstrm. \n"
17276 " Redacted form: plgstrm(p_strm)\n"
17278 " This function is used in example 1,20. \n"
17284 "plgstrm(p_strm)\n"
17288 " p_strm (PLINT *, output) : Pointer to current stream value. \n"
17291 { (
char *)
"plgver",
_wrap_plgver, METH_VARARGS, (
char *)
"\n"
17292 "Get the current library version number \n"
17296 " Get the current library version number. Note: you must have allocated\n"
17297 " space for this (80 characters is safe). \n"
17299 " Redacted form: plgver(p_ver)\n"
17301 " This function is used in example 1. \n"
17311 " p_ver (char *, output) : Pointer to the current library version\n"
17315 { (
char *)
"plgvpd",
_wrap_plgvpd, METH_VARARGS, (
char *)
"\n"
17316 "Get viewport limits in normalized device coordinates \n"
17320 " Get viewport limits in normalized device coordinates. \n"
17322 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17323 " Perl/PDL: Not available? \n"
17326 " This function is used in example 31. \n"
17332 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17336 " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
17337 " device coordinate in x. \n"
17339 " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
17340 " device coordinate in x. \n"
17342 " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
17343 " device coordinate in y. \n"
17345 " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
17346 " device coordinate in y. \n"
17349 { (
char *)
"plgvpw",
_wrap_plgvpw, METH_VARARGS, (
char *)
"\n"
17350 "Get viewport limits in world coordinates \n"
17354 " Get viewport limits in world coordinates. \n"
17356 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17357 " Perl/PDL: Not available? \n"
17360 " This function is used in example 31. \n"
17366 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17370 " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
17371 " coordinate in x. \n"
17373 " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
17374 " coordinate in x. \n"
17376 " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
17377 " coordinate in y. \n"
17379 " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
17380 " coordinate in y. \n"
17383 { (
char *)
"plgxax",
_wrap_plgxax, METH_VARARGS, (
char *)
"\n"
17384 "Get x axis parameters \n"
17388 " Returns current values of the p_digmax and p_digits flags for the x\n"
17389 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17390 " should only be called after the call to plbox (or plbox3) is complete.\n"
17391 " See the PLplot documentation for more information. \n"
17393 " Redacted form: plgxax(p_digmax, p_digits)\n"
17395 " This function is used in example 31. \n"
17401 "plgxax(p_digmax, p_digits)\n"
17405 " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n"
17406 " number of digits for the x axis. If nonzero, the printed label\n"
17407 " has been switched to a floating point representation when the\n"
17408 " number of digits exceeds p_digmax. \n"
17410 " p_digits (PLINT *, output) : Pointer to variable with the actual\n"
17411 " number of digits for the numeric labels (x axis) from the last\n"
17415 { (
char *)
"plgyax",
_wrap_plgyax, METH_VARARGS, (
char *)
"\n"
17416 "Get y axis parameters \n"
17420 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17421 " the description of plgxax for more detail. \n"
17423 " Redacted form: plgyax(p_digmax, p_digits)\n"
17425 " This function is used in example 31. \n"
17431 "plgyax(p_digmax, p_digits)\n"
17435 " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n"
17436 " number of digits for the y axis. If nonzero, the printed label\n"
17437 " has been switched to a floating point representation when the\n"
17438 " number of digits exceeds p_digmax. \n"
17440 " p_digits (PLINT *, output) : Pointer to variable with the actual\n"
17441 " number of digits for the numeric labels (y axis) from the last\n"
17445 { (
char *)
"plgzax",
_wrap_plgzax, METH_VARARGS, (
char *)
"\n"
17446 "Get z axis parameters \n"
17450 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17451 " the description of plgxax for more detail. \n"
17453 " Redacted form: plgzax(p_digmax, p_digits)\n"
17455 " This function is used in example 31. \n"
17461 "plgzax(p_digmax, p_digits)\n"
17465 " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n"
17466 " number of digits for the z axis. If nonzero, the printed label\n"
17467 " has been switched to a floating point representation when the\n"
17468 " number of digits exceeds p_digmax. \n"
17470 " p_digits (PLINT *, output) : Pointer to variable with the actual\n"
17471 " number of digits for the numeric labels (z axis) from the last\n"
17475 { (
char *)
"plhist",
_wrap_plhist, METH_VARARGS, (
char *)
"\n"
17476 "Plot a histogram from unbinned data \n"
17480 " Plots a histogram from n data points stored in the array data. This\n"
17481 " routine bins the data into nbin bins equally spaced between datmin and\n"
17482 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17483 " opt allows, among other things, the histogram either to be plotted in\n"
17484 " an existing window or causes plhist to call plenv with suitable limits\n"
17485 " before plotting the histogram. \n"
17487 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17489 " This function is used in example 5. \n"
17495 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17499 " n (PLINT, input) : Number of data points. \n"
17501 " data (const PLFLT *, input) : Pointer to array with values of the n\n"
17504 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
17506 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
17508 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17509 " divide the interval xmin to xmax. \n"
17511 " opt (PLINT, input) : Is a combination of several flags:\n"
17512 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17513 " the histogram data, the outer bins are expanded to fill up the\n"
17514 " entire x-axis, data outside the given extremes are assigned to the\n"
17515 " outer bins and bins of zero height are simply drawn. \n"
17516 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17517 " to fit the histogram data, without this flag, plenv is called\n"
17518 " to set the world coordinates. \n"
17519 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17520 " extremes are not taken into account. This option should\n"
17521 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17522 " properly present the data. \n"
17523 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17524 " size as the ones inside. \n"
17525 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17526 " (there is a gap for such bins). \n"
17529 { (
char *)
"plhlsrgb",
_wrap_plhlsrgb, METH_VARARGS, (
char *)
"\n"
17530 "Convert HLS color to RGB \n"
17534 " Convert HLS color coordinates to RGB. \n"
17536 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17537 " Perl/PDL: Not available? Implemented as plhls? \n"
17540 " This function is used in example 2. \n"
17546 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17550 " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
17552 " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
17553 " of the colour cone (0.0-1.0) \n"
17555 " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
17556 " radius of the colour cone (0.0-1.0) \n"
17558 " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
17561 " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
17564 " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
17568 { (
char *)
"plinit",
_wrap_plinit, METH_VARARGS, (
char *)
"\n"
17569 "Initialize PLplot \n"
17573 " Initializing the plotting package. The program prompts for the device\n"
17574 " keyword or number of the desired output device. Hitting a RETURN in\n"
17575 " response to the prompt is the same as selecting the first device. \n"
17576 " plinit will issue no prompt if either the device was specified\n"
17577 " previously (via command line flag, the plsetopt function, or the\n"
17578 " plsdev function), or if only one device is enabled when PLplot is\n"
17579 " installed. If subpages have been specified, the output device is\n"
17580 " divided into nx by ny subpages, each of which may be used\n"
17581 " independently. If plinit is called again during a program, the\n"
17582 " previously opened file will be closed. The subroutine pladv is used\n"
17583 " to advance from one subpage to the next. \n"
17585 " Redacted form: plinit()\n"
17587 " This function is used in all of the examples. \n"
17596 { (
char *)
"pljoin",
_wrap_pljoin, METH_VARARGS, (
char *)
"\n"
17597 "Draw a line between two points \n"
17601 " Joins the point (\n"
17607 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17609 " This function is used in examples 3,14. \n"
17615 "pljoin(x1, y1, x2, y2)\n"
17619 " x1 (PLFLT, input) : x coordinate of first point. \n"
17621 " y1 (PLFLT, input) : y coordinate of first point. \n"
17623 " x2 (PLFLT, input) : x coordinate of second point. \n"
17625 " y2 (PLFLT, input) : y coordinate of second point. \n"
17628 { (
char *)
"pllab",
_wrap_pllab, METH_VARARGS, (
char *)
"\n"
17629 "Simple routine to write labels \n"
17633 " Routine for writing simple labels. Use plmtex for more complex labels. \n"
17635 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17637 " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
17643 "pllab(xlabel, ylabel, tlabel)\n"
17647 " xlabel (const char *, input) : Label for horizontal axis. \n"
17649 " ylabel (const char *, input) : Label for vertical axis. \n"
17651 " tlabel (const char *, input) : Title of graph. \n"
17654 { (
char *)
"pllegend",
_wrap_pllegend, METH_VARARGS, (
char *)
"\n"
17655 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
17659 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17660 " line, and/or line of symbols for each annotated legend entry. (See\n"
17661 " plcolorbar for similar functionality for creating continuous color\n"
17662 " bars.) The arguments of pllegend provide control over the location\n"
17663 " and size of the legend as well as the location and characteristics of\n"
17664 " the elements (most of which are optional) within that legend. The\n"
17665 " resulting legend is clipped at the boundaries of the current subpage. \n"
17666 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17667 " defined in the documentation of the position parameter.) \n"
17669 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17670 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17671 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17672 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17673 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17674 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17676 " This function is used in examples 4, 26, and 33. \n"
17682 "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"
17686 " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
17687 " contains (after the call) the legend width in adopted coordinates.\n"
17688 " This quantity is calculated from plot_width, text_offset, ncolumn\n"
17689 " (possibly modified inside the routine depending on nlegend and\n"
17690 " nrow), and the length (calculated internally) of the longest text\n"
17693 " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
17694 " contains (after the call) the legend height in adopted\n"
17695 " coordinates. This quantity is calculated from text_scale,\n"
17696 " text_spacing, and nrow (possibly modified inside the routine\n"
17697 " depending on nlegend and nrow). \n"
17699 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17700 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17701 " on the left of the legend and the plotted area on the right.\n"
17702 " Otherwise, put the text area on the right of the legend and the\n"
17703 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17704 " plot a (semi-transparent) background for the legend. If the\n"
17705 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17706 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17707 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17708 " plot the resulting array of legend entries in row-major order.\n"
17709 " Otherwise, plot the legend entries in column-major order. \n"
17711 " position (PLINT, input) : position contains bits which control the\n"
17712 " overall position of the legend and the definition of the adopted\n"
17713 " coordinates used for positions just like what is done for the\n"
17714 " position argument for plcolorbar. However, note that the defaults\n"
17715 " for the position bits (see below) are different than the\n"
17716 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17717 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17718 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17719 " the 16 possible standard positions (the 4 corners and centers of\n"
17720 " the 4 sides for both the inside and outside cases) of the legend\n"
17721 " relative to the adopted coordinate system. The corner positions\n"
17722 " are specified by the appropriate combination of two of the\n"
17723 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17724 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17725 " value of one of those bits. The adopted coordinates are\n"
17726 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17727 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17728 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17729 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17730 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17731 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17732 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17733 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
17735 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17736 " coordinates from the specified standard position of the legend.\n"
17737 " For positive x, the direction of motion away from the standard\n"
17738 " position is inward/outward from the standard corner positions or\n"
17739 " standard left or right positions if the\n"
17740 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17741 " For the standard top or bottom positions, the direction of motion\n"
17742 " is toward positive X. \n"
17744 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17745 " coordinates from the specified standard position of the legend.\n"
17746 " For positive y, the direction of motion away from the standard\n"
17747 " position is inward/outward from the standard corner positions or\n"
17748 " standard top or bottom positions if the\n"
17749 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17750 " For the standard left or right positions, the direction of motion\n"
17751 " is toward positive Y. \n"
17753 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17754 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17755 " symbols are drawn) of the legend. \n"
17757 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17758 " legend (PL_LEGEND_BACKGROUND). \n"
17760 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17761 " for the legend (PL_LEGEND_BOUNDING_BOX). \n"
17763 " bb_style (PLINT, input) : The pllsty style number for the\n"
17764 " bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n"
17766 " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17767 " the legend (PL_LEGEND_BACKGROUND). \n"
17769 " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17770 " for the legend (PL_LEGEND_BACKGROUND). \n"
17772 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17773 " vertical height of the legend in adopted coordinates is calculated\n"
17774 " internally from nlegend, text_scale (see below), and text_spacing\n"
17777 " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17778 " options to control each individual plotted area corresponding to a\n"
17779 " legend entry. If the \n"
17780 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17782 " PL_LEGEND_COLOR_BOX, \n"
17783 " PL_LEGEND_LINE, and/or \n"
17784 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17785 " entry is plotted with a colored box; a line; and/or a line of\n"
17788 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17789 " area in units of character width. N.B. The total horizontal\n"
17790 " width of the legend in adopted coordinates is calculated\n"
17791 " internally from \n"
17792 " plot_width (see above), \n"
17793 " text_offset, and length (calculated internally) of the longest text\n"
17796 " text_scale (PLFLT, input) : Character height scale for text\n"
17797 " annotations. N.B. The total vertical height of the legend in\n"
17798 " adopted coordinates is calculated internally from \n"
17799 " nlegend (see above), \n"
17800 " text_scale, and \n"
17801 " text_spacing (see below). \n"
17803 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17804 " character height from one legend entry to the next. N.B. The\n"
17805 " total vertical height of the legend in adopted coordinates is\n"
17806 " calculated internally from \n"
17807 " nlegend (see above), \n"
17808 " text_scale (see above), and \n"
17809 " text_spacing. \n"
17811 " text_justification (PLFLT, input) : Justification parameter used\n"
17812 " for text justification. The most common values of\n"
17813 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17814 " is left justified, centred, or right justified within the text\n"
17815 " area, but other values are allowed as well. \n"
17817 " text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n"
17820 " text (const char * const *, input) : Array of nlegend text string\n"
17823 " box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n"
17824 " for the discrete colored boxes (\n"
17825 " PL_LEGEND_COLOR_BOX). \n"
17827 " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17828 " (plpsty indices) for the discrete colored boxes (\n"
17829 " PL_LEGEND_COLOR_BOX). \n"
17831 " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17832 " of fraction of character height) for the height of the discrete\n"
17833 " colored boxes (\n"
17834 " PL_LEGEND_COLOR_BOX). \n"
17836 " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17837 " widths for the patterns specified by box_patterns (\n"
17838 " PL_LEGEND_COLOR_BOX). \n"
17840 " line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n"
17842 " PL_LEGEND_LINE). \n"
17844 " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17845 " (plsty indices) (\n"
17846 " PL_LEGEND_LINE). \n"
17848 " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17849 " PL_LEGEND_LINE). \n"
17851 " symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n"
17852 " symbol colors (\n"
17853 " PL_LEGEND_SYMBOL). \n"
17855 " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17856 " values for the symbol height (\n"
17857 " PL_LEGEND_SYMBOL). \n"
17859 " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17860 " symbols to be drawn across the width of the plotted area (\n"
17861 " PL_LEGEND_SYMBOL). \n"
17863 " symbols (const char * const *, input) : Array of nlegend symbols\n"
17864 " (plpoin indices) (\n"
17865 " PL_LEGEND_SYMBOL). \n"
17869 "Plot color bar for image, shade or gradient plots \n"
17873 " Routine for creating a continuous color bar for image, shade, or\n"
17874 " gradient plots. (See pllegend for similar functionality for creating\n"
17875 " legends with discrete elements). The arguments of plcolorbar provide\n"
17876 " control over the location and size of the color bar as well as the\n"
17877 " location and characteristics of the elements (most of which are\n"
17878 " optional) within that color bar. The resulting color bar is clipped\n"
17879 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17880 " system used for some of the parameters is defined in the documentation\n"
17881 " of the position parameter.) \n"
17883 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17884 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17885 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17886 " labels, axis_opts, ticks, sub_ticks, values)\n"
17888 " This function is used in examples 16 and 33. \n"
17894 "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"
17898 " p_colorbar_width (PLFLT *, output) : Pointer to a location which\n"
17899 " contains (after the call) the labelled and decorated color bar\n"
17900 " width in adopted coordinates. \n"
17902 " p_colorbar_height (PLFLT *, output) : Pointer to a location which\n"
17903 " contains (after the call) the labelled and decorated color bar\n"
17904 " height in adopted coordinates. \n"
17906 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17907 " color bar. The orientation (direction of the maximum value) of\n"
17908 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17909 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17910 " specified, the default orientation is toward the top if the\n"
17911 " colorbar is placed on the left or right of the viewport or toward\n"
17912 " the right if the colorbar is placed on the top or bottom of the\n"
17913 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17914 " (semi-transparent) background for the color bar. If the\n"
17915 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17916 " color bar. The type of color bar must be specified with one of\n"
17917 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17918 " more than one of those bits is set only the first one in the above\n"
17919 " list is honored. The position of the (optional) label/title can be\n"
17920 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17921 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17922 " will be drawn. If more than one of this list of bits is specified,\n"
17923 " only the first one on the list is honored. End-caps for the color\n"
17924 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17925 " If a particular color bar cap option is not specified then no cap\n"
17926 " will be drawn for that end. As a special case for\n"
17927 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17928 " specified. If this option is provided then any tick marks and tick\n"
17929 " labels will be placed at the breaks between shaded segments. TODO:\n"
17930 " This should be expanded to support custom placement of tick marks\n"
17931 " and tick labels at custom value locations for any color bar type. \n"
17933 " position (PLINT, input) : position contains bits which control the\n"
17934 " overall position of the color bar and the definition of the\n"
17935 " adopted coordinates used for positions just like what is done for\n"
17936 " the position argument for pllegend. However, note that the\n"
17937 " defaults for the position bits (see below) are different than the\n"
17938 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17939 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17940 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17941 " the 16 possible standard positions (the 4 corners and centers of\n"
17942 " the 4 sides for both the inside and outside cases) of the color\n"
17943 " bar relative to the adopted coordinate system. The corner\n"
17944 " positions are specified by the appropriate combination of two of\n"
17945 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17946 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17947 " value of one of those bits. The adopted coordinates are\n"
17948 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17949 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17950 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17951 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17952 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17953 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17954 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17955 " PL_POSITION_VIEWPORT. \n"
17957 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17958 " coordinates from the specified standard position of the color bar.\n"
17959 " For positive x, the direction of motion away from the standard\n"
17960 " position is inward/outward from the standard corner positions or\n"
17961 " standard left or right positions if the\n"
17962 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17963 " For the standard top or bottom positions, the direction of motion\n"
17964 " is toward positive X. \n"
17966 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17967 " coordinates from the specified standard position of the color bar.\n"
17968 " For positive y, the direction of motion away from the standard\n"
17969 " position is inward/outward from the standard corner positions or\n"
17970 " standard top or bottom positions if the\n"
17971 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17972 " For the standard left or right positions, the direction of motion\n"
17973 " is toward positive Y. \n"
17975 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17976 " the X direction in adopted coordinates. \n"
17978 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17979 " the Y direction in adopted coordinates. \n"
17981 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17982 " color bar (PL_COLORBAR_BACKGROUND). \n"
17984 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17985 " for the color bar (PL_COLORBAR_BOUNDING_BOX). \n"
17987 " bb_style (PLINT, input) : The pllsty style number for the\n"
17988 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n"
17990 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17991 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n"
17993 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17994 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH). \n"
17996 " cont_color (PLINT, input) : The cmap0 contour color for\n"
17997 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17998 " it will be interpreted according to the design of plshades. \n"
18000 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18001 " plots. This is passed directly to plshades, so it will be\n"
18002 " interpreted according to the design of plshades. \n"
18004 " n_labels (PLINT, input) : Number of labels to place around the\n"
18007 " label_opts (const PLINT *, input) : Options for each of \n"
18008 " n_labels labels. \n"
18010 " labels (const char * const *, input) : n_labels text labels for the\n"
18011 " color bar. No label is drawn if no label position is specified\n"
18012 " with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18013 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18014 " corresponding label_opts field. \n"
18016 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18017 " value must be greater than 0. It is typically 1 (numerical axis\n"
18018 " labels are provided for one of the long edges of the color bar),\n"
18019 " but it can be larger if multiple numerical axis labels for the\n"
18020 " long edges of the color bar are desired. \n"
18022 " axis_opts (const char * const *, input) : An array of n_axes axis\n"
18023 " options (interpreted as for plbox) for the color bar's axis\n"
18026 " ticks (const PLFLT *, input) : An array of n_axes values of the\n"
18027 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18028 " color bar's axis definitions. \n"
18030 " sub_ticks (const PLINT *, input) : An array of n_axes values of the\n"
18031 " number of subticks (interpreted as for plbox) for the color bar's\n"
18032 " axis definitions. \n"
18034 " n_values (const PLINT *, input) : An array containing the number of\n"
18035 " elements in each of the n_axes rows of the two-dimensional values\n"
18038 " values (const PLFLT * const *, input) : A two-dimensional array\n"
18039 " containing the numeric values for the data range represented by\n"
18040 " the color bar. For a row index of i_axis (where 0 < i_axis <\n"
18041 " n_axes), the number of elements in the row is specified by\n"
18042 " n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT\n"
18043 " the number of elements is 2, and the corresponding row elements of\n"
18044 " the values array are the minimum and maximum value represented by\n"
18045 " the colorbar. For PL_COLORBAR_SHADE, the number and values of the\n"
18046 " elements of a row of the values array is interpreted the same as\n"
18047 " the nlevel and clevel arguments of plshades. \n"
18051 "Sets the 3D position of the light source \n"
18055 " Sets the 3D position of the light source for use with plsurf3d. \n"
18057 " Redacted form: pllightsource(x, y, z)\n"
18059 " This function is used in example 8. \n"
18065 "pllightsource(x, y, z)\n"
18069 " x (PLFLT, input) : X-coordinate of the light source. \n"
18071 " y (PLFLT, input) : Y-coordinate of the light source. \n"
18073 " z (PLFLT, input) : Z-coordinate of the light source. \n"
18076 { (
char *)
"plline",
_wrap_plline, METH_VARARGS, (
char *)
"\n"
18081 " Draws line defined by n points in x and y. \n"
18083 " Redacted form: plline(x, y)\n"
18085 " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
18091 "plline(n, x, y)\n"
18095 " n (PLINT, input) : Number of points defining line. \n"
18097 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
18100 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
18104 { (
char *)
"plline3",
_wrap_plline3, METH_VARARGS, (
char *)
"\n"
18105 "Draw a line in 3 space \n"
18109 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18110 " first set up the viewport, the 2d viewing window (in world\n"
18111 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18114 " Redacted form: plline3(x, y, z)\n"
18116 " This function is used in example 18. \n"
18122 "plline3(n, x, y, z)\n"
18126 " n (PLINT, input) : Number of points defining line. \n"
18128 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
18131 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
18134 " z (const PLFLT *, input) : Pointer to array with z coordinates of\n"
18138 { (
char *)
"pllsty",
_wrap_pllsty, METH_VARARGS, (
char *)
"\n"
18139 "Select line style \n"
18143 " This sets the line style according to one of eight predefined patterns\n"
18144 " (also see plstyl). \n"
18146 " Redacted form: pllsty(lin)\n"
18148 " This function is used in examples 9,12,22,25. \n"
18158 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18159 " a continuous line, line style 2 is a line with short dashes and\n"
18160 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18161 " 4 has long dashes and short gaps and so on. \n"
18164 { (
char *)
"plmesh",
_wrap_plmesh, METH_VARARGS, (
char *)
"\n"
18165 "Plot surface mesh \n"
18169 " Plots a surface mesh within the environment set up by plw3d. The\n"
18170 " surface is defined by the two-dimensional array z[\n"
18172 " ny] , the point z[i][j] being the value of the function at (\n"
18174 " y[j]) . Note that the points in arrays x and y do not need to be\n"
18175 " equally spaced, but must be stored in ascending order. The parameter\n"
18176 " opt controls the way in which the surface is displayed. For further\n"
18177 " details see the PLplot documentation. \n"
18179 " Redacted form: plmesh(x, y, z, opt)\n"
18181 " This function is used in example 11. \n"
18187 "plmesh(x, y, z, nx, ny, opt)\n"
18191 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18192 " which the function is evaluated. \n"
18194 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18195 " which the function is evaluated. \n"
18197 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18198 " two-dimensional array with set of function values. \n"
18200 " nx (PLINT, input) : Number of x values at which function is\n"
18203 " ny (PLINT, input) : Number of y values at which function is\n"
18206 " opt (PLINT, input) : Determines the way in which the surface is\n"
18207 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18208 " function of x for each value of y[j] . \n"
18209 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18210 " for each value of x[i] . \n"
18211 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18212 " at which function is defined. \n"
18215 { (
char *)
"plmeshc",
_wrap_plmeshc, METH_VARARGS, (
char *)
"\n"
18216 "Magnitude colored plot surface mesh with contour \n"
18220 " A more powerful form of plmesh: the surface mesh can be colored\n"
18221 " accordingly to the current z value being plotted, a contour plot can\n"
18222 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18223 " plotted function border and the base XY plane. \n"
18225 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18227 " This function is used in example 11. \n"
18233 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18237 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18238 " which the function is evaluated. \n"
18240 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18241 " which the function is evaluated. \n"
18243 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18244 " two-dimensional array with set of function values. \n"
18246 " nx (PLINT, input) : Number of x values at which function is\n"
18249 " ny (PLINT, input) : Number of y values at which function is\n"
18252 " opt (PLINT, input) : Determines the way in which the surface is\n"
18253 " represented. To specify more than one option just add the options,\n"
18254 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18255 " showing z as a function of x for each value of y[j] . \n"
18256 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18257 " for each value of x[i] . \n"
18258 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18259 " at which function is defined. \n"
18260 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18261 " the z value being plotted. The color is used from the current\n"
18263 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18264 " using parameters \n"
18267 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18268 " the borders of the plotted function. \n"
18271 " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18272 " the contour level spacing. \n"
18274 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18277 { (
char *)
"plmkstrm",
_wrap_plmkstrm, METH_VARARGS, (
char *)
"\n"
18278 "Creates a new stream and makes it the default \n"
18282 " Creates a new stream and makes it the default. Differs from using\n"
18283 " plsstrm, in that a free stream number is found, and returned.\n"
18284 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18285 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18286 " that no initial, library-opening call is required. So stream 0 must\n"
18287 " be preallocated, and there is no simple way of determining whether it\n"
18288 " is already in use or not. \n"
18290 " Redacted form: plmkstrm(p_strm)\n"
18292 " This function is used in examples 1,20. \n"
18298 "plmkstrm(p_strm)\n"
18302 " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
18306 { (
char *)
"plmtex",
_wrap_plmtex, METH_VARARGS, (
char *)
"\n"
18307 "Write text relative to viewport boundaries \n"
18311 " Writes text at a specified position relative to the viewport\n"
18312 " boundaries. Text may be written inside or outside the viewport, but\n"
18313 " is clipped at the subpage boundaries. The reference point of a string\n"
18314 " lies along a line passing through the string at half the height of a\n"
18315 " capital letter. The position of the reference point along this line\n"
18316 " is determined by just, and the position of the reference point\n"
18317 " relative to the viewport is set by disp and pos. \n"
18319 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18320 " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
18323 " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
18329 "plmtex(side, disp, pos, just, text)\n"
18333 " side (const char *, input) : Specifies the side of the viewport\n"
18334 " along which the text is to be written. The string must be one of:\n"
18335 " b: Bottom of viewport, text written parallel to edge. \n"
18336 " bv: Bottom of viewport, text written at right angles to edge. \n"
18337 " l: Left of viewport, text written parallel to edge. \n"
18338 " lv: Left of viewport, text written at right angles to edge. \n"
18339 " r: Right of viewport, text written parallel to edge. \n"
18340 " rv: Right of viewport, text written at right angles to edge. \n"
18341 " t: Top of viewport, text written parallel to edge. \n"
18342 " tv: Top of viewport, text written at right angles to edge. \n"
18345 " disp (PLFLT, input) : Position of the reference point of string,\n"
18346 " measured outwards from the specified viewport edge in units of the\n"
18347 " current character height. Use negative disp to write within the\n"
18350 " pos (PLFLT, input) : Position of the reference point of string\n"
18351 " along the specified edge, expressed as a fraction of the length of\n"
18354 " just (PLFLT, input) : Specifies the position of the string relative\n"
18355 " to its reference point. If just=0. , the reference point is at\n"
18356 " the left and if just=1. , it is at the right of the string. Other\n"
18357 " values of just give intermediate justifications. \n"
18359 " text (const char *, input) : The string to be written out. \n"
18362 { (
char *)
"plmtex3",
_wrap_plmtex3, METH_VARARGS, (
char *)
"\n"
18363 "Write text relative to viewport boundaries in 3D plots \n"
18367 " Writes text at a specified position relative to the viewport\n"
18368 " boundaries. Text may be written inside or outside the viewport, but\n"
18369 " is clipped at the subpage boundaries. The reference point of a string\n"
18370 " lies along a line passing through the string at half the height of a\n"
18371 " capital letter. The position of the reference point along this line\n"
18372 " is determined by just, and the position of the reference point\n"
18373 " relative to the viewport is set by disp and pos. \n"
18375 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18377 " This function is used in example 28. \n"
18383 "plmtex3(side, disp, pos, just, text)\n"
18387 " side (const char *, input) : Specifies the side of the viewport\n"
18388 " along which the text is to be written. The string should contain\n"
18389 " one or more of the following characters: [xyz][ps][v]. Only one\n"
18390 " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
18391 " both the X and Y axes. x: Label the X axis. \n"
18392 " y: Label the Y axis. \n"
18393 " z: Label the Z axis. \n"
18394 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18395 " For X it is the axis that starts at y-min. For Y it is the\n"
18396 " axis that starts at x-min. \n"
18397 " s: Label the secondary axis. \n"
18398 " v: Draw the text perpendicular to the axis. \n"
18401 " disp (PLFLT, input) : Position of the reference point of string,\n"
18402 " measured outwards from the specified viewport edge in units of the\n"
18403 " current character height. Use negative disp to write within the\n"
18406 " pos (PLFLT, input) : Position of the reference point of string\n"
18407 " along the specified edge, expressed as a fraction of the length of\n"
18410 " just (PLFLT, input) : Specifies the position of the string relative\n"
18411 " to its reference point. If just=0. , the reference point is at\n"
18412 " the left and if just=1. , it is at the right of the string. Other\n"
18413 " values of just give intermediate justifications. \n"
18415 " text (const char *, input) : The string to be written out. \n"
18418 { (
char *)
"plot3d",
_wrap_plot3d, METH_VARARGS, (
char *)
"\n"
18419 "Plot 3-d surface plot \n"
18423 " Plots a three dimensional surface plot within the environment set up\n"
18424 " by plw3d. The surface is defined by the two-dimensional array z[\n"
18426 " ny] , the point z[i][j] being the value of the function at (\n"
18428 " y[j]) . Note that the points in arrays x and y do not need to be\n"
18429 " equally spaced, but must be stored in ascending order. The parameter\n"
18430 " opt controls the way in which the surface is displayed. For further\n"
18431 " details see the PLplot documentation. The only difference between\n"
18432 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18433 " while plot3d only draws the surface as viewed from the top. \n"
18435 " Redacted form: plot3d(x, y, z, opt, side)\n"
18437 " This function is used in examples 11,21. \n"
18443 "plot3d(x, y, z, nx, ny, opt, side)\n"
18447 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18448 " which the function is evaluated. \n"
18450 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18451 " which the function is evaluated. \n"
18453 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18454 " two-dimensional array with set of function values. \n"
18456 " nx (PLINT, input) : Number of x values at which function is\n"
18459 " ny (PLINT, input) : Number of y values at which function is\n"
18462 " opt (PLINT, input) : Determines the way in which the surface is\n"
18463 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18464 " function of x for each value of y[j] . \n"
18465 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18466 " for each value of x[i] . \n"
18467 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18468 " at which function is defined. \n"
18471 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18472 " should be draw on the figure. If side is true sides are drawn,\n"
18473 " otherwise no sides are drawn. \n"
18476 { (
char *)
"plot3dc",
_wrap_plot3dc, METH_VARARGS, (
char *)
"\n"
18477 "Magnitude colored plot surface with contour \n"
18481 " Aside from dropping the \n"
18482 " side functionality this is a more powerful form of plot3d: the surface\n"
18483 " mesh can be colored accordingly to the current z value being plotted,\n"
18484 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18485 " drawn between the plotted function border and the base XY plane. The\n"
18486 " arguments are identical to those of plmeshc. The only difference\n"
18487 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18488 " the surface, while plot3dc only draws the surface as viewed from the\n"
18491 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18492 " Perl/PDL: Not available? \n"
18495 " This function is used in example 21. \n"
18501 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18505 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18506 " which the function is evaluated. \n"
18508 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18509 " which the function is evaluated. \n"
18511 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18512 " two-dimensional array with set of function values. \n"
18514 " nx (PLINT, input) : Number of x values at which function is\n"
18517 " ny (PLINT, input) : Number of y values at which function is\n"
18520 " opt (PLINT, input) : Determines the way in which the surface is\n"
18521 " represented. To specify more than one option just add the options,\n"
18522 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18523 " showing z as a function of x for each value of y[j] . \n"
18524 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18525 " for each value of x[i] . \n"
18526 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18527 " at which function is defined. \n"
18528 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18529 " the z value being plotted. The color is used from the current\n"
18531 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18532 " using parameters \n"
18535 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18536 " the borders of the plotted function. \n"
18539 " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18540 " the contour level spacing. \n"
18542 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18545 { (
char *)
"plot3dcl",
_wrap_plot3dcl, METH_VARARGS, (
char *)
"\n"
18546 "Magnitude colored plot surface with contour for z[x][y] with y index limits \n"
18550 " When the implementation is completed this variant of plot3dc (see that\n"
18551 " function's documentation for more details) should be suitable for the\n"
18552 " case where the area of the x, y coordinate grid where z is defined can\n"
18553 " be non-rectangular. The implementation is incomplete so the last 4\n"
18554 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18555 " indexymax; are currently ignored and the functionality is otherwise\n"
18556 " identical to that of plot3dc. \n"
18558 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18559 " indexymin, indexymax) \n"
18560 " Perl/PDL: Not available? \n"
18563 " This function is not used in any example. \n"
18569 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18573 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18574 " which the function is evaluated. \n"
18576 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18577 " which the function is evaluated. \n"
18579 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18580 " two-dimensional array with set of function values. \n"
18582 " nx (PLINT, input) : Number of x values at which the function is\n"
18585 " ny (PLINT, input) : Number of y values at which the function is\n"
18588 " opt (PLINT, input) : Determines the way in which the surface is\n"
18589 " represented. To specify more than one option just add the options,\n"
18590 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18591 " showing z as a function of x for each value of y[j] . \n"
18592 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18593 " for each value of x[i] . \n"
18594 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18595 " at which function is defined. \n"
18596 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18597 " the z value being plotted. The color is used from the current\n"
18599 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18600 " using parameters \n"
18603 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18604 " the borders of the plotted function. \n"
18607 " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18608 " the contour level spacing. \n"
18610 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18612 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18613 " corresponds to the first x index where z is defined. \n"
18615 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18616 " which corresponds (by convention) to one more than the last x\n"
18617 " index value where z is defined. \n"
18619 " indexymin (const PLINT *, input) : Array of y index values which\n"
18620 " all must be ≥ 0. These values are the first y index where z is\n"
18621 " defined for a particular x index in the range from indexxmin to\n"
18622 " indexxmax - 1. The dimension of indexymin is indexxmax. \n"
18624 " indexymax (const PLINT *, input) : Array of y index values which\n"
18625 " all must be ≤ ny. These values correspond (by convention) to one\n"
18626 " more than the last y index where z is defined for a particular x\n"
18627 " index in the range from indexxmin to indexxmax - 1. The dimension\n"
18628 " of indexymax is indexxmax. \n"
18631 { (
char *)
"plsurf3d",
_wrap_plsurf3d, METH_VARARGS, (
char *)
"\n"
18632 "Plot shaded 3-d surface plot \n"
18636 " Plots a three dimensional shaded surface plot within the environment\n"
18637 " set up by plw3d. The surface is defined by the two-dimensional array\n"
18640 " ny] , the point z[i][j] being the value of the function at (\n"
18642 " y[j]) . Note that the points in arrays x and y do not need to be\n"
18643 " equally spaced, but must be stored in ascending order. For further\n"
18644 " details see the PLplot documentation. \n"
18646 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18648 " This function is not used in any examples. \n"
18654 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18658 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18659 " which the function is evaluated. \n"
18661 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18662 " which the function is evaluated. \n"
18664 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18665 " two-dimensional array with set of function values. \n"
18667 " nx (PLINT, input) : Number of x values at which function is\n"
18670 " ny (PLINT, input) : Number of y values at which function is\n"
18673 " opt (PLINT, input) : Determines the way in which the surface is\n"
18674 " represented. To specify more than one option just add the options,\n"
18675 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18676 " connecting points at which function is defined. \n"
18677 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18678 " using parameters \n"
18681 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18682 " using parameters \n"
18685 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18686 " the borders of the plotted function. \n"
18687 " opt=MAG_COLOR : the surface is colored according to the value\n"
18688 " of Z; if MAG_COLOR is not used, then the default the surface\n"
18689 " is colored according to the intensity of the reflected light\n"
18690 " in the surface from a light source whose position is set using\n"
18691 " pllightsource. \n"
18694 " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18695 " the contour level spacing. \n"
18697 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18701 "Plot shaded 3-d surface plot for z[x][y] with y index limits \n"
18705 " This variant of plsurf3d (see that function's documentation for more\n"
18706 " details) should be suitable for the case where the area of the x, y\n"
18707 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18708 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18709 " indexymin, and indexymax. \n"
18711 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18714 " This function is used in example 8. \n"
18720 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18724 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18725 " which the function is evaluated. \n"
18727 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18728 " which the function is evaluated. \n"
18730 " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18731 " two-dimensional array with set of function values. \n"
18733 " nx (PLINT, input) : Number of x values at which function is\n"
18736 " ny (PLINT, input) : Number of y values at which function is\n"
18739 " opt (PLINT, input) : Determines the way in which the surface is\n"
18740 " represented. To specify more than one option just add the options,\n"
18741 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18742 " connecting points at which function is defined. \n"
18743 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18744 " using parameters \n"
18747 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18748 " using parameters \n"
18751 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18752 " the borders of the plotted function. \n"
18753 " opt=MAG_COLOR : the surface is colored according to the value\n"
18754 " of Z; if MAG_COLOR is not used, then the default the surface\n"
18755 " is colored according to the intensity of the reflected light\n"
18756 " in the surface from a light source whose position is set using\n"
18757 " pllightsource. \n"
18760 " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18761 " the contour level spacing. \n"
18763 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18765 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18766 " corresponds to the first x index where z is defined. \n"
18768 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18769 " which corresponds (by convention) to one more than the last x\n"
18770 " index value where z is defined. \n"
18772 " indexymin (const PLINT *, input) : Array of y index values which\n"
18773 " all must be ≥ 0. These values are the first y index where z is\n"
18774 " defined for a particular x index in the range from indexxmin to\n"
18775 " indexxmax - 1. The dimension of indexymin is indexxmax. \n"
18777 " indexymax (const PLINT *, input) : Array of y index values which\n"
18778 " all must be ≤ ny. These values correspond (by convention) to one\n"
18779 " more than the last y index where z is defined for a particular x\n"
18780 " index in the range from indexxmin to indexxmax - 1. The dimension\n"
18781 " of indexymax is indexxmax. \n"
18785 "Parse command-line arguments \n"
18789 " Parse command-line arguments. \n"
18791 " plparseopts removes all recognized flags (decreasing argc\n"
18792 " accordingly), so that invalid input may be readily detected. It can\n"
18793 " also be used to process user command line flags. The user can merge\n"
18794 " an option table of type PLOptionTable into the internal option table\n"
18795 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18796 " the external table(s) be parsed by calling plClearOpts before\n"
18799 " The default action taken by plparseopts is as follows: \n"
18800 " Returns with an error if an unrecognized option or badly formed\n"
18801 " option-value pair are encountered. \n"
18802 " Returns immediately (return code 0) when the first non-option command\n"
18803 " line argument is found. \n"
18804 " Returns with the return code of the option handler, if one was called.\n"
18806 " Deletes command line arguments from argv list as they are found, and\n"
18807 " decrements argc accordingly. \n"
18808 " Does not show \"invisible\" options in usage or help messages. \n"
18809 " Assumes the program name is contained in argv[0]. \n"
18811 " These behaviors may be controlled through the \n"
18812 " mode argument. \n"
18814 " Redacted form: General: plparseopts(argv, mode)\n"
18815 " Perl/PDL: Not available? \n"
18818 " This function is used in all of the examples. \n"
18824 "int plparseopts(p_argc, argv, mode)\n"
18828 " p_argc (int *, input) : pointer to number of arguments. \n"
18830 " argv (const char **, input) : Pointer to character array containing\n"
18831 " *p_argc command-line arguments. \n"
18833 " mode (PLINT, input) : Parsing mode with the following\n"
18834 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18835 " and all error messages enabled, including program exit when an\n"
18836 " error occurs. Anything on the command line that isn't recognized\n"
18837 " as a valid option or option argument is flagged as an error. \n"
18838 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18840 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18842 " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
18843 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18844 " pointer to the program name. \n"
18845 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
18846 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18847 " unrecognized arguments. \n"
18850 { (
char *)
"plpat",
_wrap_plpat, METH_VARARGS, (
char *)
"\n"
18851 "Set area fill pattern \n"
18855 " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
18856 " parallel lines with specified inclinations and spacings. The\n"
18857 " arguments to this routine are the number of sets to use (1 or 2)\n"
18858 " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
18859 " specifying the inclinations in tenths of a degree and the spacing in\n"
18860 " micrometers. (also see plpsty) \n"
18862 " Redacted form: General: plpat(inc, del)\n"
18863 " Perl/PDL: plpat(nlin, inc, del)\n"
18866 " This function is used in example 15. \n"
18872 "plpat(nlin, inc, del)\n"
18876 " nlin (PLINT, input) : Number of sets of lines making up the\n"
18877 " pattern, either 1 or 2. \n"
18879 " inc (const PLINT *, input) : Pointer to array with nlin elements.\n"
18880 " Specifies the line inclination in tenths of a degree. (Should be\n"
18881 " between -900 and 900). \n"
18883 " del (const PLINT *, input) : Pointer to array with nlin elements.\n"
18884 " Specifies the spacing in micrometers between the lines making up\n"
18888 { (
char *)
"plpath",
_wrap_plpath, METH_VARARGS, (
char *)
"\n"
18889 "Draw a line between two points, accounting for coordinate transforms \n"
18893 " Joins the point (\n"
18897 " y2) . If a global coordinate transform is defined then the line is\n"
18898 " broken in to n segments to approximate the path. If no transform is\n"
18899 " defined then this simply acts like a call to pljoin. \n"
18901 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18903 " This function is used in example 22. \n"
18909 "plpath(n, x1, y1, x2, y2)\n"
18913 " n (PLINT, input) : number of points to use to approximate the path. \n"
18915 " x1 (PLFLT, input) : x coordinate of first point. \n"
18917 " y1 (PLFLT, input) : y coordinate of first point. \n"
18919 " x2 (PLFLT, input) : x coordinate of second point. \n"
18921 " y2 (PLFLT, input) : y coordinate of second point. \n"
18924 { (
char *)
"plpoin",
_wrap_plpoin, METH_VARARGS, (
char *)
"\n"
18925 "Plot a glyph at the specified points \n"
18929 " Plot a glyph at the specified points. (This function is largely\n"
18930 " superseded by plstring which gives access to many[!] more glyphs.)\n"
18931 " code=-1 means try to just draw a point. Right now it's just a move\n"
18932 " and a draw at the same place. Not ideal, since a sufficiently\n"
18933 " intelligent output device may optimize it away, or there may be faster\n"
18934 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18935 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18936 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18937 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18938 " code <= 127 the corresponding printable ASCII character is plotted. \n"
18940 " Redacted form: plpoin(x, y, code)\n"
18942 " This function is used in examples 1,6,14,29. \n"
18948 "plpoin(n, x, y, code)\n"
18952 " n (PLINT, input) : Number of points in the x and y arrays. \n"
18954 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
18957 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
18960 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18961 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18962 " each of the n points. \n"
18965 { (
char *)
"plpoin3",
_wrap_plpoin3, METH_VARARGS, (
char *)
"\n"
18966 "Plot a glyph at the specified 3D points \n"
18970 " Plot a glyph at the specified 3D points. (This function is largely\n"
18971 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18972 " Set up the call to this function similar to what is done for plline3.\n"
18973 " code=-1 means try to just draw a point. Right now it's just a move\n"
18974 " and a draw at the same place. Not ideal, since a sufficiently\n"
18975 " intelligent output device may optimize it away, or there may be faster\n"
18976 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18977 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18978 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18979 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18980 " code <= 127 the corresponding printable ASCII character is plotted. \n"
18982 " Redacted form: plpoin3(x, y, z, code)\n"
18984 " This function is not used in any example. \n"
18990 "plpoin3(n, x, y, z, code)\n"
18994 " n (PLINT, input) : Number of points in the x and y arrays. \n"
18996 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
18999 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
19002 " z (const PLFLT *, input) : Pointer to an array with Z coordinates\n"
19005 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19006 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19007 " each of the n points. \n"
19010 { (
char *)
"plpoly3",
_wrap_plpoly3, METH_VARARGS, (
char *)
"\n"
19011 "Draw a polygon in 3 space \n"
19015 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19016 " like plline3, but differs from that function in that plpoly3 attempts\n"
19017 " to determine if the polygon is viewable depending on the order of the\n"
19018 " points within the arrays and the value of ifcc. If the back of\n"
19019 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19020 " you want, then use plline3 instead. \n"
19022 " The points are assumed to be in a plane, and the directionality of the\n"
19023 " plane is determined from the first three points. Additional points do\n"
19024 " not have to lie on the plane defined by the first three, but if they\n"
19025 " do not, then the determination of visibility obviously can't be 100%\n"
19026 " accurate... So if you're 3 space polygons are too far from planar,\n"
19027 " consider breaking them into smaller polygons. 3 points define a plane\n"
19030 " Bugs: If one of the first two segments is of zero length, or if they\n"
19031 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19032 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19033 " of this problem. (Search for 20.1). \n"
19035 " Redacted form: plpoly3(x, y, z, code)\n"
19037 " This function is used in example 18. \n"
19043 "plpoly3(n, x, y, z, draw, ifcc)\n"
19047 " n (PLINT, input) : Number of points defining line. \n"
19049 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
19052 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
19055 " z (const PLFLT *, input) : Pointer to array with z coordinates of\n"
19058 " draw (const PLBOOL *, input) : Pointer to array which controls\n"
19059 " drawing the segments of the polygon. If draw[i] is true, then the\n"
19060 " polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n"
19062 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19063 " polygon is determined by assuming the points are laid out in a\n"
19064 " counter-clockwise order. Otherwise, the directionality of the\n"
19065 " polygon is determined by assuming the points are laid out in a\n"
19066 " clockwise order. \n"
19069 { (
char *)
"plprec",
_wrap_plprec, METH_VARARGS, (
char *)
"\n"
19070 "Set precision in numeric labels \n"
19074 " Sets the number of places after the decimal point in numeric labels. \n"
19076 " Redacted form: plprec(setp, prec)\n"
19078 " This function is used in example 29. \n"
19084 "plprec(setp, prec)\n"
19088 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19089 " automatically determines the number of places to use after the\n"
19090 " decimal point in numeric labels (like those used to label axes). \n"
19091 " If setp is 1 then prec sets the number of places. \n"
19093 " prec (PLINT, input) : The number of characters to draw after the\n"
19094 " decimal point in numeric labels. \n"
19097 { (
char *)
"plpsty",
_wrap_plpsty, METH_VARARGS, (
char *)
"\n"
19098 "Select area fill pattern \n"
19102 " Select one of eight predefined area fill patterns to use (also see\n"
19103 " plpat). Setting the fill style to 0 gives a solid fill. \n"
19105 " Redacted form: plpsty(patt)\n"
19107 " This function is used in examples 12,13,15,16,25. \n"
19117 " patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
19118 " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
19119 " consists of lines at 45 degrees angle (upward), and so on. \n"
19122 { (
char *)
"plptex",
_wrap_plptex, METH_VARARGS, (
char *)
"\n"
19123 "Write text inside the viewport \n"
19127 " Writes text at a specified position and inclination within the\n"
19128 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19129 " point of a string lies along a line passing through the string at half\n"
19130 " the height of a capital letter. The position of the reference point\n"
19131 " along this line is determined by just, the reference point is placed\n"
19132 " at world coordinates (\n"
19134 " y) within the viewport. The inclination of the string is specified\n"
19135 " in terms of differences of world coordinates making it easy to write\n"
19136 " text parallel to a line in a graph. \n"
19138 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19140 " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
19146 "plptex(x, y, dx, dy, just, text)\n"
19150 " x (PLFLT, input) : x coordinate of reference point of string. \n"
19152 " y (PLFLT, input) : y coordinate of reference point of string. \n"
19154 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19155 " inclination of the string. The baseline of the string is parallel\n"
19156 " to a line joining (\n"
19164 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19165 " inclination of the string. \n"
19167 " just (PLFLT, input) : Specifies the position of the string relative\n"
19168 " to its reference point. If just=0. , the reference point is at\n"
19169 " the left and if just=1. , it is at the right of the string. Other\n"
19170 " values of just give intermediate justifications. \n"
19172 " text (const char *, input) : The string to be written out. \n"
19175 { (
char *)
"plptex3",
_wrap_plptex3, METH_VARARGS, (
char *)
"\n"
19176 "Write text inside the viewport of a 3D plot \n"
19180 " Writes text at a specified position and inclination and with a\n"
19181 " specified shear within the viewport. Text is clipped at the viewport\n"
19182 " boundaries. The reference point of a string lies along a line passing\n"
19183 " through the string at half the height of a capital letter. The\n"
19184 " position of the reference point along this line is determined by just,\n"
19185 " and the reference point is placed at world coordinates (\n"
19188 " wz) within the viewport. The inclination and shear of the string is\n"
19189 " specified in terms of differences of world coordinates making it easy\n"
19190 " to write text parallel to a line in a graph. \n"
19192 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text) \n"
19194 " This function is used in example 28. \n"
19200 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19204 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19207 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19210 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19213 " dx (PLFLT, input) : Together with dy and \n"
19214 " dz , this specifies the inclination of the string. The baseline of\n"
19215 " the string is parallel to a line joining (\n"
19226 " dy (PLFLT, input) : Together with dx and \n"
19227 " dz, this specifies the inclination of the string. \n"
19229 " dz (PLFLT, input) : Together with dx and \n"
19230 " dy, this specifies the inclination of the string. \n"
19232 " sx (PLFLT, input) : Together with sy and \n"
19233 " sz , this specifies the shear of the string. The string is sheared so\n"
19234 " that the characters are vertically parallel to a line joining (\n"
19243 " sz) . If sx = \n"
19245 " sz = 0.) then the text is not sheared. \n"
19247 " sy (PLFLT, input) : Together with sx and \n"
19248 " sz, this specifies shear of the string. \n"
19250 " sz (PLFLT, input) : Together with sx and \n"
19251 " sy, this specifies shear of the string. \n"
19253 " just (PLFLT, input) : Specifies the position of the string relative\n"
19254 " to its reference point. If just=0. , the reference point is at\n"
19255 " the left and if just=1. , it is at the right of the string. Other\n"
19256 " values of just give intermediate justifications. \n"
19258 " text (const char *, input) : The string to be written out. \n"
19261 { (
char *)
"plrandd",
_wrap_plrandd, METH_VARARGS, (
char *)
"\n"
19262 "Random number generator returning a real random number in the range [0,1] \n"
19266 " Random number generator returning a real random number in the range\n"
19267 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19268 " / compilers provide their own random number generator, and so this is\n"
19269 " provided purely for convenience and to give a consistent random number\n"
19270 " generator across all languages supported by PLplot. This is\n"
19271 " particularly useful for comparing results from the test suite of\n"
19274 " Redacted form: plrandd()\n"
19276 " This function is used in examples 17,21. \n"
19285 { (
char *)
"plreplot",
_wrap_plreplot, METH_VARARGS, (
char *)
"\n"
19286 "Replays contents of plot buffer to current device/file \n"
19290 " Replays contents of plot buffer to current device/file. \n"
19292 " Redacted form: plreplot()\n"
19294 " This function is used in example 1,20. \n"
19303 { (
char *)
"plrgbhls",
_wrap_plrgbhls, METH_VARARGS, (
char *)
"\n"
19304 "Convert RGB color to HLS \n"
19308 " Convert RGB color coordinates to HLS \n"
19310 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19311 " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
19314 " This function is used in example 2. \n"
19320 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19324 " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
19326 " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
19328 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
19330 " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
19331 " cone (0.0-360.0) \n"
19333 " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
19334 " fraction of the axis of the colour cone (0.0-1.0) \n"
19336 " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
19337 " fraction of the radius of the colour cone (0.0-1.0) \n"
19340 { (
char *)
"plschr",
_wrap_plschr, METH_VARARGS, (
char *)
"\n"
19341 "Set character size \n"
19345 " This sets up the size of all subsequent characters drawn. The actual\n"
19346 " height of a character is the product of the default character size and\n"
19347 " a scaling factor. \n"
19349 " Redacted form: plschr(def, scale)\n"
19351 " This function is used in example 2,13,23,24. \n"
19357 "plschr(def, scale)\n"
19361 " def (PLFLT, input) : The default height of a character in\n"
19362 " millimeters, should be set to zero if the default height is to\n"
19363 " remain unchanged. \n"
19365 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19366 " actual character height. \n"
19369 { (
char *)
"plscmap0",
_wrap_plscmap0, METH_VARARGS, (
char *)
"\n"
19370 "Set cmap0 colors by 8-bit RGB values \n"
19374 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19375 " documentation). This sets the entire color map -- only as many colors\n"
19376 " as specified will be allocated. \n"
19378 " Redacted form: plscmap0(r, g, b)\n"
19380 " This function is used in examples 2,24. \n"
19386 "plscmap0(r, g, b, ncol0)\n"
19390 " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19391 " 8-bit integers (0-255) representing the degree of red in the\n"
19394 " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19395 " 8-bit integers (0-255) representing the degree of green in the\n"
19398 " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19399 " 8-bit integers (0-255) representing the degree of blue in the\n"
19402 " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
19406 "Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n"
19410 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19411 " and floating point alpha transparency value. This sets the entire\n"
19412 " color map -- only as many colors as specified will be allocated. \n"
19414 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19416 " This function is used in examples 30. \n"
19422 "plscmap0a(r, g, b, alpha, ncol0)\n"
19426 " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19427 " 8-bit integers (0-255) representing the degree of red in the\n"
19430 " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19431 " 8-bit integers (0-255) representing the degree of green in the\n"
19434 " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19435 " 8-bit integers (0-255) representing the degree of blue in the\n"
19438 " alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n"
19439 " values (0.0 - 1.0) representing the alpha transparency of the\n"
19442 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19447 "Set number of colors in cmap0 \n"
19451 " Set number of colors in color map0 (see the PLplot documentation).\n"
19452 " Allocate (or reallocate) color map0, and fill with default values for\n"
19453 " those colors not previously allocated. The first 16 default colors are\n"
19454 " given in the plcol0 documentation. For larger indices the default\n"
19455 " color is red. \n"
19457 " The drivers are not guaranteed to support more than 16 colors. \n"
19459 " Redacted form: plscmap0n(ncol0)\n"
19461 " This function is used in examples 15,16,24. \n"
19467 "plscmap0n(ncol0)\n"
19471 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19472 " the map0 palette. If this number is zero or less, then the value\n"
19473 " from the previous call to plscmap0n is used and if there is no\n"
19474 " previous call, then a default value is used. \n"
19477 { (
char *)
"plscmap1",
_wrap_plscmap1, METH_VARARGS, (
char *)
"\n"
19478 "Set cmap1 colors using 8-bit RGB values \n"
19482 " Set cmap1 colors using 8-bit RGB values (see the PLplot\n"
19483 " documentation). This also sets the number of colors. \n"
19485 " Redacted form: plscmap1(r, g, b)\n"
19487 " This function is used in example 31. \n"
19493 "plscmap1(r, g, b, ncol1)\n"
19497 " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19498 " 8-bit integers (0-255) representing the degree of red in the\n"
19501 " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19502 " 8-bit integers (0-255) representing the degree of green in the\n"
19505 " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19506 " 8-bit integers (0-255) representing the degree of blue in the\n"
19509 " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
19513 "Set cmap1 colors using 8-bit RGB values and double alpha transparency values \n"
19517 " Set cmap1 colors using 8-bit RGB values (see the PLplot documentation)\n"
19518 " and double alpha transparency values. This also sets the number of\n"
19521 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19523 " This function is used in example 31. \n"
19529 "plscmap1a(r, g, b, alpha, ncol1)\n"
19533 " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19534 " 8-bit integers (0-255) representing the degree of red in the\n"
19537 " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19538 " 8-bit integers (0-255) representing the degree of green in the\n"
19541 " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19542 " 8-bit integers (0-255) representing the degree of blue in the\n"
19545 " alpha (const PLFLT *, input) : Pointer to array with set of double\n"
19546 " values (0.0-1.0) representing the alpha transparency value of the\n"
19549 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19554 "Set cmap1 colors using a piece-wise linear relationship \n"
19558 " Set cmap1 colors using a piece-wise linear relationship between\n"
19559 " intensity index (from 0. to 1.) of cmap1 and position in HLS or RGB\n"
19560 " color space (see the PLplot documentation). May be called at any\n"
19563 " The idea here is to specify a number of control points that define the\n"
19564 " mapping between input cmap1 intensity indices and HLS (or RGB). \n"
19565 " Between these points, linear interpolation is used which gives a\n"
19566 " smooth variation of color with intensity index. Any number of control\n"
19567 " points may be specified, located at arbitrary positions, although\n"
19568 " typically 2 - 4 are enough. Another way of stating this is that we are\n"
19569 " traversing a given number of lines through HLS (or RGB) space as we\n"
19570 " move through cmap1 intensity indices. The control points at the\n"
19571 " minimum and maximum position (0 and 1) must always be specified. By\n"
19572 " adding more control points you can get more variation. One good\n"
19573 " technique for plotting functions that vary about some expected average\n"
19574 " is to use an additional 2 control points in the center (position ~=\n"
19575 " 0.5) that are the same lightness as the background (typically white\n"
19576 " for paper output, black for crt), and same hue as the boundary control\n"
19577 " points. This allows the highs and lows to be very easily\n"
19578 " distinguished. \n"
19580 " Each control point must specify the cmap1 intensity index and the\n"
19581 " associated three coordinates in HLS or RGB space. The first point\n"
19582 " must correspond to position = 0, and the last to position = 1. \n"
19584 " The default behaviour is for the hue to be linearly interpolated\n"
19585 " between the control points. Since the hue lies in the range [0, 360]\n"
19586 " this corresponds to interpolation around the \"front\" of the color\n"
19587 " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
19588 " alternative interpolation is used between control points i and i+1. If\n"
19589 " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n"
19590 " - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n"
19591 " this as interpolation around the \"back\" or \"reverse\" of the color\n"
19592 " wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
19593 " alt_hue_path[] = false for every control point. \n"
19595 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19596 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19597 " 240]truegreen-yellow-red-magenta-blue[240\n"
19598 " 120]trueblue-magenta-red-yellow-green\n"
19600 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19601 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19602 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19604 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19607 " This function is used in examples 8,11,12,15,20,21. \n"
19613 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19617 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
19619 " npts (PLINT, input) : number of control points \n"
19621 " intensity (const PLFLT *, input) : intensity index for each control\n"
19622 " point (between 0.0 and 1.0, in ascending order) \n"
19624 " coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n"
19625 " control point \n"
19627 " coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n"
19628 " control point \n"
19630 " coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n"
19631 " control point \n"
19633 " alt_hue_path (const PLBOOL *, input) : alternative interpolation\n"
19634 " method flag for each control point. (alt_hue_path[i] refers to the\n"
19635 " interpolation interval between the i and i + 1 control points). \n"
19639 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship \n"
19643 " This is a variant of plscmap1l that supports alpha channel\n"
19644 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19645 " relationship between cmap1 intensity index (from 0. to 1.) and\n"
19646 " position in HLS or RGB color space (see the PLplot documentation) with\n"
19647 " alpha transparency value (0.0 - 1.0). It may be called at any time. \n"
19649 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19650 " alpha, alt_hue_path) \n"
19652 " This function is used in example 30. \n"
19658 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19662 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
19664 " npts (PLINT, input) : number of control points \n"
19666 " intensity (const PLFLT *, input) : position for each control point\n"
19667 " (between 0.0 and 1.0, in ascending order) \n"
19669 " coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n"
19670 " control point \n"
19672 " coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n"
19673 " control point \n"
19675 " coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n"
19676 " control point \n"
19678 " alpha (const PLFLT *, input) : the alpha transparency value for\n"
19679 " each control point \n"
19681 " alt_hue_path (const PLBOOL *, input) : alternative interpolation\n"
19682 " method flag for each control point. (alt_hue_path[i] refers to the\n"
19683 " interpolation interval between the i and i + 1 control points). \n"
19687 "Set number of colors in cmap1 \n"
19691 " Set number of colors in cmap1, (re-)allocate color map1, and set\n"
19692 " default values if this is the first allocation (see the PLplot\n"
19693 " documentation). \n"
19695 " Redacted form: plscmap1n(ncol1)\n"
19697 " This function is used in examples 8,11,20,21. \n"
19703 "plscmap1n(ncol1)\n"
19707 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19708 " the map1 palette. If this number is zero or less, then the value\n"
19709 " from the previous call to plscmap1n is used and if there is no\n"
19710 " previous call, then a default value is used. \n"
19714 "Set the cmap1 argument range for continuous color plots \n"
19718 " Set the cmap1 argument range for continuous color plots. If \n"
19719 " min_color is greater than \n"
19721 " max_color is greater than 1.0 or \n"
19722 " min_color is less than 0.0 then no change is made. (Use\n"
19723 " plgcmap1_range to get the cmap1 argument range.) \n"
19725 " Redacted form: plscmap1_range(min_color, max_color)\n"
19727 " This function is currently used in example 33. \n"
19733 "plscmap1_range(min_color, max_color)\n"
19737 " min_color (PLFLT, input) : The minimum cmap1 floating point\n"
19740 " max_color (PLFLT, input) : The maximum cmap1 floating point\n"
19745 "Get the cmap1 argument range for continuous color plots \n"
19749 " Get the cmap1 argument range for continuous color plots. (Use\n"
19750 " plgsmap1_range to set the cmap1 argument range.) \n"
19752 " Redacted form: plgcmap1_range(min_color, max_color)\n"
19754 " This function is currently not used in any example. \n"
19760 "plgcmap1_range(min_color, max_color)\n"
19764 " min_color (PLFLT *, output) : Pointer to the current minimum cmap1\n"
19765 " floating point argument. \n"
19767 " max_color (PLFLT *, output) : Pointer to the current maximum cmap1\n"
19768 " floating point argument. \n"
19771 { (
char *)
"plscol0",
_wrap_plscol0, METH_VARARGS, (
char *)
"\n"
19772 "Set 8-bit RGB values for given cmap0 color index \n"
19776 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19777 " index. Overwrites the previous color value for the given index and,\n"
19778 " thus, does not result in any additional allocation of space for\n"
19781 " Redacted form: plscol0(icol0, r, g, b)\n"
19783 " This function is used in any example 31. \n"
19789 "lscol0(icol0, r, g, b)\n"
19793 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19794 " number of colors (which is set by default, by plscmap0n, or even\n"
19795 " by plscmap0). \n"
19797 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19798 " degree of red in the color. \n"
19800 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19801 " degree of green in the color. \n"
19803 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19804 " degree of blue in the color. \n"
19807 { (
char *)
"plscol0a",
_wrap_plscol0a, METH_VARARGS, (
char *)
"\n"
19808 "Set 8-bit RGB values and double alpha transparency value for given cmap0 color index \n"
19812 " Set 8-bit RGB value and double alpha transparency value for given\n"
19813 " cmap0 (see the PLplot documentation) index. Overwrites the previous\n"
19814 " color value for the given index and, thus, does not result in any\n"
19815 " additional allocation of space for colors. \n"
19817 " This function is used in example 30. \n"
19823 "lscol0a(icol0, r, g, b, alpha)\n"
19827 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19828 " number of colors (which is set by default, by plscmap0n, or even\n"
19829 " by plscmap0). \n"
19831 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19832 " degree of red in the color. \n"
19834 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19835 " degree of green in the color. \n"
19837 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19838 " degree of blue in the color. \n"
19840 " alpha (PLFLT, input) : double value (0.0-1.0) representing the\n"
19841 " alpha transparency value of the color. \n"
19844 { (
char *)
"plscolbg",
_wrap_plscolbg, METH_VARARGS, (
char *)
"\n"
19845 "Set the background color by 8-bit RGB value \n"
19849 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
19850 " (see the PLplot documentation). \n"
19852 " Redacted form: plscolbg(r, g, b)\n"
19854 " This function is used in examples 15,31. \n"
19860 "plscolbg(r, g, b)\n"
19864 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19865 " degree of red in the color. \n"
19867 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19868 " degree of green in the color. \n"
19870 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19871 " degree of blue in the color. \n"
19875 "Set the background color by 8-bit RGB value and double alpha transparency value. \n"
19879 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
19880 " (see the PLplot documentation) and double alpha transparency value. \n"
19882 " This function is used in example 31. \n"
19888 "plscolbga(r, g, b, alpha)\n"
19892 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19893 " degree of red in the color. \n"
19895 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19896 " degree of green in the color. \n"
19898 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19899 " degree of blue in the color. \n"
19901 " alpha (PLFLT, input) : double value (0.0-1.0) representing the\n"
19902 " alpha transparency value of the color. \n"
19905 { (
char *)
"plscolor",
_wrap_plscolor, METH_VARARGS, (
char *)
"\n"
19906 "Used to globally turn color output on/off \n"
19910 " Used to globally turn color output on/off for those drivers/devices\n"
19911 " that support it. \n"
19913 " Redacted form: plscolor(color)\n"
19915 " This function is used in example 31. \n"
19921 "plscolor(color)\n"
19925 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19926 " turned off. If non-zero, color is turned on. \n"
19930 "Set device-compression level \n"
19934 " Set device-compression level. Only used for drivers that provide\n"
19935 " compression. This function, if used, should be invoked before a call\n"
19938 " Redacted form: plscompression(compression)\n"
19940 " This function is used in example 31. \n"
19946 "plscompression(compression)\n"
19950 " compression (PLINT, input) : The desired compression level. This is\n"
19951 " a device-dependent value. Currently only the jpeg and png devices\n"
19952 " use these values. For jpeg value is the jpeg quality which should\n"
19953 " normally be in the range 0-95. Higher values denote higher quality\n"
19954 " and hence larger image sizes. For png values are in the range -1\n"
19955 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19956 " A value of -1 denotes the default zlib compression level. Values\n"
19957 " in the range 10-99 are divided by 10 and then used as the zlib\n"
19958 " compression level. Higher compression levels correspond to greater\n"
19959 " compression and small file sizes at the expense of more\n"
19963 { (
char *)
"plsdev",
_wrap_plsdev, METH_VARARGS, (
char *)
"\n"
19964 "Set the device (keyword) name \n"
19968 " Set the device (keyword) name. \n"
19970 " Redacted form: plsdev(devname)\n"
19972 " This function is used in examples 1,14,20. \n"
19978 "plsdev(devname)\n"
19982 " devname (const char *, input) : Pointer to device (keyword) name\n"
19986 { (
char *)
"plsdidev",
_wrap_plsdidev, METH_VARARGS, (
char *)
"\n"
19987 "Set parameters that define current device-space window \n"
19991 " Set relative margin width, aspect ratio, and relative justification\n"
19992 " that define current device-space window. If you want to just use the\n"
19993 " previous value for any of these, just pass in the magic value\n"
19994 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19995 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19996 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19997 " to a device-specific value. \n"
19999 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20001 " This function is used in example 31. \n"
20007 "plsdidev(mar, aspect, jx, jy)\n"
20011 " mar (PLFLT, input) : Relative margin width. \n"
20013 " aspect (PLFLT, input) : Aspect ratio. \n"
20015 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20016 " the range -0.5 to 0.5. \n"
20018 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20019 " the range -0.5 to 0.5. \n"
20022 { (
char *)
"plsdimap",
_wrap_plsdimap, METH_VARARGS, (
char *)
"\n"
20023 "Set up transformation from metafile coordinates \n"
20027 " Set up transformation from metafile coordinates. The size of the plot\n"
20028 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20029 " general-purpose facility just yet (not sure why the user would need\n"
20030 " it, for one). \n"
20032 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20035 " This function is not used in any examples. \n"
20041 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20045 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
20047 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
20049 " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
20051 " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
20053 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
20055 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
20058 { (
char *)
"plsdiori",
_wrap_plsdiori, METH_VARARGS, (
char *)
"\n"
20059 "Set plot orientation \n"
20063 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20064 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20065 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20066 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20067 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20068 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20069 " not called the default value of rot is 0. \n"
20071 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20072 " probably want to change the aspect ratio to a value suitable for the\n"
20073 " plot orientation using a call to plsdidev or the command-line options\n"
20074 " -a or -freeaspect. For more documentation of those options see the\n"
20075 " PLplot documentation. Such command-line options can be set internally\n"
20076 " using plsetopt or set directly using the command line and parsed using\n"
20077 " a call to plparseopts. \n"
20079 " Redacted form: plsdiori(rot)\n"
20081 " This function is not used in any examples. \n"
20091 " rot (PLFLT, input) : Plot orientation parameter. \n"
20094 { (
char *)
"plsdiplt",
_wrap_plsdiplt, METH_VARARGS, (
char *)
"\n"
20095 "Set parameters that define current plot-space window \n"
20099 " Set relative minima and maxima that define the current plot-space\n"
20100 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20101 " xmax, and ymax are 0., 0., 1., and 1. \n"
20103 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20105 " This function is used in example 31. \n"
20111 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20115 " xmin (PLFLT, input) : Relative minimum in x. \n"
20117 " ymin (PLFLT, input) : Relative minimum in y. \n"
20119 " xmax (PLFLT, input) : Relative maximum in x. \n"
20121 " ymax (PLFLT, input) : Relative maximum in y. \n"
20124 { (
char *)
"plsdiplz",
_wrap_plsdiplz, METH_VARARGS, (
char *)
"\n"
20125 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
20129 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20130 " the current plot-space window. This function has the same effect as\n"
20131 " plsdiplt if that function has not been previously called. Otherwise,\n"
20132 " this function implements zoom mode using the transformation min_used =\n"
20133 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20134 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20135 " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
20137 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20139 " This function is used in example 31. \n"
20145 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20149 " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
20151 " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
20153 " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
20155 " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
20158 { (
char *)
"plseed",
_wrap_plseed, METH_VARARGS, (
char *)
"\n"
20159 "Set seed for internal random number generator. \n"
20163 " Set the seed for the internal random number generator. See plrandd for\n"
20164 " further details. \n"
20166 " Redacted form: plseed(seed)\n"
20168 " This function is used in example 21. \n"
20178 " seed (unsigned int, input) : Seed for random number generator. \n"
20181 { (
char *)
"plsesc",
_wrap_plsesc, METH_VARARGS, (
char *)
"\n"
20182 "Set the escape character for text strings \n"
20186 " Set the escape character for text strings. From C (in contrast to\n"
20187 " Fortran 95, see plsescfortran95) you pass esc as a character. Only\n"
20188 " selected characters are allowed to prevent the user from shooting\n"
20189 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
20190 " with C's use of backslash as a character escape). Here are the\n"
20191 " allowed escape characters and their corresponding decimal ASCII\n"
20192 " values: !, ASCII 33 \n"
20203 " Redacted form: General: plsesc(esc)\n"
20204 " Perl/PDL: Not available? \n"
20207 " This function is used in example 29. \n"
20217 " esc (char, input) : Escape character. \n"
20220 { (
char *)
"plsetopt",
_wrap_plsetopt, METH_VARARGS, (
char *)
"\n"
20221 "Set any command-line option \n"
20225 " Set any command-line option internally from a program before it\n"
20226 " invokes plinit. opt is the name of the command-line option and optarg\n"
20227 " is the corresponding command-line option argument. \n"
20229 " This function returns 0 on success. \n"
20231 " Redacted form: plsetopt(opt, optarg)\n"
20233 " This function is used in example 14. \n"
20239 "int plsetopt(opt, optarg)\n"
20243 " opt (const char *, input) : Pointer to string containing the\n"
20244 " command-line option. \n"
20246 " optarg (const char *, input) : Pointer to string containing the\n"
20247 " argument of the command-line option. \n"
20250 { (
char *)
"plsfam",
_wrap_plsfam, METH_VARARGS, (
char *)
"\n"
20251 "Set family file parameters \n"
20255 " Sets variables dealing with output file familying. Does nothing if\n"
20256 " familying not supported by the driver. This routine, if used, must be\n"
20257 " called before initializing PLplot. See the PLplot documentation for\n"
20258 " more information. \n"
20260 " Redacted form: plsfam(fam, num, bmax)\n"
20262 " This function is used in examples 14,31. \n"
20268 "plsfam(fam, num, bmax)\n"
20272 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20275 " num (PLINT, input) : Current family file number. \n"
20277 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20281 { (
char *)
"plsfci",
_wrap_plsfci, METH_VARARGS, (
char *)
"\n"
20282 "Set FCI (font characterization integer) \n"
20286 " Sets font characteristics to be used at the start of the next string\n"
20287 " using the FCI approach. See the PLplot documentation for more\n"
20290 " Redacted form: General: plsfci(fci)\n"
20291 " Perl/PDL: Not available? \n"
20294 " This function is used in example 23. \n"
20304 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20308 { (
char *)
"plsfnam",
_wrap_plsfnam, METH_VARARGS, (
char *)
"\n"
20309 "Set output file name \n"
20313 " Sets the current output file name, if applicable. If the file name\n"
20314 " has not been specified and is required by the driver, the user will be\n"
20315 " prompted for it. If using the X-windows output driver, this sets the\n"
20316 " display name. This routine, if used, must be called before\n"
20317 " initializing PLplot. \n"
20319 " Redacted form: plsfnam(fnam)\n"
20321 " This function is used in examples 1,20. \n"
20331 " fnam (const char *, input) : Pointer to file name string. \n"
20334 { (
char *)
"plsfont",
_wrap_plsfont, METH_VARARGS, (
char *)
"\n"
20335 "Set family, style and weight of the current font \n"
20339 " Sets the current font. See the PLplot documentation for more\n"
20340 " information on font selection. \n"
20342 " Redacted form: plsfont(family, style, weight)\n"
20344 " This function is used in example 23. \n"
20350 "plsfont(family, style, weight)\n"
20354 " family (PLINT, input) : Font family to select for the current font.\n"
20355 " The available values are given by the PL_FCI_* constants in\n"
20356 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20357 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20358 " signifies that the font family should not be altered. \n"
20360 " style (PLINT, input) : Font style to select for the current font.\n"
20361 " The available values are given by the PL_FCI_* constants in\n"
20362 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20363 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20364 " should not be altered. \n"
20366 " weight (PLINT, input) : Font weight to select for the current font.\n"
20367 " The available values are given by the PL_FCI_* constants in\n"
20368 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20369 " negative value signifies that the font weight should not be\n"
20373 { (
char *)
"plshades",
_wrap_plshades, METH_VARARGS, (
char *)
"\n"
20374 "Shade regions on the basis of value \n"
20378 " Shade regions on the basis of value. This is the high-level routine\n"
20379 " for making continuous color shaded plots with cmap1 while plshade (or\n"
20380 " plshade1) are used for individual shaded regions using either cmap0 or\n"
20381 " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
20382 " function. See the following discussion of the arguments and the PLplot\n"
20383 " documentation for more information. \n"
20385 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20386 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20388 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
20389 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
20393 " This function is used in examples 16,21. \n"
20399 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20403 " a (const PLFLT * const *, input) : Contains ** pointer to array to\n"
20404 " be plotted. The array must have been declared as PLFLT a[nx][ny]. \n"
20406 " nx (PLINT, input) : First dimension of array \"a\". \n"
20408 " ny (PLINT, input) : Second dimension of array \"a\". \n"
20410 " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
20411 " specifying regions excluded from the shading plot. This function\n"
20412 " accepts x and y coordinates as input arguments and must return 0\n"
20413 " if the point is in the excluded region or 1 otherwise. This\n"
20414 " argument can be NULL if all the values are valid. \n"
20416 " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20417 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20418 " at (xmax,ymin) and so on. \n"
20420 " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20421 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20422 " at (xmax,ymin) and so on. \n"
20424 " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20425 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20426 " at (xmax,ymin) and so on. \n"
20428 " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20429 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20430 " at (xmax,ymin) and so on. \n"
20432 " clevel (const PLFLT *, input) : Pointer to array containing the\n"
20433 " data levels corresponding to the edges of each shaded region that\n"
20434 " will be plotted by this function. To work properly the levels\n"
20435 " should be monotonic. \n"
20437 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20438 " of shade edge values in clevel). \n"
20440 " fill_width (PLFLT, input) : Defines line width used by the fill\n"
20443 " cont_color (PLINT, input) : Defines pen color used for contours\n"
20444 " defining edges of shaded regions. The pen color is only temporary\n"
20445 " set for the contour drawing. Set this value to zero or less if no\n"
20446 " shade edge contours are wanted. \n"
20448 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20449 " defining edges of shaded regions. This value may not be honored\n"
20450 " by all drivers. The pen width is only temporary set for the\n"
20451 " contour drawing. Set this value to zero or less if no shade edge\n"
20452 " contours are wanted. \n"
20454 " fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n"
20455 " Routine used to fill the region. Use plfill. Future version of\n"
20456 " PLplot may have other fill routines. \n"
20458 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20459 " map to rectangles after coordinate transformation with pltrl. \n"
20460 " Otherwise, set rectangular to false. If rectangular is set to\n"
20461 " true, plshade tries to save time by filling large rectangles. \n"
20462 " This optimization fails if the coordinate transformation distorts\n"
20463 " the shape of rectangles. For example a plot in polar coordinates\n"
20464 " has to have rectangular set to false. \n"
20466 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20467 " Pointer to function that defines transformation between indices\n"
20468 " in array z and the world coordinates (C only). Transformation\n"
20469 " functions are provided in the PLplot library: pltr0 for identity\n"
20470 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20471 " defined by one- and two-dimensional arrays. In addition,\n"
20472 " user-supplied routines for the transformation can be used as well.\n"
20473 " Examples of all of these approaches are given in the PLplot\n"
20474 " documentation. The transformation function should have the form\n"
20475 " given by any of pltr0, pltr1, or pltr2. \n"
20477 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20478 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20479 " externally supplied. \n"
20482 { (
char *)
"plshade",
_wrap_plshade, METH_VARARGS, (
char *)
"\n"
20483 "Shade individual region on the basis of value \n"
20487 " Shade individual region on the basis of value. Use plshades if you\n"
20488 " want to shade a number of regions using continuous colors. plshade is\n"
20489 " identical to plshade1 except for the type of the first parameter. See\n"
20490 " plshade1 for further discussion. \n"
20492 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20493 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20494 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20495 " Perl/PDL: Not available? \n"
20498 " This function is used in example 15. \n"
20504 "lshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20508 " a (const PLFLT * const *, input) : \n"
20510 " nx (PLINT, input) : \n"
20512 " ny (PLINT, input) : \n"
20514 " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
20516 " xmin (PLFLT, input) : \n"
20518 " xmax (PLFLT, input) : \n"
20520 " ymin (PLFLT, input) : \n"
20522 " ymax (PLFLT, input) : \n"
20524 " shade_min (PLFLT, input) : \n"
20526 " shade_max (PLFLT, input) : \n"
20528 " sh_cmap (PLINT, input) : \n"
20530 " sh_color (PLFLT, input) : \n"
20532 " sh_width (PLFLT, input) : \n"
20534 " min_color (PLINT, input) : \n"
20536 " min_width (PLFLT, input) : \n"
20538 " max_color (PLINT, input) : \n"
20540 " max_width (PLFLT, input) : \n"
20542 " fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n"
20544 " rectangular (PLBOOL, input) : \n"
20546 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20548 " pltr_data (PLPointer, input) : \n"
20552 "Assign a function to use for generating custom axis labels \n"
20556 " This function allows a user to provide their own function to provide\n"
20557 " axis label text. The user function is given the numeric value for a\n"
20558 " point on an axis and returns a string label to correspond with that\n"
20559 " value. Custom axis labels can be enabled by passing appropriate\n"
20560 " arguments to plenv, plbox, plbox3 and similar functions. \n"
20562 " This function is used in example 19. \n"
20568 "plslabelfunc(label_func, label_data)\n"
20572 " label_func (void (*) (PLINT, PLFLT, char *, PLINT, PLPointer), input)\n"
20573 " : This is the custom label function. In order to reset to the\n"
20574 " default labelling, set this to NULL. The labelling function\n"
20575 " parameters are, in order: axis: This indicates which axis a\n"
20576 " label is being requested for. The value will be one of PL_X_AXIS,\n"
20577 " PL_Y_AXIS or PL_Z_AXIS. \n"
20579 " value: This is the value along the axis which is being labelled. \n"
20581 " label_text: The string representation of the label value. \n"
20583 " length: The maximum length in characters allowed for label_text. \n"
20586 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20587 " data to the label_func function. \n"
20590 { (
char *)
"plsmaj",
_wrap_plsmaj, METH_VARARGS, (
char *)
"\n"
20591 "Set length of major ticks \n"
20595 " This sets up the length of the major ticks. The actual length is the\n"
20596 " product of the default length and a scaling factor as for character\n"
20599 " Redacted form: plsmaj(def, scale)\n"
20601 " This function is used in example 29. \n"
20607 "plsmaj(def, scale)\n"
20611 " def (PLFLT, input) : The default length of a major tick in\n"
20612 " millimeters, should be set to zero if the default length is to\n"
20613 " remain unchanged. \n"
20615 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20616 " actual tick length. \n"
20619 { (
char *)
"plsmem",
_wrap_plsmem, METH_VARARGS, (
char *)
"\n"
20620 "Set the memory area to be plotted (RGB) \n"
20624 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20625 " the dev member of the stream structure. Also set the number of pixels\n"
20626 " in the memory passed in \n"
20627 " plotmem, which is a block of memory \n"
20629 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
20631 " This memory will have to be freed by the user! \n"
20633 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20635 " This function is not used in any examples. \n"
20641 "plsmem(maxx, maxy, plotmem)\n"
20645 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
20647 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
20649 " plotmem (void *, input) : Pointer to the beginning of the\n"
20650 " user-supplied memory area. \n"
20653 { (
char *)
"plsmema",
_wrap_plsmema, METH_VARARGS, (
char *)
"\n"
20654 "Set the memory area to be plotted (RGBA) \n"
20658 " Set the memory area to be plotted (with the memcairo driver) as the\n"
20659 " dev member of the stream structure. Also set the number of pixels in\n"
20660 " the memory passed in \n"
20661 " plotmem, which is a block of memory \n"
20663 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
20665 " This memory will have to be freed by the user! \n"
20667 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20669 " This function is not used in any examples. \n"
20675 "plsmema(maxx, maxy, plotmem)\n"
20679 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
20681 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
20683 " plotmem (void *, input) : Pointer to the beginning of the\n"
20684 " user-supplied memory area. \n"
20687 { (
char *)
"plsmin",
_wrap_plsmin, METH_VARARGS, (
char *)
"\n"
20688 "Set length of minor ticks \n"
20692 " This sets up the length of the minor ticks and the length of the\n"
20693 " terminals on error bars. The actual length is the product of the\n"
20694 " default length and a scaling factor as for character height. \n"
20696 " Redacted form: plsmin(def, scale)\n"
20698 " This function is used in example 29. \n"
20704 "plsmin(def, scale)\n"
20708 " def (PLFLT, input) : The default length of a minor tick in\n"
20709 " millimeters, should be set to zero if the default length is to\n"
20710 " remain unchanged. \n"
20712 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20713 " actual tick length. \n"
20716 { (
char *)
"plsori",
_wrap_plsori, METH_VARARGS, (
char *)
"\n"
20717 "Set orientation \n"
20721 " Set integer plot orientation parameter. This function is identical to\n"
20722 " plsdiori except for the type of the argument, and should be used in\n"
20723 " the same way. See the PLplot documentation for details. \n"
20725 " Redacted form: plsori(ori)\n"
20727 " This function is used in example 3. \n"
20737 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20738 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20742 { (
char *)
"plspage",
_wrap_plspage, METH_VARARGS, (
char *)
"\n"
20743 "Set page parameters \n"
20747 " Sets the page configuration (optional). If an individual parameter is\n"
20748 " zero then that parameter value is not updated. Not all parameters are\n"
20749 " recognized by all drivers and the interpretation is device-dependent.\n"
20750 " The X-window driver uses the length and offset parameters to determine\n"
20751 " the window size and location. The length and offset values are\n"
20752 " expressed in units that are specific to the current driver. For\n"
20753 " instance: screen drivers will usually interpret them as number of\n"
20754 " pixels, whereas printer drivers will usually use mm. This routine, if\n"
20755 " used, must be called before initializing PLplot. \n"
20757 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20759 " This function is used in examples 14 and 31. \n"
20765 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20769 " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
20771 " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
20773 " xleng (PLINT , input) : Page length, x. \n"
20775 " yleng (PLINT, input) : Page length, y. \n"
20777 " xoff (PLINT, input) : Page offset, x. \n"
20779 " yoff (PLINT, input) : Page offset, y. \n"
20782 { (
char *)
"plspal0",
_wrap_plspal0, METH_VARARGS, (
char *)
"\n"
20783 "Set the colors for color table 0 from a cmap0 file \n"
20787 " Set the colors for color table 0 from a cmap0 file \n"
20789 " Redacted form: plspal0(filename)\n"
20791 " This function is in example 16. \n"
20797 "plspal0(filename)\n"
20801 " filename (const char *, input) : The name of the cmap0 file, or a\n"
20802 " empty to string to specify the default cmap0 file. \n"
20805 { (
char *)
"plspal1",
_wrap_plspal1, METH_VARARGS, (
char *)
"\n"
20806 "Set the palette for cmap1 using the specified cmap1*.pal format file \n"
20810 " Set the palette for cmap1 using the specified cmap1*.pal format file. \n"
20812 " Redacted form: plspal1(filename, interpolate)\n"
20814 " This function is used in example 16. \n"
20820 "plspal1(filename, interpolate)\n"
20824 " filename (const char *, input) : The name of the cmap1*.pal file,\n"
20825 " or an empty string to specify the default cmap1.pal file. \n"
20827 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20828 " columns containing the intensity index, r, g, b, alpha and\n"
20829 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20830 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20831 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20832 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20833 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20834 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20835 " are used instead to set the cmap1 palette directly with a call to\n"
20839 { (
char *)
"plspause",
_wrap_plspause, METH_VARARGS, (
char *)
"\n"
20840 "Set the pause (on end-of-page) status \n"
20844 " Set the pause (on end-of-page) status. \n"
20846 " Redacted form: plspause(pause)\n"
20848 " This function is in examples 14,20. \n"
20854 "plspause(pause)\n"
20858 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20859 " end-of-page for those drivers which support this. Otherwise there\n"
20863 { (
char *)
"plsstrm",
_wrap_plsstrm, METH_VARARGS, (
char *)
"\n"
20864 "Set current output stream \n"
20868 " Sets the number of the current output stream. The stream number\n"
20869 " defaults to 0 unless changed by this routine. The first use of this\n"
20870 " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
20872 " Redacted form: plsstrm(strm)\n"
20874 " This function is examples 1,14,20. \n"
20884 " strm (PLINT, input) : The current stream number. \n"
20887 { (
char *)
"plssub",
_wrap_plssub, METH_VARARGS, (
char *)
"\n"
20888 "Set the number of subpages in x and y \n"
20892 " Set the number of subpages in x and y. \n"
20894 " Redacted form: plssub(nx, ny)\n"
20896 " This function is examples 1,2,14,21,25,27. \n"
20906 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20907 " of window columns). \n"
20909 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20910 " of window rows). \n"
20913 { (
char *)
"plssym",
_wrap_plssym, METH_VARARGS, (
char *)
"\n"
20914 "Set symbol size \n"
20918 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20919 " plsym. The actual height of a symbol is the product of the default\n"
20920 " symbol size and a scaling factor as for the character height. \n"
20922 " Redacted form: plssym(def, scale)\n"
20924 " This function is used in example 29. \n"
20930 "plssym(def, scale)\n"
20934 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20935 " should be set to zero if the default height is to remain\n"
20938 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20939 " actual symbol height. \n"
20942 { (
char *)
"plstar",
_wrap_plstar, METH_VARARGS, (
char *)
"\n"
20943 "Initialization \n"
20947 " Initializing the plotting package. The program prompts for the device\n"
20948 " keyword or number of the desired output device. Hitting a RETURN in\n"
20949 " response to the prompt is the same as selecting the first device. If\n"
20950 " only one device is enabled when PLplot is installed, plstar will issue\n"
20951 " no prompt. The output device is divided into nx by ny subpages, each\n"
20952 " of which may be used independently. The subroutine pladv is used to\n"
20953 " advance from one subpage to the next. \n"
20955 " Redacted form: plstar(nx, ny)\n"
20957 " This function is used in example 1. \n"
20967 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20968 " horizontal direction. \n"
20970 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20971 " vertical direction. \n"
20974 { (
char *)
"plstart",
_wrap_plstart, METH_VARARGS, (
char *)
"\n"
20975 "Initialization \n"
20979 " Alternative to plstar for initializing the plotting package. The\n"
20980 " device name keyword for the desired output device must be supplied as\n"
20981 " an argument. These keywords are the same as those printed out by\n"
20982 " plstar. If the requested device is not available, or if the input\n"
20983 " string is empty or begins with ``?'', the prompted start up of plstar\n"
20984 " is used. This routine also divides the output device page into nx by\n"
20985 " ny subpages, each of which may be used independently. The subroutine\n"
20986 " pladv is used to advance from one subpage to the next. \n"
20988 " Redacted form: General: plstart(devname, nx, ny)\n"
20989 " Perl/PDL: plstart(nx, ny, devname)\n"
20992 " This function is not used in any examples. \n"
20998 "plstart(devname, nx, ny)\n"
21002 " devname (const char *, input) : Device name keyword of the required\n"
21003 " output device. If NULL or if the first character is a ``?'', the\n"
21004 " normal (prompted) start up is used. \n"
21006 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21007 " horizontal direction. \n"
21009 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21010 " vertical direction. \n"
21014 "Set a global coordinate transform function \n"
21018 " This function can be used to define a coordinate transformation which\n"
21019 " affects all elements drawn within the current plot window. The\n"
21020 " coordinate_transform function is similar to that provided for the\n"
21021 " plmap and plmeridians functions. The coordinate_transform_data\n"
21022 " parameter may be used to pass extra data to coordinate_transform. \n"
21024 " Redacted form: General: plstransform(coordinate_transform,\n"
21025 " coordinate_transform_data)\n"
21028 " This function is used in examples 19 and 22. \n"
21034 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21038 " coordinate_transform (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *,\n"
21039 " PLPointer) , input) : Pointer to a function that defines a\n"
21040 " transformation from the input (x, y) coordinate to a new plot\n"
21041 " world coordinate. A NULL pointer means that no transform is\n"
21044 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21046 " coordinate_transform. \n"
21049 { (
char *)
"plstring",
_wrap_plstring, METH_VARARGS, (
char *)
"\n"
21050 "Plot a glyph at the specified points \n"
21054 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21055 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21056 " is specified with a PLplot user string. Note that the user string is\n"
21057 " not actually limited to one glyph so it is possible (but not normally\n"
21058 " useful) to plot more than one glyph at the specified points with this\n"
21059 " function. As with plmtex and plptex, the user string can contain FCI\n"
21060 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21061 " else PLplot escapes for Hershey or unicode text to determine the\n"
21064 " Redacted form: plstring(x, y, string)\n"
21066 " This function is used in examples 4, 21 and 26. \n"
21072 "plstring(n, x, y, string)\n"
21076 " n (PLINT, input) : Number of points in the x and y arrays. \n"
21078 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
21081 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
21084 " string (const char *, input) : PLplot user string corresponding to\n"
21085 " the glyph to be plotted at each of the n points. \n"
21089 "Plot a glyph at the specified 3D points \n"
21093 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21094 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21095 " this function similar to what is done for plline3. The glyph is\n"
21096 " specified with a PLplot user string. Note that the user string is not\n"
21097 " actually limited to one glyph so it is possible (but not normally\n"
21098 " useful) to plot more than one glyph at the specified points with this\n"
21099 " function. As with plmtex and plptex, the user string can contain FCI\n"
21100 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21101 " else PLplot escapes for Hershey or unicode text to determine the\n"
21104 " Redacted form: plstring3(x, y, z, string)\n"
21106 " This function is used in example 18. \n"
21112 "plstring3(n, x, y, z, string)\n"
21116 " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
21118 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
21121 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
21124 " z (const PLFLT *, input) : Pointer to an array with Z coordinates\n"
21127 " string (const char *, input) : PLplot user string corresponding to\n"
21128 " the glyph to be plotted at each of the n points. \n"
21131 { (
char *)
"plstripa",
_wrap_plstripa, METH_VARARGS, (
char *)
"\n"
21132 "Add a point to a strip chart \n"
21136 " Add a point to a given pen of a given strip chart. There is no need\n"
21137 " for all pens to have the same number of points or to be equally\n"
21138 " sampled in the x coordinate. Allocates memory and rescales as\n"
21141 " Redacted form: plstripa(id, pen, x, y)\n"
21143 " This function is used in example 17. \n"
21149 "plstripa(id, pen, x, y)\n"
21153 " id (PLINT, input) : Identification number of the strip chart (set\n"
21154 " up in plstripc). \n"
21156 " pen (PLINT, input) : Pen number (ranges from 0 to 3). \n"
21158 " x (PLFLT, input) : X coordinate of point to plot. \n"
21160 " y (PLFLT, input) : Y coordinate of point to plot. \n"
21163 { (
char *)
"plstripc",
_wrap_plstripc, METH_VARARGS, (
char *)
"\n"
21164 "Create a 4-pen strip chart \n"
21168 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21170 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21171 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21172 " styline, legline, labx, laby, labz)\n"
21173 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
21174 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
21175 " ypsec, legline, labx, laby, labtop)\n"
21178 " This function is used in example 17. \n"
21184 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21188 " id (PLINT *, output) : Identification number of strip chart to use\n"
21189 " on plstripa and plstripd. \n"
21191 " xspec (const char *, input) : X-axis specification as in plbox. \n"
21193 " yspec (const char *, input) : Y-axis specification as in plbox. \n"
21195 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21196 " change as data are added. \n"
21198 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21199 " change as data are added. \n"
21201 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21202 " is multiplied by the factor (1 + \n"
21205 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21206 " change as data are added. \n"
21208 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21209 " change as data are added. \n"
21211 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
21213 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
21215 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21216 " true, otherwise not. \n"
21218 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21219 " otherwise slide display. \n"
21221 " colbox (PLINT, input) : Plot box color index (cmap0). \n"
21223 " collab (PLINT, input) : Legend color index (cmap0). \n"
21225 " colline (const PLINT *, input) : Pointer to array with color\n"
21226 " indices (cmap0) for the 4 pens. \n"
21228 " styline (const PLINT *, input) : Pointer to array with line styles\n"
21229 " for the 4 pens. \n"
21231 " legline (const char **, input) : Pointer to character array\n"
21232 " containing legends for the 4 pens. \n"
21234 " labx (const char *, input) : X-axis label. \n"
21236 " laby (const char *, input) : Y-axis label. \n"
21238 " labtop (const char *, input) : Plot title. \n"
21241 { (
char *)
"plstripd",
_wrap_plstripd, METH_VARARGS, (
char *)
"\n"
21242 "Deletes and releases memory used by a strip chart \n"
21246 " Deletes and releases memory used by a strip chart. \n"
21248 " Redacted form: plstripd(id)\n"
21250 " This function is used in example 17. \n"
21260 " id (PLINT, input) : Identification number of strip chart to delete. \n"
21263 { (
char *)
"plstyl",
_wrap_plstyl, METH_VARARGS, (
char *)
"\n"
21264 "Set line style \n"
21268 " This sets up the line style for all lines subsequently drawn. A line\n"
21269 " consists of segments in which the pen is alternately down and up. The\n"
21270 " lengths of these segments are passed in the arrays mark and space\n"
21271 " respectively. The number of mark-space pairs is specified by nms. In\n"
21272 " order to return the line style to the default continuous line, plstyl\n"
21273 " should be called with nms=0 .(see also pllsty) \n"
21275 " Redacted form: plstyl(mark, space)\n"
21277 " This function is used in examples 1,9,14. \n"
21283 "plstyl(nms, mark, space)\n"
21287 " nms (PLINT, input) : The number of mark and space elements in a\n"
21288 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21289 " . A continuous line is specified by setting nms=0 . \n"
21291 " mark (const PLINT *, input) : Pointer to array with the lengths of\n"
21292 " the segments during which the pen is down, measured in\n"
21295 " space (const PLINT *, input) : Pointer to array with the lengths of\n"
21296 " the segments during which the pen is up, measured in micrometers. \n"
21299 { (
char *)
"plsvect",
_wrap_plsvect, METH_VARARGS, (
char *)
"\n"
21300 "Set arrow style for vector plots \n"
21304 " Set the style for the arrow used by plvect to plot vectors. \n"
21306 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21308 " This function is used in example 22. \n"
21314 "plsvect(arrowx, arrowy, npts, fill)\n"
21318 " arrowx, arrowy (const PLFLT *,input) : Pointers to a pair of arrays\n"
21319 " containing the x and y points which make up the arrow. The arrow\n"
21320 " is plotted by joining these points to form a polygon. The scaling\n"
21321 " assumes that the x and y points in the arrow lie in the range -0.5\n"
21322 " <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n"
21323 " style will be reset to its default. \n"
21325 " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
21328 " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
21329 " fill is false then the arrow is open. \n"
21332 { (
char *)
"plsvpa",
_wrap_plsvpa, METH_VARARGS, (
char *)
"\n"
21333 "Specify viewport in absolute coordinates \n"
21337 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21338 " should be used only if the viewport is required to have a definite\n"
21339 " size in millimeters. The routine plgspa is useful for finding out the\n"
21340 " size of the current subpage. \n"
21342 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21344 " This function is used in example 10. \n"
21350 "plsvpa(xmin, xmax, ymin, ymax)\n"
21354 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21355 " viewport from the left-hand edge of the subpage in millimeters. \n"
21357 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21358 " viewport from the left-hand edge of the subpage in millimeters. \n"
21360 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21361 " viewport from the bottom edge of the subpage in millimeters. \n"
21363 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21364 " from the bottom edge of the subpage in millimeters. \n"
21367 { (
char *)
"plsxax",
_wrap_plsxax, METH_VARARGS, (
char *)
"\n"
21368 "Set x axis parameters \n"
21372 " Sets values of the digmax and digits flags for the x axis. See the\n"
21373 " PLplot documentation for more information. \n"
21375 " Redacted form: plsxax(digmax, digits)\n"
21377 " This function is used in example 31. \n"
21383 "plsxax(digmax, digits)\n"
21387 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21388 " digits for the x axis. If nonzero, the printed label will be\n"
21389 " switched to a floating point representation when the number of\n"
21390 " digits exceeds digmax. \n"
21392 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21393 " its value here has no effect since it is set only by plbox or\n"
21394 " plbox3. However, the user may obtain its value after a call to\n"
21395 " either of these functions by calling plgxax. \n"
21398 { (
char *)
"plsyax",
_wrap_plsyax, METH_VARARGS, (
char *)
"\n"
21399 "Set y axis parameters \n"
21403 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21404 " the description of plsxax for more detail. \n"
21406 " Redacted form: plsyax(digmax, digits)\n"
21408 " This function is used in examples 1,14,31. \n"
21414 "plsyax(digmax, digits)\n"
21418 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21419 " digits for the y axis. If nonzero, the printed label will be\n"
21420 " switched to a floating point representation when the number of\n"
21421 " digits exceeds digmax. \n"
21423 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21424 " its value here has no effect since it is set only by plbox or\n"
21425 " plbox3. However, the user may obtain its value after a call to\n"
21426 " either of these functions by calling plgyax. \n"
21429 { (
char *)
"plsym",
_wrap_plsym, METH_VARARGS, (
char *)
"\n"
21430 "Plot a glyph at the specified points \n"
21434 " Plot a glyph at the specified points. (This function is largely\n"
21435 " superseded by plstring which gives access to many[!] more glyphs.) \n"
21437 " Redacted form: plsym(x, y, code)\n"
21439 " This function is used in example 7. \n"
21445 "plsym(n, x, y, code)\n"
21449 " n (PLINT, input) : Number of points in the x and y arrays. \n"
21451 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
21454 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
21457 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21458 " to be plotted at each of the n points. \n"
21461 { (
char *)
"plszax",
_wrap_plszax, METH_VARARGS, (
char *)
"\n"
21462 "Set z axis parameters \n"
21466 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21467 " the description of plsxax for more detail. \n"
21469 " Redacted form: plszax(digmax, digits)\n"
21471 " This function is used in example 31. \n"
21477 "plszax(digmax, digits)\n"
21481 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21482 " digits for the z axis. If nonzero, the printed label will be\n"
21483 " switched to a floating point representation when the number of\n"
21484 " digits exceeds digmax. \n"
21486 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21487 " its value here has no effect since it is set only by plbox or\n"
21488 " plbox3. However, the user may obtain its value after a call to\n"
21489 " either of these functions by calling plgzax. \n"
21492 { (
char *)
"pltext",
_wrap_pltext, METH_VARARGS, (
char *)
"\n"
21493 "Switch to text screen \n"
21497 " Sets an interactive device to text mode, used in conjunction with\n"
21498 " plgra to allow graphics and text to be interspersed. On a device\n"
21499 " which supports separate text and graphics windows, this command causes\n"
21500 " control to be switched to the text window. This can be useful for\n"
21501 " printing diagnostic messages or getting user input, which would\n"
21502 " otherwise interfere with the plots. The program must switch back to\n"
21503 " the graphics window before issuing plot commands, as the text (or\n"
21504 " console) device will probably become quite confused otherwise. If\n"
21505 " already in text mode, this command is ignored. It is also ignored on\n"
21506 " devices which only support a single window or use a different method\n"
21507 " for shifting focus (see also plgra). \n"
21509 " Redacted form: pltext()\n"
21511 " This function is used in example 1. \n"
21521 "Set format for date / time labels \n"
21525 " Sets the format for date / time labels. To enable date / time format\n"
21526 " labels see the options to plbox and plenv. \n"
21528 " Redacted form: pltimefmt(fmt)\n"
21530 " This function is used in example 29. \n"
21540 " fmt (const char *, fmt) : This string is passed directly to the\n"
21541 " system strftime. See the system documentation for a full list of\n"
21542 " conversion specifications for your system. All conversion\n"
21543 " specifications take the form of a '%' character followed by\n"
21544 " further conversion specification character. All other text is\n"
21545 " printed as-is. Common options include: %c: The preferred date and\n"
21546 " time representation for the current locale. \n"
21547 " %d: The day of the month as a decimal number. \n"
21548 " %H: The hour as a decimal number using a 24-hour clock. \n"
21549 " %j: The day of the year as a decimal number. \n"
21550 " %m: The month as a decimal number. \n"
21551 " %M: The minute as a decimal number. \n"
21552 " %S: The second as a decimal number. \n"
21553 " %y: The year as a decimal number without a century. \n"
21554 " %Y: The year as a decimal number including a century. \n"
21557 { (
char *)
"plvasp",
_wrap_plvasp, METH_VARARGS, (
char *)
"\n"
21558 "Specify viewport using aspect ratio only \n"
21562 " Sets the viewport so that the ratio of the length of the y axis to\n"
21563 " that of the x axis is equal to aspect. \n"
21565 " Redacted form: plvasp(aspect)\n"
21567 " This function is used in example 13. \n"
21577 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21581 { (
char *)
"plvect",
_wrap_plvect, METH_VARARGS, (
char *)
"\n"
21586 " Draws a vector plot of the vector (\n"
21592 " ny]) . The scaling factor for the vectors is given by scale. A\n"
21593 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21594 " additional data required by the transformation routine is used to map\n"
21595 " indices within the array to the world coordinates. The style of the\n"
21596 " vector arrow may be set using plsvect. \n"
21598 " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
21600 " This function is used in example 22. \n"
21606 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21610 " u, v (const PLFLT * const *, input) : Pointers to a pair of\n"
21611 " vectored two-dimensional arrays containing the x and y components\n"
21612 " of the vector data to be plotted. \n"
21614 " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
21616 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21617 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21618 " automatically calculated for the data. If scale < 0 then the\n"
21619 " scaling factor is automatically calculated for the data and then\n"
21620 " multiplied by -\n"
21621 " scale. If scale > 0 then the scaling factor is set to scale. \n"
21623 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
21624 " Pointer to function that defines transformation between indices\n"
21625 " in array z and the world coordinates (C only). Transformation\n"
21626 " functions are provided in the PLplot library: pltr0 for identity\n"
21627 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
21628 " defined by one- and two-dimensional arrays. In addition,\n"
21629 " user-supplied routines for the transformation can be used as well.\n"
21630 " Examples of all of these approaches are given in the PLplot\n"
21631 " documentation. The transformation function should have the form\n"
21632 " given by any of pltr0, pltr1, or pltr2. \n"
21634 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21635 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
21636 " externally supplied. \n"
21639 { (
char *)
"plvpas",
_wrap_plvpas, METH_VARARGS, (
char *)
"\n"
21640 "Specify viewport using coordinates and aspect ratio \n"
21644 " Device-independent routine for setting up the viewport. The viewport\n"
21645 " is chosen to be the largest with the given aspect ratio that fits\n"
21646 " within the specified region (in terms of normalized subpage\n"
21647 " coordinates). This routine is functionally equivalent to plvpor when\n"
21648 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21649 " routine reserves no extra space at the edges for labels. \n"
21651 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21653 " This function is used in example 9. \n"
21659 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21663 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21664 " left-hand edge of the viewport. \n"
21666 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21667 " right-hand edge of the viewport. \n"
21669 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21670 " bottom edge of the viewport. \n"
21672 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21673 " edge of the viewport. \n"
21675 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21679 { (
char *)
"plvpor",
_wrap_plvpor, METH_VARARGS, (
char *)
"\n"
21680 "Specify viewport using coordinates \n"
21684 " Device-independent routine for setting up the viewport. This defines\n"
21685 " the viewport in terms of normalized subpage coordinates which run from\n"
21686 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21687 " current subpage. Use the alternate routine plsvpa in order to create\n"
21688 " a viewport of a definite size. \n"
21690 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21692 " This function is used in examples\n"
21693 " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
21699 "plvpor(xmin, xmax, ymin, ymax)\n"
21703 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21704 " left-hand edge of the viewport. \n"
21706 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21707 " right-hand edge of the viewport. \n"
21709 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21710 " bottom edge of the viewport. \n"
21712 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21713 " edge of the viewport. \n"
21716 { (
char *)
"plvsta",
_wrap_plvsta, METH_VARARGS, (
char *)
"\n"
21717 "Select standard viewport \n"
21721 " Sets up a standard viewport, leaving a left-hand margin of seven\n"
21722 " character heights, and four character heights around the other three\n"
21725 " Redacted form: plvsta()\n"
21727 " This function is used in examples 1,12,14,17,25,29. \n"
21736 { (
char *)
"plw3d",
_wrap_plw3d, METH_VARARGS, (
char *)
"\n"
21737 "Set up window for 3-d plotting \n"
21741 " Sets up a window for a three-dimensional surface plot within the\n"
21742 " currently defined two-dimensional window. The enclosing box for the\n"
21743 " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
21744 " user-coordinate space is mapped into a box of world coordinate size\n"
21745 " basex by basey by height so that xmin maps to -\n"
21746 " basex/2 , xmax maps to basex/2 , ymin maps to -\n"
21747 " basey/2 , ymax maps to basey/2 , zmin maps to 0 and zmax maps to\n"
21748 " height. The resulting world-coordinate box is then viewed by an\n"
21749 " observer at altitude alt and azimuth az. This routine must be called\n"
21750 " before plbox3 or plot3d. For a more complete description of\n"
21751 " three-dimensional plotting see the PLplot documentation. \n"
21753 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21754 " zmin, zmax, alt, az)\n"
21756 " This function is examples 8,11,18,21. \n"
21762 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21766 " basex (PLFLT, input) : The x coordinate size of the\n"
21767 " world-coordinate box. \n"
21769 " basey (PLFLT, input) : The y coordinate size of the\n"
21770 " world-coordinate box. \n"
21772 " height (PLFLT, input) : The z coordinate size of the\n"
21773 " world-coordinate box. \n"
21775 " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
21777 " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
21779 " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
21781 " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
21783 " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
21785 " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
21787 " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
21790 " az (PLFLT, input) : The viewing azimuth in degrees. When az=0 ,\n"
21791 " the observer is looking face onto the ZX plane, and as az is\n"
21792 " increased, the observer moves clockwise around the box when viewed\n"
21793 " from above the XY plane. \n"
21796 { (
char *)
"plwidth",
_wrap_plwidth, METH_VARARGS, (
char *)
"\n"
21801 " Sets the pen width. \n"
21803 " Redacted form: plwidth(width)\n"
21805 " This function is used in examples 1,2. \n"
21815 " width (PLFLT, input) : The desired pen width. If width is negative\n"
21816 " or the same as the previous value no action is taken. width = 0. \n"
21817 " should be interpreted as as the minimum valid pen width for the\n"
21818 " device. The interpretation of positive width values is also\n"
21819 " device dependent. \n"
21822 { (
char *)
"plwind",
_wrap_plwind, METH_VARARGS, (
char *)
"\n"
21823 "Specify world coordinates of viewport boundaries \n"
21827 " Sets up the world coordinates of the edges of the viewport. \n"
21829 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21831 " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
21837 "plwind(xmin, xmax, ymin, ymax)\n"
21841 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21842 " of the viewport. \n"
21844 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21845 " of the viewport. \n"
21847 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21848 " the viewport. \n"
21850 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21854 { (
char *)
"plxormod",
_wrap_plxormod, METH_VARARGS, (
char *)
"\n"
21855 "Enter or leave xor mode \n"
21859 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21860 " those drivers (e.g., the xwin driver) that support it. Enables\n"
21861 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21862 " is not capable of xor operation it returns a status of false. \n"
21864 " Redacted form: plxormod(mode, status)\n"
21866 " This function is used in examples 1,20. \n"
21872 "plxormod(mode, status)\n"
21876 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21877 " is false means leave xor mode. \n"
21879 " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
21880 " of true (false) means driver is capable (incapable) of xor mode. \n"
21883 { (
char *)
"plmap",
_wrap_plmap, METH_VARARGS, (
char *)
"\n"
21884 "Plot continental outline or shapefile data in world coordinates \n"
21888 " Plots continental outlines or shapefile data in world coordinates. A\n"
21889 " demonstration of how to use this function to create different \n"
21890 " projections can be found in examples/c/x19c. Plplot is provided with\n"
21891 " basic coastal outlines and USA state borders. These can be used\n"
21892 " irrespective of whether Shapefile support is built into Plplot. With\n"
21893 " Shapefile support this function can also be used with user Shapefiles,\n"
21894 " in which case it will plot the entire contents of a Shapefile joining\n"
21895 " each point of each Shapefile element with a line. Shapefiles have\n"
21896 " become a popular standard for geographical data and data in this\n"
21897 " format can be easily found from a number of online sources. Shapefile\n"
21898 " data is actually provided as three or more files with the same\n"
21899 " filename, but different extensions. The .shp and .shx files are\n"
21900 " required for plotting Shapefile data with Plplot. \n"
21902 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21904 " This function is used in example 19. \n"
21910 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21914 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
21915 " supplied function to transform the original map data coordinates\n"
21916 " to a new coordinate system. The Plplot supplied map data is\n"
21917 " provided as latitudes and longitudes; other Shapefile data may be\n"
21918 " provided in other coordinate systems as can be found in their .prj\n"
21919 " plain text files. For example, by using this transform we can\n"
21920 " change from a longitude, latitude coordinate to a polar\n"
21921 " stereographic projection. Initially, x[0]..[n-1] are the original\n"
21922 " x coordinates (longitudes for the Plplot suplied data) and\n"
21923 " y[0]..y[n-1] are the corresponding y coordinates (latitudes for\n"
21924 " the Plplot supplied data). After the call to mapform(), x[] and\n"
21925 " y[] should be replaced by the corresponding plot coordinates. If\n"
21926 " no transform is desired, mapform can be replaced by NULL. \n"
21928 " name (const char *, input) : A character string which determines\n"
21929 " the type of map plotted. This is either one of the Plplot built\n"
21930 " in maps or the file name of a set of Shapefile files without the\n"
21931 " file extensions. For the Plplot built in maps the possible values\n"
21932 " are: \"globe\" -- continental outlines \n"
21933 " \"usa\" -- USA and state boundaries \n"
21934 " \"cglobe\" -- continental outlines and countries \n"
21935 " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
21938 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21939 " drawn. For the built in maps this is a measure of longitude. For\n"
21940 " Shapefiles the units must match the projection. The value of minx\n"
21941 " must be less than the value of maxx. Specifying a useful limit for\n"
21942 " these limits provides a useful optimization for complex or\n"
21943 " detailed maps. \n"
21945 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
21948 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
21949 " drawn. For the built in maps this is a measure of latitude. For\n"
21950 " Shapefiles the units must match the projection. The value of miny\n"
21951 " must be less than the value of maxy. \n"
21953 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
21958 "Plot all or a subset of Shapefile data using lines in world coordinates \n"
21962 " Plot all or a subset of Shapefile data using lines in world\n"
21963 " coordinates. examples/c/x19c demonstrates how to use this function.\n"
21964 " This function plots data from a Shapefile using lines as in plmap,\n"
21965 " however it also has the option of also only drawing specified elements\n"
21966 " from the Shapefile. The indices of the required elements are passed\n"
21967 " into the function as an array. The Shapefile data should include a\n"
21968 " metadata file (extension.dbf) listing all items within the Shapefile.\n"
21969 " This file can be opened by most popular spreadsheet programs and can\n"
21970 " be used to decide which indices to pass to this function. \n"
21972 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
21975 " This function is used in example 19. \n"
21981 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21985 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
21986 " supplied function to transform the coordinates given in the\n"
21987 " shapefile into a plot coordinate system. By using this transform,\n"
21988 " we can change from a longitude, latitude coordinate to a polar\n"
21989 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
21990 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
21991 " After the call to mapform(), x[] and y[] should be replaced by the\n"
21992 " corresponding plot coordinates. If no transform is desired,\n"
21993 " mapform can be replaced by NULL. \n"
21995 " name (const char *, input) : The file name of a set of Shapefile\n"
21996 " files without the file extension. \n"
21998 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21999 " be in the same units as used by the Shapefile. You could use a\n"
22000 " very large negative number to plot everything, but you can improve\n"
22001 " performance by limiting the area drawn. The units must match those\n"
22002 " of the Shapefile projection, which may be for example longitude or\n"
22003 " distance. The value of minx must be less than the value of maxx. \n"
22005 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22006 " use a very large number to plot everything, but you can improve\n"
22007 " performance by limiting the area drawn. \n"
22009 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22010 " be in the same units as used by the Shapefile. You could use a\n"
22011 " very large negative number to plot everything, but you can improve\n"
22012 " performance by limiting the area drawn. The units must match those\n"
22013 " of the Shapefile projection, which may be for example latitude or\n"
22014 " distance. The value of miny must be less than the value of maxy. \n"
22016 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22017 " use a very large number to plot everything, but you can improve\n"
22018 " performance by limiting the area drawn. \n"
22020 " plotentries (const PLINT *, input) : An array of integers\n"
22021 " indicating the elements of the Shapefile (zero indexed) which will\n"
22022 " be drawn. Setting plotentries to NULL will plot all elements of\n"
22023 " the Shapefile. \n"
22025 " nplotentries (PLINT, input) : The number of items in plotentries.\n"
22026 " Ignored if plotentries is NULL. \n"
22030 "Plot all or a subset of Shapefile data using strings or points in world coordinates \n"
22034 " As per plmapline, however the items are plotted as strings or points\n"
22035 " in the same way as plstring. \n"
22037 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22038 " maxy, plotentries)\n"
22040 " This function is used in example 19. \n"
22046 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22050 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22051 " supplied function to transform the coordinates given in the\n"
22052 " shapefile into a plot coordinate system. By using this transform,\n"
22053 " we can change from a longitude, latitude coordinate to a polar\n"
22054 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22055 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22056 " After the call to mapform(), x[] and y[] should be replaced by the\n"
22057 " corresponding plot coordinates. If no transform is desired,\n"
22058 " mapform can be replaced by NULL. \n"
22060 " name (const char *, input) : The file name of a set of Shapefile\n"
22061 " files without the file extension. \n"
22063 " string (const char *, input) : A NULL terminated string of\n"
22064 " characters to be drawn. \n"
22066 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22067 " be in the same units as used by the Shapefile. You could use a\n"
22068 " very large negative number to plot everything, but you can improve\n"
22069 " performance by limiting the area drawn. The units must match those\n"
22070 " of the Shapefile projection, which may be for example longitude or\n"
22071 " distance. The value of minx must be less than the value of maxx. \n"
22073 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22074 " use a very large number to plot everything, but you can improve\n"
22075 " performance by limiting the area drawn. \n"
22077 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22078 " be in the same units as used by the Shapefile. You could use a\n"
22079 " very large negative number to plot everything, but you can improve\n"
22080 " performance by limiting the area drawn. The units must match those\n"
22081 " of the Shapefile projection, which may be for example latitude or\n"
22082 " distance. The value of miny must be less than the value of maxy. \n"
22084 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22085 " use a very large number to plot everything, but you can improve\n"
22086 " performance by limiting the area drawn. \n"
22088 " plotentries (const PLINT *, input) : An array of integers\n"
22089 " indicating the elements of the Shapefile (zero indexed) which will\n"
22090 " be drawn. Setting plotentries to NULL will plot all elements of\n"
22091 " the Shapefile. \n"
22093 " nplotentries (PLINT, input) : The number of items in plotentries.\n"
22094 " Ignored if plotentries is NULL. \n"
22097 { (
char *)
"plmaptex",
_wrap_plmaptex, METH_VARARGS, (
char *)
"\n"
22098 "Draw text at points defined by Shapefile data in world coordinates \n"
22102 " As per plmapline, however the items are plotted as text in the same\n"
22103 " way as plptex. \n"
22105 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22106 " miny, maxy, plotentry)\n"
22108 " This function is used in example 19. \n"
22114 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22118 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22119 " supplied function to transform the coordinates given in the\n"
22120 " shapefile into a plot coordinate system. By using this transform,\n"
22121 " we can change from a longitude, latitude coordinate to a polar\n"
22122 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22123 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22124 " After the call to mapform(), x[] and y[] should be replaced by the\n"
22125 " corresponding plot coordinates. If no transform is desired,\n"
22126 " mapform can be replaced by NULL. \n"
22128 " name (const char *, input) : The file name of a set of Shapefile\n"
22129 " files without the file extension. \n"
22131 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22134 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22137 " just (PLFLT, input) : Set the justification of the text. The value\n"
22138 " given will be the fraction of the distance along the string that\n"
22139 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22140 " centralized text and 1.0 gives right aligned text. \n"
22142 " text (const char *, input) : A NULL-terminated string of characters\n"
22145 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22146 " be in the same units as used by the Shapefile. You could use a\n"
22147 " very large negative number to plot everything, but you can improve\n"
22148 " performance by limiting the area drawn. The units must match those\n"
22149 " of the Shapefile projection, which may be for example longitude or\n"
22150 " distance. The value of minx must be less than the value of maxx. \n"
22152 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22153 " use a very large number to plot everything, but you can improve\n"
22154 " performance by limiting the area drawn. \n"
22156 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22157 " be in the same units as used by the Shapefile. You could use a\n"
22158 " very large negative number to plot everything, but you can improve\n"
22159 " performance by limiting the area drawn. The units must match those\n"
22160 " of the Shapefile projection, which may be for example latitude or\n"
22161 " distance. The value of miny must be less than the value of maxy. \n"
22163 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22164 " use a very large number to plot everything, but you can improve\n"
22165 " performance by limiting the area drawn. \n"
22167 " plotentry (PLINT, input) : An integer indicating which text string\n"
22168 " of the Shapefile (zero indexed) will be drawn. \n"
22172 "Plot all or a subset of Shapefile data, filling the polygons \n"
22176 " As per plmapline, however the items are filled in the same way as\n"
22179 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22182 " This function is used in example 19. \n"
22188 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22192 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22193 " supplied function to transform the coordinates given in the\n"
22194 " shapefile into a plot coordinate system. By using this transform,\n"
22195 " we can change from a longitude, latitude coordinate to a polar\n"
22196 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22197 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22198 " After the call to mapform(), x[] and y[] should be replaced by the\n"
22199 " corresponding plot coordinates. If no transform is desired,\n"
22200 " mapform can be replaced by NULL. \n"
22202 " name (const char *, input) : The file name of a set of Shapefile\n"
22203 " files without the file extension. \n"
22205 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22206 " be in the same units as used by the Shapefile. You could use a\n"
22207 " very large negative number to plot everything, but you can improve\n"
22208 " performance by limiting the area drawn. The units must match those\n"
22209 " of the Shapefile projection, which may be for example longitude or\n"
22210 " distance. The value of minx must be less than the value of maxx. \n"
22212 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22213 " use a very large number to plot everything, but you can improve\n"
22214 " performance by limiting the area drawn. \n"
22216 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22217 " be in the same units as used by the Shapefile. You could use a\n"
22218 " very large negative number to plot everything, but you can improve\n"
22219 " performance by limiting the area drawn. The units must match those\n"
22220 " of the Shapefile projection, which may be for example latitude or\n"
22221 " distance. The value of miny must be less than the value of maxy. \n"
22223 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22224 " use a very large number to plot everything, but you can improve\n"
22225 " performance by limiting the area drawn. \n"
22227 " plotentries (const PLINT *, input) : An array of integers\n"
22228 " indicating the elements of the Shapefile (zero indexed) which will\n"
22229 " be drawn. Setting plotentries to NULL will plot all elements of\n"
22230 " the Shapefile. \n"
22232 " nplotentries (PLINT, input) : The number of items in plotentries.\n"
22233 " Ignored if plotentries is NULL. \n"
22237 "Plot latitude and longitude lines \n"
22241 " Displays latitude and longitude on the current plot. The lines are\n"
22242 " plotted in the current color and line style. \n"
22244 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22245 " minlat, maxlat)\n"
22247 " This function is used in example 19. \n"
22253 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22257 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22258 " supplied function to transform the coordinate longitudes and\n"
22259 " latitudes to a plot coordinate system. By using this transform, we\n"
22260 " can change from a longitude, latitude coordinate to a polar\n"
22261 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22262 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22263 " After the call to mapform(), x[] and y[] should be replaced by the\n"
22264 " corresponding plot coordinates. If no transform is desired,\n"
22265 " mapform can be replaced by NULL. \n"
22267 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22268 " longitude lines are to be plotted. \n"
22270 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22271 " lines are to be plotted. \n"
22273 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22274 " side of the plot. The value of minlong must be less than the value\n"
22275 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22276 " equal to 360. \n"
22278 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22279 " side of the plot. \n"
22281 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22282 " background. One can always use -90.0 as the boundary outside the\n"
22283 " plot window will be automatically eliminated. However, the\n"
22284 " program will be faster if one can reduce the size of the\n"
22285 " background plotted. \n"
22287 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22288 " background. One can always use 90.0 as the boundary outside the\n"
22289 " plot window will be automatically eliminated. \n"
22292 { (
char *)
"plimage",
_wrap_plimage, METH_VARARGS, (
char *)
"\n"
22293 "Plot a 2D matrix using cmap1 with automatic colour adjustment \n"
22297 " Plot a 2D matrix using color palette 1. The color scale is\n"
22298 " automatically adjusted to use the maximum and minimum values in idata\n"
22299 " as valuemin and valuemax in a call to plimagefr. \n"
22301 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22302 " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
22305 " This function is used in example 20. \n"
22311 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22315 " idata (const PLFLT * const *, input) : A 2D array of values\n"
22316 " (intensities) to plot. Should have dimensions idata[nx][ny]. \n"
22318 " nx, ny (PLINT, input) : Dimensions of idata \n"
22320 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to stretch\n"
22321 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
22322 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
22324 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22325 " (inclusive) will be plotted. \n"
22327 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22328 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22329 " Dymin) to (Dxmax, Dymax). \n"
22333 "Plot a 2D matrix using cmap1 \n"
22337 " Plot a 2D matrix using cmap1. \n"
22339 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
22340 " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
22343 " This function is used in example 20. \n"
22349 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22353 " idata (const PLFLT * const *, input) : A 2D array of values\n"
22354 " (intensities) to plot. Should have dimensions idata[nx][ny]. \n"
22356 " nx, ny (PLINT, input) : Dimensions of idata \n"
22358 " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
22359 " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
22360 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
22362 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22363 " (inclusive) will be plotted. \n"
22365 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22366 " values to use for value to color mappings. A datum equal to or\n"
22367 " less than valuemin will be plotted with color 0.0, while a datum\n"
22368 " equal to or greater than valuemax will be plotted with color 1.0. \n"
22369 " Data between valuemin and valuemax map linearly to colors between\n"
22372 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
22373 " Pointer to function that defines a transformation between the\n"
22374 " data in the array idata and world coordinates. An input\n"
22375 " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
22376 " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
22377 " Some transformation functions are provided in the PLplot library:\n"
22378 " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
22379 " mappings respectively defined by one- and two-dimensional arrays. \n"
22380 " In addition, user-supplied routines for the transformation can be\n"
22381 " used as well. Examples of all of these approaches are given in\n"
22382 " the PLplot documentation. The transformation function should have\n"
22383 " the form given by any of pltr0, pltr1, or pltr2. \n"
22385 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22386 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22387 " externally supplied. \n"
22396 { NULL, NULL, 0, NULL }
22470 {0, 0, 0, 0.0, 0, 0}};
22524 #define SWIGRUNTIME_DEBUG
22534 clientdata = clientdata;
22537 if (swig_module.
next==0) {
22549 if (!module_head) {
22559 if (iter==&swig_module) {
22564 }
while (iter!= module_head);
22569 swig_module.
next = module_head->
next;
22577 if (init == 0)
return;
22580 #ifdef SWIGRUNTIME_DEBUG
22581 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
22583 for (i = 0; i < swig_module.
size; ++i) {
22588 #ifdef SWIGRUNTIME_DEBUG
22589 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
22593 if (swig_module.
next != &swig_module) {
22598 #ifdef SWIGRUNTIME_DEBUG
22599 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
22603 #ifdef SWIGRUNTIME_DEBUG
22604 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
22613 while (cast->
type) {
22616 #ifdef SWIGRUNTIME_DEBUG
22617 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
22619 if (swig_module.
next != &swig_module) {
22621 #ifdef SWIGRUNTIME_DEBUG
22622 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
22627 #ifdef SWIGRUNTIME_DEBUG
22628 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
22635 #ifdef SWIGRUNTIME_DEBUG
22636 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
22638 if (!ocast) ret = 0;
22643 #ifdef SWIGRUNTIME_DEBUG
22644 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
22655 swig_module.
types[i] = type;
22657 swig_module.
types[i] = 0;
22659 #ifdef SWIGRUNTIME_DEBUG
22660 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
22661 for (i = 0; i < swig_module.
size; ++i) {
22664 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
22665 while (cast->
type) {
22666 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
22670 printf(
"---- Total casts: %d\n",j);
22672 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
22685 static int init_run = 0;
22687 if (init_run)
return;
22690 for (i = 0; i < swig_module.
size; i++) {
22698 equiv = equiv->
next;
22719 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22720 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22721 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22741 #if PY_VERSION_HEX >= 0x03000000
22742 return PyUnicode_InternFromString(
"<Swig global variables>");
22744 return PyString_FromString(
"<Swig global variables>");
22750 #if PY_VERSION_HEX >= 0x03000000
22751 PyObject *str = PyUnicode_InternFromString(
"(");
22755 for (var = v->
vars; var; var=var->
next) {
22756 tail = PyUnicode_FromString(var->
name);
22757 joined = PyUnicode_Concat(str, tail);
22762 tail = PyUnicode_InternFromString(
", ");
22763 joined = PyUnicode_Concat(str, tail);
22769 tail = PyUnicode_InternFromString(
")");
22770 joined = PyUnicode_Concat(str, tail);
22775 PyObject *str = PyString_FromString(
"(");
22777 for (var = v->
vars; var; var=var->
next) {
22778 PyString_ConcatAndDel(&str,PyString_FromString(var->
name));
22779 if (var->
next) PyString_ConcatAndDel(&str,PyString_FromString(
", "));
22781 PyString_ConcatAndDel(&str,PyString_FromString(
")"));
22790 fprintf(fp,
"Swig global variables ");
22810 PyObject *res = NULL;
22813 if (strcmp(var->
name,n) == 0) {
22819 if (res == NULL && !PyErr_Occurred()) {
22820 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
22830 if (strcmp(var->
name,n) == 0) {
22836 if (res == 1 && !PyErr_Occurred()) {
22837 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
22844 static char varlink__doc__[] =
"Swig var link object";
22845 static PyTypeObject varlink_type;
22846 static int type_init = 0;
22848 const PyTypeObject tmp = {
22850 #if PY_VERSION_HEX >= 0x03000000
22851 PyVarObject_HEAD_INIT(NULL, 0)
22853 PyObject_HEAD_INIT(NULL)
22856 (
char *)
"swigvarlink",
22880 #if PY_VERSION_HEX >= 0x02020000
22881 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
22883 #if PY_VERSION_HEX >= 0x02030000
22886 #if PY_VERSION_HEX >= 0x02060000
22889 #ifdef COUNT_ALLOCS
22893 varlink_type = tmp;
22895 #if PY_VERSION_HEX < 0x02020000
22896 varlink_type.ob_type = &PyType_Type;
22898 if (PyType_Ready(&varlink_type) < 0)
22902 return &varlink_type;
22912 return ((PyObject*) result);
22920 size_t size = strlen(name)+1;
22921 gv->
name = (
char *)malloc(size);
22923 strncpy(gv->
name,name,size);
22934 static PyObject *_SWIG_globals = 0;
22936 return _SWIG_globals;
22948 for (i = 0; constants[i].
type; ++i) {
22949 switch(constants[i].type) {
22954 obj =
SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22961 PyDict_SetItemString(d, constants[i].name, obj);
22977 for (i = 0; methods[i].ml_name; ++i) {
22978 const char *c = methods[i].ml_doc;
22979 if (c && (c = strstr(c,
"swig_ptr: "))) {
22982 const char *name = c + 10;
22983 for (j = 0; const_table[j].
type; ++j) {
22984 if (strncmp(const_table[j].name, name,
22985 strlen(const_table[j].name)) == 0) {
22986 ci = &(const_table[j]);
22993 size_t shift = (ci->
ptype) - types;
22995 size_t ldoc = (c - methods[i].ml_doc);
22996 size_t lptr = strlen(ty->
name)+2*
sizeof(
void*)+2;
22997 char *ndoc = (
char*)malloc(ldoc + lptr + 10);
23000 strncpy(buff, methods[i].ml_doc, ldoc);
23002 strncpy(buff,
"swig_ptr: ", 10);
23005 methods[i].ml_doc = ndoc;
23026 #if PY_VERSION_HEX >= 0x03000000
23032 PyObject *m, *d, *md;
23033 #if PY_VERSION_HEX >= 0x03000000
23034 static struct PyModuleDef SWIG_module = {
23035 # if PY_VERSION_HEX >= 0x03020000
23036 PyModuleDef_HEAD_INIT,
23039 PyObject_HEAD_INIT(NULL)
23056 #if defined(SWIGPYTHON_BUILTIN)
23058 0, 0, 0, 0, 0, 0, 0
23060 static PyGetSetDef this_getset_def = {
23061 (
char *)
"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23063 static SwigPyGetSet thisown_getset_closure = {
23067 static PyGetSetDef thisown_getset_def = {
23068 (
char *)
"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23070 PyObject *metatype_args;
23071 PyTypeObject *builtin_pytype;
23072 int builtin_base_count;
23075 PyGetSetDescrObject *static_getset;
23076 PyTypeObject *metatype;
23078 PyObject *public_interface, *public_symbol;
23079 PyObject *this_descr;
23080 PyObject *thisown_descr;
23083 (
void)builtin_pytype;
23084 (
void)builtin_base_count;
23085 (
void)builtin_basetype;
23087 (
void)static_getset;
23090 metatype_args = Py_BuildValue(
"(s(O){})",
"SwigPyObjectType", &PyType_Type);
23091 assert(metatype_args);
23092 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
23094 Py_DECREF(metatype_args);
23095 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
23096 assert(PyType_Ready(metatype) >= 0);
23102 #if PY_VERSION_HEX >= 0x03000000
23103 m = PyModule_Create(&SWIG_module);
23105 m = Py_InitModule((
char *)
SWIG_name, SwigMethods);
23107 md = d = PyModule_GetDict(m);
23111 #ifdef SWIGPYTHON_BUILTIN
23113 assert(SwigPyObject_stype);
23116 SwigPyObject_stype->
clientdata = &SwigPyObject_clientdata;
23119 PyErr_SetString(PyExc_RuntimeError,
"Import error: attempted to load two incompatible swig-generated modules.");
23120 # if PY_VERSION_HEX >= 0x03000000
23133 (
void)thisown_descr;
23135 public_interface = PyList_New(0);
23137 (
void)public_symbol;
23139 PyDict_SetItemString(md,
"__all__", public_interface);
23140 Py_DECREF(public_interface);
23141 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23142 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23144 SwigPyBuiltin_AddPublicSymbol(public_interface,
swig_const_table[i].name);
23311 #if PY_VERSION_HEX >= 0x03000000