00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #define SWIGPYTHON
00012 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00021 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00022 # define SWIGTEMPLATEDISAMBIGUATOR template
00023 # elif defined(__HP_aCC)
00024
00025
00026 # define SWIGTEMPLATEDISAMBIGUATOR template
00027 # else
00028 # define SWIGTEMPLATEDISAMBIGUATOR
00029 # endif
00030 #endif
00031
00032
00033 #ifndef SWIGINLINE
00034 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00035 # define SWIGINLINE inline
00036 # else
00037 # define SWIGINLINE
00038 # endif
00039 #endif
00040
00041
00042 #ifndef SWIGUNUSED
00043 # if defined(__GNUC__)
00044 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00045 # define SWIGUNUSED __attribute__ ((__unused__))
00046 # else
00047 # define SWIGUNUSED
00048 # endif
00049 # elif defined(__ICC)
00050 # define SWIGUNUSED __attribute__ ((__unused__))
00051 # else
00052 # define SWIGUNUSED
00053 # endif
00054 #endif
00055
00056 #ifndef SWIG_MSC_UNSUPPRESS_4505
00057 # if defined(_MSC_VER)
00058 # pragma warning(disable : 4505)
00059 # endif
00060 #endif
00061
00062 #ifndef SWIGUNUSEDPARM
00063 # ifdef __cplusplus
00064 # define SWIGUNUSEDPARM(p)
00065 # else
00066 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
00067 # endif
00068 #endif
00069
00070
00071 #ifndef SWIGINTERN
00072 # define SWIGINTERN static SWIGUNUSED
00073 #endif
00074
00075
00076 #ifndef SWIGINTERNINLINE
00077 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00078 #endif
00079
00080
00081 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00082 # ifndef GCC_HASCLASSVISIBILITY
00083 # define GCC_HASCLASSVISIBILITY
00084 # endif
00085 #endif
00086
00087 #ifndef SWIGEXPORT
00088 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00089 # if defined(STATIC_LINKED)
00090 # define SWIGEXPORT
00091 # else
00092 # define SWIGEXPORT __declspec(dllexport)
00093 # endif
00094 # else
00095 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00096 # define SWIGEXPORT __attribute__ ((visibility("default")))
00097 # else
00098 # define SWIGEXPORT
00099 # endif
00100 # endif
00101 #endif
00102
00103
00104 #ifndef SWIGSTDCALL
00105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00106 # define SWIGSTDCALL __stdcall
00107 # else
00108 # define SWIGSTDCALL
00109 # endif
00110 #endif
00111
00112
00113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00114 # define _CRT_SECURE_NO_DEPRECATE
00115 #endif
00116
00117
00118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00119 # define _SCL_SECURE_NO_DEPRECATE
00120 #endif
00121
00122
00123
00124
00125 #include <Python.h>
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136 #define SWIG_RUNTIME_VERSION "4"
00137
00138
00139 #ifdef SWIG_TYPE_TABLE
00140 # define SWIG_QUOTE_STRING(x) #x
00141 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00142 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00143 #else
00144 # define SWIG_TYPE_TABLE_NAME
00145 #endif
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156 #ifndef SWIGRUNTIME
00157 # define SWIGRUNTIME SWIGINTERN
00158 #endif
00159
00160 #ifndef SWIGRUNTIMEINLINE
00161 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00162 #endif
00163
00164
00165 #ifndef SWIG_BUFFER_SIZE
00166 # define SWIG_BUFFER_SIZE 1024
00167 #endif
00168
00169
00170 #define SWIG_POINTER_DISOWN 0x1
00171 #define SWIG_CAST_NEW_MEMORY 0x2
00172
00173
00174 #define SWIG_POINTER_OWN 0x1
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256 #define SWIG_OK (0)
00257 #define SWIG_ERROR (-1)
00258 #define SWIG_IsOK(r) (r >= 0)
00259 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
00260
00261
00262 #define SWIG_CASTRANKLIMIT (1 << 8)
00263
00264 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
00265
00266 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
00267
00268 #define SWIG_BADOBJ (SWIG_ERROR)
00269 #define SWIG_OLDOBJ (SWIG_OK)
00270 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
00271 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
00272
00273 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00274 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00275 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00276 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00277 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00278 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00279
00280
00281 #if defined(SWIG_CASTRANK_MODE)
00282 # ifndef SWIG_TypeRank
00283 # define SWIG_TypeRank unsigned long
00284 # endif
00285 # ifndef SWIG_MAXCASTRANK
00286 # define SWIG_MAXCASTRANK (2)
00287 # endif
00288 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
00289 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
00290 SWIGINTERNINLINE int SWIG_AddCast(int r) {
00291 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00292 }
00293 SWIGINTERNINLINE int SWIG_CheckState(int r) {
00294 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
00295 }
00296 #else
00297 # define SWIG_AddCast
00298 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00299 #endif
00300
00301
00302 #include <string.h>
00303
00304 #ifdef __cplusplus
00305 extern "C" {
00306 #endif
00307
00308 typedef void *(*swig_converter_func)(void *, int *);
00309 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00310
00311
00312 typedef struct swig_type_info {
00313 const char *name;
00314 const char *str;
00315 swig_dycast_func dcast;
00316 struct swig_cast_info *cast;
00317 void *clientdata;
00318 int owndata;
00319 } swig_type_info;
00320
00321
00322 typedef struct swig_cast_info {
00323 swig_type_info *type;
00324 swig_converter_func converter;
00325 struct swig_cast_info *next;
00326 struct swig_cast_info *prev;
00327 } swig_cast_info;
00328
00329
00330
00331
00332 typedef struct swig_module_info {
00333 swig_type_info **types;
00334 size_t size;
00335 struct swig_module_info *next;
00336 swig_type_info **type_initial;
00337 swig_cast_info **cast_initial;
00338 void *clientdata;
00339 } swig_module_info;
00340
00341
00342
00343
00344
00345
00346
00347
00348 SWIGRUNTIME int
00349 SWIG_TypeNameComp(const char *f1, const char *l1,
00350 const char *f2, const char *l2) {
00351 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00352 while ((*f1 == ' ') && (f1 != l1)) ++f1;
00353 while ((*f2 == ' ') && (f2 != l2)) ++f2;
00354 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00355 }
00356 return (int)((l1 - f1) - (l2 - f2));
00357 }
00358
00359
00360
00361
00362
00363 SWIGRUNTIME int
00364 SWIG_TypeEquiv(const char *nb, const char *tb) {
00365 int equiv = 0;
00366 const char* te = tb + strlen(tb);
00367 const char* ne = nb;
00368 while (!equiv && *ne) {
00369 for (nb = ne; *ne; ++ne) {
00370 if (*ne == '|') break;
00371 }
00372 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00373 if (*ne) ++ne;
00374 }
00375 return equiv;
00376 }
00377
00378
00379
00380
00381
00382 SWIGRUNTIME int
00383 SWIG_TypeCompare(const char *nb, const char *tb) {
00384 int equiv = 0;
00385 const char* te = tb + strlen(tb);
00386 const char* ne = nb;
00387 while (!equiv && *ne) {
00388 for (nb = ne; *ne; ++ne) {
00389 if (*ne == '|') break;
00390 }
00391 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00392 if (*ne) ++ne;
00393 }
00394 return equiv;
00395 }
00396
00397
00398
00399
00400
00401 SWIGRUNTIME swig_cast_info *
00402 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00403 if (ty) {
00404 swig_cast_info *iter = ty->cast;
00405 while (iter) {
00406 if (strcmp(iter->type->name, c) == 0) {
00407 if (iter == ty->cast)
00408 return iter;
00409
00410 iter->prev->next = iter->next;
00411 if (iter->next)
00412 iter->next->prev = iter->prev;
00413 iter->next = ty->cast;
00414 iter->prev = 0;
00415 if (ty->cast) ty->cast->prev = iter;
00416 ty->cast = iter;
00417 return iter;
00418 }
00419 iter = iter->next;
00420 }
00421 }
00422 return 0;
00423 }
00424
00425
00426
00427
00428 SWIGRUNTIME swig_cast_info *
00429 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
00430 if (ty) {
00431 swig_cast_info *iter = ty->cast;
00432 while (iter) {
00433 if (iter->type == from) {
00434 if (iter == ty->cast)
00435 return iter;
00436
00437 iter->prev->next = iter->next;
00438 if (iter->next)
00439 iter->next->prev = iter->prev;
00440 iter->next = ty->cast;
00441 iter->prev = 0;
00442 if (ty->cast) ty->cast->prev = iter;
00443 ty->cast = iter;
00444 return iter;
00445 }
00446 iter = iter->next;
00447 }
00448 }
00449 return 0;
00450 }
00451
00452
00453
00454
00455 SWIGRUNTIMEINLINE void *
00456 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
00457 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
00458 }
00459
00460
00461
00462
00463 SWIGRUNTIME swig_type_info *
00464 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00465 swig_type_info *lastty = ty;
00466 if (!ty || !ty->dcast) return ty;
00467 while (ty && (ty->dcast)) {
00468 ty = (*ty->dcast)(ptr);
00469 if (ty) lastty = ty;
00470 }
00471 return lastty;
00472 }
00473
00474
00475
00476
00477 SWIGRUNTIMEINLINE const char *
00478 SWIG_TypeName(const swig_type_info *ty) {
00479 return ty->name;
00480 }
00481
00482
00483
00484
00485
00486 SWIGRUNTIME const char *
00487 SWIG_TypePrettyName(const swig_type_info *type) {
00488
00489
00490
00491
00492 if (!type) return NULL;
00493 if (type->str != NULL) {
00494 const char *last_name = type->str;
00495 const char *s;
00496 for (s = type->str; *s; s++)
00497 if (*s == '|') last_name = s+1;
00498 return last_name;
00499 }
00500 else
00501 return type->name;
00502 }
00503
00504
00505
00506
00507 SWIGRUNTIME void
00508 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00509 swig_cast_info *cast = ti->cast;
00510
00511 ti->clientdata = clientdata;
00512
00513 while (cast) {
00514 if (!cast->converter) {
00515 swig_type_info *tc = cast->type;
00516 if (!tc->clientdata) {
00517 SWIG_TypeClientData(tc, clientdata);
00518 }
00519 }
00520 cast = cast->next;
00521 }
00522 }
00523 SWIGRUNTIME void
00524 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00525 SWIG_TypeClientData(ti, clientdata);
00526 ti->owndata = 1;
00527 }
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537 SWIGRUNTIME swig_type_info *
00538 SWIG_MangledTypeQueryModule(swig_module_info *start,
00539 swig_module_info *end,
00540 const char *name) {
00541 swig_module_info *iter = start;
00542 do {
00543 if (iter->size) {
00544 register size_t l = 0;
00545 register size_t r = iter->size - 1;
00546 do {
00547
00548 register size_t i = (l + r) >> 1;
00549 const char *iname = iter->types[i]->name;
00550 if (iname) {
00551 register int compare = strcmp(name, iname);
00552 if (compare == 0) {
00553 return iter->types[i];
00554 } else if (compare < 0) {
00555 if (i) {
00556 r = i - 1;
00557 } else {
00558 break;
00559 }
00560 } else if (compare > 0) {
00561 l = i + 1;
00562 }
00563 } else {
00564 break;
00565 }
00566 } while (l <= r);
00567 }
00568 iter = iter->next;
00569 } while (iter != end);
00570 return 0;
00571 }
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582 SWIGRUNTIME swig_type_info *
00583 SWIG_TypeQueryModule(swig_module_info *start,
00584 swig_module_info *end,
00585 const char *name) {
00586
00587 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00588 if (ret) {
00589 return ret;
00590 } else {
00591
00592
00593 swig_module_info *iter = start;
00594 do {
00595 register size_t i = 0;
00596 for (; i < iter->size; ++i) {
00597 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00598 return iter->types[i];
00599 }
00600 iter = iter->next;
00601 } while (iter != end);
00602 }
00603
00604
00605 return 0;
00606 }
00607
00608
00609
00610
00611 SWIGRUNTIME char *
00612 SWIG_PackData(char *c, void *ptr, size_t sz) {
00613 static const char hex[17] = "0123456789abcdef";
00614 register const unsigned char *u = (unsigned char *) ptr;
00615 register const unsigned char *eu = u + sz;
00616 for (; u != eu; ++u) {
00617 register unsigned char uu = *u;
00618 *(c++) = hex[(uu & 0xf0) >> 4];
00619 *(c++) = hex[uu & 0xf];
00620 }
00621 return c;
00622 }
00623
00624
00625
00626
00627 SWIGRUNTIME const char *
00628 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00629 register unsigned char *u = (unsigned char *) ptr;
00630 register const unsigned char *eu = u + sz;
00631 for (; u != eu; ++u) {
00632 register char d = *(c++);
00633 register unsigned char uu;
00634 if ((d >= '0') && (d <= '9'))
00635 uu = ((d - '0') << 4);
00636 else if ((d >= 'a') && (d <= 'f'))
00637 uu = ((d - ('a'-10)) << 4);
00638 else
00639 return (char *) 0;
00640 d = *(c++);
00641 if ((d >= '0') && (d <= '9'))
00642 uu |= (d - '0');
00643 else if ((d >= 'a') && (d <= 'f'))
00644 uu |= (d - ('a'-10));
00645 else
00646 return (char *) 0;
00647 *u = uu;
00648 }
00649 return c;
00650 }
00651
00652
00653
00654
00655 SWIGRUNTIME char *
00656 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00657 char *r = buff;
00658 if ((2*sizeof(void *) + 2) > bsz) return 0;
00659 *(r++) = '_';
00660 r = SWIG_PackData(r,&ptr,sizeof(void *));
00661 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00662 strcpy(r,name);
00663 return buff;
00664 }
00665
00666 SWIGRUNTIME const char *
00667 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00668 if (*c != '_') {
00669 if (strcmp(c,"NULL") == 0) {
00670 *ptr = (void *) 0;
00671 return name;
00672 } else {
00673 return 0;
00674 }
00675 }
00676 return SWIG_UnpackData(++c,ptr,sizeof(void *));
00677 }
00678
00679 SWIGRUNTIME char *
00680 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00681 char *r = buff;
00682 size_t lname = (name ? strlen(name) : 0);
00683 if ((2*sz + 2 + lname) > bsz) return 0;
00684 *(r++) = '_';
00685 r = SWIG_PackData(r,ptr,sz);
00686 if (lname) {
00687 strncpy(r,name,lname+1);
00688 } else {
00689 *r = 0;
00690 }
00691 return buff;
00692 }
00693
00694 SWIGRUNTIME const char *
00695 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00696 if (*c != '_') {
00697 if (strcmp(c,"NULL") == 0) {
00698 memset(ptr,0,sz);
00699 return name;
00700 } else {
00701 return 0;
00702 }
00703 }
00704 return SWIG_UnpackData(++c,ptr,sz);
00705 }
00706
00707 #ifdef __cplusplus
00708 }
00709 #endif
00710
00711
00712 #define SWIG_UnknownError -1
00713 #define SWIG_IOError -2
00714 #define SWIG_RuntimeError -3
00715 #define SWIG_IndexError -4
00716 #define SWIG_TypeError -5
00717 #define SWIG_DivisionByZero -6
00718 #define SWIG_OverflowError -7
00719 #define SWIG_SyntaxError -8
00720 #define SWIG_ValueError -9
00721 #define SWIG_SystemError -10
00722 #define SWIG_AttributeError -11
00723 #define SWIG_MemoryError -12
00724 #define SWIG_NullReferenceError -13
00725
00726
00727
00728
00729 #if PY_VERSION_HEX >= 0x03000000
00730
00731 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
00732 #define PyInt_Check(x) PyLong_Check(x)
00733 #define PyInt_AsLong(x) PyLong_AsLong(x)
00734 #define PyInt_FromLong(x) PyLong_FromLong(x)
00735 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
00736
00737 #endif
00738
00739 #ifndef Py_TYPE
00740 # define Py_TYPE(op) ((op)->ob_type)
00741 #endif
00742
00743
00744
00745 #if PY_VERSION_HEX >= 0x03000000
00746 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
00747 #else
00748 # define SWIG_Python_str_FromFormat PyString_FromFormat
00749 #endif
00750
00751
00752
00753
00754
00755 SWIGINTERN char*
00756 SWIG_Python_str_AsChar(PyObject *str)
00757 {
00758 #if PY_VERSION_HEX >= 0x03000000
00759 char *cstr;
00760 char *newstr;
00761 Py_ssize_t len;
00762 str = PyUnicode_AsUTF8String(str);
00763 PyBytes_AsStringAndSize(str, &cstr, &len);
00764 newstr = (char *) malloc(len+1);
00765 memcpy(newstr, cstr, len+1);
00766 Py_XDECREF(str);
00767 return newstr;
00768 #else
00769 return PyString_AsString(str);
00770 #endif
00771 }
00772
00773 #if PY_VERSION_HEX >= 0x03000000
00774 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
00775 #else
00776 # define SWIG_Python_str_DelForPy3(x)
00777 #endif
00778
00779
00780 SWIGINTERN PyObject*
00781 SWIG_Python_str_FromChar(const char *c)
00782 {
00783 #if PY_VERSION_HEX >= 0x03000000
00784 return PyUnicode_FromString(c);
00785 #else
00786 return PyString_FromString(c);
00787 #endif
00788 }
00789
00790
00791 #if PY_VERSION_HEX < 0x02020000
00792 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
00793 # define PyOS_snprintf _snprintf
00794 # else
00795 # define PyOS_snprintf snprintf
00796 # endif
00797 #endif
00798
00799
00800 #if PY_VERSION_HEX < 0x02020000
00801
00802 #ifndef SWIG_PYBUFFER_SIZE
00803 # define SWIG_PYBUFFER_SIZE 1024
00804 #endif
00805
00806 static PyObject *
00807 PyString_FromFormat(const char *fmt, ...) {
00808 va_list ap;
00809 char buf[SWIG_PYBUFFER_SIZE * 2];
00810 int res;
00811 va_start(ap, fmt);
00812 res = vsnprintf(buf, sizeof(buf), fmt, ap);
00813 va_end(ap);
00814 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
00815 }
00816 #endif
00817
00818
00819 #if PY_VERSION_HEX < 0x01060000
00820 # define PyObject_Del(op) PyMem_DEL((op))
00821 #endif
00822 #ifndef PyObject_DEL
00823 # define PyObject_DEL PyObject_Del
00824 #endif
00825
00826
00827 #if PY_VERSION_HEX < 0x02020000
00828 # ifndef PyExc_StopIteration
00829 # define PyExc_StopIteration PyExc_RuntimeError
00830 # endif
00831 # ifndef PyObject_GenericGetAttr
00832 # define PyObject_GenericGetAttr 0
00833 # endif
00834 #endif
00835
00836
00837 #if PY_VERSION_HEX < 0x02010000
00838 # ifndef Py_NotImplemented
00839 # define Py_NotImplemented PyExc_RuntimeError
00840 # endif
00841 #endif
00842
00843
00844 #if PY_VERSION_HEX < 0x02010000
00845 # ifndef PyString_AsStringAndSize
00846 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
00847 # endif
00848 #endif
00849
00850
00851 #if PY_VERSION_HEX < 0x02000000
00852 # ifndef PySequence_Size
00853 # define PySequence_Size PySequence_Length
00854 # endif
00855 #endif
00856
00857
00858 #if PY_VERSION_HEX < 0x02030000
00859 static
00860 PyObject *PyBool_FromLong(long ok)
00861 {
00862 PyObject *result = ok ? Py_True : Py_False;
00863 Py_INCREF(result);
00864 return result;
00865 }
00866 #endif
00867
00868
00869
00870
00871 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
00872 typedef int Py_ssize_t;
00873 # define PY_SSIZE_T_MAX INT_MAX
00874 # define PY_SSIZE_T_MIN INT_MIN
00875 #endif
00876
00877
00878
00879
00880
00881 SWIGRUNTIME PyObject*
00882 SWIG_Python_ErrorType(int code) {
00883 PyObject* type = 0;
00884 switch(code) {
00885 case SWIG_MemoryError:
00886 type = PyExc_MemoryError;
00887 break;
00888 case SWIG_IOError:
00889 type = PyExc_IOError;
00890 break;
00891 case SWIG_RuntimeError:
00892 type = PyExc_RuntimeError;
00893 break;
00894 case SWIG_IndexError:
00895 type = PyExc_IndexError;
00896 break;
00897 case SWIG_TypeError:
00898 type = PyExc_TypeError;
00899 break;
00900 case SWIG_DivisionByZero:
00901 type = PyExc_ZeroDivisionError;
00902 break;
00903 case SWIG_OverflowError:
00904 type = PyExc_OverflowError;
00905 break;
00906 case SWIG_SyntaxError:
00907 type = PyExc_SyntaxError;
00908 break;
00909 case SWIG_ValueError:
00910 type = PyExc_ValueError;
00911 break;
00912 case SWIG_SystemError:
00913 type = PyExc_SystemError;
00914 break;
00915 case SWIG_AttributeError:
00916 type = PyExc_AttributeError;
00917 break;
00918 default:
00919 type = PyExc_RuntimeError;
00920 }
00921 return type;
00922 }
00923
00924
00925 SWIGRUNTIME void
00926 SWIG_Python_AddErrorMsg(const char* mesg)
00927 {
00928 PyObject *type = 0;
00929 PyObject *value = 0;
00930 PyObject *traceback = 0;
00931
00932 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
00933 if (value) {
00934 char *tmp;
00935 PyObject *old_str = PyObject_Str(value);
00936 PyErr_Clear();
00937 Py_XINCREF(type);
00938
00939 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
00940 SWIG_Python_str_DelForPy3(tmp);
00941 Py_DECREF(old_str);
00942 Py_DECREF(value);
00943 } else {
00944 PyErr_SetString(PyExc_RuntimeError, mesg);
00945 }
00946 }
00947
00948 #if defined(SWIG_PYTHON_NO_THREADS)
00949 # if defined(SWIG_PYTHON_THREADS)
00950 # undef SWIG_PYTHON_THREADS
00951 # endif
00952 #endif
00953 #if defined(SWIG_PYTHON_THREADS)
00954 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
00955 # if (PY_VERSION_HEX >= 0x02030000)
00956 # define SWIG_PYTHON_USE_GIL
00957 # endif
00958 # endif
00959 # if defined(SWIG_PYTHON_USE_GIL)
00960 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
00961 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
00962 # endif
00963 # ifdef __cplusplus
00964 class SWIG_Python_Thread_Block {
00965 bool status;
00966 PyGILState_STATE state;
00967 public:
00968 void end() { if (status) { PyGILState_Release(state); status = false;} }
00969 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
00970 ~SWIG_Python_Thread_Block() { end(); }
00971 };
00972 class SWIG_Python_Thread_Allow {
00973 bool status;
00974 PyThreadState *save;
00975 public:
00976 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
00977 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
00978 ~SWIG_Python_Thread_Allow() { end(); }
00979 };
00980 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
00981 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
00982 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
00983 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
00984 # else
00985 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
00986 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
00987 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
00988 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
00989 # endif
00990 # else
00991 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
00992 # define SWIG_PYTHON_INITIALIZE_THREADS
00993 # endif
00994 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
00995 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
00996 # endif
00997 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
00998 # define SWIG_PYTHON_THREAD_END_BLOCK
00999 # endif
01000 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
01001 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01002 # endif
01003 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
01004 # define SWIG_PYTHON_THREAD_END_ALLOW
01005 # endif
01006 # endif
01007 #else
01008 # define SWIG_PYTHON_INITIALIZE_THREADS
01009 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
01010 # define SWIG_PYTHON_THREAD_END_BLOCK
01011 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01012 # define SWIG_PYTHON_THREAD_END_ALLOW
01013 #endif
01014
01015
01016
01017
01018
01019 #ifdef __cplusplus
01020 extern "C" {
01021 #if 0
01022 }
01023 #endif
01024 #endif
01025
01026
01027
01028
01029
01030
01031 #define SWIG_PY_POINTER 4
01032 #define SWIG_PY_BINARY 5
01033
01034
01035 typedef struct swig_const_info {
01036 int type;
01037 char *name;
01038 long lvalue;
01039 double dvalue;
01040 void *pvalue;
01041 swig_type_info **ptype;
01042 } swig_const_info;
01043
01044
01045
01046
01047
01048
01049 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
01050 {
01051 #if PY_VERSION_HEX >= 0x03000000
01052 return PyInstanceMethod_New(func);
01053 #else
01054 return NULL;
01055 #endif
01056 }
01057
01058 #ifdef __cplusplus
01059 #if 0
01060 {
01061 #endif
01062 }
01063 #endif
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080
01081 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
01082 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
01083 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
01084 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
01085 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
01086 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
01087 #define swig_owntype int
01088
01089
01090 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01091 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
01092
01093
01094 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
01095 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
01096
01097
01098 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
01099 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
01100
01101
01102 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01103 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
01104
01105
01106
01107
01108 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
01109 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
01110 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
01111
01112 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
01113 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
01114 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
01115 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
01116 #define SWIG_fail goto fail
01117
01118
01119
01120
01121
01122
01123 SWIGINTERN void
01124 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
01125 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01126 PyErr_SetObject(errtype, obj);
01127 Py_DECREF(obj);
01128 SWIG_PYTHON_THREAD_END_BLOCK;
01129 }
01130
01131 SWIGINTERN void
01132 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
01133 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01134 PyErr_SetString(errtype, (char *) msg);
01135 SWIG_PYTHON_THREAD_END_BLOCK;
01136 }
01137
01138 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
01139
01140
01141
01142 SWIGINTERN void
01143 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
01144 PyDict_SetItemString(d, (char*) name, obj);
01145 Py_DECREF(obj);
01146 }
01147
01148
01149
01150 SWIGINTERN PyObject*
01151 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
01152 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
01153 if (!result) {
01154 result = obj;
01155 } else if (result == Py_None) {
01156 Py_DECREF(result);
01157 result = obj;
01158 } else {
01159 if (!PyList_Check(result)) {
01160 PyObject *o2 = result;
01161 result = PyList_New(1);
01162 PyList_SetItem(result, 0, o2);
01163 }
01164 PyList_Append(result,obj);
01165 Py_DECREF(obj);
01166 }
01167 return result;
01168 #else
01169 PyObject* o2;
01170 PyObject* o3;
01171 if (!result) {
01172 result = obj;
01173 } else if (result == Py_None) {
01174 Py_DECREF(result);
01175 result = obj;
01176 } else {
01177 if (!PyTuple_Check(result)) {
01178 o2 = result;
01179 result = PyTuple_New(1);
01180 PyTuple_SET_ITEM(result, 0, o2);
01181 }
01182 o3 = PyTuple_New(1);
01183 PyTuple_SET_ITEM(o3, 0, obj);
01184 o2 = result;
01185 result = PySequence_Concat(o2, o3);
01186 Py_DECREF(o2);
01187 Py_DECREF(o3);
01188 }
01189 return result;
01190 #endif
01191 }
01192
01193
01194
01195 SWIGINTERN int
01196 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
01197 {
01198 if (!args) {
01199 if (!min && !max) {
01200 return 1;
01201 } else {
01202 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
01203 name, (min == max ? "" : "at least "), (int)min);
01204 return 0;
01205 }
01206 }
01207 if (!PyTuple_Check(args)) {
01208 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
01209 return 0;
01210 } else {
01211 register Py_ssize_t l = PyTuple_GET_SIZE(args);
01212 if (l < min) {
01213 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
01214 name, (min == max ? "" : "at least "), (int)min, (int)l);
01215 return 0;
01216 } else if (l > max) {
01217 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
01218 name, (min == max ? "" : "at most "), (int)max, (int)l);
01219 return 0;
01220 } else {
01221 register int i;
01222 for (i = 0; i < l; ++i) {
01223 objs[i] = PyTuple_GET_ITEM(args, i);
01224 }
01225 for (; l < max; ++l) {
01226 objs[l] = 0;
01227 }
01228 return i + 1;
01229 }
01230 }
01231 }
01232
01233
01234 #if PY_VERSION_HEX >= 0x02020000
01235 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
01236 #else
01237 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
01238 #endif
01239
01240
01241
01242
01243
01244 #ifdef __cplusplus
01245 #define SWIG_STATIC_POINTER(var) var
01246 #else
01247 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
01248 #endif
01249
01250
01251
01252
01253
01254
01255 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
01256 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
01257
01258 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
01259
01260 #ifdef __cplusplus
01261 extern "C" {
01262 #if 0
01263 }
01264 #endif
01265 #endif
01266
01267
01268 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
01269 # ifndef SWIG_PYTHON_NO_BUILD_NONE
01270 # ifndef SWIG_PYTHON_BUILD_NONE
01271 # define SWIG_PYTHON_BUILD_NONE
01272 # endif
01273 # endif
01274 #endif
01275
01276 #ifdef SWIG_PYTHON_BUILD_NONE
01277 # ifdef Py_None
01278 # undef Py_None
01279 # define Py_None SWIG_Py_None()
01280 # endif
01281 SWIGRUNTIMEINLINE PyObject *
01282 _SWIG_Py_None(void)
01283 {
01284 PyObject *none = Py_BuildValue((char*)"");
01285 Py_DECREF(none);
01286 return none;
01287 }
01288 SWIGRUNTIME PyObject *
01289 SWIG_Py_None(void)
01290 {
01291 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
01292 return none;
01293 }
01294 #endif
01295
01296
01297
01298 SWIGRUNTIMEINLINE PyObject *
01299 SWIG_Py_Void(void)
01300 {
01301 PyObject *none = Py_None;
01302 Py_INCREF(none);
01303 return none;
01304 }
01305
01306
01307
01308 typedef struct {
01309 PyObject *klass;
01310 PyObject *newraw;
01311 PyObject *newargs;
01312 PyObject *destroy;
01313 int delargs;
01314 int implicitconv;
01315 } SwigPyClientData;
01316
01317 SWIGRUNTIMEINLINE int
01318 SWIG_Python_CheckImplicit(swig_type_info *ty)
01319 {
01320 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
01321 return data ? data->implicitconv : 0;
01322 }
01323
01324 SWIGRUNTIMEINLINE PyObject *
01325 SWIG_Python_ExceptionType(swig_type_info *desc) {
01326 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
01327 PyObject *klass = data ? data->klass : 0;
01328 return (klass ? klass : PyExc_RuntimeError);
01329 }
01330
01331
01332 SWIGRUNTIME SwigPyClientData *
01333 SwigPyClientData_New(PyObject* obj)
01334 {
01335 if (!obj) {
01336 return 0;
01337 } else {
01338 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
01339
01340 data->klass = obj;
01341 Py_INCREF(data->klass);
01342
01343 if (PyClass_Check(obj)) {
01344 data->newraw = 0;
01345 data->newargs = obj;
01346 Py_INCREF(obj);
01347 } else {
01348 #if (PY_VERSION_HEX < 0x02020000)
01349 data->newraw = 0;
01350 #else
01351 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
01352 #endif
01353 if (data->newraw) {
01354 Py_INCREF(data->newraw);
01355 data->newargs = PyTuple_New(1);
01356 PyTuple_SetItem(data->newargs, 0, obj);
01357 } else {
01358 data->newargs = obj;
01359 }
01360 Py_INCREF(data->newargs);
01361 }
01362
01363 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
01364 if (PyErr_Occurred()) {
01365 PyErr_Clear();
01366 data->destroy = 0;
01367 }
01368 if (data->destroy) {
01369 int flags;
01370 Py_INCREF(data->destroy);
01371 flags = PyCFunction_GET_FLAGS(data->destroy);
01372 #ifdef METH_O
01373 data->delargs = !(flags & (METH_O));
01374 #else
01375 data->delargs = 0;
01376 #endif
01377 } else {
01378 data->delargs = 0;
01379 }
01380 data->implicitconv = 0;
01381 return data;
01382 }
01383 }
01384
01385 SWIGRUNTIME void
01386 SwigPyClientData_Del(SwigPyClientData* data)
01387 {
01388 Py_XDECREF(data->newraw);
01389 Py_XDECREF(data->newargs);
01390 Py_XDECREF(data->destroy);
01391 }
01392
01393
01394
01395 typedef struct {
01396 PyObject_HEAD
01397 void *ptr;
01398 swig_type_info *ty;
01399 int own;
01400 PyObject *next;
01401 } SwigPyObject;
01402
01403 SWIGRUNTIME PyObject *
01404 SwigPyObject_long(SwigPyObject *v)
01405 {
01406 return PyLong_FromVoidPtr(v->ptr);
01407 }
01408
01409 SWIGRUNTIME PyObject *
01410 SwigPyObject_format(const char* fmt, SwigPyObject *v)
01411 {
01412 PyObject *res = NULL;
01413 PyObject *args = PyTuple_New(1);
01414 if (args) {
01415 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
01416 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
01417 if (ofmt) {
01418 #if PY_VERSION_HEX >= 0x03000000
01419 res = PyUnicode_Format(ofmt,args);
01420 #else
01421 res = PyString_Format(ofmt,args);
01422 #endif
01423 Py_DECREF(ofmt);
01424 }
01425 Py_DECREF(args);
01426 }
01427 }
01428 return res;
01429 }
01430
01431 SWIGRUNTIME PyObject *
01432 SwigPyObject_oct(SwigPyObject *v)
01433 {
01434 return SwigPyObject_format("%o",v);
01435 }
01436
01437 SWIGRUNTIME PyObject *
01438 SwigPyObject_hex(SwigPyObject *v)
01439 {
01440 return SwigPyObject_format("%x",v);
01441 }
01442
01443 SWIGRUNTIME PyObject *
01444 #ifdef METH_NOARGS
01445 SwigPyObject_repr(SwigPyObject *v)
01446 #else
01447 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
01448 #endif
01449 {
01450 const char *name = SWIG_TypePrettyName(v->ty);
01451 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
01452 if (v->next) {
01453 #ifdef METH_NOARGS
01454 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
01455 #else
01456 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
01457 #endif
01458 #if PY_VERSION_HEX >= 0x03000000
01459 PyObject *joined = PyUnicode_Concat(repr, nrep);
01460 Py_DecRef(repr);
01461 Py_DecRef(nrep);
01462 repr = joined;
01463 #else
01464 PyString_ConcatAndDel(&repr,nrep);
01465 #endif
01466 }
01467 return repr;
01468 }
01469
01470 SWIGRUNTIME int
01471 SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01472 {
01473 char *str;
01474 #ifdef METH_NOARGS
01475 PyObject *repr = SwigPyObject_repr(v);
01476 #else
01477 PyObject *repr = SwigPyObject_repr(v, NULL);
01478 #endif
01479 if (repr) {
01480 str = SWIG_Python_str_AsChar(repr);
01481 fputs(str, fp);
01482 SWIG_Python_str_DelForPy3(str);
01483 Py_DECREF(repr);
01484 return 0;
01485 } else {
01486 return 1;
01487 }
01488 }
01489
01490 SWIGRUNTIME PyObject *
01491 SwigPyObject_str(SwigPyObject *v)
01492 {
01493 char result[SWIG_BUFFER_SIZE];
01494 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
01495 SWIG_Python_str_FromChar(result) : 0;
01496 }
01497
01498 SWIGRUNTIME int
01499 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
01500 {
01501 void *i = v->ptr;
01502 void *j = w->ptr;
01503 return (i < j) ? -1 : ((i > j) ? 1 : 0);
01504 }
01505
01506
01507 SWIGRUNTIME PyObject*
01508 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
01509 {
01510 PyObject* res;
01511 if( op != Py_EQ && op != Py_NE ) {
01512 Py_INCREF(Py_NotImplemented);
01513 return Py_NotImplemented;
01514 }
01515 if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
01516 res = Py_True;
01517 else
01518 res = Py_False;
01519 Py_INCREF(res);
01520 return res;
01521 }
01522
01523
01524 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
01525
01526 SWIGRUNTIME PyTypeObject*
01527 SwigPyObject_type(void) {
01528 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
01529 return type;
01530 }
01531
01532 SWIGRUNTIMEINLINE int
01533 SwigPyObject_Check(PyObject *op) {
01534 return (Py_TYPE(op) == SwigPyObject_type())
01535 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
01536 }
01537
01538 SWIGRUNTIME PyObject *
01539 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
01540
01541 SWIGRUNTIME void
01542 SwigPyObject_dealloc(PyObject *v)
01543 {
01544 SwigPyObject *sobj = (SwigPyObject *) v;
01545 PyObject *next = sobj->next;
01546 if (sobj->own == SWIG_POINTER_OWN) {
01547 swig_type_info *ty = sobj->ty;
01548 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
01549 PyObject *destroy = data ? data->destroy : 0;
01550 if (destroy) {
01551
01552 PyObject *res;
01553 if (data->delargs) {
01554
01555 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
01556 res = SWIG_Python_CallFunctor(destroy, tmp);
01557 Py_DECREF(tmp);
01558 } else {
01559 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
01560 PyObject *mself = PyCFunction_GET_SELF(destroy);
01561 res = ((*meth)(mself, v));
01562 }
01563 Py_XDECREF(res);
01564 }
01565 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
01566 else {
01567 const char *name = SWIG_TypePrettyName(ty);
01568 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
01569 }
01570 #endif
01571 }
01572 Py_XDECREF(next);
01573 PyObject_DEL(v);
01574 }
01575
01576 SWIGRUNTIME PyObject*
01577 SwigPyObject_append(PyObject* v, PyObject* next)
01578 {
01579 SwigPyObject *sobj = (SwigPyObject *) v;
01580 #ifndef METH_O
01581 PyObject *tmp = 0;
01582 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
01583 next = tmp;
01584 #endif
01585 if (!SwigPyObject_Check(next)) {
01586 return NULL;
01587 }
01588 sobj->next = next;
01589 Py_INCREF(next);
01590 return SWIG_Py_Void();
01591 }
01592
01593 SWIGRUNTIME PyObject*
01594 #ifdef METH_NOARGS
01595 SwigPyObject_next(PyObject* v)
01596 #else
01597 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01598 #endif
01599 {
01600 SwigPyObject *sobj = (SwigPyObject *) v;
01601 if (sobj->next) {
01602 Py_INCREF(sobj->next);
01603 return sobj->next;
01604 } else {
01605 return SWIG_Py_Void();
01606 }
01607 }
01608
01609 SWIGINTERN PyObject*
01610 #ifdef METH_NOARGS
01611 SwigPyObject_disown(PyObject *v)
01612 #else
01613 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01614 #endif
01615 {
01616 SwigPyObject *sobj = (SwigPyObject *)v;
01617 sobj->own = 0;
01618 return SWIG_Py_Void();
01619 }
01620
01621 SWIGINTERN PyObject*
01622 #ifdef METH_NOARGS
01623 SwigPyObject_acquire(PyObject *v)
01624 #else
01625 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01626 #endif
01627 {
01628 SwigPyObject *sobj = (SwigPyObject *)v;
01629 sobj->own = SWIG_POINTER_OWN;
01630 return SWIG_Py_Void();
01631 }
01632
01633 SWIGINTERN PyObject*
01634 SwigPyObject_own(PyObject *v, PyObject *args)
01635 {
01636 PyObject *val = 0;
01637 #if (PY_VERSION_HEX < 0x02020000)
01638 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
01639 #else
01640 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
01641 #endif
01642 {
01643 return NULL;
01644 }
01645 else
01646 {
01647 SwigPyObject *sobj = (SwigPyObject *)v;
01648 PyObject *obj = PyBool_FromLong(sobj->own);
01649 if (val) {
01650 #ifdef METH_NOARGS
01651 if (PyObject_IsTrue(val)) {
01652 SwigPyObject_acquire(v);
01653 } else {
01654 SwigPyObject_disown(v);
01655 }
01656 #else
01657 if (PyObject_IsTrue(val)) {
01658 SwigPyObject_acquire(v,args);
01659 } else {
01660 SwigPyObject_disown(v,args);
01661 }
01662 #endif
01663 }
01664 return obj;
01665 }
01666 }
01667
01668 #ifdef METH_O
01669 static PyMethodDef
01670 swigobject_methods[] = {
01671 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
01672 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
01673 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01674 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
01675 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
01676 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
01677 {0, 0, 0, 0}
01678 };
01679 #else
01680 static PyMethodDef
01681 swigobject_methods[] = {
01682 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
01683 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
01684 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01685 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
01686 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
01687 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
01688 {0, 0, 0, 0}
01689 };
01690 #endif
01691
01692 #if PY_VERSION_HEX < 0x02020000
01693 SWIGINTERN PyObject *
01694 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
01695 {
01696 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
01697 }
01698 #endif
01699
01700 SWIGRUNTIME PyTypeObject*
01701 _PySwigObject_type(void) {
01702 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
01703
01704 static PyNumberMethods SwigPyObject_as_number = {
01705 (binaryfunc)0,
01706 (binaryfunc)0,
01707 (binaryfunc)0,
01708
01709 #if PY_VERSION_HEX < 0x03000000
01710 (binaryfunc)0,
01711 #endif
01712 (binaryfunc)0,
01713 (binaryfunc)0,
01714 (ternaryfunc)0,
01715 (unaryfunc)0,
01716 (unaryfunc)0,
01717 (unaryfunc)0,
01718 (inquiry)0,
01719 0,
01720 0,
01721 0,
01722 0,
01723 0,
01724 0,
01725 #if PY_VERSION_HEX < 0x03000000
01726 0,
01727 #endif
01728 (unaryfunc)SwigPyObject_long,
01729 #if PY_VERSION_HEX < 0x03000000
01730 (unaryfunc)SwigPyObject_long,
01731 #else
01732 0,
01733 #endif
01734 (unaryfunc)0,
01735 #if PY_VERSION_HEX < 0x03000000
01736 (unaryfunc)SwigPyObject_oct,
01737 (unaryfunc)SwigPyObject_hex,
01738 #endif
01739 #if PY_VERSION_HEX >= 0x03000000
01740 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
01741 #elif PY_VERSION_HEX >= 0x02050000
01742 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
01743 #elif PY_VERSION_HEX >= 0x02020000
01744 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
01745 #elif PY_VERSION_HEX >= 0x02000000
01746 0,0,0,0,0,0,0,0,0,0,0
01747 #endif
01748 };
01749
01750 static PyTypeObject swigpyobject_type;
01751 static int type_init = 0;
01752 if (!type_init) {
01753 const PyTypeObject tmp
01754 = {
01755
01756 #if PY_VERSION_HEX >= 0x03000000
01757 PyVarObject_HEAD_INIT(&PyType_Type, 0)
01758 #else
01759 PyObject_HEAD_INIT(NULL)
01760 0,
01761 #endif
01762 (char *)"SwigPyObject",
01763 sizeof(SwigPyObject),
01764 0,
01765 (destructor)SwigPyObject_dealloc,
01766 (printfunc)SwigPyObject_print,
01767 #if PY_VERSION_HEX < 0x02020000
01768 (getattrfunc)SwigPyObject_getattr,
01769 #else
01770 (getattrfunc)0,
01771 #endif
01772 (setattrfunc)0,
01773 #if PY_VERSION_HEX >= 0x03000000
01774 0,
01775 #else
01776 (cmpfunc)SwigPyObject_compare,
01777 #endif
01778 (reprfunc)SwigPyObject_repr,
01779 &SwigPyObject_as_number,
01780 0,
01781 0,
01782 (hashfunc)0,
01783 (ternaryfunc)0,
01784 (reprfunc)SwigPyObject_str,
01785 PyObject_GenericGetAttr,
01786 0,
01787 0,
01788 Py_TPFLAGS_DEFAULT,
01789 swigobject_doc,
01790 0,
01791 0,
01792 (richcmpfunc)SwigPyObject_richcompare,
01793 0,
01794 #if PY_VERSION_HEX >= 0x02020000
01795 0,
01796 0,
01797 swigobject_methods,
01798 0,
01799 0,
01800 0,
01801 0,
01802 0,
01803 0,
01804 0,
01805 0,
01806 0,
01807 0,
01808 0,
01809 0,
01810 0,
01811 0,
01812 0,
01813 0,
01814 0,
01815 #endif
01816 #if PY_VERSION_HEX >= 0x02030000
01817 0,
01818 #endif
01819 #ifdef COUNT_ALLOCS
01820 0,0,0,0
01821 #endif
01822 };
01823 swigpyobject_type = tmp;
01824
01825 #if PY_VERSION_HEX < 0x03000000
01826 swigpyobject_type.ob_type = &PyType_Type;
01827 #endif
01828 type_init = 1;
01829 }
01830 return &swigpyobject_type;
01831 }
01832
01833 SWIGRUNTIME PyObject *
01834 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
01835 {
01836 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
01837 if (sobj) {
01838 sobj->ptr = ptr;
01839 sobj->ty = ty;
01840 sobj->own = own;
01841 sobj->next = 0;
01842 }
01843 return (PyObject *)sobj;
01844 }
01845
01846
01847
01848
01849
01850 typedef struct {
01851 PyObject_HEAD
01852 void *pack;
01853 swig_type_info *ty;
01854 size_t size;
01855 } SwigPyPacked;
01856
01857 SWIGRUNTIME int
01858 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01859 {
01860 char result[SWIG_BUFFER_SIZE];
01861 fputs("<Swig Packed ", fp);
01862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01863 fputs("at ", fp);
01864 fputs(result, fp);
01865 }
01866 fputs(v->ty->name,fp);
01867 fputs(">", fp);
01868 return 0;
01869 }
01870
01871 SWIGRUNTIME PyObject *
01872 SwigPyPacked_repr(SwigPyPacked *v)
01873 {
01874 char result[SWIG_BUFFER_SIZE];
01875 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01876 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
01877 } else {
01878 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
01879 }
01880 }
01881
01882 SWIGRUNTIME PyObject *
01883 SwigPyPacked_str(SwigPyPacked *v)
01884 {
01885 char result[SWIG_BUFFER_SIZE];
01886 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
01887 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
01888 } else {
01889 return SWIG_Python_str_FromChar(v->ty->name);
01890 }
01891 }
01892
01893 SWIGRUNTIME int
01894 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
01895 {
01896 size_t i = v->size;
01897 size_t j = w->size;
01898 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
01899 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
01900 }
01901
01902 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
01903
01904 SWIGRUNTIME PyTypeObject*
01905 SwigPyPacked_type(void) {
01906 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
01907 return type;
01908 }
01909
01910 SWIGRUNTIMEINLINE int
01911 SwigPyPacked_Check(PyObject *op) {
01912 return ((op)->ob_type == _PySwigPacked_type())
01913 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
01914 }
01915
01916 SWIGRUNTIME void
01917 SwigPyPacked_dealloc(PyObject *v)
01918 {
01919 if (SwigPyPacked_Check(v)) {
01920 SwigPyPacked *sobj = (SwigPyPacked *) v;
01921 free(sobj->pack);
01922 }
01923 PyObject_DEL(v);
01924 }
01925
01926 SWIGRUNTIME PyTypeObject*
01927 _PySwigPacked_type(void) {
01928 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
01929 static PyTypeObject swigpypacked_type;
01930 static int type_init = 0;
01931 if (!type_init) {
01932 const PyTypeObject tmp
01933 = {
01934
01935 #if PY_VERSION_HEX>=0x03000000
01936 PyVarObject_HEAD_INIT(&PyType_Type, 0)
01937 #else
01938 PyObject_HEAD_INIT(NULL)
01939 0,
01940 #endif
01941 (char *)"SwigPyPacked",
01942 sizeof(SwigPyPacked),
01943 0,
01944 (destructor)SwigPyPacked_dealloc,
01945 (printfunc)SwigPyPacked_print,
01946 (getattrfunc)0,
01947 (setattrfunc)0,
01948 #if PY_VERSION_HEX>=0x03000000
01949 0,
01950 #else
01951 (cmpfunc)SwigPyPacked_compare,
01952 #endif
01953 (reprfunc)SwigPyPacked_repr,
01954 0,
01955 0,
01956 0,
01957 (hashfunc)0,
01958 (ternaryfunc)0,
01959 (reprfunc)SwigPyPacked_str,
01960 PyObject_GenericGetAttr,
01961 0,
01962 0,
01963 Py_TPFLAGS_DEFAULT,
01964 swigpacked_doc,
01965 0,
01966 0,
01967 0,
01968 0,
01969 #if PY_VERSION_HEX >= 0x02020000
01970 0,
01971 0,
01972 0,
01973 0,
01974 0,
01975 0,
01976 0,
01977 0,
01978 0,
01979 0,
01980 0,
01981 0,
01982 0,
01983 0,
01984 0,
01985 0,
01986 0,
01987 0,
01988 0,
01989 0,
01990 #endif
01991 #if PY_VERSION_HEX >= 0x02030000
01992 0,
01993 #endif
01994 #ifdef COUNT_ALLOCS
01995 0,0,0,0
01996 #endif
01997 };
01998 swigpypacked_type = tmp;
01999
02000 #if PY_VERSION_HEX < 0x03000000
02001 swigpypacked_type.ob_type = &PyType_Type;
02002 #endif
02003 type_init = 1;
02004 }
02005 return &swigpypacked_type;
02006 }
02007
02008 SWIGRUNTIME PyObject *
02009 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
02010 {
02011 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
02012 if (sobj) {
02013 void *pack = malloc(size);
02014 if (pack) {
02015 memcpy(pack, ptr, size);
02016 sobj->pack = pack;
02017 sobj->ty = ty;
02018 sobj->size = size;
02019 } else {
02020 PyObject_DEL((PyObject *) sobj);
02021 sobj = 0;
02022 }
02023 }
02024 return (PyObject *) sobj;
02025 }
02026
02027 SWIGRUNTIME swig_type_info *
02028 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
02029 {
02030 if (SwigPyPacked_Check(obj)) {
02031 SwigPyPacked *sobj = (SwigPyPacked *)obj;
02032 if (sobj->size != size) return 0;
02033 memcpy(ptr, sobj->pack, size);
02034 return sobj->ty;
02035 } else {
02036 return 0;
02037 }
02038 }
02039
02040
02041
02042
02043
02044 SWIGRUNTIMEINLINE PyObject *
02045 _SWIG_This(void)
02046 {
02047 return SWIG_Python_str_FromChar("this");
02048 }
02049
02050 SWIGRUNTIME PyObject *
02051 SWIG_This(void)
02052 {
02053 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
02054 return swig_this;
02055 }
02056
02057
02058
02059
02060 #if PY_VERSION_HEX>=0x03000000
02061 #define SWIG_PYTHON_SLOW_GETSET_THIS
02062 #endif
02063
02064 SWIGRUNTIME SwigPyObject *
02065 SWIG_Python_GetSwigThis(PyObject *pyobj)
02066 {
02067 if (SwigPyObject_Check(pyobj)) {
02068 return (SwigPyObject *) pyobj;
02069 } else {
02070 PyObject *obj = 0;
02071 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
02072 if (PyInstance_Check(pyobj)) {
02073 obj = _PyInstance_Lookup(pyobj, SWIG_This());
02074 } else {
02075 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
02076 if (dictptr != NULL) {
02077 PyObject *dict = *dictptr;
02078 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
02079 } else {
02080 #ifdef PyWeakref_CheckProxy
02081 if (PyWeakref_CheckProxy(pyobj)) {
02082 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
02083 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
02084 }
02085 #endif
02086 obj = PyObject_GetAttr(pyobj,SWIG_This());
02087 if (obj) {
02088 Py_DECREF(obj);
02089 } else {
02090 if (PyErr_Occurred()) PyErr_Clear();
02091 return 0;
02092 }
02093 }
02094 }
02095 #else
02096 obj = PyObject_GetAttr(pyobj,SWIG_This());
02097 if (obj) {
02098 Py_DECREF(obj);
02099 } else {
02100 if (PyErr_Occurred()) PyErr_Clear();
02101 return 0;
02102 }
02103 #endif
02104 if (obj && !SwigPyObject_Check(obj)) {
02105
02106
02107 return SWIG_Python_GetSwigThis(obj);
02108 }
02109 return (SwigPyObject *)obj;
02110 }
02111 }
02112
02113
02114
02115 SWIGRUNTIME int
02116 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
02117 if (own == SWIG_POINTER_OWN) {
02118 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02119 if (sobj) {
02120 int oldown = sobj->own;
02121 sobj->own = own;
02122 return oldown;
02123 }
02124 }
02125 return 0;
02126 }
02127
02128
02129
02130 SWIGRUNTIME int
02131 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
02132 if (!obj) return SWIG_ERROR;
02133 if (obj == Py_None) {
02134 if (ptr) *ptr = 0;
02135 return SWIG_OK;
02136 } else {
02137 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02138 if (own)
02139 *own = 0;
02140 while (sobj) {
02141 void *vptr = sobj->ptr;
02142 if (ty) {
02143 swig_type_info *to = sobj->ty;
02144 if (to == ty) {
02145
02146 if (ptr) *ptr = vptr;
02147 break;
02148 } else {
02149 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02150 if (!tc) {
02151 sobj = (SwigPyObject *)sobj->next;
02152 } else {
02153 if (ptr) {
02154 int newmemory = 0;
02155 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02156 if (newmemory == SWIG_CAST_NEW_MEMORY) {
02157 assert(own);
02158 if (own)
02159 *own = *own | SWIG_CAST_NEW_MEMORY;
02160 }
02161 }
02162 break;
02163 }
02164 }
02165 } else {
02166 if (ptr) *ptr = vptr;
02167 break;
02168 }
02169 }
02170 if (sobj) {
02171 if (own)
02172 *own = *own | sobj->own;
02173 if (flags & SWIG_POINTER_DISOWN) {
02174 sobj->own = 0;
02175 }
02176 return SWIG_OK;
02177 } else {
02178 int res = SWIG_ERROR;
02179 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
02180 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
02181 if (data && !data->implicitconv) {
02182 PyObject *klass = data->klass;
02183 if (klass) {
02184 PyObject *impconv;
02185 data->implicitconv = 1;
02186 impconv = SWIG_Python_CallFunctor(klass, obj);
02187 data->implicitconv = 0;
02188 if (PyErr_Occurred()) {
02189 PyErr_Clear();
02190 impconv = 0;
02191 }
02192 if (impconv) {
02193 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
02194 if (iobj) {
02195 void *vptr;
02196 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
02197 if (SWIG_IsOK(res)) {
02198 if (ptr) {
02199 *ptr = vptr;
02200
02201 iobj->own = 0;
02202 res = SWIG_AddCast(res);
02203 res = SWIG_AddNewMask(res);
02204 } else {
02205 res = SWIG_AddCast(res);
02206 }
02207 }
02208 }
02209 Py_DECREF(impconv);
02210 }
02211 }
02212 }
02213 }
02214 return res;
02215 }
02216 }
02217 }
02218
02219
02220
02221 SWIGRUNTIME int
02222 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
02223 if (!PyCFunction_Check(obj)) {
02224 return SWIG_ConvertPtr(obj, ptr, ty, 0);
02225 } else {
02226 void *vptr = 0;
02227
02228
02229 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
02230 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
02231 if (desc)
02232 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
02233 if (!desc)
02234 return SWIG_ERROR;
02235 if (ty) {
02236 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
02237 if (tc) {
02238 int newmemory = 0;
02239 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02240 assert(!newmemory);
02241 } else {
02242 return SWIG_ERROR;
02243 }
02244 } else {
02245 *ptr = vptr;
02246 }
02247 return SWIG_OK;
02248 }
02249 }
02250
02251
02252
02253 SWIGRUNTIME int
02254 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
02255 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
02256 if (!to) return SWIG_ERROR;
02257 if (ty) {
02258 if (to != ty) {
02259
02260 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02261 if (!tc) return SWIG_ERROR;
02262 }
02263 }
02264 return SWIG_OK;
02265 }
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276 SWIGRUNTIME PyObject*
02277 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
02278 {
02279 #if (PY_VERSION_HEX >= 0x02020000)
02280 PyObject *inst = 0;
02281 PyObject *newraw = data->newraw;
02282 if (newraw) {
02283 inst = PyObject_Call(newraw, data->newargs, NULL);
02284 if (inst) {
02285 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02286 PyObject **dictptr = _PyObject_GetDictPtr(inst);
02287 if (dictptr != NULL) {
02288 PyObject *dict = *dictptr;
02289 if (dict == NULL) {
02290 dict = PyDict_New();
02291 *dictptr = dict;
02292 PyDict_SetItem(dict, SWIG_This(), swig_this);
02293 }
02294 }
02295 #else
02296 PyObject *key = SWIG_This();
02297 PyObject_SetAttr(inst, key, swig_this);
02298 #endif
02299 }
02300 } else {
02301 #if PY_VERSION_HEX >= 0x03000000
02302 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
02303 PyObject_SetAttr(inst, SWIG_This(), swig_this);
02304 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
02305 #else
02306 PyObject *dict = PyDict_New();
02307 PyDict_SetItem(dict, SWIG_This(), swig_this);
02308 inst = PyInstance_NewRaw(data->newargs, dict);
02309 Py_DECREF(dict);
02310 #endif
02311 }
02312 return inst;
02313 #else
02314 #if (PY_VERSION_HEX >= 0x02010000)
02315 PyObject *inst;
02316 PyObject *dict = PyDict_New();
02317 PyDict_SetItem(dict, SWIG_This(), swig_this);
02318 inst = PyInstance_NewRaw(data->newargs, dict);
02319 Py_DECREF(dict);
02320 return (PyObject *) inst;
02321 #else
02322 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
02323 if (inst == NULL) {
02324 return NULL;
02325 }
02326 inst->in_class = (PyClassObject *)data->newargs;
02327 Py_INCREF(inst->in_class);
02328 inst->in_dict = PyDict_New();
02329 if (inst->in_dict == NULL) {
02330 Py_DECREF(inst);
02331 return NULL;
02332 }
02333 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
02334 inst->in_weakreflist = NULL;
02335 #endif
02336 #ifdef Py_TPFLAGS_GC
02337 PyObject_GC_Init(inst);
02338 #endif
02339 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
02340 return (PyObject *) inst;
02341 #endif
02342 #endif
02343 }
02344
02345 SWIGRUNTIME void
02346 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
02347 {
02348 PyObject *dict;
02349 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02350 PyObject **dictptr = _PyObject_GetDictPtr(inst);
02351 if (dictptr != NULL) {
02352 dict = *dictptr;
02353 if (dict == NULL) {
02354 dict = PyDict_New();
02355 *dictptr = dict;
02356 }
02357 PyDict_SetItem(dict, SWIG_This(), swig_this);
02358 return;
02359 }
02360 #endif
02361 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
02362 PyDict_SetItem(dict, SWIG_This(), swig_this);
02363 Py_DECREF(dict);
02364 }
02365
02366
02367 SWIGINTERN PyObject *
02368 SWIG_Python_InitShadowInstance(PyObject *args) {
02369 PyObject *obj[2];
02370 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
02371 return NULL;
02372 } else {
02373 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
02374 if (sthis) {
02375 SwigPyObject_append((PyObject*) sthis, obj[1]);
02376 } else {
02377 SWIG_Python_SetSwigThis(obj[0], obj[1]);
02378 }
02379 return SWIG_Py_Void();
02380 }
02381 }
02382
02383
02384
02385 SWIGRUNTIME PyObject *
02386 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
02387 if (!ptr) {
02388 return SWIG_Py_Void();
02389 } else {
02390 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
02391 PyObject *robj = SwigPyObject_New(ptr, type, own);
02392 SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
02393 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
02394 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
02395 if (inst) {
02396 Py_DECREF(robj);
02397 robj = inst;
02398 }
02399 }
02400 return robj;
02401 }
02402 }
02403
02404
02405
02406 SWIGRUNTIMEINLINE PyObject *
02407 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
02408 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
02409 }
02410
02411
02412
02413
02414
02415 #ifdef SWIG_LINK_RUNTIME
02416 void *SWIG_ReturnGlobalTypeList(void *);
02417 #endif
02418
02419 SWIGRUNTIME swig_module_info *
02420 SWIG_Python_GetModule(void) {
02421 static void *type_pointer = (void *)0;
02422
02423 if (!type_pointer) {
02424 #ifdef SWIG_LINK_RUNTIME
02425 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
02426 #else
02427 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02428 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
02429 if (PyErr_Occurred()) {
02430 PyErr_Clear();
02431 type_pointer = (void *)0;
02432 }
02433 #endif
02434 }
02435 return (swig_module_info *) type_pointer;
02436 }
02437
02438 #if PY_MAJOR_VERSION < 2
02439
02440
02441 SWIGINTERN int
02442 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
02443 {
02444 PyObject *dict;
02445 if (!PyModule_Check(m)) {
02446 PyErr_SetString(PyExc_TypeError,
02447 "PyModule_AddObject() needs module as first arg");
02448 return SWIG_ERROR;
02449 }
02450 if (!o) {
02451 PyErr_SetString(PyExc_TypeError,
02452 "PyModule_AddObject() needs non-NULL value");
02453 return SWIG_ERROR;
02454 }
02455
02456 dict = PyModule_GetDict(m);
02457 if (dict == NULL) {
02458
02459 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
02460 PyModule_GetName(m));
02461 return SWIG_ERROR;
02462 }
02463 if (PyDict_SetItemString(dict, name, o))
02464 return SWIG_ERROR;
02465 Py_DECREF(o);
02466 return SWIG_OK;
02467 }
02468 #endif
02469
02470 SWIGRUNTIME void
02471 SWIG_Python_DestroyModule(void *vptr)
02472 {
02473 swig_module_info *swig_module = (swig_module_info *) vptr;
02474 swig_type_info **types = swig_module->types;
02475 size_t i;
02476 for (i =0; i < swig_module->size; ++i) {
02477 swig_type_info *ty = types[i];
02478 if (ty->owndata) {
02479 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
02480 if (data) SwigPyClientData_Del(data);
02481 }
02482 }
02483 Py_DECREF(SWIG_This());
02484 }
02485
02486 SWIGRUNTIME void
02487 SWIG_Python_SetModule(swig_module_info *swig_module) {
02488 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };
02489
02490 #if PY_VERSION_HEX >= 0x03000000
02491
02492 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
02493 #else
02494 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02495 swig_empty_runtime_method_table);
02496 #endif
02497 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
02498 if (pointer && module) {
02499 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
02500 } else {
02501 Py_XDECREF(pointer);
02502 }
02503 }
02504
02505
02506 SWIGRUNTIME PyObject *
02507 SWIG_Python_TypeCache(void) {
02508 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
02509 return cache;
02510 }
02511
02512 SWIGRUNTIME swig_type_info *
02513 SWIG_Python_TypeQuery(const char *type)
02514 {
02515 PyObject *cache = SWIG_Python_TypeCache();
02516 PyObject *key = SWIG_Python_str_FromChar(type);
02517 PyObject *obj = PyDict_GetItem(cache, key);
02518 swig_type_info *descriptor;
02519 if (obj) {
02520 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
02521 } else {
02522 swig_module_info *swig_module = SWIG_Python_GetModule();
02523 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
02524 if (descriptor) {
02525 obj = PyCObject_FromVoidPtr(descriptor, NULL);
02526 PyDict_SetItem(cache, key, obj);
02527 Py_DECREF(obj);
02528 }
02529 }
02530 Py_DECREF(key);
02531 return descriptor;
02532 }
02533
02534
02535
02536
02537 #define SWIG_POINTER_EXCEPTION 0
02538 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
02539 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
02540
02541 SWIGRUNTIME int
02542 SWIG_Python_AddErrMesg(const char* mesg, int infront)
02543 {
02544 if (PyErr_Occurred()) {
02545 PyObject *type = 0;
02546 PyObject *value = 0;
02547 PyObject *traceback = 0;
02548 PyErr_Fetch(&type, &value, &traceback);
02549 if (value) {
02550 char *tmp;
02551 PyObject *old_str = PyObject_Str(value);
02552 Py_XINCREF(type);
02553 PyErr_Clear();
02554 if (infront) {
02555 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
02556 } else {
02557 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
02558 }
02559 SWIG_Python_str_DelForPy3(tmp);
02560 Py_DECREF(old_str);
02561 }
02562 return 1;
02563 } else {
02564 return 0;
02565 }
02566 }
02567
02568 SWIGRUNTIME int
02569 SWIG_Python_ArgFail(int argnum)
02570 {
02571 if (PyErr_Occurred()) {
02572
02573 char mesg[256];
02574 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
02575 return SWIG_Python_AddErrMesg(mesg, 1);
02576 } else {
02577 return 0;
02578 }
02579 }
02580
02581 SWIGRUNTIMEINLINE const char *
02582 SwigPyObject_GetDesc(PyObject *self)
02583 {
02584 SwigPyObject *v = (SwigPyObject *)self;
02585 swig_type_info *ty = v ? v->ty : 0;
02586 return ty ? ty->str : (char*)"";
02587 }
02588
02589 SWIGRUNTIME void
02590 SWIG_Python_TypeError(const char *type, PyObject *obj)
02591 {
02592 if (type) {
02593 #if defined(SWIG_COBJECT_TYPES)
02594 if (obj && SwigPyObject_Check(obj)) {
02595 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
02596 if (otype) {
02597 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
02598 type, otype);
02599 return;
02600 }
02601 } else
02602 #endif
02603 {
02604 const char *otype = (obj ? obj->ob_type->tp_name : 0);
02605 if (otype) {
02606 PyObject *str = PyObject_Str(obj);
02607 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
02608 if (cstr) {
02609 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
02610 type, otype, cstr);
02611 SWIG_Python_str_DelForPy3(cstr);
02612 } else {
02613 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
02614 type, otype);
02615 }
02616 Py_XDECREF(str);
02617 return;
02618 }
02619 }
02620 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
02621 } else {
02622 PyErr_Format(PyExc_TypeError, "unexpected type is received");
02623 }
02624 }
02625
02626
02627
02628 SWIGRUNTIME void *
02629 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
02630 void *result;
02631 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
02632 PyErr_Clear();
02633 #if SWIG_POINTER_EXCEPTION
02634 if (flags) {
02635 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
02636 SWIG_Python_ArgFail(argnum);
02637 }
02638 #endif
02639 }
02640 return result;
02641 }
02642
02643
02644 #ifdef __cplusplus
02645 #if 0
02646 {
02647 #endif
02648 }
02649 #endif
02650
02651
02652
02653 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
02654
02655 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
02656
02657
02658
02659
02660
02661 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
02662 #define SWIGTYPE_p_PLcGrid swig_types[1]
02663 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
02664 #define SWIGTYPE_p_char swig_types[3]
02665 #define SWIGTYPE_p_double swig_types[4]
02666 #define SWIGTYPE_p_f_double_double__int swig_types[5]
02667 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
02668 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
02669 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
02670 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
02671 #define SWIGTYPE_p_int swig_types[10]
02672 #define SWIGTYPE_p_p_char swig_types[11]
02673 #define SWIGTYPE_p_p_double swig_types[12]
02674 #define SWIGTYPE_p_unsigned_int swig_types[13]
02675 static swig_type_info *swig_types[15];
02676 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
02677 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02678 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02679
02680
02681
02682 #if (PY_VERSION_HEX <= 0x02000000)
02683 # if !defined(SWIG_PYTHON_CLASSIC)
02684 # error "This python version requires swig to be run with the '-classic' option"
02685 # endif
02686 #endif
02687
02688
02689
02690
02691 #if PY_VERSION_HEX >= 0x03000000
02692 # define SWIG_init PyInit__plplotc
02693
02694 #else
02695 # define SWIG_init init_plplotc
02696
02697 #endif
02698 #define SWIG_name "_plplotc"
02699
02700 #define SWIGVERSION 0x010340
02701 #define SWIG_VERSION SWIGVERSION
02702
02703
02704 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
02705 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
02706
02707
02708
02709
02710
02711 #include <arrayobject.h>
02712 #include "plplot.h"
02713 #include "plplotP.h"
02714
02715 #ifdef PL_DOUBLE
02716 #define PyArray_PLFLT PyArray_DOUBLE
02717 #else
02718 #define PyArray_PLFLT PyArray_FLOAT
02719 #endif
02720
02721 #ifdef HAVE_NUMPY
02722 #define PyArray_PLINT PyArray_INT32
02723
02724 #ifdef PL_DOUBLE
02725 #define NPY_PLFLT NPY_DOUBLE
02726 #else
02727 #define NPY_PLFLT NPY_FLOAT
02728 #endif
02729
02730 #else // HAVE_NUMPY
02731 #define PyArray_PLINT PyArray_INT
02732 #endif
02733
02734 #if !defined ( PySequence_Fast_GET_ITEM )
02735 #define PySequence_Fast_GET_ITEM PySequence_GetItem
02736 #endif
02737 #define PySequence_Size PySequence_Length
02738
02739
02740 static PLINT Alen = 0;
02741 static PLINT Xlen = 0, Ylen = 0;
02742
02743
02744 SWIGINTERN int
02745 SWIG_AsVal_double (PyObject *obj, double *val)
02746 {
02747 int res = SWIG_TypeError;
02748 if (PyFloat_Check(obj)) {
02749 if (val) *val = PyFloat_AsDouble(obj);
02750 return SWIG_OK;
02751 } else if (PyInt_Check(obj)) {
02752 if (val) *val = PyInt_AsLong(obj);
02753 return SWIG_OK;
02754 } else if (PyLong_Check(obj)) {
02755 double v = PyLong_AsDouble(obj);
02756 if (!PyErr_Occurred()) {
02757 if (val) *val = v;
02758 return SWIG_OK;
02759 } else {
02760 PyErr_Clear();
02761 }
02762 }
02763 #ifdef SWIG_PYTHON_CAST_MODE
02764 {
02765 int dispatch = 0;
02766 double d = PyFloat_AsDouble(obj);
02767 if (!PyErr_Occurred()) {
02768 if (val) *val = d;
02769 return SWIG_AddCast(SWIG_OK);
02770 } else {
02771 PyErr_Clear();
02772 }
02773 if (!dispatch) {
02774 long v = PyLong_AsLong(obj);
02775 if (!PyErr_Occurred()) {
02776 if (val) *val = v;
02777 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
02778 } else {
02779 PyErr_Clear();
02780 }
02781 }
02782 }
02783 #endif
02784 return res;
02785 }
02786
02787
02788 #define SWIG_From_double PyFloat_FromDouble
02789
02790
02791 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
02792 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
02793 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
02794 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
02795 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
02796 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
02797 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
02798
02799
02800 #define SWIG_From_long PyInt_FromLong
02801
02802
02803 SWIGINTERNINLINE PyObject *
02804 SWIG_From_int (int value)
02805 {
02806 return SWIG_From_long (value);
02807 }
02808
02809
02810 #include <limits.h>
02811 #if !defined(SWIG_NO_LLONG_MAX)
02812 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
02813 # define LLONG_MAX __LONG_LONG_MAX__
02814 # define LLONG_MIN (-LLONG_MAX - 1LL)
02815 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
02816 # endif
02817 #endif
02818
02819
02820 #include <float.h>
02821
02822
02823 #include <math.h>
02824
02825
02826 SWIGINTERNINLINE int
02827 SWIG_CanCastAsInteger(double *d, double min, double max) {
02828 double x = *d;
02829 if ((min <= x && x <= max)) {
02830 double fx = floor(x);
02831 double cx = ceil(x);
02832 double rd = ((x - fx) < 0.5) ? fx : cx;
02833 if ((errno == EDOM) || (errno == ERANGE)) {
02834 errno = 0;
02835 } else {
02836 double summ, reps, diff;
02837 if (rd < x) {
02838 diff = x - rd;
02839 } else if (rd > x) {
02840 diff = rd - x;
02841 } else {
02842 return 1;
02843 }
02844 summ = rd + x;
02845 reps = diff/summ;
02846 if (reps < 8*DBL_EPSILON) {
02847 *d = rd;
02848 return 1;
02849 }
02850 }
02851 }
02852 return 0;
02853 }
02854
02855
02856 SWIGINTERN int
02857 SWIG_AsVal_long (PyObject *obj, long* val)
02858 {
02859 if (PyInt_Check(obj)) {
02860 if (val) *val = PyInt_AsLong(obj);
02861 return SWIG_OK;
02862 } else if (PyLong_Check(obj)) {
02863 long v = PyLong_AsLong(obj);
02864 if (!PyErr_Occurred()) {
02865 if (val) *val = v;
02866 return SWIG_OK;
02867 } else {
02868 PyErr_Clear();
02869 }
02870 }
02871 #ifdef SWIG_PYTHON_CAST_MODE
02872 {
02873 int dispatch = 0;
02874 long v = PyInt_AsLong(obj);
02875 if (!PyErr_Occurred()) {
02876 if (val) *val = v;
02877 return SWIG_AddCast(SWIG_OK);
02878 } else {
02879 PyErr_Clear();
02880 }
02881 if (!dispatch) {
02882 double d;
02883 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
02884 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
02885 if (val) *val = (long)(d);
02886 return res;
02887 }
02888 }
02889 }
02890 #endif
02891 return SWIG_TypeError;
02892 }
02893
02894
02895 SWIGINTERN int
02896 SWIG_AsVal_int (PyObject * obj, int *val)
02897 {
02898 long v;
02899 int res = SWIG_AsVal_long (obj, &v);
02900 if (SWIG_IsOK(res)) {
02901 if ((v < INT_MIN || v > INT_MAX)) {
02902 return SWIG_OverflowError;
02903 } else {
02904 if (val) *val = (int)(v);
02905 }
02906 }
02907 return res;
02908 }
02909
02910
02911 SWIGINTERN int
02912 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
02913 {
02914 if (PyInt_Check(obj)) {
02915 long v = PyInt_AsLong(obj);
02916 if (v >= 0) {
02917 if (val) *val = v;
02918 return SWIG_OK;
02919 } else {
02920 return SWIG_OverflowError;
02921 }
02922 } else if (PyLong_Check(obj)) {
02923 unsigned long v = PyLong_AsUnsignedLong(obj);
02924 if (!PyErr_Occurred()) {
02925 if (val) *val = v;
02926 return SWIG_OK;
02927 } else {
02928 PyErr_Clear();
02929 }
02930 }
02931 #ifdef SWIG_PYTHON_CAST_MODE
02932 {
02933 int dispatch = 0;
02934 unsigned long v = PyLong_AsUnsignedLong(obj);
02935 if (!PyErr_Occurred()) {
02936 if (val) *val = v;
02937 return SWIG_AddCast(SWIG_OK);
02938 } else {
02939 PyErr_Clear();
02940 }
02941 if (!dispatch) {
02942 double d;
02943 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
02944 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
02945 if (val) *val = (unsigned long)(d);
02946 return res;
02947 }
02948 }
02949 }
02950 #endif
02951 return SWIG_TypeError;
02952 }
02953
02954
02955 SWIGINTERN int
02956 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
02957 {
02958 unsigned long v;
02959 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
02960 if (SWIG_IsOK(res)) {
02961 if ((v > UINT_MAX)) {
02962 return SWIG_OverflowError;
02963 } else {
02964 if (val) *val = (unsigned int)(v);
02965 }
02966 }
02967 return res;
02968 }
02969
02970
02971 SWIGINTERNINLINE PyObject*
02972 SWIG_From_unsigned_SS_long (unsigned long value)
02973 {
02974 return (value > LONG_MAX) ?
02975 PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
02976 }
02977
02978
02979 SWIGINTERNINLINE PyObject *
02980 SWIG_From_unsigned_SS_int (unsigned int value)
02981 {
02982 return SWIG_From_unsigned_SS_long (value);
02983 }
02984
02985
02986 SWIGINTERN swig_type_info*
02987 SWIG_pchar_descriptor(void)
02988 {
02989 static int init = 0;
02990 static swig_type_info* info = 0;
02991 if (!init) {
02992 info = SWIG_TypeQuery("_p_char");
02993 init = 1;
02994 }
02995 return info;
02996 }
02997
02998
02999 SWIGINTERN int
03000 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
03001 {
03002 #if PY_VERSION_HEX>=0x03000000
03003 if (PyUnicode_Check(obj))
03004 #else
03005 if (PyString_Check(obj))
03006 #endif
03007 {
03008 char *cstr; Py_ssize_t len;
03009 #if PY_VERSION_HEX>=0x03000000
03010 if (!alloc && cptr) {
03011
03012
03013
03014
03015 return SWIG_RuntimeError;
03016 }
03017 obj = PyUnicode_AsUTF8String(obj);
03018 PyBytes_AsStringAndSize(obj, &cstr, &len);
03019 if(alloc) *alloc = SWIG_NEWOBJ;
03020 #else
03021 PyString_AsStringAndSize(obj, &cstr, &len);
03022 #endif
03023 if (cptr) {
03024 if (alloc) {
03025
03026
03027
03028
03029
03030
03031
03032
03033
03034 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
03035 if (*alloc != SWIG_OLDOBJ)
03036 #else
03037 if (*alloc == SWIG_NEWOBJ)
03038 #endif
03039 {
03040 *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
03041 *alloc = SWIG_NEWOBJ;
03042 }
03043 else {
03044 *cptr = cstr;
03045 *alloc = SWIG_OLDOBJ;
03046 }
03047 } else {
03048 #if PY_VERSION_HEX>=0x03000000
03049 assert(0);
03050 #endif
03051 *cptr = SWIG_Python_str_AsChar(obj);
03052 }
03053 }
03054 if (psize) *psize = len + 1;
03055 #if PY_VERSION_HEX>=0x03000000
03056 Py_XDECREF(obj);
03057 #endif
03058 return SWIG_OK;
03059 } else {
03060 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03061 if (pchar_descriptor) {
03062 void* vptr = 0;
03063 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
03064 if (cptr) *cptr = (char *) vptr;
03065 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
03066 if (alloc) *alloc = SWIG_OLDOBJ;
03067 return SWIG_OK;
03068 }
03069 }
03070 }
03071 return SWIG_TypeError;
03072 }
03073
03074
03075 SWIGINTERN int
03076 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
03077 {
03078 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
03079 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
03080 if (SWIG_IsOK(res)) {
03081 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
03082 if (csize <= size) {
03083 if (val) {
03084 if (csize) memcpy(val, cptr, csize*sizeof(char));
03085 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
03086 }
03087 if (alloc == SWIG_NEWOBJ) {
03088 free((char*)cptr);
03089 res = SWIG_DelNewMask(res);
03090 }
03091 return res;
03092 }
03093 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
03094 }
03095 return SWIG_TypeError;
03096 }
03097
03098
03099 SWIGINTERNINLINE PyObject *
03100 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
03101 {
03102 if (carray) {
03103 if (size > INT_MAX) {
03104 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03105 return pchar_descriptor ?
03106 SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
03107 } else {
03108 #if PY_VERSION_HEX >= 0x03000000
03109 return PyUnicode_FromStringAndSize(carray, (int)(size));
03110 #else
03111 return PyString_FromStringAndSize(carray, (int)(size));
03112 #endif
03113 }
03114 } else {
03115 return SWIG_Py_Void();
03116 }
03117 }
03118
03119
03120
03121
03122
03123 #define t_output_helper SWIG_Python_AppendOutput
03124
03125
03126 SWIGINTERN int
03127 SWIG_AsVal_char (PyObject * obj, char *val)
03128 {
03129 int res = SWIG_AsCharArray(obj, val, 1);
03130 if (!SWIG_IsOK(res)) {
03131 long v;
03132 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
03133 if (SWIG_IsOK(res)) {
03134 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
03135 if (val) *val = (char)(v);
03136 } else {
03137 res = SWIG_OverflowError;
03138 }
03139 }
03140 }
03141 return res;
03142 }
03143
03144 #ifdef __cplusplus
03145 extern "C" {
03146 #endif
03147
03148
03149 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims )
03150 {
03151 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, PyArray_PLINT,
03152 mindims, maxdims );
03153 if ( !tmp )
03154 {
03155
03156 if ( PyArray_Check( in ) )
03157 {
03158 PyErr_Clear();
03159 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, PyArray_PLINT );
03160 }
03161 }
03162 return tmp;
03163 }
03164
03165
03166 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
03167
03168 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03169 PyObject *resultobj = 0;
03170 PLFLT arg1 ;
03171 PLFLT arg2 ;
03172 PLFLT *arg3 = (PLFLT *) 0 ;
03173 PLFLT *arg4 = (PLFLT *) 0 ;
03174 PLPointer arg5 = (PLPointer) 0 ;
03175 double val1 ;
03176 int ecode1 = 0 ;
03177 double val2 ;
03178 int ecode2 = 0 ;
03179 PLFLT temp3 ;
03180 int res3 = SWIG_TMPOBJ ;
03181 PLFLT temp4 ;
03182 int res4 = SWIG_TMPOBJ ;
03183 PyObject * obj0 = 0 ;
03184 PyObject * obj1 = 0 ;
03185
03186 arg3 = &temp3;
03187 arg4 = &temp4;
03188 {
03189 arg5 = NULL;
03190 }
03191 if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
03192 ecode1 = SWIG_AsVal_double(obj0, &val1);
03193 if (!SWIG_IsOK(ecode1)) {
03194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
03195 }
03196 arg1 = (PLFLT)(val1);
03197 ecode2 = SWIG_AsVal_double(obj1, &val2);
03198 if (!SWIG_IsOK(ecode2)) {
03199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
03200 }
03201 arg2 = (PLFLT)(val2);
03202 pltr0(arg1,arg2,arg3,arg4,arg5);
03203 resultobj = SWIG_Py_Void();
03204 if (SWIG_IsTmpObj(res3)) {
03205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03206 } else {
03207 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
03208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03209 }
03210 if (SWIG_IsTmpObj(res4)) {
03211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03212 } else {
03213 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
03214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03215 }
03216 return resultobj;
03217 fail:
03218 return NULL;
03219 }
03220
03221
03222
03223 PyArrayObject *pltr_xg, *pltr_yg;
03224 static PLcGrid tmpGrid1;
03225 static PLcGrid2 tmpGrid2;
03226
03227 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
03228 {
03229
03230 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
03231 {
03232 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
03233 return NULL;
03234 }
03235 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
03236 PyArray_PLFLT, 1, 1 );
03237 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
03238 PyArray_PLFLT, 1, 1 );
03239 if ( pltr_xg == 0 || pltr_yg == 0 )
03240 {
03241 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
03242 return NULL;
03243 }
03244 tmpGrid1.nx = pltr_xg->dimensions[0];
03245 tmpGrid1.ny = pltr_yg->dimensions[0];
03246 if ( isimg == 0 )
03247 {
03248 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
03249 {
03250 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
03251 return NULL;
03252 }
03253 }
03254 else
03255 {
03256 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
03257 {
03258 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
03259 return NULL;
03260 }
03261 }
03262 tmpGrid1.xg = (PLFLT *) pltr_xg->data;
03263 tmpGrid1.yg = (PLFLT *) pltr_yg->data;
03264 return &tmpGrid1;
03265 }
03266
03267 void cleanup_PLcGrid1( void )
03268 {
03269
03270 Py_DECREF( pltr_xg );
03271 Py_DECREF( pltr_yg );
03272 }
03273
03274 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
03275 {
03276 int i, size;
03277
03278 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
03279 {
03280 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
03281 return NULL;
03282 }
03283 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
03284 PyArray_PLFLT, 2, 2 );
03285 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
03286 PyArray_PLFLT, 2, 2 );
03287 if ( pltr_xg == 0 || pltr_yg == 0 )
03288 {
03289 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
03290 return NULL;
03291 }
03292 if ( pltr_xg->dimensions[0] != pltr_yg->dimensions[0] ||
03293 pltr_xg->dimensions[1] != pltr_yg->dimensions[1] )
03294 {
03295 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
03296 return NULL;
03297 }
03298 tmpGrid2.nx = pltr_xg->dimensions[0];
03299 tmpGrid2.ny = pltr_xg->dimensions[1];
03300 if ( isimg == 0 )
03301 {
03302 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
03303 {
03304 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
03305 return NULL;
03306 }
03307 }
03308 else
03309 {
03310 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
03311 {
03312 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
03313 return NULL;
03314 }
03315 }
03316 size = sizeof ( PLFLT ) * tmpGrid2.ny;
03317 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
03318 for ( i = 0; i < tmpGrid2.nx; i++ )
03319 tmpGrid2.xg[i] = (PLFLT *) ( pltr_xg->data + i * size );
03320 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
03321 for ( i = 0; i < tmpGrid2.nx; i++ )
03322 tmpGrid2.yg[i] = (PLFLT *) ( pltr_yg->data + i * size );
03323 return &tmpGrid2;
03324 }
03325
03326 void cleanup_PLcGrid2( void )
03327 {
03328
03329 free( tmpGrid2.xg );
03330 free( tmpGrid2.yg );
03331 Py_DECREF( pltr_xg );
03332 Py_DECREF( pltr_yg );
03333 }
03334
03335 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03336 PyObject *resultobj = 0;
03337 PLFLT arg1 ;
03338 PLFLT arg2 ;
03339 PLFLT *arg3 = (PLFLT *) 0 ;
03340 PLFLT *arg4 = (PLFLT *) 0 ;
03341 PLcGrid *arg5 = (PLcGrid *) 0 ;
03342 double val1 ;
03343 int ecode1 = 0 ;
03344 double val2 ;
03345 int ecode2 = 0 ;
03346 PLFLT temp3 ;
03347 int res3 = SWIG_TMPOBJ ;
03348 PLFLT temp4 ;
03349 int res4 = SWIG_TMPOBJ ;
03350 PyObject * obj0 = 0 ;
03351 PyObject * obj1 = 0 ;
03352 PyObject * obj2 = 0 ;
03353
03354 arg3 = &temp3;
03355 arg4 = &temp4;
03356 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
03357 ecode1 = SWIG_AsVal_double(obj0, &val1);
03358 if (!SWIG_IsOK(ecode1)) {
03359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
03360 }
03361 arg1 = (PLFLT)(val1);
03362 ecode2 = SWIG_AsVal_double(obj1, &val2);
03363 if (!SWIG_IsOK(ecode2)) {
03364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
03365 }
03366 arg2 = (PLFLT)(val2);
03367 {
03368 arg5 = marshal_PLcGrid1( obj2, 0 );
03369 if ( !arg5 )
03370 return NULL;
03371 }
03372 pltr1(arg1,arg2,arg3,arg4,arg5);
03373 resultobj = SWIG_Py_Void();
03374 if (SWIG_IsTmpObj(res3)) {
03375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03376 } else {
03377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
03378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03379 }
03380 if (SWIG_IsTmpObj(res4)) {
03381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03382 } else {
03383 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
03384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03385 }
03386 {
03387 cleanup_PLcGrid1();
03388 }
03389 return resultobj;
03390 fail:
03391 {
03392 cleanup_PLcGrid1();
03393 }
03394 return NULL;
03395 }
03396
03397
03398 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03399 PyObject *resultobj = 0;
03400 PLFLT arg1 ;
03401 PLFLT arg2 ;
03402 PLFLT *arg3 = (PLFLT *) 0 ;
03403 PLFLT *arg4 = (PLFLT *) 0 ;
03404 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
03405 double val1 ;
03406 int ecode1 = 0 ;
03407 double val2 ;
03408 int ecode2 = 0 ;
03409 PLFLT temp3 ;
03410 int res3 = SWIG_TMPOBJ ;
03411 PLFLT temp4 ;
03412 int res4 = SWIG_TMPOBJ ;
03413 PyObject * obj0 = 0 ;
03414 PyObject * obj1 = 0 ;
03415 PyObject * obj2 = 0 ;
03416
03417 arg3 = &temp3;
03418 arg4 = &temp4;
03419 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
03420 ecode1 = SWIG_AsVal_double(obj0, &val1);
03421 if (!SWIG_IsOK(ecode1)) {
03422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
03423 }
03424 arg1 = (PLFLT)(val1);
03425 ecode2 = SWIG_AsVal_double(obj1, &val2);
03426 if (!SWIG_IsOK(ecode2)) {
03427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
03428 }
03429 arg2 = (PLFLT)(val2);
03430 {
03431 arg5 = marshal_PLcGrid2( obj2, 0 );
03432 if ( !arg5 )
03433 return NULL;
03434 }
03435 pltr2(arg1,arg2,arg3,arg4,arg5);
03436 resultobj = SWIG_Py_Void();
03437 if (SWIG_IsTmpObj(res3)) {
03438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03439 } else {
03440 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
03441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03442 }
03443 if (SWIG_IsTmpObj(res4)) {
03444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03445 } else {
03446 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
03447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03448 }
03449 {
03450 cleanup_PLcGrid2();
03451 }
03452 return resultobj;
03453 fail:
03454 {
03455 cleanup_PLcGrid2();
03456 }
03457 return NULL;
03458 }
03459
03460
03461
03462
03463 #if 0
03464 static PyInterpreterState *save_interp = NULL;
03465 #endif
03466 enum callback_type { CB_0, CB_1, CB_2, CB_Python } pltr_type;
03467 PyObject* python_pltr = NULL;
03468 PyObject* python_f2eval = NULL;
03469 PyObject* python_ct = NULL;
03470 PyObject* python_mapform = NULL;
03471 PyObject* python_label = NULL;
03472
03473 #if 0
03474 #define MY_BLOCK_THREADS { \
03475 PyThreadState *prev_state, *new_state; \
03476 \
03477 \
03478 PyEval_AcquireLock(); \
03479 new_state = PyThreadState_New( save_interp ); \
03480 prev_state = PyThreadState_Swap( new_state );
03481 #define MY_UNBLOCK_THREADS \
03482 new_state = PyThreadState_Swap( prev_state ); \
03483 PyThreadState_Clear( new_state ); \
03484 PyEval_ReleaseLock(); \
03485 PyThreadState_Delete( new_state ); \
03486 }
03487 #else
03488 #define MY_BLOCK_THREADS
03489 #define MY_UNBLOCK_THREADS
03490 #endif
03491
03492
03493
03494 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
03495 {
03496 PyObject *pdata, *arglist, *result;
03497 PyArrayObject *tmp;
03498
03499
03500 pdata = (PyObject *) data;
03501 if ( data == NULL )
03502 {
03503 pdata = Py_None;
03504 }
03505 if ( python_pltr )
03506 {
03507 Py_XINCREF( pdata );
03508
03509 MY_BLOCK_THREADS
03510
03511 #ifdef PL_DOUBLE
03512 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
03513 #else
03514 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
03515 #endif
03516 if ( arglist == NULL )
03517 {
03518 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
03519 *tx = *ty = 0;
03520 return;
03521 }
03522
03523 result = PyEval_CallObject( python_pltr, arglist );
03524
03525 Py_XDECREF( arglist );
03526
03527 if ( result == NULL )
03528 {
03529 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
03530 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
03531 *tx = *ty = 0;
03532 }
03533 else
03534 {
03535 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, PyArray_PLFLT, 1, 1 );
03536 if ( tmp == 0 || tmp->dimensions[0] != 2 )
03537 {
03538 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
03539 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
03540 *tx = *ty = 0;
03541 }
03542 else
03543 {
03544 PLFLT* t = (PLFLT *) tmp->data;
03545 *tx = t[0];
03546 *ty = t[1];
03547 Py_XDECREF( tmp );
03548 }
03549 }
03550
03551 Py_XDECREF( result );
03552
03553 MY_UNBLOCK_THREADS
03554 }
03555 }
03556
03557 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
03558 {
03559 PyObject *pdata, *arglist, *result;
03560 PLFLT fresult = 0.0;
03561
03562
03563 pdata = (PyObject *) data;
03564 if ( python_f2eval )
03565 {
03566 Py_XINCREF( pdata );
03567
03568 MY_BLOCK_THREADS
03569
03570 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
03571
03572 result = PyEval_CallObject( python_f2eval, arglist );
03573
03574 Py_DECREF( arglist );
03575
03576 if ( !PyFloat_Check( result ) )
03577 {
03578 fprintf( stderr, "f2eval callback must return a float\n" );
03579 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
03580 }
03581 else
03582 {
03583
03584 fresult = (PLFLT) PyFloat_AsDouble( result );
03585 }
03586
03587 Py_XDECREF( result );
03588
03589 MY_UNBLOCK_THREADS
03590 }
03591 return fresult;
03592 }
03593
03594 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
03595 {
03596 PyObject *pdata, *arglist, *result;
03597 char *pystring;
03598 PLFLT fresult = 0.0;
03599
03600
03601 if ( data )
03602 pdata = (PyObject *) data;
03603 else
03604 pdata = Py_None;
03605 if ( python_label )
03606 {
03607 Py_XINCREF( pdata );
03608
03609 MY_BLOCK_THREADS
03610
03611 #ifdef PL_DOUBLE
03612 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
03613 #else
03614 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
03615 #endif
03616
03617 result = PyEval_CallObject( python_label, arglist );
03618
03619
03620
03621 if ( result == NULL )
03622 {
03623 fprintf( stderr, "label callback failed with 3 arguments\n" );
03624 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
03625 }
03626 else if ( !PyString_Check( result ) )
03627 {
03628 fprintf( stderr, "label callback must return a string\n" );
03629 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
03630 }
03631 else
03632 {
03633
03634 pystring = PyString_AsString( result );
03635 strncpy( string, pystring, len );
03636 }
03637
03638 Py_XDECREF( result );
03639
03640 MY_UNBLOCK_THREADS
03641 }
03642 }
03643
03644 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
03645 {
03646 PyObject *px, *py, *pdata, *arglist, *result;
03647 #ifdef HAVE_NUMPY
03648 npy_intp n;
03649 #else
03650 PLINT n;
03651 #endif
03652 n = 1;
03653
03654
03655 pdata = (PyObject *) data;
03656 if ( data == NULL )
03657 {
03658 pdata = Py_None;
03659 }
03660 if ( python_ct )
03661 {
03662 Py_XINCREF( pdata );
03663
03664 MY_BLOCK_THREADS
03665
03666 #ifdef HAVE_NUMPY
03667 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
03668 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
03669 #else
03670 px = PyArray_FromDimsAndData( 1, &n, PyArray_PLFLT, (char *) xt );
03671 py = PyArray_FromDimsAndData( 1, &n, PyArray_PLFLT, (char *) yt );
03672 #endif
03673 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
03674
03675 result = PyEval_CallObject( python_ct, arglist );
03676
03677 Py_DECREF( arglist );
03678 Py_DECREF( px );
03679 Py_DECREF( py );
03680 Py_DECREF( pdata );
03681
03682 if ( result == NULL )
03683 {
03684 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
03685 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
03686 }
03687
03688 Py_XDECREF( result );
03689
03690 MY_UNBLOCK_THREADS
03691 }
03692 }
03693
03694 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
03695 {
03696 PyObject *px, *py, *arglist, *result;
03697
03698
03699
03700 #ifdef HAVE_NUMPY
03701 npy_intp nn;
03702 nn = n;
03703 #endif
03704
03705 if ( python_mapform )
03706 {
03707 MY_BLOCK_THREADS
03708
03709 #ifdef PL_HAVE_PTHREAD
03710 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
03711 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
03712 #else
03713 px = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) x );
03714 py = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) y );
03715 #endif
03716 arglist = Py_BuildValue( "(iOO)", n, px, py );
03717
03718 result = PyEval_CallObject( python_mapform, arglist );
03719
03720 Py_DECREF( arglist );
03721 Py_DECREF( px );
03722 Py_DECREF( py );
03723
03724 if ( result == NULL )
03725 {
03726 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
03727 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
03728 }
03729
03730 Py_XDECREF( result );
03731
03732 MY_UNBLOCK_THREADS
03733 }
03734 }
03735
03736
03737 pltr_func marshal_pltr( PyObject* input )
03738 {
03739 pltr_func result = do_pltr_callback;
03740 PyObject * rep = PyObject_Repr( input );
03741 if ( rep )
03742 {
03743 char* str = PyString_AsString( rep );
03744 if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
03745 {
03746 result = pltr0;
03747 pltr_type = CB_0;
03748 python_pltr = NULL;
03749 }
03750 else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
03751 {
03752 result = pltr1;
03753 pltr_type = CB_1;
03754 python_pltr = NULL;
03755 }
03756 else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
03757 {
03758 result = pltr2;
03759 pltr_type = CB_2;
03760 python_pltr = NULL;
03761 }
03762 else
03763 {
03764 python_pltr = input;
03765 pltr_type = CB_Python;
03766 Py_XINCREF( input );
03767 }
03768 Py_DECREF( rep );
03769 }
03770 else
03771 {
03772 python_pltr = input;
03773 pltr_type = CB_Python;
03774 Py_XINCREF( input );
03775 }
03776 return result;
03777 }
03778
03779 void cleanup_pltr( void )
03780 {
03781 Py_XDECREF( python_pltr );
03782 python_pltr = 0;
03783 }
03784
03785
03786 ct_func marshal_ct( PyObject* input )
03787 {
03788 ct_func result = do_ct_callback;
03789 python_ct = input;
03790 Py_XINCREF( input );
03791 return result;
03792 }
03793
03794 void cleanup_ct( void )
03795 {
03796 Py_XDECREF( python_ct );
03797 python_ct = 0;
03798 }
03799
03800
03801 mapform_func marshal_mapform( PyObject* input )
03802 {
03803 mapform_func result = do_mapform_callback;
03804 python_mapform = input;
03805 Py_XINCREF( input );
03806 return result;
03807 }
03808
03809 void cleanup_mapform( void )
03810 {
03811 Py_XDECREF( python_mapform );
03812 python_mapform = 0;
03813 }
03814
03815 PLPointer marshal_PLPointer( PyObject* input, int isimg )
03816 {
03817 PLPointer result = NULL;
03818 switch ( pltr_type )
03819 {
03820 case CB_0:
03821 break;
03822 case CB_1:
03823 if ( input != Py_None )
03824 result = marshal_PLcGrid1( input, isimg );
03825 break;
03826 case CB_2:
03827 if ( input != Py_None )
03828 result = marshal_PLcGrid2( input, isimg );
03829 break;
03830 case CB_Python:
03831 Py_XINCREF( input );
03832 result = (PLPointer *) input;
03833 break;
03834 default:
03835 fprintf( stderr, "pltr_type is invalid\n" );
03836 }
03837 return result;
03838 }
03839
03840 void cleanup_PLPointer( void )
03841 {
03842 switch ( pltr_type )
03843 {
03844 case CB_0:
03845 break;
03846 case CB_1:
03847 cleanup_PLcGrid1();
03848 break;
03849 case CB_2:
03850 cleanup_PLcGrid2();
03851 break;
03852 case CB_Python:
03853 Py_XDECREF( python_pltr );
03854 break;
03855 default:
03856 fprintf( stderr, "pltr_type is invalid\n" );
03857 }
03858 python_pltr = 0;
03859 pltr_type = CB_0;
03860 }
03861
03862
03863
03864 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03865 PyObject *resultobj = 0;
03866 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03867 int arg2 ;
03868 void *argp1 = 0 ;
03869 int res1 = 0 ;
03870 int val2 ;
03871 int ecode2 = 0 ;
03872 PyObject * obj0 = 0 ;
03873 PyObject * obj1 = 0 ;
03874
03875 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
03876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
03877 if (!SWIG_IsOK(res1)) {
03878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
03879 }
03880 arg1 = (PLGraphicsIn *)(argp1);
03881 ecode2 = SWIG_AsVal_int(obj1, &val2);
03882 if (!SWIG_IsOK(ecode2)) {
03883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
03884 }
03885 arg2 = (int)(val2);
03886 if (arg1) (arg1)->type = arg2;
03887 resultobj = SWIG_Py_Void();
03888 return resultobj;
03889 fail:
03890 return NULL;
03891 }
03892
03893
03894 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03895 PyObject *resultobj = 0;
03896 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03897 void *argp1 = 0 ;
03898 int res1 = 0 ;
03899 PyObject * obj0 = 0 ;
03900 int result;
03901
03902 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
03903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
03904 if (!SWIG_IsOK(res1)) {
03905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
03906 }
03907 arg1 = (PLGraphicsIn *)(argp1);
03908 result = (int) ((arg1)->type);
03909 resultobj = SWIG_From_int((int)(result));
03910 return resultobj;
03911 fail:
03912 return NULL;
03913 }
03914
03915
03916 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03917 PyObject *resultobj = 0;
03918 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03919 unsigned int arg2 ;
03920 void *argp1 = 0 ;
03921 int res1 = 0 ;
03922 unsigned int val2 ;
03923 int ecode2 = 0 ;
03924 PyObject * obj0 = 0 ;
03925 PyObject * obj1 = 0 ;
03926
03927 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
03928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
03929 if (!SWIG_IsOK(res1)) {
03930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
03931 }
03932 arg1 = (PLGraphicsIn *)(argp1);
03933 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
03934 if (!SWIG_IsOK(ecode2)) {
03935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
03936 }
03937 arg2 = (unsigned int)(val2);
03938 if (arg1) (arg1)->state = arg2;
03939 resultobj = SWIG_Py_Void();
03940 return resultobj;
03941 fail:
03942 return NULL;
03943 }
03944
03945
03946 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03947 PyObject *resultobj = 0;
03948 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03949 void *argp1 = 0 ;
03950 int res1 = 0 ;
03951 PyObject * obj0 = 0 ;
03952 unsigned int result;
03953
03954 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
03955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
03956 if (!SWIG_IsOK(res1)) {
03957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
03958 }
03959 arg1 = (PLGraphicsIn *)(argp1);
03960 result = (unsigned int) ((arg1)->state);
03961 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
03962 return resultobj;
03963 fail:
03964 return NULL;
03965 }
03966
03967
03968 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03969 PyObject *resultobj = 0;
03970 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03971 unsigned int arg2 ;
03972 void *argp1 = 0 ;
03973 int res1 = 0 ;
03974 unsigned int val2 ;
03975 int ecode2 = 0 ;
03976 PyObject * obj0 = 0 ;
03977 PyObject * obj1 = 0 ;
03978
03979 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
03980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
03981 if (!SWIG_IsOK(res1)) {
03982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
03983 }
03984 arg1 = (PLGraphicsIn *)(argp1);
03985 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
03986 if (!SWIG_IsOK(ecode2)) {
03987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
03988 }
03989 arg2 = (unsigned int)(val2);
03990 if (arg1) (arg1)->keysym = arg2;
03991 resultobj = SWIG_Py_Void();
03992 return resultobj;
03993 fail:
03994 return NULL;
03995 }
03996
03997
03998 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03999 PyObject *resultobj = 0;
04000 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04001 void *argp1 = 0 ;
04002 int res1 = 0 ;
04003 PyObject * obj0 = 0 ;
04004 unsigned int result;
04005
04006 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
04007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04008 if (!SWIG_IsOK(res1)) {
04009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04010 }
04011 arg1 = (PLGraphicsIn *)(argp1);
04012 result = (unsigned int) ((arg1)->keysym);
04013 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04014 return resultobj;
04015 fail:
04016 return NULL;
04017 }
04018
04019
04020 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04021 PyObject *resultobj = 0;
04022 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04023 unsigned int arg2 ;
04024 void *argp1 = 0 ;
04025 int res1 = 0 ;
04026 unsigned int val2 ;
04027 int ecode2 = 0 ;
04028 PyObject * obj0 = 0 ;
04029 PyObject * obj1 = 0 ;
04030
04031 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
04032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04033 if (!SWIG_IsOK(res1)) {
04034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04035 }
04036 arg1 = (PLGraphicsIn *)(argp1);
04037 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
04038 if (!SWIG_IsOK(ecode2)) {
04039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
04040 }
04041 arg2 = (unsigned int)(val2);
04042 if (arg1) (arg1)->button = arg2;
04043 resultobj = SWIG_Py_Void();
04044 return resultobj;
04045 fail:
04046 return NULL;
04047 }
04048
04049
04050 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04051 PyObject *resultobj = 0;
04052 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04053 void *argp1 = 0 ;
04054 int res1 = 0 ;
04055 PyObject * obj0 = 0 ;
04056 unsigned int result;
04057
04058 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
04059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04060 if (!SWIG_IsOK(res1)) {
04061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04062 }
04063 arg1 = (PLGraphicsIn *)(argp1);
04064 result = (unsigned int) ((arg1)->button);
04065 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04066 return resultobj;
04067 fail:
04068 return NULL;
04069 }
04070
04071
04072 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04073 PyObject *resultobj = 0;
04074 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04075 PLINT arg2 ;
04076 void *argp1 = 0 ;
04077 int res1 = 0 ;
04078 int val2 ;
04079 int ecode2 = 0 ;
04080 PyObject * obj0 = 0 ;
04081 PyObject * obj1 = 0 ;
04082
04083 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
04084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04085 if (!SWIG_IsOK(res1)) {
04086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04087 }
04088 arg1 = (PLGraphicsIn *)(argp1);
04089 ecode2 = SWIG_AsVal_int(obj1, &val2);
04090 if (!SWIG_IsOK(ecode2)) {
04091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
04092 }
04093 arg2 = (PLINT)(val2);
04094 if (arg1) (arg1)->subwindow = arg2;
04095 resultobj = SWIG_Py_Void();
04096 return resultobj;
04097 fail:
04098 return NULL;
04099 }
04100
04101
04102 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04103 PyObject *resultobj = 0;
04104 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04105 void *argp1 = 0 ;
04106 int res1 = 0 ;
04107 PyObject * obj0 = 0 ;
04108 PLINT result;
04109
04110 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
04111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04112 if (!SWIG_IsOK(res1)) {
04113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04114 }
04115 arg1 = (PLGraphicsIn *)(argp1);
04116 result = (PLINT) ((arg1)->subwindow);
04117 resultobj = SWIG_From_int((int)(result));
04118 return resultobj;
04119 fail:
04120 return NULL;
04121 }
04122
04123
04124 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04125 PyObject *resultobj = 0;
04126 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04127 char *arg2 ;
04128 void *argp1 = 0 ;
04129 int res1 = 0 ;
04130 char temp2[16] ;
04131 int res2 ;
04132 PyObject * obj0 = 0 ;
04133 PyObject * obj1 = 0 ;
04134
04135 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
04136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04137 if (!SWIG_IsOK(res1)) {
04138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04139 }
04140 arg1 = (PLGraphicsIn *)(argp1);
04141 res2 = SWIG_AsCharArray(obj1, temp2, 16);
04142 if (!SWIG_IsOK(res2)) {
04143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
04144 }
04145 arg2 = (char *)(temp2);
04146 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
04147 else memset(arg1->string,0,16*sizeof(char));
04148 resultobj = SWIG_Py_Void();
04149 return resultobj;
04150 fail:
04151 return NULL;
04152 }
04153
04154
04155 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04156 PyObject *resultobj = 0;
04157 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04158 void *argp1 = 0 ;
04159 int res1 = 0 ;
04160 PyObject * obj0 = 0 ;
04161 char *result = 0 ;
04162
04163 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
04164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04165 if (!SWIG_IsOK(res1)) {
04166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04167 }
04168 arg1 = (PLGraphicsIn *)(argp1);
04169 result = (char *)(char *) ((arg1)->string);
04170 {
04171 size_t size = 16;
04172
04173 while (size && (result[size - 1] == '\0')) --size;
04174
04175 resultobj = SWIG_FromCharPtrAndSize(result, size);
04176 }
04177 return resultobj;
04178 fail:
04179 return NULL;
04180 }
04181
04182
04183 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04184 PyObject *resultobj = 0;
04185 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04186 int arg2 ;
04187 void *argp1 = 0 ;
04188 int res1 = 0 ;
04189 int val2 ;
04190 int ecode2 = 0 ;
04191 PyObject * obj0 = 0 ;
04192 PyObject * obj1 = 0 ;
04193
04194 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
04195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04196 if (!SWIG_IsOK(res1)) {
04197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04198 }
04199 arg1 = (PLGraphicsIn *)(argp1);
04200 ecode2 = SWIG_AsVal_int(obj1, &val2);
04201 if (!SWIG_IsOK(ecode2)) {
04202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
04203 }
04204 arg2 = (int)(val2);
04205 if (arg1) (arg1)->pX = arg2;
04206 resultobj = SWIG_Py_Void();
04207 return resultobj;
04208 fail:
04209 return NULL;
04210 }
04211
04212
04213 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04214 PyObject *resultobj = 0;
04215 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04216 void *argp1 = 0 ;
04217 int res1 = 0 ;
04218 PyObject * obj0 = 0 ;
04219 int result;
04220
04221 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
04222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04223 if (!SWIG_IsOK(res1)) {
04224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04225 }
04226 arg1 = (PLGraphicsIn *)(argp1);
04227 result = (int) ((arg1)->pX);
04228 resultobj = SWIG_From_int((int)(result));
04229 return resultobj;
04230 fail:
04231 return NULL;
04232 }
04233
04234
04235 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04236 PyObject *resultobj = 0;
04237 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04238 int arg2 ;
04239 void *argp1 = 0 ;
04240 int res1 = 0 ;
04241 int val2 ;
04242 int ecode2 = 0 ;
04243 PyObject * obj0 = 0 ;
04244 PyObject * obj1 = 0 ;
04245
04246 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
04247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04248 if (!SWIG_IsOK(res1)) {
04249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04250 }
04251 arg1 = (PLGraphicsIn *)(argp1);
04252 ecode2 = SWIG_AsVal_int(obj1, &val2);
04253 if (!SWIG_IsOK(ecode2)) {
04254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
04255 }
04256 arg2 = (int)(val2);
04257 if (arg1) (arg1)->pY = arg2;
04258 resultobj = SWIG_Py_Void();
04259 return resultobj;
04260 fail:
04261 return NULL;
04262 }
04263
04264
04265 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04266 PyObject *resultobj = 0;
04267 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04268 void *argp1 = 0 ;
04269 int res1 = 0 ;
04270 PyObject * obj0 = 0 ;
04271 int result;
04272
04273 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
04274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04275 if (!SWIG_IsOK(res1)) {
04276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04277 }
04278 arg1 = (PLGraphicsIn *)(argp1);
04279 result = (int) ((arg1)->pY);
04280 resultobj = SWIG_From_int((int)(result));
04281 return resultobj;
04282 fail:
04283 return NULL;
04284 }
04285
04286
04287 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04288 PyObject *resultobj = 0;
04289 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04290 PLFLT arg2 ;
04291 void *argp1 = 0 ;
04292 int res1 = 0 ;
04293 double val2 ;
04294 int ecode2 = 0 ;
04295 PyObject * obj0 = 0 ;
04296 PyObject * obj1 = 0 ;
04297
04298 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
04299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04300 if (!SWIG_IsOK(res1)) {
04301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04302 }
04303 arg1 = (PLGraphicsIn *)(argp1);
04304 ecode2 = SWIG_AsVal_double(obj1, &val2);
04305 if (!SWIG_IsOK(ecode2)) {
04306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
04307 }
04308 arg2 = (PLFLT)(val2);
04309 if (arg1) (arg1)->dX = arg2;
04310 resultobj = SWIG_Py_Void();
04311 return resultobj;
04312 fail:
04313 return NULL;
04314 }
04315
04316
04317 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04318 PyObject *resultobj = 0;
04319 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04320 void *argp1 = 0 ;
04321 int res1 = 0 ;
04322 PyObject * obj0 = 0 ;
04323 PLFLT result;
04324
04325 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
04326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04327 if (!SWIG_IsOK(res1)) {
04328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04329 }
04330 arg1 = (PLGraphicsIn *)(argp1);
04331 result = (PLFLT) ((arg1)->dX);
04332 resultobj = SWIG_From_double((double)(result));
04333 return resultobj;
04334 fail:
04335 return NULL;
04336 }
04337
04338
04339 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04340 PyObject *resultobj = 0;
04341 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04342 PLFLT arg2 ;
04343 void *argp1 = 0 ;
04344 int res1 = 0 ;
04345 double val2 ;
04346 int ecode2 = 0 ;
04347 PyObject * obj0 = 0 ;
04348 PyObject * obj1 = 0 ;
04349
04350 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
04351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04352 if (!SWIG_IsOK(res1)) {
04353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04354 }
04355 arg1 = (PLGraphicsIn *)(argp1);
04356 ecode2 = SWIG_AsVal_double(obj1, &val2);
04357 if (!SWIG_IsOK(ecode2)) {
04358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
04359 }
04360 arg2 = (PLFLT)(val2);
04361 if (arg1) (arg1)->dY = arg2;
04362 resultobj = SWIG_Py_Void();
04363 return resultobj;
04364 fail:
04365 return NULL;
04366 }
04367
04368
04369 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04370 PyObject *resultobj = 0;
04371 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04372 void *argp1 = 0 ;
04373 int res1 = 0 ;
04374 PyObject * obj0 = 0 ;
04375 PLFLT result;
04376
04377 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
04378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04379 if (!SWIG_IsOK(res1)) {
04380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04381 }
04382 arg1 = (PLGraphicsIn *)(argp1);
04383 result = (PLFLT) ((arg1)->dY);
04384 resultobj = SWIG_From_double((double)(result));
04385 return resultobj;
04386 fail:
04387 return NULL;
04388 }
04389
04390
04391 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04392 PyObject *resultobj = 0;
04393 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04394 PLFLT arg2 ;
04395 void *argp1 = 0 ;
04396 int res1 = 0 ;
04397 double val2 ;
04398 int ecode2 = 0 ;
04399 PyObject * obj0 = 0 ;
04400 PyObject * obj1 = 0 ;
04401
04402 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
04403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04404 if (!SWIG_IsOK(res1)) {
04405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04406 }
04407 arg1 = (PLGraphicsIn *)(argp1);
04408 ecode2 = SWIG_AsVal_double(obj1, &val2);
04409 if (!SWIG_IsOK(ecode2)) {
04410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
04411 }
04412 arg2 = (PLFLT)(val2);
04413 if (arg1) (arg1)->wX = arg2;
04414 resultobj = SWIG_Py_Void();
04415 return resultobj;
04416 fail:
04417 return NULL;
04418 }
04419
04420
04421 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04422 PyObject *resultobj = 0;
04423 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04424 void *argp1 = 0 ;
04425 int res1 = 0 ;
04426 PyObject * obj0 = 0 ;
04427 PLFLT result;
04428
04429 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
04430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04431 if (!SWIG_IsOK(res1)) {
04432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04433 }
04434 arg1 = (PLGraphicsIn *)(argp1);
04435 result = (PLFLT) ((arg1)->wX);
04436 resultobj = SWIG_From_double((double)(result));
04437 return resultobj;
04438 fail:
04439 return NULL;
04440 }
04441
04442
04443 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04444 PyObject *resultobj = 0;
04445 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04446 PLFLT arg2 ;
04447 void *argp1 = 0 ;
04448 int res1 = 0 ;
04449 double val2 ;
04450 int ecode2 = 0 ;
04451 PyObject * obj0 = 0 ;
04452 PyObject * obj1 = 0 ;
04453
04454 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
04455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04456 if (!SWIG_IsOK(res1)) {
04457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04458 }
04459 arg1 = (PLGraphicsIn *)(argp1);
04460 ecode2 = SWIG_AsVal_double(obj1, &val2);
04461 if (!SWIG_IsOK(ecode2)) {
04462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
04463 }
04464 arg2 = (PLFLT)(val2);
04465 if (arg1) (arg1)->wY = arg2;
04466 resultobj = SWIG_Py_Void();
04467 return resultobj;
04468 fail:
04469 return NULL;
04470 }
04471
04472
04473 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04474 PyObject *resultobj = 0;
04475 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04476 void *argp1 = 0 ;
04477 int res1 = 0 ;
04478 PyObject * obj0 = 0 ;
04479 PLFLT result;
04480
04481 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
04482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
04483 if (!SWIG_IsOK(res1)) {
04484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04485 }
04486 arg1 = (PLGraphicsIn *)(argp1);
04487 result = (PLFLT) ((arg1)->wY);
04488 resultobj = SWIG_From_double((double)(result));
04489 return resultobj;
04490 fail:
04491 return NULL;
04492 }
04493
04494
04495 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04496 PyObject *resultobj = 0;
04497 PLGraphicsIn *result = 0 ;
04498
04499 if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
04500 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
04501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_NEW | 0 );
04502 return resultobj;
04503 fail:
04504 return NULL;
04505 }
04506
04507
04508 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04509 PyObject *resultobj = 0;
04510 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04511 void *argp1 = 0 ;
04512 int res1 = 0 ;
04513 PyObject * obj0 = 0 ;
04514
04515 if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
04516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
04517 if (!SWIG_IsOK(res1)) {
04518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
04519 }
04520 arg1 = (PLGraphicsIn *)(argp1);
04521 free((char *) arg1);
04522 resultobj = SWIG_Py_Void();
04523 return resultobj;
04524 fail:
04525 return NULL;
04526 }
04527
04528
04529 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04530 PyObject *obj;
04531 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04532 SWIG_TypeNewClientData(SWIGTYPE_p_PLGraphicsIn, SWIG_NewClientData(obj));
04533 return SWIG_Py_Void();
04534 }
04535
04536 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04537 PyObject *resultobj = 0;
04538 PLINT arg1 ;
04539 int val1 ;
04540 int ecode1 = 0 ;
04541 PyObject * obj0 = 0 ;
04542
04543 if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
04544 ecode1 = SWIG_AsVal_int(obj0, &val1);
04545 if (!SWIG_IsOK(ecode1)) {
04546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
04547 }
04548 arg1 = (PLINT)(val1);
04549 plsxwin(arg1);
04550 resultobj = SWIG_Py_Void();
04551 return resultobj;
04552 fail:
04553 return NULL;
04554 }
04555
04556
04557 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04558 PyObject *resultobj = 0;
04559 PLINT arg1 ;
04560 PLINT arg2 ;
04561 int val1 ;
04562 int ecode1 = 0 ;
04563 int val2 ;
04564 int ecode2 = 0 ;
04565 PyObject * obj0 = 0 ;
04566 PyObject * obj1 = 0 ;
04567
04568 if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
04569 ecode1 = SWIG_AsVal_int(obj0, &val1);
04570 if (!SWIG_IsOK(ecode1)) {
04571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
04572 }
04573 arg1 = (PLINT)(val1);
04574 ecode2 = SWIG_AsVal_int(obj1, &val2);
04575 if (!SWIG_IsOK(ecode2)) {
04576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
04577 }
04578 arg2 = (PLINT)(val2);
04579 pl_setcontlabelformat(arg1,arg2);
04580 resultobj = SWIG_Py_Void();
04581 return resultobj;
04582 fail:
04583 return NULL;
04584 }
04585
04586
04587 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04588 PyObject *resultobj = 0;
04589 PLFLT arg1 ;
04590 PLFLT arg2 ;
04591 PLFLT arg3 ;
04592 PLINT arg4 ;
04593 double val1 ;
04594 int ecode1 = 0 ;
04595 double val2 ;
04596 int ecode2 = 0 ;
04597 double val3 ;
04598 int ecode3 = 0 ;
04599 int val4 ;
04600 int ecode4 = 0 ;
04601 PyObject * obj0 = 0 ;
04602 PyObject * obj1 = 0 ;
04603 PyObject * obj2 = 0 ;
04604 PyObject * obj3 = 0 ;
04605
04606 if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
04607 ecode1 = SWIG_AsVal_double(obj0, &val1);
04608 if (!SWIG_IsOK(ecode1)) {
04609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
04610 }
04611 arg1 = (PLFLT)(val1);
04612 ecode2 = SWIG_AsVal_double(obj1, &val2);
04613 if (!SWIG_IsOK(ecode2)) {
04614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
04615 }
04616 arg2 = (PLFLT)(val2);
04617 ecode3 = SWIG_AsVal_double(obj2, &val3);
04618 if (!SWIG_IsOK(ecode3)) {
04619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
04620 }
04621 arg3 = (PLFLT)(val3);
04622 ecode4 = SWIG_AsVal_int(obj3, &val4);
04623 if (!SWIG_IsOK(ecode4)) {
04624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
04625 }
04626 arg4 = (PLINT)(val4);
04627 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
04628 resultobj = SWIG_Py_Void();
04629 return resultobj;
04630 fail:
04631 return NULL;
04632 }
04633
04634
04635 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04636 PyObject *resultobj = 0;
04637 PLINT arg1 ;
04638 int val1 ;
04639 int ecode1 = 0 ;
04640 PyObject * obj0 = 0 ;
04641
04642 if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
04643 ecode1 = SWIG_AsVal_int(obj0, &val1);
04644 if (!SWIG_IsOK(ecode1)) {
04645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
04646 }
04647 arg1 = (PLINT)(val1);
04648 pladv(arg1);
04649 resultobj = SWIG_Py_Void();
04650 return resultobj;
04651 fail:
04652 return NULL;
04653 }
04654
04655
04656 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04657 PyObject *resultobj = 0;
04658 PLFLT arg1 ;
04659 PLFLT arg2 ;
04660 PLFLT arg3 ;
04661 PLFLT arg4 ;
04662 PLFLT arg5 ;
04663 PLFLT arg6 ;
04664 PLFLT arg7 ;
04665 PLBOOL arg8 ;
04666 double val1 ;
04667 int ecode1 = 0 ;
04668 double val2 ;
04669 int ecode2 = 0 ;
04670 double val3 ;
04671 int ecode3 = 0 ;
04672 double val4 ;
04673 int ecode4 = 0 ;
04674 double val5 ;
04675 int ecode5 = 0 ;
04676 double val6 ;
04677 int ecode6 = 0 ;
04678 double val7 ;
04679 int ecode7 = 0 ;
04680 int val8 ;
04681 int ecode8 = 0 ;
04682 PyObject * obj0 = 0 ;
04683 PyObject * obj1 = 0 ;
04684 PyObject * obj2 = 0 ;
04685 PyObject * obj3 = 0 ;
04686 PyObject * obj4 = 0 ;
04687 PyObject * obj5 = 0 ;
04688 PyObject * obj6 = 0 ;
04689 PyObject * obj7 = 0 ;
04690
04691 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
04692 ecode1 = SWIG_AsVal_double(obj0, &val1);
04693 if (!SWIG_IsOK(ecode1)) {
04694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
04695 }
04696 arg1 = (PLFLT)(val1);
04697 ecode2 = SWIG_AsVal_double(obj1, &val2);
04698 if (!SWIG_IsOK(ecode2)) {
04699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
04700 }
04701 arg2 = (PLFLT)(val2);
04702 ecode3 = SWIG_AsVal_double(obj2, &val3);
04703 if (!SWIG_IsOK(ecode3)) {
04704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
04705 }
04706 arg3 = (PLFLT)(val3);
04707 ecode4 = SWIG_AsVal_double(obj3, &val4);
04708 if (!SWIG_IsOK(ecode4)) {
04709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
04710 }
04711 arg4 = (PLFLT)(val4);
04712 ecode5 = SWIG_AsVal_double(obj4, &val5);
04713 if (!SWIG_IsOK(ecode5)) {
04714 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
04715 }
04716 arg5 = (PLFLT)(val5);
04717 ecode6 = SWIG_AsVal_double(obj5, &val6);
04718 if (!SWIG_IsOK(ecode6)) {
04719 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
04720 }
04721 arg6 = (PLFLT)(val6);
04722 ecode7 = SWIG_AsVal_double(obj6, &val7);
04723 if (!SWIG_IsOK(ecode7)) {
04724 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
04725 }
04726 arg7 = (PLFLT)(val7);
04727 ecode8 = SWIG_AsVal_int(obj7, &val8);
04728 if (!SWIG_IsOK(ecode8)) {
04729 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
04730 }
04731 arg8 = (PLBOOL)(val8);
04732 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
04733 resultobj = SWIG_Py_Void();
04734 return resultobj;
04735 fail:
04736 return NULL;
04737 }
04738
04739
04740 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04741 PyObject *resultobj = 0;
04742 PLFLT arg1 ;
04743 PLFLT arg2 ;
04744 char *arg3 = (char *) 0 ;
04745 PLFLT arg4 ;
04746 PLINT arg5 ;
04747 char *arg6 = (char *) 0 ;
04748 PLFLT arg7 ;
04749 PLINT arg8 ;
04750 double val1 ;
04751 int ecode1 = 0 ;
04752 double val2 ;
04753 int ecode2 = 0 ;
04754 int res3 ;
04755 char *buf3 = 0 ;
04756 int alloc3 = 0 ;
04757 double val4 ;
04758 int ecode4 = 0 ;
04759 int val5 ;
04760 int ecode5 = 0 ;
04761 int res6 ;
04762 char *buf6 = 0 ;
04763 int alloc6 = 0 ;
04764 double val7 ;
04765 int ecode7 = 0 ;
04766 int val8 ;
04767 int ecode8 = 0 ;
04768 PyObject * obj0 = 0 ;
04769 PyObject * obj1 = 0 ;
04770 PyObject * obj2 = 0 ;
04771 PyObject * obj3 = 0 ;
04772 PyObject * obj4 = 0 ;
04773 PyObject * obj5 = 0 ;
04774 PyObject * obj6 = 0 ;
04775 PyObject * obj7 = 0 ;
04776
04777 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
04778 ecode1 = SWIG_AsVal_double(obj0, &val1);
04779 if (!SWIG_IsOK(ecode1)) {
04780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
04781 }
04782 arg1 = (PLFLT)(val1);
04783 ecode2 = SWIG_AsVal_double(obj1, &val2);
04784 if (!SWIG_IsOK(ecode2)) {
04785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
04786 }
04787 arg2 = (PLFLT)(val2);
04788 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04789 if (!SWIG_IsOK(res3)) {
04790 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
04791 }
04792 arg3 = (char *)(buf3);
04793 ecode4 = SWIG_AsVal_double(obj3, &val4);
04794 if (!SWIG_IsOK(ecode4)) {
04795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
04796 }
04797 arg4 = (PLFLT)(val4);
04798 ecode5 = SWIG_AsVal_int(obj4, &val5);
04799 if (!SWIG_IsOK(ecode5)) {
04800 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
04801 }
04802 arg5 = (PLINT)(val5);
04803 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
04804 if (!SWIG_IsOK(res6)) {
04805 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
04806 }
04807 arg6 = (char *)(buf6);
04808 ecode7 = SWIG_AsVal_double(obj6, &val7);
04809 if (!SWIG_IsOK(ecode7)) {
04810 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
04811 }
04812 arg7 = (PLFLT)(val7);
04813 ecode8 = SWIG_AsVal_int(obj7, &val8);
04814 if (!SWIG_IsOK(ecode8)) {
04815 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
04816 }
04817 arg8 = (PLINT)(val8);
04818 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
04819 resultobj = SWIG_Py_Void();
04820 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
04821 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
04822 return resultobj;
04823 fail:
04824 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
04825 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
04826 return NULL;
04827 }
04828
04829
04830 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04831 PyObject *resultobj = 0;
04832 PLINT arg1 ;
04833 PLFLT *arg2 = (PLFLT *) 0 ;
04834 PLFLT *arg3 = (PLFLT *) 0 ;
04835 PLINT arg4 ;
04836 PyArrayObject *tmp1 ;
04837 PyArrayObject *tmp3 ;
04838 int val4 ;
04839 int ecode4 = 0 ;
04840 PyObject * obj0 = 0 ;
04841 PyObject * obj1 = 0 ;
04842 PyObject * obj2 = 0 ;
04843
04844 if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
04845 {
04846 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
04847 if ( tmp1 == NULL )
04848 return NULL;
04849 arg1 = Alen = tmp1->dimensions[0];
04850 arg2 = (PLFLT *) tmp1->data;
04851 }
04852 {
04853 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
04854 if ( tmp3 == NULL )
04855 return NULL;
04856 if ( tmp3->dimensions[0] != Alen )
04857 {
04858 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
04859 return NULL;
04860 }
04861 arg3 = (PLFLT *) tmp3->data;
04862 }
04863 ecode4 = SWIG_AsVal_int(obj2, &val4);
04864 if (!SWIG_IsOK(ecode4)) {
04865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
04866 }
04867 arg4 = (PLINT)(val4);
04868 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
04869 resultobj = SWIG_Py_Void();
04870 {
04871 Py_DECREF( tmp1 );
04872 }
04873 {
04874 Py_DECREF( tmp3 );
04875 }
04876 return resultobj;
04877 fail:
04878 {
04879 Py_DECREF( tmp1 );
04880 }
04881 {
04882 Py_DECREF( tmp3 );
04883 }
04884 return NULL;
04885 }
04886
04887
04888 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04889 PyObject *resultobj = 0;
04890 PLINT *arg1 = (PLINT *) 0 ;
04891 PLINT *arg2 = (PLINT *) 0 ;
04892 PLINT *arg3 = (PLINT *) 0 ;
04893 PLINT *arg4 = (PLINT *) 0 ;
04894 PLINT *arg5 = (PLINT *) 0 ;
04895 PLFLT *arg6 = (PLFLT *) 0 ;
04896 PLFLT arg7 ;
04897 PLINT temp1 ;
04898 int res1 = SWIG_TMPOBJ ;
04899 PLINT temp2 ;
04900 int res2 = SWIG_TMPOBJ ;
04901 PLINT temp3 ;
04902 int res3 = SWIG_TMPOBJ ;
04903 PLINT temp4 ;
04904 int res4 = SWIG_TMPOBJ ;
04905 PLINT temp5 ;
04906 int res5 = SWIG_TMPOBJ ;
04907 PLFLT temp6 ;
04908 int res6 = SWIG_TMPOBJ ;
04909 double val7 ;
04910 int ecode7 = 0 ;
04911 PyObject * obj0 = 0 ;
04912
04913 arg1 = &temp1;
04914 arg2 = &temp2;
04915 arg3 = &temp3;
04916 arg4 = &temp4;
04917 arg5 = &temp5;
04918 arg6 = &temp6;
04919 if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
04920 ecode7 = SWIG_AsVal_double(obj0, &val7);
04921 if (!SWIG_IsOK(ecode7)) {
04922 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
04923 }
04924 arg7 = (PLFLT)(val7);
04925 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
04926 resultobj = SWIG_Py_Void();
04927 if (SWIG_IsTmpObj(res1)) {
04928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
04929 } else {
04930 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
04931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
04932 }
04933 if (SWIG_IsTmpObj(res2)) {
04934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
04935 } else {
04936 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
04937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
04938 }
04939 if (SWIG_IsTmpObj(res3)) {
04940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
04941 } else {
04942 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
04943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
04944 }
04945 if (SWIG_IsTmpObj(res4)) {
04946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
04947 } else {
04948 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
04949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
04950 }
04951 if (SWIG_IsTmpObj(res5)) {
04952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
04953 } else {
04954 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
04955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
04956 }
04957 if (SWIG_IsTmpObj(res6)) {
04958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
04959 } else {
04960 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
04961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
04962 }
04963 return resultobj;
04964 fail:
04965 return NULL;
04966 }
04967
04968
04969 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04970 PyObject *resultobj = 0;
04971
04972 if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
04973 plbop();
04974 resultobj = SWIG_Py_Void();
04975 return resultobj;
04976 fail:
04977 return NULL;
04978 }
04979
04980
04981 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04982 PyObject *resultobj = 0;
04983 char *arg1 = (char *) 0 ;
04984 PLFLT arg2 ;
04985 PLINT arg3 ;
04986 char *arg4 = (char *) 0 ;
04987 PLFLT arg5 ;
04988 PLINT arg6 ;
04989 int res1 ;
04990 char *buf1 = 0 ;
04991 int alloc1 = 0 ;
04992 double val2 ;
04993 int ecode2 = 0 ;
04994 int val3 ;
04995 int ecode3 = 0 ;
04996 int res4 ;
04997 char *buf4 = 0 ;
04998 int alloc4 = 0 ;
04999 double val5 ;
05000 int ecode5 = 0 ;
05001 int val6 ;
05002 int ecode6 = 0 ;
05003 PyObject * obj0 = 0 ;
05004 PyObject * obj1 = 0 ;
05005 PyObject * obj2 = 0 ;
05006 PyObject * obj3 = 0 ;
05007 PyObject * obj4 = 0 ;
05008 PyObject * obj5 = 0 ;
05009
05010 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05011 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
05012 if (!SWIG_IsOK(res1)) {
05013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
05014 }
05015 arg1 = (char *)(buf1);
05016 ecode2 = SWIG_AsVal_double(obj1, &val2);
05017 if (!SWIG_IsOK(ecode2)) {
05018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
05019 }
05020 arg2 = (PLFLT)(val2);
05021 ecode3 = SWIG_AsVal_int(obj2, &val3);
05022 if (!SWIG_IsOK(ecode3)) {
05023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
05024 }
05025 arg3 = (PLINT)(val3);
05026 res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
05027 if (!SWIG_IsOK(res4)) {
05028 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
05029 }
05030 arg4 = (char *)(buf4);
05031 ecode5 = SWIG_AsVal_double(obj4, &val5);
05032 if (!SWIG_IsOK(ecode5)) {
05033 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
05034 }
05035 arg5 = (PLFLT)(val5);
05036 ecode6 = SWIG_AsVal_int(obj5, &val6);
05037 if (!SWIG_IsOK(ecode6)) {
05038 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
05039 }
05040 arg6 = (PLINT)(val6);
05041 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
05042 resultobj = SWIG_Py_Void();
05043 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05044 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
05045 return resultobj;
05046 fail:
05047 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05048 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
05049 return NULL;
05050 }
05051
05052
05053 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05054 PyObject *resultobj = 0;
05055 char *arg1 = (char *) 0 ;
05056 char *arg2 = (char *) 0 ;
05057 PLFLT arg3 ;
05058 PLINT arg4 ;
05059 char *arg5 = (char *) 0 ;
05060 char *arg6 = (char *) 0 ;
05061 PLFLT arg7 ;
05062 PLINT arg8 ;
05063 char *arg9 = (char *) 0 ;
05064 char *arg10 = (char *) 0 ;
05065 PLFLT arg11 ;
05066 PLINT arg12 ;
05067 int res1 ;
05068 char *buf1 = 0 ;
05069 int alloc1 = 0 ;
05070 int res2 ;
05071 char *buf2 = 0 ;
05072 int alloc2 = 0 ;
05073 double val3 ;
05074 int ecode3 = 0 ;
05075 int val4 ;
05076 int ecode4 = 0 ;
05077 int res5 ;
05078 char *buf5 = 0 ;
05079 int alloc5 = 0 ;
05080 int res6 ;
05081 char *buf6 = 0 ;
05082 int alloc6 = 0 ;
05083 double val7 ;
05084 int ecode7 = 0 ;
05085 int val8 ;
05086 int ecode8 = 0 ;
05087 int res9 ;
05088 char *buf9 = 0 ;
05089 int alloc9 = 0 ;
05090 int res10 ;
05091 char *buf10 = 0 ;
05092 int alloc10 = 0 ;
05093 double val11 ;
05094 int ecode11 = 0 ;
05095 int val12 ;
05096 int ecode12 = 0 ;
05097 PyObject * obj0 = 0 ;
05098 PyObject * obj1 = 0 ;
05099 PyObject * obj2 = 0 ;
05100 PyObject * obj3 = 0 ;
05101 PyObject * obj4 = 0 ;
05102 PyObject * obj5 = 0 ;
05103 PyObject * obj6 = 0 ;
05104 PyObject * obj7 = 0 ;
05105 PyObject * obj8 = 0 ;
05106 PyObject * obj9 = 0 ;
05107 PyObject * obj10 = 0 ;
05108 PyObject * obj11 = 0 ;
05109
05110 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
05111 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
05112 if (!SWIG_IsOK(res1)) {
05113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
05114 }
05115 arg1 = (char *)(buf1);
05116 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05117 if (!SWIG_IsOK(res2)) {
05118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
05119 }
05120 arg2 = (char *)(buf2);
05121 ecode3 = SWIG_AsVal_double(obj2, &val3);
05122 if (!SWIG_IsOK(ecode3)) {
05123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
05124 }
05125 arg3 = (PLFLT)(val3);
05126 ecode4 = SWIG_AsVal_int(obj3, &val4);
05127 if (!SWIG_IsOK(ecode4)) {
05128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
05129 }
05130 arg4 = (PLINT)(val4);
05131 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
05132 if (!SWIG_IsOK(res5)) {
05133 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
05134 }
05135 arg5 = (char *)(buf5);
05136 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
05137 if (!SWIG_IsOK(res6)) {
05138 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
05139 }
05140 arg6 = (char *)(buf6);
05141 ecode7 = SWIG_AsVal_double(obj6, &val7);
05142 if (!SWIG_IsOK(ecode7)) {
05143 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
05144 }
05145 arg7 = (PLFLT)(val7);
05146 ecode8 = SWIG_AsVal_int(obj7, &val8);
05147 if (!SWIG_IsOK(ecode8)) {
05148 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
05149 }
05150 arg8 = (PLINT)(val8);
05151 res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
05152 if (!SWIG_IsOK(res9)) {
05153 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
05154 }
05155 arg9 = (char *)(buf9);
05156 res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
05157 if (!SWIG_IsOK(res10)) {
05158 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
05159 }
05160 arg10 = (char *)(buf10);
05161 ecode11 = SWIG_AsVal_double(obj10, &val11);
05162 if (!SWIG_IsOK(ecode11)) {
05163 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
05164 }
05165 arg11 = (PLFLT)(val11);
05166 ecode12 = SWIG_AsVal_int(obj11, &val12);
05167 if (!SWIG_IsOK(ecode12)) {
05168 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
05169 }
05170 arg12 = (PLINT)(val12);
05171 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);
05172 resultobj = SWIG_Py_Void();
05173 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05174 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
05175 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
05176 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05177 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
05178 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
05179 return resultobj;
05180 fail:
05181 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05182 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
05183 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
05184 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05185 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
05186 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
05187 return NULL;
05188 }
05189
05190
05191 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05192 PyObject *resultobj = 0;
05193 PLFLT arg1 ;
05194 PLFLT arg2 ;
05195 PLFLT *arg3 = (PLFLT *) 0 ;
05196 PLFLT *arg4 = (PLFLT *) 0 ;
05197 PLINT *arg5 = (PLINT *) 0 ;
05198 double val1 ;
05199 int ecode1 = 0 ;
05200 double val2 ;
05201 int ecode2 = 0 ;
05202 PLFLT temp3 ;
05203 int res3 = SWIG_TMPOBJ ;
05204 PLFLT temp4 ;
05205 int res4 = SWIG_TMPOBJ ;
05206 PLINT temp5 ;
05207 int res5 = SWIG_TMPOBJ ;
05208 PyObject * obj0 = 0 ;
05209 PyObject * obj1 = 0 ;
05210
05211 arg3 = &temp3;
05212 arg4 = &temp4;
05213 arg5 = &temp5;
05214 if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
05215 ecode1 = SWIG_AsVal_double(obj0, &val1);
05216 if (!SWIG_IsOK(ecode1)) {
05217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
05218 }
05219 arg1 = (PLFLT)(val1);
05220 ecode2 = SWIG_AsVal_double(obj1, &val2);
05221 if (!SWIG_IsOK(ecode2)) {
05222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
05223 }
05224 arg2 = (PLFLT)(val2);
05225 plcalc_world(arg1,arg2,arg3,arg4,arg5);
05226 resultobj = SWIG_Py_Void();
05227 if (SWIG_IsTmpObj(res3)) {
05228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
05229 } else {
05230 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
05231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
05232 }
05233 if (SWIG_IsTmpObj(res4)) {
05234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
05235 } else {
05236 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
05237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
05238 }
05239 if (SWIG_IsTmpObj(res5)) {
05240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
05241 } else {
05242 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
05243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
05244 }
05245 return resultobj;
05246 fail:
05247 return NULL;
05248 }
05249
05250
05251 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05252 PyObject *resultobj = 0;
05253
05254 if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
05255 plclear();
05256 resultobj = SWIG_Py_Void();
05257 return resultobj;
05258 fail:
05259 return NULL;
05260 }
05261
05262
05263 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05264 PyObject *resultobj = 0;
05265 PLINT arg1 ;
05266 int val1 ;
05267 int ecode1 = 0 ;
05268 PyObject * obj0 = 0 ;
05269
05270 if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
05271 ecode1 = SWIG_AsVal_int(obj0, &val1);
05272 if (!SWIG_IsOK(ecode1)) {
05273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
05274 }
05275 arg1 = (PLINT)(val1);
05276 plcol0(arg1);
05277 resultobj = SWIG_Py_Void();
05278 return resultobj;
05279 fail:
05280 return NULL;
05281 }
05282
05283
05284 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05285 PyObject *resultobj = 0;
05286 PLFLT arg1 ;
05287 double val1 ;
05288 int ecode1 = 0 ;
05289 PyObject * obj0 = 0 ;
05290
05291 if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
05292 ecode1 = SWIG_AsVal_double(obj0, &val1);
05293 if (!SWIG_IsOK(ecode1)) {
05294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
05295 }
05296 arg1 = (PLFLT)(val1);
05297 plcol1(arg1);
05298 resultobj = SWIG_Py_Void();
05299 return resultobj;
05300 fail:
05301 return NULL;
05302 }
05303
05304
05305 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05306 PyObject *resultobj = 0;
05307 PLFLT arg1 ;
05308 PLFLT arg2 ;
05309 PLFLT arg3 ;
05310 PLINT arg4 ;
05311 PLBOOL arg5 ;
05312 PLINT arg6 ;
05313 PLINT arg7 ;
05314 PLINT arg8 ;
05315 PLINT arg9 ;
05316 PLINT arg10 ;
05317 PLFLT arg11 ;
05318 double val1 ;
05319 int ecode1 = 0 ;
05320 double val2 ;
05321 int ecode2 = 0 ;
05322 double val3 ;
05323 int ecode3 = 0 ;
05324 int val4 ;
05325 int ecode4 = 0 ;
05326 int val5 ;
05327 int ecode5 = 0 ;
05328 int val6 ;
05329 int ecode6 = 0 ;
05330 int val7 ;
05331 int ecode7 = 0 ;
05332 int val8 ;
05333 int ecode8 = 0 ;
05334 int val9 ;
05335 int ecode9 = 0 ;
05336 int val10 ;
05337 int ecode10 = 0 ;
05338 double val11 ;
05339 int ecode11 = 0 ;
05340 PyObject * obj0 = 0 ;
05341 PyObject * obj1 = 0 ;
05342 PyObject * obj2 = 0 ;
05343 PyObject * obj3 = 0 ;
05344 PyObject * obj4 = 0 ;
05345 PyObject * obj5 = 0 ;
05346 PyObject * obj6 = 0 ;
05347 PyObject * obj7 = 0 ;
05348 PyObject * obj8 = 0 ;
05349 PyObject * obj9 = 0 ;
05350 PyObject * obj10 = 0 ;
05351
05352 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
05353 ecode1 = SWIG_AsVal_double(obj0, &val1);
05354 if (!SWIG_IsOK(ecode1)) {
05355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
05356 }
05357 arg1 = (PLFLT)(val1);
05358 ecode2 = SWIG_AsVal_double(obj1, &val2);
05359 if (!SWIG_IsOK(ecode2)) {
05360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
05361 }
05362 arg2 = (PLFLT)(val2);
05363 ecode3 = SWIG_AsVal_double(obj2, &val3);
05364 if (!SWIG_IsOK(ecode3)) {
05365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
05366 }
05367 arg3 = (PLFLT)(val3);
05368 ecode4 = SWIG_AsVal_int(obj3, &val4);
05369 if (!SWIG_IsOK(ecode4)) {
05370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
05371 }
05372 arg4 = (PLINT)(val4);
05373 ecode5 = SWIG_AsVal_int(obj4, &val5);
05374 if (!SWIG_IsOK(ecode5)) {
05375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
05376 }
05377 arg5 = (PLBOOL)(val5);
05378 ecode6 = SWIG_AsVal_int(obj5, &val6);
05379 if (!SWIG_IsOK(ecode6)) {
05380 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
05381 }
05382 arg6 = (PLINT)(val6);
05383 ecode7 = SWIG_AsVal_int(obj6, &val7);
05384 if (!SWIG_IsOK(ecode7)) {
05385 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
05386 }
05387 arg7 = (PLINT)(val7);
05388 ecode8 = SWIG_AsVal_int(obj7, &val8);
05389 if (!SWIG_IsOK(ecode8)) {
05390 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
05391 }
05392 arg8 = (PLINT)(val8);
05393 ecode9 = SWIG_AsVal_int(obj8, &val9);
05394 if (!SWIG_IsOK(ecode9)) {
05395 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
05396 }
05397 arg9 = (PLINT)(val9);
05398 ecode10 = SWIG_AsVal_int(obj9, &val10);
05399 if (!SWIG_IsOK(ecode10)) {
05400 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
05401 }
05402 arg10 = (PLINT)(val10);
05403 ecode11 = SWIG_AsVal_double(obj10, &val11);
05404 if (!SWIG_IsOK(ecode11)) {
05405 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
05406 }
05407 arg11 = (PLFLT)(val11);
05408 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
05409 resultobj = SWIG_Py_Void();
05410 return resultobj;
05411 fail:
05412 return NULL;
05413 }
05414
05415
05416 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05417 PyObject *resultobj = 0;
05418 PLFLT **arg1 = (PLFLT **) 0 ;
05419 PLINT arg2 ;
05420 PLINT arg3 ;
05421 PLINT arg4 ;
05422 PLINT arg5 ;
05423 PLINT arg6 ;
05424 PLINT arg7 ;
05425 PLFLT *arg8 = (PLFLT *) 0 ;
05426 PLINT arg9 ;
05427 pltr_func arg10 = (pltr_func) 0 ;
05428 PLPointer arg11 = (PLPointer) 0 ;
05429 PyArrayObject *tmp1 ;
05430 int val4 ;
05431 int ecode4 = 0 ;
05432 int val5 ;
05433 int ecode5 = 0 ;
05434 int val6 ;
05435 int ecode6 = 0 ;
05436 int val7 ;
05437 int ecode7 = 0 ;
05438 PyArrayObject *tmp8 ;
05439 PyObject * obj0 = 0 ;
05440 PyObject * obj1 = 0 ;
05441 PyObject * obj2 = 0 ;
05442 PyObject * obj3 = 0 ;
05443 PyObject * obj4 = 0 ;
05444 PyObject * obj5 = 0 ;
05445 PyObject * obj6 = 0 ;
05446 PyObject * obj7 = 0 ;
05447
05448 {
05449 python_pltr = 0;
05450 arg10 = NULL;
05451 }
05452 {
05453 arg11 = NULL;
05454 }
05455 if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
05456 {
05457 int i, size;
05458 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
05459 if ( tmp1 == NULL )
05460 return NULL;
05461 Xlen = arg2 = tmp1->dimensions[0];
05462 Ylen = arg3 = tmp1->dimensions[1];
05463 size = sizeof ( PLFLT ) * arg3;
05464 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
05465 for ( i = 0; i < arg2; i++ )
05466 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
05467 }
05468 ecode4 = SWIG_AsVal_int(obj1, &val4);
05469 if (!SWIG_IsOK(ecode4)) {
05470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
05471 }
05472 arg4 = (PLINT)(val4);
05473 ecode5 = SWIG_AsVal_int(obj2, &val5);
05474 if (!SWIG_IsOK(ecode5)) {
05475 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
05476 }
05477 arg5 = (PLINT)(val5);
05478 ecode6 = SWIG_AsVal_int(obj3, &val6);
05479 if (!SWIG_IsOK(ecode6)) {
05480 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
05481 }
05482 arg6 = (PLINT)(val6);
05483 ecode7 = SWIG_AsVal_int(obj4, &val7);
05484 if (!SWIG_IsOK(ecode7)) {
05485 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
05486 }
05487 arg7 = (PLINT)(val7);
05488 {
05489 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 1, 1 );
05490 if ( tmp8 == NULL )
05491 return NULL;
05492 arg9 = tmp8->dimensions[0];
05493 arg8 = (PLFLT *) tmp8->data;
05494 }
05495 if (obj6) {
05496 {
05497
05498 if ( obj6 == Py_None )
05499 {
05500 arg10 = NULL;
05501 }
05502 else
05503 {
05504 if ( !PyCallable_Check( (PyObject *) obj6 ) )
05505 {
05506 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
05507 return NULL;
05508 }
05509 arg10 = marshal_pltr( obj6 );
05510 }
05511 }
05512 }
05513 if (obj7) {
05514 {
05515 if ( obj7 == Py_None )
05516 arg11 = NULL;
05517 else
05518 {
05519 arg11 = marshal_PLPointer( obj7, 0 );
05520 }
05521 }
05522 }
05523 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
05524 resultobj = SWIG_Py_Void();
05525 {
05526 Py_DECREF( tmp1 );
05527 free( arg1 );
05528 }
05529 {
05530 Py_DECREF( tmp8 );
05531 }
05532 {
05533 cleanup_pltr();
05534 }
05535 {
05536 cleanup_PLPointer();
05537 }
05538 return resultobj;
05539 fail:
05540 {
05541 Py_DECREF( tmp1 );
05542 free( arg1 );
05543 }
05544 {
05545 Py_DECREF( tmp8 );
05546 }
05547 {
05548 cleanup_pltr();
05549 }
05550 {
05551 cleanup_PLPointer();
05552 }
05553 return NULL;
05554 }
05555
05556
05557 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05558 PyObject *resultobj = 0;
05559 PLINT arg1 ;
05560 PLINT arg2 ;
05561 PLINT arg3 ;
05562 PLINT arg4 ;
05563 PLINT arg5 ;
05564 PLFLT arg6 ;
05565 PLFLT *arg7 = (PLFLT *) 0 ;
05566 int val1 ;
05567 int ecode1 = 0 ;
05568 int val2 ;
05569 int ecode2 = 0 ;
05570 int val3 ;
05571 int ecode3 = 0 ;
05572 int val4 ;
05573 int ecode4 = 0 ;
05574 int val5 ;
05575 int ecode5 = 0 ;
05576 double val6 ;
05577 int ecode6 = 0 ;
05578 PLFLT temp7 ;
05579 int res7 = SWIG_TMPOBJ ;
05580 PyObject * obj0 = 0 ;
05581 PyObject * obj1 = 0 ;
05582 PyObject * obj2 = 0 ;
05583 PyObject * obj3 = 0 ;
05584 PyObject * obj4 = 0 ;
05585 PyObject * obj5 = 0 ;
05586
05587 arg7 = &temp7;
05588 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05589 ecode1 = SWIG_AsVal_int(obj0, &val1);
05590 if (!SWIG_IsOK(ecode1)) {
05591 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
05592 }
05593 arg1 = (PLINT)(val1);
05594 ecode2 = SWIG_AsVal_int(obj1, &val2);
05595 if (!SWIG_IsOK(ecode2)) {
05596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
05597 }
05598 arg2 = (PLINT)(val2);
05599 ecode3 = SWIG_AsVal_int(obj2, &val3);
05600 if (!SWIG_IsOK(ecode3)) {
05601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
05602 }
05603 arg3 = (PLINT)(val3);
05604 ecode4 = SWIG_AsVal_int(obj3, &val4);
05605 if (!SWIG_IsOK(ecode4)) {
05606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
05607 }
05608 arg4 = (PLINT)(val4);
05609 ecode5 = SWIG_AsVal_int(obj4, &val5);
05610 if (!SWIG_IsOK(ecode5)) {
05611 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
05612 }
05613 arg5 = (PLINT)(val5);
05614 ecode6 = SWIG_AsVal_double(obj5, &val6);
05615 if (!SWIG_IsOK(ecode6)) {
05616 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
05617 }
05618 arg6 = (PLFLT)(val6);
05619 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
05620 resultobj = SWIG_Py_Void();
05621 if (SWIG_IsTmpObj(res7)) {
05622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
05623 } else {
05624 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
05625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
05626 }
05627 return resultobj;
05628 fail:
05629 return NULL;
05630 }
05631
05632
05633 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05634 PyObject *resultobj = 0;
05635 PLINT arg1 ;
05636 PLBOOL arg2 ;
05637 int val1 ;
05638 int ecode1 = 0 ;
05639 int val2 ;
05640 int ecode2 = 0 ;
05641 PyObject * obj0 = 0 ;
05642 PyObject * obj1 = 0 ;
05643
05644 if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
05645 ecode1 = SWIG_AsVal_int(obj0, &val1);
05646 if (!SWIG_IsOK(ecode1)) {
05647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
05648 }
05649 arg1 = (PLINT)(val1);
05650 ecode2 = SWIG_AsVal_int(obj1, &val2);
05651 if (!SWIG_IsOK(ecode2)) {
05652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
05653 }
05654 arg2 = (PLBOOL)(val2);
05655 plcpstrm(arg1,arg2);
05656 resultobj = SWIG_Py_Void();
05657 return resultobj;
05658 fail:
05659 return NULL;
05660 }
05661
05662
05663 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05664 PyObject *resultobj = 0;
05665
05666 if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
05667 plend();
05668 resultobj = SWIG_Py_Void();
05669 return resultobj;
05670 fail:
05671 return NULL;
05672 }
05673
05674
05675 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05676 PyObject *resultobj = 0;
05677
05678 if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
05679 plend1();
05680 resultobj = SWIG_Py_Void();
05681 return resultobj;
05682 fail:
05683 return NULL;
05684 }
05685
05686
05687 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05688 PyObject *resultobj = 0;
05689 PLFLT arg1 ;
05690 PLFLT arg2 ;
05691 PLFLT arg3 ;
05692 PLFLT arg4 ;
05693 PLINT arg5 ;
05694 PLINT arg6 ;
05695 double val1 ;
05696 int ecode1 = 0 ;
05697 double val2 ;
05698 int ecode2 = 0 ;
05699 double val3 ;
05700 int ecode3 = 0 ;
05701 double val4 ;
05702 int ecode4 = 0 ;
05703 int val5 ;
05704 int ecode5 = 0 ;
05705 int val6 ;
05706 int ecode6 = 0 ;
05707 PyObject * obj0 = 0 ;
05708 PyObject * obj1 = 0 ;
05709 PyObject * obj2 = 0 ;
05710 PyObject * obj3 = 0 ;
05711 PyObject * obj4 = 0 ;
05712 PyObject * obj5 = 0 ;
05713
05714 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05715 ecode1 = SWIG_AsVal_double(obj0, &val1);
05716 if (!SWIG_IsOK(ecode1)) {
05717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
05718 }
05719 arg1 = (PLFLT)(val1);
05720 ecode2 = SWIG_AsVal_double(obj1, &val2);
05721 if (!SWIG_IsOK(ecode2)) {
05722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
05723 }
05724 arg2 = (PLFLT)(val2);
05725 ecode3 = SWIG_AsVal_double(obj2, &val3);
05726 if (!SWIG_IsOK(ecode3)) {
05727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
05728 }
05729 arg3 = (PLFLT)(val3);
05730 ecode4 = SWIG_AsVal_double(obj3, &val4);
05731 if (!SWIG_IsOK(ecode4)) {
05732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
05733 }
05734 arg4 = (PLFLT)(val4);
05735 ecode5 = SWIG_AsVal_int(obj4, &val5);
05736 if (!SWIG_IsOK(ecode5)) {
05737 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
05738 }
05739 arg5 = (PLINT)(val5);
05740 ecode6 = SWIG_AsVal_int(obj5, &val6);
05741 if (!SWIG_IsOK(ecode6)) {
05742 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
05743 }
05744 arg6 = (PLINT)(val6);
05745 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
05746 resultobj = SWIG_Py_Void();
05747 return resultobj;
05748 fail:
05749 return NULL;
05750 }
05751
05752
05753 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05754 PyObject *resultobj = 0;
05755 PLFLT arg1 ;
05756 PLFLT arg2 ;
05757 PLFLT arg3 ;
05758 PLFLT arg4 ;
05759 PLINT arg5 ;
05760 PLINT arg6 ;
05761 double val1 ;
05762 int ecode1 = 0 ;
05763 double val2 ;
05764 int ecode2 = 0 ;
05765 double val3 ;
05766 int ecode3 = 0 ;
05767 double val4 ;
05768 int ecode4 = 0 ;
05769 int val5 ;
05770 int ecode5 = 0 ;
05771 int val6 ;
05772 int ecode6 = 0 ;
05773 PyObject * obj0 = 0 ;
05774 PyObject * obj1 = 0 ;
05775 PyObject * obj2 = 0 ;
05776 PyObject * obj3 = 0 ;
05777 PyObject * obj4 = 0 ;
05778 PyObject * obj5 = 0 ;
05779
05780 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05781 ecode1 = SWIG_AsVal_double(obj0, &val1);
05782 if (!SWIG_IsOK(ecode1)) {
05783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
05784 }
05785 arg1 = (PLFLT)(val1);
05786 ecode2 = SWIG_AsVal_double(obj1, &val2);
05787 if (!SWIG_IsOK(ecode2)) {
05788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
05789 }
05790 arg2 = (PLFLT)(val2);
05791 ecode3 = SWIG_AsVal_double(obj2, &val3);
05792 if (!SWIG_IsOK(ecode3)) {
05793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
05794 }
05795 arg3 = (PLFLT)(val3);
05796 ecode4 = SWIG_AsVal_double(obj3, &val4);
05797 if (!SWIG_IsOK(ecode4)) {
05798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
05799 }
05800 arg4 = (PLFLT)(val4);
05801 ecode5 = SWIG_AsVal_int(obj4, &val5);
05802 if (!SWIG_IsOK(ecode5)) {
05803 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
05804 }
05805 arg5 = (PLINT)(val5);
05806 ecode6 = SWIG_AsVal_int(obj5, &val6);
05807 if (!SWIG_IsOK(ecode6)) {
05808 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
05809 }
05810 arg6 = (PLINT)(val6);
05811 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
05812 resultobj = SWIG_Py_Void();
05813 return resultobj;
05814 fail:
05815 return NULL;
05816 }
05817
05818
05819 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05820 PyObject *resultobj = 0;
05821
05822 if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
05823 pleop();
05824 resultobj = SWIG_Py_Void();
05825 return resultobj;
05826 fail:
05827 return NULL;
05828 }
05829
05830
05831 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05832 PyObject *resultobj = 0;
05833 PLINT arg1 ;
05834 PLFLT *arg2 = (PLFLT *) 0 ;
05835 PLFLT *arg3 = (PLFLT *) 0 ;
05836 PLFLT *arg4 = (PLFLT *) 0 ;
05837 PyArrayObject *tmp1 ;
05838 PyArrayObject *tmp3 ;
05839 PyArrayObject *tmp4 ;
05840 PyObject * obj0 = 0 ;
05841 PyObject * obj1 = 0 ;
05842 PyObject * obj2 = 0 ;
05843
05844 if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
05845 {
05846 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
05847 if ( tmp1 == NULL )
05848 return NULL;
05849 arg1 = Alen = tmp1->dimensions[0];
05850 arg2 = (PLFLT *) tmp1->data;
05851 }
05852 {
05853 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
05854 if ( tmp3 == NULL )
05855 return NULL;
05856 if ( tmp3->dimensions[0] != Alen )
05857 {
05858 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05859 return NULL;
05860 }
05861 arg3 = (PLFLT *) tmp3->data;
05862 }
05863 {
05864 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
05865 if ( tmp4 == NULL )
05866 return NULL;
05867 if ( tmp4->dimensions[0] != Alen )
05868 {
05869 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05870 return NULL;
05871 }
05872 arg4 = (PLFLT *) tmp4->data;
05873 }
05874 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
05875 resultobj = SWIG_Py_Void();
05876 {
05877 Py_DECREF( tmp1 );
05878 }
05879 {
05880 Py_DECREF( tmp3 );
05881 }
05882 {
05883 Py_DECREF( tmp4 );
05884 }
05885 return resultobj;
05886 fail:
05887 {
05888 Py_DECREF( tmp1 );
05889 }
05890 {
05891 Py_DECREF( tmp3 );
05892 }
05893 {
05894 Py_DECREF( tmp4 );
05895 }
05896 return NULL;
05897 }
05898
05899
05900 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05901 PyObject *resultobj = 0;
05902 PLINT arg1 ;
05903 PLFLT *arg2 = (PLFLT *) 0 ;
05904 PLFLT *arg3 = (PLFLT *) 0 ;
05905 PLFLT *arg4 = (PLFLT *) 0 ;
05906 PyArrayObject *tmp1 ;
05907 PyArrayObject *tmp3 ;
05908 PyArrayObject *tmp4 ;
05909 PyObject * obj0 = 0 ;
05910 PyObject * obj1 = 0 ;
05911 PyObject * obj2 = 0 ;
05912
05913 if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
05914 {
05915 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
05916 if ( tmp1 == NULL )
05917 return NULL;
05918 arg1 = Alen = tmp1->dimensions[0];
05919 arg2 = (PLFLT *) tmp1->data;
05920 }
05921 {
05922 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
05923 if ( tmp3 == NULL )
05924 return NULL;
05925 if ( tmp3->dimensions[0] != Alen )
05926 {
05927 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05928 return NULL;
05929 }
05930 arg3 = (PLFLT *) tmp3->data;
05931 }
05932 {
05933 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
05934 if ( tmp4 == NULL )
05935 return NULL;
05936 if ( tmp4->dimensions[0] != Alen )
05937 {
05938 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05939 return NULL;
05940 }
05941 arg4 = (PLFLT *) tmp4->data;
05942 }
05943 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
05944 resultobj = SWIG_Py_Void();
05945 {
05946 Py_DECREF( tmp1 );
05947 }
05948 {
05949 Py_DECREF( tmp3 );
05950 }
05951 {
05952 Py_DECREF( tmp4 );
05953 }
05954 return resultobj;
05955 fail:
05956 {
05957 Py_DECREF( tmp1 );
05958 }
05959 {
05960 Py_DECREF( tmp3 );
05961 }
05962 {
05963 Py_DECREF( tmp4 );
05964 }
05965 return NULL;
05966 }
05967
05968
05969 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05970 PyObject *resultobj = 0;
05971
05972 if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
05973 plfamadv();
05974 resultobj = SWIG_Py_Void();
05975 return resultobj;
05976 fail:
05977 return NULL;
05978 }
05979
05980
05981 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05982 PyObject *resultobj = 0;
05983 PLINT arg1 ;
05984 PLFLT *arg2 = (PLFLT *) 0 ;
05985 PLFLT *arg3 = (PLFLT *) 0 ;
05986 PyArrayObject *tmp1 ;
05987 PyArrayObject *tmp3 ;
05988 PyObject * obj0 = 0 ;
05989 PyObject * obj1 = 0 ;
05990
05991 if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
05992 {
05993 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
05994 if ( tmp1 == NULL )
05995 return NULL;
05996 arg1 = Alen = tmp1->dimensions[0];
05997 arg2 = (PLFLT *) tmp1->data;
05998 }
05999 {
06000 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06001 if ( tmp3 == NULL )
06002 return NULL;
06003 if ( tmp3->dimensions[0] != Alen )
06004 {
06005 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06006 return NULL;
06007 }
06008 arg3 = (PLFLT *) tmp3->data;
06009 }
06010 plfill(arg1,(double const *)arg2,(double const *)arg3);
06011 resultobj = SWIG_Py_Void();
06012 {
06013 Py_DECREF( tmp1 );
06014 }
06015 {
06016 Py_DECREF( tmp3 );
06017 }
06018 return resultobj;
06019 fail:
06020 {
06021 Py_DECREF( tmp1 );
06022 }
06023 {
06024 Py_DECREF( tmp3 );
06025 }
06026 return NULL;
06027 }
06028
06029
06030 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06031 PyObject *resultobj = 0;
06032 PLINT arg1 ;
06033 PLFLT *arg2 = (PLFLT *) 0 ;
06034 PLFLT *arg3 = (PLFLT *) 0 ;
06035 PLFLT *arg4 = (PLFLT *) 0 ;
06036 PyArrayObject *tmp1 ;
06037 PyArrayObject *tmp3 ;
06038 PyArrayObject *tmp4 ;
06039 PyObject * obj0 = 0 ;
06040 PyObject * obj1 = 0 ;
06041 PyObject * obj2 = 0 ;
06042
06043 if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
06044 {
06045 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
06046 if ( tmp1 == NULL )
06047 return NULL;
06048 arg1 = Alen = tmp1->dimensions[0];
06049 arg2 = (PLFLT *) tmp1->data;
06050 }
06051 {
06052 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06053 if ( tmp3 == NULL )
06054 return NULL;
06055 if ( tmp3->dimensions[0] != Alen )
06056 {
06057 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06058 return NULL;
06059 }
06060 arg3 = (PLFLT *) tmp3->data;
06061 }
06062 {
06063 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
06064 if ( tmp4 == NULL )
06065 return NULL;
06066 if ( tmp4->dimensions[0] != Alen )
06067 {
06068 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06069 return NULL;
06070 }
06071 arg4 = (PLFLT *) tmp4->data;
06072 }
06073 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
06074 resultobj = SWIG_Py_Void();
06075 {
06076 Py_DECREF( tmp1 );
06077 }
06078 {
06079 Py_DECREF( tmp3 );
06080 }
06081 {
06082 Py_DECREF( tmp4 );
06083 }
06084 return resultobj;
06085 fail:
06086 {
06087 Py_DECREF( tmp1 );
06088 }
06089 {
06090 Py_DECREF( tmp3 );
06091 }
06092 {
06093 Py_DECREF( tmp4 );
06094 }
06095 return NULL;
06096 }
06097
06098
06099 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06100 PyObject *resultobj = 0;
06101 PLINT arg1 ;
06102 PLFLT *arg2 = (PLFLT *) 0 ;
06103 PLFLT *arg3 = (PLFLT *) 0 ;
06104 PLFLT arg4 ;
06105 PyArrayObject *tmp1 ;
06106 PyArrayObject *tmp3 ;
06107 double val4 ;
06108 int ecode4 = 0 ;
06109 PyObject * obj0 = 0 ;
06110 PyObject * obj1 = 0 ;
06111 PyObject * obj2 = 0 ;
06112
06113 if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
06114 {
06115 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
06116 if ( tmp1 == NULL )
06117 return NULL;
06118 arg1 = Alen = tmp1->dimensions[0];
06119 arg2 = (PLFLT *) tmp1->data;
06120 }
06121 {
06122 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06123 if ( tmp3 == NULL )
06124 return NULL;
06125 if ( tmp3->dimensions[0] != Alen )
06126 {
06127 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06128 return NULL;
06129 }
06130 arg3 = (PLFLT *) tmp3->data;
06131 }
06132 ecode4 = SWIG_AsVal_double(obj2, &val4);
06133 if (!SWIG_IsOK(ecode4)) {
06134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
06135 }
06136 arg4 = (PLFLT)(val4);
06137 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
06138 resultobj = SWIG_Py_Void();
06139 {
06140 Py_DECREF( tmp1 );
06141 }
06142 {
06143 Py_DECREF( tmp3 );
06144 }
06145 return resultobj;
06146 fail:
06147 {
06148 Py_DECREF( tmp1 );
06149 }
06150 {
06151 Py_DECREF( tmp3 );
06152 }
06153 return NULL;
06154 }
06155
06156
06157 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06158 PyObject *resultobj = 0;
06159
06160 if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
06161 plflush();
06162 resultobj = SWIG_Py_Void();
06163 return resultobj;
06164 fail:
06165 return NULL;
06166 }
06167
06168
06169 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06170 PyObject *resultobj = 0;
06171 PLINT arg1 ;
06172 int val1 ;
06173 int ecode1 = 0 ;
06174 PyObject * obj0 = 0 ;
06175
06176 if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
06177 ecode1 = SWIG_AsVal_int(obj0, &val1);
06178 if (!SWIG_IsOK(ecode1)) {
06179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
06180 }
06181 arg1 = (PLINT)(val1);
06182 plfont(arg1);
06183 resultobj = SWIG_Py_Void();
06184 return resultobj;
06185 fail:
06186 return NULL;
06187 }
06188
06189
06190 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06191 PyObject *resultobj = 0;
06192 PLINT arg1 ;
06193 int val1 ;
06194 int ecode1 = 0 ;
06195 PyObject * obj0 = 0 ;
06196
06197 if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
06198 ecode1 = SWIG_AsVal_int(obj0, &val1);
06199 if (!SWIG_IsOK(ecode1)) {
06200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
06201 }
06202 arg1 = (PLINT)(val1);
06203 plfontld(arg1);
06204 resultobj = SWIG_Py_Void();
06205 return resultobj;
06206 fail:
06207 return NULL;
06208 }
06209
06210
06211 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06212 PyObject *resultobj = 0;
06213 PLFLT *arg1 = (PLFLT *) 0 ;
06214 PLFLT *arg2 = (PLFLT *) 0 ;
06215 PLFLT temp1 ;
06216 int res1 = SWIG_TMPOBJ ;
06217 PLFLT temp2 ;
06218 int res2 = SWIG_TMPOBJ ;
06219
06220 arg1 = &temp1;
06221 arg2 = &temp2;
06222 if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
06223 plgchr(arg1,arg2);
06224 resultobj = SWIG_Py_Void();
06225 if (SWIG_IsTmpObj(res1)) {
06226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06227 } else {
06228 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06230 }
06231 if (SWIG_IsTmpObj(res2)) {
06232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06233 } else {
06234 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06236 }
06237 return resultobj;
06238 fail:
06239 return NULL;
06240 }
06241
06242
06243 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06244 PyObject *resultobj = 0;
06245 PLINT arg1 ;
06246 PLINT *arg2 = (PLINT *) 0 ;
06247 PLINT *arg3 = (PLINT *) 0 ;
06248 PLINT *arg4 = (PLINT *) 0 ;
06249 int val1 ;
06250 int ecode1 = 0 ;
06251 PLINT temp2 ;
06252 int res2 = SWIG_TMPOBJ ;
06253 PLINT temp3 ;
06254 int res3 = SWIG_TMPOBJ ;
06255 PLINT temp4 ;
06256 int res4 = SWIG_TMPOBJ ;
06257 PyObject * obj0 = 0 ;
06258
06259 arg2 = &temp2;
06260 arg3 = &temp3;
06261 arg4 = &temp4;
06262 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
06263 ecode1 = SWIG_AsVal_int(obj0, &val1);
06264 if (!SWIG_IsOK(ecode1)) {
06265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
06266 }
06267 arg1 = (PLINT)(val1);
06268 plgcol0(arg1,arg2,arg3,arg4);
06269 resultobj = SWIG_Py_Void();
06270 if (SWIG_IsTmpObj(res2)) {
06271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06272 } else {
06273 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06275 }
06276 if (SWIG_IsTmpObj(res3)) {
06277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06278 } else {
06279 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06281 }
06282 if (SWIG_IsTmpObj(res4)) {
06283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06284 } else {
06285 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06287 }
06288 return resultobj;
06289 fail:
06290 return NULL;
06291 }
06292
06293
06294 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06295 PyObject *resultobj = 0;
06296 PLINT arg1 ;
06297 PLINT *arg2 = (PLINT *) 0 ;
06298 PLINT *arg3 = (PLINT *) 0 ;
06299 PLINT *arg4 = (PLINT *) 0 ;
06300 PLFLT *arg5 = (PLFLT *) 0 ;
06301 int val1 ;
06302 int ecode1 = 0 ;
06303 PLINT temp2 ;
06304 int res2 = SWIG_TMPOBJ ;
06305 PLINT temp3 ;
06306 int res3 = SWIG_TMPOBJ ;
06307 PLINT temp4 ;
06308 int res4 = SWIG_TMPOBJ ;
06309 PLFLT temp5 ;
06310 int res5 = SWIG_TMPOBJ ;
06311 PyObject * obj0 = 0 ;
06312
06313 arg2 = &temp2;
06314 arg3 = &temp3;
06315 arg4 = &temp4;
06316 arg5 = &temp5;
06317 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
06318 ecode1 = SWIG_AsVal_int(obj0, &val1);
06319 if (!SWIG_IsOK(ecode1)) {
06320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
06321 }
06322 arg1 = (PLINT)(val1);
06323 plgcol0a(arg1,arg2,arg3,arg4,arg5);
06324 resultobj = SWIG_Py_Void();
06325 if (SWIG_IsTmpObj(res2)) {
06326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06327 } else {
06328 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06330 }
06331 if (SWIG_IsTmpObj(res3)) {
06332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06333 } else {
06334 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06336 }
06337 if (SWIG_IsTmpObj(res4)) {
06338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06339 } else {
06340 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06342 }
06343 if (SWIG_IsTmpObj(res5)) {
06344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
06345 } else {
06346 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
06348 }
06349 return resultobj;
06350 fail:
06351 return NULL;
06352 }
06353
06354
06355 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06356 PyObject *resultobj = 0;
06357 PLINT *arg1 = (PLINT *) 0 ;
06358 PLINT *arg2 = (PLINT *) 0 ;
06359 PLINT *arg3 = (PLINT *) 0 ;
06360 PLINT temp1 ;
06361 int res1 = SWIG_TMPOBJ ;
06362 PLINT temp2 ;
06363 int res2 = SWIG_TMPOBJ ;
06364 PLINT temp3 ;
06365 int res3 = SWIG_TMPOBJ ;
06366
06367 arg1 = &temp1;
06368 arg2 = &temp2;
06369 arg3 = &temp3;
06370 if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
06371 plgcolbg(arg1,arg2,arg3);
06372 resultobj = SWIG_Py_Void();
06373 if (SWIG_IsTmpObj(res1)) {
06374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06375 } else {
06376 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06378 }
06379 if (SWIG_IsTmpObj(res2)) {
06380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06381 } else {
06382 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06384 }
06385 if (SWIG_IsTmpObj(res3)) {
06386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06387 } else {
06388 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06390 }
06391 return resultobj;
06392 fail:
06393 return NULL;
06394 }
06395
06396
06397 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06398 PyObject *resultobj = 0;
06399 PLINT *arg1 = (PLINT *) 0 ;
06400 PLINT *arg2 = (PLINT *) 0 ;
06401 PLINT *arg3 = (PLINT *) 0 ;
06402 PLFLT *arg4 = (PLFLT *) 0 ;
06403 PLINT temp1 ;
06404 int res1 = SWIG_TMPOBJ ;
06405 PLINT temp2 ;
06406 int res2 = SWIG_TMPOBJ ;
06407 PLINT temp3 ;
06408 int res3 = SWIG_TMPOBJ ;
06409 PLFLT temp4 ;
06410 int res4 = SWIG_TMPOBJ ;
06411
06412 arg1 = &temp1;
06413 arg2 = &temp2;
06414 arg3 = &temp3;
06415 arg4 = &temp4;
06416 if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
06417 plgcolbga(arg1,arg2,arg3,arg4);
06418 resultobj = SWIG_Py_Void();
06419 if (SWIG_IsTmpObj(res1)) {
06420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06421 } else {
06422 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06424 }
06425 if (SWIG_IsTmpObj(res2)) {
06426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06427 } else {
06428 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06430 }
06431 if (SWIG_IsTmpObj(res3)) {
06432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06433 } else {
06434 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06436 }
06437 if (SWIG_IsTmpObj(res4)) {
06438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06439 } else {
06440 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06442 }
06443 return resultobj;
06444 fail:
06445 return NULL;
06446 }
06447
06448
06449 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06450 PyObject *resultobj = 0;
06451 PLINT *arg1 = (PLINT *) 0 ;
06452 PLINT temp1 ;
06453 int res1 = SWIG_TMPOBJ ;
06454
06455 arg1 = &temp1;
06456 if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
06457 plgcompression(arg1);
06458 resultobj = SWIG_Py_Void();
06459 if (SWIG_IsTmpObj(res1)) {
06460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06461 } else {
06462 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06464 }
06465 return resultobj;
06466 fail:
06467 return NULL;
06468 }
06469
06470
06471 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06472 PyObject *resultobj = 0;
06473 char *arg1 = (char *) 0 ;
06474 char buff1[1000] ;
06475
06476 {
06477 arg1 = buff1;
06478 }
06479 if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
06480 plgdev(arg1);
06481 resultobj = SWIG_Py_Void();
06482 {
06483 PyObject *o = PyString_FromString( arg1 );
06484 resultobj = t_output_helper( resultobj, o );
06485 }
06486 return resultobj;
06487 fail:
06488 return NULL;
06489 }
06490
06491
06492 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06493 PyObject *resultobj = 0;
06494 PLFLT *arg1 = (PLFLT *) 0 ;
06495 PLFLT *arg2 = (PLFLT *) 0 ;
06496 PLFLT *arg3 = (PLFLT *) 0 ;
06497 PLFLT *arg4 = (PLFLT *) 0 ;
06498 PLFLT temp1 ;
06499 int res1 = SWIG_TMPOBJ ;
06500 PLFLT temp2 ;
06501 int res2 = SWIG_TMPOBJ ;
06502 PLFLT temp3 ;
06503 int res3 = SWIG_TMPOBJ ;
06504 PLFLT temp4 ;
06505 int res4 = SWIG_TMPOBJ ;
06506
06507 arg1 = &temp1;
06508 arg2 = &temp2;
06509 arg3 = &temp3;
06510 arg4 = &temp4;
06511 if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
06512 plgdidev(arg1,arg2,arg3,arg4);
06513 resultobj = SWIG_Py_Void();
06514 if (SWIG_IsTmpObj(res1)) {
06515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06516 } else {
06517 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06519 }
06520 if (SWIG_IsTmpObj(res2)) {
06521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06522 } else {
06523 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06525 }
06526 if (SWIG_IsTmpObj(res3)) {
06527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
06528 } else {
06529 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
06531 }
06532 if (SWIG_IsTmpObj(res4)) {
06533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06534 } else {
06535 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06537 }
06538 return resultobj;
06539 fail:
06540 return NULL;
06541 }
06542
06543
06544 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06545 PyObject *resultobj = 0;
06546 PLFLT *arg1 = (PLFLT *) 0 ;
06547 PLFLT temp1 ;
06548 int res1 = SWIG_TMPOBJ ;
06549
06550 arg1 = &temp1;
06551 if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
06552 plgdiori(arg1);
06553 resultobj = SWIG_Py_Void();
06554 if (SWIG_IsTmpObj(res1)) {
06555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06556 } else {
06557 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06559 }
06560 return resultobj;
06561 fail:
06562 return NULL;
06563 }
06564
06565
06566 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06567 PyObject *resultobj = 0;
06568 PLFLT *arg1 = (PLFLT *) 0 ;
06569 PLFLT *arg2 = (PLFLT *) 0 ;
06570 PLFLT *arg3 = (PLFLT *) 0 ;
06571 PLFLT *arg4 = (PLFLT *) 0 ;
06572 PLFLT temp1 ;
06573 int res1 = SWIG_TMPOBJ ;
06574 PLFLT temp2 ;
06575 int res2 = SWIG_TMPOBJ ;
06576 PLFLT temp3 ;
06577 int res3 = SWIG_TMPOBJ ;
06578 PLFLT temp4 ;
06579 int res4 = SWIG_TMPOBJ ;
06580
06581 arg1 = &temp1;
06582 arg2 = &temp2;
06583 arg3 = &temp3;
06584 arg4 = &temp4;
06585 if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
06586 plgdiplt(arg1,arg2,arg3,arg4);
06587 resultobj = SWIG_Py_Void();
06588 if (SWIG_IsTmpObj(res1)) {
06589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06590 } else {
06591 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06593 }
06594 if (SWIG_IsTmpObj(res2)) {
06595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06596 } else {
06597 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06599 }
06600 if (SWIG_IsTmpObj(res3)) {
06601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
06602 } else {
06603 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06604 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
06605 }
06606 if (SWIG_IsTmpObj(res4)) {
06607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06608 } else {
06609 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06611 }
06612 return resultobj;
06613 fail:
06614 return NULL;
06615 }
06616
06617
06618 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06619 PyObject *resultobj = 0;
06620 PLINT *arg1 = (PLINT *) 0 ;
06621 PLINT *arg2 = (PLINT *) 0 ;
06622 PLINT *arg3 = (PLINT *) 0 ;
06623 PLINT temp1 ;
06624 int res1 = SWIG_TMPOBJ ;
06625 PLINT temp2 ;
06626 int res2 = SWIG_TMPOBJ ;
06627 PLINT temp3 ;
06628 int res3 = SWIG_TMPOBJ ;
06629
06630 arg1 = &temp1;
06631 arg2 = &temp2;
06632 arg3 = &temp3;
06633 if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
06634 plgfam(arg1,arg2,arg3);
06635 resultobj = SWIG_Py_Void();
06636 if (SWIG_IsTmpObj(res1)) {
06637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06638 } else {
06639 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06641 }
06642 if (SWIG_IsTmpObj(res2)) {
06643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06644 } else {
06645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06647 }
06648 if (SWIG_IsTmpObj(res3)) {
06649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06650 } else {
06651 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06653 }
06654 return resultobj;
06655 fail:
06656 return NULL;
06657 }
06658
06659
06660 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06661 PyObject *resultobj = 0;
06662 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
06663 PLUNICODE temp1 ;
06664 int res1 = SWIG_TMPOBJ ;
06665
06666 arg1 = &temp1;
06667 if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
06668 plgfci(arg1);
06669 resultobj = SWIG_Py_Void();
06670 if (SWIG_IsTmpObj(res1)) {
06671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
06672 } else {
06673 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
06675 }
06676 return resultobj;
06677 fail:
06678 return NULL;
06679 }
06680
06681
06682 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06683 PyObject *resultobj = 0;
06684 char *arg1 = (char *) 0 ;
06685 char buff1[1000] ;
06686
06687 {
06688 arg1 = buff1;
06689 }
06690 if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
06691 plgfnam(arg1);
06692 resultobj = SWIG_Py_Void();
06693 {
06694 PyObject *o = PyString_FromString( arg1 );
06695 resultobj = t_output_helper( resultobj, o );
06696 }
06697 return resultobj;
06698 fail:
06699 return NULL;
06700 }
06701
06702
06703 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06704 PyObject *resultobj = 0;
06705 PLINT *arg1 = (PLINT *) 0 ;
06706 PLINT *arg2 = (PLINT *) 0 ;
06707 PLINT *arg3 = (PLINT *) 0 ;
06708 PLINT temp1 ;
06709 int res1 = SWIG_TMPOBJ ;
06710 PLINT temp2 ;
06711 int res2 = SWIG_TMPOBJ ;
06712 PLINT temp3 ;
06713 int res3 = SWIG_TMPOBJ ;
06714
06715 arg1 = &temp1;
06716 arg2 = &temp2;
06717 arg3 = &temp3;
06718 if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
06719 plgfont(arg1,arg2,arg3);
06720 resultobj = SWIG_Py_Void();
06721 if (SWIG_IsTmpObj(res1)) {
06722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06723 } else {
06724 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06726 }
06727 if (SWIG_IsTmpObj(res2)) {
06728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06729 } else {
06730 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06732 }
06733 if (SWIG_IsTmpObj(res3)) {
06734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06735 } else {
06736 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06738 }
06739 return resultobj;
06740 fail:
06741 return NULL;
06742 }
06743
06744
06745 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06746 PyObject *resultobj = 0;
06747 PLINT *arg1 = (PLINT *) 0 ;
06748 PLINT temp1 ;
06749 int res1 = SWIG_TMPOBJ ;
06750
06751 arg1 = &temp1;
06752 if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
06753 plglevel(arg1);
06754 resultobj = SWIG_Py_Void();
06755 if (SWIG_IsTmpObj(res1)) {
06756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06757 } else {
06758 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06760 }
06761 return resultobj;
06762 fail:
06763 return NULL;
06764 }
06765
06766
06767 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06768 PyObject *resultobj = 0;
06769 PLFLT *arg1 = (PLFLT *) 0 ;
06770 PLFLT *arg2 = (PLFLT *) 0 ;
06771 PLINT *arg3 = (PLINT *) 0 ;
06772 PLINT *arg4 = (PLINT *) 0 ;
06773 PLINT *arg5 = (PLINT *) 0 ;
06774 PLINT *arg6 = (PLINT *) 0 ;
06775 PLFLT temp1 ;
06776 int res1 = SWIG_TMPOBJ ;
06777 PLFLT temp2 ;
06778 int res2 = SWIG_TMPOBJ ;
06779 PLINT temp3 ;
06780 int res3 = SWIG_TMPOBJ ;
06781 PLINT temp4 ;
06782 int res4 = SWIG_TMPOBJ ;
06783 PLINT temp5 ;
06784 int res5 = SWIG_TMPOBJ ;
06785 PLINT temp6 ;
06786 int res6 = SWIG_TMPOBJ ;
06787
06788 arg1 = &temp1;
06789 arg2 = &temp2;
06790 arg3 = &temp3;
06791 arg4 = &temp4;
06792 arg5 = &temp5;
06793 arg6 = &temp6;
06794 if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
06795 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
06796 resultobj = SWIG_Py_Void();
06797 if (SWIG_IsTmpObj(res1)) {
06798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06799 } else {
06800 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06802 }
06803 if (SWIG_IsTmpObj(res2)) {
06804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06805 } else {
06806 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06808 }
06809 if (SWIG_IsTmpObj(res3)) {
06810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06811 } else {
06812 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06814 }
06815 if (SWIG_IsTmpObj(res4)) {
06816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06817 } else {
06818 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06820 }
06821 if (SWIG_IsTmpObj(res5)) {
06822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
06823 } else {
06824 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
06826 }
06827 if (SWIG_IsTmpObj(res6)) {
06828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
06829 } else {
06830 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
06831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
06832 }
06833 return resultobj;
06834 fail:
06835 return NULL;
06836 }
06837
06838
06839 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06840 PyObject *resultobj = 0;
06841
06842 if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
06843 plgra();
06844 resultobj = SWIG_Py_Void();
06845 return resultobj;
06846 fail:
06847 return NULL;
06848 }
06849
06850
06851 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06852 PyObject *resultobj = 0;
06853 PLFLT *arg1 = (PLFLT *) 0 ;
06854 PLFLT *arg2 = (PLFLT *) 0 ;
06855 PLFLT *arg3 = (PLFLT *) 0 ;
06856 PLINT arg4 ;
06857 PLFLT *arg5 = (PLFLT *) 0 ;
06858 PLINT arg6 ;
06859 PLFLT *arg7 = (PLFLT *) 0 ;
06860 PLINT arg8 ;
06861 PLFLT **arg9 = (PLFLT **) 0 ;
06862 PLINT arg10 ;
06863 PLFLT arg11 ;
06864 PyArrayObject *tmp1 ;
06865 PyArrayObject *tmp2 ;
06866 PyArrayObject *tmp3 ;
06867 PyArrayObject *tmp5 ;
06868 PyArrayObject *tmp7 ;
06869 PyArrayObject *tmp9 ;
06870 int val10 ;
06871 int ecode10 = 0 ;
06872 double val11 ;
06873 int ecode11 = 0 ;
06874 PyObject * obj0 = 0 ;
06875 PyObject * obj1 = 0 ;
06876 PyObject * obj2 = 0 ;
06877 PyObject * obj3 = 0 ;
06878 PyObject * obj4 = 0 ;
06879 PyObject * obj5 = 0 ;
06880 PyObject * obj6 = 0 ;
06881 PyObject * obj7 = 0 ;
06882
06883 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
06884 {
06885 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
06886 if ( tmp1 == NULL )
06887 return NULL;
06888 Alen = tmp1->dimensions[0];
06889 arg1 = (PLFLT *) tmp1->data;
06890 }
06891 {
06892 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06893 if ( tmp2 == NULL )
06894 return NULL;
06895 if ( tmp2->dimensions[0] != Alen )
06896 {
06897 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06898 return NULL;
06899 }
06900 arg2 = (PLFLT *) tmp2->data;
06901 }
06902 {
06903 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
06904 if ( tmp3 == NULL )
06905 return NULL;
06906 if ( tmp3->dimensions[0] != Alen )
06907 {
06908 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06909 return NULL;
06910 }
06911 arg3 = (PLFLT *) tmp3->data;
06912 arg4 = tmp3->dimensions[0];
06913 }
06914 {
06915 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
06916 if ( tmp5 == NULL )
06917 return NULL;
06918 Xlen = tmp5->dimensions[0];
06919 arg6 = Xlen;
06920 arg5 = (PLFLT *) tmp5->data;
06921 }
06922 {
06923 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
06924 if ( tmp7 == NULL )
06925 return NULL;
06926 Ylen = tmp7->dimensions[0];
06927 arg8 = Ylen;
06928 arg7 = (PLFLT *) tmp7->data;
06929 }
06930 {
06931 int i, size;
06932 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 2, 2 );
06933 if ( tmp9 == NULL )
06934 return NULL;
06935 if ( tmp9->dimensions[0] != Xlen || tmp9->dimensions[1] != Ylen )
06936 {
06937 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
06938 return NULL;
06939 }
06940 size = sizeof ( PLFLT ) * Ylen;
06941 arg9 = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
06942 for ( i = 0; i < Xlen; i++ )
06943 arg9[i] = (PLFLT *) ( tmp9->data + i * size );
06944 }
06945 ecode10 = SWIG_AsVal_int(obj6, &val10);
06946 if (!SWIG_IsOK(ecode10)) {
06947 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
06948 }
06949 arg10 = (PLINT)(val10);
06950 ecode11 = SWIG_AsVal_double(obj7, &val11);
06951 if (!SWIG_IsOK(ecode11)) {
06952 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
06953 }
06954 arg11 = (PLFLT)(val11);
06955 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
06956 resultobj = SWIG_Py_Void();
06957 {
06958 Py_DECREF( tmp1 );
06959 }
06960 {
06961 Py_DECREF( tmp2 );
06962 }
06963 {
06964 Py_DECREF( tmp3 );
06965 }
06966 {
06967 Py_DECREF( tmp5 );
06968 }
06969 {
06970 Py_DECREF( tmp7 );
06971 }
06972 {
06973 Py_DECREF( tmp9 );
06974 free( arg9 );
06975 }
06976 return resultobj;
06977 fail:
06978 {
06979 Py_DECREF( tmp1 );
06980 }
06981 {
06982 Py_DECREF( tmp2 );
06983 }
06984 {
06985 Py_DECREF( tmp3 );
06986 }
06987 {
06988 Py_DECREF( tmp5 );
06989 }
06990 {
06991 Py_DECREF( tmp7 );
06992 }
06993 {
06994 Py_DECREF( tmp9 );
06995 free( arg9 );
06996 }
06997 return NULL;
06998 }
06999
07000
07001 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07002 PyObject *resultobj = 0;
07003 PLFLT *arg1 = (PLFLT *) 0 ;
07004 PLFLT *arg2 = (PLFLT *) 0 ;
07005 PLFLT *arg3 = (PLFLT *) 0 ;
07006 PLFLT *arg4 = (PLFLT *) 0 ;
07007 PLFLT temp1 ;
07008 int res1 = SWIG_TMPOBJ ;
07009 PLFLT temp2 ;
07010 int res2 = SWIG_TMPOBJ ;
07011 PLFLT temp3 ;
07012 int res3 = SWIG_TMPOBJ ;
07013 PLFLT temp4 ;
07014 int res4 = SWIG_TMPOBJ ;
07015
07016 arg1 = &temp1;
07017 arg2 = &temp2;
07018 arg3 = &temp3;
07019 arg4 = &temp4;
07020 if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
07021 plgspa(arg1,arg2,arg3,arg4);
07022 resultobj = SWIG_Py_Void();
07023 if (SWIG_IsTmpObj(res1)) {
07024 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07025 } else {
07026 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07028 }
07029 if (SWIG_IsTmpObj(res2)) {
07030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07031 } else {
07032 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07034 }
07035 if (SWIG_IsTmpObj(res3)) {
07036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07037 } else {
07038 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07040 }
07041 if (SWIG_IsTmpObj(res4)) {
07042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07043 } else {
07044 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07046 }
07047 return resultobj;
07048 fail:
07049 return NULL;
07050 }
07051
07052
07053 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07054 PyObject *resultobj = 0;
07055 PLINT *arg1 = (PLINT *) 0 ;
07056 PLINT temp1 ;
07057 int res1 = SWIG_TMPOBJ ;
07058
07059 arg1 = &temp1;
07060 if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
07061 plgstrm(arg1);
07062 resultobj = SWIG_Py_Void();
07063 if (SWIG_IsTmpObj(res1)) {
07064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07065 } else {
07066 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07068 }
07069 return resultobj;
07070 fail:
07071 return NULL;
07072 }
07073
07074
07075 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07076 PyObject *resultobj = 0;
07077 char *arg1 = (char *) 0 ;
07078 char buff1[1000] ;
07079
07080 {
07081 arg1 = buff1;
07082 }
07083 if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
07084 plgver(arg1);
07085 resultobj = SWIG_Py_Void();
07086 {
07087 PyObject *o = PyString_FromString( arg1 );
07088 resultobj = t_output_helper( resultobj, o );
07089 }
07090 return resultobj;
07091 fail:
07092 return NULL;
07093 }
07094
07095
07096 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07097 PyObject *resultobj = 0;
07098 PLFLT *arg1 = (PLFLT *) 0 ;
07099 PLFLT *arg2 = (PLFLT *) 0 ;
07100 PLFLT *arg3 = (PLFLT *) 0 ;
07101 PLFLT *arg4 = (PLFLT *) 0 ;
07102 PLFLT temp1 ;
07103 int res1 = SWIG_TMPOBJ ;
07104 PLFLT temp2 ;
07105 int res2 = SWIG_TMPOBJ ;
07106 PLFLT temp3 ;
07107 int res3 = SWIG_TMPOBJ ;
07108 PLFLT temp4 ;
07109 int res4 = SWIG_TMPOBJ ;
07110
07111 arg1 = &temp1;
07112 arg2 = &temp2;
07113 arg3 = &temp3;
07114 arg4 = &temp4;
07115 if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
07116 plgvpd(arg1,arg2,arg3,arg4);
07117 resultobj = SWIG_Py_Void();
07118 if (SWIG_IsTmpObj(res1)) {
07119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07120 } else {
07121 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07123 }
07124 if (SWIG_IsTmpObj(res2)) {
07125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07126 } else {
07127 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07129 }
07130 if (SWIG_IsTmpObj(res3)) {
07131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07132 } else {
07133 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07135 }
07136 if (SWIG_IsTmpObj(res4)) {
07137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07138 } else {
07139 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07140 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07141 }
07142 return resultobj;
07143 fail:
07144 return NULL;
07145 }
07146
07147
07148 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07149 PyObject *resultobj = 0;
07150 PLFLT *arg1 = (PLFLT *) 0 ;
07151 PLFLT *arg2 = (PLFLT *) 0 ;
07152 PLFLT *arg3 = (PLFLT *) 0 ;
07153 PLFLT *arg4 = (PLFLT *) 0 ;
07154 PLFLT temp1 ;
07155 int res1 = SWIG_TMPOBJ ;
07156 PLFLT temp2 ;
07157 int res2 = SWIG_TMPOBJ ;
07158 PLFLT temp3 ;
07159 int res3 = SWIG_TMPOBJ ;
07160 PLFLT temp4 ;
07161 int res4 = SWIG_TMPOBJ ;
07162
07163 arg1 = &temp1;
07164 arg2 = &temp2;
07165 arg3 = &temp3;
07166 arg4 = &temp4;
07167 if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
07168 plgvpw(arg1,arg2,arg3,arg4);
07169 resultobj = SWIG_Py_Void();
07170 if (SWIG_IsTmpObj(res1)) {
07171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07172 } else {
07173 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07175 }
07176 if (SWIG_IsTmpObj(res2)) {
07177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07178 } else {
07179 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07181 }
07182 if (SWIG_IsTmpObj(res3)) {
07183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07184 } else {
07185 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07187 }
07188 if (SWIG_IsTmpObj(res4)) {
07189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07190 } else {
07191 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07193 }
07194 return resultobj;
07195 fail:
07196 return NULL;
07197 }
07198
07199
07200 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07201 PyObject *resultobj = 0;
07202 PLINT *arg1 = (PLINT *) 0 ;
07203 PLINT *arg2 = (PLINT *) 0 ;
07204 PLINT temp1 ;
07205 int res1 = SWIG_TMPOBJ ;
07206 PLINT temp2 ;
07207 int res2 = SWIG_TMPOBJ ;
07208
07209 arg1 = &temp1;
07210 arg2 = &temp2;
07211 if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
07212 plgxax(arg1,arg2);
07213 resultobj = SWIG_Py_Void();
07214 if (SWIG_IsTmpObj(res1)) {
07215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07216 } else {
07217 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07219 }
07220 if (SWIG_IsTmpObj(res2)) {
07221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07222 } else {
07223 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07225 }
07226 return resultobj;
07227 fail:
07228 return NULL;
07229 }
07230
07231
07232 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07233 PyObject *resultobj = 0;
07234 PLINT *arg1 = (PLINT *) 0 ;
07235 PLINT *arg2 = (PLINT *) 0 ;
07236 PLINT temp1 ;
07237 int res1 = SWIG_TMPOBJ ;
07238 PLINT temp2 ;
07239 int res2 = SWIG_TMPOBJ ;
07240
07241 arg1 = &temp1;
07242 arg2 = &temp2;
07243 if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
07244 plgyax(arg1,arg2);
07245 resultobj = SWIG_Py_Void();
07246 if (SWIG_IsTmpObj(res1)) {
07247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07248 } else {
07249 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07251 }
07252 if (SWIG_IsTmpObj(res2)) {
07253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07254 } else {
07255 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07257 }
07258 return resultobj;
07259 fail:
07260 return NULL;
07261 }
07262
07263
07264 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07265 PyObject *resultobj = 0;
07266 PLINT *arg1 = (PLINT *) 0 ;
07267 PLINT *arg2 = (PLINT *) 0 ;
07268 PLINT temp1 ;
07269 int res1 = SWIG_TMPOBJ ;
07270 PLINT temp2 ;
07271 int res2 = SWIG_TMPOBJ ;
07272
07273 arg1 = &temp1;
07274 arg2 = &temp2;
07275 if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
07276 plgzax(arg1,arg2);
07277 resultobj = SWIG_Py_Void();
07278 if (SWIG_IsTmpObj(res1)) {
07279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07280 } else {
07281 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07283 }
07284 if (SWIG_IsTmpObj(res2)) {
07285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07286 } else {
07287 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07289 }
07290 return resultobj;
07291 fail:
07292 return NULL;
07293 }
07294
07295
07296 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07297 PyObject *resultobj = 0;
07298 PLINT arg1 ;
07299 PLFLT *arg2 = (PLFLT *) 0 ;
07300 PLFLT arg3 ;
07301 PLFLT arg4 ;
07302 PLINT arg5 ;
07303 PLINT arg6 ;
07304 PyArrayObject *tmp1 ;
07305 double val3 ;
07306 int ecode3 = 0 ;
07307 double val4 ;
07308 int ecode4 = 0 ;
07309 int val5 ;
07310 int ecode5 = 0 ;
07311 int val6 ;
07312 int ecode6 = 0 ;
07313 PyObject * obj0 = 0 ;
07314 PyObject * obj1 = 0 ;
07315 PyObject * obj2 = 0 ;
07316 PyObject * obj3 = 0 ;
07317 PyObject * obj4 = 0 ;
07318
07319 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
07320 {
07321 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
07322 if ( tmp1 == NULL )
07323 return NULL;
07324 arg1 = Alen = tmp1->dimensions[0];
07325 arg2 = (PLFLT *) tmp1->data;
07326 }
07327 ecode3 = SWIG_AsVal_double(obj1, &val3);
07328 if (!SWIG_IsOK(ecode3)) {
07329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
07330 }
07331 arg3 = (PLFLT)(val3);
07332 ecode4 = SWIG_AsVal_double(obj2, &val4);
07333 if (!SWIG_IsOK(ecode4)) {
07334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
07335 }
07336 arg4 = (PLFLT)(val4);
07337 ecode5 = SWIG_AsVal_int(obj3, &val5);
07338 if (!SWIG_IsOK(ecode5)) {
07339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
07340 }
07341 arg5 = (PLINT)(val5);
07342 ecode6 = SWIG_AsVal_int(obj4, &val6);
07343 if (!SWIG_IsOK(ecode6)) {
07344 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
07345 }
07346 arg6 = (PLINT)(val6);
07347 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
07348 resultobj = SWIG_Py_Void();
07349 {
07350 Py_DECREF( tmp1 );
07351 }
07352 return resultobj;
07353 fail:
07354 {
07355 Py_DECREF( tmp1 );
07356 }
07357 return NULL;
07358 }
07359
07360
07361 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07362 PyObject *resultobj = 0;
07363 PLFLT arg1 ;
07364 PLFLT arg2 ;
07365 PLFLT arg3 ;
07366 PLFLT *arg4 = (PLFLT *) 0 ;
07367 PLFLT *arg5 = (PLFLT *) 0 ;
07368 PLFLT *arg6 = (PLFLT *) 0 ;
07369 double val1 ;
07370 int ecode1 = 0 ;
07371 double val2 ;
07372 int ecode2 = 0 ;
07373 double val3 ;
07374 int ecode3 = 0 ;
07375 PLFLT temp4 ;
07376 int res4 = SWIG_TMPOBJ ;
07377 PLFLT temp5 ;
07378 int res5 = SWIG_TMPOBJ ;
07379 PLFLT temp6 ;
07380 int res6 = SWIG_TMPOBJ ;
07381 PyObject * obj0 = 0 ;
07382 PyObject * obj1 = 0 ;
07383 PyObject * obj2 = 0 ;
07384
07385 arg4 = &temp4;
07386 arg5 = &temp5;
07387 arg6 = &temp6;
07388 if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
07389 ecode1 = SWIG_AsVal_double(obj0, &val1);
07390 if (!SWIG_IsOK(ecode1)) {
07391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
07392 }
07393 arg1 = (PLFLT)(val1);
07394 ecode2 = SWIG_AsVal_double(obj1, &val2);
07395 if (!SWIG_IsOK(ecode2)) {
07396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
07397 }
07398 arg2 = (PLFLT)(val2);
07399 ecode3 = SWIG_AsVal_double(obj2, &val3);
07400 if (!SWIG_IsOK(ecode3)) {
07401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
07402 }
07403 arg3 = (PLFLT)(val3);
07404 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
07405 resultobj = SWIG_Py_Void();
07406 if (SWIG_IsTmpObj(res4)) {
07407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07408 } else {
07409 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07411 }
07412 if (SWIG_IsTmpObj(res5)) {
07413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
07414 } else {
07415 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
07417 }
07418 if (SWIG_IsTmpObj(res6)) {
07419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
07420 } else {
07421 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
07423 }
07424 return resultobj;
07425 fail:
07426 return NULL;
07427 }
07428
07429
07430 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07431 PyObject *resultobj = 0;
07432
07433 if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
07434 plinit();
07435 resultobj = SWIG_Py_Void();
07436 return resultobj;
07437 fail:
07438 return NULL;
07439 }
07440
07441
07442 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07443 PyObject *resultobj = 0;
07444 PLFLT arg1 ;
07445 PLFLT arg2 ;
07446 PLFLT arg3 ;
07447 PLFLT arg4 ;
07448 double val1 ;
07449 int ecode1 = 0 ;
07450 double val2 ;
07451 int ecode2 = 0 ;
07452 double val3 ;
07453 int ecode3 = 0 ;
07454 double val4 ;
07455 int ecode4 = 0 ;
07456 PyObject * obj0 = 0 ;
07457 PyObject * obj1 = 0 ;
07458 PyObject * obj2 = 0 ;
07459 PyObject * obj3 = 0 ;
07460
07461 if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
07462 ecode1 = SWIG_AsVal_double(obj0, &val1);
07463 if (!SWIG_IsOK(ecode1)) {
07464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
07465 }
07466 arg1 = (PLFLT)(val1);
07467 ecode2 = SWIG_AsVal_double(obj1, &val2);
07468 if (!SWIG_IsOK(ecode2)) {
07469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
07470 }
07471 arg2 = (PLFLT)(val2);
07472 ecode3 = SWIG_AsVal_double(obj2, &val3);
07473 if (!SWIG_IsOK(ecode3)) {
07474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
07475 }
07476 arg3 = (PLFLT)(val3);
07477 ecode4 = SWIG_AsVal_double(obj3, &val4);
07478 if (!SWIG_IsOK(ecode4)) {
07479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
07480 }
07481 arg4 = (PLFLT)(val4);
07482 pljoin(arg1,arg2,arg3,arg4);
07483 resultobj = SWIG_Py_Void();
07484 return resultobj;
07485 fail:
07486 return NULL;
07487 }
07488
07489
07490 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07491 PyObject *resultobj = 0;
07492 char *arg1 = (char *) 0 ;
07493 char *arg2 = (char *) 0 ;
07494 char *arg3 = (char *) 0 ;
07495 int res1 ;
07496 char *buf1 = 0 ;
07497 int alloc1 = 0 ;
07498 int res2 ;
07499 char *buf2 = 0 ;
07500 int alloc2 = 0 ;
07501 int res3 ;
07502 char *buf3 = 0 ;
07503 int alloc3 = 0 ;
07504 PyObject * obj0 = 0 ;
07505 PyObject * obj1 = 0 ;
07506 PyObject * obj2 = 0 ;
07507
07508 if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
07509 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
07510 if (!SWIG_IsOK(res1)) {
07511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
07512 }
07513 arg1 = (char *)(buf1);
07514 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
07515 if (!SWIG_IsOK(res2)) {
07516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
07517 }
07518 arg2 = (char *)(buf2);
07519 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
07520 if (!SWIG_IsOK(res3)) {
07521 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
07522 }
07523 arg3 = (char *)(buf3);
07524 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
07525 resultobj = SWIG_Py_Void();
07526 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
07527 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
07528 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
07529 return resultobj;
07530 fail:
07531 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
07532 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
07533 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
07534 return NULL;
07535 }
07536
07537
07538 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07539 PyObject *resultobj = 0;
07540 PLFLT *arg1 = (PLFLT *) 0 ;
07541 PLFLT *arg2 = (PLFLT *) 0 ;
07542 PLINT arg3 ;
07543 PLINT arg4 ;
07544 PLFLT arg5 ;
07545 PLFLT arg6 ;
07546 PLFLT arg7 ;
07547 PLINT arg8 ;
07548 PLINT arg9 ;
07549 PLINT arg10 ;
07550 PLINT arg11 ;
07551 PLINT arg12 ;
07552 PLINT arg13 ;
07553 PLINT *arg14 = (PLINT *) 0 ;
07554 PLFLT arg15 ;
07555 PLFLT arg16 ;
07556 PLFLT arg17 ;
07557 PLFLT arg18 ;
07558 PLINT *arg19 = (PLINT *) 0 ;
07559 char **arg20 = (char **) 0 ;
07560 PLINT *arg21 = (PLINT *) 0 ;
07561 PLINT *arg22 = (PLINT *) 0 ;
07562 PLFLT *arg23 = (PLFLT *) 0 ;
07563 PLINT *arg24 = (PLINT *) 0 ;
07564 PLINT *arg25 = (PLINT *) 0 ;
07565 PLINT *arg26 = (PLINT *) 0 ;
07566 PLINT *arg27 = (PLINT *) 0 ;
07567 PLINT *arg28 = (PLINT *) 0 ;
07568 PLFLT *arg29 = (PLFLT *) 0 ;
07569 PLINT *arg30 = (PLINT *) 0 ;
07570 char **arg31 = (char **) 0 ;
07571 PLFLT temp1 ;
07572 int res1 = SWIG_TMPOBJ ;
07573 PLFLT temp2 ;
07574 int res2 = SWIG_TMPOBJ ;
07575 int val3 ;
07576 int ecode3 = 0 ;
07577 int val4 ;
07578 int ecode4 = 0 ;
07579 double val5 ;
07580 int ecode5 = 0 ;
07581 double val6 ;
07582 int ecode6 = 0 ;
07583 double val7 ;
07584 int ecode7 = 0 ;
07585 int val8 ;
07586 int ecode8 = 0 ;
07587 int val9 ;
07588 int ecode9 = 0 ;
07589 int val10 ;
07590 int ecode10 = 0 ;
07591 int val11 ;
07592 int ecode11 = 0 ;
07593 int val12 ;
07594 int ecode12 = 0 ;
07595 PyArrayObject *tmp13 ;
07596 double val15 ;
07597 int ecode15 = 0 ;
07598 double val16 ;
07599 int ecode16 = 0 ;
07600 double val17 ;
07601 int ecode17 = 0 ;
07602 double val18 ;
07603 int ecode18 = 0 ;
07604 PyArrayObject *tmp19 ;
07605 PyArrayObject *tmp20 ;
07606 PyArrayObject *tmp21 ;
07607 PyArrayObject *tmp22 ;
07608 PyArrayObject *tmp23 ;
07609 PyArrayObject *tmp24 ;
07610 PyArrayObject *tmp25 ;
07611 PyArrayObject *tmp26 ;
07612 PyArrayObject *tmp27 ;
07613 PyArrayObject *tmp28 ;
07614 PyArrayObject *tmp29 ;
07615 PyArrayObject *tmp30 ;
07616 PyArrayObject *tmp31 ;
07617 PyObject * obj0 = 0 ;
07618 PyObject * obj1 = 0 ;
07619 PyObject * obj2 = 0 ;
07620 PyObject * obj3 = 0 ;
07621 PyObject * obj4 = 0 ;
07622 PyObject * obj5 = 0 ;
07623 PyObject * obj6 = 0 ;
07624 PyObject * obj7 = 0 ;
07625 PyObject * obj8 = 0 ;
07626 PyObject * obj9 = 0 ;
07627 PyObject * obj10 = 0 ;
07628 PyObject * obj11 = 0 ;
07629 PyObject * obj12 = 0 ;
07630 PyObject * obj13 = 0 ;
07631 PyObject * obj14 = 0 ;
07632 PyObject * obj15 = 0 ;
07633 PyObject * obj16 = 0 ;
07634 PyObject * obj17 = 0 ;
07635 PyObject * obj18 = 0 ;
07636 PyObject * obj19 = 0 ;
07637 PyObject * obj20 = 0 ;
07638 PyObject * obj21 = 0 ;
07639 PyObject * obj22 = 0 ;
07640 PyObject * obj23 = 0 ;
07641 PyObject * obj24 = 0 ;
07642 PyObject * obj25 = 0 ;
07643 PyObject * obj26 = 0 ;
07644 PyObject * obj27 = 0 ;
07645
07646 arg1 = &temp1;
07647 arg2 = &temp2;
07648 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;
07649 ecode3 = SWIG_AsVal_int(obj0, &val3);
07650 if (!SWIG_IsOK(ecode3)) {
07651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
07652 }
07653 arg3 = (PLINT)(val3);
07654 ecode4 = SWIG_AsVal_int(obj1, &val4);
07655 if (!SWIG_IsOK(ecode4)) {
07656 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
07657 }
07658 arg4 = (PLINT)(val4);
07659 ecode5 = SWIG_AsVal_double(obj2, &val5);
07660 if (!SWIG_IsOK(ecode5)) {
07661 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
07662 }
07663 arg5 = (PLFLT)(val5);
07664 ecode6 = SWIG_AsVal_double(obj3, &val6);
07665 if (!SWIG_IsOK(ecode6)) {
07666 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
07667 }
07668 arg6 = (PLFLT)(val6);
07669 ecode7 = SWIG_AsVal_double(obj4, &val7);
07670 if (!SWIG_IsOK(ecode7)) {
07671 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
07672 }
07673 arg7 = (PLFLT)(val7);
07674 ecode8 = SWIG_AsVal_int(obj5, &val8);
07675 if (!SWIG_IsOK(ecode8)) {
07676 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
07677 }
07678 arg8 = (PLINT)(val8);
07679 ecode9 = SWIG_AsVal_int(obj6, &val9);
07680 if (!SWIG_IsOK(ecode9)) {
07681 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
07682 }
07683 arg9 = (PLINT)(val9);
07684 ecode10 = SWIG_AsVal_int(obj7, &val10);
07685 if (!SWIG_IsOK(ecode10)) {
07686 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
07687 }
07688 arg10 = (PLINT)(val10);
07689 ecode11 = SWIG_AsVal_int(obj8, &val11);
07690 if (!SWIG_IsOK(ecode11)) {
07691 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
07692 }
07693 arg11 = (PLINT)(val11);
07694 ecode12 = SWIG_AsVal_int(obj9, &val12);
07695 if (!SWIG_IsOK(ecode12)) {
07696 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
07697 }
07698 arg12 = (PLINT)(val12);
07699 {
07700 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, PyArray_PLINT, 1, 1 );
07701 if ( tmp13 == NULL )
07702 return NULL;
07703 arg13 = Alen = tmp13->dimensions[0];
07704 arg14 = (PLINT *) tmp13->data;
07705 }
07706 ecode15 = SWIG_AsVal_double(obj11, &val15);
07707 if (!SWIG_IsOK(ecode15)) {
07708 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
07709 }
07710 arg15 = (PLFLT)(val15);
07711 ecode16 = SWIG_AsVal_double(obj12, &val16);
07712 if (!SWIG_IsOK(ecode16)) {
07713 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
07714 }
07715 arg16 = (PLFLT)(val16);
07716 ecode17 = SWIG_AsVal_double(obj13, &val17);
07717 if (!SWIG_IsOK(ecode17)) {
07718 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
07719 }
07720 arg17 = (PLFLT)(val17);
07721 ecode18 = SWIG_AsVal_double(obj14, &val18);
07722 if (!SWIG_IsOK(ecode18)) {
07723 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
07724 }
07725 arg18 = (PLFLT)(val18);
07726 {
07727 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, PyArray_PLINT, 1, 1 );
07728 if ( tmp19 == NULL )
07729 return NULL;
07730 if ( tmp19->dimensions[0] != Alen )
07731 {
07732 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07733 return NULL;
07734 }
07735 arg19 = (PLINT *) tmp19->data;
07736 }
07737 {
07738 int i;
07739 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
07740 if ( tmp20 == NULL )
07741 return NULL;
07742 if ( tmp20->dimensions[0] != Alen )
07743 {
07744 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07745 return NULL;
07746 }
07747 arg20 = (char **) malloc( sizeof ( char* ) * Alen );
07748 for ( i = 0; i < Alen; i++ )
07749 {
07750 arg20[i] = tmp20->data + i * tmp20->strides[0];
07751 if ( arg20[i] == NULL )
07752 {
07753 free( arg20 );
07754 return NULL;
07755 }
07756 }
07757 }
07758 {
07759 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, PyArray_PLINT, 1, 1 );
07760 if ( tmp21 == NULL )
07761 return NULL;
07762 if ( tmp21->dimensions[0] != Alen )
07763 {
07764 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07765 return NULL;
07766 }
07767 arg21 = (PLINT *) tmp21->data;
07768 }
07769 {
07770 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, PyArray_PLINT, 1, 1 );
07771 if ( tmp22 == NULL )
07772 return NULL;
07773 if ( tmp22->dimensions[0] != Alen )
07774 {
07775 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07776 return NULL;
07777 }
07778 arg22 = (PLINT *) tmp22->data;
07779 }
07780 {
07781 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, PyArray_PLFLT, 1, 1 );
07782 if ( tmp23 == NULL )
07783 return NULL;
07784 if ( tmp23->dimensions[0] != Alen )
07785 {
07786 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07787 return NULL;
07788 }
07789 arg23 = (PLFLT *) tmp23->data;
07790 }
07791 {
07792 tmp24 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj20, PyArray_PLINT, 1, 1 );
07793 if ( tmp24 == NULL )
07794 return NULL;
07795 if ( tmp24->dimensions[0] != Alen )
07796 {
07797 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07798 return NULL;
07799 }
07800 arg24 = (PLINT *) tmp24->data;
07801 }
07802 {
07803 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, PyArray_PLINT, 1, 1 );
07804 if ( tmp25 == NULL )
07805 return NULL;
07806 if ( tmp25->dimensions[0] != Alen )
07807 {
07808 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07809 return NULL;
07810 }
07811 arg25 = (PLINT *) tmp25->data;
07812 }
07813 {
07814 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, PyArray_PLINT, 1, 1 );
07815 if ( tmp26 == NULL )
07816 return NULL;
07817 if ( tmp26->dimensions[0] != Alen )
07818 {
07819 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07820 return NULL;
07821 }
07822 arg26 = (PLINT *) tmp26->data;
07823 }
07824 {
07825 tmp27 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj23, PyArray_PLINT, 1, 1 );
07826 if ( tmp27 == NULL )
07827 return NULL;
07828 if ( tmp27->dimensions[0] != Alen )
07829 {
07830 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07831 return NULL;
07832 }
07833 arg27 = (PLINT *) tmp27->data;
07834 }
07835 {
07836 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, PyArray_PLINT, 1, 1 );
07837 if ( tmp28 == NULL )
07838 return NULL;
07839 if ( tmp28->dimensions[0] != Alen )
07840 {
07841 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07842 return NULL;
07843 }
07844 arg28 = (PLINT *) tmp28->data;
07845 }
07846 {
07847 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, PyArray_PLFLT, 1, 1 );
07848 if ( tmp29 == NULL )
07849 return NULL;
07850 if ( tmp29->dimensions[0] != Alen )
07851 {
07852 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07853 return NULL;
07854 }
07855 arg29 = (PLFLT *) tmp29->data;
07856 }
07857 {
07858 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, PyArray_PLINT, 1, 1 );
07859 if ( tmp30 == NULL )
07860 return NULL;
07861 if ( tmp30->dimensions[0] != Alen )
07862 {
07863 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07864 return NULL;
07865 }
07866 arg30 = (PLINT *) tmp30->data;
07867 }
07868 {
07869 int i;
07870 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
07871 if ( tmp31 == NULL )
07872 return NULL;
07873 if ( tmp31->dimensions[0] != Alen )
07874 {
07875 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07876 return NULL;
07877 }
07878 arg31 = (char **) malloc( sizeof ( char* ) * Alen );
07879 for ( i = 0; i < Alen; i++ )
07880 {
07881 arg31[i] = tmp31->data + i * tmp31->strides[0];
07882 if ( arg31[i] == NULL )
07883 {
07884 free( arg31 );
07885 return NULL;
07886 }
07887 }
07888 }
07889 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,(int const *)arg24,(int const *)arg25,(int const *)arg26,(int const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
07890 resultobj = SWIG_Py_Void();
07891 if (SWIG_IsTmpObj(res1)) {
07892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07893 } else {
07894 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07896 }
07897 if (SWIG_IsTmpObj(res2)) {
07898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07899 } else {
07900 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07902 }
07903 {
07904 Py_DECREF( tmp13 );
07905 }
07906 {
07907 Py_DECREF( tmp19 );
07908 }
07909 {
07910 Py_DECREF( tmp20 ); free( arg20 );
07911 }
07912 {
07913 Py_DECREF( tmp21 );
07914 }
07915 {
07916 Py_DECREF( tmp22 );
07917 }
07918 {
07919 Py_DECREF( tmp23 );
07920 }
07921 {
07922 Py_DECREF( tmp24 );
07923 }
07924 {
07925 Py_DECREF( tmp25 );
07926 }
07927 {
07928 Py_DECREF( tmp26 );
07929 }
07930 {
07931 Py_DECREF( tmp27 );
07932 }
07933 {
07934 Py_DECREF( tmp28 );
07935 }
07936 {
07937 Py_DECREF( tmp29 );
07938 }
07939 {
07940 Py_DECREF( tmp30 );
07941 }
07942 {
07943 Py_DECREF( tmp31 ); free( arg31 );
07944 }
07945 return resultobj;
07946 fail:
07947 {
07948 Py_DECREF( tmp13 );
07949 }
07950 {
07951 Py_DECREF( tmp19 );
07952 }
07953 {
07954 Py_DECREF( tmp20 ); free( arg20 );
07955 }
07956 {
07957 Py_DECREF( tmp21 );
07958 }
07959 {
07960 Py_DECREF( tmp22 );
07961 }
07962 {
07963 Py_DECREF( tmp23 );
07964 }
07965 {
07966 Py_DECREF( tmp24 );
07967 }
07968 {
07969 Py_DECREF( tmp25 );
07970 }
07971 {
07972 Py_DECREF( tmp26 );
07973 }
07974 {
07975 Py_DECREF( tmp27 );
07976 }
07977 {
07978 Py_DECREF( tmp28 );
07979 }
07980 {
07981 Py_DECREF( tmp29 );
07982 }
07983 {
07984 Py_DECREF( tmp30 );
07985 }
07986 {
07987 Py_DECREF( tmp31 ); free( arg31 );
07988 }
07989 return NULL;
07990 }
07991
07992
07993 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07994 PyObject *resultobj = 0;
07995 PLFLT arg1 ;
07996 PLFLT arg2 ;
07997 PLFLT arg3 ;
07998 double val1 ;
07999 int ecode1 = 0 ;
08000 double val2 ;
08001 int ecode2 = 0 ;
08002 double val3 ;
08003 int ecode3 = 0 ;
08004 PyObject * obj0 = 0 ;
08005 PyObject * obj1 = 0 ;
08006 PyObject * obj2 = 0 ;
08007
08008 if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
08009 ecode1 = SWIG_AsVal_double(obj0, &val1);
08010 if (!SWIG_IsOK(ecode1)) {
08011 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
08012 }
08013 arg1 = (PLFLT)(val1);
08014 ecode2 = SWIG_AsVal_double(obj1, &val2);
08015 if (!SWIG_IsOK(ecode2)) {
08016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
08017 }
08018 arg2 = (PLFLT)(val2);
08019 ecode3 = SWIG_AsVal_double(obj2, &val3);
08020 if (!SWIG_IsOK(ecode3)) {
08021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
08022 }
08023 arg3 = (PLFLT)(val3);
08024 pllightsource(arg1,arg2,arg3);
08025 resultobj = SWIG_Py_Void();
08026 return resultobj;
08027 fail:
08028 return NULL;
08029 }
08030
08031
08032 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08033 PyObject *resultobj = 0;
08034 PLINT arg1 ;
08035 PLFLT *arg2 = (PLFLT *) 0 ;
08036 PLFLT *arg3 = (PLFLT *) 0 ;
08037 PyArrayObject *tmp1 ;
08038 PyArrayObject *tmp3 ;
08039 PyObject * obj0 = 0 ;
08040 PyObject * obj1 = 0 ;
08041
08042 if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
08043 {
08044 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08045 if ( tmp1 == NULL )
08046 return NULL;
08047 arg1 = Alen = tmp1->dimensions[0];
08048 arg2 = (PLFLT *) tmp1->data;
08049 }
08050 {
08051 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08052 if ( tmp3 == NULL )
08053 return NULL;
08054 if ( tmp3->dimensions[0] != Alen )
08055 {
08056 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08057 return NULL;
08058 }
08059 arg3 = (PLFLT *) tmp3->data;
08060 }
08061 plline(arg1,(double const *)arg2,(double const *)arg3);
08062 resultobj = SWIG_Py_Void();
08063 {
08064 Py_DECREF( tmp1 );
08065 }
08066 {
08067 Py_DECREF( tmp3 );
08068 }
08069 return resultobj;
08070 fail:
08071 {
08072 Py_DECREF( tmp1 );
08073 }
08074 {
08075 Py_DECREF( tmp3 );
08076 }
08077 return NULL;
08078 }
08079
08080
08081 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08082 PyObject *resultobj = 0;
08083 PLINT arg1 ;
08084 PLFLT *arg2 = (PLFLT *) 0 ;
08085 PLFLT *arg3 = (PLFLT *) 0 ;
08086 PLFLT *arg4 = (PLFLT *) 0 ;
08087 PyArrayObject *tmp1 ;
08088 PyArrayObject *tmp3 ;
08089 PyArrayObject *tmp4 ;
08090 PyObject * obj0 = 0 ;
08091 PyObject * obj1 = 0 ;
08092 PyObject * obj2 = 0 ;
08093
08094 if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
08095 {
08096 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08097 if ( tmp1 == NULL )
08098 return NULL;
08099 arg1 = Alen = tmp1->dimensions[0];
08100 arg2 = (PLFLT *) tmp1->data;
08101 }
08102 {
08103 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08104 if ( tmp3 == NULL )
08105 return NULL;
08106 if ( tmp3->dimensions[0] != Alen )
08107 {
08108 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08109 return NULL;
08110 }
08111 arg3 = (PLFLT *) tmp3->data;
08112 }
08113 {
08114 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
08115 if ( tmp4 == NULL )
08116 return NULL;
08117 if ( tmp4->dimensions[0] != Alen )
08118 {
08119 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08120 return NULL;
08121 }
08122 arg4 = (PLFLT *) tmp4->data;
08123 }
08124 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
08125 resultobj = SWIG_Py_Void();
08126 {
08127 Py_DECREF( tmp1 );
08128 }
08129 {
08130 Py_DECREF( tmp3 );
08131 }
08132 {
08133 Py_DECREF( tmp4 );
08134 }
08135 return resultobj;
08136 fail:
08137 {
08138 Py_DECREF( tmp1 );
08139 }
08140 {
08141 Py_DECREF( tmp3 );
08142 }
08143 {
08144 Py_DECREF( tmp4 );
08145 }
08146 return NULL;
08147 }
08148
08149
08150 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08151 PyObject *resultobj = 0;
08152 PLINT arg1 ;
08153 int val1 ;
08154 int ecode1 = 0 ;
08155 PyObject * obj0 = 0 ;
08156
08157 if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
08158 ecode1 = SWIG_AsVal_int(obj0, &val1);
08159 if (!SWIG_IsOK(ecode1)) {
08160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
08161 }
08162 arg1 = (PLINT)(val1);
08163 pllsty(arg1);
08164 resultobj = SWIG_Py_Void();
08165 return resultobj;
08166 fail:
08167 return NULL;
08168 }
08169
08170
08171 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08172 PyObject *resultobj = 0;
08173 PLFLT *arg1 = (PLFLT *) 0 ;
08174 PLFLT *arg2 = (PLFLT *) 0 ;
08175 PLFLT **arg3 = (PLFLT **) 0 ;
08176 PLINT arg4 ;
08177 PLINT arg5 ;
08178 PLINT arg6 ;
08179 PyArrayObject *tmp1 ;
08180 PyArrayObject *tmp2 ;
08181 PyArrayObject *tmp3 ;
08182 int val6 ;
08183 int ecode6 = 0 ;
08184 PyObject * obj0 = 0 ;
08185 PyObject * obj1 = 0 ;
08186 PyObject * obj2 = 0 ;
08187 PyObject * obj3 = 0 ;
08188
08189 if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
08190 {
08191 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08192 if ( tmp1 == NULL )
08193 return NULL;
08194 Xlen = tmp1->dimensions[0];
08195 arg1 = (PLFLT *) tmp1->data;
08196 }
08197 {
08198 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08199 if ( tmp2 == NULL )
08200 return NULL;
08201 Ylen = tmp2->dimensions[0];
08202 arg2 = (PLFLT *) tmp2->data;
08203 }
08204 {
08205 int i, size;
08206 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08207 if ( tmp3 == NULL )
08208 return NULL;
08209 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08210 {
08211 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08212 return NULL;
08213 }
08214 arg4 = tmp3->dimensions[0];
08215 arg5 = tmp3->dimensions[1];
08216 size = sizeof ( PLFLT ) * arg5;
08217 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08218 for ( i = 0; i < arg4; i++ )
08219 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08220 }
08221 ecode6 = SWIG_AsVal_int(obj3, &val6);
08222 if (!SWIG_IsOK(ecode6)) {
08223 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
08224 }
08225 arg6 = (PLINT)(val6);
08226 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
08227 resultobj = SWIG_Py_Void();
08228 {
08229 Py_DECREF( tmp1 );
08230 }
08231 {
08232 Py_DECREF( tmp2 );
08233 }
08234 {
08235 Py_DECREF( tmp3 );
08236 free( arg3 );
08237 }
08238 return resultobj;
08239 fail:
08240 {
08241 Py_DECREF( tmp1 );
08242 }
08243 {
08244 Py_DECREF( tmp2 );
08245 }
08246 {
08247 Py_DECREF( tmp3 );
08248 free( arg3 );
08249 }
08250 return NULL;
08251 }
08252
08253
08254 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08255 PyObject *resultobj = 0;
08256 PLFLT *arg1 = (PLFLT *) 0 ;
08257 PLFLT *arg2 = (PLFLT *) 0 ;
08258 PLFLT **arg3 = (PLFLT **) 0 ;
08259 PLINT arg4 ;
08260 PLINT arg5 ;
08261 PLINT arg6 ;
08262 PLFLT *arg7 = (PLFLT *) 0 ;
08263 PLINT arg8 ;
08264 PyArrayObject *tmp1 ;
08265 PyArrayObject *tmp2 ;
08266 PyArrayObject *tmp3 ;
08267 int val6 ;
08268 int ecode6 = 0 ;
08269 PyArrayObject *tmp7 ;
08270 PyObject * obj0 = 0 ;
08271 PyObject * obj1 = 0 ;
08272 PyObject * obj2 = 0 ;
08273 PyObject * obj3 = 0 ;
08274 PyObject * obj4 = 0 ;
08275
08276 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08277 {
08278 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08279 if ( tmp1 == NULL )
08280 return NULL;
08281 Xlen = tmp1->dimensions[0];
08282 arg1 = (PLFLT *) tmp1->data;
08283 }
08284 {
08285 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08286 if ( tmp2 == NULL )
08287 return NULL;
08288 Ylen = tmp2->dimensions[0];
08289 arg2 = (PLFLT *) tmp2->data;
08290 }
08291 {
08292 int i, size;
08293 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08294 if ( tmp3 == NULL )
08295 return NULL;
08296 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08297 {
08298 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08299 return NULL;
08300 }
08301 arg4 = tmp3->dimensions[0];
08302 arg5 = tmp3->dimensions[1];
08303 size = sizeof ( PLFLT ) * arg5;
08304 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08305 for ( i = 0; i < arg4; i++ )
08306 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08307 }
08308 ecode6 = SWIG_AsVal_int(obj3, &val6);
08309 if (!SWIG_IsOK(ecode6)) {
08310 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
08311 }
08312 arg6 = (PLINT)(val6);
08313 {
08314 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08315 if ( tmp7 == NULL )
08316 return NULL;
08317 arg8 = tmp7->dimensions[0];
08318 arg7 = (PLFLT *) tmp7->data;
08319 }
08320 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08321 resultobj = SWIG_Py_Void();
08322 {
08323 Py_DECREF( tmp1 );
08324 }
08325 {
08326 Py_DECREF( tmp2 );
08327 }
08328 {
08329 Py_DECREF( tmp3 );
08330 free( arg3 );
08331 }
08332 {
08333 Py_DECREF( tmp7 );
08334 }
08335 return resultobj;
08336 fail:
08337 {
08338 Py_DECREF( tmp1 );
08339 }
08340 {
08341 Py_DECREF( tmp2 );
08342 }
08343 {
08344 Py_DECREF( tmp3 );
08345 free( arg3 );
08346 }
08347 {
08348 Py_DECREF( tmp7 );
08349 }
08350 return NULL;
08351 }
08352
08353
08354 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08355 PyObject *resultobj = 0;
08356 PLINT *arg1 = (PLINT *) 0 ;
08357 PLINT temp1 ;
08358 int res1 = SWIG_TMPOBJ ;
08359
08360 arg1 = &temp1;
08361 if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
08362 plmkstrm(arg1);
08363 resultobj = SWIG_Py_Void();
08364 if (SWIG_IsTmpObj(res1)) {
08365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
08366 } else {
08367 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
08368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
08369 }
08370 return resultobj;
08371 fail:
08372 return NULL;
08373 }
08374
08375
08376 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08377 PyObject *resultobj = 0;
08378 char *arg1 = (char *) 0 ;
08379 PLFLT arg2 ;
08380 PLFLT arg3 ;
08381 PLFLT arg4 ;
08382 char *arg5 = (char *) 0 ;
08383 int res1 ;
08384 char *buf1 = 0 ;
08385 int alloc1 = 0 ;
08386 double val2 ;
08387 int ecode2 = 0 ;
08388 double val3 ;
08389 int ecode3 = 0 ;
08390 double val4 ;
08391 int ecode4 = 0 ;
08392 int res5 ;
08393 char *buf5 = 0 ;
08394 int alloc5 = 0 ;
08395 PyObject * obj0 = 0 ;
08396 PyObject * obj1 = 0 ;
08397 PyObject * obj2 = 0 ;
08398 PyObject * obj3 = 0 ;
08399 PyObject * obj4 = 0 ;
08400
08401 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08402 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
08403 if (!SWIG_IsOK(res1)) {
08404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
08405 }
08406 arg1 = (char *)(buf1);
08407 ecode2 = SWIG_AsVal_double(obj1, &val2);
08408 if (!SWIG_IsOK(ecode2)) {
08409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
08410 }
08411 arg2 = (PLFLT)(val2);
08412 ecode3 = SWIG_AsVal_double(obj2, &val3);
08413 if (!SWIG_IsOK(ecode3)) {
08414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
08415 }
08416 arg3 = (PLFLT)(val3);
08417 ecode4 = SWIG_AsVal_double(obj3, &val4);
08418 if (!SWIG_IsOK(ecode4)) {
08419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
08420 }
08421 arg4 = (PLFLT)(val4);
08422 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
08423 if (!SWIG_IsOK(res5)) {
08424 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
08425 }
08426 arg5 = (char *)(buf5);
08427 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
08428 resultobj = SWIG_Py_Void();
08429 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08430 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08431 return resultobj;
08432 fail:
08433 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08434 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08435 return NULL;
08436 }
08437
08438
08439 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08440 PyObject *resultobj = 0;
08441 char *arg1 = (char *) 0 ;
08442 PLFLT arg2 ;
08443 PLFLT arg3 ;
08444 PLFLT arg4 ;
08445 char *arg5 = (char *) 0 ;
08446 int res1 ;
08447 char *buf1 = 0 ;
08448 int alloc1 = 0 ;
08449 double val2 ;
08450 int ecode2 = 0 ;
08451 double val3 ;
08452 int ecode3 = 0 ;
08453 double val4 ;
08454 int ecode4 = 0 ;
08455 int res5 ;
08456 char *buf5 = 0 ;
08457 int alloc5 = 0 ;
08458 PyObject * obj0 = 0 ;
08459 PyObject * obj1 = 0 ;
08460 PyObject * obj2 = 0 ;
08461 PyObject * obj3 = 0 ;
08462 PyObject * obj4 = 0 ;
08463
08464 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08465 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
08466 if (!SWIG_IsOK(res1)) {
08467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
08468 }
08469 arg1 = (char *)(buf1);
08470 ecode2 = SWIG_AsVal_double(obj1, &val2);
08471 if (!SWIG_IsOK(ecode2)) {
08472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
08473 }
08474 arg2 = (PLFLT)(val2);
08475 ecode3 = SWIG_AsVal_double(obj2, &val3);
08476 if (!SWIG_IsOK(ecode3)) {
08477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
08478 }
08479 arg3 = (PLFLT)(val3);
08480 ecode4 = SWIG_AsVal_double(obj3, &val4);
08481 if (!SWIG_IsOK(ecode4)) {
08482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
08483 }
08484 arg4 = (PLFLT)(val4);
08485 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
08486 if (!SWIG_IsOK(res5)) {
08487 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
08488 }
08489 arg5 = (char *)(buf5);
08490 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
08491 resultobj = SWIG_Py_Void();
08492 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08493 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08494 return resultobj;
08495 fail:
08496 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08497 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08498 return NULL;
08499 }
08500
08501
08502 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08503 PyObject *resultobj = 0;
08504 PLFLT *arg1 = (PLFLT *) 0 ;
08505 PLFLT *arg2 = (PLFLT *) 0 ;
08506 PLFLT **arg3 = (PLFLT **) 0 ;
08507 PLINT arg4 ;
08508 PLINT arg5 ;
08509 PLINT arg6 ;
08510 PLBOOL arg7 ;
08511 PyArrayObject *tmp1 ;
08512 PyArrayObject *tmp2 ;
08513 PyArrayObject *tmp3 ;
08514 int val6 ;
08515 int ecode6 = 0 ;
08516 int val7 ;
08517 int ecode7 = 0 ;
08518 PyObject * obj0 = 0 ;
08519 PyObject * obj1 = 0 ;
08520 PyObject * obj2 = 0 ;
08521 PyObject * obj3 = 0 ;
08522 PyObject * obj4 = 0 ;
08523
08524 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08525 {
08526 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08527 if ( tmp1 == NULL )
08528 return NULL;
08529 Xlen = tmp1->dimensions[0];
08530 arg1 = (PLFLT *) tmp1->data;
08531 }
08532 {
08533 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08534 if ( tmp2 == NULL )
08535 return NULL;
08536 Ylen = tmp2->dimensions[0];
08537 arg2 = (PLFLT *) tmp2->data;
08538 }
08539 {
08540 int i, size;
08541 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08542 if ( tmp3 == NULL )
08543 return NULL;
08544 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08545 {
08546 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08547 return NULL;
08548 }
08549 arg4 = tmp3->dimensions[0];
08550 arg5 = tmp3->dimensions[1];
08551 size = sizeof ( PLFLT ) * arg5;
08552 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08553 for ( i = 0; i < arg4; i++ )
08554 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08555 }
08556 ecode6 = SWIG_AsVal_int(obj3, &val6);
08557 if (!SWIG_IsOK(ecode6)) {
08558 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
08559 }
08560 arg6 = (PLINT)(val6);
08561 ecode7 = SWIG_AsVal_int(obj4, &val7);
08562 if (!SWIG_IsOK(ecode7)) {
08563 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
08564 }
08565 arg7 = (PLBOOL)(val7);
08566 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
08567 resultobj = SWIG_Py_Void();
08568 {
08569 Py_DECREF( tmp1 );
08570 }
08571 {
08572 Py_DECREF( tmp2 );
08573 }
08574 {
08575 Py_DECREF( tmp3 );
08576 free( arg3 );
08577 }
08578 return resultobj;
08579 fail:
08580 {
08581 Py_DECREF( tmp1 );
08582 }
08583 {
08584 Py_DECREF( tmp2 );
08585 }
08586 {
08587 Py_DECREF( tmp3 );
08588 free( arg3 );
08589 }
08590 return NULL;
08591 }
08592
08593
08594 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08595 PyObject *resultobj = 0;
08596 PLFLT *arg1 = (PLFLT *) 0 ;
08597 PLFLT *arg2 = (PLFLT *) 0 ;
08598 PLFLT **arg3 = (PLFLT **) 0 ;
08599 PLINT arg4 ;
08600 PLINT arg5 ;
08601 PLINT arg6 ;
08602 PLFLT *arg7 = (PLFLT *) 0 ;
08603 PLINT arg8 ;
08604 PyArrayObject *tmp1 ;
08605 PyArrayObject *tmp2 ;
08606 PyArrayObject *tmp3 ;
08607 int val6 ;
08608 int ecode6 = 0 ;
08609 PyArrayObject *tmp7 ;
08610 PyObject * obj0 = 0 ;
08611 PyObject * obj1 = 0 ;
08612 PyObject * obj2 = 0 ;
08613 PyObject * obj3 = 0 ;
08614 PyObject * obj4 = 0 ;
08615
08616 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08617 {
08618 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08619 if ( tmp1 == NULL )
08620 return NULL;
08621 Xlen = tmp1->dimensions[0];
08622 arg1 = (PLFLT *) tmp1->data;
08623 }
08624 {
08625 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08626 if ( tmp2 == NULL )
08627 return NULL;
08628 Ylen = tmp2->dimensions[0];
08629 arg2 = (PLFLT *) tmp2->data;
08630 }
08631 {
08632 int i, size;
08633 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08634 if ( tmp3 == NULL )
08635 return NULL;
08636 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08637 {
08638 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08639 return NULL;
08640 }
08641 arg4 = tmp3->dimensions[0];
08642 arg5 = tmp3->dimensions[1];
08643 size = sizeof ( PLFLT ) * arg5;
08644 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08645 for ( i = 0; i < arg4; i++ )
08646 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08647 }
08648 ecode6 = SWIG_AsVal_int(obj3, &val6);
08649 if (!SWIG_IsOK(ecode6)) {
08650 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
08651 }
08652 arg6 = (PLINT)(val6);
08653 {
08654 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08655 if ( tmp7 == NULL )
08656 return NULL;
08657 arg8 = tmp7->dimensions[0];
08658 arg7 = (PLFLT *) tmp7->data;
08659 }
08660 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08661 resultobj = SWIG_Py_Void();
08662 {
08663 Py_DECREF( tmp1 );
08664 }
08665 {
08666 Py_DECREF( tmp2 );
08667 }
08668 {
08669 Py_DECREF( tmp3 );
08670 free( arg3 );
08671 }
08672 {
08673 Py_DECREF( tmp7 );
08674 }
08675 return resultobj;
08676 fail:
08677 {
08678 Py_DECREF( tmp1 );
08679 }
08680 {
08681 Py_DECREF( tmp2 );
08682 }
08683 {
08684 Py_DECREF( tmp3 );
08685 free( arg3 );
08686 }
08687 {
08688 Py_DECREF( tmp7 );
08689 }
08690 return NULL;
08691 }
08692
08693
08694 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08695 PyObject *resultobj = 0;
08696 PLFLT *arg1 = (PLFLT *) 0 ;
08697 PLFLT *arg2 = (PLFLT *) 0 ;
08698 PLFLT **arg3 = (PLFLT **) 0 ;
08699 PLINT arg4 ;
08700 PLINT arg5 ;
08701 PLINT arg6 ;
08702 PLFLT *arg7 = (PLFLT *) 0 ;
08703 PLINT arg8 ;
08704 PLINT arg9 ;
08705 PLINT arg10 ;
08706 PLINT *arg11 = (PLINT *) 0 ;
08707 PLINT *arg12 = (PLINT *) 0 ;
08708 PyArrayObject *tmp1 ;
08709 PyArrayObject *tmp2 ;
08710 PyArrayObject *tmp3 ;
08711 int val6 ;
08712 int ecode6 = 0 ;
08713 PyArrayObject *tmp7 ;
08714 int val9 ;
08715 int ecode9 = 0 ;
08716 PyArrayObject *tmp10 ;
08717 PyArrayObject *tmp12 ;
08718 PyObject * obj0 = 0 ;
08719 PyObject * obj1 = 0 ;
08720 PyObject * obj2 = 0 ;
08721 PyObject * obj3 = 0 ;
08722 PyObject * obj4 = 0 ;
08723 PyObject * obj5 = 0 ;
08724 PyObject * obj6 = 0 ;
08725 PyObject * obj7 = 0 ;
08726
08727 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
08728 {
08729 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08730 if ( tmp1 == NULL )
08731 return NULL;
08732 Xlen = tmp1->dimensions[0];
08733 arg1 = (PLFLT *) tmp1->data;
08734 }
08735 {
08736 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08737 if ( tmp2 == NULL )
08738 return NULL;
08739 Ylen = tmp2->dimensions[0];
08740 arg2 = (PLFLT *) tmp2->data;
08741 }
08742 {
08743 int i, size;
08744 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08745 if ( tmp3 == NULL )
08746 return NULL;
08747 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08748 {
08749 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08750 return NULL;
08751 }
08752 arg4 = tmp3->dimensions[0];
08753 arg5 = tmp3->dimensions[1];
08754 size = sizeof ( PLFLT ) * arg5;
08755 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08756 for ( i = 0; i < arg4; i++ )
08757 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08758 }
08759 ecode6 = SWIG_AsVal_int(obj3, &val6);
08760 if (!SWIG_IsOK(ecode6)) {
08761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
08762 }
08763 arg6 = (PLINT)(val6);
08764 {
08765 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08766 if ( tmp7 == NULL )
08767 return NULL;
08768 arg8 = tmp7->dimensions[0];
08769 arg7 = (PLFLT *) tmp7->data;
08770 }
08771 ecode9 = SWIG_AsVal_int(obj5, &val9);
08772 if (!SWIG_IsOK(ecode9)) {
08773 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
08774 }
08775 arg9 = (PLINT)(val9);
08776 {
08777 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, PyArray_PLINT, 1, 1 );
08778 if ( tmp10 == NULL )
08779 return NULL;
08780 arg10 = Alen = tmp10->dimensions[0];
08781 arg11 = (PLINT *) tmp10->data;
08782 }
08783 {
08784 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, PyArray_PLINT, 1, 1 );
08785 if ( tmp12 == NULL )
08786 return NULL;
08787 if ( tmp12->dimensions[0] != Alen )
08788 {
08789 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08790 return NULL;
08791 }
08792 arg12 = (PLINT *) tmp12->data;
08793 }
08794 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);
08795 resultobj = SWIG_Py_Void();
08796 {
08797 Py_DECREF( tmp1 );
08798 }
08799 {
08800 Py_DECREF( tmp2 );
08801 }
08802 {
08803 Py_DECREF( tmp3 );
08804 free( arg3 );
08805 }
08806 {
08807 Py_DECREF( tmp7 );
08808 }
08809 {
08810 Py_DECREF( tmp10 );
08811 }
08812 {
08813 Py_DECREF( tmp12 );
08814 }
08815 return resultobj;
08816 fail:
08817 {
08818 Py_DECREF( tmp1 );
08819 }
08820 {
08821 Py_DECREF( tmp2 );
08822 }
08823 {
08824 Py_DECREF( tmp3 );
08825 free( arg3 );
08826 }
08827 {
08828 Py_DECREF( tmp7 );
08829 }
08830 {
08831 Py_DECREF( tmp10 );
08832 }
08833 {
08834 Py_DECREF( tmp12 );
08835 }
08836 return NULL;
08837 }
08838
08839
08840 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08841 PyObject *resultobj = 0;
08842 PLFLT *arg1 = (PLFLT *) 0 ;
08843 PLFLT *arg2 = (PLFLT *) 0 ;
08844 PLFLT **arg3 = (PLFLT **) 0 ;
08845 PLINT arg4 ;
08846 PLINT arg5 ;
08847 PLINT arg6 ;
08848 PLFLT *arg7 = (PLFLT *) 0 ;
08849 PLINT arg8 ;
08850 PyArrayObject *tmp1 ;
08851 PyArrayObject *tmp2 ;
08852 PyArrayObject *tmp3 ;
08853 int val6 ;
08854 int ecode6 = 0 ;
08855 PyArrayObject *tmp7 ;
08856 PyObject * obj0 = 0 ;
08857 PyObject * obj1 = 0 ;
08858 PyObject * obj2 = 0 ;
08859 PyObject * obj3 = 0 ;
08860 PyObject * obj4 = 0 ;
08861
08862 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08863 {
08864 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08865 if ( tmp1 == NULL )
08866 return NULL;
08867 Xlen = tmp1->dimensions[0];
08868 arg1 = (PLFLT *) tmp1->data;
08869 }
08870 {
08871 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08872 if ( tmp2 == NULL )
08873 return NULL;
08874 Ylen = tmp2->dimensions[0];
08875 arg2 = (PLFLT *) tmp2->data;
08876 }
08877 {
08878 int i, size;
08879 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08880 if ( tmp3 == NULL )
08881 return NULL;
08882 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08883 {
08884 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08885 return NULL;
08886 }
08887 arg4 = tmp3->dimensions[0];
08888 arg5 = tmp3->dimensions[1];
08889 size = sizeof ( PLFLT ) * arg5;
08890 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08891 for ( i = 0; i < arg4; i++ )
08892 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08893 }
08894 ecode6 = SWIG_AsVal_int(obj3, &val6);
08895 if (!SWIG_IsOK(ecode6)) {
08896 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
08897 }
08898 arg6 = (PLINT)(val6);
08899 {
08900 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08901 if ( tmp7 == NULL )
08902 return NULL;
08903 arg8 = tmp7->dimensions[0];
08904 arg7 = (PLFLT *) tmp7->data;
08905 }
08906 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08907 resultobj = SWIG_Py_Void();
08908 {
08909 Py_DECREF( tmp1 );
08910 }
08911 {
08912 Py_DECREF( tmp2 );
08913 }
08914 {
08915 Py_DECREF( tmp3 );
08916 free( arg3 );
08917 }
08918 {
08919 Py_DECREF( tmp7 );
08920 }
08921 return resultobj;
08922 fail:
08923 {
08924 Py_DECREF( tmp1 );
08925 }
08926 {
08927 Py_DECREF( tmp2 );
08928 }
08929 {
08930 Py_DECREF( tmp3 );
08931 free( arg3 );
08932 }
08933 {
08934 Py_DECREF( tmp7 );
08935 }
08936 return NULL;
08937 }
08938
08939
08940 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08941 PyObject *resultobj = 0;
08942 PLFLT *arg1 = (PLFLT *) 0 ;
08943 PLFLT *arg2 = (PLFLT *) 0 ;
08944 PLFLT **arg3 = (PLFLT **) 0 ;
08945 PLINT arg4 ;
08946 PLINT arg5 ;
08947 PLINT arg6 ;
08948 PLFLT *arg7 = (PLFLT *) 0 ;
08949 PLINT arg8 ;
08950 PLINT arg9 ;
08951 PLINT arg10 ;
08952 PLINT *arg11 = (PLINT *) 0 ;
08953 PLINT *arg12 = (PLINT *) 0 ;
08954 PyArrayObject *tmp1 ;
08955 PyArrayObject *tmp2 ;
08956 PyArrayObject *tmp3 ;
08957 int val6 ;
08958 int ecode6 = 0 ;
08959 PyArrayObject *tmp7 ;
08960 int val9 ;
08961 int ecode9 = 0 ;
08962 PyArrayObject *tmp10 ;
08963 PyArrayObject *tmp12 ;
08964 PyObject * obj0 = 0 ;
08965 PyObject * obj1 = 0 ;
08966 PyObject * obj2 = 0 ;
08967 PyObject * obj3 = 0 ;
08968 PyObject * obj4 = 0 ;
08969 PyObject * obj5 = 0 ;
08970 PyObject * obj6 = 0 ;
08971 PyObject * obj7 = 0 ;
08972
08973 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
08974 {
08975 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08976 if ( tmp1 == NULL )
08977 return NULL;
08978 Xlen = tmp1->dimensions[0];
08979 arg1 = (PLFLT *) tmp1->data;
08980 }
08981 {
08982 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08983 if ( tmp2 == NULL )
08984 return NULL;
08985 Ylen = tmp2->dimensions[0];
08986 arg2 = (PLFLT *) tmp2->data;
08987 }
08988 {
08989 int i, size;
08990 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08991 if ( tmp3 == NULL )
08992 return NULL;
08993 if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08994 {
08995 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08996 return NULL;
08997 }
08998 arg4 = tmp3->dimensions[0];
08999 arg5 = tmp3->dimensions[1];
09000 size = sizeof ( PLFLT ) * arg5;
09001 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
09002 for ( i = 0; i < arg4; i++ )
09003 arg3[i] = (PLFLT *) ( tmp3->data + i * size );
09004 }
09005 ecode6 = SWIG_AsVal_int(obj3, &val6);
09006 if (!SWIG_IsOK(ecode6)) {
09007 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
09008 }
09009 arg6 = (PLINT)(val6);
09010 {
09011 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
09012 if ( tmp7 == NULL )
09013 return NULL;
09014 arg8 = tmp7->dimensions[0];
09015 arg7 = (PLFLT *) tmp7->data;
09016 }
09017 ecode9 = SWIG_AsVal_int(obj5, &val9);
09018 if (!SWIG_IsOK(ecode9)) {
09019 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
09020 }
09021 arg9 = (PLINT)(val9);
09022 {
09023 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, PyArray_PLINT, 1, 1 );
09024 if ( tmp10 == NULL )
09025 return NULL;
09026 arg10 = Alen = tmp10->dimensions[0];
09027 arg11 = (PLINT *) tmp10->data;
09028 }
09029 {
09030 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, PyArray_PLINT, 1, 1 );
09031 if ( tmp12 == NULL )
09032 return NULL;
09033 if ( tmp12->dimensions[0] != Alen )
09034 {
09035 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09036 return NULL;
09037 }
09038 arg12 = (PLINT *) tmp12->data;
09039 }
09040 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);
09041 resultobj = SWIG_Py_Void();
09042 {
09043 Py_DECREF( tmp1 );
09044 }
09045 {
09046 Py_DECREF( tmp2 );
09047 }
09048 {
09049 Py_DECREF( tmp3 );
09050 free( arg3 );
09051 }
09052 {
09053 Py_DECREF( tmp7 );
09054 }
09055 {
09056 Py_DECREF( tmp10 );
09057 }
09058 {
09059 Py_DECREF( tmp12 );
09060 }
09061 return resultobj;
09062 fail:
09063 {
09064 Py_DECREF( tmp1 );
09065 }
09066 {
09067 Py_DECREF( tmp2 );
09068 }
09069 {
09070 Py_DECREF( tmp3 );
09071 free( arg3 );
09072 }
09073 {
09074 Py_DECREF( tmp7 );
09075 }
09076 {
09077 Py_DECREF( tmp10 );
09078 }
09079 {
09080 Py_DECREF( tmp12 );
09081 }
09082 return NULL;
09083 }
09084
09085
09086 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09087 PyObject *resultobj = 0;
09088 int *arg1 = (int *) 0 ;
09089 char **arg2 = (char **) 0 ;
09090 PLINT arg3 ;
09091 int tmp1 ;
09092 int val3 ;
09093 int ecode3 = 0 ;
09094 PyObject * obj0 = 0 ;
09095 PyObject * obj1 = 0 ;
09096 PLINT result;
09097
09098 if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
09099 {
09100 int i;
09101 if ( !PyList_Check( obj0 ) )
09102 {
09103 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
09104 return NULL;
09105 }
09106 tmp1 = PyList_Size( obj0 );
09107 arg1 = &tmp1;
09108 arg2 = (char **) malloc( ( tmp1 + 1 ) * sizeof ( char * ) );
09109 for ( i = 0; i < tmp1; i++ )
09110 {
09111 PyObject *s = PyList_GetItem( obj0, i );
09112 if ( !PyString_Check( s ) )
09113 {
09114 free( arg2 );
09115 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
09116 return NULL;
09117 }
09118 arg2[i] = PyString_AsString( s );
09119 }
09120 arg2[i] = 0;
09121 }
09122 ecode3 = SWIG_AsVal_int(obj1, &val3);
09123 if (!SWIG_IsOK(ecode3)) {
09124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
09125 }
09126 arg3 = (PLINT)(val3);
09127 result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
09128 resultobj = SWIG_From_int((int)(result));
09129 {
09130 if ( arg2 )
09131 free( arg2 );
09132 }
09133 return resultobj;
09134 fail:
09135 {
09136 if ( arg2 )
09137 free( arg2 );
09138 }
09139 return NULL;
09140 }
09141
09142
09143 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09144 PyObject *resultobj = 0;
09145 PLINT arg1 ;
09146 PLINT *arg2 = (PLINT *) 0 ;
09147 PLINT *arg3 = (PLINT *) 0 ;
09148 PyArrayObject *tmp1 ;
09149 PyArrayObject *tmp3 ;
09150 PyObject * obj0 = 0 ;
09151 PyObject * obj1 = 0 ;
09152
09153 if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
09154 {
09155 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09156 if ( tmp1 == NULL )
09157 return NULL;
09158 arg1 = Alen = tmp1->dimensions[0];
09159 arg2 = (PLINT *) tmp1->data;
09160 }
09161 {
09162 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09163 if ( tmp3 == NULL )
09164 return NULL;
09165 if ( tmp3->dimensions[0] != Alen )
09166 {
09167 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09168 return NULL;
09169 }
09170 arg3 = (PLINT *) tmp3->data;
09171 }
09172 plpat(arg1,(int const *)arg2,(int const *)arg3);
09173 resultobj = SWIG_Py_Void();
09174 {
09175 Py_DECREF( tmp1 );
09176 }
09177 {
09178 Py_DECREF( tmp3 );
09179 }
09180 return resultobj;
09181 fail:
09182 {
09183 Py_DECREF( tmp1 );
09184 }
09185 {
09186 Py_DECREF( tmp3 );
09187 }
09188 return NULL;
09189 }
09190
09191
09192 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09193 PyObject *resultobj = 0;
09194 PLINT arg1 ;
09195 PLFLT *arg2 = (PLFLT *) 0 ;
09196 PLFLT *arg3 = (PLFLT *) 0 ;
09197 PLINT arg4 ;
09198 PyArrayObject *tmp1 ;
09199 PyArrayObject *tmp3 ;
09200 int val4 ;
09201 int ecode4 = 0 ;
09202 PyObject * obj0 = 0 ;
09203 PyObject * obj1 = 0 ;
09204 PyObject * obj2 = 0 ;
09205
09206 if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
09207 {
09208 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
09209 if ( tmp1 == NULL )
09210 return NULL;
09211 arg1 = Alen = tmp1->dimensions[0];
09212 arg2 = (PLFLT *) tmp1->data;
09213 }
09214 {
09215 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
09216 if ( tmp3 == NULL )
09217 return NULL;
09218 if ( tmp3->dimensions[0] != Alen )
09219 {
09220 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09221 return NULL;
09222 }
09223 arg3 = (PLFLT *) tmp3->data;
09224 }
09225 ecode4 = SWIG_AsVal_int(obj2, &val4);
09226 if (!SWIG_IsOK(ecode4)) {
09227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
09228 }
09229 arg4 = (PLINT)(val4);
09230 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
09231 resultobj = SWIG_Py_Void();
09232 {
09233 Py_DECREF( tmp1 );
09234 }
09235 {
09236 Py_DECREF( tmp3 );
09237 }
09238 return resultobj;
09239 fail:
09240 {
09241 Py_DECREF( tmp1 );
09242 }
09243 {
09244 Py_DECREF( tmp3 );
09245 }
09246 return NULL;
09247 }
09248
09249
09250 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09251 PyObject *resultobj = 0;
09252 PLINT arg1 ;
09253 PLFLT *arg2 = (PLFLT *) 0 ;
09254 PLFLT *arg3 = (PLFLT *) 0 ;
09255 PLFLT *arg4 = (PLFLT *) 0 ;
09256 PLINT arg5 ;
09257 PyArrayObject *tmp1 ;
09258 PyArrayObject *tmp3 ;
09259 PyArrayObject *tmp4 ;
09260 int val5 ;
09261 int ecode5 = 0 ;
09262 PyObject * obj0 = 0 ;
09263 PyObject * obj1 = 0 ;
09264 PyObject * obj2 = 0 ;
09265 PyObject * obj3 = 0 ;
09266
09267 if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
09268 {
09269 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
09270 if ( tmp1 == NULL )
09271 return NULL;
09272 arg1 = Alen = tmp1->dimensions[0];
09273 arg2 = (PLFLT *) tmp1->data;
09274 }
09275 {
09276 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
09277 if ( tmp3 == NULL )
09278 return NULL;
09279 if ( tmp3->dimensions[0] != Alen )
09280 {
09281 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09282 return NULL;
09283 }
09284 arg3 = (PLFLT *) tmp3->data;
09285 }
09286 {
09287 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
09288 if ( tmp4 == NULL )
09289 return NULL;
09290 if ( tmp4->dimensions[0] != Alen )
09291 {
09292 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09293 return NULL;
09294 }
09295 arg4 = (PLFLT *) tmp4->data;
09296 }
09297 ecode5 = SWIG_AsVal_int(obj3, &val5);
09298 if (!SWIG_IsOK(ecode5)) {
09299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
09300 }
09301 arg5 = (PLINT)(val5);
09302 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
09303 resultobj = SWIG_Py_Void();
09304 {
09305 Py_DECREF( tmp1 );
09306 }
09307 {
09308 Py_DECREF( tmp3 );
09309 }
09310 {
09311 Py_DECREF( tmp4 );
09312 }
09313 return resultobj;
09314 fail:
09315 {
09316 Py_DECREF( tmp1 );
09317 }
09318 {
09319 Py_DECREF( tmp3 );
09320 }
09321 {
09322 Py_DECREF( tmp4 );
09323 }
09324 return NULL;
09325 }
09326
09327
09328 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09329 PyObject *resultobj = 0;
09330 PLINT arg1 ;
09331 PLFLT *arg2 = (PLFLT *) 0 ;
09332 PLFLT *arg3 = (PLFLT *) 0 ;
09333 PLFLT *arg4 = (PLFLT *) 0 ;
09334 PLBOOL *arg5 = (PLBOOL *) 0 ;
09335 PLBOOL arg6 ;
09336 PyArrayObject *tmp1 ;
09337 PyArrayObject *tmp3 ;
09338 PyArrayObject *tmp4 ;
09339 PyArrayObject *tmp5 ;
09340 int val6 ;
09341 int ecode6 = 0 ;
09342 PyObject * obj0 = 0 ;
09343 PyObject * obj1 = 0 ;
09344 PyObject * obj2 = 0 ;
09345 PyObject * obj3 = 0 ;
09346 PyObject * obj4 = 0 ;
09347
09348 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09349 {
09350 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
09351 if ( tmp1 == NULL )
09352 return NULL;
09353 arg1 = Alen = tmp1->dimensions[0];
09354 arg2 = (PLFLT *) tmp1->data;
09355 }
09356 {
09357 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
09358 if ( tmp3 == NULL )
09359 return NULL;
09360 if ( tmp3->dimensions[0] != Alen )
09361 {
09362 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09363 return NULL;
09364 }
09365 arg3 = (PLFLT *) tmp3->data;
09366 }
09367 {
09368 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
09369 if ( tmp4 == NULL )
09370 return NULL;
09371 if ( tmp4->dimensions[0] != Alen )
09372 {
09373 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09374 return NULL;
09375 }
09376 arg4 = (PLFLT *) tmp4->data;
09377 }
09378 {
09379 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, PyArray_PLINT, 1, 1 );
09380 if ( tmp5 == NULL )
09381 return NULL;
09382 if ( tmp5->dimensions[0] < Alen - 1 )
09383 {
09384 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
09385 return NULL;
09386 }
09387 arg5 = (PLINT *) tmp5->data;
09388 }
09389 ecode6 = SWIG_AsVal_int(obj4, &val6);
09390 if (!SWIG_IsOK(ecode6)) {
09391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
09392 }
09393 arg6 = (PLBOOL)(val6);
09394 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
09395 resultobj = SWIG_Py_Void();
09396 {
09397 Py_DECREF( tmp1 );
09398 }
09399 {
09400 Py_DECREF( tmp3 );
09401 }
09402 {
09403 Py_DECREF( tmp4 );
09404 }
09405 {
09406 Py_DECREF( tmp5 );
09407 }
09408 return resultobj;
09409 fail:
09410 {
09411 Py_DECREF( tmp1 );
09412 }
09413 {
09414 Py_DECREF( tmp3 );
09415 }
09416 {
09417 Py_DECREF( tmp4 );
09418 }
09419 {
09420 Py_DECREF( tmp5 );
09421 }
09422 return NULL;
09423 }
09424
09425
09426 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09427 PyObject *resultobj = 0;
09428 PLINT arg1 ;
09429 PLINT arg2 ;
09430 int val1 ;
09431 int ecode1 = 0 ;
09432 int val2 ;
09433 int ecode2 = 0 ;
09434 PyObject * obj0 = 0 ;
09435 PyObject * obj1 = 0 ;
09436
09437 if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
09438 ecode1 = SWIG_AsVal_int(obj0, &val1);
09439 if (!SWIG_IsOK(ecode1)) {
09440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
09441 }
09442 arg1 = (PLINT)(val1);
09443 ecode2 = SWIG_AsVal_int(obj1, &val2);
09444 if (!SWIG_IsOK(ecode2)) {
09445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
09446 }
09447 arg2 = (PLINT)(val2);
09448 plprec(arg1,arg2);
09449 resultobj = SWIG_Py_Void();
09450 return resultobj;
09451 fail:
09452 return NULL;
09453 }
09454
09455
09456 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09457 PyObject *resultobj = 0;
09458 PLINT arg1 ;
09459 int val1 ;
09460 int ecode1 = 0 ;
09461 PyObject * obj0 = 0 ;
09462
09463 if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
09464 ecode1 = SWIG_AsVal_int(obj0, &val1);
09465 if (!SWIG_IsOK(ecode1)) {
09466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
09467 }
09468 arg1 = (PLINT)(val1);
09469 plpsty(arg1);
09470 resultobj = SWIG_Py_Void();
09471 return resultobj;
09472 fail:
09473 return NULL;
09474 }
09475
09476
09477 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09478 PyObject *resultobj = 0;
09479 PLFLT arg1 ;
09480 PLFLT arg2 ;
09481 PLFLT arg3 ;
09482 PLFLT arg4 ;
09483 PLFLT arg5 ;
09484 char *arg6 = (char *) 0 ;
09485 double val1 ;
09486 int ecode1 = 0 ;
09487 double val2 ;
09488 int ecode2 = 0 ;
09489 double val3 ;
09490 int ecode3 = 0 ;
09491 double val4 ;
09492 int ecode4 = 0 ;
09493 double val5 ;
09494 int ecode5 = 0 ;
09495 int res6 ;
09496 char *buf6 = 0 ;
09497 int alloc6 = 0 ;
09498 PyObject * obj0 = 0 ;
09499 PyObject * obj1 = 0 ;
09500 PyObject * obj2 = 0 ;
09501 PyObject * obj3 = 0 ;
09502 PyObject * obj4 = 0 ;
09503 PyObject * obj5 = 0 ;
09504
09505 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
09506 ecode1 = SWIG_AsVal_double(obj0, &val1);
09507 if (!SWIG_IsOK(ecode1)) {
09508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
09509 }
09510 arg1 = (PLFLT)(val1);
09511 ecode2 = SWIG_AsVal_double(obj1, &val2);
09512 if (!SWIG_IsOK(ecode2)) {
09513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
09514 }
09515 arg2 = (PLFLT)(val2);
09516 ecode3 = SWIG_AsVal_double(obj2, &val3);
09517 if (!SWIG_IsOK(ecode3)) {
09518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
09519 }
09520 arg3 = (PLFLT)(val3);
09521 ecode4 = SWIG_AsVal_double(obj3, &val4);
09522 if (!SWIG_IsOK(ecode4)) {
09523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
09524 }
09525 arg4 = (PLFLT)(val4);
09526 ecode5 = SWIG_AsVal_double(obj4, &val5);
09527 if (!SWIG_IsOK(ecode5)) {
09528 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
09529 }
09530 arg5 = (PLFLT)(val5);
09531 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
09532 if (!SWIG_IsOK(res6)) {
09533 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
09534 }
09535 arg6 = (char *)(buf6);
09536 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
09537 resultobj = SWIG_Py_Void();
09538 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
09539 return resultobj;
09540 fail:
09541 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
09542 return NULL;
09543 }
09544
09545
09546 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09547 PyObject *resultobj = 0;
09548 PLFLT arg1 ;
09549 PLFLT arg2 ;
09550 PLFLT arg3 ;
09551 PLFLT arg4 ;
09552 PLFLT arg5 ;
09553 PLFLT arg6 ;
09554 PLFLT arg7 ;
09555 PLFLT arg8 ;
09556 PLFLT arg9 ;
09557 PLFLT arg10 ;
09558 char *arg11 = (char *) 0 ;
09559 double val1 ;
09560 int ecode1 = 0 ;
09561 double val2 ;
09562 int ecode2 = 0 ;
09563 double val3 ;
09564 int ecode3 = 0 ;
09565 double val4 ;
09566 int ecode4 = 0 ;
09567 double val5 ;
09568 int ecode5 = 0 ;
09569 double val6 ;
09570 int ecode6 = 0 ;
09571 double val7 ;
09572 int ecode7 = 0 ;
09573 double val8 ;
09574 int ecode8 = 0 ;
09575 double val9 ;
09576 int ecode9 = 0 ;
09577 double val10 ;
09578 int ecode10 = 0 ;
09579 int res11 ;
09580 char *buf11 = 0 ;
09581 int alloc11 = 0 ;
09582 PyObject * obj0 = 0 ;
09583 PyObject * obj1 = 0 ;
09584 PyObject * obj2 = 0 ;
09585 PyObject * obj3 = 0 ;
09586 PyObject * obj4 = 0 ;
09587 PyObject * obj5 = 0 ;
09588 PyObject * obj6 = 0 ;
09589 PyObject * obj7 = 0 ;
09590 PyObject * obj8 = 0 ;
09591 PyObject * obj9 = 0 ;
09592 PyObject * obj10 = 0 ;
09593
09594 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
09595 ecode1 = SWIG_AsVal_double(obj0, &val1);
09596 if (!SWIG_IsOK(ecode1)) {
09597 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
09598 }
09599 arg1 = (PLFLT)(val1);
09600 ecode2 = SWIG_AsVal_double(obj1, &val2);
09601 if (!SWIG_IsOK(ecode2)) {
09602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
09603 }
09604 arg2 = (PLFLT)(val2);
09605 ecode3 = SWIG_AsVal_double(obj2, &val3);
09606 if (!SWIG_IsOK(ecode3)) {
09607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
09608 }
09609 arg3 = (PLFLT)(val3);
09610 ecode4 = SWIG_AsVal_double(obj3, &val4);
09611 if (!SWIG_IsOK(ecode4)) {
09612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
09613 }
09614 arg4 = (PLFLT)(val4);
09615 ecode5 = SWIG_AsVal_double(obj4, &val5);
09616 if (!SWIG_IsOK(ecode5)) {
09617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
09618 }
09619 arg5 = (PLFLT)(val5);
09620 ecode6 = SWIG_AsVal_double(obj5, &val6);
09621 if (!SWIG_IsOK(ecode6)) {
09622 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
09623 }
09624 arg6 = (PLFLT)(val6);
09625 ecode7 = SWIG_AsVal_double(obj6, &val7);
09626 if (!SWIG_IsOK(ecode7)) {
09627 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
09628 }
09629 arg7 = (PLFLT)(val7);
09630 ecode8 = SWIG_AsVal_double(obj7, &val8);
09631 if (!SWIG_IsOK(ecode8)) {
09632 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
09633 }
09634 arg8 = (PLFLT)(val8);
09635 ecode9 = SWIG_AsVal_double(obj8, &val9);
09636 if (!SWIG_IsOK(ecode9)) {
09637 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
09638 }
09639 arg9 = (PLFLT)(val9);
09640 ecode10 = SWIG_AsVal_double(obj9, &val10);
09641 if (!SWIG_IsOK(ecode10)) {
09642 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
09643 }
09644 arg10 = (PLFLT)(val10);
09645 res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
09646 if (!SWIG_IsOK(res11)) {
09647 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
09648 }
09649 arg11 = (char *)(buf11);
09650 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
09651 resultobj = SWIG_Py_Void();
09652 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
09653 return resultobj;
09654 fail:
09655 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
09656 return NULL;
09657 }
09658
09659
09660 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09661 PyObject *resultobj = 0;
09662 PLFLT result;
09663
09664 if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
09665 result = (PLFLT)plrandd();
09666 resultobj = SWIG_From_double((double)(result));
09667 return resultobj;
09668 fail:
09669 return NULL;
09670 }
09671
09672
09673 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09674 PyObject *resultobj = 0;
09675
09676 if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
09677 plreplot();
09678 resultobj = SWIG_Py_Void();
09679 return resultobj;
09680 fail:
09681 return NULL;
09682 }
09683
09684
09685 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09686 PyObject *resultobj = 0;
09687 PLFLT arg1 ;
09688 PLFLT arg2 ;
09689 PLFLT arg3 ;
09690 PLFLT *arg4 = (PLFLT *) 0 ;
09691 PLFLT *arg5 = (PLFLT *) 0 ;
09692 PLFLT *arg6 = (PLFLT *) 0 ;
09693 double val1 ;
09694 int ecode1 = 0 ;
09695 double val2 ;
09696 int ecode2 = 0 ;
09697 double val3 ;
09698 int ecode3 = 0 ;
09699 PLFLT temp4 ;
09700 int res4 = SWIG_TMPOBJ ;
09701 PLFLT temp5 ;
09702 int res5 = SWIG_TMPOBJ ;
09703 PLFLT temp6 ;
09704 int res6 = SWIG_TMPOBJ ;
09705 PyObject * obj0 = 0 ;
09706 PyObject * obj1 = 0 ;
09707 PyObject * obj2 = 0 ;
09708
09709 arg4 = &temp4;
09710 arg5 = &temp5;
09711 arg6 = &temp6;
09712 if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
09713 ecode1 = SWIG_AsVal_double(obj0, &val1);
09714 if (!SWIG_IsOK(ecode1)) {
09715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
09716 }
09717 arg1 = (PLFLT)(val1);
09718 ecode2 = SWIG_AsVal_double(obj1, &val2);
09719 if (!SWIG_IsOK(ecode2)) {
09720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
09721 }
09722 arg2 = (PLFLT)(val2);
09723 ecode3 = SWIG_AsVal_double(obj2, &val3);
09724 if (!SWIG_IsOK(ecode3)) {
09725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
09726 }
09727 arg3 = (PLFLT)(val3);
09728 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
09729 resultobj = SWIG_Py_Void();
09730 if (SWIG_IsTmpObj(res4)) {
09731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
09732 } else {
09733 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
09734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
09735 }
09736 if (SWIG_IsTmpObj(res5)) {
09737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
09738 } else {
09739 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
09740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
09741 }
09742 if (SWIG_IsTmpObj(res6)) {
09743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
09744 } else {
09745 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
09746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
09747 }
09748 return resultobj;
09749 fail:
09750 return NULL;
09751 }
09752
09753
09754 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09755 PyObject *resultobj = 0;
09756 PLFLT arg1 ;
09757 PLFLT arg2 ;
09758 double val1 ;
09759 int ecode1 = 0 ;
09760 double val2 ;
09761 int ecode2 = 0 ;
09762 PyObject * obj0 = 0 ;
09763 PyObject * obj1 = 0 ;
09764
09765 if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
09766 ecode1 = SWIG_AsVal_double(obj0, &val1);
09767 if (!SWIG_IsOK(ecode1)) {
09768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
09769 }
09770 arg1 = (PLFLT)(val1);
09771 ecode2 = SWIG_AsVal_double(obj1, &val2);
09772 if (!SWIG_IsOK(ecode2)) {
09773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
09774 }
09775 arg2 = (PLFLT)(val2);
09776 plschr(arg1,arg2);
09777 resultobj = SWIG_Py_Void();
09778 return resultobj;
09779 fail:
09780 return NULL;
09781 }
09782
09783
09784 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09785 PyObject *resultobj = 0;
09786 PLINT *arg1 = (PLINT *) 0 ;
09787 PLINT *arg2 = (PLINT *) 0 ;
09788 PLINT *arg3 = (PLINT *) 0 ;
09789 PLINT arg4 ;
09790 PyArrayObject *tmp1 ;
09791 PyArrayObject *tmp2 ;
09792 PyArrayObject *tmp3 ;
09793 PyObject * obj0 = 0 ;
09794 PyObject * obj1 = 0 ;
09795 PyObject * obj2 = 0 ;
09796
09797 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
09798 {
09799 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09800 if ( tmp1 == NULL )
09801 return NULL;
09802 Alen = tmp1->dimensions[0];
09803 arg1 = (PLINT *) tmp1->data;
09804 }
09805 {
09806 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09807 if ( tmp2 == NULL )
09808 return NULL;
09809 if ( tmp2->dimensions[0] != Alen )
09810 {
09811 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09812 return NULL;
09813 }
09814 arg2 = (PLINT *) tmp2->data;
09815 }
09816 {
09817 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
09818 if ( tmp3 == NULL )
09819 return NULL;
09820 if ( tmp3->dimensions[0] != Alen )
09821 {
09822 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09823 return NULL;
09824 }
09825 arg4 = tmp3->dimensions[0];
09826 arg3 = (PLINT *) tmp3->data;
09827 }
09828 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
09829 resultobj = SWIG_Py_Void();
09830 {
09831 Py_DECREF( tmp1 );
09832 }
09833 {
09834 Py_DECREF( tmp2 );
09835 }
09836 {
09837 Py_DECREF( tmp3 );
09838 }
09839 return resultobj;
09840 fail:
09841 {
09842 Py_DECREF( tmp1 );
09843 }
09844 {
09845 Py_DECREF( tmp2 );
09846 }
09847 {
09848 Py_DECREF( tmp3 );
09849 }
09850 return NULL;
09851 }
09852
09853
09854 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09855 PyObject *resultobj = 0;
09856 PLINT *arg1 = (PLINT *) 0 ;
09857 PLINT *arg2 = (PLINT *) 0 ;
09858 PLINT *arg3 = (PLINT *) 0 ;
09859 PLFLT *arg4 = (PLFLT *) 0 ;
09860 PLINT arg5 ;
09861 PyArrayObject *tmp1 ;
09862 PyArrayObject *tmp2 ;
09863 PyArrayObject *tmp3 ;
09864 PyArrayObject *tmp4 ;
09865 PyObject * obj0 = 0 ;
09866 PyObject * obj1 = 0 ;
09867 PyObject * obj2 = 0 ;
09868 PyObject * obj3 = 0 ;
09869
09870 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
09871 {
09872 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09873 if ( tmp1 == NULL )
09874 return NULL;
09875 Alen = tmp1->dimensions[0];
09876 arg1 = (PLINT *) tmp1->data;
09877 }
09878 {
09879 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09880 if ( tmp2 == NULL )
09881 return NULL;
09882 if ( tmp2->dimensions[0] != Alen )
09883 {
09884 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09885 return NULL;
09886 }
09887 arg2 = (PLINT *) tmp2->data;
09888 }
09889 {
09890 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
09891 if ( tmp3 == NULL )
09892 return NULL;
09893 if ( tmp3->dimensions[0] != Alen )
09894 {
09895 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09896 return NULL;
09897 }
09898 arg3 = (PLINT *) tmp3->data;
09899 }
09900 {
09901 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
09902 if ( tmp4 == NULL )
09903 return NULL;
09904 if ( tmp4->dimensions[0] != Alen )
09905 {
09906 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09907 return NULL;
09908 }
09909 arg4 = (PLFLT *) tmp4->data;
09910 arg5 = tmp4->dimensions[0];
09911 }
09912 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
09913 resultobj = SWIG_Py_Void();
09914 {
09915 Py_DECREF( tmp1 );
09916 }
09917 {
09918 Py_DECREF( tmp2 );
09919 }
09920 {
09921 Py_DECREF( tmp3 );
09922 }
09923 {
09924 Py_DECREF( tmp4 );
09925 }
09926 return resultobj;
09927 fail:
09928 {
09929 Py_DECREF( tmp1 );
09930 }
09931 {
09932 Py_DECREF( tmp2 );
09933 }
09934 {
09935 Py_DECREF( tmp3 );
09936 }
09937 {
09938 Py_DECREF( tmp4 );
09939 }
09940 return NULL;
09941 }
09942
09943
09944 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09945 PyObject *resultobj = 0;
09946 PLINT arg1 ;
09947 int val1 ;
09948 int ecode1 = 0 ;
09949 PyObject * obj0 = 0 ;
09950
09951 if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
09952 ecode1 = SWIG_AsVal_int(obj0, &val1);
09953 if (!SWIG_IsOK(ecode1)) {
09954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
09955 }
09956 arg1 = (PLINT)(val1);
09957 plscmap0n(arg1);
09958 resultobj = SWIG_Py_Void();
09959 return resultobj;
09960 fail:
09961 return NULL;
09962 }
09963
09964
09965 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09966 PyObject *resultobj = 0;
09967 PLINT *arg1 = (PLINT *) 0 ;
09968 PLINT *arg2 = (PLINT *) 0 ;
09969 PLINT *arg3 = (PLINT *) 0 ;
09970 PLINT arg4 ;
09971 PyArrayObject *tmp1 ;
09972 PyArrayObject *tmp2 ;
09973 PyArrayObject *tmp3 ;
09974 PyObject * obj0 = 0 ;
09975 PyObject * obj1 = 0 ;
09976 PyObject * obj2 = 0 ;
09977
09978 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
09979 {
09980 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09981 if ( tmp1 == NULL )
09982 return NULL;
09983 Alen = tmp1->dimensions[0];
09984 arg1 = (PLINT *) tmp1->data;
09985 }
09986 {
09987 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09988 if ( tmp2 == NULL )
09989 return NULL;
09990 if ( tmp2->dimensions[0] != Alen )
09991 {
09992 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09993 return NULL;
09994 }
09995 arg2 = (PLINT *) tmp2->data;
09996 }
09997 {
09998 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
09999 if ( tmp3 == NULL )
10000 return NULL;
10001 if ( tmp3->dimensions[0] != Alen )
10002 {
10003 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10004 return NULL;
10005 }
10006 arg4 = tmp3->dimensions[0];
10007 arg3 = (PLINT *) tmp3->data;
10008 }
10009 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10010 resultobj = SWIG_Py_Void();
10011 {
10012 Py_DECREF( tmp1 );
10013 }
10014 {
10015 Py_DECREF( tmp2 );
10016 }
10017 {
10018 Py_DECREF( tmp3 );
10019 }
10020 return resultobj;
10021 fail:
10022 {
10023 Py_DECREF( tmp1 );
10024 }
10025 {
10026 Py_DECREF( tmp2 );
10027 }
10028 {
10029 Py_DECREF( tmp3 );
10030 }
10031 return NULL;
10032 }
10033
10034
10035 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10036 PyObject *resultobj = 0;
10037 PLINT *arg1 = (PLINT *) 0 ;
10038 PLINT *arg2 = (PLINT *) 0 ;
10039 PLINT *arg3 = (PLINT *) 0 ;
10040 PLFLT *arg4 = (PLFLT *) 0 ;
10041 PLINT arg5 ;
10042 PyArrayObject *tmp1 ;
10043 PyArrayObject *tmp2 ;
10044 PyArrayObject *tmp3 ;
10045 PyArrayObject *tmp4 ;
10046 PyObject * obj0 = 0 ;
10047 PyObject * obj1 = 0 ;
10048 PyObject * obj2 = 0 ;
10049 PyObject * obj3 = 0 ;
10050
10051 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10052 {
10053 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
10054 if ( tmp1 == NULL )
10055 return NULL;
10056 Alen = tmp1->dimensions[0];
10057 arg1 = (PLINT *) tmp1->data;
10058 }
10059 {
10060 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
10061 if ( tmp2 == NULL )
10062 return NULL;
10063 if ( tmp2->dimensions[0] != Alen )
10064 {
10065 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10066 return NULL;
10067 }
10068 arg2 = (PLINT *) tmp2->data;
10069 }
10070 {
10071 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
10072 if ( tmp3 == NULL )
10073 return NULL;
10074 if ( tmp3->dimensions[0] != Alen )
10075 {
10076 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10077 return NULL;
10078 }
10079 arg3 = (PLINT *) tmp3->data;
10080 }
10081 {
10082 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
10083 if ( tmp4 == NULL )
10084 return NULL;
10085 if ( tmp4->dimensions[0] != Alen )
10086 {
10087 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10088 return NULL;
10089 }
10090 arg4 = (PLFLT *) tmp4->data;
10091 arg5 = tmp4->dimensions[0];
10092 }
10093 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10094 resultobj = SWIG_Py_Void();
10095 {
10096 Py_DECREF( tmp1 );
10097 }
10098 {
10099 Py_DECREF( tmp2 );
10100 }
10101 {
10102 Py_DECREF( tmp3 );
10103 }
10104 {
10105 Py_DECREF( tmp4 );
10106 }
10107 return resultobj;
10108 fail:
10109 {
10110 Py_DECREF( tmp1 );
10111 }
10112 {
10113 Py_DECREF( tmp2 );
10114 }
10115 {
10116 Py_DECREF( tmp3 );
10117 }
10118 {
10119 Py_DECREF( tmp4 );
10120 }
10121 return NULL;
10122 }
10123
10124
10125 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10126 PyObject *resultobj = 0;
10127 PLBOOL arg1 ;
10128 PLINT arg2 ;
10129 PLFLT *arg3 = (PLFLT *) 0 ;
10130 PLFLT *arg4 = (PLFLT *) 0 ;
10131 PLFLT *arg5 = (PLFLT *) 0 ;
10132 PLFLT *arg6 = (PLFLT *) 0 ;
10133 PLBOOL *arg7 = (PLBOOL *) 0 ;
10134 int val1 ;
10135 int ecode1 = 0 ;
10136 PyArrayObject *tmp2 ;
10137 PyArrayObject *tmp4 ;
10138 PyArrayObject *tmp5 ;
10139 PyArrayObject *tmp6 ;
10140 PyArrayObject *tmp7 ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 PyObject * obj2 = 0 ;
10144 PyObject * obj3 = 0 ;
10145 PyObject * obj4 = 0 ;
10146 PyObject * obj5 = 0 ;
10147
10148 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10149 ecode1 = SWIG_AsVal_int(obj0, &val1);
10150 if (!SWIG_IsOK(ecode1)) {
10151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10152 }
10153 arg1 = (PLBOOL)(val1);
10154 {
10155 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
10156 if ( tmp2 == NULL )
10157 return NULL;
10158 arg2 = Alen = tmp2->dimensions[0];
10159 arg3 = (PLFLT *) tmp2->data;
10160 }
10161 {
10162 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
10163 if ( tmp4 == NULL )
10164 return NULL;
10165 if ( tmp4->dimensions[0] != Alen )
10166 {
10167 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10168 return NULL;
10169 }
10170 arg4 = (PLFLT *) tmp4->data;
10171 }
10172 {
10173 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
10174 if ( tmp5 == NULL )
10175 return NULL;
10176 if ( tmp5->dimensions[0] != Alen )
10177 {
10178 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10179 return NULL;
10180 }
10181 arg5 = (PLFLT *) tmp5->data;
10182 }
10183 {
10184 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
10185 if ( tmp6 == NULL )
10186 return NULL;
10187 if ( tmp6->dimensions[0] != Alen )
10188 {
10189 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10190 return NULL;
10191 }
10192 arg6 = (PLFLT *) tmp6->data;
10193 }
10194 {
10195 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, PyArray_PLINT, 1, 1 );
10196 if ( tmp7 == NULL )
10197 return NULL;
10198 if ( tmp7->dimensions[0] < Alen - 1 )
10199 {
10200 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10201 return NULL;
10202 }
10203 arg7 = (PLINT *) tmp7->data;
10204 }
10205 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10206 resultobj = SWIG_Py_Void();
10207 {
10208 Py_DECREF( tmp2 );
10209 }
10210 {
10211 Py_DECREF( tmp4 );
10212 }
10213 {
10214 Py_DECREF( tmp5 );
10215 }
10216 {
10217 Py_DECREF( tmp6 );
10218 }
10219 {
10220 Py_DECREF( tmp7 );
10221 }
10222 return resultobj;
10223 fail:
10224 {
10225 Py_DECREF( tmp2 );
10226 }
10227 {
10228 Py_DECREF( tmp4 );
10229 }
10230 {
10231 Py_DECREF( tmp5 );
10232 }
10233 {
10234 Py_DECREF( tmp6 );
10235 }
10236 {
10237 Py_DECREF( tmp7 );
10238 }
10239 return NULL;
10240 }
10241
10242
10243 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244 PyObject *resultobj = 0;
10245 PLBOOL arg1 ;
10246 PLINT arg2 ;
10247 PLFLT *arg3 = (PLFLT *) 0 ;
10248 PLFLT *arg4 = (PLFLT *) 0 ;
10249 PLFLT *arg5 = (PLFLT *) 0 ;
10250 PLFLT *arg6 = (PLFLT *) 0 ;
10251 PLFLT *arg7 = (PLFLT *) 0 ;
10252 PLBOOL *arg8 = (PLBOOL *) 0 ;
10253 int val1 ;
10254 int ecode1 = 0 ;
10255 PyArrayObject *tmp2 ;
10256 PyArrayObject *tmp4 ;
10257 PyArrayObject *tmp5 ;
10258 PyArrayObject *tmp6 ;
10259 PyArrayObject *tmp7 ;
10260 PyArrayObject *tmp8 ;
10261 PyObject * obj0 = 0 ;
10262 PyObject * obj1 = 0 ;
10263 PyObject * obj2 = 0 ;
10264 PyObject * obj3 = 0 ;
10265 PyObject * obj4 = 0 ;
10266 PyObject * obj5 = 0 ;
10267 PyObject * obj6 = 0 ;
10268
10269 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10270 ecode1 = SWIG_AsVal_int(obj0, &val1);
10271 if (!SWIG_IsOK(ecode1)) {
10272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10273 }
10274 arg1 = (PLBOOL)(val1);
10275 {
10276 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
10277 if ( tmp2 == NULL )
10278 return NULL;
10279 arg2 = Alen = tmp2->dimensions[0];
10280 arg3 = (PLFLT *) tmp2->data;
10281 }
10282 {
10283 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
10284 if ( tmp4 == NULL )
10285 return NULL;
10286 if ( tmp4->dimensions[0] != Alen )
10287 {
10288 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10289 return NULL;
10290 }
10291 arg4 = (PLFLT *) tmp4->data;
10292 }
10293 {
10294 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
10295 if ( tmp5 == NULL )
10296 return NULL;
10297 if ( tmp5->dimensions[0] != Alen )
10298 {
10299 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10300 return NULL;
10301 }
10302 arg5 = (PLFLT *) tmp5->data;
10303 }
10304 {
10305 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
10306 if ( tmp6 == NULL )
10307 return NULL;
10308 if ( tmp6->dimensions[0] != Alen )
10309 {
10310 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10311 return NULL;
10312 }
10313 arg6 = (PLFLT *) tmp6->data;
10314 }
10315 {
10316 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 1, 1 );
10317 if ( tmp7 == NULL )
10318 return NULL;
10319 if ( tmp7->dimensions[0] != Alen )
10320 {
10321 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10322 return NULL;
10323 }
10324 arg7 = (PLFLT *) tmp7->data;
10325 }
10326 {
10327 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, PyArray_PLINT, 1, 1 );
10328 if ( tmp8 == NULL )
10329 return NULL;
10330 if ( tmp8->dimensions[0] < Alen - 1 )
10331 {
10332 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10333 return NULL;
10334 }
10335 arg8 = (PLINT *) tmp8->data;
10336 }
10337 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10338 resultobj = SWIG_Py_Void();
10339 {
10340 Py_DECREF( tmp2 );
10341 }
10342 {
10343 Py_DECREF( tmp4 );
10344 }
10345 {
10346 Py_DECREF( tmp5 );
10347 }
10348 {
10349 Py_DECREF( tmp6 );
10350 }
10351 {
10352 Py_DECREF( tmp7 );
10353 }
10354 {
10355 Py_DECREF( tmp8 );
10356 }
10357 return resultobj;
10358 fail:
10359 {
10360 Py_DECREF( tmp2 );
10361 }
10362 {
10363 Py_DECREF( tmp4 );
10364 }
10365 {
10366 Py_DECREF( tmp5 );
10367 }
10368 {
10369 Py_DECREF( tmp6 );
10370 }
10371 {
10372 Py_DECREF( tmp7 );
10373 }
10374 {
10375 Py_DECREF( tmp8 );
10376 }
10377 return NULL;
10378 }
10379
10380
10381 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10382 PyObject *resultobj = 0;
10383 PLINT arg1 ;
10384 int val1 ;
10385 int ecode1 = 0 ;
10386 PyObject * obj0 = 0 ;
10387
10388 if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
10389 ecode1 = SWIG_AsVal_int(obj0, &val1);
10390 if (!SWIG_IsOK(ecode1)) {
10391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10392 }
10393 arg1 = (PLINT)(val1);
10394 plscmap1n(arg1);
10395 resultobj = SWIG_Py_Void();
10396 return resultobj;
10397 fail:
10398 return NULL;
10399 }
10400
10401
10402 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10403 PyObject *resultobj = 0;
10404 PLINT arg1 ;
10405 PLINT arg2 ;
10406 PLINT arg3 ;
10407 PLINT arg4 ;
10408 int val1 ;
10409 int ecode1 = 0 ;
10410 int val2 ;
10411 int ecode2 = 0 ;
10412 int val3 ;
10413 int ecode3 = 0 ;
10414 int val4 ;
10415 int ecode4 = 0 ;
10416 PyObject * obj0 = 0 ;
10417 PyObject * obj1 = 0 ;
10418 PyObject * obj2 = 0 ;
10419 PyObject * obj3 = 0 ;
10420
10421 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10422 ecode1 = SWIG_AsVal_int(obj0, &val1);
10423 if (!SWIG_IsOK(ecode1)) {
10424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
10425 }
10426 arg1 = (PLINT)(val1);
10427 ecode2 = SWIG_AsVal_int(obj1, &val2);
10428 if (!SWIG_IsOK(ecode2)) {
10429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
10430 }
10431 arg2 = (PLINT)(val2);
10432 ecode3 = SWIG_AsVal_int(obj2, &val3);
10433 if (!SWIG_IsOK(ecode3)) {
10434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
10435 }
10436 arg3 = (PLINT)(val3);
10437 ecode4 = SWIG_AsVal_int(obj3, &val4);
10438 if (!SWIG_IsOK(ecode4)) {
10439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
10440 }
10441 arg4 = (PLINT)(val4);
10442 plscol0(arg1,arg2,arg3,arg4);
10443 resultobj = SWIG_Py_Void();
10444 return resultobj;
10445 fail:
10446 return NULL;
10447 }
10448
10449
10450 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10451 PyObject *resultobj = 0;
10452 PLINT arg1 ;
10453 PLINT arg2 ;
10454 PLINT arg3 ;
10455 PLINT arg4 ;
10456 PLFLT arg5 ;
10457 int val1 ;
10458 int ecode1 = 0 ;
10459 int val2 ;
10460 int ecode2 = 0 ;
10461 int val3 ;
10462 int ecode3 = 0 ;
10463 int val4 ;
10464 int ecode4 = 0 ;
10465 double val5 ;
10466 int ecode5 = 0 ;
10467 PyObject * obj0 = 0 ;
10468 PyObject * obj1 = 0 ;
10469 PyObject * obj2 = 0 ;
10470 PyObject * obj3 = 0 ;
10471 PyObject * obj4 = 0 ;
10472
10473 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10474 ecode1 = SWIG_AsVal_int(obj0, &val1);
10475 if (!SWIG_IsOK(ecode1)) {
10476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
10477 }
10478 arg1 = (PLINT)(val1);
10479 ecode2 = SWIG_AsVal_int(obj1, &val2);
10480 if (!SWIG_IsOK(ecode2)) {
10481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
10482 }
10483 arg2 = (PLINT)(val2);
10484 ecode3 = SWIG_AsVal_int(obj2, &val3);
10485 if (!SWIG_IsOK(ecode3)) {
10486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
10487 }
10488 arg3 = (PLINT)(val3);
10489 ecode4 = SWIG_AsVal_int(obj3, &val4);
10490 if (!SWIG_IsOK(ecode4)) {
10491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
10492 }
10493 arg4 = (PLINT)(val4);
10494 ecode5 = SWIG_AsVal_double(obj4, &val5);
10495 if (!SWIG_IsOK(ecode5)) {
10496 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
10497 }
10498 arg5 = (PLFLT)(val5);
10499 plscol0a(arg1,arg2,arg3,arg4,arg5);
10500 resultobj = SWIG_Py_Void();
10501 return resultobj;
10502 fail:
10503 return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508 PyObject *resultobj = 0;
10509 PLINT arg1 ;
10510 PLINT arg2 ;
10511 PLINT arg3 ;
10512 int val1 ;
10513 int ecode1 = 0 ;
10514 int val2 ;
10515 int ecode2 = 0 ;
10516 int val3 ;
10517 int ecode3 = 0 ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520 PyObject * obj2 = 0 ;
10521
10522 if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
10523 ecode1 = SWIG_AsVal_int(obj0, &val1);
10524 if (!SWIG_IsOK(ecode1)) {
10525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
10526 }
10527 arg1 = (PLINT)(val1);
10528 ecode2 = SWIG_AsVal_int(obj1, &val2);
10529 if (!SWIG_IsOK(ecode2)) {
10530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
10531 }
10532 arg2 = (PLINT)(val2);
10533 ecode3 = SWIG_AsVal_int(obj2, &val3);
10534 if (!SWIG_IsOK(ecode3)) {
10535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
10536 }
10537 arg3 = (PLINT)(val3);
10538 plscolbg(arg1,arg2,arg3);
10539 resultobj = SWIG_Py_Void();
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10547 PyObject *resultobj = 0;
10548 PLINT arg1 ;
10549 PLINT arg2 ;
10550 PLINT arg3 ;
10551 PLFLT arg4 ;
10552 int val1 ;
10553 int ecode1 = 0 ;
10554 int val2 ;
10555 int ecode2 = 0 ;
10556 int val3 ;
10557 int ecode3 = 0 ;
10558 double val4 ;
10559 int ecode4 = 0 ;
10560 PyObject * obj0 = 0 ;
10561 PyObject * obj1 = 0 ;
10562 PyObject * obj2 = 0 ;
10563 PyObject * obj3 = 0 ;
10564
10565 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10566 ecode1 = SWIG_AsVal_int(obj0, &val1);
10567 if (!SWIG_IsOK(ecode1)) {
10568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
10569 }
10570 arg1 = (PLINT)(val1);
10571 ecode2 = SWIG_AsVal_int(obj1, &val2);
10572 if (!SWIG_IsOK(ecode2)) {
10573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
10574 }
10575 arg2 = (PLINT)(val2);
10576 ecode3 = SWIG_AsVal_int(obj2, &val3);
10577 if (!SWIG_IsOK(ecode3)) {
10578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
10579 }
10580 arg3 = (PLINT)(val3);
10581 ecode4 = SWIG_AsVal_double(obj3, &val4);
10582 if (!SWIG_IsOK(ecode4)) {
10583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
10584 }
10585 arg4 = (PLFLT)(val4);
10586 plscolbga(arg1,arg2,arg3,arg4);
10587 resultobj = SWIG_Py_Void();
10588 return resultobj;
10589 fail:
10590 return NULL;
10591 }
10592
10593
10594 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10595 PyObject *resultobj = 0;
10596 PLINT arg1 ;
10597 int val1 ;
10598 int ecode1 = 0 ;
10599 PyObject * obj0 = 0 ;
10600
10601 if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
10602 ecode1 = SWIG_AsVal_int(obj0, &val1);
10603 if (!SWIG_IsOK(ecode1)) {
10604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
10605 }
10606 arg1 = (PLINT)(val1);
10607 plscolor(arg1);
10608 resultobj = SWIG_Py_Void();
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10616 PyObject *resultobj = 0;
10617 PLINT arg1 ;
10618 int val1 ;
10619 int ecode1 = 0 ;
10620 PyObject * obj0 = 0 ;
10621
10622 if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
10623 ecode1 = SWIG_AsVal_int(obj0, &val1);
10624 if (!SWIG_IsOK(ecode1)) {
10625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
10626 }
10627 arg1 = (PLINT)(val1);
10628 plscompression(arg1);
10629 resultobj = SWIG_Py_Void();
10630 return resultobj;
10631 fail:
10632 return NULL;
10633 }
10634
10635
10636 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10637 PyObject *resultobj = 0;
10638 char *arg1 = (char *) 0 ;
10639 int res1 ;
10640 char *buf1 = 0 ;
10641 int alloc1 = 0 ;
10642 PyObject * obj0 = 0 ;
10643
10644 if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
10645 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
10646 if (!SWIG_IsOK(res1)) {
10647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
10648 }
10649 arg1 = (char *)(buf1);
10650 plsdev((char const *)arg1);
10651 resultobj = SWIG_Py_Void();
10652 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10653 return resultobj;
10654 fail:
10655 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10656 return NULL;
10657 }
10658
10659
10660 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10661 PyObject *resultobj = 0;
10662 PLFLT arg1 ;
10663 PLFLT arg2 ;
10664 PLFLT arg3 ;
10665 PLFLT arg4 ;
10666 double val1 ;
10667 int ecode1 = 0 ;
10668 double val2 ;
10669 int ecode2 = 0 ;
10670 double val3 ;
10671 int ecode3 = 0 ;
10672 double val4 ;
10673 int ecode4 = 0 ;
10674 PyObject * obj0 = 0 ;
10675 PyObject * obj1 = 0 ;
10676 PyObject * obj2 = 0 ;
10677 PyObject * obj3 = 0 ;
10678
10679 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10680 ecode1 = SWIG_AsVal_double(obj0, &val1);
10681 if (!SWIG_IsOK(ecode1)) {
10682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
10683 }
10684 arg1 = (PLFLT)(val1);
10685 ecode2 = SWIG_AsVal_double(obj1, &val2);
10686 if (!SWIG_IsOK(ecode2)) {
10687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
10688 }
10689 arg2 = (PLFLT)(val2);
10690 ecode3 = SWIG_AsVal_double(obj2, &val3);
10691 if (!SWIG_IsOK(ecode3)) {
10692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
10693 }
10694 arg3 = (PLFLT)(val3);
10695 ecode4 = SWIG_AsVal_double(obj3, &val4);
10696 if (!SWIG_IsOK(ecode4)) {
10697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
10698 }
10699 arg4 = (PLFLT)(val4);
10700 plsdidev(arg1,arg2,arg3,arg4);
10701 resultobj = SWIG_Py_Void();
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10709 PyObject *resultobj = 0;
10710 PLINT arg1 ;
10711 PLINT arg2 ;
10712 PLINT arg3 ;
10713 PLINT arg4 ;
10714 PLFLT arg5 ;
10715 PLFLT arg6 ;
10716 int val1 ;
10717 int ecode1 = 0 ;
10718 int val2 ;
10719 int ecode2 = 0 ;
10720 int val3 ;
10721 int ecode3 = 0 ;
10722 int val4 ;
10723 int ecode4 = 0 ;
10724 double val5 ;
10725 int ecode5 = 0 ;
10726 double val6 ;
10727 int ecode6 = 0 ;
10728 PyObject * obj0 = 0 ;
10729 PyObject * obj1 = 0 ;
10730 PyObject * obj2 = 0 ;
10731 PyObject * obj3 = 0 ;
10732 PyObject * obj4 = 0 ;
10733 PyObject * obj5 = 0 ;
10734
10735 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10736 ecode1 = SWIG_AsVal_int(obj0, &val1);
10737 if (!SWIG_IsOK(ecode1)) {
10738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
10739 }
10740 arg1 = (PLINT)(val1);
10741 ecode2 = SWIG_AsVal_int(obj1, &val2);
10742 if (!SWIG_IsOK(ecode2)) {
10743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
10744 }
10745 arg2 = (PLINT)(val2);
10746 ecode3 = SWIG_AsVal_int(obj2, &val3);
10747 if (!SWIG_IsOK(ecode3)) {
10748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
10749 }
10750 arg3 = (PLINT)(val3);
10751 ecode4 = SWIG_AsVal_int(obj3, &val4);
10752 if (!SWIG_IsOK(ecode4)) {
10753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
10754 }
10755 arg4 = (PLINT)(val4);
10756 ecode5 = SWIG_AsVal_double(obj4, &val5);
10757 if (!SWIG_IsOK(ecode5)) {
10758 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
10759 }
10760 arg5 = (PLFLT)(val5);
10761 ecode6 = SWIG_AsVal_double(obj5, &val6);
10762 if (!SWIG_IsOK(ecode6)) {
10763 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
10764 }
10765 arg6 = (PLFLT)(val6);
10766 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
10767 resultobj = SWIG_Py_Void();
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 PyObject *resultobj = 0;
10776 PLFLT arg1 ;
10777 double val1 ;
10778 int ecode1 = 0 ;
10779 PyObject * obj0 = 0 ;
10780
10781 if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
10782 ecode1 = SWIG_AsVal_double(obj0, &val1);
10783 if (!SWIG_IsOK(ecode1)) {
10784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
10785 }
10786 arg1 = (PLFLT)(val1);
10787 plsdiori(arg1);
10788 resultobj = SWIG_Py_Void();
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10796 PyObject *resultobj = 0;
10797 PLFLT arg1 ;
10798 PLFLT arg2 ;
10799 PLFLT arg3 ;
10800 PLFLT arg4 ;
10801 double val1 ;
10802 int ecode1 = 0 ;
10803 double val2 ;
10804 int ecode2 = 0 ;
10805 double val3 ;
10806 int ecode3 = 0 ;
10807 double val4 ;
10808 int ecode4 = 0 ;
10809 PyObject * obj0 = 0 ;
10810 PyObject * obj1 = 0 ;
10811 PyObject * obj2 = 0 ;
10812 PyObject * obj3 = 0 ;
10813
10814 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10815 ecode1 = SWIG_AsVal_double(obj0, &val1);
10816 if (!SWIG_IsOK(ecode1)) {
10817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
10818 }
10819 arg1 = (PLFLT)(val1);
10820 ecode2 = SWIG_AsVal_double(obj1, &val2);
10821 if (!SWIG_IsOK(ecode2)) {
10822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
10823 }
10824 arg2 = (PLFLT)(val2);
10825 ecode3 = SWIG_AsVal_double(obj2, &val3);
10826 if (!SWIG_IsOK(ecode3)) {
10827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
10828 }
10829 arg3 = (PLFLT)(val3);
10830 ecode4 = SWIG_AsVal_double(obj3, &val4);
10831 if (!SWIG_IsOK(ecode4)) {
10832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
10833 }
10834 arg4 = (PLFLT)(val4);
10835 plsdiplt(arg1,arg2,arg3,arg4);
10836 resultobj = SWIG_Py_Void();
10837 return resultobj;
10838 fail:
10839 return NULL;
10840 }
10841
10842
10843 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10844 PyObject *resultobj = 0;
10845 PLFLT arg1 ;
10846 PLFLT arg2 ;
10847 PLFLT arg3 ;
10848 PLFLT arg4 ;
10849 double val1 ;
10850 int ecode1 = 0 ;
10851 double val2 ;
10852 int ecode2 = 0 ;
10853 double val3 ;
10854 int ecode3 = 0 ;
10855 double val4 ;
10856 int ecode4 = 0 ;
10857 PyObject * obj0 = 0 ;
10858 PyObject * obj1 = 0 ;
10859 PyObject * obj2 = 0 ;
10860 PyObject * obj3 = 0 ;
10861
10862 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10863 ecode1 = SWIG_AsVal_double(obj0, &val1);
10864 if (!SWIG_IsOK(ecode1)) {
10865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
10866 }
10867 arg1 = (PLFLT)(val1);
10868 ecode2 = SWIG_AsVal_double(obj1, &val2);
10869 if (!SWIG_IsOK(ecode2)) {
10870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
10871 }
10872 arg2 = (PLFLT)(val2);
10873 ecode3 = SWIG_AsVal_double(obj2, &val3);
10874 if (!SWIG_IsOK(ecode3)) {
10875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
10876 }
10877 arg3 = (PLFLT)(val3);
10878 ecode4 = SWIG_AsVal_double(obj3, &val4);
10879 if (!SWIG_IsOK(ecode4)) {
10880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
10881 }
10882 arg4 = (PLFLT)(val4);
10883 plsdiplz(arg1,arg2,arg3,arg4);
10884 resultobj = SWIG_Py_Void();
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10892 PyObject *resultobj = 0;
10893 unsigned int arg1 ;
10894 unsigned int val1 ;
10895 int ecode1 = 0 ;
10896 PyObject * obj0 = 0 ;
10897
10898 if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
10899 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
10900 if (!SWIG_IsOK(ecode1)) {
10901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
10902 }
10903 arg1 = (unsigned int)(val1);
10904 plseed(arg1);
10905 resultobj = SWIG_Py_Void();
10906 return resultobj;
10907 fail:
10908 return NULL;
10909 }
10910
10911
10912 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10913 PyObject *resultobj = 0;
10914 char arg1 ;
10915 char val1 ;
10916 int ecode1 = 0 ;
10917 PyObject * obj0 = 0 ;
10918
10919 if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
10920 ecode1 = SWIG_AsVal_char(obj0, &val1);
10921 if (!SWIG_IsOK(ecode1)) {
10922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
10923 }
10924 arg1 = (char)(val1);
10925 plsesc(arg1);
10926 resultobj = SWIG_Py_Void();
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934 PyObject *resultobj = 0;
10935 char *arg1 = (char *) 0 ;
10936 char *arg2 = (char *) 0 ;
10937 int res1 ;
10938 char *buf1 = 0 ;
10939 int alloc1 = 0 ;
10940 int res2 ;
10941 char *buf2 = 0 ;
10942 int alloc2 = 0 ;
10943 PyObject * obj0 = 0 ;
10944 PyObject * obj1 = 0 ;
10945 PLINT result;
10946
10947 if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
10948 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
10949 if (!SWIG_IsOK(res1)) {
10950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
10951 }
10952 arg1 = (char *)(buf1);
10953 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10954 if (!SWIG_IsOK(res2)) {
10955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
10956 }
10957 arg2 = (char *)(buf2);
10958 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
10959 resultobj = SWIG_From_int((int)(result));
10960 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10961 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10962 return resultobj;
10963 fail:
10964 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10965 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10966 return NULL;
10967 }
10968
10969
10970 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971 PyObject *resultobj = 0;
10972 PLINT arg1 ;
10973 PLINT arg2 ;
10974 PLINT arg3 ;
10975 int val1 ;
10976 int ecode1 = 0 ;
10977 int val2 ;
10978 int ecode2 = 0 ;
10979 int val3 ;
10980 int ecode3 = 0 ;
10981 PyObject * obj0 = 0 ;
10982 PyObject * obj1 = 0 ;
10983 PyObject * obj2 = 0 ;
10984
10985 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
10986 ecode1 = SWIG_AsVal_int(obj0, &val1);
10987 if (!SWIG_IsOK(ecode1)) {
10988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
10989 }
10990 arg1 = (PLINT)(val1);
10991 ecode2 = SWIG_AsVal_int(obj1, &val2);
10992 if (!SWIG_IsOK(ecode2)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
10994 }
10995 arg2 = (PLINT)(val2);
10996 ecode3 = SWIG_AsVal_int(obj2, &val3);
10997 if (!SWIG_IsOK(ecode3)) {
10998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
10999 }
11000 arg3 = (PLINT)(val3);
11001 plsfam(arg1,arg2,arg3);
11002 resultobj = SWIG_Py_Void();
11003 return resultobj;
11004 fail:
11005 return NULL;
11006 }
11007
11008
11009 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11010 PyObject *resultobj = 0;
11011 PLUNICODE arg1 ;
11012 unsigned int val1 ;
11013 int ecode1 = 0 ;
11014 PyObject * obj0 = 0 ;
11015
11016 if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11017 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11018 if (!SWIG_IsOK(ecode1)) {
11019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11020 }
11021 arg1 = (PLUNICODE)(val1);
11022 plsfci(arg1);
11023 resultobj = SWIG_Py_Void();
11024 return resultobj;
11025 fail:
11026 return NULL;
11027 }
11028
11029
11030 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11031 PyObject *resultobj = 0;
11032 char *arg1 = (char *) 0 ;
11033 int res1 ;
11034 char *buf1 = 0 ;
11035 int alloc1 = 0 ;
11036 PyObject * obj0 = 0 ;
11037
11038 if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11039 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11040 if (!SWIG_IsOK(res1)) {
11041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11042 }
11043 arg1 = (char *)(buf1);
11044 plsfnam((char const *)arg1);
11045 resultobj = SWIG_Py_Void();
11046 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11047 return resultobj;
11048 fail:
11049 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11050 return NULL;
11051 }
11052
11053
11054 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055 PyObject *resultobj = 0;
11056 PLINT arg1 ;
11057 PLINT arg2 ;
11058 PLINT arg3 ;
11059 int val1 ;
11060 int ecode1 = 0 ;
11061 int val2 ;
11062 int ecode2 = 0 ;
11063 int val3 ;
11064 int ecode3 = 0 ;
11065 PyObject * obj0 = 0 ;
11066 PyObject * obj1 = 0 ;
11067 PyObject * obj2 = 0 ;
11068
11069 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11070 ecode1 = SWIG_AsVal_int(obj0, &val1);
11071 if (!SWIG_IsOK(ecode1)) {
11072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11073 }
11074 arg1 = (PLINT)(val1);
11075 ecode2 = SWIG_AsVal_int(obj1, &val2);
11076 if (!SWIG_IsOK(ecode2)) {
11077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11078 }
11079 arg2 = (PLINT)(val2);
11080 ecode3 = SWIG_AsVal_int(obj2, &val3);
11081 if (!SWIG_IsOK(ecode3)) {
11082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11083 }
11084 arg3 = (PLINT)(val3);
11085 plsfont(arg1,arg2,arg3);
11086 resultobj = SWIG_Py_Void();
11087 return resultobj;
11088 fail:
11089 return NULL;
11090 }
11091
11092
11093 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094 PyObject *resultobj = 0;
11095 PLFLT **arg1 = (PLFLT **) 0 ;
11096 PLINT arg2 ;
11097 PLINT arg3 ;
11098 defined_func arg4 = (defined_func) 0 ;
11099 PLFLT arg5 ;
11100 PLFLT arg6 ;
11101 PLFLT arg7 ;
11102 PLFLT arg8 ;
11103 PLFLT *arg9 = (PLFLT *) 0 ;
11104 PLINT arg10 ;
11105 PLINT arg11 ;
11106 PLINT arg12 ;
11107 PLINT arg13 ;
11108 fill_func arg14 = (fill_func) 0 ;
11109 PLBOOL arg15 ;
11110 pltr_func arg16 = (pltr_func) 0 ;
11111 PLPointer arg17 = (PLPointer) 0 ;
11112 PyArrayObject *tmp1 ;
11113 double val5 ;
11114 int ecode5 = 0 ;
11115 double val6 ;
11116 int ecode6 = 0 ;
11117 double val7 ;
11118 int ecode7 = 0 ;
11119 double val8 ;
11120 int ecode8 = 0 ;
11121 PyArrayObject *tmp9 ;
11122 int val11 ;
11123 int ecode11 = 0 ;
11124 int val12 ;
11125 int ecode12 = 0 ;
11126 int val13 ;
11127 int ecode13 = 0 ;
11128 int val15 ;
11129 int ecode15 = 0 ;
11130 PyObject * obj0 = 0 ;
11131 PyObject * obj1 = 0 ;
11132 PyObject * obj2 = 0 ;
11133 PyObject * obj3 = 0 ;
11134 PyObject * obj4 = 0 ;
11135 PyObject * obj5 = 0 ;
11136 PyObject * obj6 = 0 ;
11137 PyObject * obj7 = 0 ;
11138 PyObject * obj8 = 0 ;
11139 PyObject * obj9 = 0 ;
11140 PyObject * obj10 = 0 ;
11141 PyObject * obj11 = 0 ;
11142
11143 {
11144 python_pltr = 0;
11145 arg16 = NULL;
11146 }
11147 {
11148 arg17 = NULL;
11149 }
11150 {
11151 arg4 = NULL;
11152 }
11153 {
11154 arg14 = plfill;
11155 }
11156 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11157 {
11158 int i, size;
11159 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
11160 if ( tmp1 == NULL )
11161 return NULL;
11162 Xlen = arg2 = tmp1->dimensions[0];
11163 Ylen = arg3 = tmp1->dimensions[1];
11164 size = sizeof ( PLFLT ) * arg3;
11165 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11166 for ( i = 0; i < arg2; i++ )
11167 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
11168 }
11169 ecode5 = SWIG_AsVal_double(obj1, &val5);
11170 if (!SWIG_IsOK(ecode5)) {
11171 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11172 }
11173 arg5 = (PLFLT)(val5);
11174 ecode6 = SWIG_AsVal_double(obj2, &val6);
11175 if (!SWIG_IsOK(ecode6)) {
11176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11177 }
11178 arg6 = (PLFLT)(val6);
11179 ecode7 = SWIG_AsVal_double(obj3, &val7);
11180 if (!SWIG_IsOK(ecode7)) {
11181 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11182 }
11183 arg7 = (PLFLT)(val7);
11184 ecode8 = SWIG_AsVal_double(obj4, &val8);
11185 if (!SWIG_IsOK(ecode8)) {
11186 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11187 }
11188 arg8 = (PLFLT)(val8);
11189 {
11190 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 1, 1 );
11191 if ( tmp9 == NULL )
11192 return NULL;
11193 arg10 = tmp9->dimensions[0];
11194 arg9 = (PLFLT *) tmp9->data;
11195 }
11196 ecode11 = SWIG_AsVal_int(obj6, &val11);
11197 if (!SWIG_IsOK(ecode11)) {
11198 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
11199 }
11200 arg11 = (PLINT)(val11);
11201 ecode12 = SWIG_AsVal_int(obj7, &val12);
11202 if (!SWIG_IsOK(ecode12)) {
11203 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11204 }
11205 arg12 = (PLINT)(val12);
11206 ecode13 = SWIG_AsVal_int(obj8, &val13);
11207 if (!SWIG_IsOK(ecode13)) {
11208 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLINT""'");
11209 }
11210 arg13 = (PLINT)(val13);
11211 ecode15 = SWIG_AsVal_int(obj9, &val15);
11212 if (!SWIG_IsOK(ecode15)) {
11213 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11214 }
11215 arg15 = (PLBOOL)(val15);
11216 if (obj10) {
11217 {
11218
11219 if ( obj10 == Py_None )
11220 {
11221 arg16 = NULL;
11222 }
11223 else
11224 {
11225 if ( !PyCallable_Check( (PyObject *) obj10 ) )
11226 {
11227 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11228 return NULL;
11229 }
11230 arg16 = marshal_pltr( obj10 );
11231 }
11232 }
11233 }
11234 if (obj11) {
11235 {
11236 if ( obj11 == Py_None )
11237 arg17 = NULL;
11238 else
11239 {
11240 arg17 = marshal_PLPointer( obj11, 0 );
11241 }
11242 }
11243 }
11244 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11245 resultobj = SWIG_Py_Void();
11246 {
11247 Py_DECREF( tmp1 );
11248 free( arg1 );
11249 }
11250 {
11251 Py_DECREF( tmp9 );
11252 }
11253 {
11254 cleanup_pltr();
11255 }
11256 {
11257 cleanup_PLPointer();
11258 }
11259 return resultobj;
11260 fail:
11261 {
11262 Py_DECREF( tmp1 );
11263 free( arg1 );
11264 }
11265 {
11266 Py_DECREF( tmp9 );
11267 }
11268 {
11269 cleanup_pltr();
11270 }
11271 {
11272 cleanup_PLPointer();
11273 }
11274 return NULL;
11275 }
11276
11277
11278 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11279 PyObject *resultobj = 0;
11280 PLFLT **arg1 = (PLFLT **) 0 ;
11281 PLINT arg2 ;
11282 PLINT arg3 ;
11283 defined_func arg4 = (defined_func) 0 ;
11284 PLFLT arg5 ;
11285 PLFLT arg6 ;
11286 PLFLT arg7 ;
11287 PLFLT arg8 ;
11288 PLFLT arg9 ;
11289 PLFLT arg10 ;
11290 PLINT arg11 ;
11291 PLFLT arg12 ;
11292 PLINT arg13 ;
11293 PLINT arg14 ;
11294 PLINT arg15 ;
11295 PLINT arg16 ;
11296 PLINT arg17 ;
11297 fill_func arg18 = (fill_func) 0 ;
11298 PLBOOL arg19 ;
11299 pltr_func arg20 = (pltr_func) 0 ;
11300 PLPointer arg21 = (PLPointer) 0 ;
11301 PyArrayObject *tmp1 ;
11302 double val5 ;
11303 int ecode5 = 0 ;
11304 double val6 ;
11305 int ecode6 = 0 ;
11306 double val7 ;
11307 int ecode7 = 0 ;
11308 double val8 ;
11309 int ecode8 = 0 ;
11310 double val9 ;
11311 int ecode9 = 0 ;
11312 double val10 ;
11313 int ecode10 = 0 ;
11314 int val11 ;
11315 int ecode11 = 0 ;
11316 double val12 ;
11317 int ecode12 = 0 ;
11318 int val13 ;
11319 int ecode13 = 0 ;
11320 int val14 ;
11321 int ecode14 = 0 ;
11322 int val15 ;
11323 int ecode15 = 0 ;
11324 int val16 ;
11325 int ecode16 = 0 ;
11326 int val17 ;
11327 int ecode17 = 0 ;
11328 int val19 ;
11329 int ecode19 = 0 ;
11330 PyObject * obj0 = 0 ;
11331 PyObject * obj1 = 0 ;
11332 PyObject * obj2 = 0 ;
11333 PyObject * obj3 = 0 ;
11334 PyObject * obj4 = 0 ;
11335 PyObject * obj5 = 0 ;
11336 PyObject * obj6 = 0 ;
11337 PyObject * obj7 = 0 ;
11338 PyObject * obj8 = 0 ;
11339 PyObject * obj9 = 0 ;
11340 PyObject * obj10 = 0 ;
11341 PyObject * obj11 = 0 ;
11342 PyObject * obj12 = 0 ;
11343 PyObject * obj13 = 0 ;
11344 PyObject * obj14 = 0 ;
11345 PyObject * obj15 = 0 ;
11346 PyObject * obj16 = 0 ;
11347
11348 {
11349 python_pltr = 0;
11350 arg20 = NULL;
11351 }
11352 {
11353 arg21 = NULL;
11354 }
11355 {
11356 arg4 = NULL;
11357 }
11358 {
11359 arg18 = plfill;
11360 }
11361 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;
11362 {
11363 int i, size;
11364 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
11365 if ( tmp1 == NULL )
11366 return NULL;
11367 Xlen = arg2 = tmp1->dimensions[0];
11368 Ylen = arg3 = tmp1->dimensions[1];
11369 size = sizeof ( PLFLT ) * arg3;
11370 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11371 for ( i = 0; i < arg2; i++ )
11372 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
11373 }
11374 ecode5 = SWIG_AsVal_double(obj1, &val5);
11375 if (!SWIG_IsOK(ecode5)) {
11376 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11377 }
11378 arg5 = (PLFLT)(val5);
11379 ecode6 = SWIG_AsVal_double(obj2, &val6);
11380 if (!SWIG_IsOK(ecode6)) {
11381 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11382 }
11383 arg6 = (PLFLT)(val6);
11384 ecode7 = SWIG_AsVal_double(obj3, &val7);
11385 if (!SWIG_IsOK(ecode7)) {
11386 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11387 }
11388 arg7 = (PLFLT)(val7);
11389 ecode8 = SWIG_AsVal_double(obj4, &val8);
11390 if (!SWIG_IsOK(ecode8)) {
11391 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11392 }
11393 arg8 = (PLFLT)(val8);
11394 ecode9 = SWIG_AsVal_double(obj5, &val9);
11395 if (!SWIG_IsOK(ecode9)) {
11396 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11397 }
11398 arg9 = (PLFLT)(val9);
11399 ecode10 = SWIG_AsVal_double(obj6, &val10);
11400 if (!SWIG_IsOK(ecode10)) {
11401 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11402 }
11403 arg10 = (PLFLT)(val10);
11404 ecode11 = SWIG_AsVal_int(obj7, &val11);
11405 if (!SWIG_IsOK(ecode11)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11407 }
11408 arg11 = (PLINT)(val11);
11409 ecode12 = SWIG_AsVal_double(obj8, &val12);
11410 if (!SWIG_IsOK(ecode12)) {
11411 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11412 }
11413 arg12 = (PLFLT)(val12);
11414 ecode13 = SWIG_AsVal_int(obj9, &val13);
11415 if (!SWIG_IsOK(ecode13)) {
11416 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
11417 }
11418 arg13 = (PLINT)(val13);
11419 ecode14 = SWIG_AsVal_int(obj10, &val14);
11420 if (!SWIG_IsOK(ecode14)) {
11421 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11422 }
11423 arg14 = (PLINT)(val14);
11424 ecode15 = SWIG_AsVal_int(obj11, &val15);
11425 if (!SWIG_IsOK(ecode15)) {
11426 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
11427 }
11428 arg15 = (PLINT)(val15);
11429 ecode16 = SWIG_AsVal_int(obj12, &val16);
11430 if (!SWIG_IsOK(ecode16)) {
11431 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11432 }
11433 arg16 = (PLINT)(val16);
11434 ecode17 = SWIG_AsVal_int(obj13, &val17);
11435 if (!SWIG_IsOK(ecode17)) {
11436 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
11437 }
11438 arg17 = (PLINT)(val17);
11439 ecode19 = SWIG_AsVal_int(obj14, &val19);
11440 if (!SWIG_IsOK(ecode19)) {
11441 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
11442 }
11443 arg19 = (PLBOOL)(val19);
11444 if (obj15) {
11445 {
11446
11447 if ( obj15 == Py_None )
11448 {
11449 arg20 = NULL;
11450 }
11451 else
11452 {
11453 if ( !PyCallable_Check( (PyObject *) obj15 ) )
11454 {
11455 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11456 return NULL;
11457 }
11458 arg20 = marshal_pltr( obj15 );
11459 }
11460 }
11461 }
11462 if (obj16) {
11463 {
11464 if ( obj16 == Py_None )
11465 arg21 = NULL;
11466 else
11467 {
11468 arg21 = marshal_PLPointer( obj16, 0 );
11469 }
11470 }
11471 }
11472 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
11473 resultobj = SWIG_Py_Void();
11474 {
11475 Py_DECREF( tmp1 );
11476 free( arg1 );
11477 }
11478 {
11479 cleanup_pltr();
11480 }
11481 {
11482 cleanup_PLPointer();
11483 }
11484 return resultobj;
11485 fail:
11486 {
11487 Py_DECREF( tmp1 );
11488 free( arg1 );
11489 }
11490 {
11491 cleanup_pltr();
11492 }
11493 {
11494 cleanup_PLPointer();
11495 }
11496 return NULL;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11501 PyObject *resultobj = 0;
11502 label_func arg1 = (label_func) 0 ;
11503 PLPointer arg2 = (PLPointer) 0 ;
11504 int res2 ;
11505 PyObject * obj0 = 0 ;
11506 PyObject * obj1 = 0 ;
11507
11508 if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
11509 {
11510
11511 if ( python_label )
11512 {
11513 Py_XDECREF( python_label );
11514 python_label = 0;
11515 }
11516
11517 if ( obj0 == Py_None )
11518 {
11519 arg1 = NULL;
11520 }
11521 else
11522 {
11523 if ( !PyCallable_Check( (PyObject *) obj0 ) )
11524 {
11525 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
11526 return NULL;
11527 }
11528
11529 Py_XINCREF( (PyObject *) obj0 );
11530 python_label = (PyObject *) obj0;
11531
11532 arg1 = do_label_callback;
11533 }
11534 }
11535 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
11536 if (!SWIG_IsOK(res2)) {
11537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
11538 }
11539 plslabelfunc(arg1,arg2);
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11548 PyObject *resultobj = 0;
11549 PLFLT arg1 ;
11550 PLFLT arg2 ;
11551 double val1 ;
11552 int ecode1 = 0 ;
11553 double val2 ;
11554 int ecode2 = 0 ;
11555 PyObject * obj0 = 0 ;
11556 PyObject * obj1 = 0 ;
11557
11558 if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
11559 ecode1 = SWIG_AsVal_double(obj0, &val1);
11560 if (!SWIG_IsOK(ecode1)) {
11561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
11562 }
11563 arg1 = (PLFLT)(val1);
11564 ecode2 = SWIG_AsVal_double(obj1, &val2);
11565 if (!SWIG_IsOK(ecode2)) {
11566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
11567 }
11568 arg2 = (PLFLT)(val2);
11569 plsmaj(arg1,arg2);
11570 resultobj = SWIG_Py_Void();
11571 return resultobj;
11572 fail:
11573 return NULL;
11574 }
11575
11576
11577 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11578 PyObject *resultobj = 0;
11579 PLINT arg1 ;
11580 PLINT arg2 ;
11581 void *arg3 = (void *) 0 ;
11582 int val1 ;
11583 int ecode1 = 0 ;
11584 int val2 ;
11585 int ecode2 = 0 ;
11586 int res3 ;
11587 Py_ssize_t size3 = 0 ;
11588 void *buf3 = 0 ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 PyObject * obj2 = 0 ;
11592
11593 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
11594 ecode1 = SWIG_AsVal_int(obj0, &val1);
11595 if (!SWIG_IsOK(ecode1)) {
11596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
11597 }
11598 arg1 = (PLINT)(val1);
11599 ecode2 = SWIG_AsVal_int(obj1, &val2);
11600 if (!SWIG_IsOK(ecode2)) {
11601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
11602 }
11603 arg2 = (PLINT)(val2);
11604 {
11605 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
11606 if (res3<0) {
11607 PyErr_Clear();
11608 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
11609 }
11610 arg3 = (void *) buf3;
11611 }
11612 plsmem(arg1,arg2,arg3);
11613 resultobj = SWIG_Py_Void();
11614 return resultobj;
11615 fail:
11616 return NULL;
11617 }
11618
11619
11620 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11621 PyObject *resultobj = 0;
11622 PLINT arg1 ;
11623 PLINT arg2 ;
11624 void *arg3 = (void *) 0 ;
11625 int val1 ;
11626 int ecode1 = 0 ;
11627 int val2 ;
11628 int ecode2 = 0 ;
11629 int res3 ;
11630 Py_ssize_t size3 = 0 ;
11631 void *buf3 = 0 ;
11632 PyObject * obj0 = 0 ;
11633 PyObject * obj1 = 0 ;
11634 PyObject * obj2 = 0 ;
11635
11636 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
11637 ecode1 = SWIG_AsVal_int(obj0, &val1);
11638 if (!SWIG_IsOK(ecode1)) {
11639 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
11640 }
11641 arg1 = (PLINT)(val1);
11642 ecode2 = SWIG_AsVal_int(obj1, &val2);
11643 if (!SWIG_IsOK(ecode2)) {
11644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
11645 }
11646 arg2 = (PLINT)(val2);
11647 {
11648 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
11649 if (res3<0) {
11650 PyErr_Clear();
11651 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
11652 }
11653 arg3 = (void *) buf3;
11654 }
11655 plsmema(arg1,arg2,arg3);
11656 resultobj = SWIG_Py_Void();
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 PyObject *resultobj = 0;
11665 PLFLT arg1 ;
11666 PLFLT arg2 ;
11667 double val1 ;
11668 int ecode1 = 0 ;
11669 double val2 ;
11670 int ecode2 = 0 ;
11671 PyObject * obj0 = 0 ;
11672 PyObject * obj1 = 0 ;
11673
11674 if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
11675 ecode1 = SWIG_AsVal_double(obj0, &val1);
11676 if (!SWIG_IsOK(ecode1)) {
11677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
11678 }
11679 arg1 = (PLFLT)(val1);
11680 ecode2 = SWIG_AsVal_double(obj1, &val2);
11681 if (!SWIG_IsOK(ecode2)) {
11682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
11683 }
11684 arg2 = (PLFLT)(val2);
11685 plsmin(arg1,arg2);
11686 resultobj = SWIG_Py_Void();
11687 return resultobj;
11688 fail:
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *resultobj = 0;
11695 PLINT arg1 ;
11696 int val1 ;
11697 int ecode1 = 0 ;
11698 PyObject * obj0 = 0 ;
11699
11700 if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
11701 ecode1 = SWIG_AsVal_int(obj0, &val1);
11702 if (!SWIG_IsOK(ecode1)) {
11703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
11704 }
11705 arg1 = (PLINT)(val1);
11706 plsori(arg1);
11707 resultobj = SWIG_Py_Void();
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11715 PyObject *resultobj = 0;
11716 PLFLT arg1 ;
11717 PLFLT arg2 ;
11718 PLINT arg3 ;
11719 PLINT arg4 ;
11720 PLINT arg5 ;
11721 PLINT arg6 ;
11722 double val1 ;
11723 int ecode1 = 0 ;
11724 double val2 ;
11725 int ecode2 = 0 ;
11726 int val3 ;
11727 int ecode3 = 0 ;
11728 int val4 ;
11729 int ecode4 = 0 ;
11730 int val5 ;
11731 int ecode5 = 0 ;
11732 int val6 ;
11733 int ecode6 = 0 ;
11734 PyObject * obj0 = 0 ;
11735 PyObject * obj1 = 0 ;
11736 PyObject * obj2 = 0 ;
11737 PyObject * obj3 = 0 ;
11738 PyObject * obj4 = 0 ;
11739 PyObject * obj5 = 0 ;
11740
11741 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11742 ecode1 = SWIG_AsVal_double(obj0, &val1);
11743 if (!SWIG_IsOK(ecode1)) {
11744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
11745 }
11746 arg1 = (PLFLT)(val1);
11747 ecode2 = SWIG_AsVal_double(obj1, &val2);
11748 if (!SWIG_IsOK(ecode2)) {
11749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
11750 }
11751 arg2 = (PLFLT)(val2);
11752 ecode3 = SWIG_AsVal_int(obj2, &val3);
11753 if (!SWIG_IsOK(ecode3)) {
11754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
11755 }
11756 arg3 = (PLINT)(val3);
11757 ecode4 = SWIG_AsVal_int(obj3, &val4);
11758 if (!SWIG_IsOK(ecode4)) {
11759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
11760 }
11761 arg4 = (PLINT)(val4);
11762 ecode5 = SWIG_AsVal_int(obj4, &val5);
11763 if (!SWIG_IsOK(ecode5)) {
11764 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
11765 }
11766 arg5 = (PLINT)(val5);
11767 ecode6 = SWIG_AsVal_int(obj5, &val6);
11768 if (!SWIG_IsOK(ecode6)) {
11769 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
11770 }
11771 arg6 = (PLINT)(val6);
11772 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
11773 resultobj = SWIG_Py_Void();
11774 return resultobj;
11775 fail:
11776 return NULL;
11777 }
11778
11779
11780 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11781 PyObject *resultobj = 0;
11782 char *arg1 = (char *) 0 ;
11783 int res1 ;
11784 char *buf1 = 0 ;
11785 int alloc1 = 0 ;
11786 PyObject * obj0 = 0 ;
11787
11788 if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
11789 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11790 if (!SWIG_IsOK(res1)) {
11791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
11792 }
11793 arg1 = (char *)(buf1);
11794 plspal0((char const *)arg1);
11795 resultobj = SWIG_Py_Void();
11796 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11797 return resultobj;
11798 fail:
11799 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11800 return NULL;
11801 }
11802
11803
11804 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11805 PyObject *resultobj = 0;
11806 char *arg1 = (char *) 0 ;
11807 PLBOOL arg2 ;
11808 int res1 ;
11809 char *buf1 = 0 ;
11810 int alloc1 = 0 ;
11811 int val2 ;
11812 int ecode2 = 0 ;
11813 PyObject * obj0 = 0 ;
11814 PyObject * obj1 = 0 ;
11815
11816 if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
11817 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
11820 }
11821 arg1 = (char *)(buf1);
11822 ecode2 = SWIG_AsVal_int(obj1, &val2);
11823 if (!SWIG_IsOK(ecode2)) {
11824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
11825 }
11826 arg2 = (PLBOOL)(val2);
11827 plspal1((char const *)arg1,arg2);
11828 resultobj = SWIG_Py_Void();
11829 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11830 return resultobj;
11831 fail:
11832 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11833 return NULL;
11834 }
11835
11836
11837 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11838 PyObject *resultobj = 0;
11839 PLBOOL arg1 ;
11840 int val1 ;
11841 int ecode1 = 0 ;
11842 PyObject * obj0 = 0 ;
11843
11844 if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
11845 ecode1 = SWIG_AsVal_int(obj0, &val1);
11846 if (!SWIG_IsOK(ecode1)) {
11847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
11848 }
11849 arg1 = (PLBOOL)(val1);
11850 plspause(arg1);
11851 resultobj = SWIG_Py_Void();
11852 return resultobj;
11853 fail:
11854 return NULL;
11855 }
11856
11857
11858 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11859 PyObject *resultobj = 0;
11860 PLINT arg1 ;
11861 int val1 ;
11862 int ecode1 = 0 ;
11863 PyObject * obj0 = 0 ;
11864
11865 if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
11866 ecode1 = SWIG_AsVal_int(obj0, &val1);
11867 if (!SWIG_IsOK(ecode1)) {
11868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
11869 }
11870 arg1 = (PLINT)(val1);
11871 plsstrm(arg1);
11872 resultobj = SWIG_Py_Void();
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11880 PyObject *resultobj = 0;
11881 PLINT arg1 ;
11882 PLINT arg2 ;
11883 int val1 ;
11884 int ecode1 = 0 ;
11885 int val2 ;
11886 int ecode2 = 0 ;
11887 PyObject * obj0 = 0 ;
11888 PyObject * obj1 = 0 ;
11889
11890 if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
11891 ecode1 = SWIG_AsVal_int(obj0, &val1);
11892 if (!SWIG_IsOK(ecode1)) {
11893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
11894 }
11895 arg1 = (PLINT)(val1);
11896 ecode2 = SWIG_AsVal_int(obj1, &val2);
11897 if (!SWIG_IsOK(ecode2)) {
11898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
11899 }
11900 arg2 = (PLINT)(val2);
11901 plssub(arg1,arg2);
11902 resultobj = SWIG_Py_Void();
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910 PyObject *resultobj = 0;
11911 PLFLT arg1 ;
11912 PLFLT arg2 ;
11913 double val1 ;
11914 int ecode1 = 0 ;
11915 double val2 ;
11916 int ecode2 = 0 ;
11917 PyObject * obj0 = 0 ;
11918 PyObject * obj1 = 0 ;
11919
11920 if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
11921 ecode1 = SWIG_AsVal_double(obj0, &val1);
11922 if (!SWIG_IsOK(ecode1)) {
11923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
11924 }
11925 arg1 = (PLFLT)(val1);
11926 ecode2 = SWIG_AsVal_double(obj1, &val2);
11927 if (!SWIG_IsOK(ecode2)) {
11928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
11929 }
11930 arg2 = (PLFLT)(val2);
11931 plssym(arg1,arg2);
11932 resultobj = SWIG_Py_Void();
11933 return resultobj;
11934 fail:
11935 return NULL;
11936 }
11937
11938
11939 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11940 PyObject *resultobj = 0;
11941 PLINT arg1 ;
11942 PLINT arg2 ;
11943 int val1 ;
11944 int ecode1 = 0 ;
11945 int val2 ;
11946 int ecode2 = 0 ;
11947 PyObject * obj0 = 0 ;
11948 PyObject * obj1 = 0 ;
11949
11950 if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
11951 ecode1 = SWIG_AsVal_int(obj0, &val1);
11952 if (!SWIG_IsOK(ecode1)) {
11953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
11954 }
11955 arg1 = (PLINT)(val1);
11956 ecode2 = SWIG_AsVal_int(obj1, &val2);
11957 if (!SWIG_IsOK(ecode2)) {
11958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
11959 }
11960 arg2 = (PLINT)(val2);
11961 plstar(arg1,arg2);
11962 resultobj = SWIG_Py_Void();
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11970 PyObject *resultobj = 0;
11971 char *arg1 = (char *) 0 ;
11972 PLINT arg2 ;
11973 PLINT arg3 ;
11974 int res1 ;
11975 char *buf1 = 0 ;
11976 int alloc1 = 0 ;
11977 int val2 ;
11978 int ecode2 = 0 ;
11979 int val3 ;
11980 int ecode3 = 0 ;
11981 PyObject * obj0 = 0 ;
11982 PyObject * obj1 = 0 ;
11983 PyObject * obj2 = 0 ;
11984
11985 if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
11986 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
11989 }
11990 arg1 = (char *)(buf1);
11991 ecode2 = SWIG_AsVal_int(obj1, &val2);
11992 if (!SWIG_IsOK(ecode2)) {
11993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
11994 }
11995 arg2 = (PLINT)(val2);
11996 ecode3 = SWIG_AsVal_int(obj2, &val3);
11997 if (!SWIG_IsOK(ecode3)) {
11998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
11999 }
12000 arg3 = (PLINT)(val3);
12001 plstart((char const *)arg1,arg2,arg3);
12002 resultobj = SWIG_Py_Void();
12003 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12004 return resultobj;
12005 fail:
12006 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12007 return NULL;
12008 }
12009
12010
12011 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12012 PyObject *resultobj = 0;
12013 ct_func arg1 = (ct_func) 0 ;
12014 PLPointer arg2 = (PLPointer) 0 ;
12015 int res2 ;
12016 PyObject * obj0 = 0 ;
12017 PyObject * obj1 = 0 ;
12018
12019 {
12020 python_ct = 0;
12021 arg1 = NULL;
12022 }
12023 if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12024 if (obj0) {
12025 {
12026 if ( python_ct )
12027 cleanup_ct();
12028
12029 if ( obj0 == Py_None )
12030 {
12031 arg1 = NULL;
12032 }
12033 else
12034 {
12035 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12036 {
12037 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12038 return NULL;
12039 }
12040 arg1 = marshal_ct( obj0 );
12041 }
12042 }
12043 }
12044 if (obj1) {
12045 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12046 if (!SWIG_IsOK(res2)) {
12047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12048 }
12049 }
12050 plstransform(arg1,arg2);
12051 resultobj = SWIG_Py_Void();
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12059 PyObject *resultobj = 0;
12060 PLINT arg1 ;
12061 PLFLT *arg2 = (PLFLT *) 0 ;
12062 PLFLT *arg3 = (PLFLT *) 0 ;
12063 char *arg4 = (char *) 0 ;
12064 PyArrayObject *tmp1 ;
12065 PyArrayObject *tmp3 ;
12066 int res4 ;
12067 char *buf4 = 0 ;
12068 int alloc4 = 0 ;
12069 PyObject * obj0 = 0 ;
12070 PyObject * obj1 = 0 ;
12071 PyObject * obj2 = 0 ;
12072
12073 if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12074 {
12075 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12076 if ( tmp1 == NULL )
12077 return NULL;
12078 arg1 = Alen = tmp1->dimensions[0];
12079 arg2 = (PLFLT *) tmp1->data;
12080 }
12081 {
12082 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12083 if ( tmp3 == NULL )
12084 return NULL;
12085 if ( tmp3->dimensions[0] != Alen )
12086 {
12087 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12088 return NULL;
12089 }
12090 arg3 = (PLFLT *) tmp3->data;
12091 }
12092 res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12093 if (!SWIG_IsOK(res4)) {
12094 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12095 }
12096 arg4 = (char *)(buf4);
12097 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12098 resultobj = SWIG_Py_Void();
12099 {
12100 Py_DECREF( tmp1 );
12101 }
12102 {
12103 Py_DECREF( tmp3 );
12104 }
12105 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12106 return resultobj;
12107 fail:
12108 {
12109 Py_DECREF( tmp1 );
12110 }
12111 {
12112 Py_DECREF( tmp3 );
12113 }
12114 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12115 return NULL;
12116 }
12117
12118
12119 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12120 PyObject *resultobj = 0;
12121 PLINT arg1 ;
12122 PLFLT *arg2 = (PLFLT *) 0 ;
12123 PLFLT *arg3 = (PLFLT *) 0 ;
12124 PLFLT *arg4 = (PLFLT *) 0 ;
12125 char *arg5 = (char *) 0 ;
12126 PyArrayObject *tmp1 ;
12127 PyArrayObject *tmp3 ;
12128 PyArrayObject *tmp4 ;
12129 int res5 ;
12130 char *buf5 = 0 ;
12131 int alloc5 = 0 ;
12132 PyObject * obj0 = 0 ;
12133 PyObject * obj1 = 0 ;
12134 PyObject * obj2 = 0 ;
12135 PyObject * obj3 = 0 ;
12136
12137 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12138 {
12139 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12140 if ( tmp1 == NULL )
12141 return NULL;
12142 arg1 = Alen = tmp1->dimensions[0];
12143 arg2 = (PLFLT *) tmp1->data;
12144 }
12145 {
12146 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12147 if ( tmp3 == NULL )
12148 return NULL;
12149 if ( tmp3->dimensions[0] != Alen )
12150 {
12151 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12152 return NULL;
12153 }
12154 arg3 = (PLFLT *) tmp3->data;
12155 }
12156 {
12157 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
12158 if ( tmp4 == NULL )
12159 return NULL;
12160 if ( tmp4->dimensions[0] != Alen )
12161 {
12162 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12163 return NULL;
12164 }
12165 arg4 = (PLFLT *) tmp4->data;
12166 }
12167 res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12168 if (!SWIG_IsOK(res5)) {
12169 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12170 }
12171 arg5 = (char *)(buf5);
12172 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12173 resultobj = SWIG_Py_Void();
12174 {
12175 Py_DECREF( tmp1 );
12176 }
12177 {
12178 Py_DECREF( tmp3 );
12179 }
12180 {
12181 Py_DECREF( tmp4 );
12182 }
12183 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12184 return resultobj;
12185 fail:
12186 {
12187 Py_DECREF( tmp1 );
12188 }
12189 {
12190 Py_DECREF( tmp3 );
12191 }
12192 {
12193 Py_DECREF( tmp4 );
12194 }
12195 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201 PyObject *resultobj = 0;
12202 PLINT arg1 ;
12203 PLINT arg2 ;
12204 PLFLT arg3 ;
12205 PLFLT arg4 ;
12206 int val1 ;
12207 int ecode1 = 0 ;
12208 int val2 ;
12209 int ecode2 = 0 ;
12210 double val3 ;
12211 int ecode3 = 0 ;
12212 double val4 ;
12213 int ecode4 = 0 ;
12214 PyObject * obj0 = 0 ;
12215 PyObject * obj1 = 0 ;
12216 PyObject * obj2 = 0 ;
12217 PyObject * obj3 = 0 ;
12218
12219 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12220 ecode1 = SWIG_AsVal_int(obj0, &val1);
12221 if (!SWIG_IsOK(ecode1)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12223 }
12224 arg1 = (PLINT)(val1);
12225 ecode2 = SWIG_AsVal_int(obj1, &val2);
12226 if (!SWIG_IsOK(ecode2)) {
12227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12228 }
12229 arg2 = (PLINT)(val2);
12230 ecode3 = SWIG_AsVal_double(obj2, &val3);
12231 if (!SWIG_IsOK(ecode3)) {
12232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12233 }
12234 arg3 = (PLFLT)(val3);
12235 ecode4 = SWIG_AsVal_double(obj3, &val4);
12236 if (!SWIG_IsOK(ecode4)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12238 }
12239 arg4 = (PLFLT)(val4);
12240 plstripa(arg1,arg2,arg3,arg4);
12241 resultobj = SWIG_Py_Void();
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12249 PyObject *resultobj = 0;
12250 PLINT *arg1 = (PLINT *) 0 ;
12251 char *arg2 = (char *) 0 ;
12252 char *arg3 = (char *) 0 ;
12253 PLFLT arg4 ;
12254 PLFLT arg5 ;
12255 PLFLT arg6 ;
12256 PLFLT arg7 ;
12257 PLFLT arg8 ;
12258 PLFLT arg9 ;
12259 PLFLT arg10 ;
12260 PLBOOL arg11 ;
12261 PLBOOL arg12 ;
12262 PLINT arg13 ;
12263 PLINT arg14 ;
12264 PLINT *arg15 = (PLINT *) 0 ;
12265 PLINT *arg16 = (PLINT *) 0 ;
12266 char **arg17 ;
12267 char *arg18 = (char *) 0 ;
12268 char *arg19 = (char *) 0 ;
12269 char *arg20 = (char *) 0 ;
12270 PLINT temp1 ;
12271 int res1 = SWIG_TMPOBJ ;
12272 int res2 ;
12273 char *buf2 = 0 ;
12274 int alloc2 = 0 ;
12275 int res3 ;
12276 char *buf3 = 0 ;
12277 int alloc3 = 0 ;
12278 double val4 ;
12279 int ecode4 = 0 ;
12280 double val5 ;
12281 int ecode5 = 0 ;
12282 double val6 ;
12283 int ecode6 = 0 ;
12284 double val7 ;
12285 int ecode7 = 0 ;
12286 double val8 ;
12287 int ecode8 = 0 ;
12288 double val9 ;
12289 int ecode9 = 0 ;
12290 double val10 ;
12291 int ecode10 = 0 ;
12292 int val11 ;
12293 int ecode11 = 0 ;
12294 int val12 ;
12295 int ecode12 = 0 ;
12296 int val13 ;
12297 int ecode13 = 0 ;
12298 int val14 ;
12299 int ecode14 = 0 ;
12300 PyArrayObject *tmp15 ;
12301 PyArrayObject *tmp16 ;
12302 int res18 ;
12303 char *buf18 = 0 ;
12304 int alloc18 = 0 ;
12305 int res19 ;
12306 char *buf19 = 0 ;
12307 int alloc19 = 0 ;
12308 int res20 ;
12309 char *buf20 = 0 ;
12310 int alloc20 = 0 ;
12311 PyObject * obj0 = 0 ;
12312 PyObject * obj1 = 0 ;
12313 PyObject * obj2 = 0 ;
12314 PyObject * obj3 = 0 ;
12315 PyObject * obj4 = 0 ;
12316 PyObject * obj5 = 0 ;
12317 PyObject * obj6 = 0 ;
12318 PyObject * obj7 = 0 ;
12319 PyObject * obj8 = 0 ;
12320 PyObject * obj9 = 0 ;
12321 PyObject * obj10 = 0 ;
12322 PyObject * obj11 = 0 ;
12323 PyObject * obj12 = 0 ;
12324 PyObject * obj13 = 0 ;
12325 PyObject * obj14 = 0 ;
12326 PyObject * obj15 = 0 ;
12327 PyObject * obj16 = 0 ;
12328 PyObject * obj17 = 0 ;
12329 PyObject * obj18 = 0 ;
12330
12331 arg1 = &temp1;
12332 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;
12333 res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
12334 if (!SWIG_IsOK(res2)) {
12335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12336 }
12337 arg2 = (char *)(buf2);
12338 res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
12339 if (!SWIG_IsOK(res3)) {
12340 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12341 }
12342 arg3 = (char *)(buf3);
12343 ecode4 = SWIG_AsVal_double(obj2, &val4);
12344 if (!SWIG_IsOK(ecode4)) {
12345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12346 }
12347 arg4 = (PLFLT)(val4);
12348 ecode5 = SWIG_AsVal_double(obj3, &val5);
12349 if (!SWIG_IsOK(ecode5)) {
12350 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12351 }
12352 arg5 = (PLFLT)(val5);
12353 ecode6 = SWIG_AsVal_double(obj4, &val6);
12354 if (!SWIG_IsOK(ecode6)) {
12355 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12356 }
12357 arg6 = (PLFLT)(val6);
12358 ecode7 = SWIG_AsVal_double(obj5, &val7);
12359 if (!SWIG_IsOK(ecode7)) {
12360 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12361 }
12362 arg7 = (PLFLT)(val7);
12363 ecode8 = SWIG_AsVal_double(obj6, &val8);
12364 if (!SWIG_IsOK(ecode8)) {
12365 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12366 }
12367 arg8 = (PLFLT)(val8);
12368 ecode9 = SWIG_AsVal_double(obj7, &val9);
12369 if (!SWIG_IsOK(ecode9)) {
12370 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12371 }
12372 arg9 = (PLFLT)(val9);
12373 ecode10 = SWIG_AsVal_double(obj8, &val10);
12374 if (!SWIG_IsOK(ecode10)) {
12375 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12376 }
12377 arg10 = (PLFLT)(val10);
12378 ecode11 = SWIG_AsVal_int(obj9, &val11);
12379 if (!SWIG_IsOK(ecode11)) {
12380 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12381 }
12382 arg11 = (PLBOOL)(val11);
12383 ecode12 = SWIG_AsVal_int(obj10, &val12);
12384 if (!SWIG_IsOK(ecode12)) {
12385 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12386 }
12387 arg12 = (PLBOOL)(val12);
12388 ecode13 = SWIG_AsVal_int(obj11, &val13);
12389 if (!SWIG_IsOK(ecode13)) {
12390 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12391 }
12392 arg13 = (PLINT)(val13);
12393 ecode14 = SWIG_AsVal_int(obj12, &val14);
12394 if (!SWIG_IsOK(ecode14)) {
12395 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12396 }
12397 arg14 = (PLINT)(val14);
12398 {
12399 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, PyArray_PLINT, 1, 1 );
12400 if ( tmp15 == NULL )
12401 return NULL;
12402 Alen = tmp15->dimensions[0];
12403 arg15 = (PLINT *) tmp15->data;
12404 }
12405 {
12406 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, PyArray_PLINT, 1, 1 );
12407 if ( tmp16 == NULL )
12408 return NULL;
12409 if ( tmp16->dimensions[0] != Alen )
12410 {
12411 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12412 return NULL;
12413 }
12414 arg16 = (PLINT *) tmp16->data;
12415 }
12416 {
12417 int i;
12418 if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
12419 {
12420 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12421 return NULL;
12422 }
12423 if ( Alen != 4 )
12424 {
12425 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12426 return NULL;
12427 }
12428 arg17 = malloc( sizeof ( char* ) * 4 );
12429 for ( i = 0; i < 4; i++ )
12430 {
12431 arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
12432 if ( arg17[i] == NULL )
12433 {
12434 free( arg17 );
12435 return NULL;
12436 }
12437 }
12438 }
12439 res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
12440 if (!SWIG_IsOK(res18)) {
12441 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12442 }
12443 arg18 = (char *)(buf18);
12444 res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
12445 if (!SWIG_IsOK(res19)) {
12446 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12447 }
12448 arg19 = (char *)(buf19);
12449 res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
12450 if (!SWIG_IsOK(res20)) {
12451 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12452 }
12453 arg20 = (char *)(buf20);
12454 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);
12455 resultobj = SWIG_Py_Void();
12456 if (SWIG_IsTmpObj(res1)) {
12457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
12458 } else {
12459 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
12461 }
12462 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12463 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12464 {
12465 Py_DECREF( tmp15 );
12466 }
12467 {
12468 Py_DECREF( tmp16 );
12469 }
12470 {
12471 free( arg17 );
12472 }
12473 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12474 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12475 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12476 return resultobj;
12477 fail:
12478 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12479 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12480 {
12481 Py_DECREF( tmp15 );
12482 }
12483 {
12484 Py_DECREF( tmp16 );
12485 }
12486 {
12487 free( arg17 );
12488 }
12489 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12490 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12491 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12492 return NULL;
12493 }
12494
12495
12496 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12497 PyObject *resultobj = 0;
12498 PLINT arg1 ;
12499 int val1 ;
12500 int ecode1 = 0 ;
12501 PyObject * obj0 = 0 ;
12502
12503 if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
12504 ecode1 = SWIG_AsVal_int(obj0, &val1);
12505 if (!SWIG_IsOK(ecode1)) {
12506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
12507 }
12508 arg1 = (PLINT)(val1);
12509 plstripd(arg1);
12510 resultobj = SWIG_Py_Void();
12511 return resultobj;
12512 fail:
12513 return NULL;
12514 }
12515
12516
12517 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12518 PyObject *resultobj = 0;
12519 PLINT arg1 ;
12520 PLINT *arg2 = (PLINT *) 0 ;
12521 PLINT *arg3 = (PLINT *) 0 ;
12522 PyArrayObject *tmp1 ;
12523 PyArrayObject *tmp3 ;
12524 PyObject * obj0 = 0 ;
12525 PyObject * obj1 = 0 ;
12526
12527 if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
12528 {
12529 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
12530 if ( tmp1 == NULL )
12531 return NULL;
12532 arg1 = Alen = tmp1->dimensions[0];
12533 arg2 = (PLINT *) tmp1->data;
12534 }
12535 {
12536 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
12537 if ( tmp3 == NULL )
12538 return NULL;
12539 if ( tmp3->dimensions[0] != Alen )
12540 {
12541 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12542 return NULL;
12543 }
12544 arg3 = (PLINT *) tmp3->data;
12545 }
12546 plstyl(arg1,(int const *)arg2,(int const *)arg3);
12547 resultobj = SWIG_Py_Void();
12548 {
12549 Py_DECREF( tmp1 );
12550 }
12551 {
12552 Py_DECREF( tmp3 );
12553 }
12554 return resultobj;
12555 fail:
12556 {
12557 Py_DECREF( tmp1 );
12558 }
12559 {
12560 Py_DECREF( tmp3 );
12561 }
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567 PyObject *resultobj = 0;
12568 PLFLT *arg1 = (PLFLT *) 0 ;
12569 PLFLT *arg2 = (PLFLT *) 0 ;
12570 PLINT arg3 ;
12571 PLBOOL arg4 ;
12572 PyArrayObject *tmp1 ;
12573 PyArrayObject *tmp2 ;
12574 int val4 ;
12575 int ecode4 = 0 ;
12576 PyObject * obj0 = 0 ;
12577 PyObject * obj1 = 0 ;
12578 PyObject * obj2 = 0 ;
12579
12580 if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
12581 {
12582 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12583 if ( tmp1 == NULL )
12584 return NULL;
12585 Alen = tmp1->dimensions[0];
12586 arg1 = (PLFLT *) tmp1->data;
12587 }
12588 {
12589 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12590 if ( tmp2 == NULL )
12591 return NULL;
12592 if ( tmp2->dimensions[0] != Alen )
12593 {
12594 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12595 return NULL;
12596 }
12597 arg2 = (PLFLT *) tmp2->data;
12598 arg3 = tmp2->dimensions[0];
12599 }
12600 ecode4 = SWIG_AsVal_int(obj2, &val4);
12601 if (!SWIG_IsOK(ecode4)) {
12602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
12603 }
12604 arg4 = (PLBOOL)(val4);
12605 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
12606 resultobj = SWIG_Py_Void();
12607 {
12608 Py_DECREF( tmp1 );
12609 }
12610 {
12611 Py_DECREF( tmp2 );
12612 }
12613 return resultobj;
12614 fail:
12615 {
12616 Py_DECREF( tmp1 );
12617 }
12618 {
12619 Py_DECREF( tmp2 );
12620 }
12621 return NULL;
12622 }
12623
12624
12625 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 PyObject *resultobj = 0;
12627 PLFLT arg1 ;
12628 PLFLT arg2 ;
12629 PLFLT arg3 ;
12630 PLFLT arg4 ;
12631 double val1 ;
12632 int ecode1 = 0 ;
12633 double val2 ;
12634 int ecode2 = 0 ;
12635 double val3 ;
12636 int ecode3 = 0 ;
12637 double val4 ;
12638 int ecode4 = 0 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 PyObject * obj3 = 0 ;
12643
12644 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12645 ecode1 = SWIG_AsVal_double(obj0, &val1);
12646 if (!SWIG_IsOK(ecode1)) {
12647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
12648 }
12649 arg1 = (PLFLT)(val1);
12650 ecode2 = SWIG_AsVal_double(obj1, &val2);
12651 if (!SWIG_IsOK(ecode2)) {
12652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
12653 }
12654 arg2 = (PLFLT)(val2);
12655 ecode3 = SWIG_AsVal_double(obj2, &val3);
12656 if (!SWIG_IsOK(ecode3)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
12658 }
12659 arg3 = (PLFLT)(val3);
12660 ecode4 = SWIG_AsVal_double(obj3, &val4);
12661 if (!SWIG_IsOK(ecode4)) {
12662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
12663 }
12664 arg4 = (PLFLT)(val4);
12665 plsvpa(arg1,arg2,arg3,arg4);
12666 resultobj = SWIG_Py_Void();
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674 PyObject *resultobj = 0;
12675 PLINT arg1 ;
12676 PLINT arg2 ;
12677 int val1 ;
12678 int ecode1 = 0 ;
12679 int val2 ;
12680 int ecode2 = 0 ;
12681 PyObject * obj0 = 0 ;
12682 PyObject * obj1 = 0 ;
12683
12684 if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
12685 ecode1 = SWIG_AsVal_int(obj0, &val1);
12686 if (!SWIG_IsOK(ecode1)) {
12687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
12688 }
12689 arg1 = (PLINT)(val1);
12690 ecode2 = SWIG_AsVal_int(obj1, &val2);
12691 if (!SWIG_IsOK(ecode2)) {
12692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
12693 }
12694 arg2 = (PLINT)(val2);
12695 plsxax(arg1,arg2);
12696 resultobj = SWIG_Py_Void();
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704 PyObject *resultobj = 0;
12705 PLINT arg1 ;
12706 PLINT arg2 ;
12707 int val1 ;
12708 int ecode1 = 0 ;
12709 int val2 ;
12710 int ecode2 = 0 ;
12711 PyObject * obj0 = 0 ;
12712 PyObject * obj1 = 0 ;
12713
12714 if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
12715 ecode1 = SWIG_AsVal_int(obj0, &val1);
12716 if (!SWIG_IsOK(ecode1)) {
12717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
12718 }
12719 arg1 = (PLINT)(val1);
12720 ecode2 = SWIG_AsVal_int(obj1, &val2);
12721 if (!SWIG_IsOK(ecode2)) {
12722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
12723 }
12724 arg2 = (PLINT)(val2);
12725 plsyax(arg1,arg2);
12726 resultobj = SWIG_Py_Void();
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *resultobj = 0;
12735 PLINT arg1 ;
12736 PLFLT *arg2 = (PLFLT *) 0 ;
12737 PLFLT *arg3 = (PLFLT *) 0 ;
12738 PLINT arg4 ;
12739 PyArrayObject *tmp1 ;
12740 PyArrayObject *tmp3 ;
12741 int val4 ;
12742 int ecode4 = 0 ;
12743 PyObject * obj0 = 0 ;
12744 PyObject * obj1 = 0 ;
12745 PyObject * obj2 = 0 ;
12746
12747 if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
12748 {
12749 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12750 if ( tmp1 == NULL )
12751 return NULL;
12752 arg1 = Alen = tmp1->dimensions[0];
12753 arg2 = (PLFLT *) tmp1->data;
12754 }
12755 {
12756 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12757 if ( tmp3 == NULL )
12758 return NULL;
12759 if ( tmp3->dimensions[0] != Alen )
12760 {
12761 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12762 return NULL;
12763 }
12764 arg3 = (PLFLT *) tmp3->data;
12765 }
12766 ecode4 = SWIG_AsVal_int(obj2, &val4);
12767 if (!SWIG_IsOK(ecode4)) {
12768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
12769 }
12770 arg4 = (PLINT)(val4);
12771 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
12772 resultobj = SWIG_Py_Void();
12773 {
12774 Py_DECREF( tmp1 );
12775 }
12776 {
12777 Py_DECREF( tmp3 );
12778 }
12779 return resultobj;
12780 fail:
12781 {
12782 Py_DECREF( tmp1 );
12783 }
12784 {
12785 Py_DECREF( tmp3 );
12786 }
12787 return NULL;
12788 }
12789
12790
12791 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12792 PyObject *resultobj = 0;
12793 PLINT arg1 ;
12794 PLINT arg2 ;
12795 int val1 ;
12796 int ecode1 = 0 ;
12797 int val2 ;
12798 int ecode2 = 0 ;
12799 PyObject * obj0 = 0 ;
12800 PyObject * obj1 = 0 ;
12801
12802 if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
12803 ecode1 = SWIG_AsVal_int(obj0, &val1);
12804 if (!SWIG_IsOK(ecode1)) {
12805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
12806 }
12807 arg1 = (PLINT)(val1);
12808 ecode2 = SWIG_AsVal_int(obj1, &val2);
12809 if (!SWIG_IsOK(ecode2)) {
12810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
12811 }
12812 arg2 = (PLINT)(val2);
12813 plszax(arg1,arg2);
12814 resultobj = SWIG_Py_Void();
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822 PyObject *resultobj = 0;
12823
12824 if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
12825 pltext();
12826 resultobj = SWIG_Py_Void();
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12834 PyObject *resultobj = 0;
12835 char *arg1 = (char *) 0 ;
12836 int res1 ;
12837 char *buf1 = 0 ;
12838 int alloc1 = 0 ;
12839 PyObject * obj0 = 0 ;
12840
12841 if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
12842 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12843 if (!SWIG_IsOK(res1)) {
12844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
12845 }
12846 arg1 = (char *)(buf1);
12847 pltimefmt((char const *)arg1);
12848 resultobj = SWIG_Py_Void();
12849 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12850 return resultobj;
12851 fail:
12852 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *resultobj = 0;
12859 PLFLT arg1 ;
12860 double val1 ;
12861 int ecode1 = 0 ;
12862 PyObject * obj0 = 0 ;
12863
12864 if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
12865 ecode1 = SWIG_AsVal_double(obj0, &val1);
12866 if (!SWIG_IsOK(ecode1)) {
12867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
12868 }
12869 arg1 = (PLFLT)(val1);
12870 plvasp(arg1);
12871 resultobj = SWIG_Py_Void();
12872 return resultobj;
12873 fail:
12874 return NULL;
12875 }
12876
12877
12878 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879 PyObject *resultobj = 0;
12880 PLFLT **arg1 = (PLFLT **) 0 ;
12881 PLFLT **arg2 = (PLFLT **) 0 ;
12882 PLINT arg3 ;
12883 PLINT arg4 ;
12884 PLFLT arg5 ;
12885 pltr_func arg6 = (pltr_func) 0 ;
12886 PLPointer arg7 = (PLPointer) 0 ;
12887 PyArrayObject *tmp1 ;
12888 PyArrayObject *tmp2 ;
12889 double val5 ;
12890 int ecode5 = 0 ;
12891 PyObject * obj0 = 0 ;
12892 PyObject * obj1 = 0 ;
12893 PyObject * obj2 = 0 ;
12894 PyObject * obj3 = 0 ;
12895 PyObject * obj4 = 0 ;
12896
12897 {
12898 python_pltr = 0;
12899 arg6 = NULL;
12900 }
12901 {
12902 arg7 = NULL;
12903 }
12904 if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12905 {
12906 int i, size;
12907 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
12908 if ( tmp1 == NULL )
12909 return NULL;
12910 Xlen = tmp1->dimensions[0];
12911 Ylen = tmp1->dimensions[1];
12912 size = sizeof ( PLFLT ) * Ylen;
12913 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
12914 for ( i = 0; i < Xlen; i++ )
12915 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
12916 }
12917 {
12918 int i, size;
12919 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 2, 2 );
12920 if ( tmp2 == NULL )
12921 return NULL;
12922 if ( Xlen != tmp2->dimensions[0] || Ylen != tmp2->dimensions[1] )
12923 {
12924 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
12925 return NULL;
12926 }
12927 arg3 = tmp2->dimensions[0];
12928 arg4 = tmp2->dimensions[1];
12929 size = sizeof ( PLFLT ) * arg4;
12930 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg3 );
12931 for ( i = 0; i < arg3; i++ )
12932 arg2[i] = (PLFLT *) ( tmp2->data + i * size );
12933 }
12934 ecode5 = SWIG_AsVal_double(obj2, &val5);
12935 if (!SWIG_IsOK(ecode5)) {
12936 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
12937 }
12938 arg5 = (PLFLT)(val5);
12939 if (obj3) {
12940 {
12941
12942 if ( obj3 == Py_None )
12943 {
12944 arg6 = NULL;
12945 }
12946 else
12947 {
12948 if ( !PyCallable_Check( (PyObject *) obj3 ) )
12949 {
12950 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12951 return NULL;
12952 }
12953 arg6 = marshal_pltr( obj3 );
12954 }
12955 }
12956 }
12957 if (obj4) {
12958 {
12959 if ( obj4 == Py_None )
12960 arg7 = NULL;
12961 else
12962 {
12963 arg7 = marshal_PLPointer( obj4, 0 );
12964 }
12965 }
12966 }
12967 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
12968 resultobj = SWIG_Py_Void();
12969 {
12970 Py_DECREF( tmp1 );
12971 free( arg1 );
12972 }
12973 {
12974 Py_DECREF( tmp2 );
12975 free( arg2 );
12976 }
12977 {
12978 cleanup_pltr();
12979 }
12980 {
12981 cleanup_PLPointer();
12982 }
12983 return resultobj;
12984 fail:
12985 {
12986 Py_DECREF( tmp1 );
12987 free( arg1 );
12988 }
12989 {
12990 Py_DECREF( tmp2 );
12991 free( arg2 );
12992 }
12993 {
12994 cleanup_pltr();
12995 }
12996 {
12997 cleanup_PLPointer();
12998 }
12999 return NULL;
13000 }
13001
13002
13003 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004 PyObject *resultobj = 0;
13005 PLFLT arg1 ;
13006 PLFLT arg2 ;
13007 PLFLT arg3 ;
13008 PLFLT arg4 ;
13009 PLFLT arg5 ;
13010 double val1 ;
13011 int ecode1 = 0 ;
13012 double val2 ;
13013 int ecode2 = 0 ;
13014 double val3 ;
13015 int ecode3 = 0 ;
13016 double val4 ;
13017 int ecode4 = 0 ;
13018 double val5 ;
13019 int ecode5 = 0 ;
13020 PyObject * obj0 = 0 ;
13021 PyObject * obj1 = 0 ;
13022 PyObject * obj2 = 0 ;
13023 PyObject * obj3 = 0 ;
13024 PyObject * obj4 = 0 ;
13025
13026 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13027 ecode1 = SWIG_AsVal_double(obj0, &val1);
13028 if (!SWIG_IsOK(ecode1)) {
13029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13030 }
13031 arg1 = (PLFLT)(val1);
13032 ecode2 = SWIG_AsVal_double(obj1, &val2);
13033 if (!SWIG_IsOK(ecode2)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13035 }
13036 arg2 = (PLFLT)(val2);
13037 ecode3 = SWIG_AsVal_double(obj2, &val3);
13038 if (!SWIG_IsOK(ecode3)) {
13039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13040 }
13041 arg3 = (PLFLT)(val3);
13042 ecode4 = SWIG_AsVal_double(obj3, &val4);
13043 if (!SWIG_IsOK(ecode4)) {
13044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13045 }
13046 arg4 = (PLFLT)(val4);
13047 ecode5 = SWIG_AsVal_double(obj4, &val5);
13048 if (!SWIG_IsOK(ecode5)) {
13049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13050 }
13051 arg5 = (PLFLT)(val5);
13052 plvpas(arg1,arg2,arg3,arg4,arg5);
13053 resultobj = SWIG_Py_Void();
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 PLFLT arg1 ;
13063 PLFLT arg2 ;
13064 PLFLT arg3 ;
13065 PLFLT arg4 ;
13066 double val1 ;
13067 int ecode1 = 0 ;
13068 double val2 ;
13069 int ecode2 = 0 ;
13070 double val3 ;
13071 int ecode3 = 0 ;
13072 double val4 ;
13073 int ecode4 = 0 ;
13074 PyObject * obj0 = 0 ;
13075 PyObject * obj1 = 0 ;
13076 PyObject * obj2 = 0 ;
13077 PyObject * obj3 = 0 ;
13078
13079 if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13080 ecode1 = SWIG_AsVal_double(obj0, &val1);
13081 if (!SWIG_IsOK(ecode1)) {
13082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13083 }
13084 arg1 = (PLFLT)(val1);
13085 ecode2 = SWIG_AsVal_double(obj1, &val2);
13086 if (!SWIG_IsOK(ecode2)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13088 }
13089 arg2 = (PLFLT)(val2);
13090 ecode3 = SWIG_AsVal_double(obj2, &val3);
13091 if (!SWIG_IsOK(ecode3)) {
13092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13093 }
13094 arg3 = (PLFLT)(val3);
13095 ecode4 = SWIG_AsVal_double(obj3, &val4);
13096 if (!SWIG_IsOK(ecode4)) {
13097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13098 }
13099 arg4 = (PLFLT)(val4);
13100 plvpor(arg1,arg2,arg3,arg4);
13101 resultobj = SWIG_Py_Void();
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13109 PyObject *resultobj = 0;
13110
13111 if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13112 plvsta();
13113 resultobj = SWIG_Py_Void();
13114 return resultobj;
13115 fail:
13116 return NULL;
13117 }
13118
13119
13120 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13121 PyObject *resultobj = 0;
13122 PLFLT arg1 ;
13123 PLFLT arg2 ;
13124 PLFLT arg3 ;
13125 PLFLT arg4 ;
13126 PLFLT arg5 ;
13127 PLFLT arg6 ;
13128 PLFLT arg7 ;
13129 PLFLT arg8 ;
13130 PLFLT arg9 ;
13131 PLFLT arg10 ;
13132 PLFLT arg11 ;
13133 double val1 ;
13134 int ecode1 = 0 ;
13135 double val2 ;
13136 int ecode2 = 0 ;
13137 double val3 ;
13138 int ecode3 = 0 ;
13139 double val4 ;
13140 int ecode4 = 0 ;
13141 double val5 ;
13142 int ecode5 = 0 ;
13143 double val6 ;
13144 int ecode6 = 0 ;
13145 double val7 ;
13146 int ecode7 = 0 ;
13147 double val8 ;
13148 int ecode8 = 0 ;
13149 double val9 ;
13150 int ecode9 = 0 ;
13151 double val10 ;
13152 int ecode10 = 0 ;
13153 double val11 ;
13154 int ecode11 = 0 ;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 PyObject * obj2 = 0 ;
13158 PyObject * obj3 = 0 ;
13159 PyObject * obj4 = 0 ;
13160 PyObject * obj5 = 0 ;
13161 PyObject * obj6 = 0 ;
13162 PyObject * obj7 = 0 ;
13163 PyObject * obj8 = 0 ;
13164 PyObject * obj9 = 0 ;
13165 PyObject * obj10 = 0 ;
13166
13167 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13168 ecode1 = SWIG_AsVal_double(obj0, &val1);
13169 if (!SWIG_IsOK(ecode1)) {
13170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13171 }
13172 arg1 = (PLFLT)(val1);
13173 ecode2 = SWIG_AsVal_double(obj1, &val2);
13174 if (!SWIG_IsOK(ecode2)) {
13175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13176 }
13177 arg2 = (PLFLT)(val2);
13178 ecode3 = SWIG_AsVal_double(obj2, &val3);
13179 if (!SWIG_IsOK(ecode3)) {
13180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13181 }
13182 arg3 = (PLFLT)(val3);
13183 ecode4 = SWIG_AsVal_double(obj3, &val4);
13184 if (!SWIG_IsOK(ecode4)) {
13185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13186 }
13187 arg4 = (PLFLT)(val4);
13188 ecode5 = SWIG_AsVal_double(obj4, &val5);
13189 if (!SWIG_IsOK(ecode5)) {
13190 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13191 }
13192 arg5 = (PLFLT)(val5);
13193 ecode6 = SWIG_AsVal_double(obj5, &val6);
13194 if (!SWIG_IsOK(ecode6)) {
13195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13196 }
13197 arg6 = (PLFLT)(val6);
13198 ecode7 = SWIG_AsVal_double(obj6, &val7);
13199 if (!SWIG_IsOK(ecode7)) {
13200 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13201 }
13202 arg7 = (PLFLT)(val7);
13203 ecode8 = SWIG_AsVal_double(obj7, &val8);
13204 if (!SWIG_IsOK(ecode8)) {
13205 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13206 }
13207 arg8 = (PLFLT)(val8);
13208 ecode9 = SWIG_AsVal_double(obj8, &val9);
13209 if (!SWIG_IsOK(ecode9)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13211 }
13212 arg9 = (PLFLT)(val9);
13213 ecode10 = SWIG_AsVal_double(obj9, &val10);
13214 if (!SWIG_IsOK(ecode10)) {
13215 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13216 }
13217 arg10 = (PLFLT)(val10);
13218 ecode11 = SWIG_AsVal_double(obj10, &val11);
13219 if (!SWIG_IsOK(ecode11)) {
13220 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13221 }
13222 arg11 = (PLFLT)(val11);
13223 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13224 resultobj = SWIG_Py_Void();
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *_wrap_plwid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232 PyObject *resultobj = 0;
13233 PLINT arg1 ;
13234 int val1 ;
13235 int ecode1 = 0 ;
13236 PyObject * obj0 = 0 ;
13237
13238 if (!PyArg_ParseTuple(args,(char *)"O:plwid",&obj0)) SWIG_fail;
13239 ecode1 = SWIG_AsVal_int(obj0, &val1);
13240 if (!SWIG_IsOK(ecode1)) {
13241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwid" "', argument " "1"" of type '" "PLINT""'");
13242 }
13243 arg1 = (PLINT)(val1);
13244 plwid(arg1);
13245 resultobj = SWIG_Py_Void();
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253 PyObject *resultobj = 0;
13254 PLFLT arg1 ;
13255 PLFLT arg2 ;
13256 PLFLT arg3 ;
13257 PLFLT arg4 ;
13258 double val1 ;
13259 int ecode1 = 0 ;
13260 double val2 ;
13261 int ecode2 = 0 ;
13262 double val3 ;
13263 int ecode3 = 0 ;
13264 double val4 ;
13265 int ecode4 = 0 ;
13266 PyObject * obj0 = 0 ;
13267 PyObject * obj1 = 0 ;
13268 PyObject * obj2 = 0 ;
13269 PyObject * obj3 = 0 ;
13270
13271 if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13272 ecode1 = SWIG_AsVal_double(obj0, &val1);
13273 if (!SWIG_IsOK(ecode1)) {
13274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13275 }
13276 arg1 = (PLFLT)(val1);
13277 ecode2 = SWIG_AsVal_double(obj1, &val2);
13278 if (!SWIG_IsOK(ecode2)) {
13279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13280 }
13281 arg2 = (PLFLT)(val2);
13282 ecode3 = SWIG_AsVal_double(obj2, &val3);
13283 if (!SWIG_IsOK(ecode3)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13285 }
13286 arg3 = (PLFLT)(val3);
13287 ecode4 = SWIG_AsVal_double(obj3, &val4);
13288 if (!SWIG_IsOK(ecode4)) {
13289 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13290 }
13291 arg4 = (PLFLT)(val4);
13292 plwind(arg1,arg2,arg3,arg4);
13293 resultobj = SWIG_Py_Void();
13294 return resultobj;
13295 fail:
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301 PyObject *resultobj = 0;
13302 PLBOOL arg1 ;
13303 PLBOOL *arg2 = (PLBOOL *) 0 ;
13304 int val1 ;
13305 int ecode1 = 0 ;
13306 PLBOOL temp2 ;
13307 int res2 = SWIG_TMPOBJ ;
13308 PyObject * obj0 = 0 ;
13309
13310 arg2 = &temp2;
13311 if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
13312 ecode1 = SWIG_AsVal_int(obj0, &val1);
13313 if (!SWIG_IsOK(ecode1)) {
13314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13315 }
13316 arg1 = (PLBOOL)(val1);
13317 plxormod(arg1,arg2);
13318 resultobj = SWIG_Py_Void();
13319 if (SWIG_IsTmpObj(res2)) {
13320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13321 } else {
13322 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13332 PyObject *resultobj = 0;
13333 mapform_func arg1 = (mapform_func) 0 ;
13334 char *arg2 = (char *) 0 ;
13335 PLFLT arg3 ;
13336 PLFLT arg4 ;
13337 PLFLT arg5 ;
13338 PLFLT arg6 ;
13339 int res2 ;
13340 char *buf2 = 0 ;
13341 int alloc2 = 0 ;
13342 double val3 ;
13343 int ecode3 = 0 ;
13344 double val4 ;
13345 int ecode4 = 0 ;
13346 double val5 ;
13347 int ecode5 = 0 ;
13348 double val6 ;
13349 int ecode6 = 0 ;
13350 PyObject * obj0 = 0 ;
13351 PyObject * obj1 = 0 ;
13352 PyObject * obj2 = 0 ;
13353 PyObject * obj3 = 0 ;
13354 PyObject * obj4 = 0 ;
13355 PyObject * obj5 = 0 ;
13356
13357 {
13358 python_mapform = 0;
13359 arg1 = NULL;
13360 }
13361 if (!PyArg_ParseTuple(args,(char *)"|OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13362 if (obj0) {
13363 {
13364
13365 if ( obj0 == Py_None )
13366 {
13367 arg1 = NULL;
13368 }
13369 else
13370 {
13371 if ( !PyCallable_Check( (PyObject *) obj0 ) )
13372 {
13373 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13374 return NULL;
13375 }
13376 arg1 = marshal_mapform( obj0 );
13377 }
13378 }
13379 }
13380 if (obj1) {
13381 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13382 if (!SWIG_IsOK(res2)) {
13383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13384 }
13385 arg2 = (char *)(buf2);
13386 }
13387 if (obj2) {
13388 ecode3 = SWIG_AsVal_double(obj2, &val3);
13389 if (!SWIG_IsOK(ecode3)) {
13390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13391 }
13392 arg3 = (PLFLT)(val3);
13393 }
13394 if (obj3) {
13395 ecode4 = SWIG_AsVal_double(obj3, &val4);
13396 if (!SWIG_IsOK(ecode4)) {
13397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13398 }
13399 arg4 = (PLFLT)(val4);
13400 }
13401 if (obj4) {
13402 ecode5 = SWIG_AsVal_double(obj4, &val5);
13403 if (!SWIG_IsOK(ecode5)) {
13404 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13405 }
13406 arg5 = (PLFLT)(val5);
13407 }
13408 if (obj5) {
13409 ecode6 = SWIG_AsVal_double(obj5, &val6);
13410 if (!SWIG_IsOK(ecode6)) {
13411 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13412 }
13413 arg6 = (PLFLT)(val6);
13414 }
13415 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13416 resultobj = SWIG_Py_Void();
13417 {
13418 cleanup_mapform();
13419 }
13420 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13421 return resultobj;
13422 fail:
13423 {
13424 cleanup_mapform();
13425 }
13426 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13427 return NULL;
13428 }
13429
13430
13431 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 PyObject *resultobj = 0;
13433 mapform_func arg1 = (mapform_func) 0 ;
13434 PLFLT arg2 ;
13435 PLFLT arg3 ;
13436 PLFLT arg4 ;
13437 PLFLT arg5 ;
13438 PLFLT arg6 ;
13439 PLFLT arg7 ;
13440 double val2 ;
13441 int ecode2 = 0 ;
13442 double val3 ;
13443 int ecode3 = 0 ;
13444 double val4 ;
13445 int ecode4 = 0 ;
13446 double val5 ;
13447 int ecode5 = 0 ;
13448 double val6 ;
13449 int ecode6 = 0 ;
13450 double val7 ;
13451 int ecode7 = 0 ;
13452 PyObject * obj0 = 0 ;
13453 PyObject * obj1 = 0 ;
13454 PyObject * obj2 = 0 ;
13455 PyObject * obj3 = 0 ;
13456 PyObject * obj4 = 0 ;
13457 PyObject * obj5 = 0 ;
13458 PyObject * obj6 = 0 ;
13459
13460 {
13461 python_mapform = 0;
13462 arg1 = NULL;
13463 }
13464 if (!PyArg_ParseTuple(args,(char *)"|OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13465 if (obj0) {
13466 {
13467
13468 if ( obj0 == Py_None )
13469 {
13470 arg1 = NULL;
13471 }
13472 else
13473 {
13474 if ( !PyCallable_Check( (PyObject *) obj0 ) )
13475 {
13476 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13477 return NULL;
13478 }
13479 arg1 = marshal_mapform( obj0 );
13480 }
13481 }
13482 }
13483 if (obj1) {
13484 ecode2 = SWIG_AsVal_double(obj1, &val2);
13485 if (!SWIG_IsOK(ecode2)) {
13486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
13487 }
13488 arg2 = (PLFLT)(val2);
13489 }
13490 if (obj2) {
13491 ecode3 = SWIG_AsVal_double(obj2, &val3);
13492 if (!SWIG_IsOK(ecode3)) {
13493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
13494 }
13495 arg3 = (PLFLT)(val3);
13496 }
13497 if (obj3) {
13498 ecode4 = SWIG_AsVal_double(obj3, &val4);
13499 if (!SWIG_IsOK(ecode4)) {
13500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
13501 }
13502 arg4 = (PLFLT)(val4);
13503 }
13504 if (obj4) {
13505 ecode5 = SWIG_AsVal_double(obj4, &val5);
13506 if (!SWIG_IsOK(ecode5)) {
13507 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
13508 }
13509 arg5 = (PLFLT)(val5);
13510 }
13511 if (obj5) {
13512 ecode6 = SWIG_AsVal_double(obj5, &val6);
13513 if (!SWIG_IsOK(ecode6)) {
13514 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
13515 }
13516 arg6 = (PLFLT)(val6);
13517 }
13518 if (obj6) {
13519 ecode7 = SWIG_AsVal_double(obj6, &val7);
13520 if (!SWIG_IsOK(ecode7)) {
13521 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
13522 }
13523 arg7 = (PLFLT)(val7);
13524 }
13525 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13526 resultobj = SWIG_Py_Void();
13527 {
13528 cleanup_mapform();
13529 }
13530 return resultobj;
13531 fail:
13532 {
13533 cleanup_mapform();
13534 }
13535 return NULL;
13536 }
13537
13538
13539 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13540 PyObject *resultobj = 0;
13541 PLFLT **arg1 = (PLFLT **) 0 ;
13542 PLINT arg2 ;
13543 PLINT arg3 ;
13544 PLFLT arg4 ;
13545 PLFLT arg5 ;
13546 PLFLT arg6 ;
13547 PLFLT arg7 ;
13548 PLFLT arg8 ;
13549 PLFLT arg9 ;
13550 PLFLT arg10 ;
13551 PLFLT arg11 ;
13552 PLFLT arg12 ;
13553 PLFLT arg13 ;
13554 PyArrayObject *tmp1 ;
13555 double val4 ;
13556 int ecode4 = 0 ;
13557 double val5 ;
13558 int ecode5 = 0 ;
13559 double val6 ;
13560 int ecode6 = 0 ;
13561 double val7 ;
13562 int ecode7 = 0 ;
13563 double val8 ;
13564 int ecode8 = 0 ;
13565 double val9 ;
13566 int ecode9 = 0 ;
13567 double val10 ;
13568 int ecode10 = 0 ;
13569 double val11 ;
13570 int ecode11 = 0 ;
13571 double val12 ;
13572 int ecode12 = 0 ;
13573 double val13 ;
13574 int ecode13 = 0 ;
13575 PyObject * obj0 = 0 ;
13576 PyObject * obj1 = 0 ;
13577 PyObject * obj2 = 0 ;
13578 PyObject * obj3 = 0 ;
13579 PyObject * obj4 = 0 ;
13580 PyObject * obj5 = 0 ;
13581 PyObject * obj6 = 0 ;
13582 PyObject * obj7 = 0 ;
13583 PyObject * obj8 = 0 ;
13584 PyObject * obj9 = 0 ;
13585 PyObject * obj10 = 0 ;
13586
13587 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13588 {
13589 int i, size;
13590 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
13591 if ( tmp1 == NULL )
13592 return NULL;
13593 Xlen = arg2 = tmp1->dimensions[0];
13594 Ylen = arg3 = tmp1->dimensions[1];
13595 size = sizeof ( PLFLT ) * arg3;
13596 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
13597 for ( i = 0; i < arg2; i++ )
13598 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
13599 }
13600 ecode4 = SWIG_AsVal_double(obj1, &val4);
13601 if (!SWIG_IsOK(ecode4)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
13603 }
13604 arg4 = (PLFLT)(val4);
13605 ecode5 = SWIG_AsVal_double(obj2, &val5);
13606 if (!SWIG_IsOK(ecode5)) {
13607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
13608 }
13609 arg5 = (PLFLT)(val5);
13610 ecode6 = SWIG_AsVal_double(obj3, &val6);
13611 if (!SWIG_IsOK(ecode6)) {
13612 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
13613 }
13614 arg6 = (PLFLT)(val6);
13615 ecode7 = SWIG_AsVal_double(obj4, &val7);
13616 if (!SWIG_IsOK(ecode7)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
13618 }
13619 arg7 = (PLFLT)(val7);
13620 ecode8 = SWIG_AsVal_double(obj5, &val8);
13621 if (!SWIG_IsOK(ecode8)) {
13622 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
13623 }
13624 arg8 = (PLFLT)(val8);
13625 ecode9 = SWIG_AsVal_double(obj6, &val9);
13626 if (!SWIG_IsOK(ecode9)) {
13627 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
13628 }
13629 arg9 = (PLFLT)(val9);
13630 ecode10 = SWIG_AsVal_double(obj7, &val10);
13631 if (!SWIG_IsOK(ecode10)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
13633 }
13634 arg10 = (PLFLT)(val10);
13635 ecode11 = SWIG_AsVal_double(obj8, &val11);
13636 if (!SWIG_IsOK(ecode11)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
13638 }
13639 arg11 = (PLFLT)(val11);
13640 ecode12 = SWIG_AsVal_double(obj9, &val12);
13641 if (!SWIG_IsOK(ecode12)) {
13642 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
13643 }
13644 arg12 = (PLFLT)(val12);
13645 ecode13 = SWIG_AsVal_double(obj10, &val13);
13646 if (!SWIG_IsOK(ecode13)) {
13647 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
13648 }
13649 arg13 = (PLFLT)(val13);
13650 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13651 resultobj = SWIG_Py_Void();
13652 {
13653 Py_DECREF( tmp1 );
13654 free( arg1 );
13655 }
13656 return resultobj;
13657 fail:
13658 {
13659 Py_DECREF( tmp1 );
13660 free( arg1 );
13661 }
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13667 PyObject *resultobj = 0;
13668 PLFLT **arg1 = (PLFLT **) 0 ;
13669 PLINT arg2 ;
13670 PLINT arg3 ;
13671 PLFLT arg4 ;
13672 PLFLT arg5 ;
13673 PLFLT arg6 ;
13674 PLFLT arg7 ;
13675 PLFLT arg8 ;
13676 PLFLT arg9 ;
13677 PLFLT arg10 ;
13678 PLFLT arg11 ;
13679 pltr_func arg12 = (pltr_func) 0 ;
13680 PLPointer arg13 = (PLPointer) 0 ;
13681 PyArrayObject *tmp1 ;
13682 double val4 ;
13683 int ecode4 = 0 ;
13684 double val5 ;
13685 int ecode5 = 0 ;
13686 double val6 ;
13687 int ecode6 = 0 ;
13688 double val7 ;
13689 int ecode7 = 0 ;
13690 double val8 ;
13691 int ecode8 = 0 ;
13692 double val9 ;
13693 int ecode9 = 0 ;
13694 double val10 ;
13695 int ecode10 = 0 ;
13696 double val11 ;
13697 int ecode11 = 0 ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 PyObject * obj2 = 0 ;
13701 PyObject * obj3 = 0 ;
13702 PyObject * obj4 = 0 ;
13703 PyObject * obj5 = 0 ;
13704 PyObject * obj6 = 0 ;
13705 PyObject * obj7 = 0 ;
13706 PyObject * obj8 = 0 ;
13707 PyObject * obj9 = 0 ;
13708 PyObject * obj10 = 0 ;
13709
13710 {
13711 python_pltr = 0;
13712 arg12 = NULL;
13713 }
13714 {
13715 arg13 = NULL;
13716 }
13717 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13718 {
13719 int i, size;
13720 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
13721 if ( tmp1 == NULL )
13722 return NULL;
13723 Xlen = arg2 = tmp1->dimensions[0];
13724 Ylen = arg3 = tmp1->dimensions[1];
13725 size = sizeof ( PLFLT ) * arg3;
13726 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
13727 for ( i = 0; i < arg2; i++ )
13728 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
13729 }
13730 ecode4 = SWIG_AsVal_double(obj1, &val4);
13731 if (!SWIG_IsOK(ecode4)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
13733 }
13734 arg4 = (PLFLT)(val4);
13735 ecode5 = SWIG_AsVal_double(obj2, &val5);
13736 if (!SWIG_IsOK(ecode5)) {
13737 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
13738 }
13739 arg5 = (PLFLT)(val5);
13740 ecode6 = SWIG_AsVal_double(obj3, &val6);
13741 if (!SWIG_IsOK(ecode6)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
13743 }
13744 arg6 = (PLFLT)(val6);
13745 ecode7 = SWIG_AsVal_double(obj4, &val7);
13746 if (!SWIG_IsOK(ecode7)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
13748 }
13749 arg7 = (PLFLT)(val7);
13750 ecode8 = SWIG_AsVal_double(obj5, &val8);
13751 if (!SWIG_IsOK(ecode8)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
13753 }
13754 arg8 = (PLFLT)(val8);
13755 ecode9 = SWIG_AsVal_double(obj6, &val9);
13756 if (!SWIG_IsOK(ecode9)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
13758 }
13759 arg9 = (PLFLT)(val9);
13760 ecode10 = SWIG_AsVal_double(obj7, &val10);
13761 if (!SWIG_IsOK(ecode10)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
13763 }
13764 arg10 = (PLFLT)(val10);
13765 ecode11 = SWIG_AsVal_double(obj8, &val11);
13766 if (!SWIG_IsOK(ecode11)) {
13767 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
13768 }
13769 arg11 = (PLFLT)(val11);
13770 if (obj9) {
13771 {
13772
13773 if ( obj9 == Py_None )
13774 {
13775 arg12 = NULL;
13776 }
13777 else
13778 {
13779 if ( !PyCallable_Check( (PyObject *) obj9 ) )
13780 {
13781 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13782 return NULL;
13783 }
13784 arg12 = marshal_pltr( obj9 );
13785 }
13786 }
13787 }
13788 if (obj10) {
13789 {
13790 if ( obj10 == Py_None )
13791 arg13 = NULL;
13792 else
13793 {
13794 arg13 = marshal_PLPointer( obj10, 1 );
13795 }
13796 }
13797 }
13798 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13799 resultobj = SWIG_Py_Void();
13800 {
13801 Py_DECREF( tmp1 );
13802 free( arg1 );
13803 }
13804 {
13805 cleanup_pltr();
13806 }
13807 {
13808 cleanup_PLPointer();
13809 }
13810 return resultobj;
13811 fail:
13812 {
13813 Py_DECREF( tmp1 );
13814 free( arg1 );
13815 }
13816 {
13817 cleanup_pltr();
13818 }
13819 {
13820 cleanup_PLPointer();
13821 }
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13827 PyObject *resultobj = 0;
13828
13829 if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
13830 plClearOpts();
13831 resultobj = SWIG_Py_Void();
13832 return resultobj;
13833 fail:
13834 return NULL;
13835 }
13836
13837
13838 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13839 PyObject *resultobj = 0;
13840
13841 if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
13842 plResetOpts();
13843 resultobj = SWIG_Py_Void();
13844 return resultobj;
13845 fail:
13846 return NULL;
13847 }
13848
13849
13850 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13851 PyObject *resultobj = 0;
13852 char *arg1 = (char *) 0 ;
13853 char *arg2 = (char *) 0 ;
13854 int res1 ;
13855 char *buf1 = 0 ;
13856 int alloc1 = 0 ;
13857 int res2 ;
13858 char *buf2 = 0 ;
13859 int alloc2 = 0 ;
13860 PyObject * obj0 = 0 ;
13861 PyObject * obj1 = 0 ;
13862
13863 if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
13864 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13865 if (!SWIG_IsOK(res1)) {
13866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
13867 }
13868 arg1 = (char *)(buf1);
13869 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13870 if (!SWIG_IsOK(res2)) {
13871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
13872 }
13873 arg2 = (char *)(buf2);
13874 plSetUsage((char const *)arg1,(char const *)arg2);
13875 resultobj = SWIG_Py_Void();
13876 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13877 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13878 return resultobj;
13879 fail:
13880 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13881 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13882 return NULL;
13883 }
13884
13885
13886 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13887 PyObject *resultobj = 0;
13888
13889 if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
13890 plOptUsage();
13891 resultobj = SWIG_Py_Void();
13892 return resultobj;
13893 fail:
13894 return NULL;
13895 }
13896
13897
13898 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13899 PyObject *resultobj = 0;
13900 PLFLT **arg1 = (PLFLT **) 0 ;
13901 PLINT arg2 ;
13902 PLINT arg3 ;
13903 PLFLT *arg4 = (PLFLT *) 0 ;
13904 PLFLT *arg5 = (PLFLT *) 0 ;
13905 PyArrayObject *tmp1 ;
13906 PLFLT temp4 ;
13907 int res4 = SWIG_TMPOBJ ;
13908 PLFLT temp5 ;
13909 int res5 = SWIG_TMPOBJ ;
13910 PyObject * obj0 = 0 ;
13911
13912 arg4 = &temp4;
13913 arg5 = &temp5;
13914 if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
13915 {
13916 int i, size;
13917 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
13918 if ( tmp1 == NULL )
13919 return NULL;
13920 Xlen = arg2 = tmp1->dimensions[0];
13921 Ylen = arg3 = tmp1->dimensions[1];
13922 size = sizeof ( PLFLT ) * arg3;
13923 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
13924 for ( i = 0; i < arg2; i++ )
13925 arg1[i] = (PLFLT *) ( tmp1->data + i * size );
13926 }
13927 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
13928 resultobj = SWIG_Py_Void();
13929 if (SWIG_IsTmpObj(res4)) {
13930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
13931 } else {
13932 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
13934 }
13935 if (SWIG_IsTmpObj(res5)) {
13936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
13937 } else {
13938 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
13940 }
13941 {
13942 Py_DECREF( tmp1 );
13943 free( arg1 );
13944 }
13945 return resultobj;
13946 fail:
13947 {
13948 Py_DECREF( tmp1 );
13949 free( arg1 );
13950 }
13951 return NULL;
13952 }
13953
13954
13955 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13956 PyObject *resultobj = 0;
13957 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13958 void *argp1 = 0 ;
13959 int res1 = 0 ;
13960 PyObject * obj0 = 0 ;
13961 PLINT result;
13962
13963 if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
13964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13965 if (!SWIG_IsOK(res1)) {
13966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13967 }
13968 arg1 = (PLGraphicsIn *)(argp1);
13969 result = (PLINT)plGetCursor(arg1);
13970 resultobj = SWIG_From_int((int)(result));
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 static PyMethodDef SwigMethods[] = {
13978 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
13979 { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
13980 { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
13981 { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
13982 { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
13983 { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
13984 { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
13985 { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
13986 { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
13987 { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
13988 { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
13989 { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
13990 { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
13991 { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
13992 { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
13993 { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
13994 { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
13995 { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
13996 { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
13997 { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
13998 { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
13999 { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
14000 { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14001 { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
14002 { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14003 { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
14004 { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14005 { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
14006 { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
14007 { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
14008 { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14009 { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
14010 { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
14011 "Set format of numerical label for contours\n"
14012 "\n"
14013 "DESCRIPTION:\n"
14014 "\n"
14015 " Set format of numerical label for contours. \n"
14016 "\n"
14017 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14018 "\n"
14019 " This function is used example 9. \n"
14020 "\n"
14021 "\n"
14022 "\n"
14023 "SYNOPSIS:\n"
14024 "\n"
14025 "pl_setcontlabelformat(lexp, sigdig)\n"
14026 "\n"
14027 "ARGUMENTS:\n"
14028 "\n"
14029 " lexp (PLINT, input) : If the contour numerical label is greater\n"
14030 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14031 " format is used. Default value of lexp is 4. \n"
14032 "\n"
14033 " sigdig (PLINT, input) : Number of significant digits. Default\n"
14034 " value is 2. \n"
14035 "\n"
14036 ""},
14037 { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
14038 "Set parameters of contour labelling other than format of numerical label\n"
14039 "\n"
14040 "DESCRIPTION:\n"
14041 "\n"
14042 " Set parameters of contour labelling other than those handled by\n"
14043 " pl_setcontlabelformat. \n"
14044 "\n"
14045 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14046 "\n"
14047 " This function is used in example 9. \n"
14048 "\n"
14049 "\n"
14050 "\n"
14051 "SYNOPSIS:\n"
14052 "\n"
14053 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14054 "\n"
14055 "ARGUMENTS:\n"
14056 "\n"
14057 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14058 " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
14059 "\n"
14060 " size (PLFLT, input) : Font height for contour labels (normalized). \n"
14061 " Default value is 0.3. \n"
14062 "\n"
14063 " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
14064 " Default value is 0.1. \n"
14065 "\n"
14066 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14067 " contour labels on. Default is off (0). \n"
14068 "\n"
14069 ""},
14070 { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
14071 "Advance the (sub-)page\n"
14072 "\n"
14073 "DESCRIPTION:\n"
14074 "\n"
14075 " Advances to the next subpage if sub=0, performing a page advance if\n"
14076 " there are no remaining subpages on the current page. If subpages\n"
14077 " aren't being used, pladv(0) will always advance the page. If sub>0,\n"
14078 " PLplot switches to the specified subpage. Note that this allows you\n"
14079 " to overwrite a plot on the specified subpage; if this is not what you\n"
14080 " intended, use pleop followed by plbop to first advance the page. This\n"
14081 " routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14082 " not used, pladv must be called after initializing PLplot but before\n"
14083 " defining the viewport. \n"
14084 "\n"
14085 " Redacted form: pladv(sub)\n"
14086 "\n"
14087 " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14088 "\n"
14089 "\n"
14090 "\n"
14091 "SYNOPSIS:\n"
14092 "\n"
14093 "pladv(sub)\n"
14094 "\n"
14095 "ARGUMENTS:\n"
14096 "\n"
14097 " sub (PLINT, input) : Specifies the subpage number (starting from 1\n"
14098 " in the top left corner and increasing along the rows) to which to\n"
14099 " advance. Set to zero to advance to the next subpage. \n"
14100 "\n"
14101 ""},
14102 { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
14103 "Draw a circular or elliptical arc \n"
14104 "\n"
14105 "DESCRIPTION:\n"
14106 "\n"
14107 " Draw a possible filled arc centered at x, y with semimajor axis a and\n"
14108 " semiminor axis b, starting at angle1 and ending at angle2. \n"
14109 "\n"
14110 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14111 "\n"
14112 "\n"
14113 " This function is used in example 3. \n"
14114 "\n"
14115 "\n"
14116 "\n"
14117 "SYNOPSIS:\n"
14118 "\n"
14119 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14120 "\n"
14121 "ARGUMENTS:\n"
14122 "\n"
14123 " x (PLFLT, input) : X coordinate of arc center. \n"
14124 "\n"
14125 " y (PLFLT, input) : Y coordinate of arc center. \n"
14126 "\n"
14127 " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
14128 "\n"
14129 " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
14130 "\n"
14131 " angle1 (PLFLT, input) : Starting angle of the arc. \n"
14132 "\n"
14133 " angle2 (PLFLT, input) : Ending angle of the arc. \n"
14134 "\n"
14135 " rotate (PLFLT, input) : Rotation of arc\n"
14136 "\n"
14137 " fill (PLBOOL, input) : Draw a filled arc. \n"
14138 "\n"
14139 ""},
14140 { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
14141 "Draw a box with axes, etc. with arbitrary origin \n"
14142 "\n"
14143 "DESCRIPTION:\n"
14144 "\n"
14145 " Draws a box around the currently defined viewport with arbitrary\n"
14146 " world-coordinate origin specified by x0 and y0 and labels it with\n"
14147 " world coordinate values appropriate to the window. Thus plaxes should\n"
14148 " only be called after defining both viewport and window. The character\n"
14149 " strings xopt and yopt specify how the box should be drawn as described\n"
14150 " below. If ticks and/or subticks are to be drawn for a particular\n"
14151 " axis, the tick intervals and number of subintervals may be specified\n"
14152 " explicitly, or they may be defaulted by setting the appropriate\n"
14153 " arguments to zero. \n"
14154 "\n"
14155 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14156 " ytick, nysub)\n"
14157 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14158 " yopt)\n"
14159 "\n"
14160 "\n"
14161 " This function is not used in any examples. \n"
14162 "\n"
14163 "\n"
14164 "\n"
14165 "SYNOPSIS:\n"
14166 "\n"
14167 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14168 "\n"
14169 "ARGUMENTS:\n"
14170 "\n"
14171 " x0 (PLFLT, input) : World X coordinate of origin. \n"
14172 "\n"
14173 " y0 (PLFLT, input) : World Y coordinate of origin. \n"
14174 "\n"
14175 " xopt (const char *, input) : Pointer to character string specifying\n"
14176 " options for horizontal axis. The string can include any\n"
14177 " combination of the following letters (upper or lower case) in any\n"
14178 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14179 " is vertical line (x=0). \n"
14180 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14181 " c: Draws top (X) or right (Y) edge of frame. \n"
14182 " d: Plot labels as date / time. Values are assumed to be\n"
14183 " seconds since the epoch (as used by gmtime). \n"
14184 " f: Always use fixed point numeric labels. \n"
14185 " g: Draws a grid at the major tick interval. \n"
14186 " h: Draws a grid at the minor tick interval. \n"
14187 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14188 " inwards. \n"
14189 " l: Labels axis logarithmically. This only affects the labels,\n"
14190 " not the data, and so it is necessary to compute the logarithms\n"
14191 " of data points before passing them to any of the drawing\n"
14192 " routines. \n"
14193 " m: Writes numeric labels at major tick intervals in the\n"
14194 " unconventional location (above box for X, right of box for Y). \n"
14195 " n: Writes numeric labels at major tick intervals in the\n"
14196 " conventional location (below box for X, left of box for Y). \n"
14197 " o: Use custom labeling function to generate axis label text. \n"
14198 " The custom labeling function can be defined with the\n"
14199 " plslabelfuncplslabelfunc; command. \n"
14200 " s: Enables subticks between major ticks, only valid if t is\n"
14201 " also specified. \n"
14202 " t: Draws major ticks. \n"
14203 "\n"
14204 "\n"
14205 " xtick (PLFLT, input) : World coordinate interval between major\n"
14206 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14207 " generates a suitable tick interval. \n"
14208 "\n"
14209 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14210 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14211 " generates a suitable minor tick interval. \n"
14212 "\n"
14213 " yopt (const char *, input) : Pointer to character string specifying\n"
14214 " options for vertical axis. The string can include any combination\n"
14215 " of the letters defined above for xopt, and in addition may\n"
14216 " contain: v: Write numeric labels for vertical axis parallel to the\n"
14217 " base of the graph, rather than parallel to the axis. \n"
14218 "\n"
14219 "\n"
14220 " ytick (PLFLT, input) : World coordinate interval between major\n"
14221 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14222 " generates a suitable tick interval. \n"
14223 "\n"
14224 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14225 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14226 " generates a suitable minor tick interval. \n"
14227 "\n"
14228 ""},
14229 { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
14230 "Plot a histogram from binned data \n"
14231 "\n"
14232 "DESCRIPTION:\n"
14233 "\n"
14234 " Plots a histogram consisting of nbin bins. The value associated with\n"
14235 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14236 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14237 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14238 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14239 " placed midway between the values in the x array. Also see plhist for\n"
14240 " drawing histograms from unbinned data. \n"
14241 "\n"
14242 " Redacted form: General: plbin(x, y, opt)\n"
14243 " Perl/PDL: plbin(nbin, x, y, opt)\n"
14244 " Python: plbin(nbin, x, y, opt)\n"
14245 "\n"
14246 "\n"
14247 " This function is not used in any examples. \n"
14248 "\n"
14249 "\n"
14250 "\n"
14251 "SYNOPSIS:\n"
14252 "\n"
14253 "plbin(nbin, x, y, opt)\n"
14254 "\n"
14255 "ARGUMENTS:\n"
14256 "\n"
14257 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14258 " and y arrays.) \n"
14259 "\n"
14260 " x (PLFLT *, input) : Pointer to array containing values associated\n"
14261 " with bins. These must form a strictly increasing sequence. \n"
14262 "\n"
14263 " y (PLFLT *, input) : Pointer to array containing number of points\n"
14264 " in bin. This is a PLFLT (instead of PLINT) array so as to allow\n"
14265 " histograms of probabilities, etc. \n"
14266 "\n"
14267 " opt (PLINT, input) : Is a combination of several flags:\n"
14268 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14269 " outer bins are expanded to fill up the entire x-axis and bins of\n"
14270 " zero height are simply drawn. \n"
14271 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14272 " between the x values. If the values in x are equally spaced,\n"
14273 " the values are the center values of the bins. \n"
14274 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14275 " size as the ones inside. \n"
14276 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14277 " (there is a gap for such bins). \n"
14278 "\n"
14279 ""},
14280 { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, NULL},
14281 { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
14282 "Begin a new page\n"
14283 "\n"
14284 "DESCRIPTION:\n"
14285 "\n"
14286 " Begins a new page. For a file driver, the output file is opened if\n"
14287 " necessary. Advancing the page via pleop and plbop is useful when a\n"
14288 " page break is desired at a particular point when plotting to subpages.\n"
14289 " Another use for pleop and plbop is when plotting pages to different\n"
14290 " files, since you can manually set the file name by calling plsfnam\n"
14291 " after the call to pleop. (In fact some drivers may only support a\n"
14292 " single page per file, making this a necessity.) One way to handle\n"
14293 " this case automatically is to page advance via pladv, but enable\n"
14294 " familying (see plsfam) with a small limit on the file size so that a\n"
14295 " new family member file will be created on each page break. \n"
14296 "\n"
14297 " Redacted form: plbop()\n"
14298 "\n"
14299 " This function is used in examples 2,20. \n"
14300 "\n"
14301 "\n"
14302 "\n"
14303 "SYNOPSIS:\n"
14304 "\n"
14305 "plbop()\n"
14306 "\n"
14307 ""},
14308 { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
14309 "Draw a box with axes, etc\n"
14310 "\n"
14311 "DESCRIPTION:\n"
14312 "\n"
14313 " Draws a box around the currently defined viewport, and labels it with\n"
14314 " world coordinate values appropriate to the window. Thus plbox should\n"
14315 " only be called after defining both viewport and window. The character\n"
14316 " strings xopt and yopt specify how the box should be drawn as described\n"
14317 " below. If ticks and/or subticks are to be drawn for a particular\n"
14318 " axis, the tick intervals and number of subintervals may be specified\n"
14319 " explicitly, or they may be defaulted by setting the appropriate\n"
14320 " arguments to zero. \n"
14321 "\n"
14322 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14323 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
14324 "\n"
14325 "\n"
14326 " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
14327 "\n"
14328 "\n"
14329 "\n"
14330 "SYNOPSIS:\n"
14331 "\n"
14332 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14333 "\n"
14334 "ARGUMENTS:\n"
14335 "\n"
14336 " xopt (const char *, input) : Pointer to character string specifying\n"
14337 " options for horizontal axis. The string can include any\n"
14338 " combination of the following letters (upper or lower case) in any\n"
14339 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14340 " is vertical line (x=0). \n"
14341 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14342 " c: Draws top (X) or right (Y) edge of frame. \n"
14343 " d: Plot labels as date / time. Values are assumed to be\n"
14344 " seconds since the epoch (as used by gmtime). \n"
14345 " f: Always use fixed point numeric labels. \n"
14346 " g: Draws a grid at the major tick interval. \n"
14347 " h: Draws a grid at the minor tick interval. \n"
14348 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14349 " inwards. \n"
14350 " l: Labels axis logarithmically. This only affects the labels,\n"
14351 " not the data, and so it is necessary to compute the logarithms\n"
14352 " of data points before passing them to any of the drawing\n"
14353 " routines. \n"
14354 " m: Writes numeric labels at major tick intervals in the\n"
14355 " unconventional location (above box for X, right of box for Y). \n"
14356 " n: Writes numeric labels at major tick intervals in the\n"
14357 " conventional location (below box for X, left of box for Y). \n"
14358 " o: Use custom labeling function to generate axis label text. \n"
14359 " The custom labeling function can be defined with the\n"
14360 " plslabelfuncplslabelfunc; command. \n"
14361 " s: Enables subticks between major ticks, only valid if t is\n"
14362 " also specified. \n"
14363 " t: Draws major ticks. \n"
14364 "\n"
14365 "\n"
14366 " xtick (PLFLT, input) : World coordinate interval between major\n"
14367 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14368 " generates a suitable tick interval. \n"
14369 "\n"
14370 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14371 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14372 " generates a suitable minor tick interval. \n"
14373 "\n"
14374 " yopt (const char *, input) : Pointer to character string specifying\n"
14375 " options for vertical axis. The string can include any combination\n"
14376 " of the letters defined above for xopt, and in addition may\n"
14377 " contain: v: Write numeric labels for vertical axis parallel to the\n"
14378 " base of the graph, rather than parallel to the axis. \n"
14379 "\n"
14380 "\n"
14381 " ytick (PLFLT, input) : World coordinate interval between major\n"
14382 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14383 " generates a suitable tick interval. \n"
14384 "\n"
14385 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14386 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14387 " generates a suitable minor tick interval. \n"
14388 "\n"
14389 ""},
14390 { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
14391 "Draw a box with axes, etc, in 3-d \n"
14392 "\n"
14393 "DESCRIPTION:\n"
14394 "\n"
14395 " Draws axes, numeric and text labels for a three-dimensional surface\n"
14396 " plot. For a more complete description of three-dimensional plotting\n"
14397 " see the PLplot documentation. \n"
14398 "\n"
14399 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
14400 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
14401 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
14402 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
14403 "\n"
14404 "\n"
14405 " This function is used in examples 8,11,18,21. \n"
14406 "\n"
14407 "\n"
14408 "\n"
14409 "SYNOPSIS:\n"
14410 "\n"
14411 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
14412 "\n"
14413 "ARGUMENTS:\n"
14414 "\n"
14415 " xopt (const char *, input) : Pointer to character string specifying\n"
14416 " options for the x axis. The string can include any combination of\n"
14417 " the following letters (upper or lower case) in any order: b: Draws\n"
14418 " axis at base, at height z=\n"
14419 " zmin where zmin is defined by call to plw3d. This character must be\n"
14420 " specified in order to use any of the other options. \n"
14421 " f: Always use fixed point numeric labels. \n"
14422 " i: Inverts tick marks, so they are drawn downwards, rather\n"
14423 " than upwards. \n"
14424 " l: Labels axis logarithmically. This only affects the labels,\n"
14425 " not the data, and so it is necessary to compute the logarithms\n"
14426 " of data points before passing them to any of the drawing\n"
14427 " routines. \n"
14428 " n: Writes numeric labels at major tick intervals. \n"
14429 " o: Use custom labeling function to generate axis label text. \n"
14430 " The custom labeling function can be defined with the\n"
14431 " plslabelfuncplslabelfunc; command. \n"
14432 " s: Enables subticks between major ticks, only valid if t is\n"
14433 " also specified. \n"
14434 " t: Draws major ticks. \n"
14435 " u: If this is specified, the text label for the axis is\n"
14436 " written under the axis. \n"
14437 "\n"
14438 "\n"
14439 " xlabel (const char *, input) : Pointer to character string\n"
14440 " specifying text label for the x axis. It is only drawn if u is in\n"
14441 " the xopt string. \n"
14442 "\n"
14443 " xtick (PLFLT, input) : World coordinate interval between major\n"
14444 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14445 " generates a suitable tick interval. \n"
14446 "\n"
14447 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14448 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14449 " generates a suitable minor tick interval. \n"
14450 "\n"
14451 " yopt (const char *, input) : Pointer to character string specifying\n"
14452 " options for the y axis. The string is interpreted in the same way\n"
14453 " as xopt. \n"
14454 "\n"
14455 " ylabel (const char *, input) : Pointer to character string\n"
14456 " specifying text label for the y axis. It is only drawn if u is in\n"
14457 " the yopt string. \n"
14458 "\n"
14459 " ytick (PLFLT, input) : World coordinate interval between major\n"
14460 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14461 " generates a suitable tick interval. \n"
14462 "\n"
14463 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14464 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14465 " generates a suitable minor tick interval. \n"
14466 "\n"
14467 " zopt (const char *, input) : Pointer to character string specifying\n"
14468 " options for the z axis. The string can include any combination of\n"
14469 " the following letters (upper or lower case) in any order: b: Draws\n"
14470 " z axis to the left of the surface plot. \n"
14471 " c: Draws z axis to the right of the surface plot. \n"
14472 " d: Draws grid lines parallel to the x-y plane behind the\n"
14473 " figure. These lines are not drawn until after plot3d or\n"
14474 " plmesh are called because of the need for hidden line removal. \n"
14475 " f: Always use fixed point numeric labels. \n"
14476 " i: Inverts tick marks, so they are drawn away from the center. \n"
14477 " l: Labels axis logarithmically. This only affects the labels,\n"
14478 " not the data, and so it is necessary to compute the logarithms\n"
14479 " of data points before passing them to any of the drawing\n"
14480 " routines. \n"
14481 " m: Writes numeric labels at major tick intervals on the\n"
14482 " right-hand vertical axis. \n"
14483 " n: Writes numeric labels at major tick intervals on the\n"
14484 " left-hand vertical axis. \n"
14485 " o: Use custom labeling function to generate axis label text. \n"
14486 " The custom labeling function can be defined with the\n"
14487 " plslabelfuncplslabelfunc; command. \n"
14488 " s: Enables subticks between major ticks, only valid if t is\n"
14489 " also specified. \n"
14490 " t: Draws major ticks. \n"
14491 " u: If this is specified, the text label is written beside the\n"
14492 " left-hand axis. \n"
14493 " v: If this is specified, the text label is written beside the\n"
14494 " right-hand axis. \n"
14495 "\n"
14496 "\n"
14497 " zlabel (const char *, input) : Pointer to character string\n"
14498 " specifying text label for the z axis. It is only drawn if u or v\n"
14499 " are in the zopt string. \n"
14500 "\n"
14501 " ztick (PLFLT, input) : World coordinate interval between major\n"
14502 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
14503 " generates a suitable tick interval. \n"
14504 "\n"
14505 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
14506 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14507 " generates a suitable minor tick interval. \n"
14508 "\n"
14509 ""},
14510 { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
14511 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
14512 "\n"
14513 "DESCRIPTION:\n"
14514 "\n"
14515 " Calculate world coordinates, wx and wy, and corresponding window index\n"
14516 " from relative device coordinates, rx and ry. \n"
14517 "\n"
14518 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
14519 " Perl/PDL: Not available? \n"
14520 "\n"
14521 "\n"
14522 " This function is used in example 31. \n"
14523 "\n"
14524 "\n"
14525 "\n"
14526 "SYNOPSIS:\n"
14527 "\n"
14528 "plcalc_world(rx, ry, wx, wy, window)\n"
14529 "\n"
14530 "ARGUMENTS:\n"
14531 "\n"
14532 " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
14533 " 0. to 1.) for the x coordinate. \n"
14534 "\n"
14535 " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
14536 " 0. to 1.) for the y coordinate. \n"
14537 "\n"
14538 " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
14539 " x corresponding to the relative device coordinates rx and ry. \n"
14540 "\n"
14541 " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
14542 " y corresponding to the relative device coordinates rx and ry. \n"
14543 "\n"
14544 " window (PLINT *, output) : Pointer to the returned last defined\n"
14545 " window index that corresponds to the input relative device\n"
14546 " coordinates (and the returned world coordinates). To give some\n"
14547 " background on the window index, for each page the initial window\n"
14548 " index is set to zero, and each time plwind is called within the\n"
14549 " page, world and device coordinates are stored for the window and\n"
14550 " the window index is incremented. Thus, for a simple page layout\n"
14551 " with non-overlapping viewports and one window per viewport, window\n"
14552 " corresponds to the viewport index (in the order which the\n"
14553 " viewport/windows were created) of the only viewport/window\n"
14554 " corresponding to rx and ry. However, for more complicated layouts\n"
14555 " with potentially overlapping viewports and possibly more than one\n"
14556 " window (set of world coordinates) per viewport, window and the\n"
14557 " corresponding output world coordinates corresponds to the last\n"
14558 " window created that fulfils the criterion that the relative device\n"
14559 " coordinates are inside it. Finally, in all cases where the input\n"
14560 " relative device coordinates are not inside any viewport/window,\n"
14561 " then window is set to -1. \n"
14562 "\n"
14563 ""},
14564 { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
14565 "Clear current (sub)page \n"
14566 "\n"
14567 "DESCRIPTION:\n"
14568 "\n"
14569 " Clears the current page, effectively erasing everything that have been\n"
14570 " drawn. This command only works with interactive drivers; if the\n"
14571 " driver does not support this, the page is filled with the background\n"
14572 " color in use. If the current page is divided into subpages, only the\n"
14573 " current subpage is erased. The nth subpage can be selected with\n"
14574 " pladv(n). \n"
14575 "\n"
14576 " Redacted form: General: plclear()\n"
14577 " Perl/PDL: Not available? \n"
14578 "\n"
14579 "\n"
14580 " This function is not used in any examples. \n"
14581 "\n"
14582 "\n"
14583 "\n"
14584 "SYNOPSIS:\n"
14585 "\n"
14586 "plclear()\n"
14587 "\n"
14588 ""},
14589 { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
14590 "Set color, map0 \n"
14591 "\n"
14592 "DESCRIPTION:\n"
14593 "\n"
14594 " Sets the color for color map0 (see the PLplot documentation). \n"
14595 "\n"
14596 " Redacted form: plcol0(color)\n"
14597 "\n"
14598 " This function is used in examples 1-9,11-16,18-27,29. \n"
14599 "\n"
14600 "\n"
14601 "\n"
14602 "SYNOPSIS:\n"
14603 "\n"
14604 "plcol0(color)\n"
14605 "\n"
14606 "ARGUMENTS:\n"
14607 "\n"
14608 " color (PLINT, input) : Integer representing the color. The\n"
14609 " defaults at present are (these may change): \n"
14610 " 0 black (default background) \n"
14611 " 1 red (default foreground) \n"
14612 " 2 yellow \n"
14613 " 3 green \n"
14614 " 4 aquamarine \n"
14615 " 5 pink \n"
14616 " 6 wheat \n"
14617 " 7 grey \n"
14618 " 8 brown \n"
14619 " 9 blue \n"
14620 " 10 BlueViolet \n"
14621 " 11 cyan \n"
14622 " 12 turquoise \n"
14623 " 13 magenta \n"
14624 " 14 salmon \n"
14625 " 15 white \n"
14626 " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
14627 " change an individual color in the map0 color palette. \n"
14628 "\n"
14629 ""},
14630 { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
14631 "Set color, map1 \n"
14632 "\n"
14633 "DESCRIPTION:\n"
14634 "\n"
14635 " Sets the color for color map1 (see the PLplot documentation). \n"
14636 "\n"
14637 " Redacted form: plcol1(col1)\n"
14638 "\n"
14639 " This function is used in example 12. \n"
14640 "\n"
14641 "\n"
14642 "\n"
14643 "SYNOPSIS:\n"
14644 "\n"
14645 "plcol1(col1)\n"
14646 "\n"
14647 "ARGUMENTS:\n"
14648 "\n"
14649 " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
14650 " and is mapped to color using the continuous map1 color palette\n"
14651 " which by default ranges from blue to the background color to red. \n"
14652 " The map1 palette can also be straightforwardly changed by the user\n"
14653 " with plscmap1 or plscmap1l. \n"
14654 "\n"
14655 ""},
14656 { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, NULL},
14657 { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
14658 "Contour plot \n"
14659 "\n"
14660 "DESCRIPTION:\n"
14661 "\n"
14662 " Draws a contour plot of the data in z[\n"
14663 " nx][\n"
14664 " ny], using the nlevel contour levels specified by clevel. Only the\n"
14665 " region of the array from kx to lx and from ky to ly is plotted out. A\n"
14666 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
14667 " additional data required by the transformation routine is used to map\n"
14668 " indices within the array to the world coordinates. See the following\n"
14669 " discussion of the arguments and the PLplot documentation for more\n"
14670 " information. \n"
14671 "\n"
14672 " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
14673 " plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
14674 " clevel, xgrid, ygrid)\n"
14675 " Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
14676 " Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
14677 " Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
14678 "\n"
14679 "\n"
14680 " This function is used in examples 9,14,16,22. \n"
14681 "\n"
14682 "\n"
14683 "\n"
14684 "SYNOPSIS:\n"
14685 "\n"
14686 "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
14687 "\n"
14688 "ARGUMENTS:\n"
14689 "\n"
14690 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
14691 " containing data to be contoured. \n"
14692 "\n"
14693 " nx, ny (PLINT, input) : Physical dimensions of array z. \n"
14694 "\n"
14695 " kx, lx (PLINT, input) : Range of x indices to consider. \n"
14696 "\n"
14697 " ky, ly (PLINT, input) : Range of y indices to consider. \n"
14698 "\n"
14699 " clevel (PLFLT *, input) : Pointer to array specifying levels at\n"
14700 " which to draw contours. \n"
14701 "\n"
14702 " nlevel (PLINT, input) : Number of contour levels to draw. \n"
14703 "\n"
14704 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
14705 " Pointer to function that defines transformation between indices\n"
14706 " in array z and the world coordinates (C only). Transformation\n"
14707 " functions are provided in the PLplot library: pltr0 for identity\n"
14708 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
14709 " defined by one- and two-dimensional arrays. In addition,\n"
14710 " user-supplied routines for the transformation can be used as well.\n"
14711 " Examples of all of these approaches are given in the PLplot\n"
14712 " documentation. The transformation function should have the form\n"
14713 " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
14714 " and similar PLplot functions which have a pltr argument, plcont\n"
14715 " requires that a transformation function be provided in the C\n"
14716 " interface. Leaving pltr NULL will result in an error. \n"
14717 "\n"
14718 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
14719 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
14720 " externally supplied. \n"
14721 "\n"
14722 ""},
14723 { (char *)"plctime", _wrap_plctime, METH_VARARGS, NULL},
14724 { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
14725 "Copy state parameters from the reference stream to the current stream \n"
14726 "\n"
14727 "DESCRIPTION:\n"
14728 "\n"
14729 " Copies state parameters from the reference stream to the current\n"
14730 " stream. Tell driver interface to map device coordinates unless flags\n"
14731 " == 1. \n"
14732 "\n"
14733 " This function is used for making save files of selected plots (e.g.\n"
14734 " from the TK driver). After initializing, you can get a copy of the\n"
14735 " current plot to the specified device by switching to this stream and\n"
14736 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
14737 " appropriate. The plot buffer must have previously been enabled (done\n"
14738 " automatically by some display drivers, such as X). \n"
14739 "\n"
14740 " Redacted form: plcpstrm(iplsr, flags)\n"
14741 "\n"
14742 " This function is used in example 1,20. \n"
14743 "\n"
14744 "\n"
14745 "\n"
14746 "SYNOPSIS:\n"
14747 "\n"
14748 "plcpstrm(iplsr, flags)\n"
14749 "\n"
14750 "ARGUMENTS:\n"
14751 "\n"
14752 " iplsr (PLINT, input) : Number of reference stream. \n"
14753 "\n"
14754 " flags (PLBOOL, input) : If flags is set to true the device\n"
14755 " coordinates are not copied from the reference to current stream. \n"
14756 "\n"
14757 ""},
14758 { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
14759 "End plotting session \n"
14760 "\n"
14761 "DESCRIPTION:\n"
14762 "\n"
14763 " Ends a plotting session, tidies up all the output files, switches\n"
14764 " interactive devices back into text mode and frees up any memory that\n"
14765 " was allocated. Must be called before end of program. \n"
14766 "\n"
14767 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
14768 " wait state after a call to plend or other functions which trigger the\n"
14769 " end of a plot page. To avoid this, use the plspause function. \n"
14770 "\n"
14771 " Redacted form: plend()\n"
14772 "\n"
14773 " This function is used in all of the examples. \n"
14774 "\n"
14775 "\n"
14776 "\n"
14777 "SYNOPSIS:\n"
14778 "\n"
14779 "plend()\n"
14780 "\n"
14781 ""},
14782 { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
14783 "End plotting session for current stream \n"
14784 "\n"
14785 "DESCRIPTION:\n"
14786 "\n"
14787 " Ends a plotting session for the current output stream only. See\n"
14788 " plsstrm for more info. \n"
14789 "\n"
14790 " Redacted form: plend1()\n"
14791 "\n"
14792 " This function is used in examples 1,20. \n"
14793 "\n"
14794 "\n"
14795 "\n"
14796 "SYNOPSIS:\n"
14797 "\n"
14798 "plend1()\n"
14799 "\n"
14800 ""},
14801 { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
14802 "Set up standard window and draw box \n"
14803 "\n"
14804 "DESCRIPTION:\n"
14805 "\n"
14806 " Sets up plotter environment for simple graphs by calling pladv and\n"
14807 " setting up viewport and window to sensible default values. plenv\n"
14808 " leaves enough room around most graphs for axis labels and a title.\n"
14809 " When these defaults are not suitable, use the individual routines\n"
14810 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
14811 " defining the window, and plbox for drawing the box. \n"
14812 "\n"
14813 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
14814 "\n"
14815 " This function is used in example 1,3,9,13,14,19-22,29. \n"
14816 "\n"
14817 "\n"
14818 "\n"
14819 "SYNOPSIS:\n"
14820 "\n"
14821 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
14822 "\n"
14823 "ARGUMENTS:\n"
14824 "\n"
14825 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
14826 " world coordinates). \n"
14827 "\n"
14828 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
14829 " world coordinates). \n"
14830 "\n"
14831 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
14832 " coordinates). \n"
14833 "\n"
14834 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
14835 " coordinates). \n"
14836 "\n"
14837 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
14838 " scales will not be set, the user must set up the scale before\n"
14839 " calling plenv using plsvpa, plvasp or other. \n"
14840 " 0: the x and y axes are scaled independently to use as much of\n"
14841 " the screen as possible. \n"
14842 " 1: the scales of the x and y axes are made equal. \n"
14843 " 2: the axis of the x and y axes are made equal, and the plot\n"
14844 " box will be square. \n"
14845 "\n"
14846 "\n"
14847 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
14848 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
14849 " -1: draw box only. \n"
14850 " 0: draw box, ticks, and numeric tick labels. \n"
14851 " 1: also draw coordinate axes at x=0 and y=0. \n"
14852 " 2: also draw a grid at major tick positions in both\n"
14853 " coordinates. \n"
14854 " 3: also draw a grid at minor tick positions in both\n"
14855 " coordinates. \n"
14856 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
14857 " have to be converted to logarithms separately.) \n"
14858 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
14859 " have to be converted to logarithms separately.) \n"
14860 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
14861 " have to be converted to logarithms separately.) \n"
14862 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
14863 " have to be converted to logarithms separately.) \n"
14864 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
14865 " have to be converted to logarithms separately.) \n"
14866 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
14867 " have to be converted to logarithms separately.) \n"
14868 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
14869 " have to be converted to logarithms separately.) \n"
14870 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
14871 " have to be converted to logarithms separately.) \n"
14872 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
14873 " and y data have to be converted to logarithms separately.) \n"
14874 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
14875 " and y data have to be converted to logarithms separately.) \n"
14876 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
14877 " and y data have to be converted to logarithms separately.) \n"
14878 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
14879 " and y data have to be converted to logarithms separately.) \n"
14880 " 40: same as 0 except date / time x labels. \n"
14881 " 41: same as 1 except date / time x labels. \n"
14882 " 42: same as 2 except date / time x labels. \n"
14883 " 43: same as 3 except date / time x labels. \n"
14884 " 50: same as 0 except date / time y labels. \n"
14885 " 51: same as 1 except date / time y labels. \n"
14886 " 52: same as 2 except date / time y labels. \n"
14887 " 53: same as 3 except date / time y labels. \n"
14888 " 60: same as 0 except date / time x and y labels. \n"
14889 " 61: same as 1 except date / time x and y labels. \n"
14890 " 62: same as 2 except date / time x and y labels. \n"
14891 " 63: same as 3 except date / time x and y labels. \n"
14892 " 70: same as 0 except custom x and y labels. \n"
14893 " 71: same as 1 except custom x and y labels. \n"
14894 " 72: same as 2 except custom x and y labels. \n"
14895 " 73: same as 3 except custom x and y labels. \n"
14896 "\n"
14897 ""},
14898 { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
14899 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
14900 "\n"
14901 "DESCRIPTION:\n"
14902 "\n"
14903 " Sets up plotter environment for simple graphs by calling pladv and\n"
14904 " setting up viewport and window to sensible default values. plenv0\n"
14905 " leaves enough room around most graphs for axis labels and a title.\n"
14906 " When these defaults are not suitable, use the individual routines\n"
14907 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
14908 " defining the window, and plbox for drawing the box. \n"
14909 "\n"
14910 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
14911 "\n"
14912 " This function is used in example 21. \n"
14913 "\n"
14914 "\n"
14915 "\n"
14916 "SYNOPSIS:\n"
14917 "\n"
14918 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
14919 "\n"
14920 "ARGUMENTS:\n"
14921 "\n"
14922 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
14923 " world coordinates). \n"
14924 "\n"
14925 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
14926 " world coordinates). \n"
14927 "\n"
14928 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
14929 " coordinates). \n"
14930 "\n"
14931 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
14932 " coordinates). \n"
14933 "\n"
14934 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
14935 " scales will not be set, the user must set up the scale before\n"
14936 " calling plenv0 using plsvpa, plvasp or other. \n"
14937 " 0: the x and y axes are scaled independently to use as much of\n"
14938 " the screen as possible. \n"
14939 " 1: the scales of the x and y axes are made equal. \n"
14940 " 2: the axis of the x and y axes are made equal, and the plot\n"
14941 " box will be square. \n"
14942 "\n"
14943 "\n"
14944 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
14945 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
14946 " -1: draw box only. \n"
14947 " 0: draw box, ticks, and numeric tick labels. \n"
14948 " 1: also draw coordinate axes at x=0 and y=0. \n"
14949 " 2: also draw a grid at major tick positions in both\n"
14950 " coordinates. \n"
14951 " 3: also draw a grid at minor tick positions in both\n"
14952 " coordinates. \n"
14953 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
14954 " have to be converted to logarithms separately.) \n"
14955 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
14956 " have to be converted to logarithms separately.) \n"
14957 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
14958 " have to be converted to logarithms separately.) \n"
14959 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
14960 " have to be converted to logarithms separately.) \n"
14961 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
14962 " have to be converted to logarithms separately.) \n"
14963 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
14964 " have to be converted to logarithms separately.) \n"
14965 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
14966 " have to be converted to logarithms separately.) \n"
14967 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
14968 " have to be converted to logarithms separately.) \n"
14969 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
14970 " and y data have to be converted to logarithms separately.) \n"
14971 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
14972 " and y data have to be converted to logarithms separately.) \n"
14973 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
14974 " and y data have to be converted to logarithms separately.) \n"
14975 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
14976 " and y data have to be converted to logarithms separately.) \n"
14977 " 40: same as 0 except date / time x labels. \n"
14978 " 41: same as 1 except date / time x labels. \n"
14979 " 42: same as 2 except date / time x labels. \n"
14980 " 43: same as 3 except date / time x labels. \n"
14981 " 50: same as 0 except date / time y labels. \n"
14982 " 51: same as 1 except date / time y labels. \n"
14983 " 52: same as 2 except date / time y labels. \n"
14984 " 53: same as 3 except date / time y labels. \n"
14985 " 60: same as 0 except date / time x and y labels. \n"
14986 " 61: same as 1 except date / time x and y labels. \n"
14987 " 62: same as 2 except date / time x and y labels. \n"
14988 " 63: same as 3 except date / time x and y labels. \n"
14989 " 70: same as 0 except custom x and y labels. \n"
14990 " 71: same as 1 except custom x and y labels. \n"
14991 " 72: same as 2 except custom x and y labels. \n"
14992 " 73: same as 3 except custom x and y labels. \n"
14993 "\n"
14994 ""},
14995 { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
14996 "Eject current page \n"
14997 "\n"
14998 "DESCRIPTION:\n"
14999 "\n"
15000 " Clears the graphics screen of an interactive device, or ejects a page\n"
15001 " on a plotter. See plbop for more information. \n"
15002 "\n"
15003 " Redacted form: pleop()\n"
15004 "\n"
15005 " This function is used in example 2,14. \n"
15006 "\n"
15007 "\n"
15008 "\n"
15009 "SYNOPSIS:\n"
15010 "\n"
15011 "pleop()\n"
15012 "\n"
15013 ""},
15014 { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
15015 "Draw x error bar \n"
15016 "\n"
15017 "DESCRIPTION:\n"
15018 "\n"
15019 " Draws a set of n horizontal error bars, the i'th error bar extending\n"
15020 " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
15021 " error bar are of length equal to the minor tick length (settable using\n"
15022 " plsmin). \n"
15023 "\n"
15024 " Redacted form: General: plerrx(xmin, ymax, y)\n"
15025 " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15026 "\n"
15027 "\n"
15028 " This function is used in example 29. \n"
15029 "\n"
15030 "\n"
15031 "\n"
15032 "SYNOPSIS:\n"
15033 "\n"
15034 "plerrx(n, xmin, xmax, y)\n"
15035 "\n"
15036 "ARGUMENTS:\n"
15037 "\n"
15038 " n (PLINT, input) : Number of error bars to draw. \n"
15039 "\n"
15040 " xmin (PLFLT *, input) : Pointer to array with x coordinates of\n"
15041 " left-hand endpoint of error bars. \n"
15042 "\n"
15043 " xmax (PLFLT *, input) : Pointer to array with x coordinates of\n"
15044 " right-hand endpoint of error bars. \n"
15045 "\n"
15046 " y (PLFLT *, input) : Pointer to array with y coordinates of error\n"
15047 " bar. \n"
15048 "\n"
15049 ""},
15050 { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
15051 "Draw y error bar \n"
15052 "\n"
15053 "DESCRIPTION:\n"
15054 "\n"
15055 " Draws a set of n vertical error bars, the i'th error bar extending\n"
15056 " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
15057 " error bar are of length equal to the minor tick length (settable using\n"
15058 " plsmin). \n"
15059 "\n"
15060 " Redacted form: General: plerry(x, ymin, ymax)\n"
15061 " Perl/PDL: plerry(n, x, ymin, ymax)\n"
15062 "\n"
15063 "\n"
15064 " This function is used in example 29. \n"
15065 "\n"
15066 "\n"
15067 "\n"
15068 "SYNOPSIS:\n"
15069 "\n"
15070 "plerry(n, x, ymin, ymax)\n"
15071 "\n"
15072 "ARGUMENTS:\n"
15073 "\n"
15074 " n (PLINT, input) : Number of error bars to draw. \n"
15075 "\n"
15076 " x (PLFLT *, input) : Pointer to array with x coordinates of error\n"
15077 " bars. \n"
15078 "\n"
15079 " ymin (PLFLT *, input) : Pointer to array with y coordinates of\n"
15080 " lower endpoint of error bars. \n"
15081 "\n"
15082 " ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n"
15083 " endpoint of error bar. \n"
15084 "\n"
15085 ""},
15086 { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
15087 "Advance to the next family file on the next new page \n"
15088 "\n"
15089 "DESCRIPTION:\n"
15090 "\n"
15091 " Advance to the next family file on the next new page. \n"
15092 "\n"
15093 " Redacted form: plfamadv()\n"
15094 "\n"
15095 " This function is not used in any examples. \n"
15096 "\n"
15097 "\n"
15098 "\n"
15099 "SYNOPSIS:\n"
15100 "\n"
15101 "plfamadv()\n"
15102 "\n"
15103 ""},
15104 { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
15105 "Draw filled polygon \n"
15106 "\n"
15107 "DESCRIPTION:\n"
15108 "\n"
15109 " Fills the polygon defined by the n points (\n"
15110 " x[i], \n"
15111 " y[i]) using the pattern defined by plpsty or plpat. The routine will\n"
15112 " automatically close the polygon between the last and first vertices. \n"
15113 " If multiple closed polygons are passed in x and y then plfill will\n"
15114 " fill in between them. \n"
15115 "\n"
15116 " Redacted form: plfill(x,y)\n"
15117 "\n"
15118 " This function is used in examples 12,13,15,16,21,24,25. \n"
15119 "\n"
15120 "\n"
15121 "\n"
15122 "SYNOPSIS:\n"
15123 "\n"
15124 "plfill(n, x, y)\n"
15125 "\n"
15126 "ARGUMENTS:\n"
15127 "\n"
15128 " n (PLINT, input) : Number of vertices in polygon. \n"
15129 "\n"
15130 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15131 " vertices. \n"
15132 "\n"
15133 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15134 " vertices. \n"
15135 "\n"
15136 ""},
15137 { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
15138 "Draw filled polygon in 3D \n"
15139 "\n"
15140 "DESCRIPTION:\n"
15141 "\n"
15142 " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15143 " using the pattern defined by plpsty or plpat. The routine will\n"
15144 " automatically close the polygon between the last and first vertices. \n"
15145 " If multiple closed polygons are passed in x, y, and z then plfill3\n"
15146 " will fill in between them. \n"
15147 "\n"
15148 " Redacted form: General: plfill3(x, y, z)\n"
15149 " Perl/PDL: plfill3(n, x, y, z)\n"
15150 "\n"
15151 "\n"
15152 " This function is used in example 15. \n"
15153 "\n"
15154 "\n"
15155 "\n"
15156 "SYNOPSIS:\n"
15157 "\n"
15158 "plfill3(n, x, y, z)\n"
15159 "\n"
15160 "ARGUMENTS:\n"
15161 "\n"
15162 " n (PLINT, input) : Number of vertices in polygon. \n"
15163 "\n"
15164 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15165 " vertices. \n"
15166 "\n"
15167 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15168 " vertices. \n"
15169 "\n"
15170 " z (PLFLT *, input) : Pointer to array with z coordinates of\n"
15171 " vertices. \n"
15172 "\n"
15173 ""},
15174 { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
15175 "Draw linear gradient inside polygon \n"
15176 "\n"
15177 "DESCRIPTION:\n"
15178 "\n"
15179 " Draw a linear gradient using colour map 1 inside the polygon defined\n"
15180 " by the n points (\n"
15181 " x[i], \n"
15182 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15183 " polygon coordinates and the gradient angle are all expressed in world\n"
15184 " coordinates. The angle from the x axis for both the rotated\n"
15185 " coordinate system and the gradient vector is specified by angle. The\n"
15186 " magnitude of the gradient vector is the difference between the maximum\n"
15187 " and minimum values of x for the vertices in the rotated coordinate\n"
15188 " system. The origin of the gradient vector can be interpreted as being\n"
15189 " anywhere on the line corresponding to the minimum x value for the\n"
15190 " vertices in the rotated coordinate system. The distance along the\n"
15191 " gradient vector is linearly transformed to the independent variable of\n"
15192 " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15193 " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15194 " colour corresponding to the independent variable of colour map 1. For\n"
15195 " more information about colour map 1 (see the PLplot documentation). \n"
15196 "\n"
15197 " Redacted form: plgradient(x,y,angle)\n"
15198 "\n"
15199 " This function is used in examples 25,30. \n"
15200 "\n"
15201 "\n"
15202 "\n"
15203 "SYNOPSIS:\n"
15204 "\n"
15205 "plgradient(n, x, y, angle)\n"
15206 "\n"
15207 "ARGUMENTS:\n"
15208 "\n"
15209 " n (PLINT, input) : Number of vertices in polygon. \n"
15210 "\n"
15211 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15212 " vertices. \n"
15213 "\n"
15214 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15215 " vertices. \n"
15216 "\n"
15217 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
15218 " axis. \n"
15219 "\n"
15220 ""},
15221 { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
15222 "Flushes the output stream \n"
15223 "\n"
15224 "DESCRIPTION:\n"
15225 "\n"
15226 " Flushes the output stream. Use sparingly, if at all. \n"
15227 "\n"
15228 " Redacted form: plflush()\n"
15229 "\n"
15230 " This function is used in examples 1,14. \n"
15231 "\n"
15232 "\n"
15233 "\n"
15234 "SYNOPSIS:\n"
15235 "\n"
15236 "plflush()\n"
15237 "\n"
15238 ""},
15239 { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
15240 "Set character font \n"
15241 "\n"
15242 "DESCRIPTION:\n"
15243 "\n"
15244 " Sets the default character font for subsequent character drawing. Also\n"
15245 " affects symbols produced by plpoin. This routine has no effect unless\n"
15246 " the extended character set is loaded (see plfontld). \n"
15247 "\n"
15248 " Redacted form: plfont(font)\n"
15249 "\n"
15250 " This function is used in examples 1,2,4,7,13,24,26. \n"
15251 "\n"
15252 "\n"
15253 "\n"
15254 "SYNOPSIS:\n"
15255 "\n"
15256 "plfont(font)\n"
15257 "\n"
15258 "ARGUMENTS:\n"
15259 "\n"
15260 " font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
15261 " and fastest) \n"
15262 " 2: Roman font \n"
15263 " 3: Italic font \n"
15264 " 4: Script font \n"
15265 "\n"
15266 ""},
15267 { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
15268 "Load character font \n"
15269 "\n"
15270 "DESCRIPTION:\n"
15271 "\n"
15272 " Sets the character set to use for subsequent character drawing. May\n"
15273 " be called before initializing PLplot. \n"
15274 "\n"
15275 " Redacted form: plfontld(set)\n"
15276 "\n"
15277 " This function is used in examples 1,7. \n"
15278 "\n"
15279 "\n"
15280 "\n"
15281 "SYNOPSIS:\n"
15282 "\n"
15283 "plfontld(set)\n"
15284 "\n"
15285 "ARGUMENTS:\n"
15286 "\n"
15287 " set (PLINT, input) : Specifies the character set to load: 0:\n"
15288 " Standard character set \n"
15289 " 1: Extended character set \n"
15290 "\n"
15291 ""},
15292 { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
15293 "Get character default height and current (scaled) height \n"
15294 "\n"
15295 "DESCRIPTION:\n"
15296 "\n"
15297 " Get character default height and current (scaled) height. \n"
15298 "\n"
15299 " Redacted form: plgchr(p_def, p_ht)\n"
15300 "\n"
15301 " This function is used in example 23. \n"
15302 "\n"
15303 "\n"
15304 "\n"
15305 "SYNOPSIS:\n"
15306 "\n"
15307 "plgchr(p_def, p_ht)\n"
15308 "\n"
15309 "ARGUMENTS:\n"
15310 "\n"
15311 " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
15312 "\n"
15313 " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
15314 " height (mm). \n"
15315 "\n"
15316 ""},
15317 { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
15318 "Returns 8-bit RGB values for given color from color map0 \n"
15319 "\n"
15320 "DESCRIPTION:\n"
15321 "\n"
15322 " Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
15323 " the PLplot documentation). Values are negative if an invalid color id\n"
15324 " is given. \n"
15325 "\n"
15326 " Redacted form: plgcol0(icol0, r, g, b)\n"
15327 "\n"
15328 " This function is used in example 2. \n"
15329 "\n"
15330 "\n"
15331 "\n"
15332 "SYNOPSIS:\n"
15333 "\n"
15334 "plgcol0(icol0, r, g, b)\n"
15335 "\n"
15336 "ARGUMENTS:\n"
15337 "\n"
15338 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15339 "\n"
15340 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15341 "\n"
15342 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15343 "\n"
15344 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15345 "\n"
15346 ""},
15347 { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
15348 "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
15349 "\n"
15350 "DESCRIPTION:\n"
15351 "\n"
15352 " Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
15353 " for given color from color map0 (see the PLplot documentation). \n"
15354 " Values are negative if an invalid color id is given. \n"
15355 "\n"
15356 " This function is used in example 30. \n"
15357 "\n"
15358 "\n"
15359 "\n"
15360 "SYNOPSIS:\n"
15361 "\n"
15362 "plgcol0a(icol0, r, g, b, a)\n"
15363 "\n"
15364 "ARGUMENTS:\n"
15365 "\n"
15366 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15367 "\n"
15368 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15369 "\n"
15370 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15371 "\n"
15372 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15373 "\n"
15374 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
15375 "\n"
15376 ""},
15377 { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
15378 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
15379 "\n"
15380 "ESCRIPTION:\n"
15381 "\n"
15382 " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
15383 "\n"
15384 " Redacted form: plgcolbg(r, g, b)\n"
15385 "\n"
15386 " This function is used in example 31. \n"
15387 "\n"
15388 "\n"
15389 "\n"
15390 "YNOPSIS:\n"
15391 "\n"
15392 "lgcolbg(r, g, b)\n"
15393 "\n"
15394 "RGUMENTS:\n"
15395 "\n"
15396 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
15397 " representing the degree of red in the color. \n"
15398 "\n"
15399 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
15400 " representing the degree of green in the color. \n"
15401 "\n"
15402 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
15403 " representing the degree of blue in the color. \n"
15404 "\n"
15405 ""},
15406 { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
15407 "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n"
15408 "\n"
15409 "ESCRIPTION:\n"
15410 "\n"
15411 " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
15412 " alpha value. \n"
15413 "\n"
15414 " This function is used in example 31. \n"
15415 "\n"
15416 "\n"
15417 "\n"
15418 "YNOPSIS:\n"
15419 "\n"
15420 "lgcolbga(r, g, b, a)\n"
15421 "\n"
15422 "RGUMENTS:\n"
15423 "\n"
15424 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
15425 " representing the degree of red in the color. \n"
15426 "\n"
15427 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
15428 " representing the degree of green in the color. \n"
15429 "\n"
15430 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
15431 " representing the degree of blue in the color. \n"
15432 "\n"
15433 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
15434 "\n"
15435 ""},
15436 { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
15437 "Get the current device-compression setting \n"
15438 "\n"
15439 "DESCRIPTION:\n"
15440 "\n"
15441 " Get the current device-compression setting. This parameter is only\n"
15442 " used for drivers that provide compression. \n"
15443 "\n"
15444 " Redacted form: plgcompression(compression)\n"
15445 "\n"
15446 " This function is used in example 31. \n"
15447 "\n"
15448 "\n"
15449 "\n"
15450 "SYNOPSIS:\n"
15451 "\n"
15452 "plgcompression(compression)\n"
15453 "\n"
15454 "ARGUMENTS:\n"
15455 "\n"
15456 " compression (PLINT *, output) : Pointer to a variable to be filled\n"
15457 " with the current device-compression setting. \n"
15458 "\n"
15459 ""},
15460 { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
15461 "Get the current device (keyword) name \n"
15462 "\n"
15463 "DESCRIPTION:\n"
15464 "\n"
15465 " Get the current device (keyword) name. Note: you must have allocated\n"
15466 " space for this (80 characters is safe). \n"
15467 "\n"
15468 " Redacted form: plgdev(p_dev)\n"
15469 "\n"
15470 " This function is used in example 14. \n"
15471 "\n"
15472 "\n"
15473 "\n"
15474 "SYNOPSIS:\n"
15475 "\n"
15476 "plgdev(p_dev)\n"
15477 "\n"
15478 "ARGUMENTS:\n"
15479 "\n"
15480 " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
15481 "\n"
15482 ""},
15483 { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
15484 "Get parameters that define current device-space window \n"
15485 "\n"
15486 "DESCRIPTION:\n"
15487 "\n"
15488 " Get relative margin width, aspect ratio, and relative justification\n"
15489 " that define current device-space window. If plsdidev has not been\n"
15490 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
15491 " p_jy will all be 0. \n"
15492 "\n"
15493 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
15494 "\n"
15495 " This function is used in example 31. \n"
15496 "\n"
15497 "\n"
15498 "\n"
15499 "SYNOPSIS:\n"
15500 "\n"
15501 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
15502 "\n"
15503 "ARGUMENTS:\n"
15504 "\n"
15505 " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
15506 "\n"
15507 " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
15508 "\n"
15509 " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
15510 "\n"
15511 " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
15512 "\n"
15513 ""},
15514 { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
15515 "Get plot orientation \n"
15516 "\n"
15517 "DESCRIPTION:\n"
15518 "\n"
15519 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
15520 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
15521 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
15522 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
15523 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
15524 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
15525 " not been called the default value pointed to by p_rot will be 0. \n"
15526 "\n"
15527 " Redacted form: plgdiori(p_rot)\n"
15528 "\n"
15529 " This function is not used in any examples. \n"
15530 "\n"
15531 "\n"
15532 "\n"
15533 "SYNOPSIS:\n"
15534 "\n"
15535 "plgdiori(p_rot)\n"
15536 "\n"
15537 "ARGUMENTS:\n"
15538 "\n"
15539 " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
15540 "\n"
15541 ""},
15542 { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
15543 "Get parameters that define current plot-space window \n"
15544 "\n"
15545 "DESCRIPTION:\n"
15546 "\n"
15547 " Get relative minima and maxima that define current plot-space window.\n"
15548 " If plsdiplt has not been called the default values pointed to by\n"
15549 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
15550 "\n"
15551 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
15552 "\n"
15553 " This function is used in example 31. \n"
15554 "\n"
15555 "\n"
15556 "\n"
15557 "SYNOPSIS:\n"
15558 "\n"
15559 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
15560 "\n"
15561 "ARGUMENTS:\n"
15562 "\n"
15563 " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
15564 "\n"
15565 " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
15566 "\n"
15567 " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
15568 "\n"
15569 " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
15570 "\n"
15571 ""},
15572 { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
15573 "Get family file parameters \n"
15574 "\n"
15575 "DESCRIPTION:\n"
15576 "\n"
15577 " Gets information about current family file, if familying is enabled. \n"
15578 " See the PLplot documentation for more information. \n"
15579 "\n"
15580 " Redacted form: plgfam(fam, num, bmax)\n"
15581 "\n"
15582 " This function is used in examples 14,31. \n"
15583 "\n"
15584 "\n"
15585 "\n"
15586 "SYNOPSIS:\n"
15587 "\n"
15588 "plgfam(fam, num, bmax)\n"
15589 "\n"
15590 "ARGUMENTS:\n"
15591 "\n"
15592 " fam (PLINT *, output) : Pointer to variable with the Boolean family\n"
15593 " flag value. If nonzero, familying is enabled. \n"
15594 "\n"
15595 " num (PLINT *, output) : Pointer to variable with the current family\n"
15596 " file number. \n"
15597 "\n"
15598 " bmax (PLINT *, output) : Pointer to variable with the maximum file\n"
15599 " size (in bytes) for a family file. \n"
15600 "\n"
15601 ""},
15602 { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
15603 "Get FCI (font characterization integer) \n"
15604 "\n"
15605 "DESCRIPTION:\n"
15606 "\n"
15607 " Gets information about the current font using the FCI approach. See\n"
15608 " the PLplot documentation for more information. \n"
15609 "\n"
15610 " Redacted form: plgfci(fci)\n"
15611 "\n"
15612 " This function is used in example 23. \n"
15613 "\n"
15614 "\n"
15615 "\n"
15616 "SYNOPSIS:\n"
15617 "\n"
15618 "plgfci(fci)\n"
15619 "\n"
15620 "ARGUMENTS:\n"
15621 "\n"
15622 " fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
15623 " integer) variable which is updated with current FCI value. \n"
15624 "\n"
15625 ""},
15626 { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
15627 "Get output file name \n"
15628 "\n"
15629 "DESCRIPTION:\n"
15630 "\n"
15631 " Gets the current output file name, if applicable. \n"
15632 "\n"
15633 " Redacted form: plgfnam(fnam)\n"
15634 "\n"
15635 " This function is used in example 31. \n"
15636 "\n"
15637 "\n"
15638 "\n"
15639 "SYNOPSIS:\n"
15640 "\n"
15641 "plgfnam(fnam)\n"
15642 "\n"
15643 "ARGUMENTS:\n"
15644 "\n"
15645 " fnam (char *, output) : Pointer to file name string (a preallocated\n"
15646 " string of 80 characters or more). \n"
15647 "\n"
15648 ""},
15649 { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
15650 "Get family, style and weight of the current font \n"
15651 "\n"
15652 "DESCRIPTION:\n"
15653 "\n"
15654 " Gets information about current font. See the PLplot documentation for\n"
15655 " more information on font selection. \n"
15656 "\n"
15657 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
15658 "\n"
15659 " This function is used in example 23. \n"
15660 "\n"
15661 "\n"
15662 "\n"
15663 "SYNOPSIS:\n"
15664 "\n"
15665 "plgfont(p_family, p_style, p_weight)\n"
15666 "\n"
15667 "ARGUMENTS:\n"
15668 "\n"
15669 " p_family (PLINT *, output) : Pointer to variable with the current\n"
15670 " font family. The available values are given by the PL_FCI_*\n"
15671 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
15672 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
15673 " p_family is NULL then the font family is not returned. \n"
15674 "\n"
15675 " p_style (PLINT *, output) : Pointer to variable with the current\n"
15676 " font style. The available values are given by the PL_FCI_*\n"
15677 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
15678 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
15679 " font style is not returned. \n"
15680 "\n"
15681 " p_weight (PLINT *, output) : Pointer to variable with the current\n"
15682 " font weight. The available values are given by the PL_FCI_*\n"
15683 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
15684 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
15685 " returned. \n"
15686 "\n"
15687 ""},
15688 { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
15689 "Get the (current) run level \n"
15690 "\n"
15691 "DESCRIPTION:\n"
15692 "\n"
15693 " Get the (current) run level. Valid settings are: 0, uninitialized \n"
15694 " 1, initialized \n"
15695 " 2, viewport defined \n"
15696 " 3, world coordinates defined \n"
15697 "\n"
15698 "\n"
15699 " Redacted form: plglevel(p_level)\n"
15700 "\n"
15701 " This function is used in example 31. \n"
15702 "\n"
15703 "\n"
15704 "\n"
15705 "SYNOPSIS:\n"
15706 "\n"
15707 "plglevel(p_level)\n"
15708 "\n"
15709 "ARGUMENTS:\n"
15710 "\n"
15711 " p_level (PLINT *, output) : Pointer to the run level. \n"
15712 "\n"
15713 ""},
15714 { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
15715 "Get page parameters \n"
15716 "\n"
15717 "DESCRIPTION:\n"
15718 "\n"
15719 " Gets the current page configuration. The length and offset values are\n"
15720 " expressed in units that are specific to the current driver. For\n"
15721 " instance: screen drivers will usually interpret them as number of\n"
15722 " pixels, whereas printer drivers will usually use mm. \n"
15723 "\n"
15724 " Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
15725 "\n"
15726 " This function is used in example 31. \n"
15727 "\n"
15728 "\n"
15729 "\n"
15730 "SYNOPSIS:\n"
15731 "\n"
15732 "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
15733 "\n"
15734 "ARGUMENTS:\n"
15735 "\n"
15736 " xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
15737 "\n"
15738 " yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n"
15739 "\n"
15740 " xleng (PLINT *, output) : Pointer to x page length value. \n"
15741 "\n"
15742 " yleng (PLINT *, output) : Pointer to y page length value. \n"
15743 "\n"
15744 " xoff (PLINT *, output) : Pointer to x page offset. \n"
15745 "\n"
15746 " yoff (PLINT *, output) : Pointer to y page offset. \n"
15747 "\n"
15748 ""},
15749 { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
15750 "Switch to graphics screen \n"
15751 "\n"
15752 "DESCRIPTION:\n"
15753 "\n"
15754 " Sets an interactive device to graphics mode, used in conjunction with\n"
15755 " pltext to allow graphics and text to be interspersed. On a device\n"
15756 " which supports separate text and graphics windows, this command causes\n"
15757 " control to be switched to the graphics window. If already in graphics\n"
15758 " mode, this command is ignored. It is also ignored on devices which\n"
15759 " only support a single window or use a different method for shifting\n"
15760 " focus. See also pltext. \n"
15761 "\n"
15762 " Redacted form: plgra()\n"
15763 "\n"
15764 " This function is used in example 1. \n"
15765 "\n"
15766 "\n"
15767 "\n"
15768 "SYNOPSIS:\n"
15769 "\n"
15770 "plgra()\n"
15771 "\n"
15772 ""},
15773 { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
15774 "Grid data from irregularly sampled data \n"
15775 "\n"
15776 "DESCRIPTION:\n"
15777 "\n"
15778 " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
15779 " plots require data placed in a uniform grid. This function takes\n"
15780 " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
15781 " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
15782 " and yg[nptsy], and returns the gridded data into output array\n"
15783 " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
15784 " with the argument type which can have one parameter specified in\n"
15785 " argument data. \n"
15786 "\n"
15787 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
15788 " Perl/PDL: Not available? \n"
15789 "\n"
15790 "\n"
15791 " This function is used in example 21. \n"
15792 "\n"
15793 "\n"
15794 "\n"
15795 "SYNOPSIS:\n"
15796 "\n"
15797 "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
15798 "\n"
15799 "ARGUMENTS:\n"
15800 "\n"
15801 " x (PLFLT *, input) : The input x array. \n"
15802 "\n"
15803 " y (PLFLT *, input) : The input y array. \n"
15804 "\n"
15805 " z (PLFLT *, input) : The input z array. Each triple x[i], y[i],\n"
15806 " z[i] represents one data sample coordinate. \n"
15807 "\n"
15808 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
15809 " arrays. \n"
15810 "\n"
15811 " xg (PLFLT *, input) : The input array that specifies the grid\n"
15812 " spacing in the x direction. Usually xg has nptsx equally spaced\n"
15813 " values from the minimum to the maximum values of the x input\n"
15814 " array. \n"
15815 "\n"
15816 " nptsx (PLINT, input) : The number of points in the xg array. \n"
15817 "\n"
15818 " yg (PLFLT *, input) : The input array that specifies the grid\n"
15819 " spacing in the y direction. Similar to the xg parameter. \n"
15820 "\n"
15821 " nptsy (PLINT, input) : The number of points in the yg array. \n"
15822 "\n"
15823 " zg (PLFLT **, output) : The output array, where data lies in the\n"
15824 " regular grid specified by xg and yg. the zg array must exist or be\n"
15825 " allocated by the user prior to the call, and must have dimension\n"
15826 " zg[nptsx][nptsy]. \n"
15827 "\n"
15828 " type (PLINT, input) : The type of gridding algorithm to use, which\n"
15829 " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
15830 " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
15831 " GRID_NNI: Natural Neighbors Interpolation \n"
15832 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
15833 " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
15834 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
15835 " Weighted \n"
15836 " For details of the algorithms read the source file plgridd.c. \n"
15837 "\n"
15838 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
15839 " which can be specified through this argument. Currently, for\n"
15840 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
15841 " use, the lower the value, the noisier (more local) the\n"
15842 " approximation is. \n"
15843 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
15844 " range [1. .. 2.]. High values enable the usage of very thin\n"
15845 " triangles for interpolation, possibly resulting in error in\n"
15846 " the approximation. \n"
15847 " GRID_NNI, only weights greater than data will be accepted. If\n"
15848 " 0, all weights will be accepted. \n"
15849 "\n"
15850 ""},
15851 { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
15852 "Get current subpage parameters \n"
15853 "\n"
15854 "DESCRIPTION:\n"
15855 "\n"
15856 " Gets the size of the current subpage in millimeters measured from the\n"
15857 " bottom left hand corner of the output device page or screen. Can be\n"
15858 " used in conjunction with plsvpa for setting the size of a viewport in\n"
15859 " absolute coordinates (millimeters). \n"
15860 "\n"
15861 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
15862 "\n"
15863 " This function is used in example 23. \n"
15864 "\n"
15865 "\n"
15866 "\n"
15867 "SYNOPSIS:\n"
15868 "\n"
15869 "plgspa(xmin, xmax, ymin, ymax)\n"
15870 "\n"
15871 "ARGUMENTS:\n"
15872 "\n"
15873 " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
15874 " hand edge of subpage in millimeters. \n"
15875 "\n"
15876 " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
15877 " hand edge of subpage in millimeters. \n"
15878 "\n"
15879 " ymin (PLFLT *, output) : Pointer to variable with position of\n"
15880 " bottom edge of subpage in millimeters. \n"
15881 "\n"
15882 " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
15883 " edge of subpage in millimeters. \n"
15884 "\n"
15885 ""},
15886 { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
15887 "Get current stream number \n"
15888 "\n"
15889 "DESCRIPTION:\n"
15890 "\n"
15891 " Gets the number of the current output stream. See also plsstrm. \n"
15892 "\n"
15893 " Redacted form: plgstrm(strm)\n"
15894 "\n"
15895 " This function is used in example 1,20. \n"
15896 "\n"
15897 "\n"
15898 "\n"
15899 "SYNOPSIS:\n"
15900 "\n"
15901 "plgstrm(strm)\n"
15902 "\n"
15903 "ARGUMENTS:\n"
15904 "\n"
15905 " strm (PLINT *, output) : Pointer to current stream value. \n"
15906 "\n"
15907 ""},
15908 { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
15909 "Get the current library version number \n"
15910 "\n"
15911 "DESCRIPTION:\n"
15912 "\n"
15913 " Get the current library version number. Note: you must have allocated\n"
15914 " space for this (80 characters is safe). \n"
15915 "\n"
15916 " Redacted form: plgver(p_ver)\n"
15917 "\n"
15918 " This function is used in example 1. \n"
15919 "\n"
15920 "\n"
15921 "\n"
15922 "SYNOPSIS:\n"
15923 "\n"
15924 "plgver(p_ver)\n"
15925 "\n"
15926 "ARGUMENTS:\n"
15927 "\n"
15928 " p_ver (char *, output) : Pointer to the current library version\n"
15929 " number. \n"
15930 "\n"
15931 ""},
15932 { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
15933 "Get viewport limits in normalized device coordinates \n"
15934 "\n"
15935 "DESCRIPTION:\n"
15936 "\n"
15937 " Get viewport limits in normalized device coordinates. \n"
15938 "\n"
15939 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15940 " Perl/PDL: Not available? \n"
15941 "\n"
15942 "\n"
15943 " This function is used in example 31. \n"
15944 "\n"
15945 "\n"
15946 "\n"
15947 "SYNOPSIS:\n"
15948 "\n"
15949 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15950 "\n"
15951 "ARGUMENTS:\n"
15952 "\n"
15953 " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
15954 " device coordinate in x. \n"
15955 "\n"
15956 " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
15957 " device coordinate in x. \n"
15958 "\n"
15959 " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
15960 " device coordinate in y. \n"
15961 "\n"
15962 " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
15963 " device coordinate in y. \n"
15964 "\n"
15965 ""},
15966 { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
15967 "Get viewport limits in world coordinates \n"
15968 "\n"
15969 "DESCRIPTION:\n"
15970 "\n"
15971 " Get viewport limits in world coordinates. \n"
15972 "\n"
15973 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15974 " Perl/PDL: Not available? \n"
15975 "\n"
15976 "\n"
15977 " This function is used in example 31. \n"
15978 "\n"
15979 "\n"
15980 "\n"
15981 "SYNOPSIS:\n"
15982 "\n"
15983 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15984 "\n"
15985 "ARGUMENTS:\n"
15986 "\n"
15987 " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
15988 " coordinate in x. \n"
15989 "\n"
15990 " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
15991 " coordinate in x. \n"
15992 "\n"
15993 " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
15994 " coordinate in y. \n"
15995 "\n"
15996 " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
15997 " coordinate in y. \n"
15998 "\n"
15999 ""},
16000 { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
16001 "Get x axis parameters \n"
16002 "\n"
16003 "DESCRIPTION:\n"
16004 "\n"
16005 " Returns current values of the digmax and digits flags for the x axis. \n"
16006 " digits is updated after the plot is drawn, so this routine should only\n"
16007 " be called after the call to plbox (or plbox3) is complete. See the\n"
16008 " PLplot documentation for more information. \n"
16009 "\n"
16010 " Redacted form: plgxax(digmax, digits)\n"
16011 "\n"
16012 " This function is used in example 31. \n"
16013 "\n"
16014 "\n"
16015 "\n"
16016 "SYNOPSIS:\n"
16017 "\n"
16018 "plgxax(digmax, digits)\n"
16019 "\n"
16020 "ARGUMENTS:\n"
16021 "\n"
16022 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16023 " number of digits for the x axis. If nonzero, the printed label\n"
16024 " has been switched to a floating point representation when the\n"
16025 " number of digits exceeds digmax. \n"
16026 "\n"
16027 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16028 " number of digits for the numeric labels (x axis) from the last\n"
16029 " plot. \n"
16030 "\n"
16031 ""},
16032 { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
16033 "Get y axis parameters \n"
16034 "\n"
16035 "DESCRIPTION:\n"
16036 "\n"
16037 " Identical to plgxax, except that arguments are flags for y axis. See\n"
16038 " the description of plgxax for more detail. \n"
16039 "\n"
16040 " Redacted form: plgyax(digmax, digits)\n"
16041 "\n"
16042 " This function is used in example 31. \n"
16043 "\n"
16044 "\n"
16045 "\n"
16046 "SYNOPSIS:\n"
16047 "\n"
16048 "plgyax(digmax, digits)\n"
16049 "\n"
16050 "ARGUMENTS:\n"
16051 "\n"
16052 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16053 " number of digits for the y axis. If nonzero, the printed label\n"
16054 " has been switched to a floating point representation when the\n"
16055 " number of digits exceeds digmax. \n"
16056 "\n"
16057 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16058 " number of digits for the numeric labels (y axis) from the last\n"
16059 " plot. \n"
16060 "\n"
16061 ""},
16062 { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
16063 "Get z axis parameters \n"
16064 "\n"
16065 "DESCRIPTION:\n"
16066 "\n"
16067 " Identical to plgxax, except that arguments are flags for z axis. See\n"
16068 " the description of plgxax for more detail. \n"
16069 "\n"
16070 " Redacted form: plgzax(digmax, digits)\n"
16071 "\n"
16072 " This function is used in example 31. \n"
16073 "\n"
16074 "\n"
16075 "\n"
16076 "SYNOPSIS:\n"
16077 "\n"
16078 "plgzax(digmax, digits)\n"
16079 "\n"
16080 "ARGUMENTS:\n"
16081 "\n"
16082 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16083 " number of digits for the z axis. If nonzero, the printed label\n"
16084 " has been switched to a floating point representation when the\n"
16085 " number of digits exceeds digmax. \n"
16086 "\n"
16087 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16088 " number of digits for the numeric labels (z axis) from the last\n"
16089 " plot. \n"
16090 "\n"
16091 ""},
16092 { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
16093 "Plot a histogram from unbinned data \n"
16094 "\n"
16095 "DESCRIPTION:\n"
16096 "\n"
16097 " Plots a histogram from n data points stored in the array data. This\n"
16098 " routine bins the data into nbin bins equally spaced between datmin and\n"
16099 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16100 " opt allows, among other things, the histogram either to be plotted in\n"
16101 " an existing window or causes plhist to call plenv with suitable limits\n"
16102 " before plotting the histogram. \n"
16103 "\n"
16104 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16105 "\n"
16106 " This function is used in example 5. \n"
16107 "\n"
16108 "\n"
16109 "\n"
16110 "SYNOPSIS:\n"
16111 "\n"
16112 "plhist(n, data, datmin, datmax, nbin, opt)\n"
16113 "\n"
16114 "ARGUMENTS:\n"
16115 "\n"
16116 " n (PLINT, input) : Number of data points. \n"
16117 "\n"
16118 " data (PLFLT *, input) : Pointer to array with values of the n data\n"
16119 " points. \n"
16120 "\n"
16121 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
16122 "\n"
16123 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
16124 "\n"
16125 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16126 " divide the interval xmin to xmax. \n"
16127 "\n"
16128 " opt (PLINT, input) : Is a combination of several flags:\n"
16129 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16130 " the histogram data, the outer bins are expanded to fill up the\n"
16131 " entire x-axis, data outside the given extremes are assigned to the\n"
16132 " outer bins and bins of zero height are simply drawn. \n"
16133 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16134 " to fit the histogram data, without this flag, plenv is called\n"
16135 " to set the world coordinates. \n"
16136 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16137 " extremes are not taken into account. This option should\n"
16138 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16139 " properly present the data. \n"
16140 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16141 " size as the ones inside. \n"
16142 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16143 " (there is a gap for such bins). \n"
16144 "\n"
16145 ""},
16146 { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
16147 "Convert HLS color to RGB \n"
16148 "\n"
16149 "DESCRIPTION:\n"
16150 "\n"
16151 " Convert HLS color coordinates to RGB. \n"
16152 "\n"
16153 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16154 " Perl/PDL: Not available? Implemented as plhls? \n"
16155 "\n"
16156 "\n"
16157 " This function is used in example 2. \n"
16158 "\n"
16159 "\n"
16160 "\n"
16161 "SYNOPSIS:\n"
16162 "\n"
16163 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16164 "\n"
16165 "ARGUMENTS:\n"
16166 "\n"
16167 " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
16168 "\n"
16169 " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
16170 " of the colour cone (0.0-1.0) \n"
16171 "\n"
16172 " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
16173 " radius of the colour cone (0.0-1.0) \n"
16174 "\n"
16175 " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
16176 " colour \n"
16177 "\n"
16178 " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
16179 " colour \n"
16180 "\n"
16181 " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
16182 " colour \n"
16183 "\n"
16184 ""},
16185 { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
16186 "Initialize PLplot \n"
16187 "\n"
16188 "DESCRIPTION:\n"
16189 "\n"
16190 " Initializing the plotting package. The program prompts for the device\n"
16191 " keyword or number of the desired output device. Hitting a RETURN in\n"
16192 " response to the prompt is the same as selecting the first device. \n"
16193 " plinit will issue no prompt if either the device was specified\n"
16194 " previously (via command line flag, the plsetopt function, or the\n"
16195 " plsdev function), or if only one device is enabled when PLplot is\n"
16196 " installed. If subpages have been specified, the output device is\n"
16197 " divided into nx by ny subpages, each of which may be used\n"
16198 " independently. If plinit is called again during a program, the\n"
16199 " previously opened file will be closed. The subroutine pladv is used\n"
16200 " to advance from one subpage to the next. \n"
16201 "\n"
16202 " Redacted form: plinit()\n"
16203 "\n"
16204 " This function is used in all of the examples. \n"
16205 "\n"
16206 "\n"
16207 "\n"
16208 "SYNOPSIS:\n"
16209 "\n"
16210 "plinit()\n"
16211 "\n"
16212 ""},
16213 { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
16214 "Draw a line between two points \n"
16215 "\n"
16216 "DESCRIPTION:\n"
16217 "\n"
16218 " Joins the point (\n"
16219 " x1, \n"
16220 " y1) to (\n"
16221 " x2, \n"
16222 " y2). \n"
16223 "\n"
16224 " Redacted form: pljoin(x1,y1,x2,y2)\n"
16225 "\n"
16226 " This function is used in examples 3,14. \n"
16227 "\n"
16228 "\n"
16229 "\n"
16230 "SYNOPSIS:\n"
16231 "\n"
16232 "pljoin(x1, y1, x2, y2)\n"
16233 "\n"
16234 "ARGUMENTS:\n"
16235 "\n"
16236 " x1 (PLFLT, input) : x coordinate of first point. \n"
16237 "\n"
16238 " y1 (PLFLT, input) : y coordinate of first point. \n"
16239 "\n"
16240 " x2 (PLFLT, input) : x coordinate of second point. \n"
16241 "\n"
16242 " y2 (PLFLT, input) : y coordinate of second point. \n"
16243 "\n"
16244 ""},
16245 { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
16246 "Simple routine to write labels \n"
16247 "\n"
16248 "DESCRIPTION:\n"
16249 "\n"
16250 " Routine for writing simple labels. Use plmtex for more complex labels. \n"
16251 "\n"
16252 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16253 "\n"
16254 " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16255 "\n"
16256 "\n"
16257 "\n"
16258 "SYNOPSIS:\n"
16259 "\n"
16260 "pllab(xlabel, ylabel, tlabel)\n"
16261 "\n"
16262 "ARGUMENTS:\n"
16263 "\n"
16264 " xlabel (const char *, input) : Label for horizontal axis. \n"
16265 "\n"
16266 " ylabel (const char *, input) : Label for vertical axis. \n"
16267 "\n"
16268 " tlabel (const char *, input) : Title of graph. \n"
16269 "\n"
16270 ""},
16271 { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
16272 "Create a discrete annotated legend using boxes, lines, and/or lines of symbols \n"
16273 "\n"
16274 "DESCRIPTION:\n"
16275 "\n"
16276 " (N.B. This is an experimental API that may be subject to further\n"
16277 " change as we gain more experience with it.) Routine for creating a\n"
16278 " discrete plot legend with a plotted box, line, and/or line of symbols\n"
16279 " for each annotated legend entry. The arguments of pllegend provide\n"
16280 " control over the location and size of the legend within the current\n"
16281 " subpage as well as the location and characteristics of the elements\n"
16282 " (most of which are optional) within that legend. The resulting legend\n"
16283 " is clipped at the boundaries of the current subpage \n"
16284 "\n"
16285 " Redacted form: pllegend(opt, x, y, plot_width, bg_color, opt_array,\n"
16286 " text_offset, text_scale, text_spacing, test_justification,\n"
16287 " text_colors, text, box_colors, box_patterns, box_scales, line_colors,\n"
16288 " line_styles, line_widths, symbol_colors, symbol_scales,\n"
16289 " symbol_numbers, symbols)\n"
16290 "\n"
16291 " This function is used in examples 4 and 26. \n"
16292 "\n"
16293 "\n"
16294 "\n"
16295 "SYNOPSIS:\n"
16296 "\n"
16297 "pllegend(opt, x, y, plot_width, bg_color, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16298 "\n"
16299 "ARGUMENTS:\n"
16300 "\n"
16301 " opt (PLINT, input) : opt contains bits controlling the overall\n"
16302 " legend. If the \n"
16303 " PL_LEGEND_BACKGROUND bit is set, plot a (semi-transparent) background\n"
16304 " for the legend. If the \n"
16305 " PL_LEGEND_TEXT_LEFT bit is set, put the text area on the left of the\n"
16306 " legend and the plotted area on the right. Otherwise, put the text\n"
16307 " area on the right of the legend and the plotted area on the left. \n"
16308 "\n"
16309 " x (PLFLT, input) : Normalized sub-page X position of the upper-left\n"
16310 " corner of the legend. \n"
16311 "\n"
16312 " y (PLFLT, input) : Normalized sub-page Y position of the upper-left\n"
16313 " corner of the legend. \n"
16314 "\n"
16315 " plot_width (PLFLT, input) : Horizontal width in normalized subpage\n"
16316 " units of the plot area (where the rectangular boxes, lines, and/or\n"
16317 " lines of symbols are drawn) of the legend. N.B. The total\n"
16318 " horizontal width of the legend in normalized subpage coordinates\n"
16319 " is calculated internally from \n"
16320 " plot_width, \n"
16321 " text_offset (see below), and length (calculated internally) of the\n"
16322 " longest text string. \n"
16323 "\n"
16324 " bg_color (PLINT, input) : The cmap0 index of the background color\n"
16325 " for the legend (\n"
16326 " PL_LEGEND_BACKGROUND). \n"
16327 "\n"
16328 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
16329 " vertical height of the legend in normalized subpage coordinates is\n"
16330 " calculated internally from \n"
16331 " nlegend, \n"
16332 " text_scale (see below), and \n"
16333 " text_spacing (see below). \n"
16334 "\n"
16335 " opt_array (const PLINT *, input) : Array of nlegend values of\n"
16336 " options to control each individual plotted area corresponding to a\n"
16337 " legend entry. If the \n"
16338 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
16339 " area. If the \n"
16340 " PL_LEGEND_COLOR_BOX, \n"
16341 " PL_LEGEND_LINE, and/or \n"
16342 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
16343 " entry is plotted with a colored box; a line; and/or a line of\n"
16344 " symbols. \n"
16345 "\n"
16346 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
16347 " area in units of character width. N.B. The total horizontal\n"
16348 " width of the legend in normalized subpage coordinates is\n"
16349 " calculated internally from \n"
16350 " plot_width (see above), \n"
16351 " text_offset, and length (calculated internally) of the longest text\n"
16352 " string. \n"
16353 "\n"
16354 " text_scale (PLFLT, input) : Character height scale for text\n"
16355 " annotations. N.B. The total vertical height of the legend in\n"
16356 " normalized subpage coordinates is calculated internally from \n"
16357 " nlegend (see above), \n"
16358 " text_scale, and \n"
16359 " text_spacing (see below). \n"
16360 "\n"
16361 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
16362 " character height from one legend entry to the next. N.B. The\n"
16363 " total vertical height of the legend in normalized subpage\n"
16364 " coordinates is calculated internally from \n"
16365 " nlegend (see above), \n"
16366 " text_scale (see above), and \n"
16367 " text_spacing. \n"
16368 "\n"
16369 " text_justification (PLFLT, input) : Justification parameter used\n"
16370 " for text justification. The most common values of\n"
16371 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
16372 " is left justified, centred, or right justified within the text\n"
16373 " area, but other values are allowed as well. \n"
16374 "\n"
16375 " text_colors (const PLINT *, input) : Array of nlegend text colors\n"
16376 " (cmap0 indices). \n"
16377 "\n"
16378 " text (const char **, input) : Array of nlegend text string\n"
16379 " annotations. \n"
16380 "\n"
16381 " box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n"
16382 " indices) for the discrete colored boxes (\n"
16383 " PL_LEGEND_COLOR_BOX). \n"
16384 "\n"
16385 " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
16386 " (plpsty indices) for the discrete colored boxes (\n"
16387 " PL_LEGEND_COLOR_BOX). \n"
16388 "\n"
16389 " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
16390 " of fraction of character height) for the height of the discrete\n"
16391 " colored boxes (\n"
16392 " PL_LEGEND_COLOR_BOX). \n"
16393 "\n"
16394 " line_colors (const PLINT *, input) : Array of nlegend line colors\n"
16395 " (cmap0 indices) (\n"
16396 " PL_LEGEND_LINE). \n"
16397 "\n"
16398 " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
16399 " (plsty indices) (\n"
16400 " PL_LEGEND_LINE). \n"
16401 "\n"
16402 " line_widths (const PLINT *, input) : Array of nlegend line widths (\n"
16403 " PL_LEGEND_LINE). \n"
16404 "\n"
16405 " symbol_colors (const PLINT *, input) : Array of nlegend symbol\n"
16406 " colors (cmap0 indices) (\n"
16407 " PL_LEGEND_SYMBOL). \n"
16408 "\n"
16409 " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
16410 " values for the symbol height (\n"
16411 " PL_LEGEND_SYMBOL). \n"
16412 "\n"
16413 " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
16414 " symbols to be drawn across the width of the plotted area (\n"
16415 " PL_LEGEND_SYMBOL). \n"
16416 "\n"
16417 " symbols (const PLINT *, input) : Array of nlegend symbols (plpoin\n"
16418 " indices) (\n"
16419 " PL_LEGEND_SYMBOL). \n"
16420 "\n"
16421 ""},
16422 { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
16423 "Sets the 3D position of the light source \n"
16424 "\n"
16425 "DESCRIPTION:\n"
16426 "\n"
16427 " Sets the 3D position of the light source for use with plsurf3d. \n"
16428 "\n"
16429 " Redacted form: pllightsource(x, y, z)\n"
16430 "\n"
16431 " This function is used in example 8. \n"
16432 "\n"
16433 "\n"
16434 "\n"
16435 "SYNOPSIS:\n"
16436 "\n"
16437 "pllightsource(x, y, z)\n"
16438 "\n"
16439 "ARGUMENTS:\n"
16440 "\n"
16441 " x (PLFLT, input) : X-coordinate of the light source. \n"
16442 "\n"
16443 " y (PLFLT, input) : Y-coordinate of the light source. \n"
16444 "\n"
16445 " z (PLFLT, input) : Z-coordinate of the light source. \n"
16446 "\n"
16447 ""},
16448 { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
16449 "Draw a line \n"
16450 "\n"
16451 "DESCRIPTION:\n"
16452 "\n"
16453 " Draws line defined by n points in x and y. \n"
16454 "\n"
16455 " Redacted form: plline(x, y)\n"
16456 "\n"
16457 " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
16458 "\n"
16459 "\n"
16460 "\n"
16461 "SYNOPSIS:\n"
16462 "\n"
16463 "plline(n, x, y)\n"
16464 "\n"
16465 "ARGUMENTS:\n"
16466 "\n"
16467 " n (PLINT, input) : Number of points defining line. \n"
16468 "\n"
16469 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
16470 "\n"
16471 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
16472 "\n"
16473 ""},
16474 { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
16475 "Draw a line in 3 space \n"
16476 "\n"
16477 "DESCRIPTION:\n"
16478 "\n"
16479 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
16480 " first set up the viewport, the 2d viewing window (in world\n"
16481 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
16482 " more info. \n"
16483 "\n"
16484 " Redacted form: plline3(x, y, z)\n"
16485 "\n"
16486 " This function is used in example 18. \n"
16487 "\n"
16488 "\n"
16489 "\n"
16490 "SYNOPSIS:\n"
16491 "\n"
16492 "plline3(n, x, y, z)\n"
16493 "\n"
16494 "ARGUMENTS:\n"
16495 "\n"
16496 " n (PLINT, input) : Number of points defining line. \n"
16497 "\n"
16498 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
16499 "\n"
16500 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
16501 "\n"
16502 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
16503 "\n"
16504 ""},
16505 { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
16506 "Select line style \n"
16507 "\n"
16508 "DESCRIPTION:\n"
16509 "\n"
16510 " This sets the line style according to one of eight predefined patterns\n"
16511 " (also see plstyl). \n"
16512 "\n"
16513 " Redacted form: pllsty(n)\n"
16514 "\n"
16515 " This function is used in examples 9,12,22,25. \n"
16516 "\n"
16517 "\n"
16518 "\n"
16519 "SYNOPSIS:\n"
16520 "\n"
16521 "pllsty(n)\n"
16522 "\n"
16523 "ARGUMENTS:\n"
16524 "\n"
16525 " n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n"
16526 " continuous line, line style 2 is a line with short dashes and\n"
16527 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
16528 " 4 has long dashes and short gaps and so on. \n"
16529 "\n"
16530 ""},
16531 { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
16532 "Plot surface mesh \n"
16533 "\n"
16534 "DESCRIPTION:\n"
16535 "\n"
16536 " Plots a surface mesh within the environment set up by plw3d. The\n"
16537 " surface is defined by the two-dimensional array z[\n"
16538 " nx][\n"
16539 " ny], the point z[i][j] being the value of the function at (\n"
16540 " x[i], \n"
16541 " y[j]). Note that the points in arrays x and y do not need to be\n"
16542 " equally spaced, but must be stored in ascending order. The parameter\n"
16543 " opt controls the way in which the surface is displayed. For further\n"
16544 " details see the PLplot documentation. \n"
16545 "\n"
16546 " Redacted form: plmesh(x, y, z, opt)\n"
16547 "\n"
16548 " This function is used in example 11. \n"
16549 "\n"
16550 "\n"
16551 "\n"
16552 "SYNOPSIS:\n"
16553 "\n"
16554 "plmesh(x, y, z, nx, ny, opt)\n"
16555 "\n"
16556 "ARGUMENTS:\n"
16557 "\n"
16558 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
16559 " the function is evaluated. \n"
16560 "\n"
16561 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
16562 " the function is evaluated. \n"
16563 "\n"
16564 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
16565 " with set of function values. \n"
16566 "\n"
16567 " nx (PLINT, input) : Number of x values at which function is\n"
16568 " evaluated. \n"
16569 "\n"
16570 " ny (PLINT, input) : Number of y values at which function is\n"
16571 " evaluated. \n"
16572 "\n"
16573 " opt (PLINT, input) : Determines the way in which the surface is\n"
16574 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
16575 " function of x for each value of y[j]. \n"
16576 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
16577 " for each value of x[i]. \n"
16578 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
16579 " at which function is defined. \n"
16580 "\n"
16581 ""},
16582 { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
16583 "Magnitude colored plot surface mesh with contour. \n"
16584 "\n"
16585 "DESCRIPTION:\n"
16586 "\n"
16587 " Identical to plmesh but with extra functionalities: the surface mesh\n"
16588 " can be colored accordingly to the current z value being plotted, a\n"
16589 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
16590 " drawn between the plotted function border and the base XY plane. \n"
16591 "\n"
16592 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
16593 "\n"
16594 " This function is used in example 11. \n"
16595 "\n"
16596 "\n"
16597 "\n"
16598 "SYNOPSIS:\n"
16599 "\n"
16600 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
16601 "\n"
16602 "ARGUMENTS:\n"
16603 "\n"
16604 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
16605 " the function is evaluated. \n"
16606 "\n"
16607 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
16608 " the function is evaluated. \n"
16609 "\n"
16610 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
16611 " with set of function values. \n"
16612 "\n"
16613 " nx (PLINT, input) : Number of x values at which function is\n"
16614 " evaluated. \n"
16615 "\n"
16616 " ny (PLINT, input) : Number of y values at which function is\n"
16617 " evaluated. \n"
16618 "\n"
16619 " opt (PLINT, input) : Determines the way in which the surface is\n"
16620 " represented. To specify more than one option just add the options,\n"
16621 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
16622 " showing z as a function of x for each value of y[j]. \n"
16623 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
16624 " for each value of x[i]. \n"
16625 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
16626 " at which function is defined. \n"
16627 " opt=MAG_COLOR: Each line in the mesh is colored according to\n"
16628 " the z value being plotted. The color is used from the current\n"
16629 " colormap 1. \n"
16630 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
16631 " using parameters \n"
16632 " nlevel and \n"
16633 " clevel. \n"
16634 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
16635 " the borders of the plotted function. \n"
16636 "\n"
16637 "\n"
16638 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
16639 " contour level spacing. \n"
16640 "\n"
16641 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
16642 "\n"
16643 ""},
16644 { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
16645 "Creates a new stream and makes it the default \n"
16646 "\n"
16647 "DESCRIPTION:\n"
16648 "\n"
16649 " Creates a new stream and makes it the default. Differs from using\n"
16650 " plsstrm, in that a free stream number is found, and returned.\n"
16651 " Unfortunately, I have to start at stream 1 and work upward, since\n"
16652 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
16653 " that no initial, library-opening call is required. So stream 0 must\n"
16654 " be preallocated, and there is no simple way of determining whether it\n"
16655 " is already in use or not. \n"
16656 "\n"
16657 " Redacted form: plmkstrm(p_strm)\n"
16658 "\n"
16659 " This function is used in examples 1,20. \n"
16660 "\n"
16661 "\n"
16662 "\n"
16663 "SYNOPSIS:\n"
16664 "\n"
16665 "plmkstrm(p_strm)\n"
16666 "\n"
16667 "ARGUMENTS:\n"
16668 "\n"
16669 " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
16670 " stream. \n"
16671 "\n"
16672 ""},
16673 { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
16674 "Write text relative to viewport boundaries \n"
16675 "\n"
16676 "DESCRIPTION:\n"
16677 "\n"
16678 " Writes text at a specified position relative to the viewport\n"
16679 " boundaries. Text may be written inside or outside the viewport, but\n"
16680 " is clipped at the subpage boundaries. The reference point of a string\n"
16681 " lies along a line passing through the string at half the height of a\n"
16682 " capital letter. The position of the reference point along this line\n"
16683 " is determined by just, and the position of the reference point\n"
16684 " relative to the viewport is set by disp and pos. \n"
16685 "\n"
16686 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
16687 " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
16688 "\n"
16689 "\n"
16690 " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
16691 "\n"
16692 "\n"
16693 "\n"
16694 "SYNOPSIS:\n"
16695 "\n"
16696 "plmtex(side, disp, pos, just, text)\n"
16697 "\n"
16698 "ARGUMENTS:\n"
16699 "\n"
16700 " side (const char *, input) : Specifies the side of the viewport\n"
16701 " along which the text is to be written. The string must be one of:\n"
16702 " b: Bottom of viewport, text written parallel to edge. \n"
16703 " bv: Bottom of viewport, text written at right angles to edge. \n"
16704 " l: Left of viewport, text written parallel to edge. \n"
16705 " lv: Left of viewport, text written at right angles to edge. \n"
16706 " r: Right of viewport, text written parallel to edge. \n"
16707 " rv: Right of viewport, text written at right angles to edge. \n"
16708 " t: Top of viewport, text written parallel to edge. \n"
16709 " tv: Top of viewport, text written at right angles to edge. \n"
16710 "\n"
16711 "\n"
16712 " disp (PLFLT, input) : Position of the reference point of string,\n"
16713 " measured outwards from the specified viewport edge in units of the\n"
16714 " current character height. Use negative disp to write within the\n"
16715 " viewport. \n"
16716 "\n"
16717 " pos (PLFLT, input) : Position of the reference point of string\n"
16718 " along the specified edge, expressed as a fraction of the length of\n"
16719 " the edge. \n"
16720 "\n"
16721 " just (PLFLT, input) : Specifies the position of the string relative\n"
16722 " to its reference point. If just=0., the reference point is at the\n"
16723 " left and if just=1., it is at the right of the string. Other\n"
16724 " values of just give intermediate justifications. \n"
16725 "\n"
16726 " text (const char *, input) : The string to be written out. \n"
16727 "\n"
16728 ""},
16729 { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
16730 "Write text relative to viewport boundaries in 3D plots. \n"
16731 "\n"
16732 "DESCRIPTION:\n"
16733 "\n"
16734 " Writes text at a specified position relative to the viewport\n"
16735 " boundaries. Text may be written inside or outside the viewport, but\n"
16736 " is clipped at the subpage boundaries. The reference point of a string\n"
16737 " lies along a line passing through the string at half the height of a\n"
16738 " capital letter. The position of the reference point along this line\n"
16739 " is determined by just, and the position of the reference point\n"
16740 " relative to the viewport is set by disp and pos. \n"
16741 "\n"
16742 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
16743 "\n"
16744 " This function is used in example 28. \n"
16745 "\n"
16746 "\n"
16747 "\n"
16748 "SYNOPSIS:\n"
16749 "\n"
16750 "plmtex3(side, disp, pos, just, text)\n"
16751 "\n"
16752 "ARGUMENTS:\n"
16753 "\n"
16754 " side (const char *, input) : Specifies the side of the viewport\n"
16755 " along which the text is to be written. The string should contain\n"
16756 " one or more of the following characters: [xyz][ps][v]. Only one\n"
16757 " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
16758 " both the X and Y axes. x: Label the X axis. \n"
16759 " y: Label the Y axis. \n"
16760 " z: Label the Z axis. \n"
16761 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
16762 " For X it is the axis that starts at y-min. For Y it is the\n"
16763 " axis that starts at x-min. \n"
16764 " s: Label the secondary axis. \n"
16765 " v: Draw the text perpendicular to the axis. \n"
16766 "\n"
16767 "\n"
16768 " disp (PLFLT, input) : Position of the reference point of string,\n"
16769 " measured outwards from the specified viewport edge in units of the\n"
16770 " current character height. Use negative disp to write within the\n"
16771 " viewport. \n"
16772 "\n"
16773 " pos (PLFLT, input) : Position of the reference point of string\n"
16774 " along the specified edge, expressed as a fraction of the length of\n"
16775 " the edge. \n"
16776 "\n"
16777 " just (PLFLT, input) : Specifies the position of the string relative\n"
16778 " to its reference point. If just=0., the reference point is at the\n"
16779 " left and if just=1., it is at the right of the string. Other\n"
16780 " values of just give intermediate justifications. \n"
16781 "\n"
16782 " text (const char *, input) : The string to be written out. \n"
16783 "\n"
16784 ""},
16785 { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
16786 "Plot 3-d surface plot \n"
16787 "\n"
16788 "DESCRIPTION:\n"
16789 "\n"
16790 " Plots a three dimensional surface plot within the environment set up\n"
16791 " by plw3d. The surface is defined by the two-dimensional array z[\n"
16792 " nx][\n"
16793 " ny], the point z[i][j] being the value of the function at (\n"
16794 " x[i], \n"
16795 " y[j]). Note that the points in arrays x and y do not need to be\n"
16796 " equally spaced, but must be stored in ascending order. The parameter\n"
16797 " opt controls the way in which the surface is displayed. For further\n"
16798 " details see the PLplot documentation. The only difference between\n"
16799 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
16800 " while plot3d only draws the surface as viewed from the top. \n"
16801 "\n"
16802 " Redacted form: plot3d(x, y, z, opt, side)\n"
16803 "\n"
16804 " This function is used in examples 11,21. \n"
16805 "\n"
16806 "\n"
16807 "\n"
16808 "SYNOPSIS:\n"
16809 "\n"
16810 "plot3d(x, y, z, nx, ny, opt, side)\n"
16811 "\n"
16812 "ARGUMENTS:\n"
16813 "\n"
16814 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
16815 " the function is evaluated. \n"
16816 "\n"
16817 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
16818 " the function is evaluated. \n"
16819 "\n"
16820 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
16821 " with set of function values. \n"
16822 "\n"
16823 " nx (PLINT, input) : Number of x values at which function is\n"
16824 " evaluated. \n"
16825 "\n"
16826 " ny (PLINT, input) : Number of y values at which function is\n"
16827 " evaluated. \n"
16828 "\n"
16829 " opt (PLINT, input) : Determines the way in which the surface is\n"
16830 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
16831 " function of x for each value of y[j]. \n"
16832 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
16833 " for each value of x[i]. \n"
16834 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
16835 " at which function is defined. \n"
16836 "\n"
16837 "\n"
16838 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
16839 " should be draw on the figure. If side is true sides are drawn,\n"
16840 " otherwise no sides are drawn. \n"
16841 "\n"
16842 ""},
16843 { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
16844 "Magnitude colored plot surface with contour. \n"
16845 "\n"
16846 "DESCRIPTION:\n"
16847 "\n"
16848 " Identical to plot3d but with extra functionalities: the surface mesh\n"
16849 " can be colored accordingly to the current z value being plotted, a\n"
16850 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
16851 " drawn between the plotted function border and the base XY plane. The\n"
16852 " arguments are identical to plmeshc. The only difference between\n"
16853 " plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
16854 " surface, while plot3dc only draws the surface as viewed from the top. \n"
16855 "\n"
16856 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
16857 " Perl/PDL: Not available? \n"
16858 "\n"
16859 "\n"
16860 " This function is used in example 21. \n"
16861 "\n"
16862 "\n"
16863 "\n"
16864 "SYNOPSIS:\n"
16865 "\n"
16866 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
16867 "\n"
16868 ""},
16869 { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, NULL},
16870 { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
16871 "Plot shaded 3-d surface plot \n"
16872 "\n"
16873 "DESCRIPTION:\n"
16874 "\n"
16875 " Plots a three dimensional shaded surface plot within the environment\n"
16876 " set up by plw3d. The surface is defined by the two-dimensional array\n"
16877 " z[\n"
16878 " nx][\n"
16879 " ny], the point z[i][j] being the value of the function at (\n"
16880 " x[i], \n"
16881 " y[j]). Note that the points in arrays x and y do not need to be\n"
16882 " equally spaced, but must be stored in ascending order. For further\n"
16883 " details see the PLplot documentation. \n"
16884 "\n"
16885 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
16886 "\n"
16887 " This function is not used in any examples. \n"
16888 "\n"
16889 "\n"
16890 "\n"
16891 "SYNOPSIS:\n"
16892 "\n"
16893 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
16894 "\n"
16895 "ARGUMENTS:\n"
16896 "\n"
16897 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
16898 " the function is evaluated. \n"
16899 "\n"
16900 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
16901 " the function is evaluated. \n"
16902 "\n"
16903 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
16904 " with set of function values. \n"
16905 "\n"
16906 " nx (PLINT, input) : Number of x values at which function is\n"
16907 " evaluated. \n"
16908 "\n"
16909 " ny (PLINT, input) : Number of y values at which function is\n"
16910 " evaluated. \n"
16911 "\n"
16912 " opt (PLINT, input) : Determines the way in which the surface is\n"
16913 " represented. To specify more than one option just add the options,\n"
16914 " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
16915 " connecting points at which function is defined. \n"
16916 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
16917 " using parameters \n"
16918 " nlevel and \n"
16919 " clevel. \n"
16920 " opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
16921 " using parameters \n"
16922 " nlevel and \n"
16923 " clevel. \n"
16924 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
16925 " the borders of the plotted function. \n"
16926 " opt=MAG_COLOR: the surface is colored according to the value\n"
16927 " of Z; if MAG_COLOR is not used, then the default the surface\n"
16928 " is colored according to the intensity of the reflected light\n"
16929 " in the surface from a light source whose position is set using\n"
16930 " pllightsource. \n"
16931 "\n"
16932 "\n"
16933 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
16934 " contour level spacing. \n"
16935 "\n"
16936 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
16937 "\n"
16938 ""},
16939 { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, NULL},
16940 { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
16941 "Parse command-line arguments \n"
16942 "\n"
16943 "DESCRIPTION:\n"
16944 "\n"
16945 " Parse command-line arguments. \n"
16946 "\n"
16947 " plparseopts removes all recognized flags (decreasing argc\n"
16948 " accordingly), so that invalid input may be readily detected. It can\n"
16949 " also be used to process user command line flags. The user can merge\n"
16950 " an option table of type PLOptionTable into the internal option table\n"
16951 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
16952 " the external table(s) be parsed by calling plClearOpts before\n"
16953 " plMergeOpts. \n"
16954 "\n"
16955 " The default action taken by plparseopts is as follows: \n"
16956 " Returns with an error if an unrecognized option or badly formed\n"
16957 " option-value pair are encountered. \n"
16958 " Returns immediately (return code 0) when the first non-option command\n"
16959 " line argument is found. \n"
16960 " Returns with the return code of the option handler, if one was called.\n"
16961 " \n"
16962 " Deletes command line arguments from argv list as they are found, and\n"
16963 " decrements argc accordingly. \n"
16964 " Does not show \"invisible\" options in usage or help messages. \n"
16965 " Assumes the program name is contained in argv[0]. \n"
16966 "\n"
16967 "\n"
16968 " These behaviors may be controlled through the \n"
16969 " mode argument. \n"
16970 "\n"
16971 " Redacted form: General: plparseopts(argv, mode)\n"
16972 " Perl/PDL: Not available? \n"
16973 "\n"
16974 "\n"
16975 " This function is used in all of the examples. \n"
16976 "\n"
16977 "\n"
16978 "\n"
16979 "SYNOPSIS:\n"
16980 "\n"
16981 "int plparseopts(p_argc, argv, mode)\n"
16982 "\n"
16983 "ARGUMENTS:\n"
16984 "\n"
16985 " p_argc (int *, input) : pointer to number of arguments. \n"
16986 "\n"
16987 " argv (char **, input) : Pointer to character array containing\n"
16988 " *p_argc command-line arguments. \n"
16989 "\n"
16990 " mode (PLINT, input) : Parsing mode with the following\n"
16991 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
16992 " and all error messages enabled, including program exit when an\n"
16993 " error occurs. Anything on the command line that isn't recognized\n"
16994 " as a valid option or option argument is flagged as an error. \n"
16995 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
16996 " of errors. \n"
16997 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
16998 " arguments. \n"
16999 " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17000 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17001 " pointer to the program name. \n"
17002 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17003 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17004 " unrecognized arguments. \n"
17005 "\n"
17006 ""},
17007 { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
17008 "Set area fill pattern \n"
17009 "\n"
17010 "DESCRIPTION:\n"
17011 "\n"
17012 " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
17013 " parallel lines with specified inclinations and spacings. The\n"
17014 " arguments to this routine are the number of sets to use (1 or 2)\n"
17015 " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17016 " specifying the inclinations in tenths of a degree and the spacing in\n"
17017 " micrometers. (also see plpsty) \n"
17018 "\n"
17019 " Redacted form: General: plpat(inc, del)\n"
17020 " Perl/PDL: plpat(nlin, inc, del)\n"
17021 "\n"
17022 "\n"
17023 " This function is used in example 15. \n"
17024 "\n"
17025 "\n"
17026 "\n"
17027 "SYNOPSIS:\n"
17028 "\n"
17029 "plpat(nlin, inc, del)\n"
17030 "\n"
17031 "ARGUMENTS:\n"
17032 "\n"
17033 " nlin (PLINT, input) : Number of sets of lines making up the\n"
17034 " pattern, either 1 or 2. \n"
17035 "\n"
17036 " inc (PLINT *, input) : Pointer to array with nlin elements.\n"
17037 " Specifies the line inclination in tenths of a degree. (Should be\n"
17038 " between -900 and 900). \n"
17039 "\n"
17040 " del (PLINT *, input) : Pointer to array with nlin elements.\n"
17041 " Specifies the spacing in micrometers between the lines making up\n"
17042 " the pattern. \n"
17043 "\n"
17044 ""},
17045 { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
17046 "Plots a character at the specified points \n"
17047 "\n"
17048 "DESCRIPTION:\n"
17049 "\n"
17050 " Marks a set of n points in x and y using the symbol defined by code.\n"
17051 " If code is between 32 and 127, the symbol is simply the corresponding\n"
17052 " printable ASCII character in the default font. \n"
17053 "\n"
17054 " Redacted form: plpoin(x, y, code)\n"
17055 "\n"
17056 " This function is used in examples 1,6,14,18,21,29. \n"
17057 "\n"
17058 "\n"
17059 "\n"
17060 "SYNOPSIS:\n"
17061 "\n"
17062 "plpoin(n, x, y, code)\n"
17063 "\n"
17064 "ARGUMENTS:\n"
17065 "\n"
17066 " n (PLINT, input) : Number of points to be marked. \n"
17067 "\n"
17068 " x (PLFLT *, input) : Pointer to array with x coordinates of the\n"
17069 " points. \n"
17070 "\n"
17071 " y (PLFLT *, input) : Pointer to array with y coordinates of the\n"
17072 " points. \n"
17073 "\n"
17074 " code (PLINT, input) : Code number for the symbol to be plotted. \n"
17075 "\n"
17076 ""},
17077 { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
17078 "Plots a character at the specified points in 3 space \n"
17079 "\n"
17080 "ESCRIPTION:\n"
17081 "\n"
17082 " Marks a set of n points in x, y, and z using the symbol defined by\n"
17083 " code. If code is between 32 and 127, the symbol is simply the\n"
17084 " corresponding printable ASCII character in the default font. Setup\n"
17085 " similar to plline3. \n"
17086 "\n"
17087 " Redacted form: plpoin3(x, y, z, code)\n"
17088 "\n"
17089 " This function is used in example 18. \n"
17090 "\n"
17091 "\n"
17092 "\n"
17093 "YNOPSIS:\n"
17094 "\n"
17095 "lpoin3(n, x, y, z, code)\n"
17096 "\n"
17097 "RGUMENTS:\n"
17098 "\n"
17099 " n (PLINT, input) : Number of points to be marked. \n"
17100 "\n"
17101 " x (PLFLT *, input) : Pointer to array with x coordinates of the\n"
17102 " points. \n"
17103 "\n"
17104 " y (PLFLT *, input) : Pointer to array with y coordinates of the\n"
17105 " points. \n"
17106 "\n"
17107 " z (PLFLT *, input) : Pointer to array with z coordinates of the\n"
17108 " points. \n"
17109 "\n"
17110 " code (PLINT, input) : Code number for the symbol to be plotted. \n"
17111 "\n"
17112 ""},
17113 { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
17114 "Draw a polygon in 3 space \n"
17115 "\n"
17116 "DESCRIPTION:\n"
17117 "\n"
17118 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
17119 " like plline3, but differs from that function in that plpoly3 attempts\n"
17120 " to determine if the polygon is viewable depending on the order of the\n"
17121 " points within the arrays and the value of ifcc. If the back of\n"
17122 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
17123 " you want, then use plline3 instead. \n"
17124 "\n"
17125 " The points are assumed to be in a plane, and the directionality of the\n"
17126 " plane is determined from the first three points. Additional points do\n"
17127 " not have to lie on the plane defined by the first three, but if they\n"
17128 " do not, then the determination of visibility obviously can't be 100%\n"
17129 " accurate... So if you're 3 space polygons are too far from planar,\n"
17130 " consider breaking them into smaller polygons. 3 points define a plane\n"
17131 " :-). \n"
17132 "\n"
17133 " Bugs: If one of the first two segments is of zero length, or if they\n"
17134 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
17135 " being correct. Avoid such situations :-). See x18c.c for an example\n"
17136 " of this problem. (Search for 20.1). \n"
17137 "\n"
17138 " Redacted form: plpoly3(x, y, z, code)\n"
17139 "\n"
17140 " This function is used in example 18. \n"
17141 "\n"
17142 "\n"
17143 "\n"
17144 "SYNOPSIS:\n"
17145 "\n"
17146 "plpoly3(n, x, y, z, draw, ifcc)\n"
17147 "\n"
17148 "ARGUMENTS:\n"
17149 "\n"
17150 " n (PLINT, input) : Number of points defining line. \n"
17151 "\n"
17152 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17153 "\n"
17154 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17155 "\n"
17156 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17157 "\n"
17158 " draw (PLBOOL *, input) : Pointer to array which controls drawing\n"
17159 " the segments of the polygon. If draw[i] is true, then the polygon\n"
17160 " segment from index [i] to [i+1] is drawn, otherwise, not. \n"
17161 "\n"
17162 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
17163 " polygon is determined by assuming the points are laid out in a\n"
17164 " counter-clockwise order. Otherwise, the directionality of the\n"
17165 " polygon is determined by assuming the points are laid out in a\n"
17166 " clockwise order. \n"
17167 "\n"
17168 ""},
17169 { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
17170 "Set precision in numeric labels \n"
17171 "\n"
17172 "DESCRIPTION:\n"
17173 "\n"
17174 " Sets the number of places after the decimal point in numeric labels. \n"
17175 "\n"
17176 " Redacted form: plprec(set, prec)\n"
17177 "\n"
17178 " This function is used in example 29. \n"
17179 "\n"
17180 "\n"
17181 "\n"
17182 "SYNOPSIS:\n"
17183 "\n"
17184 "plprec(set, prec)\n"
17185 "\n"
17186 "ARGUMENTS:\n"
17187 "\n"
17188 " set (PLINT, input) : If set is equal to 0 then PLplot automatically\n"
17189 " determines the number of places to use after the decimal point in\n"
17190 " numeric labels (like those used to label axes). If set is 1 then\n"
17191 " prec sets the number of places. \n"
17192 "\n"
17193 " prec (PLINT, input) : The number of characters to draw after the\n"
17194 " decimal point in numeric labels. \n"
17195 "\n"
17196 ""},
17197 { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
17198 "Select area fill pattern \n"
17199 "\n"
17200 "DESCRIPTION:\n"
17201 "\n"
17202 " Select one of eight predefined area fill patterns to use (also see\n"
17203 " plpat). \n"
17204 "\n"
17205 " Redacted form: plpsty(n)\n"
17206 "\n"
17207 " This function is used in examples 12,13,15,16,25. \n"
17208 "\n"
17209 "\n"
17210 "\n"
17211 "SYNOPSIS:\n"
17212 "\n"
17213 "plpsty(n)\n"
17214 "\n"
17215 "ARGUMENTS:\n"
17216 "\n"
17217 " n (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
17218 " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
17219 " consists of lines at 45 degrees angle (upward), and so on. \n"
17220 "\n"
17221 ""},
17222 { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
17223 "Write text inside the viewport \n"
17224 "\n"
17225 "DESCRIPTION:\n"
17226 "\n"
17227 " Writes text at a specified position and inclination within the\n"
17228 " viewport. Text is clipped at the viewport boundaries. The reference\n"
17229 " point of a string lies along a line passing through the string at half\n"
17230 " the height of a capital letter. The position of the reference point\n"
17231 " along this line is determined by just, the reference point is placed\n"
17232 " at world coordinates (\n"
17233 " x, \n"
17234 " y) within the viewport. The inclination of the string is specified in\n"
17235 " terms of differences of world coordinates making it easy to write text\n"
17236 " parallel to a line in a graph. \n"
17237 "\n"
17238 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
17239 "\n"
17240 " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
17241 "\n"
17242 "\n"
17243 "\n"
17244 "SYNOPSIS:\n"
17245 "\n"
17246 "plptex(x, y, dx, dy, just, text)\n"
17247 "\n"
17248 "ARGUMENTS:\n"
17249 "\n"
17250 " x (PLFLT, input) : x coordinate of reference point of string. \n"
17251 "\n"
17252 " y (PLFLT, input) : y coordinate of reference point of string. \n"
17253 "\n"
17254 " dx (PLFLT, input) : Together with dy, this specifies the\n"
17255 " inclination of the string. The baseline of the string is parallel\n"
17256 " to a line joining (\n"
17257 " x, \n"
17258 " y) to (\n"
17259 " x+\n"
17260 " dx, \n"
17261 " y+\n"
17262 " dy). \n"
17263 "\n"
17264 " dy (PLFLT, input) : Together with dx, this specifies the\n"
17265 " inclination of the string. \n"
17266 "\n"
17267 " just (PLFLT, input) : Specifies the position of the string relative\n"
17268 " to its reference point. If just=0., the reference point is at the\n"
17269 " left and if just=1., it is at the right of the string. Other\n"
17270 " values of just give intermediate justifications. \n"
17271 "\n"
17272 " text (const char *, input) : The string to be written out. \n"
17273 "\n"
17274 ""},
17275 { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
17276 "Write text inside the viewport of a 3D plot. \n"
17277 "\n"
17278 "DESCRIPTION:\n"
17279 "\n"
17280 " Writes text at a specified position and inclination and with a\n"
17281 " specified shear within the viewport. Text is clipped at the viewport\n"
17282 " boundaries. The reference point of a string lies along a line passing\n"
17283 " through the string at half the height of a capital letter. The\n"
17284 " position of the reference point along this line is determined by just,\n"
17285 " and the reference point is placed at world coordinates (\n"
17286 " x, \n"
17287 " y, \n"
17288 " z) within the viewport. The inclination and shear of the string is\n"
17289 " specified in terms of differences of world coordinates making it easy\n"
17290 " to write text parallel to a line in a graph. \n"
17291 "\n"
17292 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17293 "\n"
17294 " This function is used in example 28. \n"
17295 "\n"
17296 "\n"
17297 "\n"
17298 "SYNOPSIS:\n"
17299 "\n"
17300 "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17301 "\n"
17302 "ARGUMENTS:\n"
17303 "\n"
17304 " x (PLFLT, input) : x coordinate of reference point of string. \n"
17305 "\n"
17306 " y (PLFLT, input) : y coordinate of reference point of string. \n"
17307 "\n"
17308 " z (PLFLT, input) : z coordinate of reference point of string. \n"
17309 "\n"
17310 " dx (PLFLT, input) : Together with dy and \n"
17311 " dz, this specifies the inclination of the string. The baseline of\n"
17312 " the string is parallel to a line joining (\n"
17313 " x, \n"
17314 " y, \n"
17315 " z) to (\n"
17316 " x+\n"
17317 " dx, \n"
17318 " y+\n"
17319 " dy, \n"
17320 " z+\n"
17321 " dz). \n"
17322 "\n"
17323 " dy (PLFLT, input) : Together with dx and \n"
17324 " dz, this specifies the inclination of the string. \n"
17325 "\n"
17326 " dz (PLFLT, input) : Together with dx and \n"
17327 " dy, this specifies the inclination of the string. \n"
17328 "\n"
17329 " sx (PLFLT, input) : Together with sy and \n"
17330 " sz, this specifies the shear of the string. The string is sheared so\n"
17331 " that the characters are vertically parallel to a line joining (\n"
17332 " x, \n"
17333 " y, \n"
17334 " z) to (\n"
17335 " x+\n"
17336 " sx, \n"
17337 " y+\n"
17338 " sy, \n"
17339 " z+\n"
17340 " sz). If sx = \n"
17341 " sy = \n"
17342 " sz = 0.) then the text is not sheared. \n"
17343 "\n"
17344 " sy (PLFLT, input) : Together with sx and \n"
17345 " sz, this specifies shear of the string. \n"
17346 "\n"
17347 " sz (PLFLT, input) : Together with sx and \n"
17348 " sy, this specifies shear of the string. \n"
17349 "\n"
17350 " just (PLFLT, input) : Specifies the position of the string relative\n"
17351 " to its reference point. If just=0., the reference point is at the\n"
17352 " left and if just=1., it is at the right of the string. Other\n"
17353 " values of just give intermediate justifications. \n"
17354 "\n"
17355 " text (const char *, input) : The string to be written out. \n"
17356 "\n"
17357 ""},
17358 { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
17359 "Random number generator returning a real random number in the range [0,1]. \n"
17360 "\n"
17361 "DESCRIPTION:\n"
17362 "\n"
17363 " Random number generator returning a real random number in the range\n"
17364 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
17365 " / compilers provide their own random number generator, and so this is\n"
17366 " provided purely for convenience and to give a consistent random number\n"
17367 " generator across all languages supported by PLplot. This is\n"
17368 " particularly useful for comparing results from the test suite of\n"
17369 " examples. \n"
17370 "\n"
17371 " Redacted form: plrandd()\n"
17372 "\n"
17373 " This function is used in examples 17,21. \n"
17374 "\n"
17375 "\n"
17376 "\n"
17377 "SYNOPSIS:\n"
17378 "\n"
17379 "plrandd()\n"
17380 "\n"
17381 ""},
17382 { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
17383 "Replays contents of plot buffer to current device/file \n"
17384 "\n"
17385 "DESCRIPTION:\n"
17386 "\n"
17387 " Replays contents of plot buffer to current device/file. \n"
17388 "\n"
17389 " Redacted form: plreplot()\n"
17390 "\n"
17391 " This function is used in example 1,20. \n"
17392 "\n"
17393 "\n"
17394 "\n"
17395 "SYNOPSIS:\n"
17396 "\n"
17397 "plreplot()\n"
17398 "\n"
17399 ""},
17400 { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
17401 "Convert RGB color to HLS \n"
17402 "\n"
17403 "DESCRIPTION:\n"
17404 "\n"
17405 " Convert RGB color coordinates to HLS \n"
17406 "\n"
17407 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
17408 " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
17409 "\n"
17410 "\n"
17411 " This function is used in example 2. \n"
17412 "\n"
17413 "\n"
17414 "\n"
17415 "SYNOPSIS:\n"
17416 "\n"
17417 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
17418 "\n"
17419 "ARGUMENTS:\n"
17420 "\n"
17421 " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
17422 "\n"
17423 " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
17424 "\n"
17425 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
17426 "\n"
17427 " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
17428 " cone (0.0-360.0) \n"
17429 "\n"
17430 " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
17431 " fraction of the axis of the colour cone (0.0-1.0) \n"
17432 "\n"
17433 " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
17434 " fraction of the radius of the colour cone (0.0-1.0) \n"
17435 "\n"
17436 ""},
17437 { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
17438 "Set character size \n"
17439 "\n"
17440 "DESCRIPTION:\n"
17441 "\n"
17442 " This sets up the size of all subsequent characters drawn. The actual\n"
17443 " height of a character is the product of the default character size and\n"
17444 " a scaling factor. \n"
17445 "\n"
17446 " Redacted form: plschr(def, scale)\n"
17447 "\n"
17448 " This function is used in example 2,13,23,24. \n"
17449 "\n"
17450 "\n"
17451 "\n"
17452 "SYNOPSIS:\n"
17453 "\n"
17454 "plschr(def, scale)\n"
17455 "\n"
17456 "ARGUMENTS:\n"
17457 "\n"
17458 " def (PLFLT, input) : The default height of a character in\n"
17459 " millimeters, should be set to zero if the default height is to\n"
17460 " remain unchanged. \n"
17461 "\n"
17462 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
17463 " actual character height. \n"
17464 "\n"
17465 ""},
17466 { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
17467 "Set color map0 colors by 8-bit RGB values \n"
17468 "\n"
17469 "DESCRIPTION:\n"
17470 "\n"
17471 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
17472 " documentation). This sets the entire color map -- only as many colors\n"
17473 " as specified will be allocated. \n"
17474 "\n"
17475 " Redacted form: plscmap0(r, g, b, ncol0)\n"
17476 "\n"
17477 " This function is used in examples 2,24. \n"
17478 "\n"
17479 "\n"
17480 "\n"
17481 "SYNOPSIS:\n"
17482 "\n"
17483 "plscmap0(r, g, b, ncol0)\n"
17484 "\n"
17485 "ARGUMENTS:\n"
17486 "\n"
17487 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17488 " integers (0-255) representing the degree of red in the color. \n"
17489 "\n"
17490 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17491 " integers (0-255) representing the degree of green in the color. \n"
17492 "\n"
17493 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17494 " integers (0-255) representing the degree of blue in the color. \n"
17495 "\n"
17496 " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
17497 "\n"
17498 ""},
17499 { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
17500 "Set color map0 colors by 8-bit RGB values and double alpha value. \n"
17501 "\n"
17502 "DESCRIPTION:\n"
17503 "\n"
17504 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
17505 " documentation) and floating point alpha value. This sets the entire\n"
17506 " color map -- only as many colors as specified will be allocated. \n"
17507 "\n"
17508 " This function is used in examples 30. \n"
17509 "\n"
17510 "\n"
17511 "\n"
17512 "SYNOPSIS:\n"
17513 "\n"
17514 "plscmap0a(r, g, b, a, ncol0)\n"
17515 "\n"
17516 "ARGUMENTS:\n"
17517 "\n"
17518 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17519 " integers (0-255) representing the degree of red in the color. \n"
17520 "\n"
17521 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17522 " integers (0-255) representing the degree of green in the color. \n"
17523 "\n"
17524 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17525 " integers (0-255) representing the degree of blue in the color. \n"
17526 "\n"
17527 " a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n"
17528 " - 1.0) representing the transparency of the color. \n"
17529 "\n"
17530 " ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n"
17531 " arrays. \n"
17532 "\n"
17533 ""},
17534 { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
17535 "Set number of colors in color map0 \n"
17536 "\n"
17537 "DESCRIPTION:\n"
17538 "\n"
17539 " Set number of colors in color map0 (see the PLplot documentation).\n"
17540 " Allocate (or reallocate) color map0, and fill with default values for\n"
17541 " those colors not previously allocated. The first 16 default colors are\n"
17542 " given in the plcol0 documentation. For larger indices the default\n"
17543 " color is red. \n"
17544 "\n"
17545 " The drivers are not guaranteed to support more than 16 colors. \n"
17546 "\n"
17547 " Redacted form: plscmap0n(ncol0)\n"
17548 "\n"
17549 " This function is used in examples 15,16,24. \n"
17550 "\n"
17551 "\n"
17552 "\n"
17553 "SYNOPSIS:\n"
17554 "\n"
17555 "plscmap0n(ncol0)\n"
17556 "\n"
17557 "ARGUMENTS:\n"
17558 "\n"
17559 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
17560 " the map0 palette. If this number is zero or less, then the value\n"
17561 " from the previous call to plscmap0n is used and if there is no\n"
17562 " previous call, then a default value is used. \n"
17563 "\n"
17564 ""},
17565 { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
17566 "Set color map1 colors using 8-bit RGB values \n"
17567 "\n"
17568 "DESCRIPTION:\n"
17569 "\n"
17570 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
17571 " documentation). This also sets the number of colors. \n"
17572 "\n"
17573 " Redacted form: plscmap1(r, g, b, ncol1)\n"
17574 "\n"
17575 " This function is used in example 31. \n"
17576 "\n"
17577 "\n"
17578 "\n"
17579 "SYNOPSIS:\n"
17580 "\n"
17581 "plscmap1(r, g, b, ncol1)\n"
17582 "\n"
17583 "ARGUMENTS:\n"
17584 "\n"
17585 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17586 " integers (0-255) representing the degree of red in the color. \n"
17587 "\n"
17588 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17589 " integers (0-255) representing the degree of green in the color. \n"
17590 "\n"
17591 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17592 " integers (0-255) representing the degree of blue in the color. \n"
17593 "\n"
17594 " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
17595 "\n"
17596 ""},
17597 { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
17598 "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
17599 "\n"
17600 "DESCRIPTION:\n"
17601 "\n"
17602 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
17603 " documentation) and double alpha values. This also sets the number of\n"
17604 " colors.\n"
17605 "\n"
17606 " This function is used in example 31. \n"
17607 "\n"
17608 "\n"
17609 "\n"
17610 "SYNOPSIS:\n"
17611 "\n"
17612 "plscmap1a(r, g, b, a, ncol1)\n"
17613 "\n"
17614 "ARGUMENTS:\n"
17615 "\n"
17616 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17617 " integers (0-255) representing the degree of red in the color. \n"
17618 "\n"
17619 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17620 " integers (0-255) representing the degree of green in the color. \n"
17621 "\n"
17622 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
17623 " integers (0-255) representing the degree of blue in the color. \n"
17624 "\n"
17625 " a (PLFLT *, input) : Pointer to array with set of double values\n"
17626 " (0.0-1.0) representing the alpha value of the color. \n"
17627 "\n"
17628 " ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n"
17629 " arrays. \n"
17630 "\n"
17631 ""},
17632 { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
17633 "Set color map1 colors using a piece-wise linear relationship \n"
17634 "\n"
17635 "DESCRIPTION:\n"
17636 "\n"
17637 " Set color map1 colors using a piece-wise linear relationship between\n"
17638 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
17639 " color space (see the PLplot documentation). May be called at any\n"
17640 " time. \n"
17641 "\n"
17642 " The idea here is to specify a number of control points that define the\n"
17643 " mapping between palette 1 input positions (intensities) and HLS (or\n"
17644 " RGB). Between these points, linear interpolation is used which gives\n"
17645 " a smooth variation of color with input position. Any number of\n"
17646 " control points may be specified, located at arbitrary positions,\n"
17647 " although typically 2 - 4 are enough. Another way of stating this is\n"
17648 " that we are traversing a given number of lines through HLS (or RGB)\n"
17649 " space as we move through color map1 entries. The control points at\n"
17650 " the minimum and maximum position (0 and 1) must always be specified. \n"
17651 " By adding more control points you can get more variation. One good\n"
17652 " technique for plotting functions that vary about some expected average\n"
17653 " is to use an additional 2 control points in the center (position ~=\n"
17654 " 0.5) that are the same lightness as the background (typically white\n"
17655 " for paper output, black for crt), and same hue as the boundary control\n"
17656 " points. This allows the highs and lows to be very easily\n"
17657 " distinguished. \n"
17658 "\n"
17659 " Each control point must specify the position in color map1 as well as\n"
17660 " three coordinates in HLS or RGB space. The first point must\n"
17661 " correspond to position = 0, and the last to position = 1. \n"
17662 "\n"
17663 " The hue is interpolated around the \"front\" of the color wheel\n"
17664 " (red<->green<->blue<->red) unless the \"rev\" flag is set to true, in\n"
17665 " which case interpolation (between the i and i + 1 control point for\n"
17666 " rev[i]) proceeds around the back (reverse) side. Specifying rev=NULL\n"
17667 " is equivalent to setting rev[]= false for every control point. \n"
17668 "\n"
17669 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
17670 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
17671 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
17672 "\n"
17673 " Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3, rev)\n"
17674 "\n"
17675 " This function is used in examples 8,11,12,15,20,21. \n"
17676 "\n"
17677 "\n"
17678 "\n"
17679 "SYNOPSIS:\n"
17680 "\n"
17681 "plscmap1l(itype, npts, pos, coord1, coord2, coord3, rev)\n"
17682 "\n"
17683 "ARGUMENTS:\n"
17684 "\n"
17685 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
17686 "\n"
17687 " npts (PLINT, input) : number of control points \n"
17688 "\n"
17689 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
17690 " and 1.0, in ascending order) \n"
17691 "\n"
17692 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
17693 " control point \n"
17694 "\n"
17695 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
17696 " control point \n"
17697 "\n"
17698 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
17699 " control point \n"
17700 "\n"
17701 " rev (PLBOOL: *, input) : reverse flag for each control point.\n"
17702 " (rev[i] refers to the interpolation interval between the i and i +\n"
17703 " 1 control points). \n"
17704 "\n"
17705 ""},
17706 { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
17707 "Set color map1 colors using a piece-wise linear relationship \n"
17708 "\n"
17709 "DESCRIPTION:\n"
17710 "\n"
17711 " This is a version of plscmap1l that supports alpha transparency. It\n"
17712 " sets color map1 colors using a piece-wise linear relationship between\n"
17713 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
17714 " color space (see the PLplot documentation) with alpha value (0.0 -\n"
17715 " 1.0). It may be called at any time. \n"
17716 "\n"
17717 " This function is used in example 30. \n"
17718 "\n"
17719 "\n"
17720 "\n"
17721 "SYNOPSIS:\n"
17722 "\n"
17723 "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, rev)\n"
17724 "\n"
17725 "ARGUMENTS:\n"
17726 "\n"
17727 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
17728 "\n"
17729 " npts (PLINT, input) : number of control points \n"
17730 "\n"
17731 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
17732 " and 1.0, in ascending order) \n"
17733 "\n"
17734 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
17735 " control point \n"
17736 "\n"
17737 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
17738 " control point \n"
17739 "\n"
17740 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
17741 " control point \n"
17742 "\n"
17743 " coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n"
17744 " each control point \n"
17745 "\n"
17746 " rev (PLBOOL: *, input) : reverse flag for each control point.\n"
17747 " (rev[i] refers to the interpolation interval between the i and i +\n"
17748 " 1 control points). \n"
17749 "\n"
17750 ""},
17751 { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
17752 "Set number of colors in color map1 \n"
17753 "\n"
17754 "DESCRIPTION:\n"
17755 "\n"
17756 " Set number of colors in color map1, (re-)allocate color map1, and set\n"
17757 " default values if this is the first allocation (see the PLplot\n"
17758 " documentation). \n"
17759 "\n"
17760 " Redacted form: plscmap1n(ncol1)\n"
17761 "\n"
17762 " This function is used in examples 8,11,20,21. \n"
17763 "\n"
17764 "\n"
17765 "\n"
17766 "SYNOPSIS:\n"
17767 "\n"
17768 "plscmap1n(ncol1)\n"
17769 "\n"
17770 "ARGUMENTS:\n"
17771 "\n"
17772 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
17773 " the map1 palette. If this number is zero or less, then the value\n"
17774 " from the previous call to plscmap1n is used and if there is no\n"
17775 " previous call, then a default value is used. \n"
17776 "\n"
17777 ""},
17778 { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
17779 "Set a given color from color map0 by 8 bit RGB value \n"
17780 "\n"
17781 "ESCRIPTION:\n"
17782 "\n"
17783 " Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
17784 " documentation). Overwrites the previous color value for the given\n"
17785 " index and, thus, does not result in any additional allocation of space\n"
17786 " for colors. \n"
17787 "\n"
17788 " Redacted form: plscol0(icol0, r, g, b)\n"
17789 "\n"
17790 " This function is not used in any examples. \n"
17791 "\n"
17792 "\n"
17793 "\n"
17794 "YNOPSIS:\n"
17795 "\n"
17796 "lscol0(icol0, r, g, b)\n"
17797 "\n"
17798 "RGUMENTS:\n"
17799 "\n"
17800 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
17801 " number of colors (which is set by default, by plscmap0n, or even\n"
17802 " by plscmap0). \n"
17803 "\n"
17804 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17805 " degree of red in the color. \n"
17806 "\n"
17807 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17808 " degree of green in the color. \n"
17809 "\n"
17810 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17811 " degree of blue in the color. \n"
17812 "\n"
17813 ""},
17814 { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
17815 "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
17816 "\n"
17817 "ESCRIPTION:\n"
17818 "\n"
17819 " Set a given color by 8-bit RGB value and double alpha value for color \n"
17820 " map0 (see the PLplot documentation). Overwrites the previous color\n"
17821 " value for the given index and, thus, does not result in any\n"
17822 " additional allocation of space for colors. \n"
17823 "\n"
17824 " This function is used in example 30. \n"
17825 "\n"
17826 "\n"
17827 "\n"
17828 "YNOPSIS:\n"
17829 "\n"
17830 "lscol0a(icol0, r, g, b, a)\n"
17831 "\n"
17832 "RGUMENTS:\n"
17833 "\n"
17834 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
17835 " number of colors (which is set by default, by plscmap0n, or even\n"
17836 " by plscmap0). \n"
17837 "\n"
17838 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17839 " degree of red in the color. \n"
17840 "\n"
17841 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17842 " degree of green in the color. \n"
17843 "\n"
17844 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17845 " degree of blue in the color. \n"
17846 "\n"
17847 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
17848 " value of the color. \n"
17849 "\n"
17850 ""},
17851 { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
17852 "Set the background color by 8-bit RGB value \n"
17853 "\n"
17854 "DESCRIPTION:\n"
17855 "\n"
17856 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
17857 " (see the PLplot documentation). \n"
17858 "\n"
17859 " Redacted form: plscolbg(r, g, b)\n"
17860 "\n"
17861 " This function is used in examples 15,31. \n"
17862 "\n"
17863 "\n"
17864 "\n"
17865 "SYNOPSIS:\n"
17866 "\n"
17867 "plscolbg(r, g, b)\n"
17868 "\n"
17869 "ARGUMENTS:\n"
17870 "\n"
17871 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17872 " degree of red in the color. \n"
17873 "\n"
17874 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17875 " degree of green in the color. \n"
17876 "\n"
17877 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17878 " degree of blue in the color. \n"
17879 "\n"
17880 ""},
17881 { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
17882 "Set the background color by 8-bit RGB value and double alpha value. \n"
17883 "\n"
17884 "DESCRIPTION:\n"
17885 "\n"
17886 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
17887 " (see the PLplot documentation) and double alpha value. \n"
17888 "\n"
17889 " This function is used in example 31. \n"
17890 "\n"
17891 "\n"
17892 "\n"
17893 "SYNOPSIS:\n"
17894 "\n"
17895 "plscolbga(r, g, b, a)\n"
17896 "\n"
17897 "ARGUMENTS:\n"
17898 "\n"
17899 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17900 " degree of red in the color. \n"
17901 "\n"
17902 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17903 " degree of green in the color. \n"
17904 "\n"
17905 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
17906 " degree of blue in the color. \n"
17907 "\n"
17908 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
17909 " value of the color. \n"
17910 "\n"
17911 ""},
17912 { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
17913 "Used to globally turn color output on/off \n"
17914 "\n"
17915 "DESCRIPTION:\n"
17916 "\n"
17917 " Used to globally turn color output on/off for those drivers/devices\n"
17918 " that support it. \n"
17919 "\n"
17920 " Redacted form: plscolor(color)\n"
17921 "\n"
17922 " This function is used in example 31. \n"
17923 "\n"
17924 "\n"
17925 "\n"
17926 "SYNOPSIS:\n"
17927 "\n"
17928 "plscolor(color)\n"
17929 "\n"
17930 "ARGUMENTS:\n"
17931 "\n"
17932 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
17933 " turned off. If non-zero, color is turned on. \n"
17934 "\n"
17935 ""},
17936 { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
17937 "Set device-compression level \n"
17938 "\n"
17939 "DESCRIPTION:\n"
17940 "\n"
17941 " Set device-compression level. Only used for drivers that provide\n"
17942 " compression. This function, if used, should be invoked before a call\n"
17943 " to plinit. \n"
17944 "\n"
17945 " Redacted form: plscompression(compression)\n"
17946 "\n"
17947 " This function is used in example 31. \n"
17948 "\n"
17949 "\n"
17950 "\n"
17951 "SYNOPSIS:\n"
17952 "\n"
17953 "plscompression(compression)\n"
17954 "\n"
17955 "ARGUMENTS:\n"
17956 "\n"
17957 " compression (PLINT, input) : The desired compression level. This is\n"
17958 " a device-dependent value. Currently only the jpeg and png devices\n"
17959 " use these values. For jpeg value is the jpeg quality which should\n"
17960 " normally be in the range 0-95. Higher values denote higher quality\n"
17961 " and hence larger image sizes. For png values are in the range -1\n"
17962 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
17963 " A value of -1 denotes the default zlib compression level. Values\n"
17964 " in the range 10-99 are divided by 10 and then used as the zlib\n"
17965 " compression level. Higher compression levels correspond to greater\n"
17966 " compression and small file sizes at the expense of more\n"
17967 " computation. \n"
17968 "\n"
17969 ""},
17970 { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
17971 "Set the device (keyword) name \n"
17972 "\n"
17973 "DESCRIPTION:\n"
17974 "\n"
17975 " Set the device (keyword) name. \n"
17976 "\n"
17977 " Redacted form: plsdev(devname)\n"
17978 "\n"
17979 " This function is used in examples 1,14,20. \n"
17980 "\n"
17981 "\n"
17982 "\n"
17983 "SYNOPSIS:\n"
17984 "\n"
17985 "plsdev(devname)\n"
17986 "\n"
17987 "ARGUMENTS:\n"
17988 "\n"
17989 " devname (const char *, input) : Pointer to device (keyword) name\n"
17990 " string. \n"
17991 "\n"
17992 ""},
17993 { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
17994 "Set parameters that define current device-space window \n"
17995 "\n"
17996 "DESCRIPTION:\n"
17997 "\n"
17998 " Set relative margin width, aspect ratio, and relative justification\n"
17999 " that define current device-space window. If you want to just use the\n"
18000 " previous value for any of these, just pass in the magic value\n"
18001 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
18002 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
18003 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
18004 " to a device-specific value. \n"
18005 "\n"
18006 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
18007 "\n"
18008 " This function is used in example 31. \n"
18009 "\n"
18010 "\n"
18011 "\n"
18012 "SYNOPSIS:\n"
18013 "\n"
18014 "plsdidev(mar, aspect, jx, jy)\n"
18015 "\n"
18016 "ARGUMENTS:\n"
18017 "\n"
18018 " mar (PLFLT, input) : Relative margin width. \n"
18019 "\n"
18020 " aspect (PLFLT, input) : Aspect ratio. \n"
18021 "\n"
18022 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
18023 " the range -0.5 to 0.5. \n"
18024 "\n"
18025 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
18026 " the range -0.5 to 0.5. \n"
18027 "\n"
18028 ""},
18029 { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
18030 "Set up transformation from metafile coordinates \n"
18031 "\n"
18032 "DESCRIPTION:\n"
18033 "\n"
18034 " Set up transformation from metafile coordinates. The size of the plot\n"
18035 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
18036 " general-purpose facility just yet (not sure why the user would need\n"
18037 " it, for one). \n"
18038 "\n"
18039 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
18040 " dimypmm)\n"
18041 "\n"
18042 " This function is not used in any examples. \n"
18043 "\n"
18044 "\n"
18045 "\n"
18046 "SYNOPSIS:\n"
18047 "\n"
18048 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
18049 "\n"
18050 "ARGUMENTS:\n"
18051 "\n"
18052 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
18053 "\n"
18054 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
18055 "\n"
18056 " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
18057 "\n"
18058 " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
18059 "\n"
18060 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18061 "\n"
18062 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18063 "\n"
18064 ""},
18065 { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
18066 "Set plot orientation \n"
18067 "\n"
18068 "DESCRIPTION:\n"
18069 "\n"
18070 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
18071 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
18072 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
18073 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
18074 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
18075 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
18076 " not called the default value of rot is 0. \n"
18077 "\n"
18078 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
18079 " probably want to change the aspect ratio to a value suitable for the\n"
18080 " plot orientation using a call to plsdidev or the command-line options\n"
18081 " -a or -freeaspect. For more documentation of those options see the\n"
18082 " PLplot documentation. Such command-line options can be set internally\n"
18083 " using plsetopt or set directly using the command line and parsed using\n"
18084 " a call to plparseopts. \n"
18085 "\n"
18086 " Redacted form: plsdiori(rot)\n"
18087 "\n"
18088 " This function is not used in any examples. \n"
18089 "\n"
18090 "\n"
18091 "\n"
18092 "SYNOPSIS:\n"
18093 "\n"
18094 "plsdiori(rot)\n"
18095 "\n"
18096 "ARGUMENTS:\n"
18097 "\n"
18098 " rot (PLFLT, input) : Plot orientation parameter. \n"
18099 "\n"
18100 ""},
18101 { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
18102 "Set parameters that define current plot-space window \n"
18103 "\n"
18104 "DESCRIPTION:\n"
18105 "\n"
18106 " Set relative minima and maxima that define the current plot-space\n"
18107 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
18108 " xmax, and ymax are 0., 0., 1., and 1. \n"
18109 "\n"
18110 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
18111 "\n"
18112 " This function is used in example 31. \n"
18113 "\n"
18114 "\n"
18115 "\n"
18116 "SYNOPSIS:\n"
18117 "\n"
18118 "plsdiplt(xmin, ymin, xmax, ymax)\n"
18119 "\n"
18120 "ARGUMENTS:\n"
18121 "\n"
18122 " xmin (PLFLT, input) : Relative minimum in x. \n"
18123 "\n"
18124 " ymin (PLFLT, input) : Relative minimum in y. \n"
18125 "\n"
18126 " xmax (PLFLT, input) : Relative maximum in x. \n"
18127 "\n"
18128 " ymax (PLFLT, input) : Relative maximum in y. \n"
18129 "\n"
18130 ""},
18131 { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
18132 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
18133 "\n"
18134 "DESCRIPTION:\n"
18135 "\n"
18136 " Set relative minima and maxima incrementally (zoom mode) that define\n"
18137 " the current plot-space window. This function has the same effect as\n"
18138 " plsdiplt if that function has not been previously called. Otherwise,\n"
18139 " this function implements zoom mode using the transformation min_used =\n"
18140 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
18141 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
18142 " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
18143 "\n"
18144 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
18145 "\n"
18146 " This function is used in example 31. \n"
18147 "\n"
18148 "\n"
18149 "\n"
18150 "SYNOPSIS:\n"
18151 "\n"
18152 "plsdiplz(xmin, ymin, xmax, ymax)\n"
18153 "\n"
18154 "ARGUMENTS:\n"
18155 "\n"
18156 " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
18157 "\n"
18158 " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
18159 "\n"
18160 " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
18161 "\n"
18162 " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
18163 "\n"
18164 ""},
18165 { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
18166 "Set seed for internal random number generator. \n"
18167 "\n"
18168 "DESCRIPTION:\n"
18169 "\n"
18170 " Set the seed for the internal random number generator. See plrandd for\n"
18171 " further details. \n"
18172 "\n"
18173 " Redacted form: plseed(seed)\n"
18174 "\n"
18175 " This function is used in example 21. \n"
18176 "\n"
18177 "\n"
18178 "\n"
18179 "SYNOPSIS:\n"
18180 "\n"
18181 "plseed(seed)\n"
18182 "\n"
18183 "ARGUMENTS:\n"
18184 "\n"
18185 " seed (unsigned int, input) : Seed for random number generator. \n"
18186 "\n"
18187 ""},
18188 { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
18189 "Set the escape character for text strings \n"
18190 "\n"
18191 "DESCRIPTION:\n"
18192 "\n"
18193 " Set the escape character for text strings. From C (in contrast to\n"
18194 " Fortran 77, see plsescfortran77) you pass esc as a character. Only\n"
18195 " selected characters are allowed to prevent the user from shooting\n"
18196 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
18197 " with C's use of backslash as a character escape). Here are the\n"
18198 " allowed escape characters and their corresponding decimal ASCII\n"
18199 " values: !, ASCII 33 \n"
18200 " #, ASCII 35 \n"
18201 " $, ASCII 36 \n"
18202 " %, ASCII 37 \n"
18203 " &, ASCII 38 \n"
18204 " *, ASCII 42 \n"
18205 " @, ASCII 64 \n"
18206 " ^, ASCII 94 \n"
18207 " ~, ASCII 126 \n"
18208 "\n"
18209 "\n"
18210 " Redacted form: General: plsesc(esc)\n"
18211 " Perl/PDL: Not available? \n"
18212 "\n"
18213 "\n"
18214 " This function is used in example 29. \n"
18215 "\n"
18216 "\n"
18217 "\n"
18218 "SYNOPSIS:\n"
18219 "\n"
18220 "plsesc(esc)\n"
18221 "\n"
18222 "ARGUMENTS:\n"
18223 "\n"
18224 " esc (char, input) : Escape character. \n"
18225 "\n"
18226 ""},
18227 { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
18228 "Set any command-line option \n"
18229 "\n"
18230 "DESCRIPTION:\n"
18231 "\n"
18232 " Set any command-line option internally from a program before it\n"
18233 " invokes plinit. opt is the name of the command-line option and optarg\n"
18234 " is the corresponding command-line option argument. \n"
18235 "\n"
18236 " This function returns 0 on success. \n"
18237 "\n"
18238 " Redacted form: plsetopt(opt, optarg)\n"
18239 "\n"
18240 " This function is used in example 14. \n"
18241 "\n"
18242 "\n"
18243 "\n"
18244 "SYNOPSIS:\n"
18245 "\n"
18246 "int plsetopt(opt, optarg)\n"
18247 "\n"
18248 "ARGUMENTS:\n"
18249 "\n"
18250 " opt (const char *, input) : Pointer to string containing the\n"
18251 " command-line option. \n"
18252 "\n"
18253 " optarg (const char *, input) : Pointer to string containing the\n"
18254 " argument of the command-line option. \n"
18255 "\n"
18256 ""},
18257 { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
18258 "Set family file parameters \n"
18259 "\n"
18260 "DESCRIPTION:\n"
18261 "\n"
18262 " Sets variables dealing with output file familying. Does nothing if\n"
18263 " familying not supported by the driver. This routine, if used, must be\n"
18264 " called before initializing PLplot. See the PLplot documentation for\n"
18265 " more information. \n"
18266 "\n"
18267 " Redacted form: plsfam(fam, num, bmax)\n"
18268 "\n"
18269 " This function is used in examples 14,31. \n"
18270 "\n"
18271 "\n"
18272 "\n"
18273 "SYNOPSIS:\n"
18274 "\n"
18275 "plsfam(fam, num, bmax)\n"
18276 "\n"
18277 "ARGUMENTS:\n"
18278 "\n"
18279 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
18280 " is enabled. \n"
18281 "\n"
18282 " num (PLINT, input) : Current family file number. \n"
18283 "\n"
18284 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
18285 " file. \n"
18286 "\n"
18287 ""},
18288 { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
18289 "Set FCI (font characterization integer) \n"
18290 "\n"
18291 "DESCRIPTION:\n"
18292 "\n"
18293 " Sets font characteristics to be used at the start of the next string\n"
18294 " using the FCI approach. See the PLplot documentation for more\n"
18295 " information. \n"
18296 "\n"
18297 " Redacted form: General: plsfci(fci)\n"
18298 " Perl/PDL: Not available? \n"
18299 "\n"
18300 "\n"
18301 " This function is used in example 23. \n"
18302 "\n"
18303 "\n"
18304 "\n"
18305 "SYNOPSIS:\n"
18306 "\n"
18307 "plsfci(fci)\n"
18308 "\n"
18309 "ARGUMENTS:\n"
18310 "\n"
18311 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
18312 " of FCI. \n"
18313 "\n"
18314 ""},
18315 { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
18316 "Set output file name \n"
18317 "\n"
18318 "DESCRIPTION:\n"
18319 "\n"
18320 " Sets the current output file name, if applicable. If the file name\n"
18321 " has not been specified and is required by the driver, the user will be\n"
18322 " prompted for it. If using the X-windows output driver, this sets the\n"
18323 " display name. This routine, if used, must be called before\n"
18324 " initializing PLplot. \n"
18325 "\n"
18326 " Redacted form: plsfnam(fnam)\n"
18327 "\n"
18328 " This function is used in examples 1,20. \n"
18329 "\n"
18330 "\n"
18331 "\n"
18332 "SYNOPSIS:\n"
18333 "\n"
18334 "plsfnam(fnam)\n"
18335 "\n"
18336 "ARGUMENTS:\n"
18337 "\n"
18338 " fnam (const char *, input) : Pointer to file name string. \n"
18339 "\n"
18340 ""},
18341 { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
18342 "Set family, style and weight of the current font \n"
18343 "\n"
18344 "DESCRIPTION:\n"
18345 "\n"
18346 " Sets the current font. See the PLplot documentation for more\n"
18347 " information on font selection. \n"
18348 "\n"
18349 " Redacted form: plsfont(family, style, weight)\n"
18350 "\n"
18351 " This function is used in example 23. \n"
18352 "\n"
18353 "\n"
18354 "\n"
18355 "SYNOPSIS:\n"
18356 "\n"
18357 "plsfont(family, style, weight)\n"
18358 "\n"
18359 "ARGUMENTS:\n"
18360 "\n"
18361 " family (PLINT, input) : Font family to select for the current font.\n"
18362 " The available values are given by the PL_FCI_* constants in\n"
18363 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
18364 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
18365 " signifies that the font family should not be altered. \n"
18366 "\n"
18367 " style (PLINT, input) : Font style to select for the current font.\n"
18368 " The available values are given by the PL_FCI_* constants in\n"
18369 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
18370 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
18371 " should not be altered. \n"
18372 "\n"
18373 " weight (PLINT, input) : Font weight to select for the current font.\n"
18374 " The available values are given by the PL_FCI_* constants in\n"
18375 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
18376 " negative value signifies that the font weight should not be\n"
18377 " altered. \n"
18378 "\n"
18379 ""},
18380 { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
18381 "Shade regions on the basis of value \n"
18382 "\n"
18383 "DESCRIPTION:\n"
18384 "\n"
18385 " Shade regions on the basis of value. This is the high-level routine\n"
18386 " for making continuous color shaded plots with cmap1 while plshade (or\n"
18387 " plshade1) are used for individual shaded regions using either cmap0 or\n"
18388 " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
18389 " function. See the following discussion of the arguments and the PLplot\n"
18390 " documentation for more information. \n"
18391 "\n"
18392 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
18393 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
18394 " pltr_data)\n"
18395 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
18396 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
18397 " pltr_data)\n"
18398 "\n"
18399 "\n"
18400 " This function is used in examples 16,21. \n"
18401 "\n"
18402 "\n"
18403 "\n"
18404 "SYNOPSIS:\n"
18405 "\n"
18406 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
18407 "\n"
18408 "ARGUMENTS:\n"
18409 "\n"
18410 " a (PLFLT **, input) : Contains ** pointer to array to be plotted.\n"
18411 " The array must have been declared as PLFLT a[nx][ny]. \n"
18412 "\n"
18413 " nx (PLINT, input) : First dimension of array \"a\". \n"
18414 "\n"
18415 " ny (PLINT, input) : Second dimension of array \"a\". \n"
18416 "\n"
18417 " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
18418 " specifying regions excluded from the shading plot. This function\n"
18419 " accepts x and y coordinates as input arguments and must return 0\n"
18420 " if the point is in the excluded region or 1 otherwise. This\n"
18421 " argument can be NULL if all the values are valid. \n"
18422 "\n"
18423 " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
18424 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18425 " at (xmax,ymin) and so on. \n"
18426 "\n"
18427 " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
18428 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18429 " at (xmax,ymin) and so on. \n"
18430 "\n"
18431 " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
18432 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18433 " at (xmax,ymin) and so on. \n"
18434 "\n"
18435 " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
18436 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18437 " at (xmax,ymin) and so on. \n"
18438 "\n"
18439 " clevel (PLFLT *, input) : Pointer to array containing the data\n"
18440 " levels corresponding to the edges of each shaded region that will\n"
18441 " be plotted by this function. To work properly the levels should\n"
18442 " be monotonic. \n"
18443 "\n"
18444 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
18445 " of shade edge values in clevel). \n"
18446 "\n"
18447 " fill_width (PLINT, input) : Defines width used by the fill pattern. \n"
18448 "\n"
18449 " cont_color (PLINT, input) : Defines pen color used for contours\n"
18450 " defining edges of shaded regions. The pen color is only temporary\n"
18451 " set for the contour drawing. Set this value to zero or less if no\n"
18452 " shade edge contours are wanted. \n"
18453 "\n"
18454 " cont_width (PLINT, input) : Defines pen width used for contours\n"
18455 " defining edges of shaded regions. This value may not be honored\n"
18456 " by all drivers. The pen width is only temporary set for the\n"
18457 " contour drawing. Set this value to zero or less if no shade edge\n"
18458 " contours are wanted. \n"
18459 "\n"
18460 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : Routine used to\n"
18461 " fill the region. Use plfill. Future version of PLplot may have\n"
18462 " other fill routines. \n"
18463 "\n"
18464 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
18465 " map to rectangles after coordinate transformation with pltrl. \n"
18466 " Otherwise, set rectangular to false. If rectangular is set to\n"
18467 " true, plshade tries to save time by filling large rectangles. \n"
18468 " This optimization fails if the coordinate transformation distorts\n"
18469 " the shape of rectangles. For example a plot in polar coordinates\n"
18470 " has to have rectangular set to false. \n"
18471 "\n"
18472 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
18473 " Pointer to function that defines transformation between indices\n"
18474 " in array z and the world coordinates (C only). Transformation\n"
18475 " functions are provided in the PLplot library: pltr0 for identity\n"
18476 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
18477 " defined by one- and two-dimensional arrays. In addition,\n"
18478 " user-supplied routines for the transformation can be used as well.\n"
18479 " Examples of all of these approaches are given in the PLplot\n"
18480 " documentation. The transformation function should have the form\n"
18481 " given by any of pltr0, pltr1, or pltr2. \n"
18482 "\n"
18483 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
18484 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
18485 " externally supplied. \n"
18486 "\n"
18487 ""},
18488 { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
18489 "Shade individual region on the basis of value \n"
18490 "\n"
18491 "ESCRIPTION:\n"
18492 "\n"
18493 " Shade individual region on the basis of value. Use plshades if you\n"
18494 " want to shade a number of regions using continuous colors. plshade is\n"
18495 " identical to plshade1 except for the type of the first parameter. See\n"
18496 " plshade1 for further discussion. \n"
18497 "\n"
18498 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
18499 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
18500 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
18501 " Perl/PDL: Not available? \n"
18502 "\n"
18503 "\n"
18504 " This function is used in example 15. \n"
18505 "\n"
18506 "\n"
18507 "\n"
18508 "YNOPSIS:\n"
18509 "\n"
18510 "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"
18511 "\n"
18512 "RGUMENTS:\n"
18513 "\n"
18514 " a (PLFLT **, input) : \n"
18515 "\n"
18516 " nx (PLINT, input) : \n"
18517 "\n"
18518 " ny (PLINT, input) : \n"
18519 "\n"
18520 " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
18521 "\n"
18522 " xmin (PLFLT, input) : \n"
18523 "\n"
18524 " xmax (PLFLT, input) : \n"
18525 "\n"
18526 " ymin (PLFLT, input) : \n"
18527 "\n"
18528 " ymax (PLFLT, input) : \n"
18529 "\n"
18530 " shade_min (PLFLT, input) : \n"
18531 "\n"
18532 " shade_max (PLFLT, input) : \n"
18533 "\n"
18534 " sh_cmap (PLINT, input) : \n"
18535 "\n"
18536 " sh_color (PLFLT, input) : \n"
18537 "\n"
18538 " sh_width (PLINT, input) : \n"
18539 "\n"
18540 " min_color (PLINT, input) : \n"
18541 "\n"
18542 " min_width (PLINT, input) : \n"
18543 "\n"
18544 " max_color (PLINT, input) : \n"
18545 "\n"
18546 " max_width (PLINT, input) : \n"
18547 "\n"
18548 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : \n"
18549 "\n"
18550 " rectangular (PLBOOL, input) : \n"
18551 "\n"
18552 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
18553 "\n"
18554 " pltr_data (PLPointer, input) : \n"
18555 "\n"
18556 ""},
18557 { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
18558 "Assign a function to use for generating custom axis labels \n"
18559 "\n"
18560 "DESCRIPTION:\n"
18561 "\n"
18562 " This function allows a user to provide their own function to provide\n"
18563 " axis label text. The user function is given the numeric value for a\n"
18564 " point on an axis and returns a string label to correspond with that\n"
18565 " value. Custom axis labels can be enabled by passing appropriate\n"
18566 " arguments to plenv, plbox, plbox3 and similar functions. \n"
18567 "\n"
18568 " This function is used in example 19. \n"
18569 "\n"
18570 "\n"
18571 "\n"
18572 "SYNOPSIS:\n"
18573 "\n"
18574 "plslabelfunc(label_func, label_data)\n"
18575 "\n"
18576 "ARGUMENTS:\n"
18577 "\n"
18578 " label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n"
18579 " This is the custom label function. In order to reset to the\n"
18580 " default labeling, set this to NULL. The labeling function\n"
18581 " parameters are, in order: axis: This indicates which axis a\n"
18582 " label is being requested for. The value will be one of PL_X_AXIS,\n"
18583 " PL_Y_AXIS or PL_Z_AXIS. \n"
18584 "\n"
18585 " value: This is the value along the axis which is being labeled. \n"
18586 "\n"
18587 " label_text: The string representation of the label value. \n"
18588 "\n"
18589 " length: The maximum length in characters allowed for label_text. \n"
18590 "\n"
18591 "\n"
18592 " label_data (void *, input) : This parameter may be used to pass\n"
18593 " data to the label_func function. \n"
18594 "\n"
18595 ""},
18596 { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
18597 "Set length of major ticks \n"
18598 "\n"
18599 "DESCRIPTION:\n"
18600 "\n"
18601 " This sets up the length of the major ticks. The actual length is the\n"
18602 " product of the default length and a scaling factor as for character\n"
18603 " height. \n"
18604 "\n"
18605 " Redacted form: plsmaj(def, scale)\n"
18606 "\n"
18607 " This function is used in example 29. \n"
18608 "\n"
18609 "\n"
18610 "\n"
18611 "SYNOPSIS:\n"
18612 "\n"
18613 "plsmaj(def, scale)\n"
18614 "\n"
18615 "ARGUMENTS:\n"
18616 "\n"
18617 " def (PLFLT, input) : The default length of a major tick in\n"
18618 " millimeters, should be set to zero if the default length is to\n"
18619 " remain unchanged. \n"
18620 "\n"
18621 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18622 " actual tick length. \n"
18623 "\n"
18624 ""},
18625 { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
18626 "Set the memory area to be plotted (RGB) \n"
18627 "\n"
18628 "DESCRIPTION:\n"
18629 "\n"
18630 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
18631 " the dev member of the stream structure. Also set the number of pixels\n"
18632 " in the memory passed in \n"
18633 " plotmem, which is a block of memory \n"
18634 " maxy by \n"
18635 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
18636 "\n"
18637 " This memory will have to be freed by the user! \n"
18638 "\n"
18639 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
18640 "\n"
18641 " This function is not used in any examples. \n"
18642 "\n"
18643 "\n"
18644 "\n"
18645 "SYNOPSIS:\n"
18646 "\n"
18647 "plsmem(maxx, maxy, plotmem)\n"
18648 "\n"
18649 "ARGUMENTS:\n"
18650 "\n"
18651 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
18652 "\n"
18653 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
18654 "\n"
18655 " plotmem (void *, input) : Pointer to the beginning of the\n"
18656 " user-supplied memory area. \n"
18657 "\n"
18658 ""},
18659 { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
18660 "Set the memory area to be plotted (RGBA) \n"
18661 "\n"
18662 "DESCRIPTION:\n"
18663 "\n"
18664 " Set the memory area to be plotted (with the memcairo driver) as the\n"
18665 " dev member of the stream structure. Also set the number of pixels in\n"
18666 " the memory passed in \n"
18667 " plotmem, which is a block of memory \n"
18668 " maxy by \n"
18669 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
18670 "\n"
18671 " This memory will have to be freed by the user! \n"
18672 "\n"
18673 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
18674 "\n"
18675 " This function is not used in any examples. \n"
18676 "\n"
18677 "\n"
18678 "\n"
18679 "SYNOPSIS:\n"
18680 "\n"
18681 "plsmema(maxx, maxy, plotmem)\n"
18682 "\n"
18683 "ARGUMENTS:\n"
18684 "\n"
18685 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
18686 "\n"
18687 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
18688 "\n"
18689 " plotmem (void *, input) : Pointer to the beginning of the\n"
18690 " user-supplied memory area. \n"
18691 "\n"
18692 ""},
18693 { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
18694 "Set length of minor ticks \n"
18695 "\n"
18696 "DESCRIPTION:\n"
18697 "\n"
18698 " This sets up the length of the minor ticks and the length of the\n"
18699 " terminals on error bars. The actual length is the product of the\n"
18700 " default length and a scaling factor as for character height. \n"
18701 "\n"
18702 " Redacted form: plsmin(def, scale)\n"
18703 "\n"
18704 " This function is used in example 29. \n"
18705 "\n"
18706 "\n"
18707 "\n"
18708 "SYNOPSIS:\n"
18709 "\n"
18710 "plsmin(def, scale)\n"
18711 "\n"
18712 "ARGUMENTS:\n"
18713 "\n"
18714 " def (PLFLT, input) : The default length of a minor tick in\n"
18715 " millimeters, should be set to zero if the default length is to\n"
18716 " remain unchanged. \n"
18717 "\n"
18718 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18719 " actual tick length. \n"
18720 "\n"
18721 ""},
18722 { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
18723 "Set orientation \n"
18724 "\n"
18725 "DESCRIPTION:\n"
18726 "\n"
18727 " Set integer plot orientation parameter. This function is identical to\n"
18728 " plsdiori except for the type of the argument, and should be used in\n"
18729 " the same way. See the PLplot documentation for details. \n"
18730 "\n"
18731 " Redacted form: plsori(ori)\n"
18732 "\n"
18733 " This function is used in example 3. \n"
18734 "\n"
18735 "\n"
18736 "\n"
18737 "SYNOPSIS:\n"
18738 "\n"
18739 "plsori(ori)\n"
18740 "\n"
18741 "ARGUMENTS:\n"
18742 "\n"
18743 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
18744 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
18745 " angle. \n"
18746 "\n"
18747 ""},
18748 { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
18749 "Set page parameters \n"
18750 "\n"
18751 "DESCRIPTION:\n"
18752 "\n"
18753 " Sets the page configuration (optional). If an individual parameter is\n"
18754 " zero then that parameter value is not updated. Not all parameters are\n"
18755 " recognized by all drivers and the interpretation is device-dependent.\n"
18756 " The X-window driver uses the length and offset parameters to determine\n"
18757 " the window size and location. The length and offset values are\n"
18758 " expressed in units that are specific to the current driver. For\n"
18759 " instance: screen drivers will usually interpret them as number of\n"
18760 " pixels, whereas printer drivers will usually use mm. This routine, if\n"
18761 " used, must be called before initializing PLplot. \n"
18762 "\n"
18763 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
18764 "\n"
18765 " This function is used in example 31. \n"
18766 "\n"
18767 "\n"
18768 "\n"
18769 "SYNOPSIS:\n"
18770 "\n"
18771 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
18772 "\n"
18773 "ARGUMENTS:\n"
18774 "\n"
18775 " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
18776 "\n"
18777 " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
18778 "\n"
18779 " xleng (PLINT , input) : Page length, x. \n"
18780 "\n"
18781 " yleng (PLINT, input) : Page length, y. \n"
18782 "\n"
18783 " xoff (PLINT, input) : Page offset, x. \n"
18784 "\n"
18785 " yoff (PLINT, input) : Page offset, y. \n"
18786 "\n"
18787 ""},
18788 { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
18789 "Set the colors for color table 0 from a cmap0 file \n"
18790 "\n"
18791 "DESCRIPTION:\n"
18792 "\n"
18793 " Set the colors for color table 0 from a cmap0 file \n"
18794 "\n"
18795 " Redacted form: plspal0(filename)\n"
18796 "\n"
18797 " This function is in example 16. \n"
18798 "\n"
18799 "\n"
18800 "\n"
18801 "SYNOPSIS:\n"
18802 "\n"
18803 "plspal0(filename)\n"
18804 "\n"
18805 "ARGUMENTS:\n"
18806 "\n"
18807 " filename (const char *, input) : The name of the cmap0 file, or a\n"
18808 " empty to string to specify the default cmap0 file. \n"
18809 "\n"
18810 ""},
18811 { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
18812 "Set the colors for color table 1 from a cmap1 file \n"
18813 "\n"
18814 "DESCRIPTION:\n"
18815 "\n"
18816 " Set the colors for color table 1 from a cmap1 file \n"
18817 "\n"
18818 " Redacted form: plspal1(filename)\n"
18819 "\n"
18820 " This function is in example 16. \n"
18821 "\n"
18822 "\n"
18823 "\n"
18824 "SYNOPSIS:\n"
18825 "\n"
18826 "plspal1(filename)\n"
18827 "\n"
18828 "ARGUMENTS:\n"
18829 "\n"
18830 " filename (const char *, input) : The name of the cmap1 file, or a\n"
18831 " empty to string to specify the default cmap1 file. \n"
18832 "\n"
18833 ""},
18834 { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
18835 "Set the pause (on end-of-page) status \n"
18836 "\n"
18837 "DESCRIPTION:\n"
18838 "\n"
18839 " Set the pause (on end-of-page) status. \n"
18840 "\n"
18841 " Redacted form: plspause(pause)\n"
18842 "\n"
18843 " This function is in examples 14,20. \n"
18844 "\n"
18845 "\n"
18846 "\n"
18847 "SYNOPSIS:\n"
18848 "\n"
18849 "plspause(pause)\n"
18850 "\n"
18851 "ARGUMENTS:\n"
18852 "\n"
18853 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
18854 " end-of-page for those drivers which support this. Otherwise there\n"
18855 " is no pause. \n"
18856 "\n"
18857 ""},
18858 { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
18859 "Set current output stream \n"
18860 "\n"
18861 "DESCRIPTION:\n"
18862 "\n"
18863 " Sets the number of the current output stream. The stream number\n"
18864 " defaults to 0 unless changed by this routine. The first use of this\n"
18865 " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
18866 "\n"
18867 " Redacted form: plsstrm(strm)\n"
18868 "\n"
18869 " This function is examples 1,14,20. \n"
18870 "\n"
18871 "\n"
18872 "\n"
18873 "SYNOPSIS:\n"
18874 "\n"
18875 "plsstrm(strm)\n"
18876 "\n"
18877 "ARGUMENTS:\n"
18878 "\n"
18879 " strm (PLINT, input) : The current stream number. \n"
18880 "\n"
18881 ""},
18882 { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
18883 "Set the number of subpages in x and y \n"
18884 "\n"
18885 "DESCRIPTION:\n"
18886 "\n"
18887 " Set the number of subpages in x and y. \n"
18888 "\n"
18889 " Redacted form: plssub(nx, ny)\n"
18890 "\n"
18891 " This function is examples 1,2,14,21,25,27. \n"
18892 "\n"
18893 "\n"
18894 "\n"
18895 "SYNOPSIS:\n"
18896 "\n"
18897 "plssub(nx, ny)\n"
18898 "\n"
18899 "ARGUMENTS:\n"
18900 "\n"
18901 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
18902 " of window columns). \n"
18903 "\n"
18904 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
18905 " of window rows). \n"
18906 "\n"
18907 ""},
18908 { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
18909 "Set symbol size \n"
18910 "\n"
18911 "DESCRIPTION:\n"
18912 "\n"
18913 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
18914 " plsym. The actual height of a symbol is the product of the default\n"
18915 " symbol size and a scaling factor as for the character height. \n"
18916 "\n"
18917 " Redacted form: plssym(def, scale)\n"
18918 "\n"
18919 " This function is used in example 29. \n"
18920 "\n"
18921 "\n"
18922 "\n"
18923 "SYNOPSIS:\n"
18924 "\n"
18925 "plssym(def, scale)\n"
18926 "\n"
18927 "ARGUMENTS:\n"
18928 "\n"
18929 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
18930 " should be set to zero if the default height is to remain\n"
18931 " unchanged. \n"
18932 "\n"
18933 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18934 " actual symbol height. \n"
18935 "\n"
18936 ""},
18937 { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
18938 "Initialization \n"
18939 "\n"
18940 "DESCRIPTION:\n"
18941 "\n"
18942 " Initializing the plotting package. The program prompts for the device\n"
18943 " keyword or number of the desired output device. Hitting a RETURN in\n"
18944 " response to the prompt is the same as selecting the first device. If\n"
18945 " only one device is enabled when PLplot is installed, plstar will issue\n"
18946 " no prompt. The output device is divided into nx by ny subpages, each\n"
18947 " of which may be used independently. The subroutine pladv is used to\n"
18948 " advance from one subpage to the next. \n"
18949 "\n"
18950 " Redacted form: plstar(nx, ny)\n"
18951 "\n"
18952 " This function is used in example 1. \n"
18953 "\n"
18954 "\n"
18955 "\n"
18956 "SYNOPSIS:\n"
18957 "\n"
18958 "plstar(nx, ny)\n"
18959 "\n"
18960 "ARGUMENTS:\n"
18961 "\n"
18962 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
18963 " horizontal direction. \n"
18964 "\n"
18965 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
18966 " vertical direction. \n"
18967 "\n"
18968 ""},
18969 { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
18970 "Initialization \n"
18971 "\n"
18972 "DESCRIPTION:\n"
18973 "\n"
18974 " Alternative to plstar for initializing the plotting package. The\n"
18975 " device name keyword for the desired output device must be supplied as\n"
18976 " an argument. The device keywords are the same as those printed out by\n"
18977 " plstar. If the requested device is not available, or if the input\n"
18978 " string is empty or begins with ``?'', the prompted startup of plstar\n"
18979 " is used. This routine also divides the output device into nx by ny\n"
18980 " subpages, each of which may be used independently. The subroutine\n"
18981 " pladv is used to advance from one subpage to the next. \n"
18982 "\n"
18983 " Redacted form: General: plstart(device, nx, ny)\n"
18984 " Perl/PDL: plstart(nx, ny, device)\n"
18985 "\n"
18986 "\n"
18987 " This function is not used in any examples. \n"
18988 "\n"
18989 "\n"
18990 "\n"
18991 "SYNOPSIS:\n"
18992 "\n"
18993 "plstart(device, nx, ny)\n"
18994 "\n"
18995 "ARGUMENTS:\n"
18996 "\n"
18997 " device (const char *, input) : Device name (keyword) of the\n"
18998 " required output device. If NULL or if the first character is a\n"
18999 " ``?'', the normal (prompted) startup is used. \n"
19000 "\n"
19001 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19002 " horizontal direction. \n"
19003 "\n"
19004 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19005 " vertical direction. \n"
19006 "\n"
19007 ""},
19008 { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
19009 "Set a global coordinate transform function \n"
19010 "\n"
19011 "DESCRIPTION:\n"
19012 "\n"
19013 " This function can be used to define a coordinate transformation which\n"
19014 " affects all elements drawn within the current plot window. The\n"
19015 " transformation function is similar to that provided for the plmap and\n"
19016 " plmeridians functions. The data parameter may be used to pass extra\n"
19017 " data to transform_fun. \n"
19018 "\n"
19019 " Redacted form: General: plstransform(transform_fun, data)\n"
19020 "\n"
19021 "\n"
19022 " This function is used in example 19. \n"
19023 "\n"
19024 "\n"
19025 "\n"
19026 "SYNOPSIS:\n"
19027 "\n"
19028 "plstransform(transform_fun, data)\n"
19029 "\n"
19030 "ARGUMENTS:\n"
19031 "\n"
19032 " transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
19033 " input) : Pointer to a function that defines a transformation\n"
19034 " from the input (x, y) coordinate to a new plot world coordiante. \n"
19035 "\n"
19036 " data (PLPointer, input) : Optional extra data for \n"
19037 " transform_fun. \n"
19038 "\n"
19039 ""},
19040 { (char *)"plstring", _wrap_plstring, METH_VARARGS, NULL},
19041 { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, NULL},
19042 { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
19043 "Add a point to a stripchart \n"
19044 "\n"
19045 "DESCRIPTION:\n"
19046 "\n"
19047 " Add a point to a given pen of a given stripchart. There is no need for\n"
19048 " all pens to have the same number of points or to be equally sampled in\n"
19049 " the x coordinate. Allocates memory and rescales as necessary. \n"
19050 "\n"
19051 " Redacted form: plstripa(id, p, x, y)\n"
19052 "\n"
19053 " This function is used in example 17. \n"
19054 "\n"
19055 "\n"
19056 "\n"
19057 "SYNOPSIS:\n"
19058 "\n"
19059 "plstripa(id, p, x, y)\n"
19060 "\n"
19061 "ARGUMENTS:\n"
19062 "\n"
19063 " id (PLINT, input) : Identification number (set up in plstripc) of\n"
19064 " the stripchart. \n"
19065 "\n"
19066 " p (PLINT, input) : Pen number (ranges from 0 to 3). \n"
19067 "\n"
19068 " x (PLFLT, input) : X coordinate of point to plot. \n"
19069 "\n"
19070 " y (PLFLT, input) : Y coordinate of point to plot. \n"
19071 "\n"
19072 ""},
19073 { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
19074 "Create a 4-pen stripchart \n"
19075 "\n"
19076 "DESCRIPTION:\n"
19077 "\n"
19078 " Create a 4-pen stripchart, to be used afterwards by plstripa\n"
19079 "\n"
19080 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
19081 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
19082 " styline, legline, labx, laby, labz)\n"
19083 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
19084 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
19085 " ypsec, legline, labx, laby, labtop)\n"
19086 "\n"
19087 "\n"
19088 " This function is used in example 17. \n"
19089 "\n"
19090 "\n"
19091 "\n"
19092 "SYNOPSIS:\n"
19093 "\n"
19094 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
19095 "\n"
19096 "ARGUMENTS:\n"
19097 "\n"
19098 " id (PLINT *, output) : Identification number of stripchart to use\n"
19099 " on plstripa and plstripd. \n"
19100 "\n"
19101 " xspec (char *, input) : X-axis specification as in plbox. \n"
19102 "\n"
19103 " yspec (char *, input) : Y-axis specification as in plbox. \n"
19104 "\n"
19105 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19106 " change as data are added. \n"
19107 "\n"
19108 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19109 " change as data are added. \n"
19110 "\n"
19111 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
19112 " is multiplied by the factor (1 + \n"
19113 " xjump). \n"
19114 "\n"
19115 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19116 " change as data are added. \n"
19117 "\n"
19118 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19119 " change as data are added. \n"
19120 "\n"
19121 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
19122 "\n"
19123 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
19124 "\n"
19125 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
19126 " true, otherwise not. \n"
19127 "\n"
19128 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
19129 " otherwise slide display. \n"
19130 "\n"
19131 " colbox (PLINT, input) : Plot box color index (cmap0). \n"
19132 "\n"
19133 " collab (PLINT, input) : Legend color index (cmap0). \n"
19134 "\n"
19135 " colline (PLINT *, input) : Pointer to array with color indices\n"
19136 " (cmap0) for the 4 pens. \n"
19137 "\n"
19138 " styline (PLINT *, input) : Pointer to array with line styles for\n"
19139 " the 4 pens. \n"
19140 "\n"
19141 " legline (char **, input) : Pointer to character array containing\n"
19142 " legends for the 4 pens. \n"
19143 "\n"
19144 " labx (char *, input) : X-axis label. \n"
19145 "\n"
19146 " laby (char *, input) : Y-axis label. \n"
19147 "\n"
19148 " labtop (char *, input) : Plot title. \n"
19149 "\n"
19150 ""},
19151 { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
19152 "Deletes and releases memory used by a stripchart \n"
19153 "\n"
19154 "DESCRIPTION:\n"
19155 "\n"
19156 " Deletes and releases memory used by a stripchart. \n"
19157 "\n"
19158 " Redacted form: plstripd(id)\n"
19159 "\n"
19160 " This function is used in example 17. \n"
19161 "\n"
19162 "\n"
19163 "\n"
19164 "SYNOPSIS:\n"
19165 "\n"
19166 "plstripd(id)\n"
19167 "\n"
19168 "ARGUMENTS:\n"
19169 "\n"
19170 " id (PLINT, input) : Identification number of stripchart to delete. \n"
19171 "\n"
19172 ""},
19173 { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
19174 "Set line style \n"
19175 "\n"
19176 "DESCRIPTION:\n"
19177 "\n"
19178 " This sets up the line style for all lines subsequently drawn. A line\n"
19179 " consists of segments in which the pen is alternately down and up. The\n"
19180 " lengths of these segments are passed in the arrays mark and space\n"
19181 " respectively. The number of mark-space pairs is specified by nels. \n"
19182 " In order to return the line style to the default continuous line,\n"
19183 " plstyl should be called with nels=0.(see also pllsty) \n"
19184 "\n"
19185 " Redacted form: plstyl(mark, space)\n"
19186 "\n"
19187 " This function is used in examples 1,9,14. \n"
19188 "\n"
19189 "\n"
19190 "\n"
19191 "SYNOPSIS:\n"
19192 "\n"
19193 "plstyl(nels, mark, space)\n"
19194 "\n"
19195 "ARGUMENTS:\n"
19196 "\n"
19197 " nels (PLINT, input) : The number of mark and space elements in a\n"
19198 " line. Thus a simple broken line can be obtained by setting\n"
19199 " nels=1. A continuous line is specified by setting nels=0. \n"
19200 "\n"
19201 " mark (PLINT *, input) : Pointer to array with the lengths of the\n"
19202 " segments during which the pen is down, measured in micrometers. \n"
19203 "\n"
19204 " space (PLINT *, input) : Pointer to array with the lengths of the\n"
19205 " segments during which the pen is up, measured in micrometers. \n"
19206 "\n"
19207 ""},
19208 { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
19209 "Set arrow style for vector plots \n"
19210 "\n"
19211 "DESCRIPTION:\n"
19212 "\n"
19213 " Set the style for the arrow used by plvect to plot vectors. \n"
19214 "\n"
19215 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
19216 "\n"
19217 " This function is used in example 22. \n"
19218 "\n"
19219 "\n"
19220 "\n"
19221 "SYNOPSIS:\n"
19222 "\n"
19223 "plsvect(arrowx, arrowy, npts, fill)\n"
19224 "\n"
19225 "ARGUMENTS:\n"
19226 "\n"
19227 " arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n"
19228 " containing the x and y points which make up the arrow. The arrow\n"
19229 " is plotted by joining these points to form a polygon. The scaling\n"
19230 " assumes that the x and y points in the arrow lie in the range -0.5\n"
19231 " <= x,y <= 0.5. \n"
19232 "\n"
19233 " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
19234 " arrowy. \n"
19235 "\n"
19236 " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
19237 " fill is false then the arrow is open. \n"
19238 "\n"
19239 ""},
19240 { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
19241 "Specify viewport in absolute coordinates \n"
19242 "\n"
19243 "DESCRIPTION:\n"
19244 "\n"
19245 " Alternate routine to plvpor for setting up the viewport. This routine\n"
19246 " should be used only if the viewport is required to have a definite\n"
19247 " size in millimeters. The routine plgspa is useful for finding out the\n"
19248 " size of the current subpage. \n"
19249 "\n"
19250 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
19251 "\n"
19252 " This function is used in example 10. \n"
19253 "\n"
19254 "\n"
19255 "\n"
19256 "SYNOPSIS:\n"
19257 "\n"
19258 "plsvpa(xmin, xmax, ymin, ymax)\n"
19259 "\n"
19260 "ARGUMENTS:\n"
19261 "\n"
19262 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
19263 " viewport from the left-hand edge of the subpage in millimeters. \n"
19264 "\n"
19265 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
19266 " viewport from the left-hand edge of the subpage in millimeters. \n"
19267 "\n"
19268 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
19269 " viewport from the bottom edge of the subpage in millimeters. \n"
19270 "\n"
19271 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
19272 " from the bottom edge of the subpage in millimeters. \n"
19273 "\n"
19274 ""},
19275 { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
19276 "Set x axis parameters \n"
19277 "\n"
19278 "DESCRIPTION:\n"
19279 "\n"
19280 " Sets values of the digmax and digits flags for the x axis. See the\n"
19281 " PLplot documentation for more information. \n"
19282 "\n"
19283 " Redacted form: plsxax(digmax, digits)\n"
19284 "\n"
19285 " This function is used in example 31. \n"
19286 "\n"
19287 "\n"
19288 "\n"
19289 "SYNOPSIS:\n"
19290 "\n"
19291 "plsxax(digmax, digits)\n"
19292 "\n"
19293 "ARGUMENTS:\n"
19294 "\n"
19295 " digmax (PLINT, input) : Variable to set the maximum number of\n"
19296 " digits for the x axis. If nonzero, the printed label will be\n"
19297 " switched to a floating point representation when the number of\n"
19298 " digits exceeds digmax. \n"
19299 "\n"
19300 " digits (PLINT, input) : Field digits value. Currently, changing\n"
19301 " its value here has no effect since it is set only by plbox or\n"
19302 " plbox3. However, the user may obtain its value after a call to\n"
19303 " either of these functions by calling plgxax. \n"
19304 "\n"
19305 ""},
19306 { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
19307 "Set y axis parameters \n"
19308 "\n"
19309 "DESCRIPTION:\n"
19310 "\n"
19311 " Identical to plsxax, except that arguments are flags for y axis. See\n"
19312 " the description of plsxax for more detail. \n"
19313 "\n"
19314 " Redacted form: plsyax(digmax, digits)\n"
19315 "\n"
19316 " This function is used in examples 1,14,31. \n"
19317 "\n"
19318 "\n"
19319 "\n"
19320 "SYNOPSIS:\n"
19321 "\n"
19322 "plsyax(digmax, digits)\n"
19323 "\n"
19324 "ARGUMENTS:\n"
19325 "\n"
19326 " digmax (PLINT, input) : Variable to set the maximum number of\n"
19327 " digits for the y axis. If nonzero, the printed label will be\n"
19328 " switched to a floating point representation when the number of\n"
19329 " digits exceeds digmax. \n"
19330 "\n"
19331 " digits (PLINT, input) : Field digits value. Currently, changing\n"
19332 " its value here has no effect since it is set only by plbox or\n"
19333 " plbox3. However, the user may obtain its value after a call to\n"
19334 " either of these functions by calling plgyax. \n"
19335 "\n"
19336 ""},
19337 { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
19338 "Plots a symbol at the specified points \n"
19339 "\n"
19340 "DESCRIPTION:\n"
19341 "\n"
19342 " Marks out a set of n points at positions (\n"
19343 " x[i], \n"
19344 " y[i]), using the symbol defined by code. The code is interpreted as\n"
19345 " an index in the Hershey font tables. \n"
19346 "\n"
19347 " Redacted form: plsym(x, y, code)\n"
19348 "\n"
19349 " This function is used in example 7. \n"
19350 "\n"
19351 "\n"
19352 "\n"
19353 "SYNOPSIS:\n"
19354 "\n"
19355 "plsym(n, x, y, code)\n"
19356 "\n"
19357 "ARGUMENTS:\n"
19358 "\n"
19359 " n (PLINT, input) : Number of points to be marked. \n"
19360 "\n"
19361 " x (PLFLT *, input) : Pointer to array with set of x coordinate\n"
19362 " values for the points. \n"
19363 "\n"
19364 " y (PLFLT *, input) : Pointer to array with set of y coordinate\n"
19365 " values for the points. \n"
19366 "\n"
19367 " code (PLINT, input) : Code number for the symbol to be plotted. \n"
19368 "\n"
19369 ""},
19370 { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
19371 "Set z axis parameters \n"
19372 "\n"
19373 "DESCRIPTION:\n"
19374 "\n"
19375 " Identical to plsxax, except that arguments are flags for z axis. See\n"
19376 " the description of plsxax for more detail. \n"
19377 "\n"
19378 " Redacted form: plszax(digmax, digits)\n"
19379 "\n"
19380 " This function is used in example 31. \n"
19381 "\n"
19382 "\n"
19383 "\n"
19384 "SYNOPSIS:\n"
19385 "\n"
19386 "plszax(digmax, digits)\n"
19387 "\n"
19388 "ARGUMENTS:\n"
19389 "\n"
19390 " digmax (PLINT, input) : Variable to set the maximum number of\n"
19391 " digits for the z axis. If nonzero, the printed label will be\n"
19392 " switched to a floating point representation when the number of\n"
19393 " digits exceeds digmax. \n"
19394 "\n"
19395 " digits (PLINT, input) : Field digits value. Currently, changing\n"
19396 " its value here has no effect since it is set only by plbox or\n"
19397 " plbox3. However, the user may obtain its value after a call to\n"
19398 " either of these functions by calling plgzax. \n"
19399 "\n"
19400 ""},
19401 { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
19402 "Switch to text screen \n"
19403 "\n"
19404 "DESCRIPTION:\n"
19405 "\n"
19406 " Sets an interactive device to text mode, used in conjunction with\n"
19407 " plgra to allow graphics and text to be interspersed. On a device\n"
19408 " which supports separate text and graphics windows, this command causes\n"
19409 " control to be switched to the text window. This can be useful for\n"
19410 " printing diagnostic messages or getting user input, which would\n"
19411 " otherwise interfere with the plots. The program must switch back to\n"
19412 " the graphics window before issuing plot commands, as the text (or\n"
19413 " console) device will probably become quite confused otherwise. If\n"
19414 " already in text mode, this command is ignored. It is also ignored on\n"
19415 " devices which only support a single window or use a different method\n"
19416 " for shifting focus (see also plgra). \n"
19417 "\n"
19418 " Redacted form: pltext()\n"
19419 "\n"
19420 " This function is used in example 1. \n"
19421 "\n"
19422 "\n"
19423 "\n"
19424 "SYNOPSIS:\n"
19425 "\n"
19426 "pltext()\n"
19427 "\n"
19428 ""},
19429 { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
19430 "Set format for date / time labels \n"
19431 "\n"
19432 "DESCRIPTION:\n"
19433 "\n"
19434 " Sets the format for date / time labels. To enable date / time format\n"
19435 " labels see the options to plbox and plenv. \n"
19436 "\n"
19437 " Redacted form: pltimefmt(fmt)\n"
19438 "\n"
19439 " This function is used in example 29. \n"
19440 "\n"
19441 "\n"
19442 "\n"
19443 "SYNOPSIS:\n"
19444 "\n"
19445 "pltimefmt(fmt)\n"
19446 "\n"
19447 "ARGUMENTS:\n"
19448 "\n"
19449 " fmt (const char *, fmt) : This string is passed directly to the\n"
19450 " system strftime. See the system documentation for a full list of\n"
19451 " conversion specifications for your system. All conversion\n"
19452 " specifications take the form of a '%' character followed by\n"
19453 " further conversion specification character. All other text is\n"
19454 " printed as-is. Common options include: %c: The preferred date and\n"
19455 " time representation for the current locale. \n"
19456 " %d: The day of the month as a decimal number. \n"
19457 " %H: The hour as a decimal number using a 24-hour clock. \n"
19458 " %j: The day of the year as a decimal number. \n"
19459 " %m: The month as a decimal number. \n"
19460 " %M: The minute as a decimal number. \n"
19461 " %S: The second as a decimal number. \n"
19462 " %y: The year as a decimal number without a century. \n"
19463 " %Y: The year as a decimal number including a century. \n"
19464 "\n"
19465 ""},
19466 { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
19467 "Specify viewport using aspect ratio only \n"
19468 "\n"
19469 "DESCRIPTION:\n"
19470 "\n"
19471 " Sets the viewport so that the ratio of the length of the y axis to\n"
19472 " that of the x axis is equal to aspect. \n"
19473 "\n"
19474 " Redacted form: plvasp(aspect)\n"
19475 "\n"
19476 " This function is used in example 13. \n"
19477 "\n"
19478 "\n"
19479 "\n"
19480 "SYNOPSIS:\n"
19481 "\n"
19482 "plvasp(aspect)\n"
19483 "\n"
19484 "ARGUMENTS:\n"
19485 "\n"
19486 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
19487 " axis. \n"
19488 "\n"
19489 ""},
19490 { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
19491 "Vector plot \n"
19492 "\n"
19493 "DESCRIPTION:\n"
19494 "\n"
19495 " Draws a vector plot of the vector (\n"
19496 " u[\n"
19497 " nx][\n"
19498 " ny],\n"
19499 " v[\n"
19500 " nx][\n"
19501 " ny]). The scaling factor for the vectors is given by scale. A\n"
19502 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
19503 " additional data required by the transformation routine is used to map\n"
19504 " indices within the array to the world coordinates. The style of the\n"
19505 " vector arrow may be set using plsvect. \n"
19506 "\n"
19507 " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
19508 "\n"
19509 " This function is used in example 22. \n"
19510 "\n"
19511 "\n"
19512 "\n"
19513 "SYNOPSIS:\n"
19514 "\n"
19515 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
19516 "\n"
19517 "ARGUMENTS:\n"
19518 "\n"
19519 " u, v (PLFLT **, input) : Pointers to a pair of vectored\n"
19520 " two-dimensional arrays containing the x and y components of the\n"
19521 " vector data to be plotted. \n"
19522 "\n"
19523 " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
19524 "\n"
19525 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
19526 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
19527 " automatically calculated for the data. If scale < 0 then the\n"
19528 " scaling factor is automatically calculated for the data and then\n"
19529 " multiplied by -\n"
19530 " scale. If scale > 0 then the scaling factor is set to scale. \n"
19531 "\n"
19532 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19533 " Pointer to function that defines transformation between indices\n"
19534 " in array z and the world coordinates (C only). Transformation\n"
19535 " functions are provided in the PLplot library: pltr0 for identity\n"
19536 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19537 " defined by one- and two-dimensional arrays. In addition,\n"
19538 " user-supplied routines for the transformation can be used as well.\n"
19539 " Examples of all of these approaches are given in the PLplot\n"
19540 " documentation. The transformation function should have the form\n"
19541 " given by any of pltr0, pltr1, or pltr2. \n"
19542 "\n"
19543 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
19544 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19545 " externally supplied. \n"
19546 "\n"
19547 ""},
19548 { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
19549 "Specify viewport using coordinates and aspect ratio \n"
19550 "\n"
19551 "DESCRIPTION:\n"
19552 "\n"
19553 " Device-independent routine for setting up the viewport. The viewport\n"
19554 " is chosen to be the largest with the given aspect ratio that fits\n"
19555 " within the specified region (in terms of normalized subpage\n"
19556 " coordinates). This routine is functionally equivalent to plvpor when\n"
19557 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
19558 " routine reserves no extra space at the edges for labels. \n"
19559 "\n"
19560 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
19561 "\n"
19562 " This function is used in example 9. \n"
19563 "\n"
19564 "\n"
19565 "\n"
19566 "SYNOPSIS:\n"
19567 "\n"
19568 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
19569 "\n"
19570 "ARGUMENTS:\n"
19571 "\n"
19572 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
19573 " left-hand edge of the viewport. \n"
19574 "\n"
19575 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
19576 " right-hand edge of the viewport. \n"
19577 "\n"
19578 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
19579 " bottom edge of the viewport. \n"
19580 "\n"
19581 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
19582 " edge of the viewport. \n"
19583 "\n"
19584 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
19585 " axis. \n"
19586 "\n"
19587 ""},
19588 { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
19589 "Specify viewport using coordinates \n"
19590 "\n"
19591 "DESCRIPTION:\n"
19592 "\n"
19593 " Device-independent routine for setting up the viewport. This defines\n"
19594 " the viewport in terms of normalized subpage coordinates which run from\n"
19595 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
19596 " current subpage. Use the alternate routine plsvpa in order to create\n"
19597 " a viewport of a definite size. \n"
19598 "\n"
19599 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
19600 "\n"
19601 " This function is used in examples\n"
19602 " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
19603 "\n"
19604 "\n"
19605 "\n"
19606 "SYNOPSIS:\n"
19607 "\n"
19608 "plvpor(xmin, xmax, ymin, ymax)\n"
19609 "\n"
19610 "ARGUMENTS:\n"
19611 "\n"
19612 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
19613 " left-hand edge of the viewport. \n"
19614 "\n"
19615 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
19616 " right-hand edge of the viewport. \n"
19617 "\n"
19618 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
19619 " bottom edge of the viewport. \n"
19620 "\n"
19621 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
19622 " edge of the viewport. \n"
19623 "\n"
19624 ""},
19625 { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
19626 "Select standard viewport \n"
19627 "\n"
19628 "DESCRIPTION:\n"
19629 "\n"
19630 " Sets up a standard viewport, leaving a left-hand margin of seven\n"
19631 " character heights, and four character heights around the other three\n"
19632 " sides. \n"
19633 "\n"
19634 " Redacted form: plvsta()\n"
19635 "\n"
19636 " This function is used in examples 1,12,14,17,25,29. \n"
19637 "\n"
19638 "\n"
19639 "\n"
19640 "SYNOPSIS:\n"
19641 "\n"
19642 "plvsta()\n"
19643 "\n"
19644 ""},
19645 { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
19646 "Set up window for 3-d plotting \n"
19647 "\n"
19648 "DESCRIPTION:\n"
19649 "\n"
19650 " Sets up a window for a three-dimensional surface plot within the\n"
19651 " currently defined two-dimensional window. The enclosing box for the\n"
19652 " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
19653 " user-coordinate space is mapped into a box of world coordinate size\n"
19654 " basex by basey by height so that xmin maps to -\n"
19655 " basex/2, xmax maps to basex/2, ymin maps to -\n"
19656 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
19657 " The resulting world-coordinate box is then viewed by an observer at\n"
19658 " altitude alt and azimuth az. This routine must be called before\n"
19659 " plbox3 or plot3d. For a more complete description of\n"
19660 " three-dimensional plotting see the PLplot documentation. \n"
19661 "\n"
19662 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
19663 " zmin, zmax, alt, az)\n"
19664 "\n"
19665 " This function is examples 8,11,18,21. \n"
19666 "\n"
19667 "\n"
19668 "\n"
19669 "SYNOPSIS:\n"
19670 "\n"
19671 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
19672 "\n"
19673 "ARGUMENTS:\n"
19674 "\n"
19675 " basex (PLFLT, input) : The x coordinate size of the\n"
19676 " world-coordinate box. \n"
19677 "\n"
19678 " basey (PLFLT, input) : The y coordinate size of the\n"
19679 " world-coordinate box. \n"
19680 "\n"
19681 " height (PLFLT, input) : The z coordinate size of the\n"
19682 " world-coordinate box. \n"
19683 "\n"
19684 " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
19685 "\n"
19686 " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
19687 "\n"
19688 " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
19689 "\n"
19690 " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
19691 "\n"
19692 " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
19693 "\n"
19694 " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
19695 "\n"
19696 " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
19697 " plane. \n"
19698 "\n"
19699 " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n"
19700 " observer is looking face onto the ZX plane, and as az is\n"
19701 " increased, the observer moves clockwise around the box when viewed\n"
19702 " from above the XY plane. \n"
19703 "\n"
19704 ""},
19705 { (char *)"plwid", _wrap_plwid, METH_VARARGS, (char *)"\n"
19706 "Set pen width \n"
19707 "\n"
19708 "DESCRIPTION:\n"
19709 "\n"
19710 " Sets the pen width. \n"
19711 "\n"
19712 " Redacted form: plwid(width)\n"
19713 "\n"
19714 " This function is used in examples 1,2. \n"
19715 "\n"
19716 "\n"
19717 "\n"
19718 "SYNOPSIS:\n"
19719 "\n"
19720 "plwid(width)\n"
19721 "\n"
19722 "ARGUMENTS:\n"
19723 "\n"
19724 " width (PLINT, input) : The desired pen width. If width is negative\n"
19725 " or the same as the previous value no action is taken. width = 0\n"
19726 " should be interpreted as as the minimum valid pen width for the\n"
19727 " device. The interpretation of positive width values is also\n"
19728 " device dependent. \n"
19729 "\n"
19730 ""},
19731 { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
19732 "Specify world coordinates of viewport boundaries \n"
19733 "\n"
19734 "DESCRIPTION:\n"
19735 "\n"
19736 " Sets up the world coordinates of the edges of the viewport. \n"
19737 "\n"
19738 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
19739 "\n"
19740 " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
19741 "\n"
19742 "\n"
19743 "\n"
19744 "SYNOPSIS:\n"
19745 "\n"
19746 "plwind(xmin, xmax, ymin, ymax)\n"
19747 "\n"
19748 "ARGUMENTS:\n"
19749 "\n"
19750 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
19751 " of the viewport. \n"
19752 "\n"
19753 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
19754 " of the viewport. \n"
19755 "\n"
19756 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
19757 " the viewport. \n"
19758 "\n"
19759 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
19760 " viewport. \n"
19761 "\n"
19762 ""},
19763 { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
19764 "Enter or leave xor mode \n"
19765 "\n"
19766 "DESCRIPTION:\n"
19767 "\n"
19768 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
19769 " those drivers (e.g., the xwin driver) that support it. Enables\n"
19770 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
19771 " is not capable of xor operation it returns a status of false. \n"
19772 "\n"
19773 " Redacted form: plxormod(mode, status)\n"
19774 "\n"
19775 " This function is used in examples 1,20. \n"
19776 "\n"
19777 "\n"
19778 "\n"
19779 "SYNOPSIS:\n"
19780 "\n"
19781 "plxormod(mode, status)\n"
19782 "\n"
19783 "ARGUMENTS:\n"
19784 "\n"
19785 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
19786 " is false means leave xor mode. \n"
19787 "\n"
19788 " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
19789 " of true (false) means driver is capable (incapable) of xor mode. \n"
19790 "\n"
19791 ""},
19792 { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
19793 "Plot continental outline in world coordinates. \n"
19794 "\n"
19795 "DESCRIPTION:\n"
19796 "\n"
19797 " Plots continental outlines in world coordinates. examples/c/x19c\n"
19798 " demonstrates how to use this function to create different\n"
19799 " projections. \n"
19800 "\n"
19801 " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n"
19802 " minlat, maxlat)\n"
19803 " F95, Java, Perl/PDL, Python: Not implemented? \n"
19804 "\n"
19805 "\n"
19806 " This function is used in example 19. \n"
19807 "\n"
19808 "\n"
19809 "\n"
19810 "SYNOPSIS:\n"
19811 "\n"
19812 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
19813 "\n"
19814 "ARGUMENTS:\n"
19815 "\n"
19816 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
19817 " supplied function to transform the coordinate longitudes and\n"
19818 " latitudes to a plot coordinate system. By using this transform,\n"
19819 " we can change from a longitude, latitude coordinate to a polar\n"
19820 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
19821 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
19822 " After the call to mapform(), x[] and y[] should be replaced by\n"
19823 " the corresponding plot coordinates. If no transform is desired,\n"
19824 " mapform can be replaced by NULL. \n"
19825 "\n"
19826 " type (char *, input) : type is a character string. The value of\n"
19827 " this parameter determines the type of background. The possible\n"
19828 " values are: \"globe\" -- continental outlines \n"
19829 " \"usa\" -- USA and state boundaries \n"
19830 " \"cglobe\" -- continental outlines and countries \n"
19831 " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
19832 "\n"
19833 "\n"
19834 " minlong (PLFLT, input) : The value of the longitude on the left\n"
19835 " side of the plot. The value of minlong must be less than the\n"
19836 " value of maxlong, and the quantity maxlong-minlong must be less\n"
19837 " than or equal to 360. \n"
19838 "\n"
19839 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
19840 " side of the plot. \n"
19841 "\n"
19842 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
19843 " background. One can always use -90.0 as the boundary outside the\n"
19844 " plot window will be automatically eliminated. However, the\n"
19845 " program will be faster if one can reduce the size of the\n"
19846 " background plotted. \n"
19847 "\n"
19848 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
19849 " background. One can always use 90.0 as the boundary outside the\n"
19850 " plot window will be automatically eliminated. \n"
19851 "\n"
19852 ""},
19853 { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
19854 "Plot latitude and longitude lines. \n"
19855 "\n"
19856 "DESCRIPTION:\n"
19857 "\n"
19858 " Displays latitude and longitude on the current plot. The lines are\n"
19859 " plotted in the current color and line style. \n"
19860 "\n"
19861 " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n"
19862 " maxlong, minlat, maxlat)\n"
19863 " F95, Java, Perl/PDL, Python: Not implemented? \n"
19864 "\n"
19865 "\n"
19866 " This function is used in example 19. \n"
19867 "\n"
19868 "\n"
19869 "\n"
19870 "SYNOPSIS:\n"
19871 "\n"
19872 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
19873 "\n"
19874 "ARGUMENTS:\n"
19875 "\n"
19876 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
19877 " supplied function to transform the coordinate longitudes and\n"
19878 " latitudes to a plot coordinate system. By using this transform,\n"
19879 " we can change from a longitude, latitude coordinate to a polar\n"
19880 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
19881 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
19882 " After the call to mapform(), x[] and y[] should be replaced by\n"
19883 " the corresponding plot coordinates. If no transform is desired,\n"
19884 " mapform can be replaced by NULL. \n"
19885 "\n"
19886 " dlong (PLFLT, input) : The interval in degrees at which the\n"
19887 " longitude lines are to be plotted. \n"
19888 "\n"
19889 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
19890 " lines are to be plotted. \n"
19891 "\n"
19892 " minlong (PLFLT, input) : The value of the longitude on the left\n"
19893 " side of the plot. The value of minlong must be less than the\n"
19894 " value of maxlong, and the quantity maxlong-minlong must be less\n"
19895 " than or equal to 360. \n"
19896 "\n"
19897 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
19898 " side of the plot. \n"
19899 "\n"
19900 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
19901 " background. One can always use -90.0 as the boundary outside the\n"
19902 " plot window will be automatically eliminated. However, the\n"
19903 " program will be faster if one can reduce the size of the\n"
19904 " background plotted. \n"
19905 "\n"
19906 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
19907 " background. One can always use 90.0 as the boundary outside the\n"
19908 " plot window will be automatically eliminated. \n"
19909 "\n"
19910 ""},
19911 { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
19912 "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
19913 "\n"
19914 "DESCRIPTION:\n"
19915 "\n"
19916 " Plot a 2D matrix using color palette 1. The color scale is\n"
19917 " automatically adjusted to use the maximum and minimum values in idata\n"
19918 " as valuemin and valuemax in a call to plimagefr. \n"
19919 "\n"
19920 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
19921 " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
19922 "\n"
19923 "\n"
19924 " This function is used in example 20. \n"
19925 "\n"
19926 "\n"
19927 "\n"
19928 "SYNOPSIS:\n"
19929 "\n"
19930 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
19931 "\n"
19932 "ARGUMENTS:\n"
19933 "\n"
19934 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
19935 " plot. Should have dimensions idata[nx][ny]. \n"
19936 "\n"
19937 " nx, ny (PLINT, input) : Dimensions of idata \n"
19938 "\n"
19939 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to strecth\n"
19940 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
19941 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
19942 "\n"
19943 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
19944 " (inclusive) will be plotted. \n"
19945 "\n"
19946 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
19947 " points whose plot coordinates fall inside the window of (Dxmin,\n"
19948 " Dymin) to (Dxmax, Dymax). \n"
19949 "\n"
19950 ""},
19951 { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
19952 "Plot a 2D matrix using color map1 \n"
19953 "\n"
19954 "DESCRIPTION:\n"
19955 "\n"
19956 " Plot a 2D matrix using color map1. \n"
19957 "\n"
19958 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
19959 " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
19960 "\n"
19961 "\n"
19962 " This function is used in example 20. \n"
19963 "\n"
19964 "\n"
19965 "\n"
19966 "SYNOPSIS:\n"
19967 "\n"
19968 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
19969 "\n"
19970 "ARGUMENTS:\n"
19971 "\n"
19972 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
19973 " plot. Should have dimensions idata[nx][ny]. \n"
19974 "\n"
19975 " nx, ny (PLINT, input) : Dimensions of idata \n"
19976 "\n"
19977 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to strecth\n"
19978 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
19979 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
19980 "\n"
19981 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
19982 " (inclusive) will be plotted. \n"
19983 "\n"
19984 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
19985 " values to use for value to color mappings. A datum equal to or\n"
19986 " less than valuemin will be plotted with color 0.0, while a datum\n"
19987 " equal to or greater than valuemax will be plotted with color 1.0. \n"
19988 " Data between valuemin and valuemax map linearly to colors between\n"
19989 " 0.0 and 1.0. \n"
19990 "\n"
19991 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19992 " Pointer to function that defines a transformation between the\n"
19993 " data in the array idata and world coordinates. An input\n"
19994 " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
19995 " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
19996 " Some transformation functions are provided in the PLplot library:\n"
19997 " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
19998 " mappings respectively defined by one- and two-dimensional arrays. \n"
19999 " In addition, user-supplied routines for the transformation can be\n"
20000 " used as well. Examples of all of these approaches are given in\n"
20001 " the PLplot documentation. The transformation function should have\n"
20002 " the form given by any of pltr0, pltr1, or pltr2. \n"
20003 "\n"
20004 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20005 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
20006 " externally supplied. \n"
20007 "\n"
20008 ""},
20009 { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
20010 { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
20011 { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
20012 { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
20013 { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
20014 { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
20015 { NULL, NULL, 0, NULL }
20016 };
20017
20018
20019
20020
20021 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
20022 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
20023 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
20024 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
20025 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
20026 static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
20027 static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void = {"_p_f_double_double_p_double_p_double_p_void__void", "ct_func|pltr_func|void (*)(double,double,double *,double *,void *)", 0, 0, (void*)0, 0};
20028 static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
20029 static swig_type_info _swigt__p_f_int_p_double_p_double__void = {"_p_f_int_p_double_p_double__void", "mapform_func|void (*)(int,double *,double *)", 0, 0, (void*)0, 0};
20030 static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
20031 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
20032 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
20033 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
20034 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
20035
20036 static swig_type_info *swig_type_initial[] = {
20037 &_swigt__p_PLGraphicsIn,
20038 &_swigt__p_PLcGrid,
20039 &_swigt__p_PLcGrid2,
20040 &_swigt__p_char,
20041 &_swigt__p_double,
20042 &_swigt__p_f_double_double__int,
20043 &_swigt__p_f_double_double_p_double_p_double_p_void__void,
20044 &_swigt__p_f_int_double_p_char_int_p_void__void,
20045 &_swigt__p_f_int_p_double_p_double__void,
20046 &_swigt__p_f_int_p_q_const__double_p_q_const__double__void,
20047 &_swigt__p_int,
20048 &_swigt__p_p_char,
20049 &_swigt__p_p_double,
20050 &_swigt__p_unsigned_int,
20051 };
20052
20053 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
20054 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
20055 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
20056 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20057 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
20058 static swig_cast_info _swigc__p_f_double_double__int[] = { {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}};
20059 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = { {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
20060 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = { {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
20061 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = { {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}};
20062 static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[] = { {&_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 0, 0, 0},{0, 0, 0, 0}};
20063 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20064 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
20065 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
20066 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20067
20068 static swig_cast_info *swig_cast_initial[] = {
20069 _swigc__p_PLGraphicsIn,
20070 _swigc__p_PLcGrid,
20071 _swigc__p_PLcGrid2,
20072 _swigc__p_char,
20073 _swigc__p_double,
20074 _swigc__p_f_double_double__int,
20075 _swigc__p_f_double_double_p_double_p_double_p_void__void,
20076 _swigc__p_f_int_double_p_char_int_p_void__void,
20077 _swigc__p_f_int_p_double_p_double__void,
20078 _swigc__p_f_int_p_q_const__double_p_q_const__double__void,
20079 _swigc__p_int,
20080 _swigc__p_p_char,
20081 _swigc__p_p_double,
20082 _swigc__p_unsigned_int,
20083 };
20084
20085
20086
20087
20088 static swig_const_info swig_const_table[] = {
20089 {0, 0, 0, 0.0, 0, 0}};
20090
20091 #ifdef __cplusplus
20092 }
20093 #endif
20094
20095
20096
20097
20098
20099
20100
20101
20102
20103
20104
20105
20106
20107
20108
20109
20110
20111
20112
20113
20114
20115
20116
20117
20118
20119
20120
20121
20122
20123
20124
20125
20126
20127
20128
20129
20130
20131
20132
20133
20134
20135 #ifdef __cplusplus
20136 extern "C" {
20137 #if 0
20138 }
20139 #endif
20140 #endif
20141
20142 #if 0
20143 #define SWIGRUNTIME_DEBUG
20144 #endif
20145
20146
20147 SWIGRUNTIME void
20148 SWIG_InitializeModule(void *clientdata) {
20149 size_t i;
20150 swig_module_info *module_head, *iter;
20151 int found, init;
20152
20153 clientdata = clientdata;
20154
20155
20156 if (swig_module.next==0) {
20157
20158 swig_module.type_initial = swig_type_initial;
20159 swig_module.cast_initial = swig_cast_initial;
20160 swig_module.next = &swig_module;
20161 init = 1;
20162 } else {
20163 init = 0;
20164 }
20165
20166
20167 module_head = SWIG_GetModule(clientdata);
20168 if (!module_head) {
20169
20170
20171 SWIG_SetModule(clientdata, &swig_module);
20172 module_head = &swig_module;
20173 } else {
20174
20175 found=0;
20176 iter=module_head;
20177 do {
20178 if (iter==&swig_module) {
20179 found=1;
20180 break;
20181 }
20182 iter=iter->next;
20183 } while (iter!= module_head);
20184
20185
20186 if (found) return;
20187
20188 swig_module.next = module_head->next;
20189 module_head->next = &swig_module;
20190 }
20191
20192
20193
20194
20195
20196 if (init == 0) return;
20197
20198
20199 #ifdef SWIGRUNTIME_DEBUG
20200 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20201 #endif
20202 for (i = 0; i < swig_module.size; ++i) {
20203 swig_type_info *type = 0;
20204 swig_type_info *ret;
20205 swig_cast_info *cast;
20206
20207 #ifdef SWIGRUNTIME_DEBUG
20208 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20209 #endif
20210
20211
20212 if (swig_module.next != &swig_module) {
20213 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20214 }
20215 if (type) {
20216
20217 #ifdef SWIGRUNTIME_DEBUG
20218 printf("SWIG_InitializeModule: found type %s\n", type->name);
20219 #endif
20220 if (swig_module.type_initial[i]->clientdata) {
20221 type->clientdata = swig_module.type_initial[i]->clientdata;
20222 #ifdef SWIGRUNTIME_DEBUG
20223 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20224 #endif
20225 }
20226 } else {
20227 type = swig_module.type_initial[i];
20228 }
20229
20230
20231 cast = swig_module.cast_initial[i];
20232 while (cast->type) {
20233
20234 ret = 0;
20235 #ifdef SWIGRUNTIME_DEBUG
20236 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20237 #endif
20238 if (swig_module.next != &swig_module) {
20239 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20240 #ifdef SWIGRUNTIME_DEBUG
20241 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20242 #endif
20243 }
20244 if (ret) {
20245 if (type == swig_module.type_initial[i]) {
20246 #ifdef SWIGRUNTIME_DEBUG
20247 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20248 #endif
20249 cast->type = ret;
20250 ret = 0;
20251 } else {
20252
20253 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20254 #ifdef SWIGRUNTIME_DEBUG
20255 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20256 #endif
20257 if (!ocast) ret = 0;
20258 }
20259 }
20260
20261 if (!ret) {
20262 #ifdef SWIGRUNTIME_DEBUG
20263 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20264 #endif
20265 if (type->cast) {
20266 type->cast->prev = cast;
20267 cast->next = type->cast;
20268 }
20269 type->cast = cast;
20270 }
20271 cast++;
20272 }
20273
20274 swig_module.types[i] = type;
20275 }
20276 swig_module.types[i] = 0;
20277
20278 #ifdef SWIGRUNTIME_DEBUG
20279 printf("**** SWIG_InitializeModule: Cast List ******\n");
20280 for (i = 0; i < swig_module.size; ++i) {
20281 int j = 0;
20282 swig_cast_info *cast = swig_module.cast_initial[i];
20283 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20284 while (cast->type) {
20285 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
20286 cast++;
20287 ++j;
20288 }
20289 printf("---- Total casts: %d\n",j);
20290 }
20291 printf("**** SWIG_InitializeModule: Cast List ******\n");
20292 #endif
20293 }
20294
20295
20296
20297
20298
20299
20300 SWIGRUNTIME void
20301 SWIG_PropagateClientData(void) {
20302 size_t i;
20303 swig_cast_info *equiv;
20304 static int init_run = 0;
20305
20306 if (init_run) return;
20307 init_run = 1;
20308
20309 for (i = 0; i < swig_module.size; i++) {
20310 if (swig_module.types[i]->clientdata) {
20311 equiv = swig_module.types[i]->cast;
20312 while (equiv) {
20313 if (!equiv->converter) {
20314 if (equiv->type && !equiv->type->clientdata)
20315 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
20316 }
20317 equiv = equiv->next;
20318 }
20319 }
20320 }
20321 }
20322
20323 #ifdef __cplusplus
20324 #if 0
20325 {
20326
20327 #endif
20328 }
20329 #endif
20330
20331
20332
20333 #ifdef __cplusplus
20334 extern "C" {
20335 #endif
20336
20337
20338 #define SWIG_newvarlink() SWIG_Python_newvarlink()
20339 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
20340 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
20341
20342
20343
20344
20345
20346 typedef struct swig_globalvar {
20347 char *name;
20348 PyObject *(*get_attr)(void);
20349 int (*set_attr)(PyObject *);
20350 struct swig_globalvar *next;
20351 } swig_globalvar;
20352
20353 typedef struct swig_varlinkobject {
20354 PyObject_HEAD
20355 swig_globalvar *vars;
20356 } swig_varlinkobject;
20357
20358 SWIGINTERN PyObject *
20359 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
20360 #if PY_VERSION_HEX >= 0x03000000
20361 return PyUnicode_InternFromString("<Swig global variables>");
20362 #else
20363 return PyString_FromString("<Swig global variables>");
20364 #endif
20365 }
20366
20367 SWIGINTERN PyObject *
20368 swig_varlink_str(swig_varlinkobject *v) {
20369 #if PY_VERSION_HEX >= 0x03000000
20370 PyObject *str = PyUnicode_InternFromString("(");
20371 PyObject *tail;
20372 PyObject *joined;
20373 swig_globalvar *var;
20374 for (var = v->vars; var; var=var->next) {
20375 tail = PyUnicode_FromString(var->name);
20376 joined = PyUnicode_Concat(str, tail);
20377 Py_DecRef(str);
20378 Py_DecRef(tail);
20379 str = joined;
20380 if (var->next) {
20381 tail = PyUnicode_InternFromString(", ");
20382 joined = PyUnicode_Concat(str, tail);
20383 Py_DecRef(str);
20384 Py_DecRef(tail);
20385 str = joined;
20386 }
20387 }
20388 tail = PyUnicode_InternFromString(")");
20389 joined = PyUnicode_Concat(str, tail);
20390 Py_DecRef(str);
20391 Py_DecRef(tail);
20392 str = joined;
20393 #else
20394 PyObject *str = PyString_FromString("(");
20395 swig_globalvar *var;
20396 for (var = v->vars; var; var=var->next) {
20397 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
20398 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
20399 }
20400 PyString_ConcatAndDel(&str,PyString_FromString(")"));
20401 #endif
20402 return str;
20403 }
20404
20405 SWIGINTERN int
20406 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
20407 char *tmp;
20408 PyObject *str = swig_varlink_str(v);
20409 fprintf(fp,"Swig global variables ");
20410 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
20411 SWIG_Python_str_DelForPy3(tmp);
20412 Py_DECREF(str);
20413 return 0;
20414 }
20415
20416 SWIGINTERN void
20417 swig_varlink_dealloc(swig_varlinkobject *v) {
20418 swig_globalvar *var = v->vars;
20419 while (var) {
20420 swig_globalvar *n = var->next;
20421 free(var->name);
20422 free(var);
20423 var = n;
20424 }
20425 }
20426
20427 SWIGINTERN PyObject *
20428 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
20429 PyObject *res = NULL;
20430 swig_globalvar *var = v->vars;
20431 while (var) {
20432 if (strcmp(var->name,n) == 0) {
20433 res = (*var->get_attr)();
20434 break;
20435 }
20436 var = var->next;
20437 }
20438 if (res == NULL && !PyErr_Occurred()) {
20439 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20440 }
20441 return res;
20442 }
20443
20444 SWIGINTERN int
20445 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
20446 int res = 1;
20447 swig_globalvar *var = v->vars;
20448 while (var) {
20449 if (strcmp(var->name,n) == 0) {
20450 res = (*var->set_attr)(p);
20451 break;
20452 }
20453 var = var->next;
20454 }
20455 if (res == 1 && !PyErr_Occurred()) {
20456 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20457 }
20458 return res;
20459 }
20460
20461 SWIGINTERN PyTypeObject*
20462 swig_varlink_type(void) {
20463 static char varlink__doc__[] = "Swig var link object";
20464 static PyTypeObject varlink_type;
20465 static int type_init = 0;
20466 if (!type_init) {
20467 const PyTypeObject tmp
20468 = {
20469
20470 #if PY_VERSION_HEX >= 0x03000000
20471 PyVarObject_HEAD_INIT(&PyType_Type, 0)
20472 #else
20473 PyObject_HEAD_INIT(NULL)
20474 0,
20475 #endif
20476 (char *)"swigvarlink",
20477 sizeof(swig_varlinkobject),
20478 0,
20479 (destructor) swig_varlink_dealloc,
20480 (printfunc) swig_varlink_print,
20481 (getattrfunc) swig_varlink_getattr,
20482 (setattrfunc) swig_varlink_setattr,
20483 0,
20484 (reprfunc) swig_varlink_repr,
20485 0,
20486 0,
20487 0,
20488 0,
20489 0,
20490 (reprfunc) swig_varlink_str,
20491 0,
20492 0,
20493 0,
20494 0,
20495 varlink__doc__,
20496 0,
20497 0,
20498 0,
20499 0,
20500 #if PY_VERSION_HEX >= 0x02020000
20501 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
20502 #endif
20503 #if PY_VERSION_HEX >= 0x02030000
20504 0,
20505 #endif
20506 #ifdef COUNT_ALLOCS
20507 0,0,0,0
20508 #endif
20509 };
20510 varlink_type = tmp;
20511
20512 #if PY_VERSION_HEX < 0x03000000
20513 varlink_type.ob_type = &PyType_Type;
20514 #endif
20515 type_init = 1;
20516 }
20517 return &varlink_type;
20518 }
20519
20520
20521 SWIGINTERN PyObject *
20522 SWIG_Python_newvarlink(void) {
20523 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
20524 if (result) {
20525 result->vars = 0;
20526 }
20527 return ((PyObject*) result);
20528 }
20529
20530 SWIGINTERN void
20531 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
20532 swig_varlinkobject *v = (swig_varlinkobject *) p;
20533 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
20534 if (gv) {
20535 size_t size = strlen(name)+1;
20536 gv->name = (char *)malloc(size);
20537 if (gv->name) {
20538 strncpy(gv->name,name,size);
20539 gv->get_attr = get_attr;
20540 gv->set_attr = set_attr;
20541 gv->next = v->vars;
20542 }
20543 }
20544 v->vars = gv;
20545 }
20546
20547 SWIGINTERN PyObject *
20548 SWIG_globals(void) {
20549 static PyObject *_SWIG_globals = 0;
20550 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
20551 return _SWIG_globals;
20552 }
20553
20554
20555
20556
20557
20558
20559 SWIGINTERN void
20560 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
20561 PyObject *obj = 0;
20562 size_t i;
20563 for (i = 0; constants[i].type; ++i) {
20564 switch(constants[i].type) {
20565 case SWIG_PY_POINTER:
20566 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
20567 break;
20568 case SWIG_PY_BINARY:
20569 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
20570 break;
20571 default:
20572 obj = 0;
20573 break;
20574 }
20575 if (obj) {
20576 PyDict_SetItemString(d, constants[i].name, obj);
20577 Py_DECREF(obj);
20578 }
20579 }
20580 }
20581
20582
20583
20584
20585
20586 SWIGINTERN void
20587 SWIG_Python_FixMethods(PyMethodDef *methods,
20588 swig_const_info *const_table,
20589 swig_type_info **types,
20590 swig_type_info **types_initial) {
20591 size_t i;
20592 for (i = 0; methods[i].ml_name; ++i) {
20593 const char *c = methods[i].ml_doc;
20594 if (c && (c = strstr(c, "swig_ptr: "))) {
20595 int j;
20596 swig_const_info *ci = 0;
20597 const char *name = c + 10;
20598 for (j = 0; const_table[j].type; ++j) {
20599 if (strncmp(const_table[j].name, name,
20600 strlen(const_table[j].name)) == 0) {
20601 ci = &(const_table[j]);
20602 break;
20603 }
20604 }
20605 if (ci) {
20606 size_t shift = (ci->ptype) - types;
20607 swig_type_info *ty = types_initial[shift];
20608 size_t ldoc = (c - methods[i].ml_doc);
20609 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
20610 char *ndoc = (char*)malloc(ldoc + lptr + 10);
20611 if (ndoc) {
20612 char *buff = ndoc;
20613 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
20614 if (ptr) {
20615 strncpy(buff, methods[i].ml_doc, ldoc);
20616 buff += ldoc;
20617 strncpy(buff, "swig_ptr: ", 10);
20618 buff += 10;
20619 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
20620 methods[i].ml_doc = ndoc;
20621 }
20622 }
20623 }
20624 }
20625 }
20626 }
20627
20628 #ifdef __cplusplus
20629 }
20630 #endif
20631
20632
20633
20634
20635
20636 #ifdef __cplusplus
20637 extern "C"
20638 #endif
20639
20640 SWIGEXPORT
20641 #if PY_VERSION_HEX >= 0x03000000
20642 PyObject*
20643 #else
20644 void
20645 #endif
20646 SWIG_init(void) {
20647 PyObject *m, *d;
20648 #if PY_VERSION_HEX >= 0x03000000
20649 static struct PyModuleDef SWIG_module = {
20650 PyModuleDef_HEAD_INIT,
20651 (char *) SWIG_name,
20652 NULL,
20653 -1,
20654 SwigMethods,
20655 NULL,
20656 NULL,
20657 NULL,
20658 NULL
20659 };
20660 #endif
20661
20662
20663 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
20664
20665 #if PY_VERSION_HEX >= 0x03000000
20666 m = PyModule_Create(&SWIG_module);
20667 #else
20668 m = Py_InitModule((char *) SWIG_name, SwigMethods);
20669 #endif
20670 d = PyModule_GetDict(m);
20671
20672 SWIG_InitializeModule(0);
20673 SWIG_InstallConstants(d,swig_const_table);
20674
20675
20676
20677 import_array();
20678
20679 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
20680 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
20681 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
20682 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
20683 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
20684 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
20685 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
20686 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
20687 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
20688 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
20689 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
20690 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
20691 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
20692 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
20693 SWIG_Python_SetConstant(d, "PLESC_PLFLTBUFFERING",SWIG_From_int((int)(15)));
20694 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
20695 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
20696 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
20697 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
20698 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
20699 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
20700 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
20701 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x01)));
20702 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x02)));
20703 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x03)));
20704 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x04)));
20705 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x08)));
20706 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x10)));
20707 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x20)));
20708 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x40)));
20709 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x80)));
20710 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
20711 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0)));
20712 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(1)));
20713 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(2)));
20714 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(4)));
20715 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0)));
20716 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(1)));
20717 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(2)));
20718 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(8)));
20719 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(16)));
20720 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(1)));
20721 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(2)));
20722 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(4)));
20723 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(8)));
20724 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(16)));
20725 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(32)));
20726 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(64)));
20727 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(128)));
20728 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(1)));
20729 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(2)));
20730 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(4)));
20731 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(8)));
20732 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(16)));
20733 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(32)));
20734 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(64)));
20735 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(128)));
20736 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(1)));
20737 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(2)));
20738 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(4)));
20739 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(8)));
20740 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(16)));
20741 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(32)));
20742 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(64)));
20743 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(128)));
20744 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(256)));
20745 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(512)));
20746 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
20747 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
20748 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
20749 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
20750 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
20751 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
20752 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
20753 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
20754 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
20755 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
20756 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
20757 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
20758 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
20759 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
20760 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
20761 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
20762 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
20763 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
20764 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
20765 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
20766 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
20767 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
20768 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
20769 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
20770 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
20771 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
20772 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
20773 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
20774 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
20775 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
20776 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
20777 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
20778 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
20779 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
20780 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
20781 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
20782 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
20783 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
20784 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
20785 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
20786 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
20787 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
20788 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
20789 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
20790 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
20791 SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_ENABLE",SWIG_From_int((int)(1)));
20792 SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_DISABLE",SWIG_From_int((int)(2)));
20793 SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_QUERY",SWIG_From_int((int)(3)));
20794 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
20795 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
20796 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
20797 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
20798 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
20799 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
20800 #if PY_VERSION_HEX >= 0x03000000
20801 return m;
20802 #else
20803 return;
20804 #endif
20805 }
20806