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(r) (r)
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 != 0 && *ne) {
369 for (nb = ne; *ne; ++ne) {
370 if (*ne ==
'|')
break;
395 if (strcmp(iter->
type->
name, c) == 0) {
396 if (iter == ty->
cast)
422 if (iter->
type == from) {
423 if (iter == ty->
cast)
455 if (!ty || !ty->
dcast)
return ty;
456 while (ty && (ty->
dcast)) {
457 ty = (*ty->
dcast)(ptr);
481 if (!type)
return NULL;
482 if (type->
str != NULL) {
483 const char *last_name = type->
str;
485 for (s = type->
str; *s; s++)
486 if (*s ==
'|') last_name = s+1;
533 register size_t l = 0;
534 register size_t r = iter->
size - 1;
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->
types[i]->
name;
540 register int compare = strcmp(name, iname);
542 return iter->
types[i];
543 }
else if (compare < 0) {
549 }
else if (compare > 0) {
558 }
while (iter != end);
584 register size_t i = 0;
585 for (; i < iter->
size; ++i) {
587 return iter->
types[i];
590 }
while (iter != end);
602 static const char hex[17] =
"0123456789abcdef";
603 register const unsigned char *u = (
unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
618 register unsigned char *u = (
unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >=
'0') && (d <=
'9'))
624 uu = ((d -
'0') << 4);
625 else if ((d >=
'a') && (d <=
'f'))
626 uu = ((d - (
'a'-10)) << 4);
630 if ((d >=
'0') && (d <=
'9'))
632 else if ((d >=
'a') && (d <=
'f'))
633 uu |= (d - (
'a'-10));
647 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
650 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
658 if (strcmp(c,
"NULL") == 0) {
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz)
return 0;
676 strncpy(r,name,lname+1);
686 if (strcmp(c,
"NULL") == 0) {
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
718 #if PY_VERSION_HEX >= 0x03000000
720 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
721 #define PyInt_Check(x) PyLong_Check(x)
722 #define PyInt_AsLong(x) PyLong_AsLong(x)
723 #define PyInt_FromLong(x) PyLong_FromLong(x)
724 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
725 #define PyString_Check(name) PyBytes_Check(name)
726 #define PyString_FromString(x) PyUnicode_FromString(x)
727 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
728 #define PyString_AsString(str) PyBytes_AsString(str)
729 #define PyString_Size(str) PyBytes_Size(str)
730 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
731 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
732 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
733 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
738 # define Py_TYPE(op) ((op)->ob_type)
743 #if PY_VERSION_HEX >= 0x03000000
744 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
746 # define SWIG_Python_str_FromFormat PyString_FromFormat
756 #if PY_VERSION_HEX >= 0x03000000
760 str = PyUnicode_AsUTF8String(str);
761 PyBytes_AsStringAndSize(str, &cstr, &len);
762 newstr = (
char *) malloc(len+1);
763 memcpy(newstr, cstr, len+1);
767 return PyString_AsString(str);
771 #if PY_VERSION_HEX >= 0x03000000
772 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
774 # define SWIG_Python_str_DelForPy3(x)
781 #if PY_VERSION_HEX >= 0x03000000
782 return PyUnicode_FromString(c);
784 return PyString_FromString(c);
789 #if PY_VERSION_HEX < 0x02020000
790 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
791 # define PyOS_snprintf _snprintf
793 # define PyOS_snprintf snprintf
798 #if PY_VERSION_HEX < 0x02020000
800 #ifndef SWIG_PYBUFFER_SIZE
801 # define SWIG_PYBUFFER_SIZE 1024
810 res = vsnprintf(buf,
sizeof(buf), fmt, ap);
812 return (res < 0 || res >= (
int)
sizeof(buf)) ? 0 : PyString_FromString(buf);
817 #if PY_VERSION_HEX < 0x01060000
818 # define PyObject_Del(op) PyMem_DEL((op))
821 # define PyObject_DEL PyObject_Del
825 #if PY_VERSION_HEX < 0x02020000
826 # ifndef PyExc_StopIteration
827 # define PyExc_StopIteration PyExc_RuntimeError
829 # ifndef PyObject_GenericGetAttr
830 # define PyObject_GenericGetAttr 0
835 #if PY_VERSION_HEX < 0x02010000
836 # ifndef Py_NotImplemented
837 # define Py_NotImplemented PyExc_RuntimeError
842 #if PY_VERSION_HEX < 0x02010000
843 # ifndef PyString_AsStringAndSize
844 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
849 #if PY_VERSION_HEX < 0x02000000
850 # ifndef PySequence_Size
851 # define PySequence_Size PySequence_Length
856 #if PY_VERSION_HEX < 0x02030000
860 PyObject *result = ok ? Py_True : Py_False;
869 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
871 # define PY_SSIZE_T_MAX INT_MAX
872 # define PY_SSIZE_T_MIN INT_MIN
885 PyObject *i = PyNumber_Int(x);
887 result = PyInt_AsLong(i);
894 #if PY_VERSION_HEX < 0x02050000
895 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
898 #if PY_VERSION_HEX < 0x02040000
899 #define Py_VISIT(op) \
902 int vret = visit((op), arg); \
909 #if PY_VERSION_HEX < 0x02030000
920 #if PY_VERSION_HEX < 0x02030000
924 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
925 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
926 (PY_MAJOR_VERSION > 3))
927 # define SWIGPY_USE_CAPSULE
928 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
931 #if PY_VERSION_HEX < 0x03020000
932 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
933 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
945 type = PyExc_MemoryError;
948 type = PyExc_IOError;
951 type = PyExc_RuntimeError;
954 type = PyExc_IndexError;
957 type = PyExc_TypeError;
960 type = PyExc_ZeroDivisionError;
963 type = PyExc_OverflowError;
966 type = PyExc_SyntaxError;
969 type = PyExc_ValueError;
972 type = PyExc_SystemError;
975 type = PyExc_AttributeError;
978 type = PyExc_RuntimeError;
989 PyObject *traceback = 0;
991 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
994 PyObject *old_str = PyObject_Str(value);
1003 PyErr_SetString(PyExc_RuntimeError, mesg);
1007 #if defined(SWIG_PYTHON_NO_THREADS)
1008 # if defined(SWIG_PYTHON_THREADS)
1009 # undef SWIG_PYTHON_THREADS
1012 #if defined(SWIG_PYTHON_THREADS)
1013 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1014 # if (PY_VERSION_HEX >= 0x02030000)
1015 # define SWIG_PYTHON_USE_GIL
1018 # if defined(SWIG_PYTHON_USE_GIL)
1019 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1020 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1023 class SWIG_Python_Thread_Block {
1025 PyGILState_STATE state;
1027 void end() {
if (status) { PyGILState_Release(state); status =
false;} }
1028 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1029 ~SWIG_Python_Thread_Block() { end(); }
1031 class SWIG_Python_Thread_Allow {
1033 PyThreadState *save;
1035 void end() {
if (status) { PyEval_RestoreThread(save); status =
false; }}
1036 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1037 ~SWIG_Python_Thread_Allow() { end(); }
1039 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1040 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1041 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1042 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1044 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1045 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1046 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1047 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1050 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1051 # define SWIG_PYTHON_INITIALIZE_THREADS
1053 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1054 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1056 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1057 # define SWIG_PYTHON_THREAD_END_BLOCK
1059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1060 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1062 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1063 # define SWIG_PYTHON_THREAD_END_ALLOW
1067 # define SWIG_PYTHON_INITIALIZE_THREADS
1068 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1069 # define SWIG_PYTHON_THREAD_END_BLOCK
1070 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1071 # define SWIG_PYTHON_THREAD_END_ALLOW
1087 #define SWIG_PY_POINTER 4
1088 #define SWIG_PY_BINARY 5
1105 #if PY_VERSION_HEX >= 0x03000000
1108 return PyInstanceMethod_New(func);
1134 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1135 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1136 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1138 #ifdef SWIGPYTHON_BUILTIN
1139 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1141 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1144 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1146 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1147 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1148 #define swig_owntype int
1151 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1152 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1155 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1156 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1159 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1160 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1163 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1164 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1169 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1170 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1171 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1173 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1174 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1175 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1176 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1177 #define SWIG_fail goto fail
1187 PyErr_SetObject(errtype, obj);
1195 PyErr_SetString(errtype, msg);
1199 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1203 #if defined(SWIGPYTHON_BUILTIN)
1206 SwigPyBuiltin_AddPublicSymbol(PyObject *seq,
const char *key) {
1207 PyObject *s = PyString_InternFromString(key);
1208 PyList_Append(seq, s);
1214 #if PY_VERSION_HEX < 0x02030000
1215 PyDict_SetItemString(d, (
char *)name, obj);
1217 PyDict_SetItemString(d, name, obj);
1220 if (public_interface)
1221 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1228 #if PY_VERSION_HEX < 0x02030000
1229 PyDict_SetItemString(d, (
char *)name, obj);
1231 PyDict_SetItemString(d, name, obj);
1242 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1245 }
else if (result == Py_None) {
1249 if (!PyList_Check(result)) {
1250 PyObject *o2 = result;
1251 result = PyList_New(1);
1252 PyList_SetItem(result, 0, o2);
1254 PyList_Append(result,obj);
1263 }
else if (result == Py_None) {
1267 if (!PyTuple_Check(result)) {
1269 result = PyTuple_New(1);
1270 PyTuple_SET_ITEM(result, 0, o2);
1272 o3 = PyTuple_New(1);
1273 PyTuple_SET_ITEM(o3, 0, obj);
1275 result = PySequence_Concat(o2, o3);
1292 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got none",
1293 name, (min == max ?
"" :
"at least "), (
int)min);
1297 if (!PyTuple_Check(args)) {
1298 if (min <= 1 && max >= 1) {
1301 for (i = 1; i <
max; ++i) {
1306 PyErr_SetString(PyExc_SystemError,
"UnpackTuple() argument list is not a tuple");
1309 register Py_ssize_t l = PyTuple_GET_SIZE(args);
1311 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1312 name, (min == max ?
"" :
"at least "), (
int)min, (
int)l);
1314 }
else if (l > max) {
1315 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1316 name, (min == max ?
"" :
"at most "), (
int)max, (
int)l);
1320 for (i = 0; i < l; ++i) {
1321 objs[i] = PyTuple_GET_ITEM(args, i);
1323 for (; l <
max; ++l) {
1332 #if PY_VERSION_HEX >= 0x02020000
1333 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1335 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1343 #define SWIG_STATIC_POINTER(var) var
1345 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1353 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1354 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1356 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1358 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1359 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1366 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1367 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1368 # ifndef SWIG_PYTHON_BUILD_NONE
1369 # define SWIG_PYTHON_BUILD_NONE
1374 #ifdef SWIG_PYTHON_BUILD_NONE
1377 # define Py_None SWIG_Py_None()
1382 PyObject *none = Py_BuildValue((
char*)
"");
1399 PyObject *none = Py_None;
1426 PyObject *klass = data ? data->
klass : 0;
1427 return (klass ? klass : PyExc_RuntimeError);
1440 Py_INCREF(data->
klass);
1442 if (PyClass_Check(obj)) {
1447 #if (PY_VERSION_HEX < 0x02020000)
1450 data->
newraw = PyObject_GetAttrString(data->
klass, (
char *)
"__new__");
1454 data->
newargs = PyTuple_New(1);
1455 PyTuple_SetItem(data->
newargs, 0, obj);
1462 data->
destroy = PyObject_GetAttrString(data->
klass, (
char *)
"__swig_destroy__");
1463 if (PyErr_Occurred()) {
1470 flags = PyCFunction_GET_FLAGS(data->
destroy);
1472 data->
delargs = !(flags & (METH_O));
1487 Py_XDECREF(data->
newraw);
1500 #ifdef SWIGPYTHON_BUILTIN
1508 return PyLong_FromVoidPtr(v->
ptr);
1514 PyObject *res = NULL;
1515 PyObject *args = PyTuple_New(1);
1520 #if PY_VERSION_HEX >= 0x03000000
1521 res = PyUnicode_Format(ofmt,args);
1523 res = PyString_Format(ofmt,args);
1560 # if PY_VERSION_HEX >= 0x03000000
1561 PyObject *joined = PyUnicode_Concat(repr, nrep);
1566 PyString_ConcatAndDel(&repr,nrep);
1605 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1613 if( op != Py_EQ && op != Py_NE ) {
1624 #ifdef SWIGPYTHON_BUILTIN
1629 assert(SwigPyObject_stype);
1645 #ifdef SWIGPYTHON_BUILTIN
1647 if (PyType_IsSubtype(op->ob_type, target_tp))
1649 return (strcmp(op->ob_type->tp_name,
"SwigPyObject") == 0);
1652 || (strcmp(
Py_TYPE(op)->tp_name,
"SwigPyObject") == 0);
1663 PyObject *next = sobj->
next;
1677 PyCFunction meth = PyCFunction_GET_FUNCTION(
destroy);
1678 PyObject *mself = PyCFunction_GET_SELF(
destroy);
1679 res = ((*meth)(mself, v));
1683 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1686 printf(
"swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name :
"unknown"));
1700 if (!PyArg_ParseTuple(next,(
char *)
"O:append", &tmp))
return NULL;
1720 Py_INCREF(sobj->
next);
1755 #if (PY_VERSION_HEX < 0x02020000)
1756 if (!PyArg_ParseTuple(args,(
char *)
"|O:own",&val))
1757 #elif (PY_VERSION_HEX < 0x02050000)
1758 if (!PyArg_UnpackTuple(args, (
char *)
"own", 0, 1, &val))
1760 if (!PyArg_UnpackTuple(args,
"own", 0, 1, &val))
1771 if (PyObject_IsTrue(val)) {
1777 if (PyObject_IsTrue(val)) {
1791 {(
char *)
"disown", (PyCFunction)
SwigPyObject_disown, METH_NOARGS, (
char *)
"releases ownership of the pointer"},
1792 {(
char *)
"acquire", (PyCFunction)
SwigPyObject_acquire, METH_NOARGS, (
char *)
"acquires ownership of the pointer"},
1793 {(
char *)
"own", (PyCFunction)
SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1794 {(
char *)
"append", (PyCFunction)
SwigPyObject_append, METH_O, (
char *)
"appends another 'this' object"},
1795 {(
char *)
"next", (PyCFunction)
SwigPyObject_next, METH_NOARGS, (
char *)
"returns the next 'this' object"},
1796 {(
char *)
"__repr__",(PyCFunction)
SwigPyObject_repr, METH_NOARGS, (
char *)
"returns object representation"},
1801 swigobject_methods[] = {
1802 {(
char *)
"disown", (PyCFunction)
SwigPyObject_disown, METH_VARARGS, (
char *)
"releases ownership of the pointer"},
1803 {(
char *)
"acquire", (PyCFunction)
SwigPyObject_acquire, METH_VARARGS, (
char *)
"aquires ownership of the pointer"},
1804 {(
char *)
"own", (PyCFunction)
SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1805 {(
char *)
"append", (PyCFunction)
SwigPyObject_append, METH_VARARGS, (
char *)
"appends another 'this' object"},
1806 {(
char *)
"next", (PyCFunction)
SwigPyObject_next, METH_VARARGS, (
char *)
"returns the next 'this' object"},
1807 {(
char *)
"__repr__",(PyCFunction)
SwigPyObject_repr, METH_VARARGS, (
char *)
"returns object representation"},
1812 #if PY_VERSION_HEX < 0x02020000
1816 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1822 static char swigobject_doc[] =
"Swig object carries a C/C++ instance pointer";
1824 static PyNumberMethods SwigPyObject_as_number = {
1829 #
if PY_VERSION_HEX < 0x03000000
1845 #
if PY_VERSION_HEX < 0x03000000
1849 #if PY_VERSION_HEX < 0x03000000
1855 #if PY_VERSION_HEX < 0x03000000
1859 #if PY_VERSION_HEX >= 0x03000000
1860 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1861 #elif PY_VERSION_HEX >= 0x02050000
1862 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1863 #elif PY_VERSION_HEX >= 0x02020000
1864 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1865 #elif PY_VERSION_HEX >= 0x02000000
1866 0,0,0,0,0,0,0,0,0,0,0
1870 static PyTypeObject swigpyobject_type;
1871 static int type_init = 0;
1873 const PyTypeObject tmp = {
1875 #if PY_VERSION_HEX >= 0x03000000
1876 PyVarObject_HEAD_INIT(NULL, 0)
1878 PyObject_HEAD_INIT(NULL)
1881 (
char *)
"SwigPyObject",
1886 #if PY_VERSION_HEX < 0x02020000
1892 #
if PY_VERSION_HEX >= 0x03000000
1898 &SwigPyObject_as_number,
1913 #
if PY_VERSION_HEX >= 0x02020000
1935 #
if PY_VERSION_HEX >= 0x02030000
1938 #
if PY_VERSION_HEX >= 0x02060000
1945 swigpyobject_type = tmp;
1947 #if PY_VERSION_HEX < 0x02020000
1948 swigpyobject_type.ob_type = &PyType_Type;
1950 if (PyType_Ready(&swigpyobject_type) < 0)
1954 return &swigpyobject_type;
1967 return (PyObject *)sobj;
1985 fputs(
"<Swig Packed ", fp);
2022 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2023 return s ? s : strncmp((
char *)v->
pack, (
char *)w->
pack, 2*v->
size);
2037 || (strcmp((op)->ob_type->tp_name,
"SwigPyPacked") == 0);
2052 static char swigpacked_doc[] =
"Swig object carries a C/C++ instance pointer";
2053 static PyTypeObject swigpypacked_type;
2054 static int type_init = 0;
2056 const PyTypeObject tmp = {
2058 #if PY_VERSION_HEX>=0x03000000
2059 PyVarObject_HEAD_INIT(NULL, 0)
2061 PyObject_HEAD_INIT(NULL)
2064 (
char *)
"SwigPyPacked",
2071 #if PY_VERSION_HEX>=0x03000000
2092 #
if PY_VERSION_HEX >= 0x02020000
2114 #
if PY_VERSION_HEX >= 0x02030000
2117 #
if PY_VERSION_HEX >= 0x02060000
2124 swigpypacked_type = tmp;
2126 #if PY_VERSION_HEX < 0x02020000
2127 swigpypacked_type.ob_type = &PyType_Type;
2129 if (PyType_Ready(&swigpypacked_type) < 0)
2133 return &swigpypacked_type;
2141 void *pack = malloc(size);
2143 memcpy(pack, ptr, size);
2152 return (PyObject *) sobj;
2160 if (sobj->
size != size)
return 0;
2161 memcpy(ptr, sobj->
pack, size);
2183 if (swig_this == NULL)
2191 #if PY_VERSION_HEX>=0x03000000
2192 #define SWIG_PYTHON_SLOW_GETSET_THIS
2203 #ifdef SWIGPYTHON_BUILTIN
2205 # ifdef PyWeakref_CheckProxy
2206 if (PyWeakref_CheckProxy(pyobj)) {
2207 pyobj = PyWeakref_GET_OBJECT(pyobj);
2217 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2218 if (PyInstance_Check(pyobj)) {
2219 obj = _PyInstance_Lookup(pyobj,
SWIG_This());
2221 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2222 if (dictptr != NULL) {
2223 PyObject *dict = *dictptr;
2224 obj = dict ? PyDict_GetItem(dict,
SWIG_This()) : 0;
2226 #ifdef PyWeakref_CheckProxy
2227 if (PyWeakref_CheckProxy(pyobj)) {
2228 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2232 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2236 if (PyErr_Occurred()) PyErr_Clear();
2242 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2246 if (PyErr_Occurred()) PyErr_Clear();
2266 int oldown = sobj->
own;
2283 if (obj == Py_None) {
2295 void *vptr = sobj->
ptr;
2300 if (ptr) *ptr = vptr;
2320 if (ptr) *ptr = vptr;
2326 *own = *own | sobj->
own;
2335 PyObject *klass = data->
klass;
2341 if (PyErr_Occurred()) {
2375 if (!PyCFunction_Check(obj)) {
2381 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2382 const char *desc = doc ? strstr(doc,
"swig_ptr: ") : 0;
2431 #if (PY_VERSION_HEX >= 0x02020000)
2433 PyObject *newraw = data->
newraw;
2435 inst = PyObject_Call(newraw, data->
newargs, NULL);
2437 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2438 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2439 if (dictptr != NULL) {
2440 PyObject *dict = *dictptr;
2442 dict = PyDict_New();
2444 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2449 PyObject_SetAttr(inst, key, swig_this);
2453 #if PY_VERSION_HEX >= 0x03000000
2454 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->
newargs, Py_None, Py_None);
2456 PyObject_SetAttr(inst,
SWIG_This(), swig_this);
2457 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2460 PyObject *dict = PyDict_New();
2462 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2463 inst = PyInstance_NewRaw(data->
newargs, dict);
2470 #if (PY_VERSION_HEX >= 0x02010000)
2472 PyObject *dict = PyDict_New();
2474 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2475 inst = PyInstance_NewRaw(data->
newargs, dict);
2478 return (PyObject *) inst;
2480 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2484 inst->in_class = (PyClassObject *)data->
newargs;
2485 Py_INCREF(inst->in_class);
2486 inst->in_dict = PyDict_New();
2487 if (inst->in_dict == NULL) {
2491 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2492 inst->in_weakreflist = NULL;
2494 #ifdef Py_TPFLAGS_GC
2495 PyObject_GC_Init(inst);
2497 PyDict_SetItem(inst->in_dict,
SWIG_This(), swig_this);
2498 return (PyObject *) inst;
2507 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2508 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2509 if (dictptr != NULL) {
2512 dict = PyDict_New();
2515 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2519 dict = PyObject_GetAttrString(inst, (
char*)
"__dict__");
2520 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2554 if (clientdata && clientdata->
pytype) {
2559 PyObject *next_self = clientdata->
pytype->tp_alloc(clientdata->
pytype, 0);
2560 while (newobj->
next)
2562 newobj->
next = next_self;
2573 #ifdef SWIGPYTHON_BUILTIN
2576 return (PyObject*) newobj;
2603 #ifdef SWIG_LINK_RUNTIME
2604 void *SWIG_ReturnGlobalTypeList(
void *);
2609 static void *type_pointer = (
void *)0;
2611 if (!type_pointer) {
2612 #ifdef SWIG_LINK_RUNTIME
2613 type_pointer = SWIG_ReturnGlobalTypeList((
void *)0);
2615 # ifdef SWIGPY_USE_CAPSULE
2616 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2621 if (PyErr_Occurred()) {
2623 type_pointer = (
void *)0;
2630 #if PY_MAJOR_VERSION < 2
2637 if (!PyModule_Check(m)) {
2638 PyErr_SetString(PyExc_TypeError,
2639 "PyModule_AddObject() needs module as first arg");
2643 PyErr_SetString(PyExc_TypeError,
2644 "PyModule_AddObject() needs non-NULL value");
2648 dict = PyModule_GetDict(m);
2651 PyErr_Format(PyExc_SystemError,
"module '%s' has no __dict__",
2652 PyModule_GetName(m));
2655 if (PyDict_SetItemString(dict, name, o))
2663 #ifdef SWIGPY_USE_CAPSULE
2669 #ifdef SWIGPY_USE_CAPSULE
2676 for (i =0; i < swig_module->
size; ++i) {
2689 #if PY_VERSION_HEX >= 0x03000000
2693 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };
2694 PyObject *module = Py_InitModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2696 #ifdef SWIGPY_USE_CAPSULE
2698 if (pointer && module) {
2701 Py_XDECREF(pointer);
2705 if (pointer && module) {
2708 Py_XDECREF(pointer);
2725 PyObject *obj = PyDict_GetItem(cache, key);
2728 #ifdef SWIGPY_USE_CAPSULE
2737 #ifdef SWIGPY_USE_CAPSULE
2738 obj = PyCapsule_New((
void*) descriptor, NULL, NULL);
2740 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2742 PyDict_SetItem(cache, key, obj);
2753 #define SWIG_POINTER_EXCEPTION 0
2754 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2755 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2760 if (PyErr_Occurred()) {
2762 PyObject *
value = 0;
2763 PyObject *traceback = 0;
2764 PyErr_Fetch(&type, &value, &traceback);
2767 PyObject *old_str = PyObject_Str(value);
2787 if (PyErr_Occurred()) {
2790 PyOS_snprintf(mesg,
sizeof(mesg),
"argument number %d:", argnum);
2802 return ty ? ty->
str :
"";
2809 #if defined(SWIG_COBJECT_TYPES)
2813 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, 'SwigPyObject(%s)' is received",
2820 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2822 PyObject *str = PyObject_Str(obj);
2825 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s(%s)' is received",
2829 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s' is received",
2836 PyErr_Format(PyExc_TypeError,
"a '%s' is expected", type);
2838 PyErr_Format(PyExc_TypeError,
"unexpected type is received");
2849 #if SWIG_POINTER_EXCEPTION
2859 #ifdef SWIGPYTHON_BUILTIN
2861 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *
value) {
2862 PyTypeObject *tp = obj->ob_type;
2864 PyObject *encoded_name;
2868 # ifdef Py_USING_UNICODE
2869 if (PyString_Check(name)) {
2870 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2873 }
else if (!PyUnicode_Check(name))
2875 if (!PyString_Check(name))
2878 PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2885 if (PyType_Ready(tp) < 0)
2890 descr = _PyType_Lookup(tp, name);
2893 f = descr->ob_type->tp_descr_set;
2895 if (PyString_Check(name)) {
2896 encoded_name =
name;
2899 encoded_name = PyUnicode_AsUTF8String(name);
2901 PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2902 Py_DECREF(encoded_name);
2904 res = f(descr, obj, value);
2920 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2922 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2928 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2929 #define SWIGTYPE_p_PLcGrid swig_types[1]
2930 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2931 #define SWIGTYPE_p_char swig_types[3]
2932 #define SWIGTYPE_p_double swig_types[4]
2933 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2934 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2935 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2936 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2937 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2938 #define SWIGTYPE_p_int swig_types[10]
2939 #define SWIGTYPE_p_p_char swig_types[11]
2940 #define SWIGTYPE_p_p_double swig_types[12]
2941 #define SWIGTYPE_p_unsigned_int swig_types[13]
2944 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2945 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2949 #if (PY_VERSION_HEX <= 0x02000000)
2950 # if !defined(SWIG_PYTHON_CLASSIC)
2951 # error "This python version requires swig to be run with the '-classic' option"
2958 #if PY_VERSION_HEX >= 0x03000000
2959 # define SWIG_init PyInit__plplotc
2962 # define SWIG_init init_plplotc
2965 #define SWIG_name "_plplotc"
2967 #define SWIGVERSION 0x020010
2968 #define SWIG_VERSION SWIGVERSION
2971 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2972 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2975 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2976 #include <arrayobject.h>
2980 #define NPY_PLINT NPY_INT32
2983 #define NPY_PLFLT NPY_DOUBLE
2985 #define NPY_PLFLT NPY_FLOAT
2989 #if !defined ( PySequence_Fast_GET_ITEM )
2990 #define PySequence_Fast_GET_ITEM PySequence_GetItem
2992 #define PySequence_Size PySequence_Length
3003 if (PyFloat_Check(obj)) {
3004 if (val) *val = PyFloat_AsDouble(obj);
3006 }
else if (PyInt_Check(obj)) {
3007 if (val) *val = PyInt_AsLong(obj);
3009 }
else if (PyLong_Check(obj)) {
3010 double v = PyLong_AsDouble(obj);
3011 if (!PyErr_Occurred()) {
3018 #ifdef SWIG_PYTHON_CAST_MODE
3021 double d = PyFloat_AsDouble(obj);
3022 if (!PyErr_Occurred()) {
3029 long v = PyLong_AsLong(obj);
3030 if (!PyErr_Occurred()) {
3043 #define SWIG_From_double PyFloat_FromDouble
3058 return PyInt_FromLong((
long) value);
3063 #if !defined(SWIG_NO_LLONG_MAX)
3064 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3065 # define LLONG_MAX __LONG_LONG_MAX__
3066 # define LLONG_MIN (-LLONG_MAX - 1LL)
3067 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3081 if ((min <= x && x <= max)) {
3082 double fx = floor(x);
3083 double cx = ceil(x);
3084 double rd = ((x - fx) < 0.5) ? fx : cx;
3085 if ((errno == EDOM) || (errno == ERANGE)) {
3088 double summ, reps, diff;
3091 }
else if (rd > x) {
3098 if (reps < 8*DBL_EPSILON) {
3111 if (PyInt_Check(obj)) {
3112 if (val) *val = PyInt_AsLong(obj);
3114 }
else if (PyLong_Check(obj)) {
3115 long v = PyLong_AsLong(obj);
3116 if (!PyErr_Occurred()) {
3123 #ifdef SWIG_PYTHON_CAST_MODE
3126 long v = PyInt_AsLong(obj);
3127 if (!PyErr_Occurred()) {
3137 if (val) *val = (long)(d);
3153 if ((v < INT_MIN || v > INT_MAX)) {
3156 if (val) *val = (int)(v);
3166 #if PY_VERSION_HEX < 0x03000000
3167 if (PyInt_Check(obj)) {
3168 long v = PyInt_AsLong(obj);
3177 if (PyLong_Check(obj)) {
3178 unsigned long v = PyLong_AsUnsignedLong(obj);
3179 if (!PyErr_Occurred()) {
3184 #if PY_VERSION_HEX >= 0x03000000
3186 long v = PyLong_AsLong(obj);
3187 if (!PyErr_Occurred()) {
3198 #ifdef SWIG_PYTHON_CAST_MODE
3201 unsigned long v = PyLong_AsUnsignedLong(obj);
3202 if (!PyErr_Occurred()) {
3212 if (val) *val = (
unsigned long)(d);
3228 if ((v > UINT_MAX)) {
3231 if (val) *val = (
unsigned int)(v);
3248 static int init = 0;
3261 #if PY_VERSION_HEX>=0x03000000
3262 if (PyUnicode_Check(obj))
3264 if (PyString_Check(obj))
3268 #if PY_VERSION_HEX>=0x03000000
3269 if (!alloc && cptr) {
3276 obj = PyUnicode_AsUTF8String(obj);
3277 PyBytes_AsStringAndSize(obj, &cstr, &len);
3293 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3299 *cptr = (
char *)memcpy((
char *)malloc((len + 1)*
sizeof(
char)), cstr,
sizeof(char)*(len + 1));
3307 #if PY_VERSION_HEX>=0x03000000
3313 if (psize) *psize = len + 1;
3314 #if PY_VERSION_HEX>=0x03000000
3320 if (pchar_descriptor) {
3323 if (cptr) *cptr = (
char *) vptr;
3324 if (psize) *psize = vptr ? (strlen((
char *)vptr) + 1) : 0;
3337 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3340 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3341 if (csize <= size) {
3343 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3344 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3362 if (size > INT_MAX) {
3364 return pchar_descriptor ?
3367 #if PY_VERSION_HEX >= 0x03000000
3368 return PyUnicode_FromStringAndSize(carray, (
int)(size));
3370 return PyString_FromStringAndSize(carray, (
int)(size));
3382 #define t_output_helper SWIG_Python_AppendOutput
3393 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3394 if (val) *val = (char)(v);
3410 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in,
NPY_PLINT,
3415 if ( PyArray_Check( in ) )
3418 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in,
NPY_PLINT );
3425 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3428 PyObject *resultobj = 0;
3431 PLFLT *arg3 = (PLFLT *) 0 ;
3432 PLFLT *arg4 = (PLFLT *) 0 ;
3442 PyObject * obj0 = 0 ;
3443 PyObject * obj1 = 0 ;
3450 if (!PyArg_ParseTuple(args,(
char *)
"OO:pltr0",&obj0,&obj1))
SWIG_fail;
3455 arg1 = (
PLFLT)(val1);
3460 arg2 = (
PLFLT)(val2);
3461 pltr0(arg1,arg2,arg3,arg4,arg5);
3491 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3498 if ( pltr_xg == 0 || pltr_yg == 0 )
3500 PyErr_SetString( PyExc_ValueError,
"Expected a sequence to two 1D arrays." );
3503 tmpGrid1.
nx = PyArray_DIMS( pltr_xg )[0];
3504 tmpGrid1.
ny = PyArray_DIMS( pltr_yg )[0];
3507 if ( Xlen != tmpGrid1.
nx ||
Ylen != tmpGrid1.
ny )
3509 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3515 if ( Xlen != tmpGrid1.
nx - 1 ||
Ylen != tmpGrid1.
ny - 1 )
3517 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3521 tmpGrid1.
xg = (PLFLT *) PyArray_DATA( pltr_xg );
3522 tmpGrid1.
yg = (PLFLT *) PyArray_DATA( pltr_yg );
3529 Py_DECREF( pltr_xg );
3530 Py_DECREF( pltr_yg );
3539 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two arrays." );
3546 if ( pltr_xg == 0 || pltr_yg == 0 )
3548 PyErr_SetString( PyExc_ValueError,
"Expected a sequence of two 2D arrays." );
3551 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3552 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3554 PyErr_SetString( PyExc_ValueError,
"Arrays must be same size." );
3557 tmpGrid2.
nx = PyArray_DIMS( pltr_xg )[0];
3558 tmpGrid2.
ny = PyArray_DIMS( pltr_xg )[1];
3561 if ( Xlen != tmpGrid2.
nx ||
Ylen != tmpGrid2.
ny )
3563 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg." );
3569 if ( Xlen != tmpGrid2.
nx - 1 ||
Ylen != tmpGrid2.
ny - 1 )
3571 PyErr_SetString( PyExc_ValueError,
"pltr arguments must have X and Y dimensions of first arg + 1." );
3575 size =
sizeof (
PLFLT ) * tmpGrid2.
ny;
3576 tmpGrid2.
xg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * tmpGrid2.
nx );
3577 for ( i = 0; i < tmpGrid2.
nx; i++ )
3578 tmpGrid2.
xg[i] = (PLFLT *) ( PyArray_DATA( pltr_xg ) + i * size );
3579 tmpGrid2.
yg = (PLFLT **) malloc(
sizeof ( PLFLT* ) * tmpGrid2.
nx );
3580 for ( i = 0; i < tmpGrid2.
nx; i++ )
3581 tmpGrid2.
yg[i] = (PLFLT *) ( PyArray_DATA( pltr_yg ) + i * size );
3588 free( tmpGrid2.
xg );
3589 free( tmpGrid2.
yg );
3590 Py_DECREF( pltr_xg );
3591 Py_DECREF( pltr_yg );
3595 PyObject *resultobj = 0;
3598 PLFLT *arg3 = (PLFLT *) 0 ;
3599 PLFLT *arg4 = (PLFLT *) 0 ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 PyObject * obj2 = 0 ;
3615 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr1",&obj0,&obj1,&obj2))
SWIG_fail;
3620 arg1 = (
PLFLT)(val1);
3625 arg2 = (
PLFLT)(val2);
3631 pltr1(arg1,arg2,arg3,arg4,arg5);
3658 PyObject *resultobj = 0;
3661 PLFLT *arg3 = (PLFLT *) 0 ;
3662 PLFLT *arg4 = (PLFLT *) 0 ;
3672 PyObject * obj0 = 0 ;
3673 PyObject * obj1 = 0 ;
3674 PyObject * obj2 = 0 ;
3678 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pltr2",&obj0,&obj1,&obj2))
SWIG_fail;
3683 arg1 = (
PLFLT)(val1);
3688 arg2 = (
PLFLT)(val2);
3694 pltr2(arg1,arg2,arg3,arg4,arg5);
3723 static PyInterpreterState *save_interp = NULL;
3733 #define MY_BLOCK_THREADS { \
3734 PyThreadState *prev_state, *new_state; \
3737 PyEval_AcquireLock(); \
3738 new_state = PyThreadState_New( save_interp ); \
3739 prev_state = PyThreadState_Swap( new_state );
3740 #define MY_UNBLOCK_THREADS \
3741 new_state = PyThreadState_Swap( prev_state ); \
3742 PyThreadState_Clear( new_state ); \
3743 PyEval_ReleaseLock(); \
3744 PyThreadState_Delete( new_state ); \
3747 #define MY_BLOCK_THREADS
3748 #define MY_UNBLOCK_THREADS
3755 PyObject *pdata, *arglist, *result;
3759 pdata = (PyObject *) data;
3766 Py_XINCREF( pdata );
3771 arglist = Py_BuildValue(
"(ddO)", x, y, pdata );
3773 arglist = Py_BuildValue(
"(ffO)", x, y, pdata );
3775 if ( arglist == NULL )
3777 fprintf( stderr,
"Py_BuildValue failed to make argument list.\n" );
3782 result = PyEval_CallObject( python_pltr, arglist );
3784 Py_XDECREF( arglist );
3786 if ( result == NULL )
3788 fprintf( stderr,
"call to python pltr function with 3 arguments failed\n" );
3789 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must take 3 argments." );
3795 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3797 fprintf( stderr,
"pltr callback must return a 2 element array or sequence\n" );
3798 PyErr_SetString( PyExc_RuntimeError,
"pltr callback must return a 2-sequence." );
3803 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3810 Py_XDECREF( result );
3818 PyObject *pdata, *arglist, *result;
3819 PLFLT fresult = 0.0;
3822 pdata = (PyObject *) data;
3823 if ( python_f2eval )
3825 Py_XINCREF( pdata );
3829 arglist = Py_BuildValue(
"(iiO)", x, y, pdata );
3831 result = PyEval_CallObject( python_f2eval, arglist );
3833 Py_DECREF( arglist );
3835 if ( !PyFloat_Check( result ) )
3837 fprintf( stderr,
"f2eval callback must return a float\n" );
3838 PyErr_SetString( PyExc_RuntimeError,
"f2eval callback must return a float." );
3843 fresult = (
PLFLT) PyFloat_AsDouble( result );
3846 Py_XDECREF( result );
3855 PyObject *pdata, *arglist, *result;
3857 PLFLT fresult = 0.0;
3861 pdata = (PyObject *) data;
3866 Py_XINCREF( pdata );
3871 arglist = Py_BuildValue(
"(ldO)", axis, value, pdata );
3873 arglist = Py_BuildValue(
"(lfO)", axis, value, pdata );
3876 result = PyEval_CallObject( python_label, arglist );
3880 if ( result == NULL )
3882 fprintf( stderr,
"label callback failed with 3 arguments\n" );
3883 PyErr_SetString( PyExc_RuntimeError,
"label callback must take 3 arguments." );
3885 else if ( !PyString_Check( result ) )
3887 fprintf( stderr,
"label callback must return a string\n" );
3888 PyErr_SetString( PyExc_RuntimeError,
"label callback must return a string." );
3893 pystring = PyString_AsString( result );
3894 strncpy(
string, pystring, len );
3897 Py_XDECREF( result );
3905 PyObject *px, *py, *pdata, *arglist, *result;
3910 pdata = (PyObject *) data;
3917 Py_XINCREF( pdata );
3921 px = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) xt );
3922 py = PyArray_SimpleNewFromData( 1, &n,
NPY_PLFLT, (
void *) yt );
3923 arglist = Py_BuildValue(
"(ddOOO)", x, y, px, py, pdata );
3925 result = PyEval_CallObject( python_ct, arglist );
3927 Py_DECREF( arglist );
3932 if ( result == NULL )
3934 fprintf( stderr,
"call to python coordinate transform function with 5 arguments failed\n" );
3935 PyErr_SetString( PyExc_RuntimeError,
"coordinate transform callback must take 5 arguments." );
3938 Py_XDECREF( result );
3946 PyObject *px, *py, *arglist, *result;
3953 if ( python_mapform )
3957 #ifdef PL_HAVE_PTHREAD
3958 px = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) x );
3959 py = PyArray_SimpleNewFromData( 1, &nn,
NPY_PLFLT, (
void *) y );
3961 px = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (
char *) x );
3962 py = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (
char *) y );
3964 arglist = Py_BuildValue(
"(iOO)", n, px, py );
3966 result = PyEval_CallObject( python_mapform, arglist );
3968 Py_DECREF( arglist );
3972 if ( result == NULL )
3974 fprintf( stderr,
"call to python mapform function with 3 arguments failed\n" );
3975 PyErr_SetString( PyExc_RuntimeError,
"mapform callback must take 3 arguments." );
3978 Py_XDECREF( result );
3988 PyObject * rep = PyObject_Repr( input );
3991 char* str = PyString_AsString( rep );
3992 if ( strcmp( str,
"<built-in function pltr0>" ) == 0 )
3998 else if ( strcmp( str,
"<built-in function pltr1>" ) == 0 )
4004 else if ( strcmp( str,
"<built-in function pltr2>" ) == 0 )
4012 python_pltr = input;
4014 Py_XINCREF( input );
4020 python_pltr = input;
4022 Py_XINCREF( input );
4029 Py_XDECREF( python_pltr );
4038 Py_XINCREF( input );
4044 Py_XDECREF( python_ct );
4052 python_mapform = input;
4053 Py_XINCREF( input );
4059 Py_XDECREF( python_mapform );
4071 if ( input != Py_None )
4075 if ( input != Py_None )
4079 Py_XINCREF( input );
4083 fprintf( stderr,
"pltr_type is invalid\n" );
4101 Py_XDECREF( python_pltr );
4104 fprintf( stderr,
"pltr_type is invalid\n" );
4113 PyObject *resultobj = 0;
4120 PyObject * obj0 = 0 ;
4121 PyObject * obj1 = 0 ;
4123 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_type_set",&obj0,&obj1))
SWIG_fail;
4134 if (arg1) (arg1)->type = arg2;
4143 PyObject *resultobj = 0;
4147 PyObject * obj0 = 0 ;
4150 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_type_get",&obj0))
SWIG_fail;
4156 result = (int) ((arg1)->type);
4165 PyObject *resultobj = 0;
4172 PyObject * obj0 = 0 ;
4173 PyObject * obj1 = 0 ;
4175 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_state_set",&obj0,&obj1))
SWIG_fail;
4185 arg2 = (
unsigned int)(val2);
4186 if (arg1) (arg1)->state = arg2;
4195 PyObject *resultobj = 0;
4199 PyObject * obj0 = 0 ;
4200 unsigned int result;
4202 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_state_get",&obj0))
SWIG_fail;
4208 result = (
unsigned int) ((arg1)->state);
4217 PyObject *resultobj = 0;
4224 PyObject * obj0 = 0 ;
4225 PyObject * obj1 = 0 ;
4227 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_keysym_set",&obj0,&obj1))
SWIG_fail;
4237 arg2 = (
unsigned int)(val2);
4238 if (arg1) (arg1)->keysym = arg2;
4247 PyObject *resultobj = 0;
4251 PyObject * obj0 = 0 ;
4252 unsigned int result;
4254 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_keysym_get",&obj0))
SWIG_fail;
4260 result = (
unsigned int) ((arg1)->keysym);
4269 PyObject *resultobj = 0;
4276 PyObject * obj0 = 0 ;
4277 PyObject * obj1 = 0 ;
4279 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_button_set",&obj0,&obj1))
SWIG_fail;
4289 arg2 = (
unsigned int)(val2);
4290 if (arg1) (arg1)->button = arg2;
4299 PyObject *resultobj = 0;
4303 PyObject * obj0 = 0 ;
4304 unsigned int result;
4306 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_button_get",&obj0))
SWIG_fail;
4312 result = (
unsigned int) ((arg1)->button);
4321 PyObject *resultobj = 0;
4328 PyObject * obj0 = 0 ;
4329 PyObject * obj1 = 0 ;
4331 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1))
SWIG_fail;
4341 arg2 = (
PLINT)(val2);
4342 if (arg1) (arg1)->subwindow = arg2;
4351 PyObject *resultobj = 0;
4355 PyObject * obj0 = 0 ;
4358 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_subwindow_get",&obj0))
SWIG_fail;
4364 result = (
PLINT) ((arg1)->subwindow);
4373 PyObject *resultobj = 0;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4383 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_string_set",&obj0,&obj1))
SWIG_fail;
4393 arg2 = (
char *)(temp2);
4394 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
4395 else memset(arg1->
string,0,16*
sizeof(
char));
4404 PyObject *resultobj = 0;
4408 PyObject * obj0 = 0 ;
4411 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_string_get",&obj0))
SWIG_fail;
4417 result = (
char *)(
char *) ((arg1)->
string);
4421 while (size && (result[size - 1] ==
'\0')) --size;
4432 PyObject *resultobj = 0;
4439 PyObject * obj0 = 0 ;
4440 PyObject * obj1 = 0 ;
4442 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pX_set",&obj0,&obj1))
SWIG_fail;
4453 if (arg1) (arg1)->pX = arg2;
4462 PyObject *resultobj = 0;
4466 PyObject * obj0 = 0 ;
4469 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pX_get",&obj0))
SWIG_fail;
4475 result = (int) ((arg1)->pX);
4484 PyObject *resultobj = 0;
4491 PyObject * obj0 = 0 ;
4492 PyObject * obj1 = 0 ;
4494 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_pY_set",&obj0,&obj1))
SWIG_fail;
4505 if (arg1) (arg1)->pY = arg2;
4514 PyObject *resultobj = 0;
4518 PyObject * obj0 = 0 ;
4521 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_pY_get",&obj0))
SWIG_fail;
4527 result = (int) ((arg1)->pY);
4536 PyObject *resultobj = 0;
4543 PyObject * obj0 = 0 ;
4544 PyObject * obj1 = 0 ;
4546 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dX_set",&obj0,&obj1))
SWIG_fail;
4556 arg2 = (
PLFLT)(val2);
4557 if (arg1) (arg1)->dX = arg2;
4566 PyObject *resultobj = 0;
4570 PyObject * obj0 = 0 ;
4573 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dX_get",&obj0))
SWIG_fail;
4579 result = (
PLFLT) ((arg1)->dX);
4588 PyObject *resultobj = 0;
4595 PyObject * obj0 = 0 ;
4596 PyObject * obj1 = 0 ;
4598 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_dY_set",&obj0,&obj1))
SWIG_fail;
4608 arg2 = (
PLFLT)(val2);
4609 if (arg1) (arg1)->dY = arg2;
4618 PyObject *resultobj = 0;
4622 PyObject * obj0 = 0 ;
4625 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_dY_get",&obj0))
SWIG_fail;
4631 result = (
PLFLT) ((arg1)->dY);
4640 PyObject *resultobj = 0;
4647 PyObject * obj0 = 0 ;
4648 PyObject * obj1 = 0 ;
4650 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wX_set",&obj0,&obj1))
SWIG_fail;
4660 arg2 = (
PLFLT)(val2);
4661 if (arg1) (arg1)->wX = arg2;
4670 PyObject *resultobj = 0;
4674 PyObject * obj0 = 0 ;
4677 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wX_get",&obj0))
SWIG_fail;
4683 result = (
PLFLT) ((arg1)->wX);
4692 PyObject *resultobj = 0;
4699 PyObject * obj0 = 0 ;
4700 PyObject * obj1 = 0 ;
4702 if (!PyArg_ParseTuple(args,(
char *)
"OO:PLGraphicsIn_wY_set",&obj0,&obj1))
SWIG_fail;
4712 arg2 = (
PLFLT)(val2);
4713 if (arg1) (arg1)->wY = arg2;
4722 PyObject *resultobj = 0;
4726 PyObject * obj0 = 0 ;
4729 if (!PyArg_ParseTuple(args,(
char *)
"O:PLGraphicsIn_wY_get",&obj0))
SWIG_fail;
4735 result = (
PLFLT) ((arg1)->wY);
4744 PyObject *resultobj = 0;
4747 if (!PyArg_ParseTuple(args,(
char *)
":new_PLGraphicsIn"))
SWIG_fail;
4757 PyObject *resultobj = 0;
4761 PyObject * obj0 = 0 ;
4763 if (!PyArg_ParseTuple(args,(
char *)
"O:delete_PLGraphicsIn",&obj0))
SWIG_fail;
4769 free((
char *) arg1);
4779 if (!PyArg_ParseTuple(args,(
char*)
"O:swigregister", &obj))
return NULL;
4785 PyObject *resultobj = 0;
4789 PyObject * obj0 = 0 ;
4791 if (!PyArg_ParseTuple(args,(
char *)
"O:plsxwin",&obj0))
SWIG_fail;
4796 arg1 = (
PLINT)(val1);
4806 PyObject *resultobj = 0;
4813 PyObject * obj0 = 0 ;
4814 PyObject * obj1 = 0 ;
4816 if (!PyArg_ParseTuple(args,(
char *)
"OO:pl_setcontlabelformat",&obj0,&obj1))
SWIG_fail;
4821 arg1 = (
PLINT)(val1);
4826 arg2 = (
PLINT)(val2);
4836 PyObject *resultobj = 0;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 PyObject * obj2 = 0 ;
4852 PyObject * obj3 = 0 ;
4854 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
4859 arg1 = (
PLFLT)(val1);
4864 arg2 = (
PLFLT)(val2);
4869 arg3 = (
PLFLT)(val3);
4874 arg4 = (
PLINT)(val4);
4884 PyObject *resultobj = 0;
4888 PyObject * obj0 = 0 ;
4890 if (!PyArg_ParseTuple(args,(
char *)
"O:pladv",&obj0))
SWIG_fail;
4895 arg1 = (
PLINT)(val1);
4905 PyObject *resultobj = 0;
4930 PyObject * obj0 = 0 ;
4931 PyObject * obj1 = 0 ;
4932 PyObject * obj2 = 0 ;
4933 PyObject * obj3 = 0 ;
4934 PyObject * obj4 = 0 ;
4935 PyObject * obj5 = 0 ;
4936 PyObject * obj6 = 0 ;
4937 PyObject * obj7 = 0 ;
4939 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
4944 arg1 = (
PLFLT)(val1);
4949 arg2 = (
PLFLT)(val2);
4954 arg3 = (
PLFLT)(val3);
4959 arg4 = (
PLFLT)(val4);
4964 arg5 = (
PLFLT)(val5);
4969 arg6 = (
PLFLT)(val6);
4974 arg7 = (
PLFLT)(val7);
4980 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4989 PyObject *resultobj = 0;
4992 char *arg3 = (
char *) 0 ;
4995 char *arg6 = (
char *) 0 ;
5016 PyObject * obj0 = 0 ;
5017 PyObject * obj1 = 0 ;
5018 PyObject * obj2 = 0 ;
5019 PyObject * obj3 = 0 ;
5020 PyObject * obj4 = 0 ;
5021 PyObject * obj5 = 0 ;
5022 PyObject * obj6 = 0 ;
5023 PyObject * obj7 = 0 ;
5025 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5030 arg1 = (
PLFLT)(val1);
5035 arg2 = (
PLFLT)(val2);
5040 arg3 = (
char *)(buf3);
5045 arg4 = (
PLFLT)(val4);
5050 arg5 = (
PLINT)(val5);
5055 arg6 = (
char *)(buf6);
5060 arg7 = (
PLFLT)(val7);
5065 arg8 = (
PLINT)(val8);
5066 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
5079 PyObject *resultobj = 0;
5081 PLFLT *arg2 = (PLFLT *) 0 ;
5082 PLFLT *arg3 = (PLFLT *) 0 ;
5084 PyArrayObject *tmp1 ;
5085 PyArrayObject *tmp3 ;
5088 PyObject * obj0 = 0 ;
5089 PyObject * obj1 = 0 ;
5090 PyObject * obj2 = 0 ;
5092 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plbin",&obj0,&obj1,&obj2))
SWIG_fail;
5097 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5098 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5104 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
5106 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
5109 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5115 arg4 = (
PLINT)(val4);
5116 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
5137 PyObject *resultobj = 0;
5138 PLINT *arg1 = (PLINT *) 0 ;
5139 PLINT *arg2 = (PLINT *) 0 ;
5140 PLINT *arg3 = (PLINT *) 0 ;
5141 PLINT *arg4 = (PLINT *) 0 ;
5142 PLINT *arg5 = (PLINT *) 0 ;
5143 PLFLT *arg6 = (PLFLT *) 0 ;
5159 PyObject * obj0 = 0 ;
5167 if (!PyArg_ParseTuple(args,(
char *)
"O:plbtime",&obj0))
SWIG_fail;
5172 arg7 = (
PLFLT)(val7);
5173 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5218 PyObject *resultobj = 0;
5220 if (!PyArg_ParseTuple(args,(
char *)
":plbop"))
SWIG_fail;
5230 PyObject *resultobj = 0;
5231 char *arg1 = (
char *) 0 ;
5234 char *arg4 = (
char *) 0 ;
5251 PyObject * obj0 = 0 ;
5252 PyObject * obj1 = 0 ;
5253 PyObject * obj2 = 0 ;
5254 PyObject * obj3 = 0 ;
5255 PyObject * obj4 = 0 ;
5256 PyObject * obj5 = 0 ;
5258 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5263 arg1 = (
char *)(buf1);
5268 arg2 = (
PLFLT)(val2);
5273 arg3 = (
PLINT)(val3);
5278 arg4 = (
char *)(buf4);
5283 arg5 = (
PLFLT)(val5);
5288 arg6 = (
PLINT)(val6);
5289 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
5302 PyObject *resultobj = 0;
5303 char *arg1 = (
char *) 0 ;
5304 char *arg2 = (
char *) 0 ;
5307 char *arg5 = (
char *) 0 ;
5308 char *arg6 = (
char *) 0 ;
5311 char *arg9 = (
char *) 0 ;
5312 char *arg10 = (
char *) 0 ;
5345 PyObject * obj0 = 0 ;
5346 PyObject * obj1 = 0 ;
5347 PyObject * obj2 = 0 ;
5348 PyObject * obj3 = 0 ;
5349 PyObject * obj4 = 0 ;
5350 PyObject * obj5 = 0 ;
5351 PyObject * obj6 = 0 ;
5352 PyObject * obj7 = 0 ;
5353 PyObject * obj8 = 0 ;
5354 PyObject * obj9 = 0 ;
5355 PyObject * obj10 = 0 ;
5356 PyObject * obj11 = 0 ;
5358 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
5363 arg1 = (
char *)(buf1);
5368 arg2 = (
char *)(buf2);
5373 arg3 = (
PLFLT)(val3);
5378 arg4 = (
PLINT)(val4);
5383 arg5 = (
char *)(buf5);
5388 arg6 = (
char *)(buf6);
5393 arg7 = (
PLFLT)(val7);
5398 arg8 = (
PLINT)(val8);
5403 arg9 = (
char *)(buf9);
5408 arg10 = (
char *)(buf10);
5413 arg11 = (
PLFLT)(val11);
5418 arg12 = (
PLINT)(val12);
5419 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);
5440 PyObject *resultobj = 0;
5443 PLFLT *arg3 = (PLFLT *) 0 ;
5444 PLFLT *arg4 = (PLFLT *) 0 ;
5445 PLINT *arg5 = (PLINT *) 0 ;
5456 PyObject * obj0 = 0 ;
5457 PyObject * obj1 = 0 ;
5462 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcalc_world",&obj0,&obj1))
SWIG_fail;
5467 arg1 = (
PLFLT)(val1);
5472 arg2 = (
PLFLT)(val2);
5500 PyObject *resultobj = 0;
5502 if (!PyArg_ParseTuple(args,(
char *)
":plclear"))
SWIG_fail;
5512 PyObject *resultobj = 0;
5516 PyObject * obj0 = 0 ;
5518 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol0",&obj0))
SWIG_fail;
5523 arg1 = (
PLINT)(val1);
5533 PyObject *resultobj = 0;
5537 PyObject * obj0 = 0 ;
5539 if (!PyArg_ParseTuple(args,(
char *)
"O:plcol1",&obj0))
SWIG_fail;
5544 arg1 = (
PLFLT)(val1);
5554 PyObject *resultobj = 0;
5588 PyObject * obj0 = 0 ;
5589 PyObject * obj1 = 0 ;
5590 PyObject * obj2 = 0 ;
5591 PyObject * obj3 = 0 ;
5592 PyObject * obj4 = 0 ;
5593 PyObject * obj5 = 0 ;
5594 PyObject * obj6 = 0 ;
5595 PyObject * obj7 = 0 ;
5596 PyObject * obj8 = 0 ;
5597 PyObject * obj9 = 0 ;
5598 PyObject * obj10 = 0 ;
5600 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
5605 arg1 = (
PLFLT)(val1);
5610 arg2 = (
PLFLT)(val2);
5615 arg3 = (
PLFLT)(val3);
5620 arg4 = (
PLINT)(val4);
5630 arg6 = (
PLINT)(val6);
5635 arg7 = (
PLINT)(val7);
5640 arg8 = (
PLINT)(val8);
5645 arg9 = (
PLINT)(val9);
5650 arg10 = (
PLINT)(val10);
5655 arg11 = (
PLFLT)(val11);
5656 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5665 PyObject *resultobj = 0;
5666 PLFLT **arg1 = (PLFLT **) 0 ;
5673 PLFLT *arg8 = (PLFLT *) 0 ;
5677 PyArrayObject *tmp1 ;
5686 PyArrayObject *tmp8 ;
5687 PyObject * obj0 = 0 ;
5688 PyObject * obj1 = 0 ;
5689 PyObject * obj2 = 0 ;
5690 PyObject * obj3 = 0 ;
5691 PyObject * obj4 = 0 ;
5692 PyObject * obj5 = 0 ;
5693 PyObject * obj6 = 0 ;
5694 PyObject * obj7 = 0 ;
5703 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
5709 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5710 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5711 size =
sizeof (
PLFLT ) * arg3;
5712 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
5713 for ( i = 0; i < arg2; i++ )
5714 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
5720 arg4 = (
PLINT)(val4);
5725 arg5 = (
PLINT)(val5);
5730 arg6 = (
PLINT)(val6);
5735 arg7 = (
PLINT)(val7);
5740 arg9 = PyArray_DIMS( tmp8 )[0];
5741 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5746 if ( obj6 == Py_None )
5752 if ( !PyCallable_Check( (PyObject *) obj6 ) )
5754 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
5763 if ( obj7 == Py_None )
5771 plcont((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11);
5806 PyObject *resultobj = 0;
5813 PLFLT *arg7 = (PLFLT *) 0 ;
5828 PyObject * obj0 = 0 ;
5829 PyObject * obj1 = 0 ;
5830 PyObject * obj2 = 0 ;
5831 PyObject * obj3 = 0 ;
5832 PyObject * obj4 = 0 ;
5833 PyObject * obj5 = 0 ;
5836 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5841 arg1 = (
PLINT)(val1);
5846 arg2 = (
PLINT)(val2);
5851 arg3 = (
PLINT)(val3);
5856 arg4 = (
PLINT)(val4);
5861 arg5 = (
PLINT)(val5);
5866 arg6 = (
PLFLT)(val6);
5867 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5882 PyObject *resultobj = 0;
5889 PyObject * obj0 = 0 ;
5890 PyObject * obj1 = 0 ;
5892 if (!PyArg_ParseTuple(args,(
char *)
"OO:plcpstrm",&obj0,&obj1))
SWIG_fail;
5897 arg1 = (
PLINT)(val1);
5912 PyObject *resultobj = 0;
5914 if (!PyArg_ParseTuple(args,(
char *)
":plend"))
SWIG_fail;
5924 PyObject *resultobj = 0;
5926 if (!PyArg_ParseTuple(args,(
char *)
":plend1"))
SWIG_fail;
5936 PyObject *resultobj = 0;
5955 PyObject * obj0 = 0 ;
5956 PyObject * obj1 = 0 ;
5957 PyObject * obj2 = 0 ;
5958 PyObject * obj3 = 0 ;
5959 PyObject * obj4 = 0 ;
5960 PyObject * obj5 = 0 ;
5962 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
5967 arg1 = (
PLFLT)(val1);
5972 arg2 = (
PLFLT)(val2);
5977 arg3 = (
PLFLT)(val3);
5982 arg4 = (
PLFLT)(val4);
5987 arg5 = (
PLINT)(val5);
5992 arg6 = (
PLINT)(val6);
5993 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6002 PyObject *resultobj = 0;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 PyObject * obj2 = 0 ;
6024 PyObject * obj3 = 0 ;
6025 PyObject * obj4 = 0 ;
6026 PyObject * obj5 = 0 ;
6028 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
6033 arg1 = (
PLFLT)(val1);
6038 arg2 = (
PLFLT)(val2);
6043 arg3 = (
PLFLT)(val3);
6048 arg4 = (
PLFLT)(val4);
6053 arg5 = (
PLINT)(val5);
6058 arg6 = (
PLINT)(val6);
6059 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6068 PyObject *resultobj = 0;
6070 if (!PyArg_ParseTuple(args,(
char *)
":pleop"))
SWIG_fail;
6080 PyObject *resultobj = 0;
6082 PLFLT *arg2 = (PLFLT *) 0 ;
6083 PLFLT *arg3 = (PLFLT *) 0 ;
6084 PLFLT *arg4 = (PLFLT *) 0 ;
6085 PyArrayObject *tmp1 ;
6086 PyArrayObject *tmp3 ;
6087 PyArrayObject *tmp4 ;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 PyObject * obj2 = 0 ;
6092 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerrx",&obj0,&obj1,&obj2))
SWIG_fail;
6097 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6098 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6104 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6106 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6109 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6115 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6117 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6120 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6122 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6149 PyObject *resultobj = 0;
6151 PLFLT *arg2 = (PLFLT *) 0 ;
6152 PLFLT *arg3 = (PLFLT *) 0 ;
6153 PLFLT *arg4 = (PLFLT *) 0 ;
6154 PyArrayObject *tmp1 ;
6155 PyArrayObject *tmp3 ;
6156 PyArrayObject *tmp4 ;
6157 PyObject * obj0 = 0 ;
6158 PyObject * obj1 = 0 ;
6159 PyObject * obj2 = 0 ;
6161 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plerry",&obj0,&obj1,&obj2))
SWIG_fail;
6166 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6167 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6173 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6175 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6178 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6184 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6186 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6189 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6191 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6218 PyObject *resultobj = 0;
6220 if (!PyArg_ParseTuple(args,(
char *)
":plfamadv"))
SWIG_fail;
6230 PyObject *resultobj = 0;
6232 PLFLT *arg2 = (PLFLT *) 0 ;
6233 PLFLT *arg3 = (PLFLT *) 0 ;
6234 PyArrayObject *tmp1 ;
6235 PyArrayObject *tmp3 ;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6239 if (!PyArg_ParseTuple(args,(
char *)
"OO:plfill",&obj0,&obj1))
SWIG_fail;
6244 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6245 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6251 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6253 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6256 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6258 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
6279 PyObject *resultobj = 0;
6281 PLFLT *arg2 = (PLFLT *) 0 ;
6282 PLFLT *arg3 = (PLFLT *) 0 ;
6283 PLFLT *arg4 = (PLFLT *) 0 ;
6284 PyArrayObject *tmp1 ;
6285 PyArrayObject *tmp3 ;
6286 PyArrayObject *tmp4 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 PyObject * obj2 = 0 ;
6291 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plfill3",&obj0,&obj1,&obj2))
SWIG_fail;
6296 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6297 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6303 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6305 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6308 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6314 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
6316 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6319 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6321 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
6348 PyObject *resultobj = 0;
6350 PLFLT *arg2 = (PLFLT *) 0 ;
6351 PLFLT *arg3 = (PLFLT *) 0 ;
6353 PyArrayObject *tmp1 ;
6354 PyArrayObject *tmp3 ;
6357 PyObject * obj0 = 0 ;
6358 PyObject * obj1 = 0 ;
6359 PyObject * obj2 = 0 ;
6361 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plgradient",&obj0,&obj1,&obj2))
SWIG_fail;
6366 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6367 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6373 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
6375 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
6378 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6384 arg4 = (
PLFLT)(val4);
6385 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
6406 PyObject *resultobj = 0;
6408 if (!PyArg_ParseTuple(args,(
char *)
":plflush"))
SWIG_fail;
6418 PyObject *resultobj = 0;
6422 PyObject * obj0 = 0 ;
6424 if (!PyArg_ParseTuple(args,(
char *)
"O:plfont",&obj0))
SWIG_fail;
6429 arg1 = (
PLINT)(val1);
6439 PyObject *resultobj = 0;
6443 PyObject * obj0 = 0 ;
6445 if (!PyArg_ParseTuple(args,(
char *)
"O:plfontld",&obj0))
SWIG_fail;
6450 arg1 = (
PLINT)(val1);
6460 PyObject *resultobj = 0;
6461 PLFLT *arg1 = (PLFLT *) 0 ;
6462 PLFLT *arg2 = (PLFLT *) 0 ;
6470 if (!PyArg_ParseTuple(args,(
char *)
":plgchr"))
SWIG_fail;
6492 PyObject *resultobj = 0;
6494 PLINT *arg2 = (PLINT *) 0 ;
6495 PLINT *arg3 = (PLINT *) 0 ;
6496 PLINT *arg4 = (PLINT *) 0 ;
6505 PyObject * obj0 = 0 ;
6510 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0",&obj0))
SWIG_fail;
6515 arg1 = (
PLINT)(val1);
6543 PyObject *resultobj = 0;
6545 PLINT *arg2 = (PLINT *) 0 ;
6546 PLINT *arg3 = (PLINT *) 0 ;
6547 PLINT *arg4 = (PLINT *) 0 ;
6548 PLFLT *arg5 = (PLFLT *) 0 ;
6559 PyObject * obj0 = 0 ;
6565 if (!PyArg_ParseTuple(args,(
char *)
"O:plgcol0a",&obj0))
SWIG_fail;
6570 arg1 = (
PLINT)(val1);
6571 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6604 PyObject *resultobj = 0;
6605 PLINT *arg1 = (PLINT *) 0 ;
6606 PLINT *arg2 = (PLINT *) 0 ;
6607 PLINT *arg3 = (PLINT *) 0 ;
6618 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbg"))
SWIG_fail;
6646 PyObject *resultobj = 0;
6647 PLINT *arg1 = (PLINT *) 0 ;
6648 PLINT *arg2 = (PLINT *) 0 ;
6649 PLINT *arg3 = (PLINT *) 0 ;
6650 PLFLT *arg4 = (PLFLT *) 0 ;
6664 if (!PyArg_ParseTuple(args,(
char *)
":plgcolbga"))
SWIG_fail;
6698 PyObject *resultobj = 0;
6699 PLINT *arg1 = (PLINT *) 0 ;
6704 if (!PyArg_ParseTuple(args,(
char *)
":plgcompression"))
SWIG_fail;
6720 PyObject *resultobj = 0;
6721 char *arg1 = (
char *) 0 ;
6727 if (!PyArg_ParseTuple(args,(
char *)
":plgdev"))
SWIG_fail;
6731 PyObject *o = PyString_FromString( arg1 );
6741 PyObject *resultobj = 0;
6742 PLFLT *arg1 = (PLFLT *) 0 ;
6743 PLFLT *arg2 = (PLFLT *) 0 ;
6744 PLFLT *arg3 = (PLFLT *) 0 ;
6745 PLFLT *arg4 = (PLFLT *) 0 ;
6759 if (!PyArg_ParseTuple(args,(
char *)
":plgdidev"))
SWIG_fail;
6793 PyObject *resultobj = 0;
6794 PLFLT *arg1 = (PLFLT *) 0 ;
6799 if (!PyArg_ParseTuple(args,(
char *)
":plgdiori"))
SWIG_fail;
6815 PyObject *resultobj = 0;
6816 PLFLT *arg1 = (PLFLT *) 0 ;
6817 PLFLT *arg2 = (PLFLT *) 0 ;
6818 PLFLT *arg3 = (PLFLT *) 0 ;
6819 PLFLT *arg4 = (PLFLT *) 0 ;
6833 if (!PyArg_ParseTuple(args,(
char *)
":plgdiplt"))
SWIG_fail;
6867 PyObject *resultobj = 0;
6868 PLINT *arg1 = (PLINT *) 0 ;
6869 PLINT *arg2 = (PLINT *) 0 ;
6870 PLINT *arg3 = (PLINT *) 0 ;
6881 if (!PyArg_ParseTuple(args,(
char *)
":plgfam"))
SWIG_fail;
6909 PyObject *resultobj = 0;
6915 if (!PyArg_ParseTuple(args,(
char *)
":plgfci"))
SWIG_fail;
6931 PyObject *resultobj = 0;
6932 char *arg1 = (
char *) 0 ;
6938 if (!PyArg_ParseTuple(args,(
char *)
":plgfnam"))
SWIG_fail;
6942 PyObject *o = PyString_FromString( arg1 );
6952 PyObject *resultobj = 0;
6953 PLINT *arg1 = (PLINT *) 0 ;
6954 PLINT *arg2 = (PLINT *) 0 ;
6955 PLINT *arg3 = (PLINT *) 0 ;
6966 if (!PyArg_ParseTuple(args,(
char *)
":plgfont"))
SWIG_fail;
6994 PyObject *resultobj = 0;
6995 PLINT *arg1 = (PLINT *) 0 ;
7000 if (!PyArg_ParseTuple(args,(
char *)
":plglevel"))
SWIG_fail;
7016 PyObject *resultobj = 0;
7017 PLFLT *arg1 = (PLFLT *) 0 ;
7018 PLFLT *arg2 = (PLFLT *) 0 ;
7019 PLINT *arg3 = (PLINT *) 0 ;
7020 PLINT *arg4 = (PLINT *) 0 ;
7021 PLINT *arg5 = (PLINT *) 0 ;
7022 PLINT *arg6 = (PLINT *) 0 ;
7042 if (!PyArg_ParseTuple(args,(
char *)
":plgpage"))
SWIG_fail;
7043 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7088 PyObject *resultobj = 0;
7090 if (!PyArg_ParseTuple(args,(
char *)
":plgra"))
SWIG_fail;
7100 PyObject *resultobj = 0;
7101 PLFLT *arg1 = (PLFLT *) 0 ;
7102 PLFLT *arg2 = (PLFLT *) 0 ;
7103 PLFLT *arg3 = (PLFLT *) 0 ;
7105 PLFLT *arg5 = (PLFLT *) 0 ;
7107 PLFLT *arg7 = (PLFLT *) 0 ;
7109 PLFLT **arg9 = (PLFLT **) 0 ;
7112 PyArrayObject *tmp1 ;
7113 PyArrayObject *tmp2 ;
7114 PyArrayObject *tmp3 ;
7115 PyArrayObject *tmp5 ;
7116 PyArrayObject *tmp7 ;
7117 PyObject *array7 = NULL ;
7122 PyObject * obj0 = 0 ;
7123 PyObject * obj1 = 0 ;
7124 PyObject * obj2 = 0 ;
7125 PyObject * obj3 = 0 ;
7126 PyObject * obj4 = 0 ;
7127 PyObject * obj5 = 0 ;
7128 PyObject * obj6 = 0 ;
7130 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
7135 Alen = PyArray_DIMS( tmp1 )[0];
7136 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7142 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
7144 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7147 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7153 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
7155 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7158 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7159 arg4 = PyArray_DIMS( tmp3 )[0];
7165 Xlen = PyArray_DIMS( tmp5 )[0];
7167 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7175 Ylen = PyArray_DIMS( tmp7 )[0];
7177 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7182 array7 = PyArray_SimpleNew( 2, dims, NPY_DOUBLE );
7185 size = (int) (
sizeof (
double ) *
Ylen );
7186 arg9 = (
double **) malloc(
sizeof (
double * ) *
Xlen );
7187 for ( i = 0; i <
Xlen; i++ )
7188 arg9[i] = (
double *) ( PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7194 arg10 = (
PLINT)(val10);
7199 arg11 = (
PLFLT)(val11);
7200 plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
7244 PyObject *resultobj = 0;
7245 PLFLT *arg1 = (PLFLT *) 0 ;
7246 PLFLT *arg2 = (PLFLT *) 0 ;
7247 PLFLT *arg3 = (PLFLT *) 0 ;
7248 PLFLT *arg4 = (PLFLT *) 0 ;
7262 if (!PyArg_ParseTuple(args,(
char *)
":plgspa"))
SWIG_fail;
7263 plgspa(arg1,arg2,arg3,arg4);
7296 PyObject *resultobj = 0;
7297 PLINT *arg1 = (PLINT *) 0 ;
7302 if (!PyArg_ParseTuple(args,(
char *)
":plgstrm"))
SWIG_fail;
7318 PyObject *resultobj = 0;
7319 char *arg1 = (
char *) 0 ;
7325 if (!PyArg_ParseTuple(args,(
char *)
":plgver"))
SWIG_fail;
7329 PyObject *o = PyString_FromString( arg1 );
7339 PyObject *resultobj = 0;
7340 PLFLT *arg1 = (PLFLT *) 0 ;
7341 PLFLT *arg2 = (PLFLT *) 0 ;
7342 PLFLT *arg3 = (PLFLT *) 0 ;
7343 PLFLT *arg4 = (PLFLT *) 0 ;
7357 if (!PyArg_ParseTuple(args,(
char *)
":plgvpd"))
SWIG_fail;
7358 plgvpd(arg1,arg2,arg3,arg4);
7391 PyObject *resultobj = 0;
7392 PLFLT *arg1 = (PLFLT *) 0 ;
7393 PLFLT *arg2 = (PLFLT *) 0 ;
7394 PLFLT *arg3 = (PLFLT *) 0 ;
7395 PLFLT *arg4 = (PLFLT *) 0 ;
7409 if (!PyArg_ParseTuple(args,(
char *)
":plgvpw"))
SWIG_fail;
7410 plgvpw(arg1,arg2,arg3,arg4);
7443 PyObject *resultobj = 0;
7444 PLINT *arg1 = (PLINT *) 0 ;
7445 PLINT *arg2 = (PLINT *) 0 ;
7453 if (!PyArg_ParseTuple(args,(
char *)
":plgxax"))
SWIG_fail;
7475 PyObject *resultobj = 0;
7476 PLINT *arg1 = (PLINT *) 0 ;
7477 PLINT *arg2 = (PLINT *) 0 ;
7485 if (!PyArg_ParseTuple(args,(
char *)
":plgyax"))
SWIG_fail;
7507 PyObject *resultobj = 0;
7508 PLINT *arg1 = (PLINT *) 0 ;
7509 PLINT *arg2 = (PLINT *) 0 ;
7517 if (!PyArg_ParseTuple(args,(
char *)
":plgzax"))
SWIG_fail;
7539 PyObject *resultobj = 0;
7541 PLFLT *arg2 = (PLFLT *) 0 ;
7546 PyArrayObject *tmp1 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 PyObject * obj2 = 0 ;
7558 PyObject * obj3 = 0 ;
7559 PyObject * obj4 = 0 ;
7561 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
7566 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7567 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7573 arg3 = (
PLFLT)(val3);
7578 arg4 = (
PLFLT)(val4);
7583 arg5 = (
PLINT)(val5);
7588 arg6 = (
PLINT)(val6);
7589 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
7604 PyObject *resultobj = 0;
7608 PLFLT *arg4 = (PLFLT *) 0 ;
7609 PLFLT *arg5 = (PLFLT *) 0 ;
7610 PLFLT *arg6 = (PLFLT *) 0 ;
7623 PyObject * obj0 = 0 ;
7624 PyObject * obj1 = 0 ;
7625 PyObject * obj2 = 0 ;
7630 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plhlsrgb",&obj0,&obj1,&obj2))
SWIG_fail;
7635 arg1 = (
PLFLT)(val1);
7640 arg2 = (
PLFLT)(val2);
7645 arg3 = (
PLFLT)(val3);
7646 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7673 PyObject *resultobj = 0;
7675 if (!PyArg_ParseTuple(args,(
char *)
":plinit"))
SWIG_fail;
7685 PyObject *resultobj = 0;
7698 PyObject * obj0 = 0 ;
7699 PyObject * obj1 = 0 ;
7700 PyObject * obj2 = 0 ;
7701 PyObject * obj3 = 0 ;
7703 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
7708 arg1 = (
PLFLT)(val1);
7713 arg2 = (
PLFLT)(val2);
7718 arg3 = (
PLFLT)(val3);
7723 arg4 = (
PLFLT)(val4);
7724 pljoin(arg1,arg2,arg3,arg4);
7733 PyObject *resultobj = 0;
7734 char *arg1 = (
char *) 0 ;
7735 char *arg2 = (
char *) 0 ;
7736 char *arg3 = (
char *) 0 ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 PyObject * obj2 = 0 ;
7750 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllab",&obj0,&obj1,&obj2))
SWIG_fail;
7755 arg1 = (
char *)(buf1);
7760 arg2 = (
char *)(buf2);
7765 arg3 = (
char *)(buf3);
7766 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
7781 PyObject *resultobj = 0;
7782 PLFLT *arg1 = (PLFLT *) 0 ;
7783 PLFLT *arg2 = (PLFLT *) 0 ;
7795 PLINT *arg14 = (PLINT *) 0 ;
7800 PLINT *arg19 = (PLINT *) 0 ;
7801 char **arg20 = (
char **) 0 ;
7802 PLINT *arg21 = (PLINT *) 0 ;
7803 PLINT *arg22 = (PLINT *) 0 ;
7804 PLFLT *arg23 = (PLFLT *) 0 ;
7805 PLFLT *arg24 = (PLFLT *) 0 ;
7806 PLINT *arg25 = (PLINT *) 0 ;
7807 PLINT *arg26 = (PLINT *) 0 ;
7808 PLFLT *arg27 = (PLFLT *) 0 ;
7809 PLINT *arg28 = (PLINT *) 0 ;
7810 PLFLT *arg29 = (PLFLT *) 0 ;
7811 PLINT *arg30 = (PLINT *) 0 ;
7812 char **arg31 = (
char **) 0 ;
7837 PyArrayObject *tmp13 ;
7846 PyArrayObject *tmp19 ;
7847 PyArrayObject *tmp20 ;
7848 PyArrayObject *tmp21 ;
7849 PyArrayObject *tmp22 ;
7850 PyArrayObject *tmp23 ;
7851 PyArrayObject *tmp24 ;
7852 PyArrayObject *tmp25 ;
7853 PyArrayObject *tmp26 ;
7854 PyArrayObject *tmp27 ;
7855 PyArrayObject *tmp28 ;
7856 PyArrayObject *tmp29 ;
7857 PyArrayObject *tmp30 ;
7858 PyArrayObject *tmp31 ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 PyObject * obj2 = 0 ;
7862 PyObject * obj3 = 0 ;
7863 PyObject * obj4 = 0 ;
7864 PyObject * obj5 = 0 ;
7865 PyObject * obj6 = 0 ;
7866 PyObject * obj7 = 0 ;
7867 PyObject * obj8 = 0 ;
7868 PyObject * obj9 = 0 ;
7869 PyObject * obj10 = 0 ;
7870 PyObject * obj11 = 0 ;
7871 PyObject * obj12 = 0 ;
7872 PyObject * obj13 = 0 ;
7873 PyObject * obj14 = 0 ;
7874 PyObject * obj15 = 0 ;
7875 PyObject * obj16 = 0 ;
7876 PyObject * obj17 = 0 ;
7877 PyObject * obj18 = 0 ;
7878 PyObject * obj19 = 0 ;
7879 PyObject * obj20 = 0 ;
7880 PyObject * obj21 = 0 ;
7881 PyObject * obj22 = 0 ;
7882 PyObject * obj23 = 0 ;
7883 PyObject * obj24 = 0 ;
7884 PyObject * obj25 = 0 ;
7885 PyObject * obj26 = 0 ;
7886 PyObject * obj27 = 0 ;
7890 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;
7895 arg3 = (
PLINT)(val3);
7900 arg4 = (
PLINT)(val4);
7905 arg5 = (
PLFLT)(val5);
7910 arg6 = (
PLFLT)(val6);
7915 arg7 = (
PLFLT)(val7);
7920 arg8 = (
PLINT)(val8);
7925 arg9 = (
PLINT)(val9);
7930 arg10 = (
PLINT)(val10);
7935 arg11 = (
PLINT)(val11);
7940 arg12 = (
PLINT)(val12);
7943 if ( tmp13 == NULL )
7945 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7946 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7952 arg15 = (
PLFLT)(val15);
7957 arg16 = (
PLFLT)(val16);
7962 arg17 = (
PLFLT)(val17);
7967 arg18 = (
PLFLT)(val18);
7970 if ( tmp19 == NULL )
7972 if ( PyArray_DIMS( tmp19 )[0] !=
Alen )
7974 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7977 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7981 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7982 if ( tmp20 == NULL )
7984 if ( PyArray_DIMS( tmp20 )[0] !=
Alen )
7986 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
7989 arg20 = (
char **) malloc(
sizeof (
char* ) *
Alen );
7990 for ( i = 0; i <
Alen; i++ )
7992 arg20[i] = PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7993 if ( arg20[i] == NULL )
8002 if ( tmp21 == NULL )
8004 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8006 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8009 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8013 if ( tmp22 == NULL )
8015 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8017 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8020 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8024 if ( tmp23 == NULL )
8026 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8028 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8031 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8035 if ( tmp24 == NULL )
8037 if ( PyArray_DIMS( tmp24 )[0] !=
Alen )
8039 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8042 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8046 if ( tmp25 == NULL )
8048 if ( PyArray_DIMS( tmp25 )[0] !=
Alen )
8050 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8053 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8057 if ( tmp26 == NULL )
8059 if ( PyArray_DIMS( tmp26 )[0] !=
Alen )
8061 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8064 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8068 if ( tmp27 == NULL )
8070 if ( PyArray_DIMS( tmp27 )[0] !=
Alen )
8072 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8075 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8079 if ( tmp28 == NULL )
8081 if ( PyArray_DIMS( tmp28 )[0] !=
Alen )
8083 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8086 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8090 if ( tmp29 == NULL )
8092 if ( PyArray_DIMS( tmp29 )[0] !=
Alen )
8094 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8097 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8101 if ( tmp30 == NULL )
8103 if ( PyArray_DIMS( tmp30 )[0] !=
Alen )
8105 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8108 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8112 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8113 if ( tmp31 == NULL )
8115 if ( PyArray_DIMS( tmp31 )[0] !=
Alen )
8117 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8120 arg31 = (
char **) malloc(
sizeof (
char* ) *
Alen );
8121 for ( i = 0; i <
Alen; i++ )
8123 arg31[i] = PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8124 if ( arg31[i] == NULL )
8131 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);
8152 Py_DECREF( tmp20 ); free( arg20 );
8185 Py_DECREF( tmp31 ); free( arg31 );
8196 Py_DECREF( tmp20 ); free( arg20 );
8229 Py_DECREF( tmp31 ); free( arg31 );
8236 PyObject *resultobj = 0;
8237 PLFLT *arg1 = (PLFLT *) 0 ;
8238 PLFLT *arg2 = (PLFLT *) 0 ;
8253 PLINT *arg17 = (PLINT *) 0 ;
8254 char **arg18 = (
char **) 0 ;
8256 char **arg20 = (
char **) 0 ;
8257 PLFLT *arg21 = (PLFLT *) 0 ;
8258 PLINT *arg22 = (PLINT *) 0 ;
8259 PLINT *arg23 = (PLINT *) 0 ;
8260 PLFLT **arg24 = (PLFLT **) 0 ;
8291 PyArrayObject *tmp16 ;
8292 PyArrayObject *tmp18 ;
8293 PyArrayObject *tmp19 ;
8294 PyArrayObject *tmp21 ;
8295 PyArrayObject *tmp22 ;
8296 PyArrayObject *tmp23 ;
8297 PyArrayObject *tmp24 ;
8298 PyObject * obj0 = 0 ;
8299 PyObject * obj1 = 0 ;
8300 PyObject * obj2 = 0 ;
8301 PyObject * obj3 = 0 ;
8302 PyObject * obj4 = 0 ;
8303 PyObject * obj5 = 0 ;
8304 PyObject * obj6 = 0 ;
8305 PyObject * obj7 = 0 ;
8306 PyObject * obj8 = 0 ;
8307 PyObject * obj9 = 0 ;
8308 PyObject * obj10 = 0 ;
8309 PyObject * obj11 = 0 ;
8310 PyObject * obj12 = 0 ;
8311 PyObject * obj13 = 0 ;
8312 PyObject * obj14 = 0 ;
8313 PyObject * obj15 = 0 ;
8314 PyObject * obj16 = 0 ;
8315 PyObject * obj17 = 0 ;
8316 PyObject * obj18 = 0 ;
8317 PyObject * obj19 = 0 ;
8321 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;
8326 arg3 = (
PLINT)(val3);
8331 arg4 = (
PLINT)(val4);
8336 arg5 = (
PLFLT)(val5);
8341 arg6 = (
PLFLT)(val6);
8346 arg7 = (
PLFLT)(val7);
8351 arg8 = (
PLFLT)(val8);
8356 arg9 = (
PLINT)(val9);
8361 arg10 = (
PLINT)(val10);
8366 arg11 = (
PLINT)(val11);
8371 arg12 = (
PLFLT)(val12);
8376 arg13 = (
PLFLT)(val13);
8381 arg14 = (
PLINT)(val14);
8386 arg15 = (
PLFLT)(val15);
8389 if ( tmp16 == NULL )
8391 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8392 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8396 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8397 if ( tmp18 == NULL )
8399 if ( PyArray_DIMS( tmp18 )[0] !=
Alen )
8401 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8404 arg18 = (
char **) malloc(
sizeof (
char* ) *
Alen );
8405 for ( i = 0; i <
Alen; i++ )
8407 arg18[i] = PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8408 if ( arg18[i] == NULL )
8417 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8418 if ( tmp19 == NULL )
8420 Alen = PyArray_DIMS( tmp19 )[0];
8422 arg20 = (
char **) malloc(
sizeof (
char* ) *
Alen );
8423 for ( i = 0; i <
Alen; i++ )
8425 arg20[i] = PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8426 if ( arg20[i] == NULL )
8435 if ( tmp21 == NULL )
8437 if ( PyArray_DIMS( tmp21 )[0] !=
Alen )
8439 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8442 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8446 if ( tmp22 == NULL )
8448 if ( PyArray_DIMS( tmp22 )[0] !=
Alen )
8450 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8453 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8458 if ( tmp23 == NULL )
8460 if ( PyArray_DIMS( tmp23 )[0] !=
Alen )
8462 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8465 Xlen = PyArray_DIMS( tmp23 )[0];
8466 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8468 for ( i = 0; i <
Xlen; i++ )
8469 if ( arg23[i] >
Ylen )
8475 if ( tmp24 == NULL )
8477 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] !=
Ylen )
8479 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8483 arg24 = (PLFLT **) malloc(
sizeof ( PLFLT* ) *
Xlen );
8484 for ( i = 0; i <
Xlen; i++ )
8485 arg24[i] = (PLFLT *) ( PyArray_DATA( tmp24 ) + i * size );
8487 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);
8505 Py_DECREF( tmp18 ); free( arg18 );
8508 Py_DECREF( tmp19 ); free( arg20 );
8529 Py_DECREF( tmp18 ); free( arg18 );
8532 Py_DECREF( tmp19 ); free( arg20 );
8552 PyObject *resultobj = 0;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 PyObject * obj2 = 0 ;
8566 if (!PyArg_ParseTuple(args,(
char *)
"OOO:pllightsource",&obj0,&obj1,&obj2))
SWIG_fail;
8571 arg1 = (
PLFLT)(val1);
8576 arg2 = (
PLFLT)(val2);
8581 arg3 = (
PLFLT)(val3);
8591 PyObject *resultobj = 0;
8593 PLFLT *arg2 = (PLFLT *) 0 ;
8594 PLFLT *arg3 = (PLFLT *) 0 ;
8595 PyArrayObject *tmp1 ;
8596 PyArrayObject *tmp3 ;
8597 PyObject * obj0 = 0 ;
8598 PyObject * obj1 = 0 ;
8600 if (!PyArg_ParseTuple(args,(
char *)
"OO:plline",&obj0,&obj1))
SWIG_fail;
8605 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8606 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8612 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8614 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8617 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8619 plline(arg1,(
double const *)arg2,(
double const *)arg3);
8640 PyObject *resultobj = 0;
8642 PLFLT *arg2 = (PLFLT *) 0 ;
8643 PLFLT *arg3 = (PLFLT *) 0 ;
8644 PLFLT *arg4 = (PLFLT *) 0 ;
8645 PyArrayObject *tmp1 ;
8646 PyArrayObject *tmp3 ;
8647 PyArrayObject *tmp4 ;
8648 PyObject * obj0 = 0 ;
8649 PyObject * obj1 = 0 ;
8650 PyObject * obj2 = 0 ;
8652 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plline3",&obj0,&obj1,&obj2))
SWIG_fail;
8657 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8658 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8664 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
8666 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8669 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8675 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
8677 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
8680 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8682 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
8709 PyObject *resultobj = 0;
8713 PyObject * obj0 = 0 ;
8715 if (!PyArg_ParseTuple(args,(
char *)
"O:pllsty",&obj0))
SWIG_fail;
8720 arg1 = (
PLINT)(val1);
8730 PyObject *resultobj = 0;
8731 PLFLT *arg1 = (PLFLT *) 0 ;
8732 PLFLT *arg2 = (PLFLT *) 0 ;
8733 PLFLT **arg3 = (PLFLT **) 0 ;
8737 PyArrayObject *tmp1 ;
8738 PyArrayObject *tmp2 ;
8739 PyArrayObject *tmp3 ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745 PyObject * obj3 = 0 ;
8747 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
8752 Xlen = PyArray_DIMS( tmp1 )[0];
8753 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8759 Ylen = PyArray_DIMS( tmp2 )[0];
8760 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8767 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8769 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8772 arg4 = PyArray_DIMS( tmp3 )[0];
8773 arg5 = PyArray_DIMS( tmp3 )[1];
8774 size =
sizeof (
PLFLT ) * arg5;
8775 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
8776 for ( i = 0; i < arg4; i++ )
8777 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8783 arg6 = (
PLINT)(val6);
8784 plmesh((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6);
8813 PyObject *resultobj = 0;
8814 PLFLT *arg1 = (PLFLT *) 0 ;
8815 PLFLT *arg2 = (PLFLT *) 0 ;
8816 PLFLT **arg3 = (PLFLT **) 0 ;
8820 PLFLT *arg7 = (PLFLT *) 0 ;
8822 PyArrayObject *tmp1 ;
8823 PyArrayObject *tmp2 ;
8824 PyArrayObject *tmp3 ;
8827 PyArrayObject *tmp7 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 PyObject * obj2 = 0 ;
8831 PyObject * obj3 = 0 ;
8832 PyObject * obj4 = 0 ;
8834 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8839 Xlen = PyArray_DIMS( tmp1 )[0];
8840 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8846 Ylen = PyArray_DIMS( tmp2 )[0];
8847 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8854 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
8856 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
8859 arg4 = PyArray_DIMS( tmp3 )[0];
8860 arg5 = PyArray_DIMS( tmp3 )[1];
8861 size =
sizeof (
PLFLT ) * arg5;
8862 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
8863 for ( i = 0; i < arg4; i++ )
8864 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8870 arg6 = (
PLINT)(val6);
8875 arg8 = PyArray_DIMS( tmp7 )[0];
8876 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8878 plmeshc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
8913 PyObject *resultobj = 0;
8914 PLINT *arg1 = (PLINT *) 0 ;
8919 if (!PyArg_ParseTuple(args,(
char *)
":plmkstrm"))
SWIG_fail;
8935 PyObject *resultobj = 0;
8936 char *arg1 = (
char *) 0 ;
8940 char *arg5 = (
char *) 0 ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 PyObject * obj2 = 0 ;
8956 PyObject * obj3 = 0 ;
8957 PyObject * obj4 = 0 ;
8959 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
8964 arg1 = (
char *)(buf1);
8969 arg2 = (
PLFLT)(val2);
8974 arg3 = (
PLFLT)(val3);
8979 arg4 = (
PLFLT)(val4);
8984 arg5 = (
char *)(buf5);
8985 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
8998 PyObject *resultobj = 0;
8999 char *arg1 = (
char *) 0 ;
9003 char *arg5 = (
char *) 0 ;
9016 PyObject * obj0 = 0 ;
9017 PyObject * obj1 = 0 ;
9018 PyObject * obj2 = 0 ;
9019 PyObject * obj3 = 0 ;
9020 PyObject * obj4 = 0 ;
9022 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9027 arg1 = (
char *)(buf1);
9032 arg2 = (
PLFLT)(val2);
9037 arg3 = (
PLFLT)(val3);
9042 arg4 = (
PLFLT)(val4);
9047 arg5 = (
char *)(buf5);
9048 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
9061 PyObject *resultobj = 0;
9062 PLFLT *arg1 = (PLFLT *) 0 ;
9063 PLFLT *arg2 = (PLFLT *) 0 ;
9064 PLFLT **arg3 = (PLFLT **) 0 ;
9069 PyArrayObject *tmp1 ;
9070 PyArrayObject *tmp2 ;
9071 PyArrayObject *tmp3 ;
9076 PyObject * obj0 = 0 ;
9077 PyObject * obj1 = 0 ;
9078 PyObject * obj2 = 0 ;
9079 PyObject * obj3 = 0 ;
9080 PyObject * obj4 = 0 ;
9082 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9087 Xlen = PyArray_DIMS( tmp1 )[0];
9088 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9094 Ylen = PyArray_DIMS( tmp2 )[0];
9095 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9102 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9104 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9107 arg4 = PyArray_DIMS( tmp3 )[0];
9108 arg5 = PyArray_DIMS( tmp3 )[1];
9109 size =
sizeof (
PLFLT ) * arg5;
9110 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9111 for ( i = 0; i < arg4; i++ )
9112 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9118 arg6 = (
PLINT)(val6);
9124 plot3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,arg7);
9153 PyObject *resultobj = 0;
9154 PLFLT *arg1 = (PLFLT *) 0 ;
9155 PLFLT *arg2 = (PLFLT *) 0 ;
9156 PLFLT **arg3 = (PLFLT **) 0 ;
9160 PLFLT *arg7 = (PLFLT *) 0 ;
9162 PyArrayObject *tmp1 ;
9163 PyArrayObject *tmp2 ;
9164 PyArrayObject *tmp3 ;
9167 PyArrayObject *tmp7 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 PyObject * obj2 = 0 ;
9171 PyObject * obj3 = 0 ;
9172 PyObject * obj4 = 0 ;
9174 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9179 Xlen = PyArray_DIMS( tmp1 )[0];
9180 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9186 Ylen = PyArray_DIMS( tmp2 )[0];
9187 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9194 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9196 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9199 arg4 = PyArray_DIMS( tmp3 )[0];
9200 arg5 = PyArray_DIMS( tmp3 )[1];
9201 size =
sizeof (
PLFLT ) * arg5;
9202 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9203 for ( i = 0; i < arg4; i++ )
9204 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9210 arg6 = (
PLINT)(val6);
9215 arg8 = PyArray_DIMS( tmp7 )[0];
9216 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9218 plot3dc((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9253 PyObject *resultobj = 0;
9254 PLFLT *arg1 = (PLFLT *) 0 ;
9255 PLFLT *arg2 = (PLFLT *) 0 ;
9256 PLFLT **arg3 = (PLFLT **) 0 ;
9260 PLFLT *arg7 = (PLFLT *) 0 ;
9264 PLINT *arg11 = (PLINT *) 0 ;
9265 PLINT *arg12 = (PLINT *) 0 ;
9266 PyArrayObject *tmp1 ;
9267 PyArrayObject *tmp2 ;
9268 PyArrayObject *tmp3 ;
9271 PyArrayObject *tmp7 ;
9274 PyArrayObject *tmp10 ;
9275 PyArrayObject *tmp12 ;
9276 PyObject * obj0 = 0 ;
9277 PyObject * obj1 = 0 ;
9278 PyObject * obj2 = 0 ;
9279 PyObject * obj3 = 0 ;
9280 PyObject * obj4 = 0 ;
9281 PyObject * obj5 = 0 ;
9282 PyObject * obj6 = 0 ;
9283 PyObject * obj7 = 0 ;
9285 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9290 Xlen = PyArray_DIMS( tmp1 )[0];
9291 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9297 Ylen = PyArray_DIMS( tmp2 )[0];
9298 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9305 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9307 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9310 arg4 = PyArray_DIMS( tmp3 )[0];
9311 arg5 = PyArray_DIMS( tmp3 )[1];
9312 size =
sizeof (
PLFLT ) * arg5;
9313 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9314 for ( i = 0; i < arg4; i++ )
9315 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9321 arg6 = (
PLINT)(val6);
9326 arg8 = PyArray_DIMS( tmp7 )[0];
9327 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9333 arg9 = (
PLINT)(val9);
9336 if ( tmp10 == NULL )
9338 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9339 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9343 if ( tmp12 == NULL )
9345 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9347 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9350 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9352 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);
9399 PyObject *resultobj = 0;
9400 PLFLT *arg1 = (PLFLT *) 0 ;
9401 PLFLT *arg2 = (PLFLT *) 0 ;
9402 PLFLT **arg3 = (PLFLT **) 0 ;
9406 PLFLT *arg7 = (PLFLT *) 0 ;
9408 PyArrayObject *tmp1 ;
9409 PyArrayObject *tmp2 ;
9410 PyArrayObject *tmp3 ;
9413 PyArrayObject *tmp7 ;
9414 PyObject * obj0 = 0 ;
9415 PyObject * obj1 = 0 ;
9416 PyObject * obj2 = 0 ;
9417 PyObject * obj3 = 0 ;
9418 PyObject * obj4 = 0 ;
9420 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9425 Xlen = PyArray_DIMS( tmp1 )[0];
9426 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9432 Ylen = PyArray_DIMS( tmp2 )[0];
9433 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9440 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9442 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9445 arg4 = PyArray_DIMS( tmp3 )[0];
9446 arg5 = PyArray_DIMS( tmp3 )[1];
9447 size =
sizeof (
PLFLT ) * arg5;
9448 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9449 for ( i = 0; i < arg4; i++ )
9450 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9456 arg6 = (
PLINT)(val6);
9461 arg8 = PyArray_DIMS( tmp7 )[0];
9462 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9464 plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const **)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9499 PyObject *resultobj = 0;
9500 PLFLT *arg1 = (PLFLT *) 0 ;
9501 PLFLT *arg2 = (PLFLT *) 0 ;
9502 PLFLT **arg3 = (PLFLT **) 0 ;
9506 PLFLT *arg7 = (PLFLT *) 0 ;
9510 PLINT *arg11 = (PLINT *) 0 ;
9511 PLINT *arg12 = (PLINT *) 0 ;
9512 PyArrayObject *tmp1 ;
9513 PyArrayObject *tmp2 ;
9514 PyArrayObject *tmp3 ;
9517 PyArrayObject *tmp7 ;
9520 PyArrayObject *tmp10 ;
9521 PyArrayObject *tmp12 ;
9522 PyObject * obj0 = 0 ;
9523 PyObject * obj1 = 0 ;
9524 PyObject * obj2 = 0 ;
9525 PyObject * obj3 = 0 ;
9526 PyObject * obj4 = 0 ;
9527 PyObject * obj5 = 0 ;
9528 PyObject * obj6 = 0 ;
9529 PyObject * obj7 = 0 ;
9531 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7))
SWIG_fail;
9536 Xlen = PyArray_DIMS( tmp1 )[0];
9537 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9543 Ylen = PyArray_DIMS( tmp2 )[0];
9544 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9551 if ( Xlen != PyArray_DIMS( tmp3 )[0] ||
Ylen != PyArray_DIMS( tmp3 )[1] )
9553 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
9556 arg4 = PyArray_DIMS( tmp3 )[0];
9557 arg5 = PyArray_DIMS( tmp3 )[1];
9558 size =
sizeof (
PLFLT ) * arg5;
9559 arg3 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg4 );
9560 for ( i = 0; i < arg4; i++ )
9561 arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9567 arg6 = (
PLINT)(val6);
9572 arg8 = PyArray_DIMS( tmp7 )[0];
9573 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9579 arg9 = (
PLINT)(val9);
9582 if ( tmp10 == NULL )
9584 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9585 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9589 if ( tmp12 == NULL )
9591 if ( PyArray_DIMS( tmp12 )[0] !=
Alen )
9593 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9596 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9598 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);
9645 PyObject *resultobj = 0;
9646 int *arg1 = (
int *) 0 ;
9647 char **arg2 = (
char **) 0 ;
9652 PyObject * obj0 = 0 ;
9653 PyObject * obj1 = 0 ;
9656 if (!PyArg_ParseTuple(args,(
char *)
"OO:plparseopts",&obj0,&obj1))
SWIG_fail;
9659 if ( !PyList_Check( obj0 ) )
9661 PyErr_SetString( PyExc_ValueError,
"Expecting a list" );
9664 tmp1 = PyList_Size( obj0 );
9666 arg2 = (
char **) malloc( ( tmp1 + 1 ) *
sizeof (
char * ) );
9667 for ( i = 0; i < tmp1; i++ )
9669 PyObject *s = PyList_GetItem( obj0, i );
9670 if ( !PyString_Check( s ) )
9673 PyErr_SetString( PyExc_ValueError,
"List items must be strings" );
9676 arg2[i] = PyString_AsString( s );
9684 arg3 = (
PLINT)(val3);
9702 PyObject *resultobj = 0;
9704 PLINT *arg2 = (PLINT *) 0 ;
9705 PLINT *arg3 = (PLINT *) 0 ;
9706 PyArrayObject *tmp1 ;
9707 PyArrayObject *tmp3 ;
9708 PyObject * obj0 = 0 ;
9709 PyObject * obj1 = 0 ;
9711 if (!PyArg_ParseTuple(args,(
char *)
"OO:plpat",&obj0,&obj1))
SWIG_fail;
9716 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9717 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9723 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9725 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9728 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9730 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
9751 PyObject *resultobj = 0;
9753 PLFLT *arg2 = (PLFLT *) 0 ;
9754 PLFLT *arg3 = (PLFLT *) 0 ;
9756 PyArrayObject *tmp1 ;
9757 PyArrayObject *tmp3 ;
9760 PyObject * obj0 = 0 ;
9761 PyObject * obj1 = 0 ;
9762 PyObject * obj2 = 0 ;
9764 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plpoin",&obj0,&obj1,&obj2))
SWIG_fail;
9769 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9770 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9776 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9778 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9781 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9787 arg4 = (
PLINT)(val4);
9788 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
9809 PyObject *resultobj = 0;
9811 PLFLT *arg2 = (PLFLT *) 0 ;
9812 PLFLT *arg3 = (PLFLT *) 0 ;
9813 PLFLT *arg4 = (PLFLT *) 0 ;
9815 PyArrayObject *tmp1 ;
9816 PyArrayObject *tmp3 ;
9817 PyArrayObject *tmp4 ;
9820 PyObject * obj0 = 0 ;
9821 PyObject * obj1 = 0 ;
9822 PyObject * obj2 = 0 ;
9823 PyObject * obj3 = 0 ;
9825 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
9830 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9831 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9837 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9839 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9842 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9848 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
9850 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9853 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9859 arg5 = (
PLINT)(val5);
9860 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
9887 PyObject *resultobj = 0;
9889 PLFLT *arg2 = (PLFLT *) 0 ;
9890 PLFLT *arg3 = (PLFLT *) 0 ;
9891 PLFLT *arg4 = (PLFLT *) 0 ;
9894 PyArrayObject *tmp1 ;
9895 PyArrayObject *tmp3 ;
9896 PyArrayObject *tmp4 ;
9897 PyArrayObject *tmp5 ;
9900 PyObject * obj0 = 0 ;
9901 PyObject * obj1 = 0 ;
9902 PyObject * obj2 = 0 ;
9903 PyObject * obj3 = 0 ;
9904 PyObject * obj4 = 0 ;
9906 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
9911 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9912 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9918 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
9920 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9923 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9929 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
9931 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
9934 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9940 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9942 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
9945 arg5 = (PLINT *) PyArray_DATA( tmp5 );
9952 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
9985 PyObject *resultobj = 0;
9992 PyObject * obj0 = 0 ;
9993 PyObject * obj1 = 0 ;
9995 if (!PyArg_ParseTuple(args,(
char *)
"OO:plprec",&obj0,&obj1))
SWIG_fail;
10000 arg1 = (
PLINT)(val1);
10005 arg2 = (
PLINT)(val2);
10015 PyObject *resultobj = 0;
10019 PyObject * obj0 = 0 ;
10021 if (!PyArg_ParseTuple(args,(
char *)
"O:plpsty",&obj0))
SWIG_fail;
10026 arg1 = (
PLINT)(val1);
10036 PyObject *resultobj = 0;
10042 char *arg6 = (
char *) 0 ;
10056 PyObject * obj0 = 0 ;
10057 PyObject * obj1 = 0 ;
10058 PyObject * obj2 = 0 ;
10059 PyObject * obj3 = 0 ;
10060 PyObject * obj4 = 0 ;
10061 PyObject * obj5 = 0 ;
10063 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10068 arg1 = (
PLFLT)(val1);
10073 arg2 = (
PLFLT)(val2);
10078 arg3 = (
PLFLT)(val3);
10083 arg4 = (
PLFLT)(val4);
10088 arg5 = (
PLFLT)(val5);
10093 arg6 = (
char *)(buf6);
10094 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
10105 PyObject *resultobj = 0;
10116 char *arg11 = (
char *) 0 ;
10140 PyObject * obj0 = 0 ;
10141 PyObject * obj1 = 0 ;
10142 PyObject * obj2 = 0 ;
10143 PyObject * obj3 = 0 ;
10144 PyObject * obj4 = 0 ;
10145 PyObject * obj5 = 0 ;
10146 PyObject * obj6 = 0 ;
10147 PyObject * obj7 = 0 ;
10148 PyObject * obj8 = 0 ;
10149 PyObject * obj9 = 0 ;
10150 PyObject * obj10 = 0 ;
10152 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
10157 arg1 = (
PLFLT)(val1);
10162 arg2 = (
PLFLT)(val2);
10167 arg3 = (
PLFLT)(val3);
10172 arg4 = (
PLFLT)(val4);
10177 arg5 = (
PLFLT)(val5);
10182 arg6 = (
PLFLT)(val6);
10187 arg7 = (
PLFLT)(val7);
10192 arg8 = (
PLFLT)(val8);
10197 arg9 = (
PLFLT)(val9);
10202 arg10 = (
PLFLT)(val10);
10207 arg11 = (
char *)(buf11);
10208 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
10219 PyObject *resultobj = 0;
10222 if (!PyArg_ParseTuple(args,(
char *)
":plrandd"))
SWIG_fail;
10232 PyObject *resultobj = 0;
10234 if (!PyArg_ParseTuple(args,(
char *)
":plreplot"))
SWIG_fail;
10244 PyObject *resultobj = 0;
10248 PLFLT *arg4 = (PLFLT *) 0 ;
10249 PLFLT *arg5 = (PLFLT *) 0 ;
10250 PLFLT *arg6 = (PLFLT *) 0 ;
10263 PyObject * obj0 = 0 ;
10264 PyObject * obj1 = 0 ;
10265 PyObject * obj2 = 0 ;
10270 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plrgbhls",&obj0,&obj1,&obj2))
SWIG_fail;
10275 arg1 = (
PLFLT)(val1);
10280 arg2 = (
PLFLT)(val2);
10285 arg3 = (
PLFLT)(val3);
10286 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10313 PyObject *resultobj = 0;
10320 PyObject * obj0 = 0 ;
10321 PyObject * obj1 = 0 ;
10323 if (!PyArg_ParseTuple(args,(
char *)
"OO:plschr",&obj0,&obj1))
SWIG_fail;
10328 arg1 = (
PLFLT)(val1);
10333 arg2 = (
PLFLT)(val2);
10343 PyObject *resultobj = 0;
10344 PLINT *arg1 = (PLINT *) 0 ;
10345 PLINT *arg2 = (PLINT *) 0 ;
10346 PLINT *arg3 = (PLINT *) 0 ;
10348 PyArrayObject *tmp1 ;
10349 PyArrayObject *tmp2 ;
10350 PyArrayObject *tmp3 ;
10351 PyObject * obj0 = 0 ;
10352 PyObject * obj1 = 0 ;
10353 PyObject * obj2 = 0 ;
10355 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap0",&obj0,&obj1,&obj2))
SWIG_fail;
10358 if ( tmp1 == NULL )
10360 Alen = PyArray_DIMS( tmp1 )[0];
10361 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10365 if ( tmp2 == NULL )
10367 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10369 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10372 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10376 if ( tmp3 == NULL )
10378 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10380 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10383 arg4 = PyArray_DIMS( tmp3 )[0];
10384 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10386 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10413 PyObject *resultobj = 0;
10414 PLINT *arg1 = (PLINT *) 0 ;
10415 PLINT *arg2 = (PLINT *) 0 ;
10416 PLINT *arg3 = (PLINT *) 0 ;
10417 PLFLT *arg4 = (PLFLT *) 0 ;
10419 PyArrayObject *tmp1 ;
10420 PyArrayObject *tmp2 ;
10421 PyArrayObject *tmp3 ;
10422 PyArrayObject *tmp4 ;
10423 PyObject * obj0 = 0 ;
10424 PyObject * obj1 = 0 ;
10425 PyObject * obj2 = 0 ;
10426 PyObject * obj3 = 0 ;
10428 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10431 if ( tmp1 == NULL )
10433 Alen = PyArray_DIMS( tmp1 )[0];
10434 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10438 if ( tmp2 == NULL )
10440 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10442 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10445 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10449 if ( tmp3 == NULL )
10451 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10453 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10456 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10460 if ( tmp4 == NULL )
10462 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10464 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10467 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10468 arg5 = PyArray_DIMS( tmp4 )[0];
10470 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10503 PyObject *resultobj = 0;
10507 PyObject * obj0 = 0 ;
10509 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap0n",&obj0))
SWIG_fail;
10514 arg1 = (
PLINT)(val1);
10524 PyObject *resultobj = 0;
10525 PLINT *arg1 = (PLINT *) 0 ;
10526 PLINT *arg2 = (PLINT *) 0 ;
10527 PLINT *arg3 = (PLINT *) 0 ;
10529 PyArrayObject *tmp1 ;
10530 PyArrayObject *tmp2 ;
10531 PyArrayObject *tmp3 ;
10532 PyObject * obj0 = 0 ;
10533 PyObject * obj1 = 0 ;
10534 PyObject * obj2 = 0 ;
10536 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscmap1",&obj0,&obj1,&obj2))
SWIG_fail;
10539 if ( tmp1 == NULL )
10541 Alen = PyArray_DIMS( tmp1 )[0];
10542 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10546 if ( tmp2 == NULL )
10548 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10550 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10553 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10557 if ( tmp3 == NULL )
10559 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10561 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10564 arg4 = PyArray_DIMS( tmp3 )[0];
10565 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10567 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
10594 PyObject *resultobj = 0;
10595 PLINT *arg1 = (PLINT *) 0 ;
10596 PLINT *arg2 = (PLINT *) 0 ;
10597 PLINT *arg3 = (PLINT *) 0 ;
10598 PLFLT *arg4 = (PLFLT *) 0 ;
10600 PyArrayObject *tmp1 ;
10601 PyArrayObject *tmp2 ;
10602 PyArrayObject *tmp3 ;
10603 PyArrayObject *tmp4 ;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 PyObject * obj2 = 0 ;
10607 PyObject * obj3 = 0 ;
10609 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
10612 if ( tmp1 == NULL )
10614 Alen = PyArray_DIMS( tmp1 )[0];
10615 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10619 if ( tmp2 == NULL )
10621 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
10623 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10626 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10630 if ( tmp3 == NULL )
10632 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
10634 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10637 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10641 if ( tmp4 == NULL )
10643 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10645 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10648 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10649 arg5 = PyArray_DIMS( tmp4 )[0];
10651 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
10684 PyObject *resultobj = 0;
10687 PLFLT *arg3 = (PLFLT *) 0 ;
10688 PLFLT *arg4 = (PLFLT *) 0 ;
10689 PLFLT *arg5 = (PLFLT *) 0 ;
10690 PLFLT *arg6 = (PLFLT *) 0 ;
10694 PyArrayObject *tmp2 ;
10695 PyArrayObject *tmp4 ;
10696 PyArrayObject *tmp5 ;
10697 PyArrayObject *tmp6 ;
10698 PyArrayObject *tmp7 ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 PyObject * obj3 = 0 ;
10703 PyObject * obj4 = 0 ;
10704 PyObject * obj5 = 0 ;
10706 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
10714 if ( tmp2 == NULL )
10716 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10717 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10721 if ( tmp4 == NULL )
10723 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10725 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10728 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10732 if ( tmp5 == NULL )
10734 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10736 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10739 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10743 if ( tmp6 == NULL )
10745 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10747 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10750 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10754 if ( tmp7 == NULL )
10756 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10758 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10761 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10763 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
10802 PyObject *resultobj = 0;
10805 PLFLT *arg3 = (PLFLT *) 0 ;
10806 PLFLT *arg4 = (PLFLT *) 0 ;
10807 PLFLT *arg5 = (PLFLT *) 0 ;
10808 PLFLT *arg6 = (PLFLT *) 0 ;
10809 PLFLT *arg7 = (PLFLT *) 0 ;
10813 PyArrayObject *tmp2 ;
10814 PyArrayObject *tmp4 ;
10815 PyArrayObject *tmp5 ;
10816 PyArrayObject *tmp6 ;
10817 PyArrayObject *tmp7 ;
10818 PyArrayObject *tmp8 ;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 PyObject * obj2 = 0 ;
10822 PyObject * obj3 = 0 ;
10823 PyObject * obj4 = 0 ;
10824 PyObject * obj5 = 0 ;
10825 PyObject * obj6 = 0 ;
10827 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
10835 if ( tmp2 == NULL )
10837 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10838 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10842 if ( tmp4 == NULL )
10844 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
10846 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10849 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10853 if ( tmp5 == NULL )
10855 if ( PyArray_DIMS( tmp5 )[0] !=
Alen )
10857 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10860 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10864 if ( tmp6 == NULL )
10866 if ( PyArray_DIMS( tmp6 )[0] !=
Alen )
10868 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10871 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10875 if ( tmp7 == NULL )
10877 if ( PyArray_DIMS( tmp7 )[0] !=
Alen )
10879 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
10882 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10886 if ( tmp8 == NULL )
10888 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10890 PyErr_SetString( PyExc_ValueError,
"Vector must be at least length of others minus 1." );
10893 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10895 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
10940 PyObject *resultobj = 0;
10944 PyObject * obj0 = 0 ;
10946 if (!PyArg_ParseTuple(args,(
char *)
"O:plscmap1n",&obj0))
SWIG_fail;
10951 arg1 = (
PLINT)(val1);
10961 PyObject *resultobj = 0;
10968 PyObject * obj0 = 0 ;
10969 PyObject * obj1 = 0 ;
10971 if (!PyArg_ParseTuple(args,(
char *)
"OO:plscmap1_range",&obj0,&obj1))
SWIG_fail;
10976 arg1 = (
PLFLT)(val1);
10981 arg2 = (
PLFLT)(val2);
10991 PyObject *resultobj = 0;
10992 PLFLT *arg1 = (PLFLT *) 0 ;
10993 PLFLT *arg2 = (PLFLT *) 0 ;
11001 if (!PyArg_ParseTuple(args,(
char *)
":plgcmap1_range"))
SWIG_fail;
11023 PyObject *resultobj = 0;
11036 PyObject * obj0 = 0 ;
11037 PyObject * obj1 = 0 ;
11038 PyObject * obj2 = 0 ;
11039 PyObject * obj3 = 0 ;
11041 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11046 arg1 = (
PLINT)(val1);
11051 arg2 = (
PLINT)(val2);
11056 arg3 = (
PLINT)(val3);
11061 arg4 = (
PLINT)(val4);
11062 plscol0(arg1,arg2,arg3,arg4);
11071 PyObject *resultobj = 0;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 PyObject * obj2 = 0 ;
11090 PyObject * obj3 = 0 ;
11091 PyObject * obj4 = 0 ;
11093 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
11098 arg1 = (
PLINT)(val1);
11103 arg2 = (
PLINT)(val2);
11108 arg3 = (
PLINT)(val3);
11113 arg4 = (
PLINT)(val4);
11118 arg5 = (
PLFLT)(val5);
11119 plscol0a(arg1,arg2,arg3,arg4,arg5);
11128 PyObject *resultobj = 0;
11138 PyObject * obj0 = 0 ;
11139 PyObject * obj1 = 0 ;
11140 PyObject * obj2 = 0 ;
11142 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plscolbg",&obj0,&obj1,&obj2))
SWIG_fail;
11147 arg1 = (
PLINT)(val1);
11152 arg2 = (
PLINT)(val2);
11157 arg3 = (
PLINT)(val3);
11167 PyObject *resultobj = 0;
11180 PyObject * obj0 = 0 ;
11181 PyObject * obj1 = 0 ;
11182 PyObject * obj2 = 0 ;
11183 PyObject * obj3 = 0 ;
11185 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11190 arg1 = (
PLINT)(val1);
11195 arg2 = (
PLINT)(val2);
11200 arg3 = (
PLINT)(val3);
11205 arg4 = (
PLFLT)(val4);
11215 PyObject *resultobj = 0;
11219 PyObject * obj0 = 0 ;
11221 if (!PyArg_ParseTuple(args,(
char *)
"O:plscolor",&obj0))
SWIG_fail;
11226 arg1 = (
PLINT)(val1);
11236 PyObject *resultobj = 0;
11240 PyObject * obj0 = 0 ;
11242 if (!PyArg_ParseTuple(args,(
char *)
"O:plscompression",&obj0))
SWIG_fail;
11247 arg1 = (
PLINT)(val1);
11257 PyObject *resultobj = 0;
11258 char *arg1 = (
char *) 0 ;
11262 PyObject * obj0 = 0 ;
11264 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdev",&obj0))
SWIG_fail;
11269 arg1 = (
char *)(buf1);
11270 plsdev((
char const *)arg1);
11281 PyObject *resultobj = 0;
11294 PyObject * obj0 = 0 ;
11295 PyObject * obj1 = 0 ;
11296 PyObject * obj2 = 0 ;
11297 PyObject * obj3 = 0 ;
11299 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11304 arg1 = (
PLFLT)(val1);
11309 arg2 = (
PLFLT)(val2);
11314 arg3 = (
PLFLT)(val3);
11319 arg4 = (
PLFLT)(val4);
11329 PyObject *resultobj = 0;
11348 PyObject * obj0 = 0 ;
11349 PyObject * obj1 = 0 ;
11350 PyObject * obj2 = 0 ;
11351 PyObject * obj3 = 0 ;
11352 PyObject * obj4 = 0 ;
11353 PyObject * obj5 = 0 ;
11355 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
11360 arg1 = (
PLINT)(val1);
11365 arg2 = (
PLINT)(val2);
11370 arg3 = (
PLINT)(val3);
11375 arg4 = (
PLINT)(val4);
11380 arg5 = (
PLFLT)(val5);
11385 arg6 = (
PLFLT)(val6);
11386 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11395 PyObject *resultobj = 0;
11399 PyObject * obj0 = 0 ;
11401 if (!PyArg_ParseTuple(args,(
char *)
"O:plsdiori",&obj0))
SWIG_fail;
11406 arg1 = (
PLFLT)(val1);
11416 PyObject *resultobj = 0;
11429 PyObject * obj0 = 0 ;
11430 PyObject * obj1 = 0 ;
11431 PyObject * obj2 = 0 ;
11432 PyObject * obj3 = 0 ;
11434 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11439 arg1 = (
PLFLT)(val1);
11444 arg2 = (
PLFLT)(val2);
11449 arg3 = (
PLFLT)(val3);
11454 arg4 = (
PLFLT)(val4);
11464 PyObject *resultobj = 0;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 PyObject * obj2 = 0 ;
11480 PyObject * obj3 = 0 ;
11482 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
11487 arg1 = (
PLFLT)(val1);
11492 arg2 = (
PLFLT)(val2);
11497 arg3 = (
PLFLT)(val3);
11502 arg4 = (
PLFLT)(val4);
11512 PyObject *resultobj = 0;
11513 unsigned int arg1 ;
11514 unsigned int val1 ;
11516 PyObject * obj0 = 0 ;
11518 if (!PyArg_ParseTuple(args,(
char *)
"O:plseed",&obj0))
SWIG_fail;
11523 arg1 = (
unsigned int)(val1);
11533 PyObject *resultobj = 0;
11537 PyObject * obj0 = 0 ;
11539 if (!PyArg_ParseTuple(args,(
char *)
"O:plsesc",&obj0))
SWIG_fail;
11544 arg1 = (char)(val1);
11554 PyObject *resultobj = 0;
11555 char *arg1 = (
char *) 0 ;
11556 char *arg2 = (
char *) 0 ;
11563 PyObject * obj0 = 0 ;
11564 PyObject * obj1 = 0 ;
11567 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsetopt",&obj0,&obj1))
SWIG_fail;
11572 arg1 = (
char *)(buf1);
11577 arg2 = (
char *)(buf2);
11578 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
11591 PyObject *resultobj = 0;
11601 PyObject * obj0 = 0 ;
11602 PyObject * obj1 = 0 ;
11603 PyObject * obj2 = 0 ;
11605 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfam",&obj0,&obj1,&obj2))
SWIG_fail;
11610 arg1 = (
PLINT)(val1);
11615 arg2 = (
PLINT)(val2);
11620 arg3 = (
PLINT)(val3);
11630 PyObject *resultobj = 0;
11632 unsigned int val1 ;
11634 PyObject * obj0 = 0 ;
11636 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfci",&obj0))
SWIG_fail;
11651 PyObject *resultobj = 0;
11652 char *arg1 = (
char *) 0 ;
11656 PyObject * obj0 = 0 ;
11658 if (!PyArg_ParseTuple(args,(
char *)
"O:plsfnam",&obj0))
SWIG_fail;
11663 arg1 = (
char *)(buf1);
11675 PyObject *resultobj = 0;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11689 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsfont",&obj0,&obj1,&obj2))
SWIG_fail;
11694 arg1 = (
PLINT)(val1);
11699 arg2 = (
PLINT)(val2);
11704 arg3 = (
PLINT)(val3);
11714 PyObject *resultobj = 0;
11715 PLFLT **arg1 = (PLFLT **) 0 ;
11723 PLFLT *arg9 = (PLFLT *) 0 ;
11732 PyArrayObject *tmp1 ;
11741 PyArrayObject *tmp9 ;
11750 PyObject * obj0 = 0 ;
11751 PyObject * obj1 = 0 ;
11752 PyObject * obj2 = 0 ;
11753 PyObject * obj3 = 0 ;
11754 PyObject * obj4 = 0 ;
11755 PyObject * obj5 = 0 ;
11756 PyObject * obj6 = 0 ;
11757 PyObject * obj7 = 0 ;
11758 PyObject * obj8 = 0 ;
11759 PyObject * obj9 = 0 ;
11760 PyObject * obj10 = 0 ;
11761 PyObject * obj11 = 0 ;
11776 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11))
SWIG_fail;
11780 if ( tmp1 == NULL )
11782 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11783 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11784 size =
sizeof (
PLFLT ) * arg3;
11785 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
11786 for ( i = 0; i < arg2; i++ )
11787 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11793 arg5 = (
PLFLT)(val5);
11798 arg6 = (
PLFLT)(val6);
11803 arg7 = (
PLFLT)(val7);
11808 arg8 = (
PLFLT)(val8);
11811 if ( tmp9 == NULL )
11813 arg10 = PyArray_DIMS( tmp9 )[0];
11814 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11820 arg11 = (
PLFLT)(val11);
11825 arg12 = (
PLINT)(val12);
11830 arg13 = (
PLFLT)(val13);
11835 arg15 = (
PLBOOL)(val15);
11839 if ( obj10 == Py_None )
11845 if ( !PyCallable_Check( (PyObject *) obj10 ) )
11847 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
11856 if ( obj11 == Py_None )
11864 plshades((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(
double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11899 PyObject *resultobj = 0;
11900 PLFLT **arg1 = (PLFLT **) 0 ;
11921 PyArrayObject *tmp1 ;
11950 PyObject * obj0 = 0 ;
11951 PyObject * obj1 = 0 ;
11952 PyObject * obj2 = 0 ;
11953 PyObject * obj3 = 0 ;
11954 PyObject * obj4 = 0 ;
11955 PyObject * obj5 = 0 ;
11956 PyObject * obj6 = 0 ;
11957 PyObject * obj7 = 0 ;
11958 PyObject * obj8 = 0 ;
11959 PyObject * obj9 = 0 ;
11960 PyObject * obj10 = 0 ;
11961 PyObject * obj11 = 0 ;
11962 PyObject * obj12 = 0 ;
11963 PyObject * obj13 = 0 ;
11964 PyObject * obj14 = 0 ;
11965 PyObject * obj15 = 0 ;
11966 PyObject * obj16 = 0 ;
11981 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;
11985 if ( tmp1 == NULL )
11987 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11988 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11989 size =
sizeof (
PLFLT ) * arg3;
11990 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
11991 for ( i = 0; i < arg2; i++ )
11992 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11998 arg5 = (
PLFLT)(val5);
12003 arg6 = (
PLFLT)(val6);
12008 arg7 = (
PLFLT)(val7);
12013 arg8 = (
PLFLT)(val8);
12018 arg9 = (
PLFLT)(val9);
12023 arg10 = (
PLFLT)(val10);
12028 arg11 = (
PLINT)(val11);
12033 arg12 = (
PLFLT)(val12);
12038 arg13 = (
PLFLT)(val13);
12043 arg14 = (
PLINT)(val14);
12048 arg15 = (
PLFLT)(val15);
12053 arg16 = (
PLINT)(val16);
12058 arg17 = (
PLFLT)(val17);
12063 arg19 = (
PLBOOL)(val19);
12067 if ( obj15 == Py_None )
12073 if ( !PyCallable_Check( (PyObject *) obj15 ) )
12075 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
12084 if ( obj16 == Py_None )
12092 plshade((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12121 PyObject *resultobj = 0;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12128 if (!PyArg_ParseTuple(args,(
char *)
"OO:plslabelfunc",&obj0,&obj1))
SWIG_fail;
12131 if ( python_label )
12133 Py_XDECREF( python_label );
12137 if ( obj0 == Py_None )
12143 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12145 PyErr_SetString( PyExc_ValueError,
"label_func argument must be callable" );
12149 Py_XINCREF( (PyObject *) obj0 );
12150 python_label = (PyObject *) obj0;
12168 PyObject *resultobj = 0;
12175 PyObject * obj0 = 0 ;
12176 PyObject * obj1 = 0 ;
12178 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmaj",&obj0,&obj1))
SWIG_fail;
12183 arg1 = (
PLFLT)(val1);
12188 arg2 = (
PLFLT)(val2);
12198 PyObject *resultobj = 0;
12201 void *arg3 = (
void *) 0 ;
12209 PyObject * obj0 = 0 ;
12210 PyObject * obj1 = 0 ;
12211 PyObject * obj2 = 0 ;
12213 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmem",&obj0,&obj1,&obj2))
SWIG_fail;
12218 arg1 = (
PLINT)(val1);
12223 arg2 = (
PLINT)(val2);
12225 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12230 arg3 = (
void *) buf3;
12241 PyObject *resultobj = 0;
12244 void *arg3 = (
void *) 0 ;
12252 PyObject * obj0 = 0 ;
12253 PyObject * obj1 = 0 ;
12254 PyObject * obj2 = 0 ;
12256 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsmema",&obj0,&obj1,&obj2))
SWIG_fail;
12261 arg1 = (
PLINT)(val1);
12266 arg2 = (
PLINT)(val2);
12268 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12273 arg3 = (
void *) buf3;
12284 PyObject *resultobj = 0;
12291 PyObject * obj0 = 0 ;
12292 PyObject * obj1 = 0 ;
12294 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsmin",&obj0,&obj1))
SWIG_fail;
12299 arg1 = (
PLFLT)(val1);
12304 arg2 = (
PLFLT)(val2);
12314 PyObject *resultobj = 0;
12318 PyObject * obj0 = 0 ;
12320 if (!PyArg_ParseTuple(args,(
char *)
"O:plsori",&obj0))
SWIG_fail;
12325 arg1 = (
PLINT)(val1);
12335 PyObject *resultobj = 0;
12354 PyObject * obj0 = 0 ;
12355 PyObject * obj1 = 0 ;
12356 PyObject * obj2 = 0 ;
12357 PyObject * obj3 = 0 ;
12358 PyObject * obj4 = 0 ;
12359 PyObject * obj5 = 0 ;
12361 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
12366 arg1 = (
PLFLT)(val1);
12371 arg2 = (
PLFLT)(val2);
12376 arg3 = (
PLINT)(val3);
12381 arg4 = (
PLINT)(val4);
12386 arg5 = (
PLINT)(val5);
12391 arg6 = (
PLINT)(val6);
12392 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12401 PyObject *resultobj = 0;
12402 char *arg1 = (
char *) 0 ;
12406 PyObject * obj0 = 0 ;
12408 if (!PyArg_ParseTuple(args,(
char *)
"O:plspal0",&obj0))
SWIG_fail;
12413 arg1 = (
char *)(buf1);
12425 PyObject *resultobj = 0;
12426 char *arg1 = (
char *) 0 ;
12433 PyObject * obj0 = 0 ;
12434 PyObject * obj1 = 0 ;
12436 if (!PyArg_ParseTuple(args,(
char *)
"OO:plspal1",&obj0,&obj1))
SWIG_fail;
12441 arg1 = (
char *)(buf1);
12447 plspal1((
char const *)arg1,arg2);
12458 PyObject *resultobj = 0;
12462 PyObject * obj0 = 0 ;
12464 if (!PyArg_ParseTuple(args,(
char *)
"O:plspause",&obj0))
SWIG_fail;
12479 PyObject *resultobj = 0;
12483 PyObject * obj0 = 0 ;
12485 if (!PyArg_ParseTuple(args,(
char *)
"O:plsstrm",&obj0))
SWIG_fail;
12490 arg1 = (
PLINT)(val1);
12500 PyObject *resultobj = 0;
12507 PyObject * obj0 = 0 ;
12508 PyObject * obj1 = 0 ;
12510 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssub",&obj0,&obj1))
SWIG_fail;
12515 arg1 = (
PLINT)(val1);
12520 arg2 = (
PLINT)(val2);
12530 PyObject *resultobj = 0;
12537 PyObject * obj0 = 0 ;
12538 PyObject * obj1 = 0 ;
12540 if (!PyArg_ParseTuple(args,(
char *)
"OO:plssym",&obj0,&obj1))
SWIG_fail;
12545 arg1 = (
PLFLT)(val1);
12550 arg2 = (
PLFLT)(val2);
12560 PyObject *resultobj = 0;
12567 PyObject * obj0 = 0 ;
12568 PyObject * obj1 = 0 ;
12570 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstar",&obj0,&obj1))
SWIG_fail;
12575 arg1 = (
PLINT)(val1);
12580 arg2 = (
PLINT)(val2);
12590 PyObject *resultobj = 0;
12591 char *arg1 = (
char *) 0 ;
12601 PyObject * obj0 = 0 ;
12602 PyObject * obj1 = 0 ;
12603 PyObject * obj2 = 0 ;
12605 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstart",&obj0,&obj1,&obj2))
SWIG_fail;
12610 arg1 = (
char *)(buf1);
12615 arg2 = (
PLINT)(val2);
12620 arg3 = (
PLINT)(val3);
12621 plstart((
char const *)arg1,arg2,arg3);
12632 PyObject *resultobj = 0;
12636 PyObject * obj0 = 0 ;
12637 PyObject * obj1 = 0 ;
12643 if (!PyArg_ParseTuple(args,(
char *)
"|OO:plstransform",&obj0,&obj1))
SWIG_fail;
12649 if ( obj0 == Py_None )
12655 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12657 PyErr_SetString( PyExc_ValueError,
"coordinate transform argument must be callable" );
12679 PyObject *resultobj = 0;
12681 PLFLT *arg2 = (PLFLT *) 0 ;
12682 PLFLT *arg3 = (PLFLT *) 0 ;
12683 char *arg4 = (
char *) 0 ;
12684 PyArrayObject *tmp1 ;
12685 PyArrayObject *tmp3 ;
12689 PyObject * obj0 = 0 ;
12690 PyObject * obj1 = 0 ;
12691 PyObject * obj2 = 0 ;
12693 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plstring",&obj0,&obj1,&obj2))
SWIG_fail;
12696 if ( tmp1 == NULL )
12698 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12699 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12703 if ( tmp3 == NULL )
12705 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12707 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12710 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12716 arg4 = (
char *)(buf4);
12717 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
12740 PyObject *resultobj = 0;
12742 PLFLT *arg2 = (PLFLT *) 0 ;
12743 PLFLT *arg3 = (PLFLT *) 0 ;
12744 PLFLT *arg4 = (PLFLT *) 0 ;
12745 char *arg5 = (
char *) 0 ;
12746 PyArrayObject *tmp1 ;
12747 PyArrayObject *tmp3 ;
12748 PyArrayObject *tmp4 ;
12752 PyObject * obj0 = 0 ;
12753 PyObject * obj1 = 0 ;
12754 PyObject * obj2 = 0 ;
12755 PyObject * obj3 = 0 ;
12757 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12760 if ( tmp1 == NULL )
12762 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12763 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12767 if ( tmp3 == NULL )
12769 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
12771 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12774 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12778 if ( tmp4 == NULL )
12780 if ( PyArray_DIMS( tmp4 )[0] !=
Alen )
12782 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
12785 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12791 arg5 = (
char *)(buf5);
12792 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
12821 PyObject *resultobj = 0;
12834 PyObject * obj0 = 0 ;
12835 PyObject * obj1 = 0 ;
12836 PyObject * obj2 = 0 ;
12837 PyObject * obj3 = 0 ;
12839 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
12844 arg1 = (
PLINT)(val1);
12849 arg2 = (
PLINT)(val2);
12854 arg3 = (
PLFLT)(val3);
12859 arg4 = (
PLFLT)(val4);
12869 PyObject *resultobj = 0;
12870 PLINT *arg1 = (PLINT *) 0 ;
12871 char *arg2 = (
char *) 0 ;
12872 char *arg3 = (
char *) 0 ;
12884 PLINT *arg15 = (PLINT *) 0 ;
12885 PLINT *arg16 = (PLINT *) 0 ;
12887 char *arg18 = (
char *) 0 ;
12888 char *arg19 = (
char *) 0 ;
12889 char *arg20 = (
char *) 0 ;
12920 PyArrayObject *tmp15 ;
12921 PyArrayObject *tmp16 ;
12931 PyObject * obj0 = 0 ;
12932 PyObject * obj1 = 0 ;
12933 PyObject * obj2 = 0 ;
12934 PyObject * obj3 = 0 ;
12935 PyObject * obj4 = 0 ;
12936 PyObject * obj5 = 0 ;
12937 PyObject * obj6 = 0 ;
12938 PyObject * obj7 = 0 ;
12939 PyObject * obj8 = 0 ;
12940 PyObject * obj9 = 0 ;
12941 PyObject * obj10 = 0 ;
12942 PyObject * obj11 = 0 ;
12943 PyObject * obj12 = 0 ;
12944 PyObject * obj13 = 0 ;
12945 PyObject * obj14 = 0 ;
12946 PyObject * obj15 = 0 ;
12947 PyObject * obj16 = 0 ;
12948 PyObject * obj17 = 0 ;
12949 PyObject * obj18 = 0 ;
12952 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;
12957 arg2 = (
char *)(buf2);
12962 arg3 = (
char *)(buf3);
12967 arg4 = (
PLFLT)(val4);
12972 arg5 = (
PLFLT)(val5);
12977 arg6 = (
PLFLT)(val6);
12982 arg7 = (
PLFLT)(val7);
12987 arg8 = (
PLFLT)(val8);
12992 arg9 = (
PLFLT)(val9);
12997 arg10 = (
PLFLT)(val10);
13002 arg11 = (
PLBOOL)(val11);
13007 arg12 = (
PLBOOL)(val12);
13012 arg13 = (
PLINT)(val13);
13017 arg14 = (
PLINT)(val14);
13020 if ( tmp15 == NULL )
13022 Alen = PyArray_DIMS( tmp15 )[0];
13023 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13027 if ( tmp16 == NULL )
13029 if ( PyArray_DIMS( tmp16 )[0] !=
Alen )
13031 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13034 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13040 PyErr_SetString( PyExc_ValueError,
"Requires a sequence of 4 strings." );
13045 PyErr_SetString( PyExc_ValueError,
"colline and styline args must be length 4." );
13048 arg17 = malloc(
sizeof (
char* ) * 4 );
13049 for ( i = 0; i < 4; i++ )
13052 if ( arg17[i] == NULL )
13063 arg18 = (
char *)(buf18);
13068 arg19 = (
char *)(buf19);
13073 arg20 = (
char *)(buf20);
13074 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);
13085 Py_DECREF( tmp15 );
13088 Py_DECREF( tmp16 );
13101 Py_DECREF( tmp15 );
13104 Py_DECREF( tmp16 );
13117 PyObject *resultobj = 0;
13121 PyObject * obj0 = 0 ;
13123 if (!PyArg_ParseTuple(args,(
char *)
"O:plstripd",&obj0))
SWIG_fail;
13128 arg1 = (
PLINT)(val1);
13138 PyObject *resultobj = 0;
13140 PLINT *arg2 = (PLINT *) 0 ;
13141 PLINT *arg3 = (PLINT *) 0 ;
13142 PyArrayObject *tmp1 ;
13143 PyArrayObject *tmp3 ;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13147 if (!PyArg_ParseTuple(args,(
char *)
"OO:plstyl",&obj0,&obj1))
SWIG_fail;
13150 if ( tmp1 == NULL )
13152 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13153 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13157 if ( tmp3 == NULL )
13159 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13161 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13164 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13166 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
13187 PyObject *resultobj = 0;
13188 PLFLT *arg1 = (PLFLT *) 0 ;
13189 PLFLT *arg2 = (PLFLT *) 0 ;
13192 PyArrayObject *tmp1 ;
13193 PyArrayObject *tmp2 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 PyObject * obj2 = 0 ;
13200 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsvect",&obj0,&obj1,&obj2))
SWIG_fail;
13203 if ( tmp1 == NULL )
13205 Alen = PyArray_DIMS( tmp1 )[0];
13206 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13210 if ( tmp2 == NULL )
13212 if ( PyArray_DIMS( tmp2 )[0] !=
Alen )
13214 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13217 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13218 arg3 = PyArray_DIMS( tmp2 )[0];
13225 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
13246 PyObject *resultobj = 0;
13259 PyObject * obj0 = 0 ;
13260 PyObject * obj1 = 0 ;
13261 PyObject * obj2 = 0 ;
13262 PyObject * obj3 = 0 ;
13264 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13269 arg1 = (
PLFLT)(val1);
13274 arg2 = (
PLFLT)(val2);
13279 arg3 = (
PLFLT)(val3);
13284 arg4 = (
PLFLT)(val4);
13285 plsvpa(arg1,arg2,arg3,arg4);
13294 PyObject *resultobj = 0;
13301 PyObject * obj0 = 0 ;
13302 PyObject * obj1 = 0 ;
13304 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsxax",&obj0,&obj1))
SWIG_fail;
13309 arg1 = (
PLINT)(val1);
13314 arg2 = (
PLINT)(val2);
13324 PyObject *resultobj = 0;
13331 PyObject * obj0 = 0 ;
13332 PyObject * obj1 = 0 ;
13334 if (!PyArg_ParseTuple(args,(
char *)
"OO:plsyax",&obj0,&obj1))
SWIG_fail;
13339 arg1 = (
PLINT)(val1);
13344 arg2 = (
PLINT)(val2);
13354 PyObject *resultobj = 0;
13356 PLFLT *arg2 = (PLFLT *) 0 ;
13357 PLFLT *arg3 = (PLFLT *) 0 ;
13359 PyArrayObject *tmp1 ;
13360 PyArrayObject *tmp3 ;
13363 PyObject * obj0 = 0 ;
13364 PyObject * obj1 = 0 ;
13365 PyObject * obj2 = 0 ;
13367 if (!PyArg_ParseTuple(args,(
char *)
"OOO:plsym",&obj0,&obj1,&obj2))
SWIG_fail;
13370 if ( tmp1 == NULL )
13372 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13373 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13377 if ( tmp3 == NULL )
13379 if ( PyArray_DIMS( tmp3 )[0] !=
Alen )
13381 PyErr_SetString( PyExc_ValueError,
"Vectors must be same length." );
13384 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13390 arg4 = (
PLINT)(val4);
13391 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
13412 PyObject *resultobj = 0;
13419 PyObject * obj0 = 0 ;
13420 PyObject * obj1 = 0 ;
13422 if (!PyArg_ParseTuple(args,(
char *)
"OO:plszax",&obj0,&obj1))
SWIG_fail;
13427 arg1 = (
PLINT)(val1);
13432 arg2 = (
PLINT)(val2);
13442 PyObject *resultobj = 0;
13444 if (!PyArg_ParseTuple(args,(
char *)
":pltext"))
SWIG_fail;
13454 PyObject *resultobj = 0;
13455 char *arg1 = (
char *) 0 ;
13459 PyObject * obj0 = 0 ;
13461 if (!PyArg_ParseTuple(args,(
char *)
"O:pltimefmt",&obj0))
SWIG_fail;
13466 arg1 = (
char *)(buf1);
13478 PyObject *resultobj = 0;
13482 PyObject * obj0 = 0 ;
13484 if (!PyArg_ParseTuple(args,(
char *)
"O:plvasp",&obj0))
SWIG_fail;
13489 arg1 = (
PLFLT)(val1);
13499 PyObject *resultobj = 0;
13500 PLFLT **arg1 = (PLFLT **) 0 ;
13501 PLFLT **arg2 = (PLFLT **) 0 ;
13507 PyArrayObject *tmp1 ;
13508 PyArrayObject *tmp2 ;
13511 PyObject * obj0 = 0 ;
13512 PyObject * obj1 = 0 ;
13513 PyObject * obj2 = 0 ;
13514 PyObject * obj3 = 0 ;
13515 PyObject * obj4 = 0 ;
13524 if (!PyArg_ParseTuple(args,(
char *)
"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13528 if ( tmp1 == NULL )
13530 Xlen = PyArray_DIMS( tmp1 )[0];
13531 Ylen = PyArray_DIMS( tmp1 )[1];
13533 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) *
Xlen );
13534 for ( i = 0; i <
Xlen; i++ )
13535 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
13540 if ( tmp2 == NULL )
13542 if ( Xlen != PyArray_DIMS( tmp2 )[0] ||
Ylen != PyArray_DIMS( tmp2 )[1] )
13544 PyErr_SetString( PyExc_ValueError,
"Vectors must match matrix." );
13547 arg3 = PyArray_DIMS( tmp2 )[0];
13548 arg4 = PyArray_DIMS( tmp2 )[1];
13549 size =
sizeof (
PLFLT ) * arg4;
13550 arg2 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg3 );
13551 for ( i = 0; i < arg3; i++ )
13552 arg2[i] = (PLFLT *) ( PyArray_DATA( tmp2 ) + i * size );
13558 arg5 = (
PLFLT)(val5);
13562 if ( obj3 == Py_None )
13568 if ( !PyCallable_Check( (PyObject *) obj3 ) )
13570 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
13579 if ( obj4 == Py_None )
13587 plvect((
double const **)arg1,(
double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13624 PyObject *resultobj = 0;
13640 PyObject * obj0 = 0 ;
13641 PyObject * obj1 = 0 ;
13642 PyObject * obj2 = 0 ;
13643 PyObject * obj3 = 0 ;
13644 PyObject * obj4 = 0 ;
13646 if (!PyArg_ParseTuple(args,(
char *)
"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4))
SWIG_fail;
13651 arg1 = (
PLFLT)(val1);
13656 arg2 = (
PLFLT)(val2);
13661 arg3 = (
PLFLT)(val3);
13666 arg4 = (
PLFLT)(val4);
13671 arg5 = (
PLFLT)(val5);
13672 plvpas(arg1,arg2,arg3,arg4,arg5);
13681 PyObject *resultobj = 0;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 PyObject * obj3 = 0 ;
13699 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13704 arg1 = (
PLFLT)(val1);
13709 arg2 = (
PLFLT)(val2);
13714 arg3 = (
PLFLT)(val3);
13719 arg4 = (
PLFLT)(val4);
13720 plvpor(arg1,arg2,arg3,arg4);
13729 PyObject *resultobj = 0;
13731 if (!PyArg_ParseTuple(args,(
char *)
":plvsta"))
SWIG_fail;
13741 PyObject *resultobj = 0;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 PyObject * obj2 = 0 ;
13778 PyObject * obj3 = 0 ;
13779 PyObject * obj4 = 0 ;
13780 PyObject * obj5 = 0 ;
13781 PyObject * obj6 = 0 ;
13782 PyObject * obj7 = 0 ;
13783 PyObject * obj8 = 0 ;
13784 PyObject * obj9 = 0 ;
13785 PyObject * obj10 = 0 ;
13787 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
13792 arg1 = (
PLFLT)(val1);
13797 arg2 = (
PLFLT)(val2);
13802 arg3 = (
PLFLT)(val3);
13807 arg4 = (
PLFLT)(val4);
13812 arg5 = (
PLFLT)(val5);
13817 arg6 = (
PLFLT)(val6);
13822 arg7 = (
PLFLT)(val7);
13827 arg8 = (
PLFLT)(val8);
13832 arg9 = (
PLFLT)(val9);
13837 arg10 = (
PLFLT)(val10);
13842 arg11 = (
PLFLT)(val11);
13843 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13852 PyObject *resultobj = 0;
13856 PyObject * obj0 = 0 ;
13858 if (!PyArg_ParseTuple(args,(
char *)
"O:plwidth",&obj0))
SWIG_fail;
13863 arg1 = (
PLINT)(val1);
13873 PyObject *resultobj = 0;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 PyObject * obj3 = 0 ;
13891 if (!PyArg_ParseTuple(args,(
char *)
"OOOO:plwind",&obj0,&obj1,&obj2,&obj3))
SWIG_fail;
13896 arg1 = (
PLFLT)(val1);
13901 arg2 = (
PLFLT)(val2);
13906 arg3 = (
PLFLT)(val3);
13911 arg4 = (
PLFLT)(val4);
13912 plwind(arg1,arg2,arg3,arg4);
13921 PyObject *resultobj = 0;
13928 PyObject * obj0 = 0 ;
13931 if (!PyArg_ParseTuple(args,(
char *)
"O:plxormod",&obj0))
SWIG_fail;
13952 PyObject *resultobj = 0;
13954 char *arg2 = (
char *) 0 ;
13970 PyObject * obj0 = 0 ;
13971 PyObject * obj1 = 0 ;
13972 PyObject * obj2 = 0 ;
13973 PyObject * obj3 = 0 ;
13974 PyObject * obj4 = 0 ;
13975 PyObject * obj5 = 0 ;
13978 python_mapform = 0;
13981 if (!PyArg_ParseTuple(args,(
char *)
"|OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5))
SWIG_fail;
13985 if ( obj0 == Py_None )
13991 if ( !PyCallable_Check( (PyObject *) obj0 ) )
13993 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14005 arg2 = (
char *)(buf2);
14012 arg3 = (
PLFLT)(val3);
14019 arg4 = (
PLFLT)(val4);
14026 arg5 = (
PLFLT)(val5);
14033 arg6 = (
PLFLT)(val6);
14035 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
14052 PyObject *resultobj = 0;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 PyObject * obj2 = 0 ;
14075 PyObject * obj3 = 0 ;
14076 PyObject * obj4 = 0 ;
14077 PyObject * obj5 = 0 ;
14078 PyObject * obj6 = 0 ;
14081 python_mapform = 0;
14084 if (!PyArg_ParseTuple(args,(
char *)
"|OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6))
SWIG_fail;
14088 if ( obj0 == Py_None )
14094 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14096 PyErr_SetString( PyExc_ValueError,
"mapform argument must be callable" );
14108 arg2 = (
PLFLT)(val2);
14115 arg3 = (
PLFLT)(val3);
14122 arg4 = (
PLFLT)(val4);
14129 arg5 = (
PLFLT)(val5);
14136 arg6 = (
PLFLT)(val6);
14143 arg7 = (
PLFLT)(val7);
14160 PyObject *resultobj = 0;
14161 PLFLT **arg1 = (PLFLT **) 0 ;
14174 PyArrayObject *tmp1 ;
14195 PyObject * obj0 = 0 ;
14196 PyObject * obj1 = 0 ;
14197 PyObject * obj2 = 0 ;
14198 PyObject * obj3 = 0 ;
14199 PyObject * obj4 = 0 ;
14200 PyObject * obj5 = 0 ;
14201 PyObject * obj6 = 0 ;
14202 PyObject * obj7 = 0 ;
14203 PyObject * obj8 = 0 ;
14204 PyObject * obj9 = 0 ;
14205 PyObject * obj10 = 0 ;
14207 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14211 if ( tmp1 == NULL )
14213 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14214 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14215 size =
sizeof (
PLFLT ) * arg3;
14216 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
14217 for ( i = 0; i < arg2; i++ )
14218 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14224 arg4 = (
PLFLT)(val4);
14229 arg5 = (
PLFLT)(val5);
14234 arg6 = (
PLFLT)(val6);
14239 arg7 = (
PLFLT)(val7);
14244 arg8 = (
PLFLT)(val8);
14249 arg9 = (
PLFLT)(val9);
14254 arg10 = (
PLFLT)(val10);
14259 arg11 = (
PLFLT)(val11);
14264 arg12 = (
PLFLT)(val12);
14269 arg13 = (
PLFLT)(val13);
14270 plimage((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14287 PyObject *resultobj = 0;
14288 PLFLT **arg1 = (PLFLT **) 0 ;
14301 PyArrayObject *tmp1 ;
14318 PyObject * obj0 = 0 ;
14319 PyObject * obj1 = 0 ;
14320 PyObject * obj2 = 0 ;
14321 PyObject * obj3 = 0 ;
14322 PyObject * obj4 = 0 ;
14323 PyObject * obj5 = 0 ;
14324 PyObject * obj6 = 0 ;
14325 PyObject * obj7 = 0 ;
14326 PyObject * obj8 = 0 ;
14327 PyObject * obj9 = 0 ;
14328 PyObject * obj10 = 0 ;
14337 if (!PyArg_ParseTuple(args,(
char *)
"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10))
SWIG_fail;
14341 if ( tmp1 == NULL )
14343 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14344 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14345 size =
sizeof (
PLFLT ) * arg3;
14346 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
14347 for ( i = 0; i < arg2; i++ )
14348 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14354 arg4 = (
PLFLT)(val4);
14359 arg5 = (
PLFLT)(val5);
14364 arg6 = (
PLFLT)(val6);
14369 arg7 = (
PLFLT)(val7);
14374 arg8 = (
PLFLT)(val8);
14379 arg9 = (
PLFLT)(val9);
14384 arg10 = (
PLFLT)(val10);
14389 arg11 = (
PLFLT)(val11);
14393 if ( obj9 == Py_None )
14399 if ( !PyCallable_Check( (PyObject *) obj9 ) )
14401 PyErr_SetString( PyExc_ValueError,
"pltr argument must be callable" );
14410 if ( obj10 == Py_None )
14418 plimagefr((
double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14447 PyObject *resultobj = 0;
14449 if (!PyArg_ParseTuple(args,(
char *)
":plClearOpts"))
SWIG_fail;
14459 PyObject *resultobj = 0;
14461 if (!PyArg_ParseTuple(args,(
char *)
":plResetOpts"))
SWIG_fail;
14471 PyObject *resultobj = 0;
14472 char *arg1 = (
char *) 0 ;
14473 char *arg2 = (
char *) 0 ;
14480 PyObject * obj0 = 0 ;
14481 PyObject * obj1 = 0 ;
14483 if (!PyArg_ParseTuple(args,(
char *)
"OO:plSetUsage",&obj0,&obj1))
SWIG_fail;
14488 arg1 = (
char *)(buf1);
14493 arg2 = (
char *)(buf2);
14494 plSetUsage((
char const *)arg1,(
char const *)arg2);
14507 PyObject *resultobj = 0;
14509 if (!PyArg_ParseTuple(args,(
char *)
":plOptUsage"))
SWIG_fail;
14519 PyObject *resultobj = 0;
14520 PLFLT **arg1 = (PLFLT **) 0 ;
14523 PLFLT *arg4 = (PLFLT *) 0 ;
14524 PLFLT *arg5 = (PLFLT *) 0 ;
14525 PyArrayObject *tmp1 ;
14530 PyObject * obj0 = 0 ;
14534 if (!PyArg_ParseTuple(args,(
char *)
"O:plMinMax2dGrid",&obj0))
SWIG_fail;
14538 if ( tmp1 == NULL )
14540 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14541 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14542 size =
sizeof (
PLFLT ) * arg3;
14543 arg1 = (PLFLT **) malloc(
sizeof ( PLFLT* ) * arg2 );
14544 for ( i = 0; i < arg2; i++ )
14545 arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14576 PyObject *resultobj = 0;
14580 PyObject * obj0 = 0 ;
14583 if (!PyArg_ParseTuple(args,(
char *)
"O:plGetCursor",&obj0))
SWIG_fail;
14599 { (
char *)
"pltr0",
_wrap_pltr0, METH_VARARGS, NULL},
14600 { (
char *)
"pltr1",
_wrap_pltr1, METH_VARARGS, NULL},
14601 { (
char *)
"pltr2",
_wrap_pltr2, METH_VARARGS, NULL},
14631 "Set format of numerical label for contours\n"
14635 " Set format of numerical label for contours. \n"
14637 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14639 " This function is used example 9. \n"
14645 "pl_setcontlabelformat(lexp, sigdig)\n"
14649 " lexp (PLINT, input) : If the contour numerical label is greater\n"
14650 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14651 " format is used. Default value of lexp is 4. \n"
14653 " sigdig (PLINT, input) : Number of significant digits. Default\n"
14658 "Set parameters of contour labelling other than format of numerical label\n"
14662 " Set parameters of contour labelling other than those handled by\n"
14663 " pl_setcontlabelformat. \n"
14665 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14667 " This function is used in example 9. \n"
14673 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14677 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14678 " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
14680 " size (PLFLT, input) : Font height for contour labels (normalized). \n"
14681 " Default value is 0.3. \n"
14683 " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
14684 " Default value is 0.1. \n"
14686 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14687 " contour labels on. Default is off (0). \n"
14690 { (
char *)
"pladv",
_wrap_pladv, METH_VARARGS, (
char *)
"\n"
14691 "Advance the (sub-)page\n"
14695 " Advances to the next subpage if sub=0, performing a page advance if\n"
14696 " there are no remaining subpages on the current page. If subpages\n"
14697 " aren't being used, pladv(0) will always advance the page. If sub>0,\n"
14698 " PLplot switches to the specified subpage. Note that this allows you\n"
14699 " to overwrite a plot on the specified subpage; if this is not what you\n"
14700 " intended, use pleop followed by plbop to first advance the page. This\n"
14701 " routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14702 " not used, pladv must be called after initializing PLplot but before\n"
14703 " defining the viewport. \n"
14705 " Redacted form: pladv(sub)\n"
14707 " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14717 " sub (PLINT, input) : Specifies the subpage number (starting from 1\n"
14718 " in the top left corner and increasing along the rows) to which to\n"
14719 " advance. Set to zero to advance to the next subpage. \n"
14722 { (
char *)
"plarc",
_wrap_plarc, METH_VARARGS, (
char *)
"\n"
14723 "Draw a circular or elliptical arc \n"
14727 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14728 " semiminor axis b, starting at angle1 and ending at angle2. \n"
14730 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14734 " This function is used in examples 3 and 27. \n"
14740 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14744 " x (PLFLT, input) : X coordinate of arc center. \n"
14746 " y (PLFLT, input) : Y coordinate of arc center. \n"
14748 " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
14750 " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
14752 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14753 " semimajor axis. \n"
14755 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14756 " semimajor axis. \n"
14758 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14761 " fill (PLBOOL, input) : Draw a filled arc. \n"
14764 { (
char *)
"plaxes",
_wrap_plaxes, METH_VARARGS, (
char *)
"\n"
14765 "Draw a box with axes, etc. with arbitrary origin \n"
14769 " Draws a box around the currently defined viewport with arbitrary\n"
14770 " world-coordinate origin specified by x0 and y0 and labels it with\n"
14771 " world coordinate values appropriate to the window. Thus plaxes should\n"
14772 " only be called after defining both viewport and window. The character\n"
14773 " strings xopt and yopt specify how the box should be drawn as described\n"
14774 " below. If ticks and/or subticks are to be drawn for a particular\n"
14775 " axis, the tick intervals and number of subintervals may be specified\n"
14776 " explicitly, or they may be defaulted by setting the appropriate\n"
14777 " arguments to zero. \n"
14779 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14781 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14785 " This function is not used in any examples. \n"
14791 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14795 " x0 (PLFLT, input) : World X coordinate of origin. \n"
14797 " y0 (PLFLT, input) : World Y coordinate of origin. \n"
14799 " xopt (const char *, input) : Pointer to character string specifying\n"
14800 " options for horizontal axis. The string can include any\n"
14801 " combination of the following letters (upper or lower case) in any\n"
14802 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14803 " is vertical line (x=0). \n"
14804 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14805 " c: Draws top (X) or right (Y) edge of frame. \n"
14806 " d: Plot labels as date / time. Values are assumed to be\n"
14807 " seconds since the epoch (as used by gmtime). \n"
14808 " f: Always use fixed point numeric labels. \n"
14809 " g: Draws a grid at the major tick interval. \n"
14810 " h: Draws a grid at the minor tick interval. \n"
14811 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14813 " l: Labels axis logarithmically. This only affects the labels,\n"
14814 " not the data, and so it is necessary to compute the logarithms\n"
14815 " of data points before passing them to any of the drawing\n"
14817 " m: Writes numeric labels at major tick intervals in the\n"
14818 " unconventional location (above box for X, right of box for Y). \n"
14819 " n: Writes numeric labels at major tick intervals in the\n"
14820 " conventional location (below box for X, left of box for Y). \n"
14821 " o: Use custom labeling function to generate axis label text. \n"
14822 " The custom labeling function can be defined with the\n"
14823 " plslabelfuncplslabelfunc; command. \n"
14824 " s: Enables subticks between major ticks, only valid if t is\n"
14825 " also specified. \n"
14826 " t: Draws major ticks. \n"
14829 " xtick (PLFLT, input) : World coordinate interval between major\n"
14830 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14831 " generates a suitable tick interval. \n"
14833 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14834 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14835 " generates a suitable minor tick interval. \n"
14837 " yopt (const char *, input) : Pointer to character string specifying\n"
14838 " options for vertical axis. The string can include any combination\n"
14839 " of the letters defined above for xopt, and in addition may\n"
14840 " contain: v: Write numeric labels for vertical axis parallel to the\n"
14841 " base of the graph, rather than parallel to the axis. \n"
14844 " ytick (PLFLT, input) : World coordinate interval between major\n"
14845 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14846 " generates a suitable tick interval. \n"
14848 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14849 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14850 " generates a suitable minor tick interval. \n"
14853 { (
char *)
"plbin",
_wrap_plbin, METH_VARARGS, (
char *)
"\n"
14854 "Plot a histogram from binned data \n"
14858 " Plots a histogram consisting of nbin bins. The value associated with\n"
14859 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14860 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14861 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14862 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14863 " placed midway between the values in the x array. Also see plhist for\n"
14864 " drawing histograms from unbinned data. \n"
14866 " Redacted form: General: plbin(x, y, opt)\n"
14867 " Perl/PDL: plbin(nbin, x, y, opt)\n"
14868 " Python: plbin(nbin, x, y, opt)\n"
14871 " This function is not used in any examples. \n"
14877 "plbin(nbin, x, y, opt)\n"
14881 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14882 " and y arrays.) \n"
14884 " x (PLFLT *, input) : Pointer to array containing values associated\n"
14885 " with bins. These must form a strictly increasing sequence. \n"
14887 " y (PLFLT *, input) : Pointer to array containing number of points\n"
14888 " in bin. This is a PLFLT (instead of PLINT) array so as to allow\n"
14889 " histograms of probabilities, etc. \n"
14891 " opt (PLINT, input) : Is a combination of several flags:\n"
14892 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14893 " outer bins are expanded to fill up the entire x-axis and bins of\n"
14894 " zero height are simply drawn. \n"
14895 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14896 " between the x values. If the values in x are equally spaced,\n"
14897 " the values are the center values of the bins. \n"
14898 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14899 " size as the ones inside. \n"
14900 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14901 " (there is a gap for such bins). \n"
14905 { (
char *)
"plbop",
_wrap_plbop, METH_VARARGS, (
char *)
"\n"
14906 "Begin a new page\n"
14910 " Begins a new page. For a file driver, the output file is opened if\n"
14911 " necessary. Advancing the page via pleop and plbop is useful when a\n"
14912 " page break is desired at a particular point when plotting to subpages.\n"
14913 " Another use for pleop and plbop is when plotting pages to different\n"
14914 " files, since you can manually set the file name by calling plsfnam\n"
14915 " after the call to pleop. (In fact some drivers may only support a\n"
14916 " single page per file, making this a necessity.) One way to handle\n"
14917 " this case automatically is to page advance via pladv, but enable\n"
14918 " familying (see plsfam) with a small limit on the file size so that a\n"
14919 " new family member file will be created on each page break. \n"
14921 " Redacted form: plbop()\n"
14923 " This function is used in examples 2,20. \n"
14932 { (
char *)
"plbox",
_wrap_plbox, METH_VARARGS, (
char *)
"\n"
14933 "Draw a box with axes, etc\n"
14937 " Draws a box around the currently defined viewport, and labels it with\n"
14938 " world coordinate values appropriate to the window. Thus plbox should\n"
14939 " only be called after defining both viewport and window. The character\n"
14940 " strings xopt and yopt specify how the box should be drawn as described\n"
14941 " below. If ticks and/or subticks are to be drawn for a particular\n"
14942 " axis, the tick intervals and number of subintervals may be specified\n"
14943 " explicitly, or they may be defaulted by setting the appropriate\n"
14944 " arguments to zero. \n"
14946 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14947 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
14950 " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
14956 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14960 " xopt (const char *, input) : Pointer to character string specifying\n"
14961 " options for horizontal axis. The string can include any\n"
14962 " combination of the following letters (upper or lower case) in any\n"
14963 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14964 " is vertical line (x=0). \n"
14965 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14966 " c: Draws top (X) or right (Y) edge of frame. \n"
14967 " d: Plot labels as date / time. Values are assumed to be\n"
14968 " seconds since the epoch (as used by gmtime). \n"
14969 " f: Always use fixed point numeric labels. \n"
14970 " g: Draws a grid at the major tick interval. \n"
14971 " h: Draws a grid at the minor tick interval. \n"
14972 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14974 " l: Labels axis logarithmically. This only affects the labels,\n"
14975 " not the data, and so it is necessary to compute the logarithms\n"
14976 " of data points before passing them to any of the drawing\n"
14978 " m: Writes numeric labels at major tick intervals in the\n"
14979 " unconventional location (above box for X, right of box for Y). \n"
14980 " n: Writes numeric labels at major tick intervals in the\n"
14981 " conventional location (below box for X, left of box for Y). \n"
14982 " o: Use custom labeling function to generate axis label text. \n"
14983 " The custom labeling function can be defined with the\n"
14984 " plslabelfuncplslabelfunc; command. \n"
14985 " s: Enables subticks between major ticks, only valid if t is\n"
14986 " also specified. \n"
14987 " t: Draws major ticks. \n"
14988 " u: Exactly like \"b\" except don't draw edge line. \n"
14989 " w: Exactly like \"c\" except don't draw edge line. \n"
14992 " xtick (PLFLT, input) : World coordinate interval between major\n"
14993 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14994 " generates a suitable tick interval. \n"
14996 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14997 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14998 " generates a suitable minor tick interval. \n"
15000 " yopt (const char *, input) : Pointer to character string specifying\n"
15001 " options for vertical axis. The string can include any combination\n"
15002 " of the letters defined above for xopt, and in addition may\n"
15003 " contain: v: Write numeric labels for vertical axis parallel to the\n"
15004 " base of the graph, rather than parallel to the axis. \n"
15007 " ytick (PLFLT, input) : World coordinate interval between major\n"
15008 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15009 " generates a suitable tick interval. \n"
15011 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15012 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15013 " generates a suitable minor tick interval. \n"
15016 { (
char *)
"plbox3",
_wrap_plbox3, METH_VARARGS, (
char *)
"\n"
15017 "Draw a box with axes, etc, in 3-d \n"
15021 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15022 " plot. For a more complete description of three-dimensional plotting\n"
15023 " see the PLplot documentation. \n"
15025 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15026 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15027 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15028 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15031 " This function is used in examples 8,11,18,21. \n"
15037 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15041 " xopt (const char *, input) : Pointer to character string specifying\n"
15042 " options for the x axis. The string can include any combination of\n"
15043 " the following letters (upper or lower case) in any order: b: Draws\n"
15044 " axis at base, at height z=\n"
15045 " zmin where zmin is defined by call to plw3d. This character must be\n"
15046 " specified in order to use any of the other options. \n"
15047 " f: Always use fixed point numeric labels. \n"
15048 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15049 " than upwards. \n"
15050 " l: Labels axis logarithmically. This only affects the labels,\n"
15051 " not the data, and so it is necessary to compute the logarithms\n"
15052 " of data points before passing them to any of the drawing\n"
15054 " n: Writes numeric labels at major tick intervals. \n"
15055 " o: Use custom labeling function to generate axis label text. \n"
15056 " The custom labeling function can be defined with the\n"
15057 " plslabelfuncplslabelfunc; command. \n"
15058 " s: Enables subticks between major ticks, only valid if t is\n"
15059 " also specified. \n"
15060 " t: Draws major ticks. \n"
15061 " u: If this is specified, the text label for the axis is\n"
15062 " written under the axis. \n"
15065 " xlabel (const char *, input) : Pointer to character string\n"
15066 " specifying text label for the x axis. It is only drawn if u is in\n"
15067 " the xopt string. \n"
15069 " xtick (PLFLT, input) : World coordinate interval between major\n"
15070 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15071 " generates a suitable tick interval. \n"
15073 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15074 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15075 " generates a suitable minor tick interval. \n"
15077 " yopt (const char *, input) : Pointer to character string specifying\n"
15078 " options for the y axis. The string is interpreted in the same way\n"
15081 " ylabel (const char *, input) : Pointer to character string\n"
15082 " specifying text label for the y axis. It is only drawn if u is in\n"
15083 " the yopt string. \n"
15085 " ytick (PLFLT, input) : World coordinate interval between major\n"
15086 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15087 " generates a suitable tick interval. \n"
15089 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15090 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15091 " generates a suitable minor tick interval. \n"
15093 " zopt (const char *, input) : Pointer to character string specifying\n"
15094 " options for the z axis. The string can include any combination of\n"
15095 " the following letters (upper or lower case) in any order: b: Draws\n"
15096 " z axis to the left of the surface plot. \n"
15097 " c: Draws z axis to the right of the surface plot. \n"
15098 " d: Draws grid lines parallel to the x-y plane behind the\n"
15099 " figure. These lines are not drawn until after plot3d or\n"
15100 " plmesh are called because of the need for hidden line removal. \n"
15101 " f: Always use fixed point numeric labels. \n"
15102 " i: Inverts tick marks, so they are drawn away from the center. \n"
15103 " l: Labels axis logarithmically. This only affects the labels,\n"
15104 " not the data, and so it is necessary to compute the logarithms\n"
15105 " of data points before passing them to any of the drawing\n"
15107 " m: Writes numeric labels at major tick intervals on the\n"
15108 " right-hand vertical axis. \n"
15109 " n: Writes numeric labels at major tick intervals on the\n"
15110 " left-hand vertical axis. \n"
15111 " o: Use custom labeling function to generate axis label text. \n"
15112 " The custom labeling function can be defined with the\n"
15113 " plslabelfuncplslabelfunc; command. \n"
15114 " s: Enables subticks between major ticks, only valid if t is\n"
15115 " also specified. \n"
15116 " t: Draws major ticks. \n"
15117 " u: If this is specified, the text label is written beside the\n"
15118 " left-hand axis. \n"
15119 " v: If this is specified, the text label is written beside the\n"
15120 " right-hand axis. \n"
15123 " zlabel (const char *, input) : Pointer to character string\n"
15124 " specifying text label for the z axis. It is only drawn if u or v\n"
15125 " are in the zopt string. \n"
15127 " ztick (PLFLT, input) : World coordinate interval between major\n"
15128 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15129 " generates a suitable tick interval. \n"
15131 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15132 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15133 " generates a suitable minor tick interval. \n"
15137 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15141 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15142 " from relative device coordinates, rx and ry. \n"
15144 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15145 " Perl/PDL: Not available? \n"
15148 " This function is used in example 31. \n"
15154 "plcalc_world(rx, ry, wx, wy, window)\n"
15158 " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15159 " 0. to 1.) for the x coordinate. \n"
15161 " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15162 " 0. to 1.) for the y coordinate. \n"
15164 " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15165 " x corresponding to the relative device coordinates rx and ry. \n"
15167 " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15168 " y corresponding to the relative device coordinates rx and ry. \n"
15170 " window (PLINT *, output) : Pointer to the returned last defined\n"
15171 " window index that corresponds to the input relative device\n"
15172 " coordinates (and the returned world coordinates). To give some\n"
15173 " background on the window index, for each page the initial window\n"
15174 " index is set to zero, and each time plwind is called within the\n"
15175 " page, world and device coordinates are stored for the window and\n"
15176 " the window index is incremented. Thus, for a simple page layout\n"
15177 " with non-overlapping viewports and one window per viewport, window\n"
15178 " corresponds to the viewport index (in the order which the\n"
15179 " viewport/windows were created) of the only viewport/window\n"
15180 " corresponding to rx and ry. However, for more complicated layouts\n"
15181 " with potentially overlapping viewports and possibly more than one\n"
15182 " window (set of world coordinates) per viewport, window and the\n"
15183 " corresponding output world coordinates corresponds to the last\n"
15184 " window created that fulfils the criterion that the relative device\n"
15185 " coordinates are inside it. Finally, in all cases where the input\n"
15186 " relative device coordinates are not inside any viewport/window,\n"
15187 " then window is set to -1. \n"
15190 { (
char *)
"plclear",
_wrap_plclear, METH_VARARGS, (
char *)
"\n"
15191 "Clear current (sub)page \n"
15195 " Clears the current page, effectively erasing everything that have been\n"
15196 " drawn. This command only works with interactive drivers; if the\n"
15197 " driver does not support this, the page is filled with the background\n"
15198 " color in use. If the current page is divided into subpages, only the\n"
15199 " current subpage is erased. The nth subpage can be selected with\n"
15202 " Redacted form: General: plclear()\n"
15203 " Perl/PDL: Not available? \n"
15206 " This function is not used in any examples. \n"
15215 { (
char *)
"plcol0",
_wrap_plcol0, METH_VARARGS, (
char *)
"\n"
15216 "Set color, map0 \n"
15220 " Sets the color for color map0 (see the PLplot documentation). \n"
15222 " Redacted form: plcol0(color)\n"
15224 " This function is used in examples 1-9,11-16,18-27,29. \n"
15234 " color (PLINT, input) : Integer representing the color. The\n"
15235 " defaults at present are (these may change): \n"
15236 " 0 black (default background) \n"
15237 " 1 red (default foreground) \n"
15246 " 10 BlueViolet \n"
15253 " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15254 " change an individual color in the map0 color palette. \n"
15257 { (
char *)
"plcol1",
_wrap_plcol1, METH_VARARGS, (
char *)
"\n"
15258 "Set color, map1 \n"
15262 " Sets the color for color map1 (see the PLplot documentation). \n"
15264 " Redacted form: plcol1(col1)\n"
15266 " This function is used in examples 12 and 21. \n"
15276 " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15277 " and is mapped to color using the continuous map1 color palette\n"
15278 " which by default ranges from blue to the background color to red. \n"
15279 " The map1 palette can also be straightforwardly changed by the user\n"
15280 " with plscmap1 or plscmap1l. \n"
15284 { (
char *)
"plcont",
_wrap_plcont, METH_VARARGS, (
char *)
"\n"
15289 " Draws a contour plot of the data in z[\n"
15291 " ny], using the nlevel contour levels specified by clevel. Only the\n"
15292 " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15293 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15294 " additional data required by the transformation routine is used to map\n"
15295 " indices within the array to the world coordinates. See the following\n"
15296 " discussion of the arguments and the PLplot documentation for more\n"
15299 " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
15300 " plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
15301 " clevel, xgrid, ygrid)\n"
15302 " Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
15303 " Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15304 " Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
15307 " This function is used in examples 9,14,16,22. \n"
15313 "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15317 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
15318 " containing data to be contoured. \n"
15320 " nx, ny (PLINT, input) : Physical dimensions of array z. \n"
15322 " kx, lx (PLINT, input) : Range of x indices to consider. \n"
15324 " ky, ly (PLINT, input) : Range of y indices to consider. \n"
15326 " clevel (PLFLT *, input) : Pointer to array specifying levels at\n"
15327 " which to draw contours. \n"
15329 " nlevel (PLINT, input) : Number of contour levels to draw. \n"
15331 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
15332 " Pointer to function that defines transformation between indices\n"
15333 " in array z and the world coordinates (C only). Transformation\n"
15334 " functions are provided in the PLplot library: pltr0 for identity\n"
15335 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
15336 " defined by one- and two-dimensional arrays. In addition,\n"
15337 " user-supplied routines for the transformation can be used as well.\n"
15338 " Examples of all of these approaches are given in the PLplot\n"
15339 " documentation. The transformation function should have the form\n"
15340 " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
15341 " and similar PLplot functions which have a pltr argument, plcont\n"
15342 " requires that a transformation function be provided in the C\n"
15343 " interface. Leaving pltr NULL will result in an error. \n"
15345 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15346 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
15347 " externally supplied. \n"
15351 { (
char *)
"plcpstrm",
_wrap_plcpstrm, METH_VARARGS, (
char *)
"\n"
15352 "Copy state parameters from the reference stream to the current stream \n"
15356 " Copies state parameters from the reference stream to the current\n"
15357 " stream. Tell driver interface to map device coordinates unless flags\n"
15360 " This function is used for making save files of selected plots (e.g.\n"
15361 " from the TK driver). After initializing, you can get a copy of the\n"
15362 " current plot to the specified device by switching to this stream and\n"
15363 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15364 " appropriate. The plot buffer must have previously been enabled (done\n"
15365 " automatically by some display drivers, such as X). \n"
15367 " Redacted form: plcpstrm(iplsr, flags)\n"
15369 " This function is used in example 1,20. \n"
15375 "plcpstrm(iplsr, flags)\n"
15379 " iplsr (PLINT, input) : Number of reference stream. \n"
15381 " flags (PLBOOL, input) : If flags is set to true the device\n"
15382 " coordinates are not copied from the reference to current stream. \n"
15385 { (
char *)
"plend",
_wrap_plend, METH_VARARGS, (
char *)
"\n"
15386 "End plotting session \n"
15390 " Ends a plotting session, tidies up all the output files, switches\n"
15391 " interactive devices back into text mode and frees up any memory that\n"
15392 " was allocated. Must be called before end of program. \n"
15394 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15395 " wait state after a call to plend or other functions which trigger the\n"
15396 " end of a plot page. To avoid this, use the plspause function. \n"
15398 " Redacted form: plend()\n"
15400 " This function is used in all of the examples. \n"
15409 { (
char *)
"plend1",
_wrap_plend1, METH_VARARGS, (
char *)
"\n"
15410 "End plotting session for current stream \n"
15414 " Ends a plotting session for the current output stream only. See\n"
15415 " plsstrm for more info. \n"
15417 " Redacted form: plend1()\n"
15419 " This function is used in examples 1,20. \n"
15428 { (
char *)
"plenv",
_wrap_plenv, METH_VARARGS, (
char *)
"\n"
15429 "Set up standard window and draw box \n"
15433 " Sets up plotter environment for simple graphs by calling pladv and\n"
15434 " setting up viewport and window to sensible default values. plenv\n"
15435 " leaves enough room around most graphs for axis labels and a title.\n"
15436 " When these defaults are not suitable, use the individual routines\n"
15437 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15438 " defining the window, and plbox for drawing the box. \n"
15440 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15442 " This function is used in example 1,3,9,13,14,19-22,29. \n"
15448 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15452 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15453 " world coordinates). \n"
15455 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15456 " world coordinates). \n"
15458 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15459 " coordinates). \n"
15461 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15462 " coordinates). \n"
15464 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15465 " scales will not be set, the user must set up the scale before\n"
15466 " calling plenv using plsvpa, plvasp or other. \n"
15467 " 0: the x and y axes are scaled independently to use as much of\n"
15468 " the screen as possible. \n"
15469 " 1: the scales of the x and y axes are made equal. \n"
15470 " 2: the axis of the x and y axes are made equal, and the plot\n"
15471 " box will be square. \n"
15474 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15475 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15476 " -1: draw box only. \n"
15477 " 0: draw box, ticks, and numeric tick labels. \n"
15478 " 1: also draw coordinate axes at x=0 and y=0. \n"
15479 " 2: also draw a grid at major tick positions in both\n"
15481 " 3: also draw a grid at minor tick positions in both\n"
15483 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15484 " have to be converted to logarithms separately.) \n"
15485 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15486 " have to be converted to logarithms separately.) \n"
15487 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15488 " have to be converted to logarithms separately.) \n"
15489 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15490 " have to be converted to logarithms separately.) \n"
15491 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15492 " have to be converted to logarithms separately.) \n"
15493 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15494 " have to be converted to logarithms separately.) \n"
15495 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15496 " have to be converted to logarithms separately.) \n"
15497 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15498 " have to be converted to logarithms separately.) \n"
15499 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15500 " and y data have to be converted to logarithms separately.) \n"
15501 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15502 " and y data have to be converted to logarithms separately.) \n"
15503 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15504 " and y data have to be converted to logarithms separately.) \n"
15505 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15506 " and y data have to be converted to logarithms separately.) \n"
15507 " 40: same as 0 except date / time x labels. \n"
15508 " 41: same as 1 except date / time x labels. \n"
15509 " 42: same as 2 except date / time x labels. \n"
15510 " 43: same as 3 except date / time x labels. \n"
15511 " 50: same as 0 except date / time y labels. \n"
15512 " 51: same as 1 except date / time y labels. \n"
15513 " 52: same as 2 except date / time y labels. \n"
15514 " 53: same as 3 except date / time y labels. \n"
15515 " 60: same as 0 except date / time x and y labels. \n"
15516 " 61: same as 1 except date / time x and y labels. \n"
15517 " 62: same as 2 except date / time x and y labels. \n"
15518 " 63: same as 3 except date / time x and y labels. \n"
15519 " 70: same as 0 except custom x and y labels. \n"
15520 " 71: same as 1 except custom x and y labels. \n"
15521 " 72: same as 2 except custom x and y labels. \n"
15522 " 73: same as 3 except custom x and y labels. \n"
15525 { (
char *)
"plenv0",
_wrap_plenv0, METH_VARARGS, (
char *)
"\n"
15526 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
15530 " Sets up plotter environment for simple graphs by calling pladv and\n"
15531 " setting up viewport and window to sensible default values. plenv0\n"
15532 " leaves enough room around most graphs for axis labels and a title.\n"
15533 " When these defaults are not suitable, use the individual routines\n"
15534 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15535 " defining the window, and plbox for drawing the box. \n"
15537 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15539 " This function is used in example 21. \n"
15545 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15549 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15550 " world coordinates). \n"
15552 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15553 " world coordinates). \n"
15555 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15556 " coordinates). \n"
15558 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15559 " coordinates). \n"
15561 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15562 " scales will not be set, the user must set up the scale before\n"
15563 " calling plenv0 using plsvpa, plvasp or other. \n"
15564 " 0: the x and y axes are scaled independently to use as much of\n"
15565 " the screen as possible. \n"
15566 " 1: the scales of the x and y axes are made equal. \n"
15567 " 2: the axis of the x and y axes are made equal, and the plot\n"
15568 " box will be square. \n"
15571 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15572 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15573 " -1: draw box only. \n"
15574 " 0: draw box, ticks, and numeric tick labels. \n"
15575 " 1: also draw coordinate axes at x=0 and y=0. \n"
15576 " 2: also draw a grid at major tick positions in both\n"
15578 " 3: also draw a grid at minor tick positions in both\n"
15580 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15581 " have to be converted to logarithms separately.) \n"
15582 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15583 " have to be converted to logarithms separately.) \n"
15584 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15585 " have to be converted to logarithms separately.) \n"
15586 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15587 " have to be converted to logarithms separately.) \n"
15588 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15589 " have to be converted to logarithms separately.) \n"
15590 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15591 " have to be converted to logarithms separately.) \n"
15592 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15593 " have to be converted to logarithms separately.) \n"
15594 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15595 " have to be converted to logarithms separately.) \n"
15596 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15597 " and y data have to be converted to logarithms separately.) \n"
15598 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15599 " and y data have to be converted to logarithms separately.) \n"
15600 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15601 " and y data have to be converted to logarithms separately.) \n"
15602 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15603 " and y data have to be converted to logarithms separately.) \n"
15604 " 40: same as 0 except date / time x labels. \n"
15605 " 41: same as 1 except date / time x labels. \n"
15606 " 42: same as 2 except date / time x labels. \n"
15607 " 43: same as 3 except date / time x labels. \n"
15608 " 50: same as 0 except date / time y labels. \n"
15609 " 51: same as 1 except date / time y labels. \n"
15610 " 52: same as 2 except date / time y labels. \n"
15611 " 53: same as 3 except date / time y labels. \n"
15612 " 60: same as 0 except date / time x and y labels. \n"
15613 " 61: same as 1 except date / time x and y labels. \n"
15614 " 62: same as 2 except date / time x and y labels. \n"
15615 " 63: same as 3 except date / time x and y labels. \n"
15616 " 70: same as 0 except custom x and y labels. \n"
15617 " 71: same as 1 except custom x and y labels. \n"
15618 " 72: same as 2 except custom x and y labels. \n"
15619 " 73: same as 3 except custom x and y labels. \n"
15622 { (
char *)
"pleop",
_wrap_pleop, METH_VARARGS, (
char *)
"\n"
15623 "Eject current page \n"
15627 " Clears the graphics screen of an interactive device, or ejects a page\n"
15628 " on a plotter. See plbop for more information. \n"
15630 " Redacted form: pleop()\n"
15632 " This function is used in example 2,14. \n"
15641 { (
char *)
"plerrx",
_wrap_plerrx, METH_VARARGS, (
char *)
"\n"
15642 "Draw x error bar \n"
15646 " Draws a set of n horizontal error bars, the i'th error bar extending\n"
15647 " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
15648 " error bar are of length equal to the minor tick length (settable using\n"
15651 " Redacted form: General: plerrx(xmin, ymax, y)\n"
15652 " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15655 " This function is used in example 29. \n"
15661 "plerrx(n, xmin, xmax, y)\n"
15665 " n (PLINT, input) : Number of error bars to draw. \n"
15667 " xmin (PLFLT *, input) : Pointer to array with x coordinates of\n"
15668 " left-hand endpoint of error bars. \n"
15670 " xmax (PLFLT *, input) : Pointer to array with x coordinates of\n"
15671 " right-hand endpoint of error bars. \n"
15673 " y (PLFLT *, input) : Pointer to array with y coordinates of error\n"
15677 { (
char *)
"plerry",
_wrap_plerry, METH_VARARGS, (
char *)
"\n"
15678 "Draw y error bar \n"
15682 " Draws a set of n vertical error bars, the i'th error bar extending\n"
15683 " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
15684 " error bar are of length equal to the minor tick length (settable using\n"
15687 " Redacted form: General: plerry(x, ymin, ymax)\n"
15688 " Perl/PDL: plerry(n, x, ymin, ymax)\n"
15691 " This function is used in example 29. \n"
15697 "plerry(n, x, ymin, ymax)\n"
15701 " n (PLINT, input) : Number of error bars to draw. \n"
15703 " x (PLFLT *, input) : Pointer to array with x coordinates of error\n"
15706 " ymin (PLFLT *, input) : Pointer to array with y coordinates of\n"
15707 " lower endpoint of error bars. \n"
15709 " ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n"
15710 " endpoint of error bar. \n"
15713 { (
char *)
"plfamadv",
_wrap_plfamadv, METH_VARARGS, (
char *)
"\n"
15714 "Advance to the next family file on the next new page \n"
15718 " Advance to the next family file on the next new page. \n"
15720 " Redacted form: plfamadv()\n"
15722 " This function is not used in any examples. \n"
15731 { (
char *)
"plfill",
_wrap_plfill, METH_VARARGS, (
char *)
"\n"
15732 "Draw filled polygon \n"
15736 " Fills the polygon defined by the n points (\n"
15738 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15739 " style is a solid fill. The routine will automatically close the\n"
15740 " polygon between the last and first vertices. If multiple closed\n"
15741 " polygons are passed in x and y then plfill will fill in between them. \n"
15743 " Redacted form: plfill(x,y)\n"
15745 " This function is used in examples 12,13,15,16,21,24,25. \n"
15751 "plfill(n, x, y)\n"
15755 " n (PLINT, input) : Number of vertices in polygon. \n"
15757 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15760 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15764 { (
char *)
"plfill3",
_wrap_plfill3, METH_VARARGS, (
char *)
"\n"
15765 "Draw filled polygon in 3D \n"
15769 " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15770 " using the pattern defined by plpsty or plpat. The routine will\n"
15771 " automatically close the polygon between the last and first vertices. \n"
15772 " If multiple closed polygons are passed in x, y, and z then plfill3\n"
15773 " will fill in between them. \n"
15775 " Redacted form: General: plfill3(x, y, z)\n"
15776 " Perl/PDL: plfill3(n, x, y, z)\n"
15779 " This function is used in example 15. \n"
15785 "plfill3(n, x, y, z)\n"
15789 " n (PLINT, input) : Number of vertices in polygon. \n"
15791 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15794 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15797 " z (PLFLT *, input) : Pointer to array with z coordinates of\n"
15802 "Draw linear gradient inside polygon \n"
15806 " Draw a linear gradient using colour map 1 inside the polygon defined\n"
15807 " by the n points (\n"
15809 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15810 " polygon coordinates and the gradient angle are all expressed in world\n"
15811 " coordinates. The angle from the x axis for both the rotated\n"
15812 " coordinate system and the gradient vector is specified by angle. The\n"
15813 " magnitude of the gradient vector is the difference between the maximum\n"
15814 " and minimum values of x for the vertices in the rotated coordinate\n"
15815 " system. The origin of the gradient vector can be interpreted as being\n"
15816 " anywhere on the line corresponding to the minimum x value for the\n"
15817 " vertices in the rotated coordinate system. The distance along the\n"
15818 " gradient vector is linearly transformed to the independent variable of\n"
15819 " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15820 " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15821 " colour corresponding to the independent variable of colour map 1. For\n"
15822 " more information about colour map 1 (see the PLplot documentation). \n"
15824 " Redacted form: plgradient(x,y,angle)\n"
15826 " This function is used in examples 25,30. \n"
15832 "plgradient(n, x, y, angle)\n"
15836 " n (PLINT, input) : Number of vertices in polygon. \n"
15838 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15841 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15844 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
15848 { (
char *)
"plflush",
_wrap_plflush, METH_VARARGS, (
char *)
"\n"
15849 "Flushes the output stream \n"
15853 " Flushes the output stream. Use sparingly, if at all. \n"
15855 " Redacted form: plflush()\n"
15857 " This function is used in examples 1,14. \n"
15866 { (
char *)
"plfont",
_wrap_plfont, METH_VARARGS, (
char *)
"\n"
15867 "Set character font \n"
15871 " Sets the default character font for subsequent character drawing. Also\n"
15872 " affects symbols produced by plpoin. This routine has no effect unless\n"
15873 " the extended character set is loaded (see plfontld). \n"
15875 " Redacted form: plfont(font)\n"
15877 " This function is used in examples 1,2,4,7,13,24,26. \n"
15887 " font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
15889 " 2: Roman font \n"
15890 " 3: Italic font \n"
15891 " 4: Script font \n"
15894 { (
char *)
"plfontld",
_wrap_plfontld, METH_VARARGS, (
char *)
"\n"
15895 "Load character font \n"
15899 " Sets the character set to use for subsequent character drawing. May\n"
15900 " be called before initializing PLplot. \n"
15902 " Redacted form: plfontld(set)\n"
15904 " This function is used in examples 1,7. \n"
15914 " set (PLINT, input) : Specifies the character set to load: 0:\n"
15915 " Standard character set \n"
15916 " 1: Extended character set \n"
15919 { (
char *)
"plgchr",
_wrap_plgchr, METH_VARARGS, (
char *)
"\n"
15920 "Get character default height and current (scaled) height \n"
15924 " Get character default height and current (scaled) height. \n"
15926 " Redacted form: plgchr(p_def, p_ht)\n"
15928 " This function is used in example 23. \n"
15934 "plgchr(p_def, p_ht)\n"
15938 " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
15940 " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
15944 { (
char *)
"plgcol0",
_wrap_plgcol0, METH_VARARGS, (
char *)
"\n"
15945 "Returns 8-bit RGB values for given color from color map0 \n"
15949 " Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
15950 " the PLplot documentation). Values are negative if an invalid color id\n"
15953 " Redacted form: plgcol0(icol0, r, g, b)\n"
15955 " This function is used in example 2. \n"
15961 "plgcol0(icol0, r, g, b)\n"
15965 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15967 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15969 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15971 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15974 { (
char *)
"plgcol0a",
_wrap_plgcol0a, METH_VARARGS, (
char *)
"\n"
15975 "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
15979 " Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
15980 " for given color from color map0 (see the PLplot documentation). \n"
15981 " Values are negative if an invalid color id is given. \n"
15983 " This function is used in example 30. \n"
15989 "plgcol0a(icol0, r, g, b, a)\n"
15993 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15995 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15997 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15999 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16001 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16004 { (
char *)
"plgcolbg",
_wrap_plgcolbg, METH_VARARGS, (
char *)
"\n"
16005 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
16009 " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
16011 " Redacted form: plgcolbg(r, g, b)\n"
16013 " This function is used in example 31. \n"
16019 "lgcolbg(r, g, b)\n"
16023 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16024 " representing the degree of red in the color. \n"
16026 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16027 " representing the degree of green in the color. \n"
16029 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16030 " representing the degree of blue in the color. \n"
16034 "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n"
16038 " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16041 " This function is used in example 31. \n"
16047 "lgcolbga(r, g, b, a)\n"
16051 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16052 " representing the degree of red in the color. \n"
16054 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16055 " representing the degree of green in the color. \n"
16057 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16058 " representing the degree of blue in the color. \n"
16060 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16064 "Get the current device-compression setting \n"
16068 " Get the current device-compression setting. This parameter is only\n"
16069 " used for drivers that provide compression. \n"
16071 " Redacted form: plgcompression(compression)\n"
16073 " This function is used in example 31. \n"
16079 "plgcompression(compression)\n"
16083 " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16084 " with the current device-compression setting. \n"
16087 { (
char *)
"plgdev",
_wrap_plgdev, METH_VARARGS, (
char *)
"\n"
16088 "Get the current device (keyword) name \n"
16092 " Get the current device (keyword) name. Note: you must have allocated\n"
16093 " space for this (80 characters is safe). \n"
16095 " Redacted form: plgdev(p_dev)\n"
16097 " This function is used in example 14. \n"
16107 " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16110 { (
char *)
"plgdidev",
_wrap_plgdidev, METH_VARARGS, (
char *)
"\n"
16111 "Get parameters that define current device-space window \n"
16115 " Get relative margin width, aspect ratio, and relative justification\n"
16116 " that define current device-space window. If plsdidev has not been\n"
16117 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16118 " p_jy will all be 0. \n"
16120 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16122 " This function is used in example 31. \n"
16128 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16132 " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16134 " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16136 " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16138 " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16141 { (
char *)
"plgdiori",
_wrap_plgdiori, METH_VARARGS, (
char *)
"\n"
16142 "Get plot orientation \n"
16146 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16147 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16148 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16149 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16150 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16151 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16152 " not been called the default value pointed to by p_rot will be 0. \n"
16154 " Redacted form: plgdiori(p_rot)\n"
16156 " This function is not used in any examples. \n"
16162 "plgdiori(p_rot)\n"
16166 " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16169 { (
char *)
"plgdiplt",
_wrap_plgdiplt, METH_VARARGS, (
char *)
"\n"
16170 "Get parameters that define current plot-space window \n"
16174 " Get relative minima and maxima that define current plot-space window.\n"
16175 " If plsdiplt has not been called the default values pointed to by\n"
16176 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16178 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16180 " This function is used in example 31. \n"
16186 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16190 " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16192 " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16194 " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16196 " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16199 { (
char *)
"plgfam",
_wrap_plgfam, METH_VARARGS, (
char *)
"\n"
16200 "Get family file parameters \n"
16204 " Gets information about current family file, if familying is enabled. \n"
16205 " See the PLplot documentation for more information. \n"
16207 " Redacted form: plgfam(fam, num, bmax)\n"
16209 " This function is used in examples 14,31. \n"
16215 "plgfam(fam, num, bmax)\n"
16219 " fam (PLINT *, output) : Pointer to variable with the Boolean family\n"
16220 " flag value. If nonzero, familying is enabled. \n"
16222 " num (PLINT *, output) : Pointer to variable with the current family\n"
16225 " bmax (PLINT *, output) : Pointer to variable with the maximum file\n"
16226 " size (in bytes) for a family file. \n"
16229 { (
char *)
"plgfci",
_wrap_plgfci, METH_VARARGS, (
char *)
"\n"
16230 "Get FCI (font characterization integer) \n"
16234 " Gets information about the current font using the FCI approach. See\n"
16235 " the PLplot documentation for more information. \n"
16237 " Redacted form: plgfci(fci)\n"
16239 " This function is used in example 23. \n"
16249 " fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
16250 " integer) variable which is updated with current FCI value. \n"
16253 { (
char *)
"plgfnam",
_wrap_plgfnam, METH_VARARGS, (
char *)
"\n"
16254 "Get output file name \n"
16258 " Gets the current output file name, if applicable. \n"
16260 " Redacted form: plgfnam(fnam)\n"
16262 " This function is used in example 31. \n"
16272 " fnam (char *, output) : Pointer to file name string (a preallocated\n"
16273 " string of 80 characters or more). \n"
16276 { (
char *)
"plgfont",
_wrap_plgfont, METH_VARARGS, (
char *)
"\n"
16277 "Get family, style and weight of the current font \n"
16281 " Gets information about current font. See the PLplot documentation for\n"
16282 " more information on font selection. \n"
16284 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16286 " This function is used in example 23. \n"
16292 "plgfont(p_family, p_style, p_weight)\n"
16296 " p_family (PLINT *, output) : Pointer to variable with the current\n"
16297 " font family. The available values are given by the PL_FCI_*\n"
16298 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16299 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16300 " p_family is NULL then the font family is not returned. \n"
16302 " p_style (PLINT *, output) : Pointer to variable with the current\n"
16303 " font style. The available values are given by the PL_FCI_*\n"
16304 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16305 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
16306 " font style is not returned. \n"
16308 " p_weight (PLINT *, output) : Pointer to variable with the current\n"
16309 " font weight. The available values are given by the PL_FCI_*\n"
16310 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16311 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16315 { (
char *)
"plglevel",
_wrap_plglevel, METH_VARARGS, (
char *)
"\n"
16316 "Get the (current) run level \n"
16320 " Get the (current) run level. Valid settings are: 0, uninitialized \n"
16321 " 1, initialized \n"
16322 " 2, viewport defined \n"
16323 " 3, world coordinates defined \n"
16326 " Redacted form: plglevel(p_level)\n"
16328 " This function is used in example 31. \n"
16334 "plglevel(p_level)\n"
16338 " p_level (PLINT *, output) : Pointer to the run level. \n"
16341 { (
char *)
"plgpage",
_wrap_plgpage, METH_VARARGS, (
char *)
"\n"
16342 "Get page parameters \n"
16346 " Gets the current page configuration. The length and offset values are\n"
16347 " expressed in units that are specific to the current driver. For\n"
16348 " instance: screen drivers will usually interpret them as number of\n"
16349 " pixels, whereas printer drivers will usually use mm. \n"
16351 " Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16353 " This function is used in examples 14 and 31. \n"
16359 "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16363 " xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
16365 " yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n"
16367 " xleng (PLINT *, output) : Pointer to x page length value. \n"
16369 " yleng (PLINT *, output) : Pointer to y page length value. \n"
16371 " xoff (PLINT *, output) : Pointer to x page offset. \n"
16373 " yoff (PLINT *, output) : Pointer to y page offset. \n"
16376 { (
char *)
"plgra",
_wrap_plgra, METH_VARARGS, (
char *)
"\n"
16377 "Switch to graphics screen \n"
16381 " Sets an interactive device to graphics mode, used in conjunction with\n"
16382 " pltext to allow graphics and text to be interspersed. On a device\n"
16383 " which supports separate text and graphics windows, this command causes\n"
16384 " control to be switched to the graphics window. If already in graphics\n"
16385 " mode, this command is ignored. It is also ignored on devices which\n"
16386 " only support a single window or use a different method for shifting\n"
16387 " focus. See also pltext. \n"
16389 " Redacted form: plgra()\n"
16391 " This function is used in example 1. \n"
16401 "Grid data from irregularly sampled data \n"
16405 " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
16406 " plots require data placed in a uniform grid. This function takes\n"
16407 " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
16408 " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
16409 " and yg[nptsy], and returns the gridded data into output array\n"
16410 " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
16411 " with the argument type which can have one parameter specified in\n"
16412 " argument data. \n"
16414 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16415 " Perl/PDL: Not available? \n"
16416 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16419 " This function is used in example 21. \n"
16425 "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16429 " x (PLFLT *, input) : The input x array. \n"
16431 " y (PLFLT *, input) : The input y array. \n"
16433 " z (PLFLT *, input) : The input z array. Each triple x[i], y[i],\n"
16434 " z[i] represents one data sample coordinate. \n"
16436 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16439 " xg (PLFLT *, input) : The input array that specifies the grid\n"
16440 " spacing in the x direction. Usually xg has nptsx equally spaced\n"
16441 " values from the minimum to the maximum values of the x input\n"
16444 " nptsx (PLINT, input) : The number of points in the xg array. \n"
16446 " yg (PLFLT *, input) : The input array that specifies the grid\n"
16447 " spacing in the y direction. Similar to the xg parameter. \n"
16449 " nptsy (PLINT, input) : The number of points in the yg array. \n"
16451 " zg (PLFLT **, output) : The output array, where data lies in the\n"
16452 " regular grid specified by xg and yg. the zg array must exist or be\n"
16453 " allocated by the user prior to the call, and must have dimension\n"
16454 " zg[nptsx][nptsy]. \n"
16456 " type (PLINT, input) : The type of gridding algorithm to use, which\n"
16457 " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
16458 " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
16459 " GRID_NNI: Natural Neighbors Interpolation \n"
16460 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
16461 " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
16462 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16464 " For details of the algorithms read the source file plgridd.c. \n"
16466 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16467 " which can be specified through this argument. Currently, for\n"
16468 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16469 " use, the lower the value, the noisier (more local) the\n"
16470 " approximation is. \n"
16471 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16472 " range [1. .. 2.]. High values enable the usage of very thin\n"
16473 " triangles for interpolation, possibly resulting in error in\n"
16474 " the approximation. \n"
16475 " GRID_NNI, only weights greater than data will be accepted. If\n"
16476 " 0, all weights will be accepted. \n"
16479 { (
char *)
"plgspa",
_wrap_plgspa, METH_VARARGS, (
char *)
"\n"
16480 "Get current subpage parameters \n"
16484 " Gets the size of the current subpage in millimeters measured from the\n"
16485 " bottom left hand corner of the output device page or screen. Can be\n"
16486 " used in conjunction with plsvpa for setting the size of a viewport in\n"
16487 " absolute coordinates (millimeters). \n"
16489 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16491 " This function is used in example 23. \n"
16497 "plgspa(xmin, xmax, ymin, ymax)\n"
16501 " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
16502 " hand edge of subpage in millimeters. \n"
16504 " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
16505 " hand edge of subpage in millimeters. \n"
16507 " ymin (PLFLT *, output) : Pointer to variable with position of\n"
16508 " bottom edge of subpage in millimeters. \n"
16510 " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
16511 " edge of subpage in millimeters. \n"
16514 { (
char *)
"plgstrm",
_wrap_plgstrm, METH_VARARGS, (
char *)
"\n"
16515 "Get current stream number \n"
16519 " Gets the number of the current output stream. See also plsstrm. \n"
16521 " Redacted form: plgstrm(strm)\n"
16523 " This function is used in example 1,20. \n"
16533 " strm (PLINT *, output) : Pointer to current stream value. \n"
16536 { (
char *)
"plgver",
_wrap_plgver, METH_VARARGS, (
char *)
"\n"
16537 "Get the current library version number \n"
16541 " Get the current library version number. Note: you must have allocated\n"
16542 " space for this (80 characters is safe). \n"
16544 " Redacted form: plgver(p_ver)\n"
16546 " This function is used in example 1. \n"
16556 " p_ver (char *, output) : Pointer to the current library version\n"
16560 { (
char *)
"plgvpd",
_wrap_plgvpd, METH_VARARGS, (
char *)
"\n"
16561 "Get viewport limits in normalized device coordinates \n"
16565 " Get viewport limits in normalized device coordinates. \n"
16567 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16568 " Perl/PDL: Not available? \n"
16571 " This function is used in example 31. \n"
16577 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16581 " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16582 " device coordinate in x. \n"
16584 " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16585 " device coordinate in x. \n"
16587 " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16588 " device coordinate in y. \n"
16590 " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16591 " device coordinate in y. \n"
16594 { (
char *)
"plgvpw",
_wrap_plgvpw, METH_VARARGS, (
char *)
"\n"
16595 "Get viewport limits in world coordinates \n"
16599 " Get viewport limits in world coordinates. \n"
16601 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16602 " Perl/PDL: Not available? \n"
16605 " This function is used in example 31. \n"
16611 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16615 " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
16616 " coordinate in x. \n"
16618 " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
16619 " coordinate in x. \n"
16621 " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
16622 " coordinate in y. \n"
16624 " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
16625 " coordinate in y. \n"
16628 { (
char *)
"plgxax",
_wrap_plgxax, METH_VARARGS, (
char *)
"\n"
16629 "Get x axis parameters \n"
16633 " Returns current values of the digmax and digits flags for the x axis. \n"
16634 " digits is updated after the plot is drawn, so this routine should only\n"
16635 " be called after the call to plbox (or plbox3) is complete. See the\n"
16636 " PLplot documentation for more information. \n"
16638 " Redacted form: plgxax(digmax, digits)\n"
16640 " This function is used in example 31. \n"
16646 "plgxax(digmax, digits)\n"
16650 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16651 " number of digits for the x axis. If nonzero, the printed label\n"
16652 " has been switched to a floating point representation when the\n"
16653 " number of digits exceeds digmax. \n"
16655 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16656 " number of digits for the numeric labels (x axis) from the last\n"
16660 { (
char *)
"plgyax",
_wrap_plgyax, METH_VARARGS, (
char *)
"\n"
16661 "Get y axis parameters \n"
16665 " Identical to plgxax, except that arguments are flags for y axis. See\n"
16666 " the description of plgxax for more detail. \n"
16668 " Redacted form: plgyax(digmax, digits)\n"
16670 " This function is used in example 31. \n"
16676 "plgyax(digmax, digits)\n"
16680 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16681 " number of digits for the y axis. If nonzero, the printed label\n"
16682 " has been switched to a floating point representation when the\n"
16683 " number of digits exceeds digmax. \n"
16685 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16686 " number of digits for the numeric labels (y axis) from the last\n"
16690 { (
char *)
"plgzax",
_wrap_plgzax, METH_VARARGS, (
char *)
"\n"
16691 "Get z axis parameters \n"
16695 " Identical to plgxax, except that arguments are flags for z axis. See\n"
16696 " the description of plgxax for more detail. \n"
16698 " Redacted form: plgzax(digmax, digits)\n"
16700 " This function is used in example 31. \n"
16706 "plgzax(digmax, digits)\n"
16710 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16711 " number of digits for the z axis. If nonzero, the printed label\n"
16712 " has been switched to a floating point representation when the\n"
16713 " number of digits exceeds digmax. \n"
16715 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16716 " number of digits for the numeric labels (z axis) from the last\n"
16720 { (
char *)
"plhist",
_wrap_plhist, METH_VARARGS, (
char *)
"\n"
16721 "Plot a histogram from unbinned data \n"
16725 " Plots a histogram from n data points stored in the array data. This\n"
16726 " routine bins the data into nbin bins equally spaced between datmin and\n"
16727 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16728 " opt allows, among other things, the histogram either to be plotted in\n"
16729 " an existing window or causes plhist to call plenv with suitable limits\n"
16730 " before plotting the histogram. \n"
16732 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16734 " This function is used in example 5. \n"
16740 "plhist(n, data, datmin, datmax, nbin, opt)\n"
16744 " n (PLINT, input) : Number of data points. \n"
16746 " data (PLFLT *, input) : Pointer to array with values of the n data\n"
16749 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
16751 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
16753 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16754 " divide the interval xmin to xmax. \n"
16756 " opt (PLINT, input) : Is a combination of several flags:\n"
16757 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16758 " the histogram data, the outer bins are expanded to fill up the\n"
16759 " entire x-axis, data outside the given extremes are assigned to the\n"
16760 " outer bins and bins of zero height are simply drawn. \n"
16761 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16762 " to fit the histogram data, without this flag, plenv is called\n"
16763 " to set the world coordinates. \n"
16764 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16765 " extremes are not taken into account. This option should\n"
16766 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16767 " properly present the data. \n"
16768 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16769 " size as the ones inside. \n"
16770 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16771 " (there is a gap for such bins). \n"
16774 { (
char *)
"plhlsrgb",
_wrap_plhlsrgb, METH_VARARGS, (
char *)
"\n"
16775 "Convert HLS color to RGB \n"
16779 " Convert HLS color coordinates to RGB. \n"
16781 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16782 " Perl/PDL: Not available? Implemented as plhls? \n"
16785 " This function is used in example 2. \n"
16791 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16795 " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
16797 " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
16798 " of the colour cone (0.0-1.0) \n"
16800 " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
16801 " radius of the colour cone (0.0-1.0) \n"
16803 " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
16806 " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
16809 " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
16813 { (
char *)
"plinit",
_wrap_plinit, METH_VARARGS, (
char *)
"\n"
16814 "Initialize PLplot \n"
16818 " Initializing the plotting package. The program prompts for the device\n"
16819 " keyword or number of the desired output device. Hitting a RETURN in\n"
16820 " response to the prompt is the same as selecting the first device. \n"
16821 " plinit will issue no prompt if either the device was specified\n"
16822 " previously (via command line flag, the plsetopt function, or the\n"
16823 " plsdev function), or if only one device is enabled when PLplot is\n"
16824 " installed. If subpages have been specified, the output device is\n"
16825 " divided into nx by ny subpages, each of which may be used\n"
16826 " independently. If plinit is called again during a program, the\n"
16827 " previously opened file will be closed. The subroutine pladv is used\n"
16828 " to advance from one subpage to the next. \n"
16830 " Redacted form: plinit()\n"
16832 " This function is used in all of the examples. \n"
16841 { (
char *)
"pljoin",
_wrap_pljoin, METH_VARARGS, (
char *)
"\n"
16842 "Draw a line between two points \n"
16846 " Joins the point (\n"
16852 " Redacted form: pljoin(x1,y1,x2,y2)\n"
16854 " This function is used in examples 3,14. \n"
16860 "pljoin(x1, y1, x2, y2)\n"
16864 " x1 (PLFLT, input) : x coordinate of first point. \n"
16866 " y1 (PLFLT, input) : y coordinate of first point. \n"
16868 " x2 (PLFLT, input) : x coordinate of second point. \n"
16870 " y2 (PLFLT, input) : y coordinate of second point. \n"
16873 { (
char *)
"pllab",
_wrap_pllab, METH_VARARGS, (
char *)
"\n"
16874 "Simple routine to write labels \n"
16878 " Routine for writing simple labels. Use plmtex for more complex labels. \n"
16880 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16882 " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16888 "pllab(xlabel, ylabel, tlabel)\n"
16892 " xlabel (const char *, input) : Label for horizontal axis. \n"
16894 " ylabel (const char *, input) : Label for vertical axis. \n"
16896 " tlabel (const char *, input) : Title of graph. \n"
16899 { (
char *)
"pllegend",
_wrap_pllegend, METH_VARARGS, (
char *)
"\n"
16900 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
16904 " Routine for creating a discrete plot legend with a plotted filled box,\n"
16905 " line, and/or line of symbols for each annotated legend entry. The\n"
16906 " arguments of pllegend provide control over the location and size of\n"
16907 " the legend as well as the location and characteristics of the elements\n"
16908 " (most of which are optional) within that legend. The resulting legend\n"
16909 " is clipped at the boundaries of the current subpage. (N.B. the adopted\n"
16910 " coordinate system used for some of the parameters is defined in the\n"
16911 " documentation of the position parameter.) \n"
16913 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
16914 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
16915 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
16916 " test_justification, text_colors, text, box_colors, box_patterns,\n"
16917 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
16918 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16920 " This function is used in examples 4 and 26. \n"
16926 "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"
16930 " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
16931 " contains (after the call) the legend width in adopted coordinates.\n"
16932 " This quantity is calculated from plot_width, text_offset, ncolumn\n"
16933 " (possibly modified inside the routine depending on nlegend and\n"
16934 " nrow), and the length (calculated internally) of the longest text\n"
16937 " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
16938 " contains (after the call) the legend height in adopted\n"
16939 " coordinates. This quantity is calculated from text_scale,\n"
16940 " text_spacing, and nrow (possibly modified inside the routine\n"
16941 " depending on nlegend and nrow). \n"
16943 " opt (PLINT, input) : opt contains bits controlling the overall\n"
16944 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
16945 " on the left of the legend and the plotted area on the right.\n"
16946 " Otherwise, put the text area on the right of the legend and the\n"
16947 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
16948 " plot a (semi-transparent) background for the legend. If the\n"
16949 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
16950 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
16951 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
16952 " plot the resulting array of legend entries in row-major order.\n"
16953 " Otherwise, plot the legend entries in column-major order. \n"
16955 " position (PLINT, input) : position contains bits controlling the\n"
16956 " overall position of the legend and the definition of the adopted\n"
16957 " coordinates used for positions. The combination of the\n"
16958 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP,\n"
16959 " PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE\n"
16960 " bits specifies one of the 16 possible standard positions (the 4\n"
16961 " corners and 4 side centers for both the inside and outside cases)\n"
16962 " of the legend relative to the adopted coordinate system. The\n"
16963 " adopted coordinates are normalized viewport coordinates if the\n"
16964 " PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates\n"
16965 " if the PL_POSITION_SUBPAGE bit is set. Default position bits: If\n"
16966 " none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or\n"
16967 " PL_POSITION_BOTTOM are set, then use the combination of\n"
16968 " PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of\n"
16969 " PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use\n"
16970 " PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
16971 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
16973 " x (PLFLT, input) : X offset of the legend position in adopted\n"
16974 " coordinates from the specified standard position of the legend.\n"
16975 " For positive x, the direction of motion away from the standard\n"
16976 " position is inward/outward from the standard corner positions or\n"
16977 " standard left or right positions if the\n"
16978 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16979 " For the standard top or bottom positions, the direction of motion\n"
16980 " is toward positive X. \n"
16982 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
16983 " coordinates from the specified standard position of the legend.\n"
16984 " For positive y, the direction of motion away from the standard\n"
16985 " position is inward/outward from the standard corner positions or\n"
16986 " standard top or bottom positions if the\n"
16987 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16988 " For the standard left or right positions, the direction of motion\n"
16989 " is toward positive Y. \n"
16991 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
16992 " of the plot area (where the colored boxes, lines, and/or lines of\n"
16993 " symbols are drawn) of the legend. \n"
16995 " bg_color (PLINT, input) : The cmap0 index of the background color\n"
16996 " for the legend (PL_LEGEND_BACKGROUND). \n"
16998 " bb_color (PLINT, input) : The cmap0 index of the color of the\n"
16999 " bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX). \n"
17001 " bb_style (PLINT, input) : The cmap0 index of the background color\n"
17002 " for the legend (PL_LEGEND_BACKGROUND). \n"
17004 " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17005 " the legend (PL_LEGEND_BACKGROUND). \n"
17007 " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17008 " for the legend (PL_LEGEND_BACKGROUND). \n"
17010 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17011 " vertical height of the legend in adopted coordinates is calculated\n"
17012 " internally from nlegend, text_scale (see below), and text_spacing\n"
17015 " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17016 " options to control each individual plotted area corresponding to a\n"
17017 " legend entry. If the \n"
17018 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17020 " PL_LEGEND_COLOR_BOX, \n"
17021 " PL_LEGEND_LINE, and/or \n"
17022 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17023 " entry is plotted with a colored box; a line; and/or a line of\n"
17026 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17027 " area in units of character width. N.B. The total horizontal\n"
17028 " width of the legend in adopted coordinates is calculated\n"
17029 " internally from \n"
17030 " plot_width (see above), \n"
17031 " text_offset, and length (calculated internally) of the longest text\n"
17034 " text_scale (PLFLT, input) : Character height scale for text\n"
17035 " annotations. N.B. The total vertical height of the legend in\n"
17036 " adopted coordinates is calculated internally from \n"
17037 " nlegend (see above), \n"
17038 " text_scale, and \n"
17039 " text_spacing (see below). \n"
17041 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17042 " character height from one legend entry to the next. N.B. The\n"
17043 " total vertical height of the legend in adopted coordinates is\n"
17044 " calculated internally from \n"
17045 " nlegend (see above), \n"
17046 " text_scale (see above), and \n"
17047 " text_spacing. \n"
17049 " text_justification (PLFLT, input) : Justification parameter used\n"
17050 " for text justification. The most common values of\n"
17051 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17052 " is left justified, centred, or right justified within the text\n"
17053 " area, but other values are allowed as well. \n"
17055 " text_colors (const PLINT *, input) : Array of nlegend text colors\n"
17056 " (cmap0 indices). \n"
17058 " text (const char **, input) : Array of nlegend text string\n"
17061 " box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n"
17062 " indices) for the discrete colored boxes (\n"
17063 " PL_LEGEND_COLOR_BOX). \n"
17065 " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17066 " (plpsty indices) for the discrete colored boxes (\n"
17067 " PL_LEGEND_COLOR_BOX). \n"
17069 " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17070 " of fraction of character height) for the height of the discrete\n"
17071 " colored boxes (\n"
17072 " PL_LEGEND_COLOR_BOX). \n"
17074 " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17075 " widths for the patterns specified by box_patterns (\n"
17076 " PL_LEGEND_COLOR_BOX). \n"
17078 " line_colors (const PLINT *, input) : Array of nlegend line colors\n"
17079 " (cmap0 indices) (\n"
17080 " PL_LEGEND_LINE). \n"
17082 " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17083 " (plsty indices) (\n"
17084 " PL_LEGEND_LINE). \n"
17086 " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17087 " PL_LEGEND_LINE). \n"
17089 " symbol_colors (const PLINT *, input) : Array of nlegend symbol\n"
17090 " colors (cmap0 indices) (\n"
17091 " PL_LEGEND_SYMBOL). \n"
17093 " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17094 " values for the symbol height (\n"
17095 " PL_LEGEND_SYMBOL). \n"
17097 " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17098 " symbols to be drawn across the width of the plotted area (\n"
17099 " PL_LEGEND_SYMBOL). \n"
17101 " symbols (const char **, input) : Array of nlegend symbols (plpoin\n"
17103 " PL_LEGEND_SYMBOL). \n"
17108 "Sets the 3D position of the light source \n"
17112 " Sets the 3D position of the light source for use with plsurf3d. \n"
17114 " Redacted form: pllightsource(x, y, z)\n"
17116 " This function is used in example 8. \n"
17122 "pllightsource(x, y, z)\n"
17126 " x (PLFLT, input) : X-coordinate of the light source. \n"
17128 " y (PLFLT, input) : Y-coordinate of the light source. \n"
17130 " z (PLFLT, input) : Z-coordinate of the light source. \n"
17133 { (
char *)
"plline",
_wrap_plline, METH_VARARGS, (
char *)
"\n"
17138 " Draws line defined by n points in x and y. \n"
17140 " Redacted form: plline(x, y)\n"
17142 " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
17148 "plline(n, x, y)\n"
17152 " n (PLINT, input) : Number of points defining line. \n"
17154 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17156 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17159 { (
char *)
"plline3",
_wrap_plline3, METH_VARARGS, (
char *)
"\n"
17160 "Draw a line in 3 space \n"
17164 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17165 " first set up the viewport, the 2d viewing window (in world\n"
17166 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17169 " Redacted form: plline3(x, y, z)\n"
17171 " This function is used in example 18. \n"
17177 "plline3(n, x, y, z)\n"
17181 " n (PLINT, input) : Number of points defining line. \n"
17183 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17185 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17187 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17190 { (
char *)
"pllsty",
_wrap_pllsty, METH_VARARGS, (
char *)
"\n"
17191 "Select line style \n"
17195 " This sets the line style according to one of eight predefined patterns\n"
17196 " (also see plstyl). \n"
17198 " Redacted form: pllsty(n)\n"
17200 " This function is used in examples 9,12,22,25. \n"
17210 " n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n"
17211 " continuous line, line style 2 is a line with short dashes and\n"
17212 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17213 " 4 has long dashes and short gaps and so on. \n"
17216 { (
char *)
"plmesh",
_wrap_plmesh, METH_VARARGS, (
char *)
"\n"
17217 "Plot surface mesh \n"
17221 " Plots a surface mesh within the environment set up by plw3d. The\n"
17222 " surface is defined by the two-dimensional array z[\n"
17224 " ny], the point z[i][j] being the value of the function at (\n"
17226 " y[j]). Note that the points in arrays x and y do not need to be\n"
17227 " equally spaced, but must be stored in ascending order. The parameter\n"
17228 " opt controls the way in which the surface is displayed. For further\n"
17229 " details see the PLplot documentation. \n"
17231 " Redacted form: plmesh(x, y, z, opt)\n"
17233 " This function is used in example 11. \n"
17239 "plmesh(x, y, z, nx, ny, opt)\n"
17243 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17244 " the function is evaluated. \n"
17246 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17247 " the function is evaluated. \n"
17249 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17250 " with set of function values. \n"
17252 " nx (PLINT, input) : Number of x values at which function is\n"
17255 " ny (PLINT, input) : Number of y values at which function is\n"
17258 " opt (PLINT, input) : Determines the way in which the surface is\n"
17259 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17260 " function of x for each value of y[j]. \n"
17261 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17262 " for each value of x[i]. \n"
17263 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17264 " at which function is defined. \n"
17267 { (
char *)
"plmeshc",
_wrap_plmeshc, METH_VARARGS, (
char *)
"\n"
17268 "Magnitude colored plot surface mesh with contour. \n"
17272 " Identical to plmesh but with extra functionalities: the surface mesh\n"
17273 " can be colored accordingly to the current z value being plotted, a\n"
17274 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17275 " drawn between the plotted function border and the base XY plane. \n"
17277 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17279 " This function is used in example 11. \n"
17285 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17289 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17290 " the function is evaluated. \n"
17292 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17293 " the function is evaluated. \n"
17295 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17296 " with set of function values. \n"
17298 " nx (PLINT, input) : Number of x values at which function is\n"
17301 " ny (PLINT, input) : Number of y values at which function is\n"
17304 " opt (PLINT, input) : Determines the way in which the surface is\n"
17305 " represented. To specify more than one option just add the options,\n"
17306 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
17307 " showing z as a function of x for each value of y[j]. \n"
17308 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17309 " for each value of x[i]. \n"
17310 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17311 " at which function is defined. \n"
17312 " opt=MAG_COLOR: Each line in the mesh is colored according to\n"
17313 " the z value being plotted. The color is used from the current\n"
17315 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17316 " using parameters \n"
17319 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17320 " the borders of the plotted function. \n"
17323 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17324 " contour level spacing. \n"
17326 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17329 { (
char *)
"plmkstrm",
_wrap_plmkstrm, METH_VARARGS, (
char *)
"\n"
17330 "Creates a new stream and makes it the default \n"
17334 " Creates a new stream and makes it the default. Differs from using\n"
17335 " plsstrm, in that a free stream number is found, and returned.\n"
17336 " Unfortunately, I have to start at stream 1 and work upward, since\n"
17337 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17338 " that no initial, library-opening call is required. So stream 0 must\n"
17339 " be preallocated, and there is no simple way of determining whether it\n"
17340 " is already in use or not. \n"
17342 " Redacted form: plmkstrm(p_strm)\n"
17344 " This function is used in examples 1,20. \n"
17350 "plmkstrm(p_strm)\n"
17354 " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
17358 { (
char *)
"plmtex",
_wrap_plmtex, METH_VARARGS, (
char *)
"\n"
17359 "Write text relative to viewport boundaries \n"
17363 " Writes text at a specified position relative to the viewport\n"
17364 " boundaries. Text may be written inside or outside the viewport, but\n"
17365 " is clipped at the subpage boundaries. The reference point of a string\n"
17366 " lies along a line passing through the string at half the height of a\n"
17367 " capital letter. The position of the reference point along this line\n"
17368 " is determined by just, and the position of the reference point\n"
17369 " relative to the viewport is set by disp and pos. \n"
17371 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17372 " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
17375 " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
17381 "plmtex(side, disp, pos, just, text)\n"
17385 " side (const char *, input) : Specifies the side of the viewport\n"
17386 " along which the text is to be written. The string must be one of:\n"
17387 " b: Bottom of viewport, text written parallel to edge. \n"
17388 " bv: Bottom of viewport, text written at right angles to edge. \n"
17389 " l: Left of viewport, text written parallel to edge. \n"
17390 " lv: Left of viewport, text written at right angles to edge. \n"
17391 " r: Right of viewport, text written parallel to edge. \n"
17392 " rv: Right of viewport, text written at right angles to edge. \n"
17393 " t: Top of viewport, text written parallel to edge. \n"
17394 " tv: Top of viewport, text written at right angles to edge. \n"
17397 " disp (PLFLT, input) : Position of the reference point of string,\n"
17398 " measured outwards from the specified viewport edge in units of the\n"
17399 " current character height. Use negative disp to write within the\n"
17402 " pos (PLFLT, input) : Position of the reference point of string\n"
17403 " along the specified edge, expressed as a fraction of the length of\n"
17406 " just (PLFLT, input) : Specifies the position of the string relative\n"
17407 " to its reference point. If just=0., the reference point is at the\n"
17408 " left and if just=1., it is at the right of the string. Other\n"
17409 " values of just give intermediate justifications. \n"
17411 " text (const char *, input) : The string to be written out. \n"
17414 { (
char *)
"plmtex3",
_wrap_plmtex3, METH_VARARGS, (
char *)
"\n"
17415 "Write text relative to viewport boundaries in 3D plots. \n"
17419 " Writes text at a specified position relative to the viewport\n"
17420 " boundaries. Text may be written inside or outside the viewport, but\n"
17421 " is clipped at the subpage boundaries. The reference point of a string\n"
17422 " lies along a line passing through the string at half the height of a\n"
17423 " capital letter. The position of the reference point along this line\n"
17424 " is determined by just, and the position of the reference point\n"
17425 " relative to the viewport is set by disp and pos. \n"
17427 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17429 " This function is used in example 28. \n"
17435 "plmtex3(side, disp, pos, just, text)\n"
17439 " side (const char *, input) : Specifies the side of the viewport\n"
17440 " along which the text is to be written. The string should contain\n"
17441 " one or more of the following characters: [xyz][ps][v]. Only one\n"
17442 " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
17443 " both the X and Y axes. x: Label the X axis. \n"
17444 " y: Label the Y axis. \n"
17445 " z: Label the Z axis. \n"
17446 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17447 " For X it is the axis that starts at y-min. For Y it is the\n"
17448 " axis that starts at x-min. \n"
17449 " s: Label the secondary axis. \n"
17450 " v: Draw the text perpendicular to the axis. \n"
17453 " disp (PLFLT, input) : Position of the reference point of string,\n"
17454 " measured outwards from the specified viewport edge in units of the\n"
17455 " current character height. Use negative disp to write within the\n"
17458 " pos (PLFLT, input) : Position of the reference point of string\n"
17459 " along the specified edge, expressed as a fraction of the length of\n"
17462 " just (PLFLT, input) : Specifies the position of the string relative\n"
17463 " to its reference point. If just=0., the reference point is at the\n"
17464 " left and if just=1., it is at the right of the string. Other\n"
17465 " values of just give intermediate justifications. \n"
17467 " text (const char *, input) : The string to be written out. \n"
17470 { (
char *)
"plot3d",
_wrap_plot3d, METH_VARARGS, (
char *)
"\n"
17471 "Plot 3-d surface plot \n"
17475 " Plots a three dimensional surface plot within the environment set up\n"
17476 " by plw3d. The surface is defined by the two-dimensional array z[\n"
17478 " ny], the point z[i][j] being the value of the function at (\n"
17480 " y[j]). Note that the points in arrays x and y do not need to be\n"
17481 " equally spaced, but must be stored in ascending order. The parameter\n"
17482 " opt controls the way in which the surface is displayed. For further\n"
17483 " details see the PLplot documentation. The only difference between\n"
17484 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17485 " while plot3d only draws the surface as viewed from the top. \n"
17487 " Redacted form: plot3d(x, y, z, opt, side)\n"
17489 " This function is used in examples 11,21. \n"
17495 "plot3d(x, y, z, nx, ny, opt, side)\n"
17499 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17500 " the function is evaluated. \n"
17502 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17503 " the function is evaluated. \n"
17505 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17506 " with set of function values. \n"
17508 " nx (PLINT, input) : Number of x values at which function is\n"
17511 " ny (PLINT, input) : Number of y values at which function is\n"
17514 " opt (PLINT, input) : Determines the way in which the surface is\n"
17515 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17516 " function of x for each value of y[j]. \n"
17517 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17518 " for each value of x[i]. \n"
17519 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17520 " at which function is defined. \n"
17523 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17524 " should be draw on the figure. If side is true sides are drawn,\n"
17525 " otherwise no sides are drawn. \n"
17528 { (
char *)
"plot3dc",
_wrap_plot3dc, METH_VARARGS, (
char *)
"\n"
17529 "Magnitude colored plot surface with contour. \n"
17533 " Identical to plot3d but with extra functionalities: the surface mesh\n"
17534 " can be colored accordingly to the current z value being plotted, a\n"
17535 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17536 " drawn between the plotted function border and the base XY plane. The\n"
17537 " arguments are identical to plmeshc. The only difference between\n"
17538 " plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
17539 " surface, while plot3dc only draws the surface as viewed from the top. \n"
17541 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17542 " Perl/PDL: Not available? \n"
17545 " This function is used in example 21. \n"
17551 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17555 { (
char *)
"plsurf3d",
_wrap_plsurf3d, METH_VARARGS, (
char *)
"\n"
17556 "Plot shaded 3-d surface plot \n"
17560 " Plots a three dimensional shaded surface plot within the environment\n"
17561 " set up by plw3d. The surface is defined by the two-dimensional array\n"
17564 " ny], the point z[i][j] being the value of the function at (\n"
17566 " y[j]). Note that the points in arrays x and y do not need to be\n"
17567 " equally spaced, but must be stored in ascending order. For further\n"
17568 " details see the PLplot documentation. \n"
17570 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
17572 " This function is not used in any examples. \n"
17578 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17582 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17583 " the function is evaluated. \n"
17585 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17586 " the function is evaluated. \n"
17588 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17589 " with set of function values. \n"
17591 " nx (PLINT, input) : Number of x values at which function is\n"
17594 " ny (PLINT, input) : Number of y values at which function is\n"
17597 " opt (PLINT, input) : Determines the way in which the surface is\n"
17598 " represented. To specify more than one option just add the options,\n"
17599 " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
17600 " connecting points at which function is defined. \n"
17601 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17602 " using parameters \n"
17605 " opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
17606 " using parameters \n"
17609 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17610 " the borders of the plotted function. \n"
17611 " opt=MAG_COLOR: the surface is colored according to the value\n"
17612 " of Z; if MAG_COLOR is not used, then the default the surface\n"
17613 " is colored according to the intensity of the reflected light\n"
17614 " in the surface from a light source whose position is set using\n"
17615 " pllightsource. \n"
17618 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17619 " contour level spacing. \n"
17621 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17626 "Parse command-line arguments \n"
17630 " Parse command-line arguments. \n"
17632 " plparseopts removes all recognized flags (decreasing argc\n"
17633 " accordingly), so that invalid input may be readily detected. It can\n"
17634 " also be used to process user command line flags. The user can merge\n"
17635 " an option table of type PLOptionTable into the internal option table\n"
17636 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
17637 " the external table(s) be parsed by calling plClearOpts before\n"
17640 " The default action taken by plparseopts is as follows: \n"
17641 " Returns with an error if an unrecognized option or badly formed\n"
17642 " option-value pair are encountered. \n"
17643 " Returns immediately (return code 0) when the first non-option command\n"
17644 " line argument is found. \n"
17645 " Returns with the return code of the option handler, if one was called.\n"
17647 " Deletes command line arguments from argv list as they are found, and\n"
17648 " decrements argc accordingly. \n"
17649 " Does not show \"invisible\" options in usage or help messages. \n"
17650 " Assumes the program name is contained in argv[0]. \n"
17652 " These behaviors may be controlled through the \n"
17653 " mode argument. \n"
17655 " Redacted form: General: plparseopts(argv, mode)\n"
17656 " Perl/PDL: Not available? \n"
17659 " This function is used in all of the examples. \n"
17665 "int plparseopts(p_argc, argv, mode)\n"
17669 " p_argc (int *, input) : pointer to number of arguments. \n"
17671 " argv (char **, input) : Pointer to character array containing\n"
17672 " *p_argc command-line arguments. \n"
17674 " mode (PLINT, input) : Parsing mode with the following\n"
17675 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
17676 " and all error messages enabled, including program exit when an\n"
17677 " error occurs. Anything on the command line that isn't recognized\n"
17678 " as a valid option or option argument is flagged as an error. \n"
17679 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
17681 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
17683 " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17684 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17685 " pointer to the program name. \n"
17686 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17687 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17688 " unrecognized arguments. \n"
17691 { (
char *)
"plpat",
_wrap_plpat, METH_VARARGS, (
char *)
"\n"
17692 "Set area fill pattern \n"
17696 " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
17697 " parallel lines with specified inclinations and spacings. The\n"
17698 " arguments to this routine are the number of sets to use (1 or 2)\n"
17699 " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17700 " specifying the inclinations in tenths of a degree and the spacing in\n"
17701 " micrometers. (also see plpsty) \n"
17703 " Redacted form: General: plpat(inc, del)\n"
17704 " Perl/PDL: plpat(nlin, inc, del)\n"
17707 " This function is used in example 15. \n"
17713 "plpat(nlin, inc, del)\n"
17717 " nlin (PLINT, input) : Number of sets of lines making up the\n"
17718 " pattern, either 1 or 2. \n"
17720 " inc (PLINT *, input) : Pointer to array with nlin elements.\n"
17721 " Specifies the line inclination in tenths of a degree. (Should be\n"
17722 " between -900 and 900). \n"
17724 " del (PLINT *, input) : Pointer to array with nlin elements.\n"
17725 " Specifies the spacing in micrometers between the lines making up\n"
17729 { (
char *)
"plpoin",
_wrap_plpoin, METH_VARARGS, (
char *)
"\n"
17730 "Plot a glyph at the specified points \n"
17734 " Plot a glyph at the specified points. (This function is largely\n"
17735 " superseded by plstring which gives access to many[!] more glyphs.)\n"
17736 " code=-1 means try to just draw a point. Right now it's just a move\n"
17737 " and a draw at the same place. Not ideal, since a sufficiently\n"
17738 " intelligent output device may optimize it away, or there may be faster\n"
17739 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17740 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17741 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17742 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17743 " code <= 127 the corresponding printable ASCII character is plotted. \n"
17745 " Redacted form: plpoin(x, y, code)\n"
17747 " This function is used in examples 1,6,14,29. \n"
17753 "plpoin(n, x, y, code)\n"
17757 " n (PLINT, input) : Number of points in the x and y arrays. \n"
17759 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17762 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17765 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17766 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17767 " each of the n points. \n"
17770 { (
char *)
"plpoin3",
_wrap_plpoin3, METH_VARARGS, (
char *)
"\n"
17771 "Plot a glyph at the specified 3D points \n"
17775 " Plot a glyph at the specified 3D points. (This function is largely\n"
17776 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
17777 " Set up the call to this function similar to what is done for plline3.\n"
17778 " code=-1 means try to just draw a point. Right now it's just a move\n"
17779 " and a draw at the same place. Not ideal, since a sufficiently\n"
17780 " intelligent output device may optimize it away, or there may be faster\n"
17781 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17782 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17783 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17784 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17785 " code <= 127 the corresponding printable ASCII character is plotted. \n"
17787 " Redacted form: plpoin3(x, y, z, code)\n"
17789 " This function is not used in any example. \n"
17795 "plpoin3(n, x, y, z, code)\n"
17799 " n (PLINT, input) : Number of points in the x and y arrays. \n"
17801 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17804 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17807 " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
17810 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17811 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17812 " each of the n points. \n"
17815 { (
char *)
"plpoly3",
_wrap_plpoly3, METH_VARARGS, (
char *)
"\n"
17816 "Draw a polygon in 3 space \n"
17820 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
17821 " like plline3, but differs from that function in that plpoly3 attempts\n"
17822 " to determine if the polygon is viewable depending on the order of the\n"
17823 " points within the arrays and the value of ifcc. If the back of\n"
17824 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
17825 " you want, then use plline3 instead. \n"
17827 " The points are assumed to be in a plane, and the directionality of the\n"
17828 " plane is determined from the first three points. Additional points do\n"
17829 " not have to lie on the plane defined by the first three, but if they\n"
17830 " do not, then the determination of visibility obviously can't be 100%\n"
17831 " accurate... So if you're 3 space polygons are too far from planar,\n"
17832 " consider breaking them into smaller polygons. 3 points define a plane\n"
17835 " Bugs: If one of the first two segments is of zero length, or if they\n"
17836 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
17837 " being correct. Avoid such situations :-). See x18c.c for an example\n"
17838 " of this problem. (Search for 20.1). \n"
17840 " Redacted form: plpoly3(x, y, z, code)\n"
17842 " This function is used in example 18. \n"
17848 "plpoly3(n, x, y, z, draw, ifcc)\n"
17852 " n (PLINT, input) : Number of points defining line. \n"
17854 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17856 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17858 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17860 " draw (PLBOOL *, input) : Pointer to array which controls drawing\n"
17861 " the segments of the polygon. If draw[i] is true, then the polygon\n"
17862 " segment from index [i] to [i+1] is drawn, otherwise, not. \n"
17864 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
17865 " polygon is determined by assuming the points are laid out in a\n"
17866 " counter-clockwise order. Otherwise, the directionality of the\n"
17867 " polygon is determined by assuming the points are laid out in a\n"
17868 " clockwise order. \n"
17871 { (
char *)
"plprec",
_wrap_plprec, METH_VARARGS, (
char *)
"\n"
17872 "Set precision in numeric labels \n"
17876 " Sets the number of places after the decimal point in numeric labels. \n"
17878 " Redacted form: plprec(set, prec)\n"
17880 " This function is used in example 29. \n"
17886 "plprec(set, prec)\n"
17890 " set (PLINT, input) : If set is equal to 0 then PLplot automatically\n"
17891 " determines the number of places to use after the decimal point in\n"
17892 " numeric labels (like those used to label axes). If set is 1 then\n"
17893 " prec sets the number of places. \n"
17895 " prec (PLINT, input) : The number of characters to draw after the\n"
17896 " decimal point in numeric labels. \n"
17899 { (
char *)
"plpsty",
_wrap_plpsty, METH_VARARGS, (
char *)
"\n"
17900 "Select area fill pattern \n"
17904 " Select one of eight predefined area fill patterns to use (also see\n"
17905 " plpat). Setting the fill style to 0 gives a solid fill. \n"
17907 " Redacted form: plpsty(n)\n"
17909 " This function is used in examples 12,13,15,16,25. \n"
17919 " n (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
17920 " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
17921 " consists of lines at 45 degrees angle (upward), and so on. \n"
17924 { (
char *)
"plptex",
_wrap_plptex, METH_VARARGS, (
char *)
"\n"
17925 "Write text inside the viewport \n"
17929 " Writes text at a specified position and inclination within the\n"
17930 " viewport. Text is clipped at the viewport boundaries. The reference\n"
17931 " point of a string lies along a line passing through the string at half\n"
17932 " the height of a capital letter. The position of the reference point\n"
17933 " along this line is determined by just, the reference point is placed\n"
17934 " at world coordinates (\n"
17936 " y) within the viewport. The inclination of the string is specified in\n"
17937 " terms of differences of world coordinates making it easy to write text\n"
17938 " parallel to a line in a graph. \n"
17940 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
17942 " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
17948 "plptex(x, y, dx, dy, just, text)\n"
17952 " x (PLFLT, input) : x coordinate of reference point of string. \n"
17954 " y (PLFLT, input) : y coordinate of reference point of string. \n"
17956 " dx (PLFLT, input) : Together with dy, this specifies the\n"
17957 " inclination of the string. The baseline of the string is parallel\n"
17958 " to a line joining (\n"
17966 " dy (PLFLT, input) : Together with dx, this specifies the\n"
17967 " inclination of the string. \n"
17969 " just (PLFLT, input) : Specifies the position of the string relative\n"
17970 " to its reference point. If just=0., the reference point is at the\n"
17971 " left and if just=1., it is at the right of the string. Other\n"
17972 " values of just give intermediate justifications. \n"
17974 " text (const char *, input) : The string to be written out. \n"
17977 { (
char *)
"plptex3",
_wrap_plptex3, METH_VARARGS, (
char *)
"\n"
17978 "Write text inside the viewport of a 3D plot. \n"
17982 " Writes text at a specified position and inclination and with a\n"
17983 " specified shear within the viewport. Text is clipped at the viewport\n"
17984 " boundaries. The reference point of a string lies along a line passing\n"
17985 " through the string at half the height of a capital letter. The\n"
17986 " position of the reference point along this line is determined by just,\n"
17987 " and the reference point is placed at world coordinates (\n"
17990 " z) within the viewport. The inclination and shear of the string is\n"
17991 " specified in terms of differences of world coordinates making it easy\n"
17992 " to write text parallel to a line in a graph. \n"
17994 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17996 " This function is used in example 28. \n"
18002 "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18006 " x (PLFLT, input) : x coordinate of reference point of string. \n"
18008 " y (PLFLT, input) : y coordinate of reference point of string. \n"
18010 " z (PLFLT, input) : z coordinate of reference point of string. \n"
18012 " dx (PLFLT, input) : Together with dy and \n"
18013 " dz, this specifies the inclination of the string. The baseline of\n"
18014 " the string is parallel to a line joining (\n"
18025 " dy (PLFLT, input) : Together with dx and \n"
18026 " dz, this specifies the inclination of the string. \n"
18028 " dz (PLFLT, input) : Together with dx and \n"
18029 " dy, this specifies the inclination of the string. \n"
18031 " sx (PLFLT, input) : Together with sy and \n"
18032 " sz, this specifies the shear of the string. The string is sheared so\n"
18033 " that the characters are vertically parallel to a line joining (\n"
18044 " sz = 0.) then the text is not sheared. \n"
18046 " sy (PLFLT, input) : Together with sx and \n"
18047 " sz, this specifies shear of the string. \n"
18049 " sz (PLFLT, input) : Together with sx and \n"
18050 " sy, this specifies shear of the string. \n"
18052 " just (PLFLT, input) : Specifies the position of the string relative\n"
18053 " to its reference point. If just=0., the reference point is at the\n"
18054 " left and if just=1., it is at the right of the string. Other\n"
18055 " values of just give intermediate justifications. \n"
18057 " text (const char *, input) : The string to be written out. \n"
18060 { (
char *)
"plrandd",
_wrap_plrandd, METH_VARARGS, (
char *)
"\n"
18061 "Random number generator returning a real random number in the range [0,1]. \n"
18065 " Random number generator returning a real random number in the range\n"
18066 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18067 " / compilers provide their own random number generator, and so this is\n"
18068 " provided purely for convenience and to give a consistent random number\n"
18069 " generator across all languages supported by PLplot. This is\n"
18070 " particularly useful for comparing results from the test suite of\n"
18073 " Redacted form: plrandd()\n"
18075 " This function is used in examples 17,21. \n"
18084 { (
char *)
"plreplot",
_wrap_plreplot, METH_VARARGS, (
char *)
"\n"
18085 "Replays contents of plot buffer to current device/file \n"
18089 " Replays contents of plot buffer to current device/file. \n"
18091 " Redacted form: plreplot()\n"
18093 " This function is used in example 1,20. \n"
18102 { (
char *)
"plrgbhls",
_wrap_plrgbhls, METH_VARARGS, (
char *)
"\n"
18103 "Convert RGB color to HLS \n"
18107 " Convert RGB color coordinates to HLS \n"
18109 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18110 " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
18113 " This function is used in example 2. \n"
18119 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18123 " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
18125 " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
18127 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
18129 " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
18130 " cone (0.0-360.0) \n"
18132 " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
18133 " fraction of the axis of the colour cone (0.0-1.0) \n"
18135 " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
18136 " fraction of the radius of the colour cone (0.0-1.0) \n"
18139 { (
char *)
"plschr",
_wrap_plschr, METH_VARARGS, (
char *)
"\n"
18140 "Set character size \n"
18144 " This sets up the size of all subsequent characters drawn. The actual\n"
18145 " height of a character is the product of the default character size and\n"
18146 " a scaling factor. \n"
18148 " Redacted form: plschr(def, scale)\n"
18150 " This function is used in example 2,13,23,24. \n"
18156 "plschr(def, scale)\n"
18160 " def (PLFLT, input) : The default height of a character in\n"
18161 " millimeters, should be set to zero if the default height is to\n"
18162 " remain unchanged. \n"
18164 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18165 " actual character height. \n"
18168 { (
char *)
"plscmap0",
_wrap_plscmap0, METH_VARARGS, (
char *)
"\n"
18169 "Set color map0 colors by 8-bit RGB values \n"
18173 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18174 " documentation). This sets the entire color map -- only as many colors\n"
18175 " as specified will be allocated. \n"
18177 " Redacted form: plscmap0(r, g, b, ncol0)\n"
18179 " This function is used in examples 2,24. \n"
18185 "plscmap0(r, g, b, ncol0)\n"
18189 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18190 " integers (0-255) representing the degree of red in the color. \n"
18192 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18193 " integers (0-255) representing the degree of green in the color. \n"
18195 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18196 " integers (0-255) representing the degree of blue in the color. \n"
18198 " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18202 "Set color map0 colors by 8-bit RGB values and double alpha value. \n"
18206 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18207 " documentation) and floating point alpha value. This sets the entire\n"
18208 " color map -- only as many colors as specified will be allocated. \n"
18210 " This function is used in examples 30. \n"
18216 "plscmap0a(r, g, b, a, ncol0)\n"
18220 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18221 " integers (0-255) representing the degree of red in the color. \n"
18223 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18224 " integers (0-255) representing the degree of green in the color. \n"
18226 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18227 " integers (0-255) representing the degree of blue in the color. \n"
18229 " a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n"
18230 " - 1.0) representing the transparency of the color. \n"
18232 " ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n"
18237 "Set number of colors in color map0 \n"
18241 " Set number of colors in color map0 (see the PLplot documentation).\n"
18242 " Allocate (or reallocate) color map0, and fill with default values for\n"
18243 " those colors not previously allocated. The first 16 default colors are\n"
18244 " given in the plcol0 documentation. For larger indices the default\n"
18245 " color is red. \n"
18247 " The drivers are not guaranteed to support more than 16 colors. \n"
18249 " Redacted form: plscmap0n(ncol0)\n"
18251 " This function is used in examples 15,16,24. \n"
18257 "plscmap0n(ncol0)\n"
18261 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18262 " the map0 palette. If this number is zero or less, then the value\n"
18263 " from the previous call to plscmap0n is used and if there is no\n"
18264 " previous call, then a default value is used. \n"
18267 { (
char *)
"plscmap1",
_wrap_plscmap1, METH_VARARGS, (
char *)
"\n"
18268 "Set color map1 colors using 8-bit RGB values \n"
18272 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18273 " documentation). This also sets the number of colors. \n"
18275 " Redacted form: plscmap1(r, g, b, ncol1)\n"
18277 " This function is used in example 31. \n"
18283 "plscmap1(r, g, b, ncol1)\n"
18287 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18288 " integers (0-255) representing the degree of red in the color. \n"
18290 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18291 " integers (0-255) representing the degree of green in the color. \n"
18293 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18294 " integers (0-255) representing the degree of blue in the color. \n"
18296 " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18300 "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
18304 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18305 " documentation) and double alpha values. This also sets the number of\n"
18308 " This function is used in example 31. \n"
18314 "plscmap1a(r, g, b, a, ncol1)\n"
18318 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18319 " integers (0-255) representing the degree of red in the color. \n"
18321 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18322 " integers (0-255) representing the degree of green in the color. \n"
18324 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18325 " integers (0-255) representing the degree of blue in the color. \n"
18327 " a (PLFLT *, input) : Pointer to array with set of double values\n"
18328 " (0.0-1.0) representing the alpha value of the color. \n"
18330 " ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n"
18335 "Set color map1 colors using a piece-wise linear relationship \n"
18339 " Set color map1 colors using a piece-wise linear relationship between\n"
18340 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18341 " color space (see the PLplot documentation). May be called at any\n"
18344 " The idea here is to specify a number of control points that define the\n"
18345 " mapping between palette 1 input positions (intensities) and HLS (or\n"
18346 " RGB). Between these points, linear interpolation is used which gives\n"
18347 " a smooth variation of color with input position. Any number of\n"
18348 " control points may be specified, located at arbitrary positions,\n"
18349 " although typically 2 - 4 are enough. Another way of stating this is\n"
18350 " that we are traversing a given number of lines through HLS (or RGB)\n"
18351 " space as we move through color map1 entries. The control points at\n"
18352 " the minimum and maximum position (0 and 1) must always be specified. \n"
18353 " By adding more control points you can get more variation. One good\n"
18354 " technique for plotting functions that vary about some expected average\n"
18355 " is to use an additional 2 control points in the center (position ~=\n"
18356 " 0.5) that are the same lightness as the background (typically white\n"
18357 " for paper output, black for crt), and same hue as the boundary control\n"
18358 " points. This allows the highs and lows to be very easily\n"
18359 " distinguished. \n"
18361 " Each control point must specify the position in color map1 as well as\n"
18362 " three coordinates in HLS or RGB space. The first point must\n"
18363 " correspond to position = 0, and the last to position = 1. \n"
18365 " The default behaviour is for the hue to be linearly interpolated \n"
18366 " between the control points. Since the hue lies in the range [0, 360]\n"
18367 " this corresponds to interpolation around the \"front\" of the color\n"
18368 " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
18369 " alternative interpolation is used between control points i and i+1. If\n"
18370 " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n"
18371 " hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n"
18372 " consider this as interpolation around the \"back\" or \"reverse\" of the\n"
18373 " color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
18374 " alt_hue_path[] = false for every control point. \n"
18376 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
18377 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
18378 " 240]truegreen-yellow-red-magenta-blue[240\n"
18379 " 120]trueblue-magenta-red-yellow-green\n"
18381 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
18382 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
18383 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
18385 " Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n"
18388 " This function is used in examples 8,11,12,15,20,21. \n"
18394 "plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n"
18398 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18400 " npts (PLINT, input) : number of control points \n"
18402 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18403 " and 1.0, in ascending order) \n"
18405 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18406 " control point \n"
18408 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18409 " control point \n"
18411 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18412 " control point \n"
18414 " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18415 " flag for each control point. (alt_hue_path[i] refers to the\n"
18416 " interpolation interval between the i and i + 1 control points). \n"
18420 "Set color map1 colors using a piece-wise linear relationship \n"
18424 " This is a version of plscmap1l that supports alpha transparency. It\n"
18425 " sets color map1 colors using a piece-wise linear relationship between\n"
18426 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18427 " color space (see the PLplot documentation) with alpha value (0.0 -\n"
18428 " 1.0). It may be called at any time. \n"
18430 " This function is used in example 30. \n"
18436 "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n"
18440 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18442 " npts (PLINT, input) : number of control points \n"
18444 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18445 " and 1.0, in ascending order) \n"
18447 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18448 " control point \n"
18450 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18451 " control point \n"
18453 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18454 " control point \n"
18456 " coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n"
18457 " each control point \n"
18459 " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18460 " flag for each control point. (alt_hue_path[i] refers to the\n"
18461 " interpolation interval between the i and i + 1 control points). \n"
18465 "Set number of colors in color map1 \n"
18469 " Set number of colors in color map1, (re-)allocate color map1, and set\n"
18470 " default values if this is the first allocation (see the PLplot\n"
18471 " documentation). \n"
18473 " Redacted form: plscmap1n(ncol1)\n"
18475 " This function is used in examples 8,11,20,21. \n"
18481 "plscmap1n(ncol1)\n"
18485 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
18486 " the map1 palette. If this number is zero or less, then the value\n"
18487 " from the previous call to plscmap1n is used and if there is no\n"
18488 " previous call, then a default value is used. \n"
18493 { (
char *)
"plscol0",
_wrap_plscol0, METH_VARARGS, (
char *)
"\n"
18494 "Set a given color from color map0 by 8 bit RGB value \n"
18498 " Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
18499 " documentation). Overwrites the previous color value for the given\n"
18500 " index and, thus, does not result in any additional allocation of space\n"
18503 " Redacted form: plscol0(icol0, r, g, b)\n"
18505 " This function is not used in any examples. \n"
18511 "lscol0(icol0, r, g, b)\n"
18515 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18516 " number of colors (which is set by default, by plscmap0n, or even\n"
18517 " by plscmap0). \n"
18519 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18520 " degree of red in the color. \n"
18522 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18523 " degree of green in the color. \n"
18525 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18526 " degree of blue in the color. \n"
18529 { (
char *)
"plscol0a",
_wrap_plscol0a, METH_VARARGS, (
char *)
"\n"
18530 "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
18534 " Set a given color by 8-bit RGB value and double alpha value for color \n"
18535 " map0 (see the PLplot documentation). Overwrites the previous color\n"
18536 " value for the given index and, thus, does not result in any\n"
18537 " additional allocation of space for colors. \n"
18539 " This function is used in example 30. \n"
18545 "lscol0a(icol0, r, g, b, a)\n"
18549 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18550 " number of colors (which is set by default, by plscmap0n, or even\n"
18551 " by plscmap0). \n"
18553 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18554 " degree of red in the color. \n"
18556 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18557 " degree of green in the color. \n"
18559 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18560 " degree of blue in the color. \n"
18562 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18563 " value of the color. \n"
18566 { (
char *)
"plscolbg",
_wrap_plscolbg, METH_VARARGS, (
char *)
"\n"
18567 "Set the background color by 8-bit RGB value \n"
18571 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18572 " (see the PLplot documentation). \n"
18574 " Redacted form: plscolbg(r, g, b)\n"
18576 " This function is used in examples 15,31. \n"
18582 "plscolbg(r, g, b)\n"
18586 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18587 " degree of red in the color. \n"
18589 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18590 " degree of green in the color. \n"
18592 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18593 " degree of blue in the color. \n"
18597 "Set the background color by 8-bit RGB value and double alpha value. \n"
18601 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18602 " (see the PLplot documentation) and double alpha value. \n"
18604 " This function is used in example 31. \n"
18610 "plscolbga(r, g, b, a)\n"
18614 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18615 " degree of red in the color. \n"
18617 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18618 " degree of green in the color. \n"
18620 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18621 " degree of blue in the color. \n"
18623 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18624 " value of the color. \n"
18627 { (
char *)
"plscolor",
_wrap_plscolor, METH_VARARGS, (
char *)
"\n"
18628 "Used to globally turn color output on/off \n"
18632 " Used to globally turn color output on/off for those drivers/devices\n"
18633 " that support it. \n"
18635 " Redacted form: plscolor(color)\n"
18637 " This function is used in example 31. \n"
18643 "plscolor(color)\n"
18647 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
18648 " turned off. If non-zero, color is turned on. \n"
18652 "Set device-compression level \n"
18656 " Set device-compression level. Only used for drivers that provide\n"
18657 " compression. This function, if used, should be invoked before a call\n"
18660 " Redacted form: plscompression(compression)\n"
18662 " This function is used in example 31. \n"
18668 "plscompression(compression)\n"
18672 " compression (PLINT, input) : The desired compression level. This is\n"
18673 " a device-dependent value. Currently only the jpeg and png devices\n"
18674 " use these values. For jpeg value is the jpeg quality which should\n"
18675 " normally be in the range 0-95. Higher values denote higher quality\n"
18676 " and hence larger image sizes. For png values are in the range -1\n"
18677 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
18678 " A value of -1 denotes the default zlib compression level. Values\n"
18679 " in the range 10-99 are divided by 10 and then used as the zlib\n"
18680 " compression level. Higher compression levels correspond to greater\n"
18681 " compression and small file sizes at the expense of more\n"
18685 { (
char *)
"plsdev",
_wrap_plsdev, METH_VARARGS, (
char *)
"\n"
18686 "Set the device (keyword) name \n"
18690 " Set the device (keyword) name. \n"
18692 " Redacted form: plsdev(devname)\n"
18694 " This function is used in examples 1,14,20. \n"
18700 "plsdev(devname)\n"
18704 " devname (const char *, input) : Pointer to device (keyword) name\n"
18708 { (
char *)
"plsdidev",
_wrap_plsdidev, METH_VARARGS, (
char *)
"\n"
18709 "Set parameters that define current device-space window \n"
18713 " Set relative margin width, aspect ratio, and relative justification\n"
18714 " that define current device-space window. If you want to just use the\n"
18715 " previous value for any of these, just pass in the magic value\n"
18716 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
18717 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
18718 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
18719 " to a device-specific value. \n"
18721 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
18723 " This function is used in example 31. \n"
18729 "plsdidev(mar, aspect, jx, jy)\n"
18733 " mar (PLFLT, input) : Relative margin width. \n"
18735 " aspect (PLFLT, input) : Aspect ratio. \n"
18737 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
18738 " the range -0.5 to 0.5. \n"
18740 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
18741 " the range -0.5 to 0.5. \n"
18744 { (
char *)
"plsdimap",
_wrap_plsdimap, METH_VARARGS, (
char *)
"\n"
18745 "Set up transformation from metafile coordinates \n"
18749 " Set up transformation from metafile coordinates. The size of the plot\n"
18750 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
18751 " general-purpose facility just yet (not sure why the user would need\n"
18752 " it, for one). \n"
18754 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
18757 " This function is not used in any examples. \n"
18763 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
18767 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
18769 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
18771 " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
18773 " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
18775 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18777 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18780 { (
char *)
"plsdiori",
_wrap_plsdiori, METH_VARARGS, (
char *)
"\n"
18781 "Set plot orientation \n"
18785 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
18786 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
18787 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
18788 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
18789 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
18790 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
18791 " not called the default value of rot is 0. \n"
18793 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
18794 " probably want to change the aspect ratio to a value suitable for the\n"
18795 " plot orientation using a call to plsdidev or the command-line options\n"
18796 " -a or -freeaspect. For more documentation of those options see the\n"
18797 " PLplot documentation. Such command-line options can be set internally\n"
18798 " using plsetopt or set directly using the command line and parsed using\n"
18799 " a call to plparseopts. \n"
18801 " Redacted form: plsdiori(rot)\n"
18803 " This function is not used in any examples. \n"
18813 " rot (PLFLT, input) : Plot orientation parameter. \n"
18816 { (
char *)
"plsdiplt",
_wrap_plsdiplt, METH_VARARGS, (
char *)
"\n"
18817 "Set parameters that define current plot-space window \n"
18821 " Set relative minima and maxima that define the current plot-space\n"
18822 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
18823 " xmax, and ymax are 0., 0., 1., and 1. \n"
18825 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
18827 " This function is used in example 31. \n"
18833 "plsdiplt(xmin, ymin, xmax, ymax)\n"
18837 " xmin (PLFLT, input) : Relative minimum in x. \n"
18839 " ymin (PLFLT, input) : Relative minimum in y. \n"
18841 " xmax (PLFLT, input) : Relative maximum in x. \n"
18843 " ymax (PLFLT, input) : Relative maximum in y. \n"
18846 { (
char *)
"plsdiplz",
_wrap_plsdiplz, METH_VARARGS, (
char *)
"\n"
18847 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
18851 " Set relative minima and maxima incrementally (zoom mode) that define\n"
18852 " the current plot-space window. This function has the same effect as\n"
18853 " plsdiplt if that function has not been previously called. Otherwise,\n"
18854 " this function implements zoom mode using the transformation min_used =\n"
18855 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
18856 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
18857 " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
18859 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
18861 " This function is used in example 31. \n"
18867 "plsdiplz(xmin, ymin, xmax, ymax)\n"
18871 " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
18873 " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
18875 " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
18877 " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
18880 { (
char *)
"plseed",
_wrap_plseed, METH_VARARGS, (
char *)
"\n"
18881 "Set seed for internal random number generator. \n"
18885 " Set the seed for the internal random number generator. See plrandd for\n"
18886 " further details. \n"
18888 " Redacted form: plseed(seed)\n"
18890 " This function is used in example 21. \n"
18900 " seed (unsigned int, input) : Seed for random number generator. \n"
18903 { (
char *)
"plsesc",
_wrap_plsesc, METH_VARARGS, (
char *)
"\n"
18904 "Set the escape character for text strings \n"
18908 " Set the escape character for text strings. From C (in contrast to\n"
18909 " Fortran 77, see plsescfortran77) you pass esc as a character. Only\n"
18910 " selected characters are allowed to prevent the user from shooting\n"
18911 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
18912 " with C's use of backslash as a character escape). Here are the\n"
18913 " allowed escape characters and their corresponding decimal ASCII\n"
18914 " values: !, ASCII 33 \n"
18925 " Redacted form: General: plsesc(esc)\n"
18926 " Perl/PDL: Not available? \n"
18929 " This function is used in example 29. \n"
18939 " esc (char, input) : Escape character. \n"
18942 { (
char *)
"plsetopt",
_wrap_plsetopt, METH_VARARGS, (
char *)
"\n"
18943 "Set any command-line option \n"
18947 " Set any command-line option internally from a program before it\n"
18948 " invokes plinit. opt is the name of the command-line option and optarg\n"
18949 " is the corresponding command-line option argument. \n"
18951 " This function returns 0 on success. \n"
18953 " Redacted form: plsetopt(opt, optarg)\n"
18955 " This function is used in example 14. \n"
18961 "int plsetopt(opt, optarg)\n"
18965 " opt (const char *, input) : Pointer to string containing the\n"
18966 " command-line option. \n"
18968 " optarg (const char *, input) : Pointer to string containing the\n"
18969 " argument of the command-line option. \n"
18972 { (
char *)
"plsfam",
_wrap_plsfam, METH_VARARGS, (
char *)
"\n"
18973 "Set family file parameters \n"
18977 " Sets variables dealing with output file familying. Does nothing if\n"
18978 " familying not supported by the driver. This routine, if used, must be\n"
18979 " called before initializing PLplot. See the PLplot documentation for\n"
18980 " more information. \n"
18982 " Redacted form: plsfam(fam, num, bmax)\n"
18984 " This function is used in examples 14,31. \n"
18990 "plsfam(fam, num, bmax)\n"
18994 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
18997 " num (PLINT, input) : Current family file number. \n"
18999 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19003 { (
char *)
"plsfci",
_wrap_plsfci, METH_VARARGS, (
char *)
"\n"
19004 "Set FCI (font characterization integer) \n"
19008 " Sets font characteristics to be used at the start of the next string\n"
19009 " using the FCI approach. See the PLplot documentation for more\n"
19012 " Redacted form: General: plsfci(fci)\n"
19013 " Perl/PDL: Not available? \n"
19016 " This function is used in example 23. \n"
19026 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19030 { (
char *)
"plsfnam",
_wrap_plsfnam, METH_VARARGS, (
char *)
"\n"
19031 "Set output file name \n"
19035 " Sets the current output file name, if applicable. If the file name\n"
19036 " has not been specified and is required by the driver, the user will be\n"
19037 " prompted for it. If using the X-windows output driver, this sets the\n"
19038 " display name. This routine, if used, must be called before\n"
19039 " initializing PLplot. \n"
19041 " Redacted form: plsfnam(fnam)\n"
19043 " This function is used in examples 1,20. \n"
19053 " fnam (const char *, input) : Pointer to file name string. \n"
19056 { (
char *)
"plsfont",
_wrap_plsfont, METH_VARARGS, (
char *)
"\n"
19057 "Set family, style and weight of the current font \n"
19061 " Sets the current font. See the PLplot documentation for more\n"
19062 " information on font selection. \n"
19064 " Redacted form: plsfont(family, style, weight)\n"
19066 " This function is used in example 23. \n"
19072 "plsfont(family, style, weight)\n"
19076 " family (PLINT, input) : Font family to select for the current font.\n"
19077 " The available values are given by the PL_FCI_* constants in\n"
19078 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
19079 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19080 " signifies that the font family should not be altered. \n"
19082 " style (PLINT, input) : Font style to select for the current font.\n"
19083 " The available values are given by the PL_FCI_* constants in\n"
19084 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19085 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19086 " should not be altered. \n"
19088 " weight (PLINT, input) : Font weight to select for the current font.\n"
19089 " The available values are given by the PL_FCI_* constants in\n"
19090 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19091 " negative value signifies that the font weight should not be\n"
19095 { (
char *)
"plshades",
_wrap_plshades, METH_VARARGS, (
char *)
"\n"
19096 "Shade regions on the basis of value \n"
19100 " Shade regions on the basis of value. This is the high-level routine\n"
19101 " for making continuous color shaded plots with cmap1 while plshade (or\n"
19102 " plshade1) are used for individual shaded regions using either cmap0 or\n"
19103 " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
19104 " function. See the following discussion of the arguments and the PLplot\n"
19105 " documentation for more information. \n"
19107 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19108 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19110 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
19111 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
19115 " This function is used in examples 16,21. \n"
19121 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19125 " a (PLFLT **, input) : Contains ** pointer to array to be plotted.\n"
19126 " The array must have been declared as PLFLT a[nx][ny]. \n"
19128 " nx (PLINT, input) : First dimension of array \"a\". \n"
19130 " ny (PLINT, input) : Second dimension of array \"a\". \n"
19132 " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
19133 " specifying regions excluded from the shading plot. This function\n"
19134 " accepts x and y coordinates as input arguments and must return 0\n"
19135 " if the point is in the excluded region or 1 otherwise. This\n"
19136 " argument can be NULL if all the values are valid. \n"
19138 " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19139 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19140 " at (xmax,ymin) and so on. \n"
19142 " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19143 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19144 " at (xmax,ymin) and so on. \n"
19146 " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19147 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19148 " at (xmax,ymin) and so on. \n"
19150 " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19151 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19152 " at (xmax,ymin) and so on. \n"
19154 " clevel (PLFLT *, input) : Pointer to array containing the data\n"
19155 " levels corresponding to the edges of each shaded region that will\n"
19156 " be plotted by this function. To work properly the levels should\n"
19157 " be monotonic. \n"
19159 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19160 " of shade edge values in clevel). \n"
19162 " fill_width (PLFLT, input) : Defines line width used by the fill\n"
19165 " cont_color (PLINT, input) : Defines pen color used for contours\n"
19166 " defining edges of shaded regions. The pen color is only temporary\n"
19167 " set for the contour drawing. Set this value to zero or less if no\n"
19168 " shade edge contours are wanted. \n"
19170 " cont_width (PLFLT, input) : Defines line width used for contours\n"
19171 " defining edges of shaded regions. This value may not be honored\n"
19172 " by all drivers. The pen width is only temporary set for the\n"
19173 " contour drawing. Set this value to zero or less if no shade edge\n"
19174 " contours are wanted. \n"
19176 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : Routine used to\n"
19177 " fill the region. Use plfill. Future version of PLplot may have\n"
19178 " other fill routines. \n"
19180 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19181 " map to rectangles after coordinate transformation with pltrl. \n"
19182 " Otherwise, set rectangular to false. If rectangular is set to\n"
19183 " true, plshade tries to save time by filling large rectangles. \n"
19184 " This optimization fails if the coordinate transformation distorts\n"
19185 " the shape of rectangles. For example a plot in polar coordinates\n"
19186 " has to have rectangular set to false. \n"
19188 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19189 " Pointer to function that defines transformation between indices\n"
19190 " in array z and the world coordinates (C only). Transformation\n"
19191 " functions are provided in the PLplot library: pltr0 for identity\n"
19192 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19193 " defined by one- and two-dimensional arrays. In addition,\n"
19194 " user-supplied routines for the transformation can be used as well.\n"
19195 " Examples of all of these approaches are given in the PLplot\n"
19196 " documentation. The transformation function should have the form\n"
19197 " given by any of pltr0, pltr1, or pltr2. \n"
19199 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
19200 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19201 " externally supplied. \n"
19204 { (
char *)
"plshade",
_wrap_plshade, METH_VARARGS, (
char *)
"\n"
19205 "Shade individual region on the basis of value \n"
19209 " Shade individual region on the basis of value. Use plshades if you\n"
19210 " want to shade a number of regions using continuous colors. plshade is\n"
19211 " identical to plshade1 except for the type of the first parameter. See\n"
19212 " plshade1 for further discussion. \n"
19214 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
19215 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
19216 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19217 " Perl/PDL: Not available? \n"
19220 " This function is used in example 15. \n"
19226 "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"
19230 " a (PLFLT **, input) : \n"
19232 " nx (PLINT, input) : \n"
19234 " ny (PLINT, input) : \n"
19236 " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
19238 " xmin (PLFLT, input) : \n"
19240 " xmax (PLFLT, input) : \n"
19242 " ymin (PLFLT, input) : \n"
19244 " ymax (PLFLT, input) : \n"
19246 " shade_min (PLFLT, input) : \n"
19248 " shade_max (PLFLT, input) : \n"
19250 " sh_cmap (PLINT, input) : \n"
19252 " sh_color (PLFLT, input) : \n"
19254 " sh_width (PLFLT, input) : \n"
19256 " min_color (PLINT, input) : \n"
19258 " min_width (PLFLT, input) : \n"
19260 " max_color (PLINT, input) : \n"
19262 " max_width (PLFLT, input) : \n"
19264 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : \n"
19266 " rectangular (PLBOOL, input) : \n"
19268 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19270 " pltr_data (PLPointer, input) : \n"
19274 "Assign a function to use for generating custom axis labels \n"
19278 " This function allows a user to provide their own function to provide\n"
19279 " axis label text. The user function is given the numeric value for a\n"
19280 " point on an axis and returns a string label to correspond with that\n"
19281 " value. Custom axis labels can be enabled by passing appropriate\n"
19282 " arguments to plenv, plbox, plbox3 and similar functions. \n"
19284 " This function is used in example 19. \n"
19290 "plslabelfunc(label_func, label_data)\n"
19294 " label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n"
19295 " This is the custom label function. In order to reset to the\n"
19296 " default labeling, set this to NULL. The labeling function\n"
19297 " parameters are, in order: axis: This indicates which axis a\n"
19298 " label is being requested for. The value will be one of PL_X_AXIS,\n"
19299 " PL_Y_AXIS or PL_Z_AXIS. \n"
19301 " value: This is the value along the axis which is being labeled. \n"
19303 " label_text: The string representation of the label value. \n"
19305 " length: The maximum length in characters allowed for label_text. \n"
19308 " label_data (void *, input) : This parameter may be used to pass\n"
19309 " data to the label_func function. \n"
19312 { (
char *)
"plsmaj",
_wrap_plsmaj, METH_VARARGS, (
char *)
"\n"
19313 "Set length of major ticks \n"
19317 " This sets up the length of the major ticks. The actual length is the\n"
19318 " product of the default length and a scaling factor as for character\n"
19321 " Redacted form: plsmaj(def, scale)\n"
19323 " This function is used in example 29. \n"
19329 "plsmaj(def, scale)\n"
19333 " def (PLFLT, input) : The default length of a major tick in\n"
19334 " millimeters, should be set to zero if the default length is to\n"
19335 " remain unchanged. \n"
19337 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19338 " actual tick length. \n"
19341 { (
char *)
"plsmem",
_wrap_plsmem, METH_VARARGS, (
char *)
"\n"
19342 "Set the memory area to be plotted (RGB) \n"
19346 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
19347 " the dev member of the stream structure. Also set the number of pixels\n"
19348 " in the memory passed in \n"
19349 " plotmem, which is a block of memory \n"
19351 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
19353 " This memory will have to be freed by the user! \n"
19355 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
19357 " This function is not used in any examples. \n"
19363 "plsmem(maxx, maxy, plotmem)\n"
19367 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19369 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19371 " plotmem (void *, input) : Pointer to the beginning of the\n"
19372 " user-supplied memory area. \n"
19375 { (
char *)
"plsmema",
_wrap_plsmema, METH_VARARGS, (
char *)
"\n"
19376 "Set the memory area to be plotted (RGBA) \n"
19380 " Set the memory area to be plotted (with the memcairo driver) as the\n"
19381 " dev member of the stream structure. Also set the number of pixels in\n"
19382 " the memory passed in \n"
19383 " plotmem, which is a block of memory \n"
19385 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
19387 " This memory will have to be freed by the user! \n"
19389 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
19391 " This function is not used in any examples. \n"
19397 "plsmema(maxx, maxy, plotmem)\n"
19401 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19403 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19405 " plotmem (void *, input) : Pointer to the beginning of the\n"
19406 " user-supplied memory area. \n"
19409 { (
char *)
"plsmin",
_wrap_plsmin, METH_VARARGS, (
char *)
"\n"
19410 "Set length of minor ticks \n"
19414 " This sets up the length of the minor ticks and the length of the\n"
19415 " terminals on error bars. The actual length is the product of the\n"
19416 " default length and a scaling factor as for character height. \n"
19418 " Redacted form: plsmin(def, scale)\n"
19420 " This function is used in example 29. \n"
19426 "plsmin(def, scale)\n"
19430 " def (PLFLT, input) : The default length of a minor tick in\n"
19431 " millimeters, should be set to zero if the default length is to\n"
19432 " remain unchanged. \n"
19434 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19435 " actual tick length. \n"
19438 { (
char *)
"plsori",
_wrap_plsori, METH_VARARGS, (
char *)
"\n"
19439 "Set orientation \n"
19443 " Set integer plot orientation parameter. This function is identical to\n"
19444 " plsdiori except for the type of the argument, and should be used in\n"
19445 " the same way. See the PLplot documentation for details. \n"
19447 " Redacted form: plsori(ori)\n"
19449 " This function is used in example 3. \n"
19459 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
19460 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
19464 { (
char *)
"plspage",
_wrap_plspage, METH_VARARGS, (
char *)
"\n"
19465 "Set page parameters \n"
19469 " Sets the page configuration (optional). If an individual parameter is\n"
19470 " zero then that parameter value is not updated. Not all parameters are\n"
19471 " recognized by all drivers and the interpretation is device-dependent.\n"
19472 " The X-window driver uses the length and offset parameters to determine\n"
19473 " the window size and location. The length and offset values are\n"
19474 " expressed in units that are specific to the current driver. For\n"
19475 " instance: screen drivers will usually interpret them as number of\n"
19476 " pixels, whereas printer drivers will usually use mm. This routine, if\n"
19477 " used, must be called before initializing PLplot. \n"
19479 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19481 " This function is used in examples 14 and 31. \n"
19487 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19491 " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
19493 " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
19495 " xleng (PLINT , input) : Page length, x. \n"
19497 " yleng (PLINT, input) : Page length, y. \n"
19499 " xoff (PLINT, input) : Page offset, x. \n"
19501 " yoff (PLINT, input) : Page offset, y. \n"
19504 { (
char *)
"plspal0",
_wrap_plspal0, METH_VARARGS, (
char *)
"\n"
19505 "Set the colors for color table 0 from a cmap0 file \n"
19509 " Set the colors for color table 0 from a cmap0 file \n"
19511 " Redacted form: plspal0(filename)\n"
19513 " This function is in example 16. \n"
19519 "plspal0(filename)\n"
19523 " filename (const char *, input) : The name of the cmap0 file, or a\n"
19524 " empty to string to specify the default cmap0 file. \n"
19527 { (
char *)
"plspal1",
_wrap_plspal1, METH_VARARGS, (
char *)
"\n"
19528 "Set the colors for color table 1 from a cmap1 file \n"
19532 " Set the colors for color table 1 from a cmap1 file \n"
19534 " Redacted form: plspal1(filename)\n"
19536 " This function is in example 16. \n"
19542 "plspal1(filename)\n"
19546 " filename (const char *, input) : The name of the cmap1 file, or a\n"
19547 " empty to string to specify the default cmap1 file. \n"
19550 { (
char *)
"plspause",
_wrap_plspause, METH_VARARGS, (
char *)
"\n"
19551 "Set the pause (on end-of-page) status \n"
19555 " Set the pause (on end-of-page) status. \n"
19557 " Redacted form: plspause(pause)\n"
19559 " This function is in examples 14,20. \n"
19565 "plspause(pause)\n"
19569 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
19570 " end-of-page for those drivers which support this. Otherwise there\n"
19574 { (
char *)
"plsstrm",
_wrap_plsstrm, METH_VARARGS, (
char *)
"\n"
19575 "Set current output stream \n"
19579 " Sets the number of the current output stream. The stream number\n"
19580 " defaults to 0 unless changed by this routine. The first use of this\n"
19581 " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
19583 " Redacted form: plsstrm(strm)\n"
19585 " This function is examples 1,14,20. \n"
19595 " strm (PLINT, input) : The current stream number. \n"
19598 { (
char *)
"plssub",
_wrap_plssub, METH_VARARGS, (
char *)
"\n"
19599 "Set the number of subpages in x and y \n"
19603 " Set the number of subpages in x and y. \n"
19605 " Redacted form: plssub(nx, ny)\n"
19607 " This function is examples 1,2,14,21,25,27. \n"
19617 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
19618 " of window columns). \n"
19620 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
19621 " of window rows). \n"
19624 { (
char *)
"plssym",
_wrap_plssym, METH_VARARGS, (
char *)
"\n"
19625 "Set symbol size \n"
19629 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
19630 " plsym. The actual height of a symbol is the product of the default\n"
19631 " symbol size and a scaling factor as for the character height. \n"
19633 " Redacted form: plssym(def, scale)\n"
19635 " This function is used in example 29. \n"
19641 "plssym(def, scale)\n"
19645 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
19646 " should be set to zero if the default height is to remain\n"
19649 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19650 " actual symbol height. \n"
19653 { (
char *)
"plstar",
_wrap_plstar, METH_VARARGS, (
char *)
"\n"
19654 "Initialization \n"
19658 " Initializing the plotting package. The program prompts for the device\n"
19659 " keyword or number of the desired output device. Hitting a RETURN in\n"
19660 " response to the prompt is the same as selecting the first device. If\n"
19661 " only one device is enabled when PLplot is installed, plstar will issue\n"
19662 " no prompt. The output device is divided into nx by ny subpages, each\n"
19663 " of which may be used independently. The subroutine pladv is used to\n"
19664 " advance from one subpage to the next. \n"
19666 " Redacted form: plstar(nx, ny)\n"
19668 " This function is used in example 1. \n"
19678 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19679 " horizontal direction. \n"
19681 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19682 " vertical direction. \n"
19685 { (
char *)
"plstart",
_wrap_plstart, METH_VARARGS, (
char *)
"\n"
19686 "Initialization \n"
19690 " Alternative to plstar for initializing the plotting package. The\n"
19691 " device name keyword for the desired output device must be supplied as\n"
19692 " an argument. The device keywords are the same as those printed out by\n"
19693 " plstar. If the requested device is not available, or if the input\n"
19694 " string is empty or begins with ``?'', the prompted startup of plstar\n"
19695 " is used. This routine also divides the output device into nx by ny\n"
19696 " subpages, each of which may be used independently. The subroutine\n"
19697 " pladv is used to advance from one subpage to the next. \n"
19699 " Redacted form: General: plstart(device, nx, ny)\n"
19700 " Perl/PDL: plstart(nx, ny, device)\n"
19703 " This function is not used in any examples. \n"
19709 "plstart(device, nx, ny)\n"
19713 " device (const char *, input) : Device name (keyword) of the\n"
19714 " required output device. If NULL or if the first character is a\n"
19715 " ``?'', the normal (prompted) startup is used. \n"
19717 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19718 " horizontal direction. \n"
19720 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19721 " vertical direction. \n"
19725 "Set a global coordinate transform function \n"
19729 " This function can be used to define a coordinate transformation which\n"
19730 " affects all elements drawn within the current plot window. The\n"
19731 " transformation function is similar to that provided for the plmap and\n"
19732 " plmeridians functions. The data parameter may be used to pass extra\n"
19733 " data to transform_fun. \n"
19735 " Redacted form: General: plstransform(transform_fun, data)\n"
19738 " This function is used in example 19. \n"
19744 "plstransform(transform_fun, data)\n"
19748 " transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
19749 " input) : Pointer to a function that defines a transformation\n"
19750 " from the input (x, y) coordinate to a new plot world coordiante. \n"
19752 " data (PLPointer, input) : Optional extra data for \n"
19753 " transform_fun. \n"
19756 { (
char *)
"plstring",
_wrap_plstring, METH_VARARGS, (
char *)
"\n"
19757 "Plot a glyph at the specified points \n"
19761 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
19762 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
19763 " is specified with a PLplot user string. Note that the user string is\n"
19764 " not actually limited to one glyph so it is possible (but not normally\n"
19765 " useful) to plot more than one glyph at the specified points with this\n"
19766 " function. As with plmtex and plptex, the user string can contain FCI\n"
19767 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19768 " else PLplot escapes for Hershey or unicode text to determine the\n"
19771 " Redacted form: plstring(x, y, string)\n"
19773 " This function is used in examples 4, 21 and 26. \n"
19779 "plstring(n, x, y, string)\n"
19783 " n (PLINT, input) : Number of points in the x and y arrays. \n"
19785 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19788 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19791 " string (const char *, input) : PLplot user string corresponding to\n"
19792 " the glyph to be plotted at each of the n points. \n"
19796 "Plot a glyph at the specified 3D points \n"
19800 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
19801 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
19802 " this function similar to what is done for plline3. The glyph is\n"
19803 " specified with a PLplot user string. Note that the user string is not\n"
19804 " actually limited to one glyph so it is possible (but not normally\n"
19805 " useful) to plot more than one glyph at the specified points with this\n"
19806 " function. As with plmtex and plptex, the user string can contain FCI\n"
19807 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19808 " else PLplot escapes for Hershey or unicode text to determine the\n"
19811 " Redacted form: plstring3(x, y, z, string)\n"
19813 " This function is used in example 18. \n"
19819 "plstring3(n, x, y, z, string)\n"
19823 " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
19825 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19828 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19831 " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
19834 " string (const char *, input) : PLplot user string corresponding to\n"
19835 " the glyph to be plotted at each of the n points. \n"
19838 { (
char *)
"plstripa",
_wrap_plstripa, METH_VARARGS, (
char *)
"\n"
19839 "Add a point to a stripchart \n"
19843 " Add a point to a given pen of a given stripchart. There is no need for\n"
19844 " all pens to have the same number of points or to be equally sampled in\n"
19845 " the x coordinate. Allocates memory and rescales as necessary. \n"
19847 " Redacted form: plstripa(id, p, x, y)\n"
19849 " This function is used in example 17. \n"
19855 "plstripa(id, p, x, y)\n"
19859 " id (PLINT, input) : Identification number (set up in plstripc) of\n"
19860 " the stripchart. \n"
19862 " p (PLINT, input) : Pen number (ranges from 0 to 3). \n"
19864 " x (PLFLT, input) : X coordinate of point to plot. \n"
19866 " y (PLFLT, input) : Y coordinate of point to plot. \n"
19869 { (
char *)
"plstripc",
_wrap_plstripc, METH_VARARGS, (
char *)
"\n"
19870 "Create a 4-pen stripchart \n"
19874 " Create a 4-pen stripchart, to be used afterwards by plstripa\n"
19876 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
19877 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
19878 " styline, legline, labx, laby, labz)\n"
19879 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
19880 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
19881 " ypsec, legline, labx, laby, labtop)\n"
19884 " This function is used in example 17. \n"
19890 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
19894 " id (PLINT *, output) : Identification number of stripchart to use\n"
19895 " on plstripa and plstripd. \n"
19897 " xspec (char *, input) : X-axis specification as in plbox. \n"
19899 " yspec (char *, input) : Y-axis specification as in plbox. \n"
19901 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19902 " change as data are added. \n"
19904 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19905 " change as data are added. \n"
19907 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
19908 " is multiplied by the factor (1 + \n"
19911 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19912 " change as data are added. \n"
19914 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19915 " change as data are added. \n"
19917 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
19919 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
19921 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
19922 " true, otherwise not. \n"
19924 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
19925 " otherwise slide display. \n"
19927 " colbox (PLINT, input) : Plot box color index (cmap0). \n"
19929 " collab (PLINT, input) : Legend color index (cmap0). \n"
19931 " colline (PLINT *, input) : Pointer to array with color indices\n"
19932 " (cmap0) for the 4 pens. \n"
19934 " styline (PLINT *, input) : Pointer to array with line styles for\n"
19937 " legline (char **, input) : Pointer to character array containing\n"
19938 " legends for the 4 pens. \n"
19940 " labx (char *, input) : X-axis label. \n"
19942 " laby (char *, input) : Y-axis label. \n"
19944 " labtop (char *, input) : Plot title. \n"
19947 { (
char *)
"plstripd",
_wrap_plstripd, METH_VARARGS, (
char *)
"\n"
19948 "Deletes and releases memory used by a stripchart \n"
19952 " Deletes and releases memory used by a stripchart. \n"
19954 " Redacted form: plstripd(id)\n"
19956 " This function is used in example 17. \n"
19966 " id (PLINT, input) : Identification number of stripchart to delete. \n"
19969 { (
char *)
"plstyl",
_wrap_plstyl, METH_VARARGS, (
char *)
"\n"
19970 "Set line style \n"
19974 " This sets up the line style for all lines subsequently drawn. A line\n"
19975 " consists of segments in which the pen is alternately down and up. The\n"
19976 " lengths of these segments are passed in the arrays mark and space\n"
19977 " respectively. The number of mark-space pairs is specified by nels. \n"
19978 " In order to return the line style to the default continuous line,\n"
19979 " plstyl should be called with nels=0.(see also pllsty) \n"
19981 " Redacted form: plstyl(mark, space)\n"
19983 " This function is used in examples 1,9,14. \n"
19989 "plstyl(nels, mark, space)\n"
19993 " nels (PLINT, input) : The number of mark and space elements in a\n"
19994 " line. Thus a simple broken line can be obtained by setting\n"
19995 " nels=1. A continuous line is specified by setting nels=0. \n"
19997 " mark (PLINT *, input) : Pointer to array with the lengths of the\n"
19998 " segments during which the pen is down, measured in micrometers. \n"
20000 " space (PLINT *, input) : Pointer to array with the lengths of the\n"
20001 " segments during which the pen is up, measured in micrometers. \n"
20004 { (
char *)
"plsvect",
_wrap_plsvect, METH_VARARGS, (
char *)
"\n"
20005 "Set arrow style for vector plots \n"
20009 " Set the style for the arrow used by plvect to plot vectors. \n"
20011 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20013 " This function is used in example 22. \n"
20019 "plsvect(arrowx, arrowy, npts, fill)\n"
20023 " arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n"
20024 " containing the x and y points which make up the arrow. The arrow\n"
20025 " is plotted by joining these points to form a polygon. The scaling\n"
20026 " assumes that the x and y points in the arrow lie in the range -0.5\n"
20027 " <= x,y <= 0.5. \n"
20029 " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
20032 " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
20033 " fill is false then the arrow is open. \n"
20036 { (
char *)
"plsvpa",
_wrap_plsvpa, METH_VARARGS, (
char *)
"\n"
20037 "Specify viewport in absolute coordinates \n"
20041 " Alternate routine to plvpor for setting up the viewport. This routine\n"
20042 " should be used only if the viewport is required to have a definite\n"
20043 " size in millimeters. The routine plgspa is useful for finding out the\n"
20044 " size of the current subpage. \n"
20046 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20048 " This function is used in example 10. \n"
20054 "plsvpa(xmin, xmax, ymin, ymax)\n"
20058 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20059 " viewport from the left-hand edge of the subpage in millimeters. \n"
20061 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20062 " viewport from the left-hand edge of the subpage in millimeters. \n"
20064 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20065 " viewport from the bottom edge of the subpage in millimeters. \n"
20067 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20068 " from the bottom edge of the subpage in millimeters. \n"
20071 { (
char *)
"plsxax",
_wrap_plsxax, METH_VARARGS, (
char *)
"\n"
20072 "Set x axis parameters \n"
20076 " Sets values of the digmax and digits flags for the x axis. See the\n"
20077 " PLplot documentation for more information. \n"
20079 " Redacted form: plsxax(digmax, digits)\n"
20081 " This function is used in example 31. \n"
20087 "plsxax(digmax, digits)\n"
20091 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20092 " digits for the x axis. If nonzero, the printed label will be\n"
20093 " switched to a floating point representation when the number of\n"
20094 " digits exceeds digmax. \n"
20096 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20097 " its value here has no effect since it is set only by plbox or\n"
20098 " plbox3. However, the user may obtain its value after a call to\n"
20099 " either of these functions by calling plgxax. \n"
20102 { (
char *)
"plsyax",
_wrap_plsyax, METH_VARARGS, (
char *)
"\n"
20103 "Set y axis parameters \n"
20107 " Identical to plsxax, except that arguments are flags for y axis. See\n"
20108 " the description of plsxax for more detail. \n"
20110 " Redacted form: plsyax(digmax, digits)\n"
20112 " This function is used in examples 1,14,31. \n"
20118 "plsyax(digmax, digits)\n"
20122 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20123 " digits for the y axis. If nonzero, the printed label will be\n"
20124 " switched to a floating point representation when the number of\n"
20125 " digits exceeds digmax. \n"
20127 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20128 " its value here has no effect since it is set only by plbox or\n"
20129 " plbox3. However, the user may obtain its value after a call to\n"
20130 " either of these functions by calling plgyax. \n"
20133 { (
char *)
"plsym",
_wrap_plsym, METH_VARARGS, (
char *)
"\n"
20134 "Plot a glyph at the specified points \n"
20138 " Plot a glyph at the specified points. (This function is largely\n"
20139 " superseded by plstring which gives access to many[!] more glyphs.) \n"
20141 " Redacted form: plsym(x, y, code)\n"
20143 " This function is used in example 7. \n"
20149 "plsym(n, x, y, code)\n"
20153 " n (PLINT, input) : Number of points in the x and y arrays. \n"
20155 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20158 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20161 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
20162 " to be plotted at each of the n points. \n"
20165 { (
char *)
"plszax",
_wrap_plszax, METH_VARARGS, (
char *)
"\n"
20166 "Set z axis parameters \n"
20170 " Identical to plsxax, except that arguments are flags for z axis. See\n"
20171 " the description of plsxax for more detail. \n"
20173 " Redacted form: plszax(digmax, digits)\n"
20175 " This function is used in example 31. \n"
20181 "plszax(digmax, digits)\n"
20185 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20186 " digits for the z axis. If nonzero, the printed label will be\n"
20187 " switched to a floating point representation when the number of\n"
20188 " digits exceeds digmax. \n"
20190 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20191 " its value here has no effect since it is set only by plbox or\n"
20192 " plbox3. However, the user may obtain its value after a call to\n"
20193 " either of these functions by calling plgzax. \n"
20196 { (
char *)
"pltext",
_wrap_pltext, METH_VARARGS, (
char *)
"\n"
20197 "Switch to text screen \n"
20201 " Sets an interactive device to text mode, used in conjunction with\n"
20202 " plgra to allow graphics and text to be interspersed. On a device\n"
20203 " which supports separate text and graphics windows, this command causes\n"
20204 " control to be switched to the text window. This can be useful for\n"
20205 " printing diagnostic messages or getting user input, which would\n"
20206 " otherwise interfere with the plots. The program must switch back to\n"
20207 " the graphics window before issuing plot commands, as the text (or\n"
20208 " console) device will probably become quite confused otherwise. If\n"
20209 " already in text mode, this command is ignored. It is also ignored on\n"
20210 " devices which only support a single window or use a different method\n"
20211 " for shifting focus (see also plgra). \n"
20213 " Redacted form: pltext()\n"
20215 " This function is used in example 1. \n"
20225 "Set format for date / time labels \n"
20229 " Sets the format for date / time labels. To enable date / time format\n"
20230 " labels see the options to plbox and plenv. \n"
20232 " Redacted form: pltimefmt(fmt)\n"
20234 " This function is used in example 29. \n"
20244 " fmt (const char *, fmt) : This string is passed directly to the\n"
20245 " system strftime. See the system documentation for a full list of\n"
20246 " conversion specifications for your system. All conversion\n"
20247 " specifications take the form of a '%' character followed by\n"
20248 " further conversion specification character. All other text is\n"
20249 " printed as-is. Common options include: %c: The preferred date and\n"
20250 " time representation for the current locale. \n"
20251 " %d: The day of the month as a decimal number. \n"
20252 " %H: The hour as a decimal number using a 24-hour clock. \n"
20253 " %j: The day of the year as a decimal number. \n"
20254 " %m: The month as a decimal number. \n"
20255 " %M: The minute as a decimal number. \n"
20256 " %S: The second as a decimal number. \n"
20257 " %y: The year as a decimal number without a century. \n"
20258 " %Y: The year as a decimal number including a century. \n"
20261 { (
char *)
"plvasp",
_wrap_plvasp, METH_VARARGS, (
char *)
"\n"
20262 "Specify viewport using aspect ratio only \n"
20266 " Sets the viewport so that the ratio of the length of the y axis to\n"
20267 " that of the x axis is equal to aspect. \n"
20269 " Redacted form: plvasp(aspect)\n"
20271 " This function is used in example 13. \n"
20281 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20285 { (
char *)
"plvect",
_wrap_plvect, METH_VARARGS, (
char *)
"\n"
20290 " Draws a vector plot of the vector (\n"
20296 " ny]). The scaling factor for the vectors is given by scale. A\n"
20297 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
20298 " additional data required by the transformation routine is used to map\n"
20299 " indices within the array to the world coordinates. The style of the\n"
20300 " vector arrow may be set using plsvect. \n"
20302 " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
20304 " This function is used in example 22. \n"
20310 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
20314 " u, v (PLFLT **, input) : Pointers to a pair of vectored\n"
20315 " two-dimensional arrays containing the x and y components of the\n"
20316 " vector data to be plotted. \n"
20318 " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
20320 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
20321 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
20322 " automatically calculated for the data. If scale < 0 then the\n"
20323 " scaling factor is automatically calculated for the data and then\n"
20324 " multiplied by -\n"
20325 " scale. If scale > 0 then the scaling factor is set to scale. \n"
20327 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20328 " Pointer to function that defines transformation between indices\n"
20329 " in array z and the world coordinates (C only). Transformation\n"
20330 " functions are provided in the PLplot library: pltr0 for identity\n"
20331 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20332 " defined by one- and two-dimensional arrays. In addition,\n"
20333 " user-supplied routines for the transformation can be used as well.\n"
20334 " Examples of all of these approaches are given in the PLplot\n"
20335 " documentation. The transformation function should have the form\n"
20336 " given by any of pltr0, pltr1, or pltr2. \n"
20338 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20339 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20340 " externally supplied. \n"
20343 { (
char *)
"plvpas",
_wrap_plvpas, METH_VARARGS, (
char *)
"\n"
20344 "Specify viewport using coordinates and aspect ratio \n"
20348 " Device-independent routine for setting up the viewport. The viewport\n"
20349 " is chosen to be the largest with the given aspect ratio that fits\n"
20350 " within the specified region (in terms of normalized subpage\n"
20351 " coordinates). This routine is functionally equivalent to plvpor when\n"
20352 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
20353 " routine reserves no extra space at the edges for labels. \n"
20355 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20357 " This function is used in example 9. \n"
20363 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20367 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20368 " left-hand edge of the viewport. \n"
20370 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20371 " right-hand edge of the viewport. \n"
20373 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20374 " bottom edge of the viewport. \n"
20376 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20377 " edge of the viewport. \n"
20379 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20383 { (
char *)
"plvpor",
_wrap_plvpor, METH_VARARGS, (
char *)
"\n"
20384 "Specify viewport using coordinates \n"
20388 " Device-independent routine for setting up the viewport. This defines\n"
20389 " the viewport in terms of normalized subpage coordinates which run from\n"
20390 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
20391 " current subpage. Use the alternate routine plsvpa in order to create\n"
20392 " a viewport of a definite size. \n"
20394 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
20396 " This function is used in examples\n"
20397 " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
20403 "plvpor(xmin, xmax, ymin, ymax)\n"
20407 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20408 " left-hand edge of the viewport. \n"
20410 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20411 " right-hand edge of the viewport. \n"
20413 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20414 " bottom edge of the viewport. \n"
20416 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20417 " edge of the viewport. \n"
20420 { (
char *)
"plvsta",
_wrap_plvsta, METH_VARARGS, (
char *)
"\n"
20421 "Select standard viewport \n"
20425 " Sets up a standard viewport, leaving a left-hand margin of seven\n"
20426 " character heights, and four character heights around the other three\n"
20429 " Redacted form: plvsta()\n"
20431 " This function is used in examples 1,12,14,17,25,29. \n"
20440 { (
char *)
"plw3d",
_wrap_plw3d, METH_VARARGS, (
char *)
"\n"
20441 "Set up window for 3-d plotting \n"
20445 " Sets up a window for a three-dimensional surface plot within the\n"
20446 " currently defined two-dimensional window. The enclosing box for the\n"
20447 " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
20448 " user-coordinate space is mapped into a box of world coordinate size\n"
20449 " basex by basey by height so that xmin maps to -\n"
20450 " basex/2, xmax maps to basex/2, ymin maps to -\n"
20451 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
20452 " The resulting world-coordinate box is then viewed by an observer at\n"
20453 " altitude alt and azimuth az. This routine must be called before\n"
20454 " plbox3 or plot3d. For a more complete description of\n"
20455 " three-dimensional plotting see the PLplot documentation. \n"
20457 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
20458 " zmin, zmax, alt, az)\n"
20460 " This function is examples 8,11,18,21. \n"
20466 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
20470 " basex (PLFLT, input) : The x coordinate size of the\n"
20471 " world-coordinate box. \n"
20473 " basey (PLFLT, input) : The y coordinate size of the\n"
20474 " world-coordinate box. \n"
20476 " height (PLFLT, input) : The z coordinate size of the\n"
20477 " world-coordinate box. \n"
20479 " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
20481 " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
20483 " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
20485 " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
20487 " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
20489 " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
20491 " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
20494 " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n"
20495 " observer is looking face onto the ZX plane, and as az is\n"
20496 " increased, the observer moves clockwise around the box when viewed\n"
20497 " from above the XY plane. \n"
20500 { (
char *)
"plwidth",
_wrap_plwidth, METH_VARARGS, (
char *)
"\n"
20505 " Sets the pen width. \n"
20507 " Redacted form: plwidth(width)\n"
20509 " This function is used in examples 1,2. \n"
20519 " width (PLINT, input) : The desired pen width. If width is negative\n"
20520 " or the same as the previous value no action is taken. width = 0\n"
20521 " should be interpreted as as the minimum valid pen width for the\n"
20522 " device. The interpretation of positive width values is also\n"
20523 " device dependent. \n"
20526 { (
char *)
"plwind",
_wrap_plwind, METH_VARARGS, (
char *)
"\n"
20527 "Specify world coordinates of viewport boundaries \n"
20531 " Sets up the world coordinates of the edges of the viewport. \n"
20533 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
20535 " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
20541 "plwind(xmin, xmax, ymin, ymax)\n"
20545 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
20546 " of the viewport. \n"
20548 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
20549 " of the viewport. \n"
20551 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
20552 " the viewport. \n"
20554 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
20558 { (
char *)
"plxormod",
_wrap_plxormod, METH_VARARGS, (
char *)
"\n"
20559 "Enter or leave xor mode \n"
20563 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
20564 " those drivers (e.g., the xwin driver) that support it. Enables\n"
20565 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
20566 " is not capable of xor operation it returns a status of false. \n"
20568 " Redacted form: plxormod(mode, status)\n"
20570 " This function is used in examples 1,20. \n"
20576 "plxormod(mode, status)\n"
20580 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
20581 " is false means leave xor mode. \n"
20583 " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
20584 " of true (false) means driver is capable (incapable) of xor mode. \n"
20587 { (
char *)
"plmap",
_wrap_plmap, METH_VARARGS, (
char *)
"\n"
20588 "Plot continental outline in world coordinates. \n"
20592 " Plots continental outlines in world coordinates. examples/c/x19c\n"
20593 " demonstrates how to use this function to create different\n"
20596 " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n"
20597 " minlat, maxlat)\n"
20598 " F95, Java, Perl/PDL, Python: Not implemented? \n"
20601 " This function is used in example 19. \n"
20607 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
20611 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20612 " supplied function to transform the coordinate longitudes and\n"
20613 " latitudes to a plot coordinate system. By using this transform,\n"
20614 " we can change from a longitude, latitude coordinate to a polar\n"
20615 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20616 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20617 " After the call to mapform(), x[] and y[] should be replaced by\n"
20618 " the corresponding plot coordinates. If no transform is desired,\n"
20619 " mapform can be replaced by NULL. \n"
20621 " type (char *, input) : type is a character string. The value of\n"
20622 " this parameter determines the type of background. The possible\n"
20623 " values are: \"globe\" -- continental outlines \n"
20624 " \"usa\" -- USA and state boundaries \n"
20625 " \"cglobe\" -- continental outlines and countries \n"
20626 " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
20629 " minlong (PLFLT, input) : The value of the longitude on the left\n"
20630 " side of the plot. The value of minlong must be less than the\n"
20631 " value of maxlong, and the quantity maxlong-minlong must be less\n"
20632 " than or equal to 360. \n"
20634 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20635 " side of the plot. \n"
20637 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20638 " background. One can always use -90.0 as the boundary outside the\n"
20639 " plot window will be automatically eliminated. However, the\n"
20640 " program will be faster if one can reduce the size of the\n"
20641 " background plotted. \n"
20643 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20644 " background. One can always use 90.0 as the boundary outside the\n"
20645 " plot window will be automatically eliminated. \n"
20649 "Plot latitude and longitude lines. \n"
20653 " Displays latitude and longitude on the current plot. The lines are\n"
20654 " plotted in the current color and line style. \n"
20656 " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n"
20657 " maxlong, minlat, maxlat)\n"
20658 " F95, Java, Perl/PDL, Python: Not implemented? \n"
20661 " This function is used in example 19. \n"
20667 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
20671 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20672 " supplied function to transform the coordinate longitudes and\n"
20673 " latitudes to a plot coordinate system. By using this transform,\n"
20674 " we can change from a longitude, latitude coordinate to a polar\n"
20675 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20676 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20677 " After the call to mapform(), x[] and y[] should be replaced by\n"
20678 " the corresponding plot coordinates. If no transform is desired,\n"
20679 " mapform can be replaced by NULL. \n"
20681 " dlong (PLFLT, input) : The interval in degrees at which the\n"
20682 " longitude lines are to be plotted. \n"
20684 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
20685 " lines are to be plotted. \n"
20687 " minlong (PLFLT, input) : The value of the longitude on the left\n"
20688 " side of the plot. The value of minlong must be less than the\n"
20689 " value of maxlong, and the quantity maxlong-minlong must be less\n"
20690 " than or equal to 360. \n"
20692 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20693 " side of the plot. \n"
20695 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20696 " background. One can always use -90.0 as the boundary outside the\n"
20697 " plot window will be automatically eliminated. However, the\n"
20698 " program will be faster if one can reduce the size of the\n"
20699 " background plotted. \n"
20701 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20702 " background. One can always use 90.0 as the boundary outside the\n"
20703 " plot window will be automatically eliminated. \n"
20706 { (
char *)
"plimage",
_wrap_plimage, METH_VARARGS, (
char *)
"\n"
20707 "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
20711 " Plot a 2D matrix using color palette 1. The color scale is\n"
20712 " automatically adjusted to use the maximum and minimum values in idata\n"
20713 " as valuemin and valuemax in a call to plimagefr. \n"
20715 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
20716 " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
20719 " This function is used in example 20. \n"
20725 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
20729 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20730 " plot. Should have dimensions idata[nx][ny]. \n"
20732 " nx, ny (PLINT, input) : Dimensions of idata \n"
20734 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to strecth\n"
20735 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
20736 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20738 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20739 " (inclusive) will be plotted. \n"
20741 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
20742 " points whose plot coordinates fall inside the window of (Dxmin,\n"
20743 " Dymin) to (Dxmax, Dymax). \n"
20747 "Plot a 2D matrix using color map1 \n"
20751 " Plot a 2D matrix using color map1. \n"
20753 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
20754 " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
20757 " This function is used in example 20. \n"
20763 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
20767 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20768 " plot. Should have dimensions idata[nx][ny]. \n"
20770 " nx, ny (PLINT, input) : Dimensions of idata \n"
20772 " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
20773 " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
20774 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20776 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20777 " (inclusive) will be plotted. \n"
20779 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
20780 " values to use for value to color mappings. A datum equal to or\n"
20781 " less than valuemin will be plotted with color 0.0, while a datum\n"
20782 " equal to or greater than valuemax will be plotted with color 1.0. \n"
20783 " Data between valuemin and valuemax map linearly to colors between\n"
20786 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20787 " Pointer to function that defines a transformation between the\n"
20788 " data in the array idata and world coordinates. An input\n"
20789 " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
20790 " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
20791 " Some transformation functions are provided in the PLplot library:\n"
20792 " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
20793 " mappings respectively defined by one- and two-dimensional arrays. \n"
20794 " In addition, user-supplied routines for the transformation can be\n"
20795 " used as well. Examples of all of these approaches are given in\n"
20796 " the PLplot documentation. The transformation function should have\n"
20797 " the form given by any of pltr0, pltr1, or pltr2. \n"
20799 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20800 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
20801 " externally supplied. \n"
20810 { NULL, NULL, 0, NULL }
20884 {0, 0, 0, 0.0, 0, 0}};
20938 #define SWIGRUNTIME_DEBUG
20949 if (swig_module.
next==0) {
20961 if (!module_head) {
20971 if (iter==&swig_module) {
20976 }
while (iter!= module_head);
20981 swig_module.
next = module_head->
next;
20989 if (init == 0)
return;
20992 #ifdef SWIGRUNTIME_DEBUG
20993 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
20995 for (i = 0; i < swig_module.
size; ++i) {
21000 #ifdef SWIGRUNTIME_DEBUG
21001 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
21005 if (swig_module.
next != &swig_module) {
21010 #ifdef SWIGRUNTIME_DEBUG
21011 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
21015 #ifdef SWIGRUNTIME_DEBUG
21016 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
21025 while (cast->
type) {
21028 #ifdef SWIGRUNTIME_DEBUG
21029 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
21031 if (swig_module.
next != &swig_module) {
21033 #ifdef SWIGRUNTIME_DEBUG
21034 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
21039 #ifdef SWIGRUNTIME_DEBUG
21040 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
21047 #ifdef SWIGRUNTIME_DEBUG
21048 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
21050 if (!ocast) ret = 0;
21055 #ifdef SWIGRUNTIME_DEBUG
21056 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
21067 swig_module.
types[i] = type;
21069 swig_module.
types[i] = 0;
21071 #ifdef SWIGRUNTIME_DEBUG
21072 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21073 for (i = 0; i < swig_module.
size; ++i) {
21076 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
21077 while (cast->
type) {
21078 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
21082 printf(
"---- Total casts: %d\n",j);
21084 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21097 static int init_run = 0;
21099 if (init_run)
return;
21102 for (i = 0; i < swig_module.
size; i++) {
21110 equiv = equiv->
next;
21131 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21132 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21133 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21153 #if PY_VERSION_HEX >= 0x03000000
21154 return PyUnicode_InternFromString(
"<Swig global variables>");
21156 return PyString_FromString(
"<Swig global variables>");
21162 #if PY_VERSION_HEX >= 0x03000000
21163 PyObject *str = PyUnicode_InternFromString(
"(");
21167 for (var = v->
vars; var; var=var->
next) {
21168 tail = PyUnicode_FromString(var->
name);
21169 joined = PyUnicode_Concat(str, tail);
21174 tail = PyUnicode_InternFromString(
", ");
21175 joined = PyUnicode_Concat(str, tail);
21181 tail = PyUnicode_InternFromString(
")");
21182 joined = PyUnicode_Concat(str, tail);
21187 PyObject *str = PyString_FromString(
"(");
21189 for (var = v->
vars; var; var=var->
next) {
21190 PyString_ConcatAndDel(&str,PyString_FromString(var->
name));
21191 if (var->
next) PyString_ConcatAndDel(&str,PyString_FromString(
", "));
21193 PyString_ConcatAndDel(&str,PyString_FromString(
")"));
21202 fprintf(fp,
"Swig global variables ");
21222 PyObject *res = NULL;
21225 if (strcmp(var->
name,n) == 0) {
21231 if (res == NULL && !PyErr_Occurred()) {
21232 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
21242 if (strcmp(var->
name,n) == 0) {
21248 if (res == 1 && !PyErr_Occurred()) {
21249 PyErr_SetString(PyExc_NameError,
"Unknown C global variable");
21256 static char varlink__doc__[] =
"Swig var link object";
21257 static PyTypeObject varlink_type;
21258 static int type_init = 0;
21260 const PyTypeObject tmp = {
21262 #if PY_VERSION_HEX >= 0x03000000
21263 PyVarObject_HEAD_INIT(NULL, 0)
21265 PyObject_HEAD_INIT(NULL)
21268 (
char *)
"swigvarlink",
21292 #if PY_VERSION_HEX >= 0x02020000
21293 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
21295 #if PY_VERSION_HEX >= 0x02030000
21298 #if PY_VERSION_HEX >= 0x02060000
21301 #ifdef COUNT_ALLOCS
21305 varlink_type = tmp;
21307 #if PY_VERSION_HEX < 0x02020000
21308 varlink_type.ob_type = &PyType_Type;
21310 if (PyType_Ready(&varlink_type) < 0)
21314 return &varlink_type;
21324 return ((PyObject*) result);
21332 size_t size = strlen(name)+1;
21333 gv->
name = (
char *)malloc(size);
21335 strncpy(gv->
name,name,size);
21346 static PyObject *_SWIG_globals = 0;
21348 return _SWIG_globals;
21360 for (i = 0; constants[i].
type; ++i) {
21361 switch(constants[i].type) {
21366 obj =
SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21373 PyDict_SetItemString(d, constants[i].name, obj);
21389 for (i = 0; methods[i].ml_name; ++i) {
21390 const char *c = methods[i].ml_doc;
21391 if (c && (c = strstr(c,
"swig_ptr: "))) {
21394 const char *name = c + 10;
21395 for (j = 0; const_table[j].
type; ++j) {
21396 if (strncmp(const_table[j].name, name,
21397 strlen(const_table[j].name)) == 0) {
21398 ci = &(const_table[j]);
21405 size_t shift = (ci->
ptype) - types;
21407 size_t ldoc = (c - methods[i].ml_doc);
21408 size_t lptr = strlen(ty->
name)+2*
sizeof(
void*)+2;
21409 char *ndoc = (
char*)malloc(ldoc + lptr + 10);
21412 strncpy(buff, methods[i].ml_doc, ldoc);
21414 strncpy(buff,
"swig_ptr: ", 10);
21417 methods[i].ml_doc = ndoc;
21438 #if PY_VERSION_HEX >= 0x03000000
21444 PyObject *m, *d, *md;
21445 #if PY_VERSION_HEX >= 0x03000000
21446 static struct PyModuleDef SWIG_module = {
21447 # if PY_VERSION_HEX >= 0x03020000
21448 PyModuleDef_HEAD_INIT,
21451 PyObject_HEAD_INIT(NULL)
21468 #if defined(SWIGPYTHON_BUILTIN)
21470 0, 0, 0, 0, 0, 0, 0
21472 static PyGetSetDef this_getset_def = {
21473 (
char *)
"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
21475 static SwigPyGetSet thisown_getset_closure = {
21479 static PyGetSetDef thisown_getset_def = {
21480 (
char *)
"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
21482 PyObject *metatype_args;
21483 PyTypeObject *builtin_pytype;
21484 int builtin_base_count;
21487 PyGetSetDescrObject *static_getset;
21488 PyTypeObject *metatype;
21490 PyObject *public_interface, *public_symbol;
21491 PyObject *this_descr;
21492 PyObject *thisown_descr;
21495 (
void)builtin_pytype;
21496 (
void)builtin_base_count;
21497 (
void)builtin_basetype;
21499 (
void)static_getset;
21502 metatype_args = Py_BuildValue(
"(s(O){})",
"SwigPyObjectType", &PyType_Type);
21503 assert(metatype_args);
21504 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
21506 Py_DECREF(metatype_args);
21507 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
21508 assert(PyType_Ready(metatype) >= 0);
21514 #if PY_VERSION_HEX >= 0x03000000
21515 m = PyModule_Create(&SWIG_module);
21517 m = Py_InitModule((
char *)
SWIG_name, SwigMethods);
21519 md = d = PyModule_GetDict(m);
21524 #ifdef SWIGPYTHON_BUILTIN
21526 assert(SwigPyObject_stype);
21529 SwigPyObject_stype->
clientdata = &SwigPyObject_clientdata;
21532 PyErr_SetString(PyExc_RuntimeError,
"Import error: attempted to load two incompatible swig-generated modules.");
21533 # if PY_VERSION_HEX >= 0x03000000
21546 (
void)thisown_descr;
21548 public_interface = PyList_New(0);
21550 (
void)public_symbol;
21552 PyDict_SetItemString(md,
"__all__", public_interface);
21553 Py_DECREF(public_interface);
21554 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
21555 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
21557 SwigPyBuiltin_AddPublicSymbol(public_interface,
swig_const_table[i].name);
21693 #if PY_VERSION_HEX >= 0x03000000